From 92edd8e958517bf8f156c11aec44595754c594c0 Mon Sep 17 00:00:00 2001 From: galact <94279960+galact-byte@users.noreply.github.com> Date: Mon, 21 Sep 2026 09:04:20 +0800 Subject: [PATCH 01/13] feat(terminal): restore bounded recent command output per pane --- .../2026-09-21-bounded-local-output.md | 73 ++ nebula_app/i18n/en-US.json | 9 + nebula_app/i18n/zh-CN.json | 9 + nebula_app/src/gpui_shell/config.rs | 2 + nebula_app/src/gpui_shell/file_editor/mod.rs | 2 +- .../src/gpui_shell/file_editor/tests.rs | 11 + nebula_app/src/gpui_shell/settings_pane.rs | 9 +- .../settings_pane/command_output.rs | 69 ++ .../settings_pane/initialization.rs | 1 + .../gpui_shell/settings_pane/navigation.rs | 2 +- .../src/gpui_shell/settings_pane/tests.rs | 83 +++ nebula_app/src/gpui_shell/terminal/view.rs | 16 +- .../gpui_shell/terminal/view/completion.rs | 1 + .../src/gpui_shell/terminal/view/pointer.rs | 5 +- .../gpui_shell/terminal/view/recent_output.rs | 134 ++++ .../terminal/view/recent_output_tests.rs | 365 ++++++++++ .../src/gpui_shell/terminal/view/runtime.rs | 5 + .../src/gpui_shell/terminal/view/startup.rs | 6 + nebula_app/src/gpui_shell/workspace.rs | 24 +- .../src/gpui_shell/workspace/closing.rs | 40 +- .../src/gpui_shell/workspace/documents.rs | 27 + .../src/gpui_shell/workspace/residency.rs | 152 +++-- .../workspace/session_persistence.rs | 139 +++- .../session_persistence/local_snapshot.rs | 302 ++++++++ .../gpui_shell/workspace/session_recovery.rs | 61 +- .../gpui_shell/workspace/terminal_activity.rs | 15 +- .../src/gpui_shell/workspace/windowing.rs | 81 ++- .../workspace/windowing/output_persistence.rs | 643 ++++++++++++++++++ .../workspace/windowing/shutdown.rs | 21 +- .../workspace/windowing/transfer_tests.rs | 4 +- nebula_app/src/main.rs | 1 + nebula_app/src/recent_output.rs | 256 +++++++ nebula_app/src/recent_output/storage.rs | 253 +++++++ .../src/recent_output/storage/lifecycle.rs | 418 ++++++++++++ nebula_app/src/session.rs | 32 +- nebula_app/src/session/local_output.rs | 97 +++ .../src/window_context/session_snapshot.rs | 1 + nebula_settings/src/lib.rs | 21 + nebula_settings/src/reset.rs | 1 + nebula_terminal/src/grid/mod.rs | 1 + nebula_terminal/src/grid/snapshot.rs | 254 +++++++ .../src/grid/snapshot/serialization.rs | 85 +++ nebula_terminal/src/term/renderable.rs | 9 +- 43 files changed, 3589 insertions(+), 151 deletions(-) create mode 100644 architecture/notes/nebula_app/recent_output/2026-09-21-bounded-local-output.md create mode 100644 nebula_app/src/gpui_shell/settings_pane/command_output.rs create mode 100644 nebula_app/src/gpui_shell/terminal/view/recent_output.rs create mode 100644 nebula_app/src/gpui_shell/terminal/view/recent_output_tests.rs create mode 100644 nebula_app/src/gpui_shell/workspace/session_persistence/local_snapshot.rs create mode 100644 nebula_app/src/gpui_shell/workspace/windowing/output_persistence.rs create mode 100644 nebula_app/src/recent_output.rs create mode 100644 nebula_app/src/recent_output/storage.rs create mode 100644 nebula_app/src/recent_output/storage/lifecycle.rs create mode 100644 nebula_app/src/session/local_output.rs create mode 100644 nebula_terminal/src/grid/snapshot.rs create mode 100644 nebula_terminal/src/grid/snapshot/serialization.rs diff --git a/architecture/notes/nebula_app/recent_output/2026-09-21-bounded-local-output.md b/architecture/notes/nebula_app/recent_output/2026-09-21-bounded-local-output.md new file mode 100644 index 000000000..9c69753fb --- /dev/null +++ b/architecture/notes/nebula_app/recent_output/2026-09-21-bounded-local-output.md @@ -0,0 +1,73 @@ +# 本机有界命令输出恢复(#160) + +## Status + +已实现并完成本机 Windows CMD 验证,待提交审核;尚未发布。 + +## Context + +布局和 AI 原生身份恢复不包含终端显示内容。全局补全历史没有 pane 身份, +不能通过目录猜测旧输出归属。恢复内容必须是静态显示,不能重新执行历史命令。 + +## Evidence + +- `nebula_app/src/recent_output.rs`:命令记录、五条上限及输出尾部截取。 +- `nebula_app/src/recent_output/storage.rs` 与 `storage/lifecycle.rs`:容量、原子交接和清除。 +- `nebula_terminal/src/grid/snapshot.rs`:安全显示快照及 Unicode/重排测试。 +- `nebula_app/src/session/local_output.rs`:本机输出引用与会话导出边界。 +- `nebula_app/src/gpui_shell/workspace/windowing/output_persistence.rs`:异步保存生命周期。 + +## Decision + +terminal 层只导出、导入静态显示数据,去除链接动作,不回放 VT;app 层复用 +已确认的 shell 命令提交,每 pane 最多五条,每条编码不超过 256 KiB,保留命令 +与输出尾部。独立本机 sidecar 使用版本化格式和精确记录引用,不按 cwd 匹配。 + +正常快照总编码不超过 16 MiB,原子交接期间允许新旧两代临时合计最多 32 MiB, +各代仍单独限额。sidecar 写入成功后才发布会话引用,成功后回收旧代;崩溃重试 +保留已发布会话的有效引用,不累积第三代。总量超限先淘汰最旧记录再生成引用。 + +读取前检查大小,读取时限流,解码后校验。损坏输出降级且不阻断有效新保存; +真实 I/O 失败保留失败和重试语义。保存与清除串行提交,代次失效阻止旧快照 +在清除后写回。关闭保存使在途旧快照失效;关闭 pane 的成功保存移除对应引用。 + +会话恢复开启时默认有界保存,提供关闭与清除入口;独立会话导出不携带本机 +输出引用或正文。旧会话无引用时沿用原恢复行为。文档在等待保存期间被编辑时, +关窗路径重新检查脏状态,包括 Runtime 关窗,不能因之前确认而丢弃新编辑。 + +## Rejected alternatives + +- 保存、重放原始 VT:会重放控制动作,不是安全静态恢复。 +- 按目录分配全局历史:多个 pane 可有相同目录,无法证明归属。 +- 把全部输出嵌入可导出的 session:扩大隐私暴露和载入成本。 +- 不允许两代临时空间:有效旧快照会阻断正常原子替换。 +- 为恢复引入常驻线程或新依赖:现有异步执行和原子写机制足够。 + +## Consequences + +不恢复活进程,不重新执行命令,不恢复完整 AI 对话或 CMD 原生命令历史。 +不采集不可见密码输入、TUI 内部按键或 AI 会话文件,但无法自动识别所有已经 +显示在屏幕上的秘密。备用屏内容不作为普通历史导入。 + +活跃 AI 恢复时,静态旧输出和 AI 自身重绘可能同时留在终端历史中。 +禁用本功能可回退至原布局和 AI 恢复,不以回退脚本删除用户数据。 + +## Validation + +本机全量应用回归 1890 通过、0 失败、15 忽略;terminal 包 283 个单元测试、 +48 个集成测试及 1 个文档测试通过;i18n 合同 20 通过、1 忽略。 +架构检查使用基线 `5ce18ba0c4c82f13548ea2dca94d2078e22e11eb`,没有扩大预算。 + +实际 GPUI 构建验证 CMD 保存、关窗、重复重启、最近五条、多 pane 不串档、 +恢复期变窄、备用屏排除和活跃 Pi 原生会话身份保持。Pi 使用本机合成服务, +不是云端兼容性证明。两 pane 大输出测试恢复各自尾部;本机计时不是通用性能保证。 +此前单线程全量测试曾超时,默认并行全量通过;没有删除或新增忽略该测试。 + +## Supersedes + +None。 + +## Revisit when + +真实工具归属或有界成本不满足需求、需要改变采集范围,或需要跨设备导出输出时, +重新审核数据与隐私合同,不隐式扩大持久化。 diff --git a/nebula_app/i18n/en-US.json b/nebula_app/i18n/en-US.json index 96a5e6d06..1586e7385 100644 --- a/nebula_app/i18n/en-US.json +++ b/nebula_app/i18n/en-US.json @@ -13,6 +13,15 @@ "en_us": "English" }, "settings": { + "command_output": { + "save": "Remember recent command output", + "help": "With session restore enabled, keep up to five commands and their output per terminal on this device. Output may contain sensitive information; full-screen applications are not captured.", + "clear": "Clear saved command output", + "clear_help": "Remove saved output for all terminals on this device without clearing their screens. New commands are still saved while the option above is enabled.", + "clearing": "Clearing…", + "cleared": "Saved output cleared", + "clear_failed": "Clear failed — retry" + }, "scrolling": { "history": "Scrollback lines", "history_description": "History lines retained per terminal. Applies to new terminals only.", diff --git a/nebula_app/i18n/zh-CN.json b/nebula_app/i18n/zh-CN.json index 747d83819..2a106b031 100644 --- a/nebula_app/i18n/zh-CN.json +++ b/nebula_app/i18n/zh-CN.json @@ -13,6 +13,15 @@ "en_us": "English" }, "settings": { + "command_output": { + "save": "保存最近命令与输出", + "help": "开启会话恢复时,在本机为每个终端保留最近五条命令及输出。输出可能包含敏感信息;不采集全屏程序画面。", + "clear": "清除已保存的命令输出", + "clear_help": "移除本机所有终端已保存的输出,不清空当前屏幕。上方开关开启时,后续新命令仍会保存。", + "clearing": "正在清除…", + "cleared": "已清除保存的输出", + "clear_failed": "清除失败,点击重试" + }, "scrolling": { "history": "回滚行数", "history_description": "每个窗格保留的历史行数。仅适用于新窗格。", diff --git a/nebula_app/src/gpui_shell/config.rs b/nebula_app/src/gpui_shell/config.rs index 7f953c521..75f10b7fe 100644 --- a/nebula_app/src/gpui_shell/config.rs +++ b/nebula_app/src/gpui_shell/config.rs @@ -75,6 +75,7 @@ pub struct Settings { pub cursor_blink: Option, /// 选区完成即复制(旧壳 `copy_on_select` 设置)。 pub copy_on_select: bool, + pub(crate) command_output_enabled: bool, pub scrollback_lines: usize, pub scroll_speed: f32, /// Pointer handlers and split rendering only read these cached preferences. @@ -274,6 +275,7 @@ impl Settings { }), cursor_blink: runtime.cursor_blink, copy_on_select: runtime.copy_on_select, + command_output_enabled: runtime.command_output_enabled(), scrollback_lines: runtime.scrollback_lines, scroll_speed: runtime.scroll_speed, focus_follows_mouse: runtime diff --git a/nebula_app/src/gpui_shell/file_editor/mod.rs b/nebula_app/src/gpui_shell/file_editor/mod.rs index e269a76a3..d1399fb69 100644 --- a/nebula_app/src/gpui_shell/file_editor/mod.rs +++ b/nebula_app/src/gpui_shell/file_editor/mod.rs @@ -31,7 +31,7 @@ mod structure_commands; mod structure_tests; mod structure_view; #[cfg(all(test, feature = "gpui-test-support"))] -mod tests; +pub(in crate::gpui_shell) mod tests; use std::cell::RefCell; use std::path::PathBuf; diff --git a/nebula_app/src/gpui_shell/file_editor/tests.rs b/nebula_app/src/gpui_shell/file_editor/tests.rs index 05191c0d9..093640fa8 100644 --- a/nebula_app/src/gpui_shell/file_editor/tests.rs +++ b/nebula_app/src/gpui_shell/file_editor/tests.rs @@ -2,6 +2,17 @@ use super::*; use gpui::{TestAppContext, VisualTestContext}; use gpui_component::Root; +pub(in crate::gpui_shell) fn replace_draft( + file: &Entity, + text: &str, + window: &mut gpui::Window, + cx: &mut gpui::App, +) { + file.update(cx, |view, cx| { + view.input.update(cx, |input, cx| input.replace_all(text, window, cx)); + }); +} + pub(super) fn open( path: PathBuf, cx: &mut TestAppContext, diff --git a/nebula_app/src/gpui_shell/settings_pane.rs b/nebula_app/src/gpui_shell/settings_pane.rs index ac326b65a..eece0aa66 100644 --- a/nebula_app/src/gpui_shell/settings_pane.rs +++ b/nebula_app/src/gpui_shell/settings_pane.rs @@ -43,6 +43,7 @@ mod appearance_picker; #[path = "background_color.rs"] mod background_color; mod backup; +mod command_output; mod design; mod font_picker; mod providers; @@ -210,6 +211,7 @@ pub struct SettingsPane { /// 备份密码(masked;只在导出/恢复动作瞬时读取,不落任何配置)。 backup_pass_input: Entity, backup_status: Option, + command_output_clear: command_output::ClearState, /// 导出/恢复/推送进行中(按钮禁用 + 忽略过期完成回调)。 backup_busy: bool, backup_seq: u64, @@ -375,7 +377,10 @@ impl SettingsPane { cx.notify(); return; } - if matches!(key, "ai_toasts" | "focus_follows_mouse" | "dim_inactive_panes") { + if matches!( + key, + "ai_toasts" | "focus_follows_mouse" | "dim_inactive_panes" | "save_command_output" + ) { if let Err(error) = self.try_persist(&[(key, (value as u8).to_string())], cx) { let language = crate::gpui_shell::config::ui_language(cx); super::toast::toast( @@ -745,6 +750,7 @@ impl SettingsPane { "fetch" => flag!(fetch), "keep_session" => flag!(keep_session), "restore_session" => flag!(restore_session), + "save_command_output" => flag!(save_command_output), "resume_ai" => flag!(resume_ai), "tray" => flag!(tray), "panel_resize" => flag!(panel_resize), @@ -1260,6 +1266,7 @@ impl SettingsPane { self.runtime.restore_session, cx, )) + .child(self.command_output_controls(cx)) .child(self.switch_row( "resume_ai", language.pick("恢复时接续 AI 对话", "Resume AI conversations"), diff --git a/nebula_app/src/gpui_shell/settings_pane/command_output.rs b/nebula_app/src/gpui_shell/settings_pane/command_output.rs new file mode 100644 index 000000000..11138c29d --- /dev/null +++ b/nebula_app/src/gpui_shell/settings_pane/command_output.rs @@ -0,0 +1,69 @@ +//! 本机命令输出沿用会话恢复设置区域;清除成功必须等磁盘操作完成。 +use super::*; +use crate::i18n::Message; + +#[derive(Default)] +pub(super) enum ClearState { + #[default] + Idle, + Busy, + Done, + Failed, +} + +impl SettingsPane { + pub(super) fn command_output_controls(&self, cx: &mut Context) -> impl IntoElement { + let language = crate::gpui_shell::config::ui_language(cx); + let label = match self.command_output_clear { + ClearState::Idle => Message::SettingsCommandOutputClear, + ClearState::Busy => Message::SettingsCommandOutputClearing, + ClearState::Done => Message::SettingsCommandOutputCleared, + ClearState::Failed => Message::SettingsCommandOutputClearFailed, + }; + let control = crate::gpui_shell::widgets::NebulaButton::new("clear-command-output") + .label(language.text(label)) + .disabled(matches!(self.command_output_clear, ClearState::Busy)) + .on_click(cx.listener(|this, _, _, cx| this.clear_command_output(cx))); + #[cfg(any(test, feature = "gpui-test-support"))] + let control = div().debug_selector(|| "clear-command-output".to_owned()).child(control); + div() + .child(self.switch_row( + "save_command_output", + language.text(Message::SettingsCommandOutputSave), + language.text(Message::SettingsCommandOutputHelp), + self.runtime.save_command_output, + cx, + )) + .child(self.row( + language.text(Message::SettingsCommandOutputClear), + language.text(Message::SettingsCommandOutputClearHelp), + control, + cx, + )) + } + + fn clear_command_output(&mut self, cx: &mut Context) { + if matches!(self.command_output_clear, ClearState::Busy) { + return; + } + self.command_output_clear = ClearState::Busy; + let clear = crate::gpui_shell::workspace::windowing::clear_command_output(cx); + cx.notify(); + cx.spawn(async move |this, cx| { + let result = clear.await; + let state = match result { + Ok(true) => ClearState::Done, + Ok(false) => ClearState::Failed, + Err(error) => { + log::warn!("Could not clear command output: {error}"); + ClearState::Failed + }, + }; + let _ = this.update(cx, |this, cx| { + this.command_output_clear = state; + cx.notify(); + }); + }) + .detach(); + } +} diff --git a/nebula_app/src/gpui_shell/settings_pane/initialization.rs b/nebula_app/src/gpui_shell/settings_pane/initialization.rs index 571f41b7b..62999d384 100644 --- a/nebula_app/src/gpui_shell/settings_pane/initialization.rs +++ b/nebula_app/src/gpui_shell/settings_pane/initialization.rs @@ -655,6 +655,7 @@ impl SettingsPane { .placeholder(localized_input_placeholder("backup_password", language)) }), backup_status: None, + command_output_clear: super::command_output::ClearState::Idle, backup_busy: false, backup_seq: 0, backup_remote: { diff --git a/nebula_app/src/gpui_shell/settings_pane/navigation.rs b/nebula_app/src/gpui_shell/settings_pane/navigation.rs index 83c259914..fe9306f9a 100644 --- a/nebula_app/src/gpui_shell/settings_pane/navigation.rs +++ b/nebula_app/src/gpui_shell/settings_pane/navigation.rs @@ -34,7 +34,7 @@ pub(super) const SECTION_SEARCH_TERMS: [&str; 10] = [ "network 网络 proxy 代理 connectivity 连接", "interaction 交互 copy 复制 paste 粘贴 tab 标签 panel 面板 focus follows mouse 焦点跟随鼠标 自动聚焦", "keymap key binding shortcut quick terminal 快速终端 独立窗口 已有窗口 按键映射 快捷键", - "advanced 高级 session 会话 tray 托盘 restore 恢复 startup autostart login silent 自启动 静默启动 开机 登录", + "advanced 高级 session 会话 tray 托盘 restore 恢复 startup autostart login silent 自启动 静默启动 开机 登录 command output 命令输出 最近命令 清除输出", "backup cloud sync 云备份 云同步 云存储 备份 export 导出 restore 恢复 webdav s3 sftp 坚果云 123 123云盘 nextcloud synology 群晖 nas r2 minio snapshots 快照", ]; diff --git a/nebula_app/src/gpui_shell/settings_pane/tests.rs b/nebula_app/src/gpui_shell/settings_pane/tests.rs index 35dedab0f..8e4e6abaf 100644 --- a/nebula_app/src/gpui_shell/settings_pane/tests.rs +++ b/nebula_app/src/gpui_shell/settings_pane/tests.rs @@ -81,6 +81,89 @@ fn ai_toast_setting_is_searchable_and_has_a_visible_switch(cx: &mut gpui::TestAp ); } +#[cfg(feature = "gpui-test-support")] +#[gpui::test] +fn command_output_controls_are_searchable_and_visible(cx: &mut gpui::TestAppContext) { + cx.update(|cx| { + gpui_component::init(cx); + cx.set_global(crate::gpui_shell::config::Settings::load(ThemeName::Nord)); + }); + let mut pane = None; + let (_, cx) = cx.add_window_view(|window, cx| { + let view = cx.new(|cx| SettingsPane::new(window, cx)); + pane = Some(view.clone()); + gpui_component::Root::new(view, window, cx) + }); + let pane = pane.unwrap(); + cx.simulate_resize(gpui::size(px(1280.0), px(1600.0))); + for query in ["命令输出", "command output"] { + cx.update(|window, cx| { + pane.update(cx, |pane, cx| { + pane.settings_search_input + .update(cx, |input, cx| input.replace_all(query, window, cx)); + }); + }); + cx.run_until_parked(); + cx.update(|window, cx| { + window.draw(cx).clear(cx); + }); + assert_eq!(pane.read_with(cx, |pane, _| pane.active_section), 8); + for id in ["nebula-switch-save_command_output", "clear-command-output"] { + let bounds = cx.debug_bounds(id).expect("command output control is rendered"); + assert!(bounds.size.width > px(0.0) && bounds.size.height > px(0.0)); + assert!(bounds.origin.y >= px(0.0) && bounds.bottom() <= px(1600.0)); + } + } +} + +#[cfg(feature = "gpui-test-support")] +#[gpui::test] +fn command_output_clear_click_reports_failure_and_allows_retry(cx: &mut gpui::TestAppContext) { + use crate::gpui_shell::workspace::windowing; + let directory = tempfile::tempdir().unwrap(); + let output = directory.path().join("output.json"); + // A directory at the file path makes removal fail without touching user data. + std::fs::create_dir(&output).unwrap(); + cx.update(|cx| { + gpui_component::init(cx); + cx.set_global(crate::gpui_shell::config::Settings::load(ThemeName::Nord)); + windowing::initialize(cx, crate::runtime_api::RuntimeHub::new()); + windowing::set_command_output_test_path(cx, output.clone()); + }); + let mut pane = None; + let (_, cx) = cx.add_window_view(|window, cx| { + let view = cx.new(|cx| SettingsPane::new(window, cx)); + view.update(cx, |pane, _| pane.active_section = 8); + pane = Some(view.clone()); + gpui_component::Root::new(view, window, cx) + }); + let pane = pane.unwrap(); + cx.simulate_resize(gpui::size(px(1280.0), px(1600.0))); + for retry in [false, true] { + if retry { + std::fs::remove_dir(&output).unwrap(); + std::fs::write(&output, b"synthetic output").unwrap(); + } + cx.update(|window, cx| { + window.draw(cx).clear(cx); + }); + let bounds = cx.debug_bounds("clear-command-output").unwrap(); + cx.simulate_mouse_down( + bounds.center(), + gpui::MouseButton::Left, + gpui::Modifiers::default(), + ); + cx.simulate_mouse_up(bounds.center(), gpui::MouseButton::Left, gpui::Modifiers::default()); + cx.run_until_parked(); + assert!(pane.read_with(cx, |pane, _| if retry { + matches!(pane.command_output_clear, command_output::ClearState::Done) + } else { + matches!(pane.command_output_clear, command_output::ClearState::Failed) + })); + assert_eq!(output.exists(), !retry); + } +} + #[test] fn settings_nav_visibility_keeps_stable_routes_and_restores_backup() { let visibility: Vec<_> = (0..SECTION_IDS.len()).map(is_nav_section_visible).collect(); diff --git a/nebula_app/src/gpui_shell/terminal/view.rs b/nebula_app/src/gpui_shell/terminal/view.rs index 907859942..637b7395a 100644 --- a/nebula_app/src/gpui_shell/terminal/view.rs +++ b/nebula_app/src/gpui_shell/terminal/view.rs @@ -16,6 +16,9 @@ mod notifications; mod output_tests; mod path_drop; mod pointer; +mod recent_output; +#[cfg(test)] +mod recent_output_tests; mod runtime; mod startup; mod startup_command; @@ -305,6 +308,10 @@ pub struct TerminalView { /// `NEBULA|` 标题报 `running_program`,装了 OSC133 集成的 bash/zsh/nu 只 /// 发这一对语义标记——两条路都要能点亮侧栏的「运行中」。 command_running: bool, + recent_output: crate::recent_output::RecentOutput, + recent_output_restore_closed: bool, + recent_output_enabled: bool, + restored_viewport_offset: Option, /// 进程树给出的反证:`command_running` 为真、但 shell 树下只剩交互式 /// shell 与 console plumbing 时置位,转圈据此熄灭(issue #42)。判据与 /// 节流都在 `runtime::reconcile_shell_activity`,裁定理由见那里。 @@ -531,6 +538,7 @@ impl TerminalView { } match event { TermEvent::Wakeup => { + self.follow_restored_viewport(); self.flush_pending_runtime_submit(cx); self.flush_pending_shell_command(cx); if self.output_visible { @@ -739,11 +747,14 @@ impl TerminalView { if !preserves_prompt { term.nebula_end_prompt(); } - term.scroll_display(Scroll::Bottom); + if self.restored_viewport_offset.is_none() { + term.scroll_display(Scroll::Bottom); + } term.selection = None; } session.notifier.notify(bytes); } + self.follow_restored_viewport(); self.sync_native_prompt(); self.restart_cursor_blink(cx); cx.notify(); @@ -879,6 +890,7 @@ impl TerminalView { let font_size = px(settings.font_size_px); let palette = Arc::new(settings.palette.clone()); let copy_on_select = settings.copy_on_select; + let command_output_enabled = settings.command_output_enabled; let default_cursor_style = settings.term_config().default_cursor_style; let cursor_style_changed = self.default_cursor_style != default_cursor_style; self.ghost_enabled = settings.ghost; @@ -928,6 +940,7 @@ impl TerminalView { term.reset_cursor_style_override(); } } + self.set_recent_output_enabled(command_output_enabled); self.restart_cursor_blink(cx); cx.notify(); } @@ -1189,6 +1202,7 @@ impl TerminalView { }; if let Some(scroll) = scroll { if let Some(session) = &self.session { + self.restored_viewport_offset = None; session.term.lock().scroll_display(scroll); } cx.notify(); diff --git a/nebula_app/src/gpui_shell/terminal/view/completion.rs b/nebula_app/src/gpui_shell/terminal/view/completion.rs index 20e5fedc3..986a91d38 100644 --- a/nebula_app/src/gpui_shell/terminal/view/completion.rs +++ b/nebula_app/src/gpui_shell/terminal/view/completion.rs @@ -56,6 +56,7 @@ impl TerminalView { && !self.suggest.screen_line.trim().is_empty(); suggest::commit_line(&mut self.suggest); if confirmed_submission { + self.begin_recent_output(); self.mark_submitted_command(native_submission); cx.notify(); } diff --git a/nebula_app/src/gpui_shell/terminal/view/pointer.rs b/nebula_app/src/gpui_shell/terminal/view/pointer.rs index 25367d190..f93ae33a4 100644 --- a/nebula_app/src/gpui_shell/terminal/view/pointer.rs +++ b/nebula_app/src/gpui_shell/terminal/view/pointer.rs @@ -98,11 +98,12 @@ impl TerminalView { } /// 把回滚位置落到 `target`(滚动条拖拽的落点提交)。 - pub(super) fn scroll_to_offset(&self, target: usize, current: usize) { + pub(super) fn scroll_to_offset(&mut self, target: usize, current: usize) { if target == current { return; } if let Some(session) = &self.session { + self.restored_viewport_offset = None; session.term.lock().scroll_display(Scroll::Delta(target as i32 - current as i32)); } } @@ -708,6 +709,7 @@ impl TerminalView { return true; } if let Some(session) = &self.session { + self.restored_viewport_offset = None; session.term.lock().scroll_display(Scroll::Delta(lines)); } // 滚动换了视口到绝对行的映射,选区末端必须按滚动后的网格重算—— @@ -894,6 +896,7 @@ impl TerminalView { } session.notifier.notify(bytes); } else { + self.restored_viewport_offset = None; session.term.lock().scroll_display(Scroll::Delta(lines)); } cx.notify(); diff --git a/nebula_app/src/gpui_shell/terminal/view/recent_output.rs b/nebula_app/src/gpui_shell/terminal/view/recent_output.rs new file mode 100644 index 000000000..67d3b6281 --- /dev/null +++ b/nebula_app/src/gpui_shell/terminal/view/recent_output.rs @@ -0,0 +1,134 @@ +//! 命令恢复只消费已确认的 shell 提交,不从运行徽章推断提交。 + +use super::TerminalView; +use nebula_terminal::term::TermMode; + +impl TerminalView { + pub(crate) fn restore_output_batch( + path: std::path::PathBuf, + targets: Vec<(String, gpui::WeakEntity)>, + cx: &mut gpui::App, + ) { + if targets.is_empty() { + return; + } + let read = cx + .background_executor() + .spawn(async move { crate::recent_output::storage::Archive::read_from(&path) }); + cx.spawn(async move |cx| { + let mut archive = match read.await { + Ok(archive) => archive, + Err(error) => { + if error.kind() != std::io::ErrorKind::NotFound { + log::warn!("Could not restore command output: {error}"); + } + return; + }, + }; + for (id, target) in targets { + let Some(records) = archive.take_records(&id) else { continue }; + let _ = target.update(cx, |view, cx| { + if view.exited.is_some() { + return; + } + if let Err(error) = view.restore_recent_output(records, cx) { + log::warn!("Invalid saved command output: {error}"); + } + }); + } + }) + .detach(); + } + + pub(crate) fn set_recent_output_enabled(&mut self, enabled: bool) { + self.recent_output_enabled = enabled; + if !enabled { + self.clear_recent_output(); + } + } + + pub(crate) fn clear_recent_output(&mut self) { + self.recent_output = crate::recent_output::RecentOutput::default(); + self.recent_output_restore_closed = true; + } + + pub(crate) fn restore_recent_output( + &mut self, + records: Vec, + cx: &mut gpui::Context, + ) -> Result { + if !self.recent_output_enabled || self.recent_output_restore_closed { + return Ok(false); + } + let Some(session) = &self.session else { return Ok(false) }; + let recent = crate::recent_output::RecentOutput::try_from_records(records)?; + let mut term = session.term.lock(); + if term.mode().contains(TermMode::ALT_SCREEN) { + return Ok(false); + } + recent.restore(term.grid_mut())?; + // 恢复内容位于主屏之前;只移动视口,不改 ConPTY 的绝对光标坐标。 + // 新输出逐步占用主屏下方空行,输入不能提前隐藏恢复内容。 + let grid = term.grid(); + use nebula_terminal::grid::Dimensions; + let room = grid.screen_lines().saturating_sub(grid.cursor.point.line.0 as usize + 1); + let offset = room.min(grid.history_size()); + term.scroll_display(nebula_terminal::grid::Scroll::Bottom); + term.scroll_display(nebula_terminal::grid::Scroll::Delta(offset as i32)); + self.restored_viewport_offset = (offset > 0).then_some(offset); + self.recent_output = recent; + self.recent_output_restore_closed = true; + drop(term); + cx.notify(); + Ok(true) + } + + pub(super) fn follow_restored_viewport(&mut self) { + use nebula_terminal::grid::{Dimensions, Scroll}; + let Some(_) = self.restored_viewport_offset else { return }; + let Some(session) = &self.session else { return }; + let mut term = session.term.lock(); + if term.mode().intersects(TermMode::ALT_SCREEN | TermMode::VI) { + self.restored_viewport_offset = None; + return; + } + let grid = term.grid(); + let room = grid.screen_lines().saturating_sub(grid.cursor.point.line.0 as usize + 1); + // 恢复跟随期间用空白容量容纳历史;宽度重排可能增加历史行数, + // 不能沿用恢复时的旧 offset,否则会截掉长命令的开头。 + let current = grid.display_offset(); + let offset = room.min(grid.history_size()); + if current != offset { + term.scroll_display(Scroll::Delta(offset as i32 - current as i32)); + } + self.restored_viewport_offset = (offset > 0).then_some(offset); + } + + pub(super) fn begin_recent_output(&mut self) { + if !self.recent_output_enabled { + return; + } + let Some(session) = &self.session else { return }; + let term = session.term.lock(); + if !term.mode().intersects(TermMode::ALT_SCREEN | TermMode::VI) { + self.recent_output_restore_closed = true; + self.recent_output.finish(term.grid()); + self.recent_output.begin(term.grid()); + } + } + + pub(super) fn finish_recent_output(&mut self) { + let Some(session) = &self.session else { return }; + let term = session.term.lock(); + self.recent_output.finish(term.primary_grid()); + } + + pub(crate) fn recent_output_snapshot(&self) -> Vec { + if !self.recent_output_enabled { + return Vec::new(); + } + let Some(session) = &self.session else { return Vec::new() }; + let term = session.term.lock(); + self.recent_output.snapshot(term.primary_grid()) + } +} diff --git a/nebula_app/src/gpui_shell/terminal/view/recent_output_tests.rs b/nebula_app/src/gpui_shell/terminal/view/recent_output_tests.rs new file mode 100644 index 000000000..7c6617da5 --- /dev/null +++ b/nebula_app/src/gpui_shell/terminal/view/recent_output_tests.rs @@ -0,0 +1,365 @@ +use super::*; +use gpui::TestAppContext; +use startup_tests::{feed, open}; + +fn prompt(view: &mut TerminalView, input: &str) { + view.suggest.suggest_env = crate::display::SuggestEnv::Local; + feed(view, format!("\x1b]133;A\x07C:\\work>\x1b]133;B\x07\x1b]1337;SetUserVar=pebrel_cmd_prompt=MQ==\x07{input}").as_bytes()); +} + +fn restored_text(view: &TerminalView) -> String { + let recent = + crate::recent_output::RecentOutput::try_from_records(view.recent_output_snapshot()) + .unwrap(); + let (session, _) = session::test_session(); + let mut term = session.term.lock(); + recent.restore(term.grid_mut()).unwrap(); + use nebula_terminal::grid::Dimensions; + term.bounds_to_string( + TermPoint::new(Line(-(term.grid().history_size() as i32)), Column(0)), + TermPoint::new(Line(-1), Column(term.columns() - 1)), + ) +} + +#[gpui::test] +fn confirmed_shell_submission_captures_output_but_not_later_idle_input(cx: &mut TestAppContext) { + let (view, window, _) = open(cx); + view.update(window, |view, cx| { + prompt(view, "echo saved"); + view.commit_line(cx); + view.write_input(b"\r".to_vec(), cx); + feed(view, b"\r\nsaved result\r\n"); + prompt(view, ""); + view.finish_foreground_command(Some(0), cx); + feed(view, b"not-submitted"); + let text = restored_text(view); + assert!(text.contains("echo saved"), "{text:?}"); + assert!(text.contains("saved result")); + assert!(!text.contains("not-submitted")); + assert_eq!(view.recent_output_snapshot().len(), 1); + }); +} + +#[gpui::test] +fn empty_enter_and_foreground_password_do_not_create_records(cx: &mut TestAppContext) { + let (view, window, _) = open(cx); + view.update(window, |view, cx| { + prompt(view, ""); + view.commit_line(cx); + assert!(view.recent_output_snapshot().is_empty()); + feed(view, b"tool"); + view.commit_line(cx); + view.write_input(b"\r".to_vec(), cx); + feed(view, b"\r\nPassword: "); + view.suggest.line_buf = "invisible-secret".into(); + view.commit_line(cx); + assert_eq!(view.recent_output_snapshot().len(), 1); + assert!(!restored_text(view).contains("invisible-secret")); + }); +} + +#[gpui::test] +fn alternate_screen_keeps_main_output_and_never_saves_tui_input(cx: &mut TestAppContext) { + let (view, window, _) = open(cx); + view.update(window, |view, cx| { + prompt(view, "tool"); + view.commit_line(cx); + view.write_input(b"\r".to_vec(), cx); + feed(view, b"\r\nmain output\x1b[?1049hTUI private input"); + let text = restored_text(view); + assert!(text.contains("main output"), "{text:?}"); + assert!(!text.contains("TUI private input"), "{text:?}"); + feed(view, b"\x1b[?1049l\r\n"); + prompt(view, ""); + view.finish_foreground_command(Some(0), cx); + assert!(restored_text(view).contains("main output")); + }); +} + +#[gpui::test] +fn cold_restore_inserts_once_without_executing_or_replacing_prompt(cx: &mut TestAppContext) { + let (source, window, _) = open(cx); + let records = source.update(window, |view, cx| { + prompt(view, "echo old-marker"); + view.commit_line(cx); + view.write_input(b"\r".to_vec(), cx); + feed(view, b"\r\nold-result\r\n"); + prompt(view, ""); + view.finish_foreground_command(Some(0), cx); + view.recent_output_snapshot() + }); + let (target, target_window, _) = open(cx); + target.update(target_window, |view, cx| { + prompt(view, ""); + let before = view.session.as_ref().unwrap().term.lock().grid().cursor.point; + assert!(view.restore_recent_output(records.clone(), cx).unwrap()); + assert!(!view.restore_recent_output(records, cx).unwrap()); + assert!(!view.command_running); + assert!(view.active_run.is_none()); + assert_eq!(view.recent_output_snapshot().len(), 1); + let term = view.session.as_ref().unwrap().term.lock(); + use nebula_terminal::grid::Dimensions; + assert_eq!(term.grid().cursor.point, before); + let text = term.bounds_to_string( + TermPoint::new(Line(-(term.grid().history_size() as i32)), Column(0)), + TermPoint::new(Line(-1), Column(term.columns() - 1)), + ); + assert_eq!(text.matches("echo old-marker").count(), 1, "{text:?}"); + assert_eq!(text.matches("old-result").count(), 1, "{text:?}"); + let origin = term.viewport_origin_for(term.screen_lines()); + let visible = term.bounds_to_string( + TermPoint::new(origin, Column(0)), + TermPoint::new(origin + term.screen_lines() - 1, Column(term.columns() - 1)), + ); + assert!(visible.contains("old-result"), "restored output must be visible: {visible:?}"); + assert!(visible.contains("C:\\work>"), "live prompt must remain visible: {visible:?}"); + }); +} + +#[gpui::test] +fn restored_output_follows_input_until_live_screen_fills(cx: &mut TestAppContext) { + let (source, window, _) = open(cx); + let records = source.update(window, |view, cx| { + prompt(view, "echo old-marker"); + view.commit_line(cx); + feed(view, b"\r\nold-result\r\n"); + prompt(view, ""); + view.finish_foreground_command(Some(0), cx); + view.recent_output_snapshot() + }); + let (target, window, _) = open(cx); + target.update(window, |view, cx| { + prompt(view, ""); + view.restore_recent_output(records, cx).unwrap(); + let offset = view.session.as_ref().unwrap().term.lock().grid().display_offset(); + assert!(offset > 0); + view.write_input(b"e".to_vec(), cx); + feed(view, b"e"); + view.process_event(TermEvent::Wakeup, cx); + assert_eq!(view.session.as_ref().unwrap().term.lock().grid().display_offset(), offset); + feed(view, b"\r\nnext-output\r\n"); + view.process_event(TermEvent::Wakeup, cx); + assert_eq!(view.session.as_ref().unwrap().term.lock().grid().display_offset(), offset); + feed(view, "\r\nnew-line".repeat(40).as_bytes()); + view.process_event(TermEvent::Wakeup, cx); + assert_eq!(view.session.as_ref().unwrap().term.lock().grid().display_offset(), 0); + }); +} + +#[gpui::test] +fn restored_long_command_stays_visible_when_startup_layout_narrows(cx: &mut TestAppContext) { + let (source, window, _) = open(cx); + let records = source.update(window, |view, cx| { + prompt(view, "echo long-command-marker-1234567890"); + view.commit_line(cx); + feed(view, b"\r\nold-result\r\n"); + prompt(view, ""); + view.finish_foreground_command(Some(0), cx); + view.recent_output_snapshot() + }); + let (target, window, _) = open(cx); + target.update(window, |view, cx| { + prompt(view, ""); + view.restore_recent_output(records, cx).unwrap(); + view.session + .as_ref() + .unwrap() + .term + .lock() + .resize(session::GridSize { columns: 24, screen_lines: 24 }); + view.process_event(TermEvent::Wakeup, cx); + let term = view.session.as_ref().unwrap().term.lock(); + use nebula_terminal::grid::Dimensions; + let origin = term.viewport_origin_for(term.screen_lines()); + let visible = term.bounds_to_string( + TermPoint::new(origin, Column(0)), + TermPoint::new(origin + term.screen_lines() - 1, Column(term.columns() - 1)), + ); + assert!(visible.contains("C:\\work>echo long-command-marker-1234567890"), "{visible:?}"); + assert!(visible.contains("old-result"), "{visible:?}"); + }); +} + +#[gpui::test] +fn manual_scroll_after_restore_keeps_normal_input_return_to_bottom(cx: &mut TestAppContext) { + let (view, window, _) = open(cx); + view.update(window, |view, cx| { + feed(view, "old-line\r\n".repeat(40).as_bytes()); + view.session.as_ref().unwrap().term.lock().scroll_display(Scroll::Delta(3)); + view.restored_viewport_offset = Some(3); + view.scroll_to_offset(5, 3); + view.process_event(TermEvent::Wakeup, cx); + assert_eq!(view.session.as_ref().unwrap().term.lock().grid().display_offset(), 5); + view.write_input(b"e".to_vec(), cx); + assert_eq!(view.session.as_ref().unwrap().term.lock().grid().display_offset(), 0); + assert_eq!(view.restored_viewport_offset, None); + }); +} + +#[gpui::test] +fn alternate_screen_ends_restore_follow_without_scrolling_the_application(cx: &mut TestAppContext) { + let (view, window, _) = open(cx); + view.update(window, |view, cx| { + feed(view, "old-line\r\n".repeat(40).as_bytes()); + view.session.as_ref().unwrap().term.lock().scroll_display(Scroll::Delta(3)); + view.restored_viewport_offset = Some(3); + feed(view, b"\x1b[?1049hfull-screen"); + view.process_event(TermEvent::Wakeup, cx); + assert_eq!(view.restored_viewport_offset, None); + assert_eq!(view.session.as_ref().unwrap().term.lock().grid().display_offset(), 0); + feed(view, b"\x1b[?1049l"); + view.write_input(b"e".to_vec(), cx); + assert_eq!(view.session.as_ref().unwrap().term.lock().grid().display_offset(), 0); + }); +} + +#[gpui::test] +fn late_restore_does_not_replace_commands_submitted_since_startup(cx: &mut TestAppContext) { + let (view, window, _) = open(cx); + view.update(window, |view, cx| { + prompt(view, "echo new-command"); + view.commit_line(cx); + assert!(!view.restore_recent_output(Vec::new(), cx).unwrap()); + assert!(restored_text(view).contains("echo new-command")); + }); +} + +#[gpui::test] +fn disabled_capture_does_not_collect_commands_or_accept_restore(cx: &mut TestAppContext) { + let (view, window, _) = open(cx); + view.update(window, |view, cx| { + view.set_recent_output_enabled(false); + prompt(view, "echo do-not-save"); + view.commit_line(cx); + feed(view, b"\r\nprivate output\r\n"); + view.finish_foreground_command(Some(0), cx); + assert!(view.recent_output_snapshot().is_empty()); + assert!(!view.restore_recent_output(Vec::new(), cx).unwrap()); + view.set_recent_output_enabled(true); + prompt(view, "echo allowed"); + view.commit_line(cx); + assert_eq!(view.recent_output_snapshot().len(), 1); + }); +} + +#[gpui::test] +fn disabling_capture_clears_memory_and_stops_active_output(cx: &mut TestAppContext) { + let (view, window, _) = open(cx); + view.update(window, |view, cx| { + prompt(view, "tool"); + view.commit_line(cx); + feed(view, b"\r\nbefore\r\n"); + assert_eq!(view.recent_output_snapshot().len(), 1); + view.set_recent_output_enabled(false); + view.set_recent_output_enabled(true); + feed(view, b"after-enable"); + view.finish_foreground_command(Some(0), cx); + assert!(view.recent_output_snapshot().is_empty()); + }); +} + +#[gpui::test] +fn loaded_settings_disable_existing_and_new_terminal_capture(cx: &mut TestAppContext) { + let (view, window, _) = open(cx); + for raw in ["save_command_output=0", "restore_session=0\nsave_command_output=1"] { + view.update(window, |view, cx| { + let settings = Settings::load_with_runtime( + nebula_settings::ThemeName::Nord, + nebula_settings::RuntimeSettings::from_raw( + &nebula_settings::RawSettings::from_text(raw), + ), + ); + cx.set_global(settings); + view.apply_settings(cx); + prompt(view, "echo private"); + view.commit_line(cx); + assert!(view.recent_output_snapshot().is_empty(), "{raw}"); + }); + window.update(|window, cx| { + let new_view = cx.new(|cx| { + TerminalView::new( + 43, + (80, 24), + TerminalLaunch::Local { + cwd: None, + shell: Some(nebula_terminal::tty::Shell::new( + "pebrel-test-missing-shell-executable".into(), + vec![], + )), + shell_name: None, + }, + window, + cx, + ) + }); + assert!(!new_view.read(cx).recent_output_enabled, "{raw}"); + }); + } +} + +#[gpui::test] +fn batch_restore_reads_exact_references_and_skips_changed_panes(cx: &mut TestAppContext) { + let (source, window, _) = open(cx); + let records = source.update(window, |view, cx| { + prompt(view, "echo batch-marker"); + view.commit_line(cx); + feed(view, b"\r\nbatch-result\r\n"); + view.finish_foreground_command(Some(0), cx); + view.recent_output_snapshot() + }); + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("outputs.json"); + crate::recent_output::storage::Archive::new(std::collections::BTreeMap::from([ + ("first".into(), records.clone()), + ("changed".into(), records.clone()), + ("disabled".into(), records), + ])) + .write_to(&path) + .unwrap(); + let (changed, changed_window, _) = open(cx); + changed.update(changed_window, |view, cx| { + prompt(view, "echo new-command"); + view.commit_line(cx); + }); + let (disabled, disabled_window, _) = open(cx); + disabled.update(disabled_window, |view, _| view.set_recent_output_enabled(false)); + let (missing, _, _) = open(cx); + let (first, first_window, _) = open(cx); + first_window.update(|_, cx| { + TerminalView::restore_output_batch( + path, + vec![ + ("first".into(), first.downgrade()), + ("changed".into(), changed.downgrade()), + ("disabled".into(), disabled.downgrade()), + ("missing".into(), missing.downgrade()), + ], + cx, + ); + }); + first_window.run_until_parked(); + first.update(first_window, |view, _| { + assert!(restored_text(view).contains("batch-marker")); + assert!(!view.command_running); + }); + changed.update(first_window, |view, _| { + assert!(restored_text(view).contains("new-command")); + assert!(!restored_text(view).contains("batch-marker")); + }); + disabled.update(first_window, |view, _| assert!(view.recent_output_snapshot().is_empty())); + missing.update(first_window, |view, _| assert!(view.recent_output_snapshot().is_empty())); +} + +#[gpui::test] +fn runtime_submission_records_echo_only_after_barrier(cx: &mut TestAppContext) { + let (view, window, _) = open(cx); + view.update(window, |view, cx| { + prompt(view, ""); + view.runtime_prompt("echo runtime".into(), true, cx).unwrap(); + assert!(view.recent_output_snapshot().is_empty()); + feed(view, b"echo runtime"); + view.flush_pending_runtime_submit(cx); + assert_eq!(view.recent_output_snapshot().len(), 1); + assert!(restored_text(view).contains("echo runtime")); + }); +} diff --git a/nebula_app/src/gpui_shell/terminal/view/runtime.rs b/nebula_app/src/gpui_shell/terminal/view/runtime.rs index e81ee91bd..035e27fa9 100644 --- a/nebula_app/src/gpui_shell/terminal/view/runtime.rs +++ b/nebula_app/src/gpui_shell/terminal/view/runtime.rs @@ -159,6 +159,7 @@ impl TerminalView { exit_code: Option, cx: &mut Context, ) { + self.finish_recent_output(); self.notify_command_done(cx); self.last_command_failed = exit_code.is_some_and(|code| code != 0); if self.clear_foreground_agent_state(cx) { @@ -1051,6 +1052,10 @@ impl TerminalView { return; } let pending = self.pending_runtime_submit.take().expect("checked above"); + // 运行徽章在 echo 前已置位;只有启动前捕获的 shell 提示符允许记录。 + if self.suggest.pending_command_prompt.is_some() && self.runtime_agent().is_none() { + self.begin_recent_output(); + } self.write_input(pending.submit_bytes, cx); } } diff --git a/nebula_app/src/gpui_shell/terminal/view/startup.rs b/nebula_app/src/gpui_shell/terminal/view/startup.rs index 19364aaf1..02ecda7bf 100644 --- a/nebula_app/src/gpui_shell/terminal/view/startup.rs +++ b/nebula_app/src/gpui_shell/terminal/view/startup.rs @@ -240,6 +240,12 @@ impl TerminalView { branch: String::new(), running_program: None, command_running: false, + recent_output: crate::recent_output::RecentOutput::default(), + recent_output_restore_closed: false, + restored_viewport_offset: None, + recent_output_enabled: cx + .try_global::() + .is_none_or(|settings| settings.command_output_enabled), command_running_disproved: false, command_started: None, last_process_probe: None, diff --git a/nebula_app/src/gpui_shell/workspace.rs b/nebula_app/src/gpui_shell/workspace.rs index a0e11702a..185ec7349 100644 --- a/nebula_app/src/gpui_shell/workspace.rs +++ b/nebula_app/src/gpui_shell/workspace.rs @@ -1662,15 +1662,6 @@ impl NebulaWorkspace { (0..self.tabs.len()).find_map(|tab_ix| self.busy_process_in_tab(tab_ix, None, cx)) } - fn save_clean_window_session(&mut self, cx: &mut App) -> std::io::Result<()> { - windowing::save_current_window_session( - self.runtime_window_id, - self.snapshot_session(cx), - session_persistence::SaveReason::WindowClose, - cx, - ) - } - fn request_close_pane( &mut self, tab_ix: usize, @@ -1871,14 +1862,17 @@ impl NebulaWorkspace { self.active -= 1; } self.active = self.active.min(self.tabs.len().saturating_sub(1)); - if let Err(error) = windowing::save_current_window_session( - self.runtime_window_id, - self.snapshot_session(cx), + let save = windowing::output_persistence::save( + Some(self.snapshot_local_session(cx)), session_persistence::SaveReason::TabsClosed, cx, - ) { - log::warn!("Could not save closed tabs: {error}"); - } + ); + cx.spawn(async move |_, _| { + if !matches!(save.await, Ok(true)) { + log::warn!("Could not save closed tabs"); + } + }) + .detach(); self.reveal_active_tab(); self.focus_active(window, cx); self.sync_side_panel_to_active(true, cx); diff --git a/nebula_app/src/gpui_shell/workspace/closing.rs b/nebula_app/src/gpui_shell/workspace/closing.rs index 199406f04..27200c37e 100644 --- a/nebula_app/src/gpui_shell/workspace/closing.rs +++ b/nebula_app/src/gpui_shell/workspace/closing.rs @@ -1,8 +1,19 @@ use super::*; impl NebulaWorkspace { - /// GPUI 的 should-close 回调必须同步返回:无繁忙进程时直接允许系统关闭; - /// 有繁忙进程时先返回 false,再由对话框确认回调显式移除窗口。 + pub(super) fn save_clean_window_session( + &mut self, + cx: &mut App, + ) -> gpui::Task> { + windowing::output_persistence::save( + Some(self.snapshot_local_session(cx)), + session_persistence::SaveReason::WindowClose, + cx, + ) + } + + /// GPUI 关闭回调必须同步返回;普通窗口先等待保存,繁忙窗口还须确认。 + /// 返回 false 后,由异步保存成功路径显式移除窗口。 pub(super) fn should_close_window( &mut self, window: &mut Window, @@ -84,13 +95,30 @@ impl NebulaWorkspace { fn finish_close_window(&mut self, _window: &mut Window, cx: &mut Context) { self.window_close_pending = true; + let documents = self.close_document_snapshot(cx); let panes = self.prepare_session_save(cx); let handle = self.window_handle; cx.spawn(async move |this, cx| { let ready = wait_for_session_ids(&panes, cx).await; + let saved = if ready { + let Ok(save) = + this.update(cx, |workspace, cx| workspace.save_clean_window_session(cx)) + else { + return; + }; + match save.await { + Ok(saved) => saved, + Err(error) => { + log::warn!("Window close cancelled because session save failed: {error}"); + false + }, + } + } else { + false + }; let _ = handle.update(cx, |_, window, cx| { let _ = this.update(cx, |workspace, cx| { - if !ready || workspace.save_clean_window_session(cx).is_err() { + if !saved { workspace.window_close_pending = false; let language = crate::gpui_shell::config::ui_language(cx); let message = if ready { @@ -107,6 +135,12 @@ impl NebulaWorkspace { cx.notify(); return; } + workspace.window_close_pending = false; + if !workspace.close_documents_unchanged(&documents, cx) { + workspace.guard_file_window_close(window, cx); + cx.notify(); + return; + } window.remove_window(); }); }); diff --git a/nebula_app/src/gpui_shell/workspace/documents.rs b/nebula_app/src/gpui_shell/workspace/documents.rs index 131c7ee27..25b639624 100644 --- a/nebula_app/src/gpui_shell/workspace/documents.rs +++ b/nebula_app/src/gpui_shell/workspace/documents.rs @@ -15,6 +15,33 @@ impl WorkspaceTab { } impl NebulaWorkspace { + pub(super) fn close_document_snapshot( + &self, + cx: &App, + ) -> Vec<(Entity, SharedString)> { + self.tabs + .iter() + .filter_map(|tab| tab.file_editor(cx)) + .map(|file| { + let draft = file.read(cx).draft(cx); + (file, draft) + }) + .collect() + } + + pub(super) fn close_documents_unchanged( + &self, + approved: &[(Entity, SharedString)], + cx: &App, + ) -> bool { + self.tabs.iter().filter_map(|tab| tab.file_editor(cx)).all(|file| { + let view = file.read(cx); + !view.is_saving() + && (!view.is_dirty() + || approved.iter().any(|(old, draft)| *old == file && *draft == view.draft(cx))) + }) + } + pub(super) fn sync_document_activity(&self, window: &mut Window, cx: &mut Context) { for (index, tab) in self.tabs.iter().enumerate() { let Some(file) = tab.file_editor(cx) else { continue }; diff --git a/nebula_app/src/gpui_shell/workspace/residency.rs b/nebula_app/src/gpui_shell/workspace/residency.rs index b15a1f321..9c93de615 100644 --- a/nebula_app/src/gpui_shell/workspace/residency.rs +++ b/nebula_app/src/gpui_shell/workspace/residency.rs @@ -148,9 +148,77 @@ impl NebulaWorkspace { fn drain_runtime_commands(&mut self, window: &mut Window, cx: &mut Context) { let pending = std::mem::take(&mut self.runtime_pending); for dispatch in pending { - let response = self.execute_runtime_command(&dispatch.command, window, cx); - dispatch.respond(response); + if let RuntimeCommand::CloseWindow { window_id } = &dispatch.command { + let close = self.runtime_close_window(*window_id, cx); + cx.spawn(async move |_, _| { + dispatch.respond(match close { + Ok(close) => close.await, + Err(error) => Err(error), + }); + }) + .detach(); + } else { + let response = self.execute_runtime_command(&dispatch.command, window, cx); + dispatch.respond(response); + } + } + } + + pub(super) fn runtime_close_window( + &mut self, + window_id: Option, + cx: &mut Context, + ) -> Result>, ApiError> { + self.runtime_window_requested(window_id)?; + if self.window_close_pending { + return Err(ApiError::new("close_pending", "window close is already pending")); + } + if !self.close_documents_unchanged(&[], cx) { + return Err(ApiError::new( + "requires_confirmation", + "unsaved documents require confirmation in the GUI", + )); } + if let Some(process) = self.busy_process_in_window(cx) { + return Err(runtime_close_confirmation( + process, + json!({ "target": "window", "window_id": self.runtime_window_id }), + )); + } + self.window_close_pending = true; + let panes = self.prepare_session_save(cx); + let handle = self.window_handle; + let id = self.runtime_window_id; + let tab_count = self.tabs.len(); + Ok(cx.spawn(async move |this, cx| { + let result = async { + if !super::closing::wait_for_session_ids(&panes, cx).await { + return Err(ApiError::new("session_identity_pending", "session identity is not ready")); + } + let save = this.update(cx, |workspace, cx| workspace.save_clean_window_session(cx)) + .map_err(|error| ApiError::new("target_not_found", error.to_string()))?; + match save.await { + Ok(true) => {}, + Ok(false) => return Err(ApiError::new("session_save_failed", "session save was superseded")), + Err(error) => return Err(ApiError::new("session_save_failed", error.to_string())), + } + let documents_safe = this.update(cx, |workspace, cx| { + workspace.close_documents_unchanged(&[], cx) + }).map_err(|error| ApiError::new("target_not_found", error.to_string()))?; + if !documents_safe { + return Err(ApiError::new("requires_confirmation", "documents changed while the window was saving")); + } + handle.update(cx, |_, window, cx| { + super::windowing::remove_saved_workspace_window(id, window, cx); + let snapshot = super::windowing::publish_runtime_snapshot(cx); + json!({ "action": { "window_id": id, "closed": true, "tabs_closed": tab_count }, "snapshot": snapshot }) + }).map_err(|error| ApiError::new("target_not_found", error.to_string())) + }.await; + if result.is_err() { + let _ = this.update(cx, |workspace, _| workspace.window_close_pending = false); + } + result + })) } pub(crate) fn execute_runtime_command( @@ -168,39 +236,10 @@ impl NebulaWorkspace { "runtime_unavailable", "window.create is not queued in the GPUI runtime", )), - RuntimeCommand::CloseWindow { window_id } => { - self.runtime_window_requested(*window_id)?; - if let Some(process) = self.busy_process_in_window(cx) { - return Err(runtime_close_confirmation( - process, - json!({ "target": "window", "window_id": self.runtime_window_id }), - )); - } - let tab_count = self.tabs.len(); - if self.tabs.is_empty() { - super::windowing::close_empty_workspace_window( - self.runtime_window_id, - window, - cx, - ); - } else { - super::windowing::close_saved_workspace_window( - self.runtime_window_id, - self.snapshot_session(cx), - window, - cx, - ); - } - let snapshot = super::windowing::publish_runtime_snapshot(cx); - Ok(json!({ - "action": { - "window_id": self.runtime_window_id, - "closed": true, - "tabs_closed": tab_count - }, - "snapshot": snapshot - })) - }, + RuntimeCommand::CloseWindow { .. } => Err(ApiError::new( + "runtime_unavailable", + "window.close requires asynchronous session publication", + )), RuntimeCommand::Focus { window_id, pane_id } => { self.runtime_window_requested(*window_id)?; if let Some(pane_id) = pane_id { @@ -1013,24 +1052,35 @@ impl NebulaWorkspace { { return false; } - if let Err(error) = super::windowing::save_current_window_session( - self.runtime_window_id, - self.snapshot_session(cx), + self.window_close_pending = true; + let save = super::windowing::output_persistence::save( + Some(self.snapshot_local_session(cx)), super::session_persistence::SaveReason::Checkpoint, cx, - ) { - log::warn!("Could not checkpoint before hiding window: {error}"); - let language = crate::gpui_shell::config::ui_language(cx); - crate::gpui_shell::toast::banner( - window, - cx, - crate::display::ToastKind::Warning, - language.text(crate::i18n::Message::SessionSaveFailed), - ); - return true; - } - crate::gpui_shell::hide_native_window(window); - self.window_hidden = true; + ); + let handle = self.window_handle; + cx.spawn(async move |this, cx| { + let saved = matches!(save.await, Ok(true)); + let _ = handle.update(cx, |_, window, cx| { + let _ = this.update(cx, |workspace, cx| { + workspace.window_close_pending = false; + if saved { + crate::gpui_shell::hide_native_window(window); + workspace.window_hidden = true; + } else { + let language = crate::gpui_shell::config::ui_language(cx); + crate::gpui_shell::toast::banner( + window, + cx, + crate::display::ToastKind::Warning, + language.text(crate::i18n::Message::SessionSaveFailed), + ); + } + cx.notify(); + }); + }); + }) + .detach(); true } diff --git a/nebula_app/src/gpui_shell/workspace/session_persistence.rs b/nebula_app/src/gpui_shell/workspace/session_persistence.rs index 9159a25ac..044fc3f8f 100644 --- a/nebula_app/src/gpui_shell/workspace/session_persistence.rs +++ b/nebula_app/src/gpui_shell/workspace/session_persistence.rs @@ -1,3 +1,6 @@ +mod local_snapshot; +pub(super) use local_snapshot::{LocalSnapshot, prepare_windows}; + use crate::session::Session; pub(super) use crate::session::combine_sessions; @@ -9,7 +12,15 @@ pub(super) enum SaveReason { Quit, } +pub(super) struct PendingSave { + pub(super) session: Session, + generation: u64, + quitting: bool, +} + pub(super) struct SessionPersistence { + generation: u64, + write_pending: bool, latest: Option, saved: Option, quitting: bool, @@ -19,6 +30,8 @@ pub(super) struct SessionPersistence { impl Default for SessionPersistence { fn default() -> Self { Self { + generation: 0, + write_pending: false, latest: None, saved: None, quitting: false, @@ -35,7 +48,17 @@ impl SessionPersistence { .into_update_windows() } + pub(super) fn clear_output_references(&mut self) { + self.generation += 1; + for session in self.latest.iter_mut().chain(self.saved.iter_mut()) { + for tab in &mut session.tabs { + tab.output_refs.clear(); + } + } + } + pub(super) fn cancel_quit(&mut self) { + self.generation += 1; self.quitting = false; } @@ -53,16 +76,27 @@ impl SessionPersistence { reason: SaveReason, write: impl FnOnce(&Session) -> std::io::Result<()>, ) -> std::io::Result<()> { + let Some(pending) = self.prepare(current, reason) else { return Ok(()) }; + write(&pending.session)?; + self.complete(pending); + Ok(()) + } + + pub(super) fn prepare( + &mut self, + current: Option, + reason: SaveReason, + ) -> Option { // An administrator window must not overwrite the ordinary workspace or // cause its privileged shell command to be restored in a later session. if self.isolated { - return Ok(()); + return None; } let retry_checkpoint = reason == SaveReason::Checkpoint && current.as_ref().is_none_or(|session| session.tabs.is_empty()); let candidate = if self.quitting { if reason != SaveReason::Quit { - return Ok(()); + return None; } self.latest.clone() } else { @@ -81,26 +115,38 @@ impl SessionPersistence { .or_else(|| self.latest.clone()), } }; - let Some(mut session) = candidate else { return Ok(()) }; + let mut session = candidate?; if !retry_checkpoint { session.clean_exit = matches!(reason, SaveReason::WindowClose | SaveReason::Quit); } + self.generation += 1; self.latest = Some(session.clone()); - if self.saved.as_ref() == Some(&session) { + if !self.write_pending && self.saved.as_ref() == Some(&session) { self.quitting |= reason == SaveReason::Quit; - return Ok(()); + return None; } - // A failed final write is cancellable: windows stay live and subsequent - // checkpoints must still be able to save newly confirmed identities. - write(&session)?; - self.saved = Some(session); - self.quitting |= reason == SaveReason::Quit; - Ok(()) + self.write_pending = true; + Some(PendingSave { + session, + generation: self.generation, + quitting: reason == SaveReason::Quit, + }) + } + + // 只在后台写入成功后确认;失败不冻结退出,迟到的确认不覆盖新状态。 + pub(super) fn complete(&mut self, pending: PendingSave) -> bool { + if pending.generation != self.generation { + return false; + } + self.saved = Some(pending.session); + self.write_pending = false; + self.quitting |= pending.quitting; + true } } #[cfg(test)] -mod tests { +pub(super) mod tests { use super::*; #[test] @@ -120,7 +166,7 @@ mod tests { } use crate::session::{AgentSession, LayoutSession, TabSession}; - fn ordinary_window() -> SessionPersistence { + pub(in crate::gpui_shell::workspace) fn ordinary_window() -> SessionPersistence { // Hosted Windows runners can be elevated. These tests exercise ordinary // window persistence; privileged isolation has its own negative test. SessionPersistence { isolated: false, ..SessionPersistence::default() } @@ -290,6 +336,73 @@ mod tests { assert!(state.saved.unwrap().tabs.is_empty()); } + #[test] + fn preparing_background_save_does_not_acknowledge_or_freeze_quit() { + let mut state = ordinary_window(); + let pending = state.prepare(Some(sample_session()), SaveReason::Quit).unwrap(); + assert!(state.saved.is_none()); + assert!(!state.quitting); + assert!(pending.session.clean_exit); + assert!(state.complete(pending)); + assert!(state.saved.as_ref().unwrap().clean_exit); + assert!(state.quitting); + } + + #[test] + fn cancelling_quit_invalidates_its_pending_completion() { + let mut state = ordinary_window(); + let pending = state.prepare(Some(sample_session()), SaveReason::Quit).unwrap(); + state.cancel_quit(); + assert!(!state.complete(pending)); + assert!(!state.quitting); + assert!(state.saved.is_none()); + let checkpoint = state.prepare(Some(sample_session()), SaveReason::Checkpoint).unwrap(); + assert!(!checkpoint.session.clean_exit); + assert!(state.complete(checkpoint)); + } + + #[test] + fn stale_background_completion_cannot_acknowledge_newer_session() { + let mut state = ordinary_window(); + let first = state.prepare(Some(sample_session()), SaveReason::Quit).unwrap(); + let mut changed = sample_session(); + changed.tabs[0].cwd = "D:/new-command".into(); + let second = state.prepare(Some(changed.clone()), SaveReason::Checkpoint).unwrap(); + assert!(!state.complete(first)); + assert!(state.saved.is_none()); + assert!(!state.quitting); + assert!(state.complete(second)); + assert_eq!(state.saved.as_ref(), Some(&changed)); + } + + #[test] + fn failed_background_write_is_retryable_without_remaining_windows() { + let mut state = ordinary_window(); + let _failed = state.prepare(Some(sample_session()), SaveReason::WindowClose).unwrap(); + let retry = state.prepare(None, SaveReason::Checkpoint).unwrap(); + assert!(retry.session.clean_exit); + assert!(state.complete(retry)); + assert_eq!(state.saved.as_ref().unwrap().tabs, sample_session().tabs); + } + + #[test] + fn reverting_to_saved_state_rewrites_disk_after_an_outstanding_write() { + let mut state = ordinary_window(); + let original = sample_session(); + state.save_with(Some(original.clone()), SaveReason::Checkpoint, |_| Ok(())).unwrap(); + let mut changed = original.clone(); + changed.tabs[0].cwd = "D:/discarded".into(); + let obsolete = state.prepare(Some(changed), SaveReason::Checkpoint).unwrap(); + // 旧后台任务可能已写入磁盘,但尚未回到 UI 确认;不能因为内存里的 + // saved 恰好等于新状态,就跳过修复磁盘所需的写入。 + let repair = state + .prepare(Some(original.clone()), SaveReason::Checkpoint) + .expect("an outstanding write may have changed disk"); + assert!(!state.complete(obsolete)); + assert!(state.complete(repair)); + assert_eq!(state.saved.as_ref(), Some(&original)); + } + #[test] fn all_windows_are_combined_with_the_active_tab_offset() { let first = sample_session(); diff --git a/nebula_app/src/gpui_shell/workspace/session_persistence/local_snapshot.rs b/nebula_app/src/gpui_shell/workspace/session_persistence/local_snapshot.rs new file mode 100644 index 000000000..f4077ee4b --- /dev/null +++ b/nebula_app/src/gpui_shell/workspace/session_persistence/local_snapshot.rs @@ -0,0 +1,302 @@ +//! 本机输出与可分享布局分离;编码和不可变引用在后台保存边界生成。 + +use crate::recent_output::{CommandRecord, storage::Archive}; +use crate::session::Session; +use std::collections::BTreeMap; +use std::io; + +pub(in crate::gpui_shell::workspace) struct LocalSnapshot { + pub(in crate::gpui_shell::workspace) session: Session, + pub(in crate::gpui_shell::workspace) outputs: Vec)>>, + pub(in crate::gpui_shell::workspace) window_id: u64, +} + +pub(in crate::gpui_shell::workspace) fn prepare_windows( + mut windows: Vec<(bool, LocalSnapshot)>, +) -> io::Result<(Option, Archive)> { + trim_outputs(&mut windows)?; + let mut sessions = Vec::new(); + let mut panes = BTreeMap::new(); + let mut seen = std::collections::HashSet::new(); + for (active, snapshot) in windows { + if !seen.insert(snapshot.window_id) { + return Err(io::Error::new(io::ErrorKind::InvalidData, "duplicate output window")); + } + let (session, mut archive) = snapshot.prepare()?; + for id in session.tabs.iter().flat_map(|tab| &tab.output_refs).filter(|id| !id.is_empty()) { + let records = archive.take_records(id).ok_or_else(|| { + io::Error::new(io::ErrorKind::InvalidData, "missing prepared output") + })?; + panes.insert(id.clone(), records); + } + sessions.push((active, session)); + } + Ok((crate::session::combine_sessions(sessions), Archive::new(panes))) +} + +/// 在生成不可变引用前淘汰全局最旧记录,不让超额输出阻断布局保存。 +fn trim_outputs(windows: &mut [(bool, LocalSnapshot)]) -> io::Result<()> { + let mut bytes = 1024usize; + let mut oldest = Vec::new(); + for (wi, (_, window)) in windows.iter().enumerate() { + for (ti, tab) in window.outputs.iter().enumerate() { + for (pi, (_, records)) in tab.iter().enumerate() { + crate::recent_output::RecentOutput::validate_records(records) + .map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error))?; + // 引用最长 128 字节,额外预留 JSON 结构及两代交接的封装空间。 + bytes += 256; + for (ri, record) in records.iter().enumerate() { + let size = serde_json::to_vec(record)?.len() + 1; + bytes += size; + oldest.push((record.captured_at, wi, ti, pi, ri, size)); + } + } + } + } + oldest.sort_unstable(); + let mut removed = std::collections::HashSet::new(); + for (_, wi, ti, pi, ri, size) in oldest { + if bytes <= crate::recent_output::storage::MAX_STORE_BYTES { + break; + } + removed.insert((wi, ti, pi, ri)); + bytes = bytes.saturating_sub(size); + } + for (wi, (_, window)) in windows.iter_mut().enumerate() { + for (ti, tab) in window.outputs.iter_mut().enumerate() { + for (pi, (_, records)) in tab.iter_mut().enumerate() { + let mut ri = 0; + records.retain(|_| { + let keep = !removed.contains(&(wi, ti, pi, ri)); + ri += 1; + keep + }); + } + } + } + Ok(()) +} + +impl LocalSnapshot { + pub(in crate::gpui_shell::workspace) fn prepare(mut self) -> io::Result<(Session, Archive)> { + use sha2::{Digest, Sha256}; + + if self.session.tabs.len() != self.outputs.len() { + return Err(io::Error::new(io::ErrorKind::InvalidData, "output tab count mismatch")); + } + let mut panes = BTreeMap::new(); + let mut seen = std::collections::HashSet::new(); + for (tab, outputs) in self.session.tabs.iter_mut().zip(self.outputs) { + let count = tab.layout.as_ref().map_or(1, crate::session::LayoutSession::pane_count); + if count != outputs.len() { + return Err(io::Error::new( + io::ErrorKind::InvalidData, + "output pane count mismatch", + )); + } + tab.output_refs.clear(); + for (pane_id, records) in outputs { + if !seen.insert(pane_id) { + return Err(io::Error::new( + io::ErrorKind::InvalidData, + "duplicate output pane", + )); + } + crate::recent_output::RecentOutput::validate_records(&records) + .map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error))?; + if records.is_empty() { + tab.output_refs.push(String::new()); + continue; + } + let bytes = serde_json::to_vec(&records)?; + let digest = Sha256::digest(&bytes); + let hash = digest.iter().map(|byte| format!("{byte:02x}")).collect::(); + let id = format!("{}-{pane_id}-{hash}", self.window_id); + if panes.insert(id.clone(), records).is_some() { + return Err(io::Error::new( + io::ErrorKind::InvalidData, + "duplicate output pane", + )); + } + tab.output_refs.push(id); + } + } + Ok((self.session, Archive::new(panes))) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::session::TabSession; + + fn snapshot(records: Vec) -> LocalSnapshot { + LocalSnapshot { + session: Session::new( + 0, + vec![ + TabSession::single("C:/same".into(), None, None), + TabSession::single("C:/same".into(), None, None), + ], + ), + outputs: vec![vec![(11, records.clone())], vec![(12, records)]], + window_id: 7, + } + } + + fn records(label: &str) -> Vec { + use nebula_terminal::{ + event::VoidListener, + grid::Dimensions, + term::{Config, Term}, + vte::ansi, + }; + struct Size; + impl Dimensions for Size { + fn total_lines(&self) -> usize { + 4 + } + fn screen_lines(&self) -> usize { + 4 + } + fn columns(&self) -> usize { + 32 + } + } + let mut term = Term::new(Config::default(), &Size, VoidListener); + let mut parser: ansi::Processor = ansi::Processor::new(); + parser.advance(&mut term, label.as_bytes()); + let mut recent = crate::recent_output::RecentOutput::default(); + recent.begin(term.grid()); + let mut records = recent.snapshot(term.grid()); + for record in &mut records { + record.captured_at = 0; + } + records + } + + #[test] + fn oversized_combined_output_evicts_old_records_without_losing_pane_ownership() { + let mut windows = Vec::new(); + for window in 0..96 { + let mut record = serde_json::to_value(records("retained").remove(0)).unwrap(); + // 合成合法的大记录;不同窗格的内容相同也不能共用身份。 + let row = record["prompt"]["rows"][0].clone(); + record["prompt"]["rows"] = serde_json::Value::Array(vec![row; 32]); + let mut record: CommandRecord = serde_json::from_value(record).unwrap(); + // 故意与窗口遍历顺序相反,防止按窗格位置而非时间淘汰。 + record.captured_at = 96 - window; + let mut captured = snapshot(vec![record; 5]); + captured.window_id = window; + windows.push((window == 95, captured)); + } + let (session, mut archive) = prepare_windows(windows).unwrap(); + let path = tempfile::tempdir().unwrap(); + archive.write_to(&path.path().join("output.json")).unwrap(); + assert!( + std::fs::metadata(path.path().join("output.json")).unwrap().len() <= 16 * 1024 * 1024 + ); + let session = session.unwrap(); + assert!(!session.tabs[0].output_refs[0].is_empty(), "newest window survives"); + assert!(session.tabs.last().unwrap().output_refs[0].is_empty(), "oldest window is evicted"); + let mut count = 0; + for tab in &session.tabs { + for reference in &tab.output_refs { + if !reference.is_empty() { + let restored = archive.take_records(reference).expect("exact pane reference"); + count += restored.len(); + assert!(!restored.is_empty()); + } + } + } + assert!(count > 0 && count < 960, "must evict records, not reject the save"); + } + + #[test] + fn combined_windows_keep_active_order_and_exact_output_ownership() { + let first = snapshot(records("first")); + let mut second = snapshot(records("second")); + second.window_id = 8; + second.session.active_tab = 1; + let (session, mut archive) = prepare_windows(vec![(false, first), (true, second)]).unwrap(); + let session = session.unwrap(); + assert_eq!(session.active_tab, 3); + let windows = session.into_update_windows().unwrap(); + assert_eq!(windows.len(), 2); + for (window, label) in windows.iter().zip(["first", "second"]) { + for tab in &window.tabs { + let restored = archive.take_records(&tab.output_refs[0]).unwrap(); + assert_eq!( + serde_json::to_value(restored).unwrap(), + serde_json::to_value(records(label)).unwrap() + ); + } + } + } + + #[test] + fn duplicated_window_identity_cannot_overwrite_another_windows_output() { + assert!( + prepare_windows(vec![ + (false, snapshot(records("first"))), + (true, snapshot(records("second"))), + ]) + .is_err() + ); + assert!(prepare_windows(Vec::new()).unwrap().0.is_none()); + } + + #[test] + fn local_snapshot_refs_are_stable_and_distinct_for_same_directory_panes() { + let records = records("same"); + let (first, mut archive) = snapshot(records.clone()).prepare().unwrap(); + let (again, _) = snapshot(records).prepare().unwrap(); + assert_eq!(first.tabs[0].output_refs, again.tabs[0].output_refs); + assert_ne!(first.tabs[0].output_refs, first.tabs[1].output_refs); + assert!(archive.take_records(&first.tabs[0].output_refs[0]).is_some()); + assert!(archive.take_records(&first.tabs[1].output_refs[0]).is_some()); + assert!(!serde_json::to_string(&first).unwrap().contains(&first.tabs[0].output_refs[0])); + } + + #[test] + fn changed_output_gets_new_reference_without_mutating_previous_snapshot() { + let (before, _) = snapshot(records("before")).prepare().unwrap(); + let (after, _) = snapshot(records("after")).prepare().unwrap(); + assert_ne!(before.tabs[0].output_refs, after.tabs[0].output_refs); + } + + #[test] + fn empty_output_keeps_leaf_position_without_persisting_a_record() { + let (session, _) = snapshot(Vec::new()).prepare().unwrap(); + assert_eq!(session.tabs[0].output_refs, [""]); + assert_eq!(session.tabs[1].output_refs, [""]); + } + + #[test] + fn duplicate_empty_panes_are_rejected_before_publication() { + let mut captured = snapshot(Vec::new()); + captured.outputs[1][0].0 = 11; + assert!(captured.prepare().is_err()); + } + + #[test] + fn invalid_record_is_rejected_before_reference_publication() { + let mut captured = snapshot(records("safe")); + captured.outputs[0][0].1 = vec![records("safe").remove(0); 6]; + assert!(captured.prepare().is_err()); + } + + #[test] + fn mismatched_leaf_capture_does_not_shift_other_pane_references() { + let mut captured = snapshot(records("safe")); + captured.outputs[0].push((13, records("other"))); + assert!(captured.prepare().is_err()); + } + + #[test] + fn mismatched_capture_does_not_publish_misattributed_references() { + let mut snapshot = snapshot(Vec::new()); + snapshot.outputs.pop(); + assert!(snapshot.prepare().is_err()); + } +} diff --git a/nebula_app/src/gpui_shell/workspace/session_recovery.rs b/nebula_app/src/gpui_shell/workspace/session_recovery.rs index 5edfc07be..327f548e7 100644 --- a/nebula_app/src/gpui_shell/workspace/session_recovery.rs +++ b/nebula_app/src/gpui_shell/workspace/session_recovery.rs @@ -12,9 +12,16 @@ impl NebulaWorkspace { ) -> bool { self.recovery_boot_attempts = session.boot_attempts.saturating_add(1); let mut restored = false; + let mut output_targets = Vec::new(); for tab in &session.tabs { - restored |= self.restore_tab(tab, resume_ai, window, cx); + restored |= + self.restore_tab_with_outputs(tab, resume_ai, &mut output_targets, window, cx); } + TerminalView::restore_output_batch( + crate::recent_output::storage::archive_path(), + output_targets, + cx, + ); if restored { self.active = session.active_tab.min(self.tabs.len().saturating_sub(1)); self.focus_active(window, cx); @@ -52,11 +59,17 @@ impl NebulaWorkspace { crate::session::mark_boot_attempt(&mut session); self.recovery_boot_attempts = session.boot_attempts; let mut restored = 0usize; + let mut output_targets = Vec::new(); for tab in &session.tabs { - if self.restore_tab(tab, resume_ai, window, cx) { + if self.restore_tab_with_outputs(tab, resume_ai, &mut output_targets, window, cx) { restored += 1; } } + TerminalView::restore_output_batch( + crate::recent_output::storage::archive_path(), + output_targets, + cx, + ); if restored == 0 { return false; } @@ -80,6 +93,18 @@ impl NebulaWorkspace { resume_ai: bool, window: &mut Window, cx: &mut Context, + ) -> bool { + // 手动工作区导入不读取本机输出,即便调用方误传了本机引用。 + self.restore_tab_with_outputs(tab, resume_ai, &mut Vec::new(), window, cx) + } + + fn restore_tab_with_outputs( + &mut self, + tab: &crate::session::TabSession, + resume_ai: bool, + output_targets: &mut Vec<(String, gpui::WeakEntity)>, + window: &mut Window, + cx: &mut Context, ) -> bool { use crate::session::{LaunchSession, LayoutSession}; @@ -123,6 +148,9 @@ impl NebulaWorkspace { if resume_ai && let Some(agent) = agent { pane.view.update(cx, |view, cx| view.restore_agent(agent.clone(), cx)); } + if let Some(id) = tab.output_refs.get(index).filter(|id| !id.is_empty()) { + output_targets.push((id.clone(), pane.view.downgrade())); + } panes.push(pane); } if panes.is_empty() { @@ -151,6 +179,34 @@ impl NebulaWorkspace { true } + pub(super) fn snapshot_local_session(&self, cx: &App) -> session_persistence::LocalSnapshot { + let outputs = self + .tabs + .iter() + .filter_map(|tab| { + let WorkspaceTab::Terminal { panes, tree, .. } = tab else { return None }; + Some( + tree.leaves() + .iter() + .map(|id| { + let records = panes + .iter() + .find(|pane| pane.id == *id) + .map(|pane| pane.view.read(cx).recent_output_snapshot()) + .unwrap_or_default(); + (*id, records) + }) + .collect(), + ) + }) + .collect(); + session_persistence::LocalSnapshot { + session: self.snapshot_session(cx), + outputs, + window_id: self.runtime_window_id, + } + } + /// 当前工作区 → 共享 v4 快照。设置/文档/图片 tab 不进会话(旧壳同 /// 合同);AI 会话身份优先取 hook 直报的精确 id,退而取可解析的前台 /// 程序名(claude 无 id 恢复成 `--continue`,安全判定在 schema 层)。 @@ -200,6 +256,7 @@ impl NebulaWorkspace { launch: Some(launch), layout: Some(layout), active_pane, + output_refs: Vec::new(), }); } let mut session = Session::new(active_out, tabs); diff --git a/nebula_app/src/gpui_shell/workspace/terminal_activity.rs b/nebula_app/src/gpui_shell/workspace/terminal_activity.rs index 36af3592d..2009684a1 100644 --- a/nebula_app/src/gpui_shell/workspace/terminal_activity.rs +++ b/nebula_app/src/gpui_shell/workspace/terminal_activity.rs @@ -20,14 +20,17 @@ impl NebulaWorkspace { ) { match event { TerminalViewEvent::SessionIdentityChanged => { - if let Err(error) = windowing::save_current_window_session( - self.runtime_window_id, - self.snapshot_session(cx), + let save = windowing::output_persistence::save( + Some(self.snapshot_local_session(cx)), session_persistence::SaveReason::Checkpoint, cx, - ) { - log::warn!("Could not checkpoint native recovery identity: {error}"); - } + ); + cx.spawn(async move |_, _| { + if !matches!(save.await, Ok(true)) { + log::warn!("Could not checkpoint native recovery identity"); + } + }) + .detach(); }, // OSC 7 cwd 与标题共用这条事件。只有当前聚焦 pane 能驱动共享文件树; // 后台 pane 的提示符更新不能把前台目录覆盖掉。 diff --git a/nebula_app/src/gpui_shell/workspace/windowing.rs b/nebula_app/src/gpui_shell/workspace/windowing.rs index 2b9bef628..770a8e715 100644 --- a/nebula_app/src/gpui_shell/workspace/windowing.rs +++ b/nebula_app/src/gpui_shell/workspace/windowing.rs @@ -4,7 +4,11 @@ //! `NebulaWorkspace`。所有外部启动和 runtime 命令先在这里选择窗口,再把 //! 变更投递到对应 workspace,避免多个 receiver 竞争消费同一事件流。 +pub(super) mod output_persistence; mod shutdown; +pub(crate) use output_persistence::clear as clear_command_output; +#[cfg(all(test, feature = "gpui-test-support"))] +pub(crate) use output_persistence::set_command_output_test_path; pub(crate) use shutdown::{quit_all, quit_for_update}; #[cfg(windows)] @@ -137,6 +141,7 @@ pub(crate) struct WindowRegistry { entries: Vec, runtime_hub: crate::runtime_api::RuntimeHub, session_persistence: SessionPersistence, + output_persistence: output_persistence::OutputPersistence, quit_pending: bool, #[cfg(windows)] quick_terminal: Option, @@ -203,6 +208,7 @@ pub(crate) fn initialize(cx: &mut App, runtime_hub: crate::runtime_api::RuntimeH entries: Vec::new(), runtime_hub, session_persistence: SessionPersistence::default(), + output_persistence: output_persistence::OutputPersistence::default(), quit_pending: false, #[cfg(windows)] quick_terminal: None, @@ -214,19 +220,26 @@ pub(crate) fn initialize(cx: &mut App, runtime_hub: crate::runtime_api::RuntimeH let quit_subscription = cx.on_app_quit(|cx| { #[cfg(windows)] quick_window::persist_quick_size(cx); - if let Err(error) = save_combined_session(cx, true) { - log::warn!("Final session write: {error}"); + let save = output_persistence::save(None, SaveReason::Quit, cx); + async move { + if !matches!(save.await, Ok(true)) { + log::warn!("Final session write failed or was superseded"); + } } - async {} }); let closed_subscription = cx.on_window_closed(|cx, _window_id| { // A tab transfer can close its source while the destination workspace // is still borrowed. Snapshot all windows only after that update ends. cx.defer(save_after_window_closed); }); - cx.global_mut::() - ._subscriptions - .extend([quit_subscription, closed_subscription]); + let settings_subscription = cx.observe_global::(|cx| { + output_persistence::settings_changed(cx); + }); + cx.global_mut::()._subscriptions.extend([ + quit_subscription, + closed_subscription, + settings_subscription, + ]); cx.spawn(async move |cx| { loop { @@ -242,9 +255,7 @@ fn save_after_window_closed(cx: &mut App) { // 快速终端不能改变普通 session 的生命周期:最后一扇普通窗口关闭后, // 即使隐藏的 Quake 窗口仍存活,也不能再补写一份空的普通 session。 if cx.global::().entries.iter().any(|entry| entry.role == WindowRole::Regular) { - if let Err(error) = save_combined_session(cx, false) { - log::warn!("Session checkpoint: {error}"); - } + output_persistence::checkpoint(cx); } } @@ -1091,6 +1102,21 @@ fn dispatch_runtime(dispatch: Arc, cx: &mut App) { return; }, }; + if let RuntimeCommand::CloseWindow { window_id } = &dispatch.command { + let close = entry + .workspace + .update(cx, |workspace, cx| workspace.runtime_close_window(*window_id, cx)); + cx.spawn(async move |_| { + let response = match close { + Ok(Ok(close)) => close.await, + Ok(Err(error)) => Err(error), + Err(error) => Err(ApiError::new("target_not_found", error.to_string())), + }; + dispatch.respond(response); + }) + .detach(); + return; + } let command = dispatch.command.clone(); let workspace = entry.workspace.clone(); let result = entry.handle.update(cx, move |_, window, cx| { @@ -1360,10 +1386,10 @@ pub(crate) fn publish_runtime_snapshot_with_current( pub(crate) fn autosave_tick(cx: &mut App) { #[cfg(windows)] quick_window::persist_quick_size(cx); - if let Err(error) = save_combined_session(cx, false) { - log::warn!("Session checkpoint: {error}"); - return; - } + output_persistence::checkpoint(cx); +} + +fn acknowledge_session_restore(cx: &App) { let workspaces = cx .global::() .entries @@ -1415,27 +1441,6 @@ fn combined_session( combine_sessions(sessions) } -fn save_combined_session(cx: &mut App, clean: bool) -> std::io::Result<()> { - let session = combined_session(None, cx); - let reason = if clean { SaveReason::Quit } else { SaveReason::Checkpoint }; - cx.global_mut::().session_persistence.save(session, reason) -} - -pub(super) fn save_current_window_session( - runtime_window_id: u64, - session: crate::session::Session, - reason: SaveReason, - cx: &mut App, -) -> std::io::Result<()> { - if !cx.global::().entries.iter().any(|entry| { - entry.runtime_window_id == runtime_window_id && entry.role == WindowRole::Regular - }) { - return Ok(()); - } - let session = combined_session(Some((runtime_window_id, session)), cx); - cx.global_mut::().session_persistence.save(session, reason) -} - pub(crate) fn move_tab_to_new_window(payload: CrossWindowTabDrag, cx: &mut App) { let opened = open_workspace_window(cx, WorkspaceStartup::Empty, None, None, true, WindowRole::Regular); @@ -1501,17 +1506,11 @@ fn unregister(runtime_window_id: u64, cx: &mut App) { } } -pub(super) fn close_saved_workspace_window( +pub(super) fn remove_saved_workspace_window( runtime_window_id: u64, - session: crate::session::Session, window: &mut Window, cx: &mut App, ) { - if let Err(error) = - save_current_window_session(runtime_window_id, session, SaveReason::WindowClose, cx) - { - log::warn!("Could not checkpoint moved window: {error}"); - } unregister(runtime_window_id, cx); window.remove_window(); } diff --git a/nebula_app/src/gpui_shell/workspace/windowing/output_persistence.rs b/nebula_app/src/gpui_shell/workspace/windowing/output_persistence.rs new file mode 100644 index 000000000..9a319e1e1 --- /dev/null +++ b/nebula_app/src/gpui_shell/workspace/windowing/output_persistence.rs @@ -0,0 +1,643 @@ +//! 本机快照在 UI 线程采集;编码、sidecar 和会话提交交给后台执行器。 + +use super::super::session_persistence::{LocalSnapshot, prepare_windows}; +use super::*; +use crate::recent_output::storage::{Archive, OutputStore}; +use futures::{FutureExt, channel::oneshot, future::Shared}; +use std::io; + +pub(super) struct OutputPersistence { + store: OutputStore, + session_path: PathBuf, + tail: Option>>, + latest_archive: Option, + clear_epoch: u64, +} + +impl Default for OutputPersistence { + fn default() -> Self { + Self { + store: OutputStore::new(crate::recent_output::storage::archive_path()), + session_path: crate::session::session_path(), + tail: None, + latest_archive: None, + clear_epoch: 0, + } + } +} + +pub(super) fn settings_changed(cx: &mut App) { + if cx + .try_global::() + .is_none_or(|settings| settings.command_output_enabled) + { + return; + } + let registry = cx.global_mut::(); + registry.session_persistence.clear_output_references(); + let state = &mut registry.output_persistence; + state.clear_epoch += 1; + state.latest_archive = None; + // 同时拦截尚未编码的队列任务和已经交给后台的写入。 + state.store.next_generation(); +} + +fn capture(mut current: Option, cx: &App) -> Vec<(bool, LocalSnapshot)> { + let mut entries = cx + .global::() + .entries + .iter() + .filter(|entry| entry.role == WindowRole::Regular) + .cloned() + .collect::>(); + entries.sort_by_key(|entry| entry.runtime_window_id); + let active = cx + .active_window() + .filter(|handle| entries.iter().any(|entry| entry.handle == *handle)) + .or_else(|| { + entries.iter().max_by_key(|entry| entry.last_activated).map(|entry| entry.handle) + }); + entries + .into_iter() + .filter_map(|entry| { + let snapshot = if current + .as_ref() + .is_some_and(|snapshot| snapshot.window_id == entry.runtime_window_id) + { + current.take()? + } else { + entry.workspace.upgrade()?.read(cx).snapshot_local_session(cx) + }; + Some((active == Some(entry.handle), snapshot)) + }) + .collect() +} + +/// 按采集顺序串行提交,关窗/退出必须等待成功,不能把已入队当作已保存。 +pub(in crate::gpui_shell::workspace) fn save( + current: Option, + reason: SaveReason, + cx: &mut App, +) -> gpui::Task> { + let snapshots = capture(current, cx); + enqueue(snapshots, reason, cx) +} + +fn enqueue( + snapshots: Vec<(bool, LocalSnapshot)>, + reason: SaveReason, + cx: &mut App, +) -> gpui::Task> { + let epoch = cx.global::().output_persistence.clear_epoch; + let (done, receiver) = oneshot::channel(); + let previous = + cx.global_mut::().output_persistence.tail.replace(receiver.shared()); + cx.spawn(async move |cx| { + let result = async { + if let Some(previous) = previous { + let _ = previous.await; + } + let (mut session, mut archive) = + cx.background_executor().spawn(async move { prepare_windows(snapshots) }).await?; + let job = cx.update(|cx| { + let enabled = + cx.global::().command_output_enabled; + let registry = cx.global_mut::(); + // 清除前采集、清除后才完成编码的任务只能保存布局。 + if epoch != registry.output_persistence.clear_epoch || !enabled { + if let Some(session) = &mut session { + for tab in &mut session.tabs { + tab.output_refs.clear(); + } + } + archive = Archive::new(Default::default()); + } + // 最后一扇窗口已关闭时,沿用同一份快照的输出,不用空档覆盖它。 + if session.as_ref().is_some_and(|session| !session.tabs.is_empty()) + || reason == SaveReason::TabsClosed + { + registry.output_persistence.latest_archive = Some(archive); + } + let pending = registry.session_persistence.prepare(session, reason)?; + let archive = registry + .output_persistence + .latest_archive + .clone() + .unwrap_or_else(|| Archive::new(Default::default())); + let store = registry.output_persistence.store.clone(); + let generation = store.next_generation(); + Some(( + pending, + archive, + store, + generation, + registry.output_persistence.session_path.clone(), + )) + }); + let Some((pending, archive, store, generation, path)) = job else { return Ok(true) }; + let (pending, result) = cx + .background_executor() + .spawn(async move { + let references = crate::session::load_local_from(&path) + .map(|session| { + session + .tabs + .into_iter() + .flat_map(|tab| tab.output_refs) + .collect::>() + }) + .unwrap_or_default(); + let result = + store.save_referenced(generation, &archive, Some(&references), || { + crate::session::save_local_to(&path, &pending.session) + }); + (pending, result) + }) + .await; + if !result? { + return Ok(false); + } + Ok(cx.update(|cx| { + cx.global_mut::().session_persistence.complete(pending) + })) + } + .await; + let _ = done.send(()); + result + }) +} + +/// 清除作用于所有本机窗格,不清屏、不关终端;任务不依赖设置页存活。 +pub(crate) fn clear(cx: &mut App) -> gpui::Task> { + let views = cx + .global::() + .entries + .iter() + .filter_map(|entry| entry.workspace.upgrade()) + .flat_map(|workspace| { + workspace + .read(cx) + .tabs + .iter() + .flat_map(|tab| match tab { + WorkspaceTab::Terminal { panes, .. } => { + panes.iter().map(|pane| pane.view.clone()).collect() + }, + _ => Vec::new(), + }) + .collect::>() + }) + .collect::>(); + for view in views { + view.update(cx, |view, _| view.clear_recent_output()); + } + let registry = cx.global_mut::(); + registry.session_persistence.clear_output_references(); + let state = &mut registry.output_persistence; + state.clear_epoch += 1; + state.latest_archive = None; + state.store.next_generation(); + let store = state.store.clone(); + let (done, receiver) = oneshot::channel(); + let previous = state.tail.replace(receiver.shared()); + cx.spawn(async move |cx| { + if let Some(previous) = previous { + let _ = previous.await; + } + let result = cx + .background_executor() + .spawn(async move { store.clear(store.next_generation()) }) + .await; + let _ = done.send(()); + result + }) +} + +#[cfg(all(test, feature = "gpui-test-support"))] +pub(crate) fn set_command_output_test_path(cx: &mut App, path: PathBuf) { + let state = &mut cx.global_mut::().output_persistence; + state.session_path = path.with_file_name("session.json"); + state.store = OutputStore::new(path); +} + +#[cfg(all(test, feature = "gpui-test-support"))] +mod tests { + use super::*; + + #[gpui::test] + fn clear_invalidates_queued_output_and_does_not_erase_later_commands( + cx: &mut gpui::TestAppContext, + ) { + super::super::transfer_tests::initialize_test(cx); + let dir = tempfile::tempdir().unwrap(); + let output = dir.path().join("output.json"); + let make_snapshot = |label: &str| { + use nebula_terminal::{ + event::VoidListener, + term::{Config, Term}, + vte::ansi, + }; + let mut term = Term::new( + Config::default(), + &crate::gpui_shell::terminal::session::GridSize { columns: 80, screen_lines: 24 }, + VoidListener, + ); + let mut parser: ansi::Processor = ansi::Processor::new(); + let mut recent = crate::recent_output::RecentOutput::default(); + parser.advance(&mut term, label.as_bytes()); + recent.begin(term.grid()); + parser.advance(&mut term, b"\r\nresult\r\n"); + recent.finish(term.grid()); + LocalSnapshot { + session: crate::session::Session::new( + 0, + vec![crate::session::TabSession::single("C:/test".into(), None, None)], + ), + outputs: vec![vec![(1, recent.snapshot(term.grid()))]], + window_id: 1, + } + }; + let (old, clearing) = cx.update(|cx| { + let mut settings = + crate::gpui_shell::config::Settings::load(nebula_settings::ThemeName::Nord); + settings.command_output_enabled = true; + cx.set_global(settings); + let registry = cx.global_mut::(); + registry.session_persistence = + super::super::super::session_persistence::tests::ordinary_window(); + registry.output_persistence.store = OutputStore::new(output.clone()); + registry.output_persistence.session_path = dir.path().join("session.json"); + let old = enqueue(vec![(true, make_snapshot("old"))], SaveReason::Checkpoint, cx); + let clearing = clear(cx); + (old, clearing) + }); + cx.run_until_parked(); + let _ = old.now_or_never().expect("old save finishes"); + assert!(clearing.now_or_never().unwrap().unwrap()); + assert!(!output.exists(), "queued snapshots must not resurrect cleared output"); + let snapshot = make_snapshot("new"); + let expected = snapshot.outputs[0][0].1.clone(); + let new = cx.update(|cx| enqueue(vec![(true, snapshot)], SaveReason::Checkpoint, cx)); + cx.run_until_parked(); + assert!(new.now_or_never().unwrap().unwrap()); + let session: serde_json::Value = + serde_json::from_slice(&std::fs::read(dir.path().join("session.json")).unwrap()) + .unwrap(); + let reference = session["local_output_refs"][0][0].as_str().unwrap(); + let mut archive = Archive::read_from(&output).unwrap(); + let restored = archive.take_records(reference).expect("new command is published"); + assert_eq!( + serde_json::to_value(restored).unwrap(), + serde_json::to_value(expected).unwrap() + ); + } + + #[gpui::test] + fn runtime_close_waits_for_publication_and_reports_write_failure( + cx: &mut gpui::TestAppContext, + ) { + super::super::transfer_tests::initialize_test(cx); + let dir = tempfile::tempdir().unwrap(); + let blocker = dir.path().join("not-a-directory"); + std::fs::write(&blocker, b"block").unwrap(); + let (handle, workspace, close) = cx.update(|cx| { + let (id, workspace) = super::super::transfer_tests::open_test_window(cx, 1); + let registry = cx.global_mut::(); + registry.session_persistence = + super::super::super::session_persistence::tests::ordinary_window(); + registry.output_persistence.store = OutputStore::new(blocker.join("output.json")); + registry.output_persistence.session_path = dir.path().join("session.json"); + let handle = entry_by_id(id, cx).unwrap().handle; + let close = workspace + .update(cx, |workspace, cx| workspace.runtime_close_window(Some(id), cx)) + .unwrap(); + assert!(cx.windows().contains(&handle)); + (handle, workspace, close) + }); + cx.run_until_parked(); + let result = close.now_or_never().expect("close task must finish"); + assert_eq!(result.unwrap_err().code, "session_save_failed"); + cx.update(|cx| { + assert!(cx.windows().contains(&handle)); + assert!(!workspace.read(cx).window_close_pending); + cx.global_mut::().output_persistence.store = + OutputStore::new(dir.path().join("output.json")); + }); + let close = cx + .update(|cx| { + workspace.update(cx, |workspace, cx| workspace.runtime_close_window(None, cx)) + }) + .unwrap(); + cx.run_until_parked(); + let result = close.now_or_never().expect("close task must finish").unwrap(); + assert_eq!(result["action"]["closed"], true); + assert!(dir.path().join("output.json").is_file()); + assert!(dir.path().join("session.json").is_file()); + cx.update(|cx| assert!(!cx.windows().contains(&handle))); + } + + #[gpui::test] + fn application_quit_publishes_output_before_finishing(cx: &mut gpui::TestAppContext) { + super::super::transfer_tests::initialize_test(cx); + let dir = tempfile::tempdir().unwrap(); + let output = dir.path().join("output.json"); + let session = dir.path().join("session.json"); + cx.update(|cx| { + super::super::transfer_tests::open_test_window(cx, 1); + let registry = cx.global_mut::(); + registry.session_persistence = + super::super::super::session_persistence::tests::ordinary_window(); + registry.output_persistence.store = OutputStore::new(output.clone()); + registry.output_persistence.session_path = session.clone(); + super::super::shutdown::quit_all(cx); + assert!(!session.exists()); + }); + cx.run_until_parked(); + assert!(output.is_file(), "quit must save the output sidecar"); + let value: serde_json::Value = + serde_json::from_slice(&std::fs::read(session).unwrap()).unwrap(); + assert_eq!(value["tabs"].as_array().unwrap().len(), 1); + assert_eq!(value["clean_exit"], true); + } + + #[gpui::test] + fn application_quit_output_failure_is_retryable(cx: &mut gpui::TestAppContext) { + super::super::transfer_tests::initialize_test(cx); + let dir = tempfile::tempdir().unwrap(); + let blocker = dir.path().join("not-a-directory"); + std::fs::write(&blocker, b"block").unwrap(); + cx.update(|cx| { + super::super::transfer_tests::open_test_window(cx, 1); + let registry = cx.global_mut::(); + registry.session_persistence = + super::super::super::session_persistence::tests::ordinary_window(); + registry.output_persistence.store = OutputStore::new(blocker.join("output.json")); + registry.output_persistence.session_path = dir.path().join("session.json"); + super::super::shutdown::quit_all(cx); + }); + cx.run_until_parked(); + cx.update(|cx| { + assert!(!cx.global::().quit_pending, "failed save must cancel quit") + }); + assert!(!dir.path().join("session.json").exists()); + } + + #[gpui::test] + fn window_close_waits_for_output_and_session_publication(cx: &mut gpui::TestAppContext) { + super::super::transfer_tests::initialize_test(cx); + let dir = tempfile::tempdir().unwrap(); + let output = dir.path().join("output.json"); + let session = dir.path().join("session.json"); + let handle = cx.update(|cx| { + let (id, workspace) = super::super::transfer_tests::open_test_window(cx, 1); + let registry = cx.global_mut::(); + registry.session_persistence = + super::super::super::session_persistence::tests::ordinary_window(); + registry.output_persistence.store = OutputStore::new(output.clone()); + registry.output_persistence.session_path = session.clone(); + let handle = entry_by_id(id, cx).unwrap().handle; + handle + .update(cx, |_, window, cx| { + workspace.update(cx, |workspace, cx| { + assert!(!workspace.close_window_after_documents(window, cx)); + assert!(workspace.window_close_pending); + }) + }) + .unwrap(); + assert!(!session.exists()); + handle + }); + cx.run_until_parked(); + assert!(output.is_file(), "closing must publish the output sidecar"); + let value: serde_json::Value = + serde_json::from_slice(&std::fs::read(session).unwrap()).unwrap(); + assert_eq!(value["tabs"].as_array().unwrap().len(), 1); + assert_eq!(value["clean_exit"], true); + cx.update(|cx| assert!(!cx.windows().contains(&handle))); + } + + #[gpui::test] + fn window_close_preserves_document_edited_while_save_is_pending(cx: &mut gpui::TestAppContext) { + check_pending_close_draft(cx, false); + } + + #[gpui::test] + fn runtime_close_preserves_document_edited_while_save_is_pending( + cx: &mut gpui::TestAppContext, + ) { + check_pending_close_draft(cx, true); + } + + fn check_pending_close_draft(cx: &mut gpui::TestAppContext, runtime: bool) { + super::super::transfer_tests::initialize_test(cx); + let dir = tempfile::tempdir().unwrap(); + let document = dir.path().join("draft.md"); + std::fs::write(&document, "original").unwrap(); + let (handle, workspace) = cx.update(|cx| { + let (id, workspace) = super::super::transfer_tests::open_test_window(cx, 1); + let handle = entry_by_id(id, cx).unwrap().handle; + handle + .update(cx, |_, window, cx| { + workspace.update(cx, |workspace, cx| { + workspace.open_document_at_startup(document.clone(), window, cx); + }); + }) + .unwrap(); + (handle, workspace) + }); + cx.run_until_parked(); + let (release, waiting) = oneshot::channel(); + cx.update(|cx| { + let registry = cx.global_mut::(); + registry.session_persistence = + super::super::super::session_persistence::tests::ordinary_window(); + registry.output_persistence.store = OutputStore::new(dir.path().join("output.json")); + registry.output_persistence.session_path = dir.path().join("session.json"); + registry.output_persistence.tail = Some(waiting.shared()); + handle + .update(cx, |_, window, cx| { + workspace.update(cx, |workspace, cx| { + if runtime { + workspace.runtime_close_window(None, cx).unwrap().detach(); + } else { + assert!(!workspace.should_close_window(window, cx)); + } + assert!(workspace.window_close_pending); + }); + }) + .unwrap(); + }); + cx.run_until_parked(); + let file = cx.update(|cx| { + let file = workspace.read(cx).tabs.iter().find_map(|tab| tab.file_editor(cx)).unwrap(); + handle + .update(cx, |_, window, cx| { + crate::gpui_shell::file_editor::tests::replace_draft( + &file, + "new unsaved draft", + window, + cx, + ); + }) + .unwrap(); + file + }); + cx.run_until_parked(); + cx.update(|cx| assert!(file.read(cx).is_dirty())); + release.send(()).unwrap(); + cx.run_until_parked(); + cx.update(|cx| { + assert!( + cx.windows().contains(&handle), + "new draft must prevent asynchronous window destruction" + ); + assert!(!workspace.read(cx).window_close_pending); + assert_eq!(file.read(cx).draft(cx).as_ref(), "new unsaved draft"); + }); + assert_eq!(std::fs::read_to_string(document).unwrap(), "original"); + } + + #[gpui::test] + fn disabling_then_enabling_output_invalidates_queued_snapshot(cx: &mut gpui::TestAppContext) { + super::super::transfer_tests::initialize_test(cx); + let dir = tempfile::tempdir().unwrap(); + let output = dir.path().join("output.json"); + let session = dir.path().join("session.json"); + let (release, waiting) = oneshot::channel(); + let save = cx.update(|cx| { + use nebula_terminal::{ + event::VoidListener, + term::{Config, Term}, + vte::ansi, + }; + let mut term = Term::new( + Config::default(), + &crate::gpui_shell::terminal::session::GridSize { columns: 80, screen_lines: 24 }, + VoidListener, + ); + let mut parser: ansi::Processor = ansi::Processor::new(); + parser.advance(&mut term, b"old command"); + let mut recent = crate::recent_output::RecentOutput::default(); + recent.begin(term.grid()); + parser.advance(&mut term, b"\r\nold output\r\n"); + recent.finish(term.grid()); + let mut settings = + crate::gpui_shell::config::Settings::load(nebula_settings::ThemeName::Nord); + settings.command_output_enabled = true; + cx.set_global(settings); + let registry = cx.global_mut::(); + registry.session_persistence = + super::super::super::session_persistence::tests::ordinary_window(); + registry.output_persistence.store = OutputStore::new(output.clone()); + registry.output_persistence.session_path = session.clone(); + registry.output_persistence.tail = Some(waiting.shared()); + enqueue( + vec![( + true, + LocalSnapshot { + session: crate::session::Session::new( + 0, + vec![crate::session::TabSession::single("C:/test".into(), None, None)], + ), + outputs: vec![vec![(1, recent.snapshot(term.grid()))]], + window_id: 1, + }, + )], + SaveReason::Checkpoint, + cx, + ) + }); + cx.run_until_parked(); + cx.update(|cx| { + cx.global_mut::().command_output_enabled = false + }); + cx.run_until_parked(); + cx.update(|cx| { + cx.global_mut::().command_output_enabled = true + }); + cx.run_until_parked(); + release.send(()).unwrap(); + cx.run_until_parked(); + assert!(save.now_or_never().unwrap().unwrap()); + let restored = crate::session::load_local_from(&session).unwrap(); + assert!( + restored.tabs.iter().all(|tab| tab.output_refs.is_empty()), + "re-enabling must not publish pre-disable snapshots" + ); + } + + #[gpui::test] + fn failed_output_write_keeps_window_open_for_retry(cx: &mut gpui::TestAppContext) { + super::super::transfer_tests::initialize_test(cx); + let dir = tempfile::tempdir().unwrap(); + let blocker = dir.path().join("not-a-directory"); + std::fs::write(&blocker, b"block").unwrap(); + let session = dir.path().join("session.json"); + let (handle, workspace) = cx.update(|cx| { + let (id, workspace) = super::super::transfer_tests::open_test_window(cx, 1); + let registry = cx.global_mut::(); + registry.session_persistence = + super::super::super::session_persistence::tests::ordinary_window(); + registry.output_persistence.store = OutputStore::new(blocker.join("output.json")); + registry.output_persistence.session_path = session.clone(); + let handle = entry_by_id(id, cx).unwrap().handle; + handle + .update(cx, |_, window, cx| { + workspace.update(cx, |workspace, cx| { + assert!(!workspace.close_window_after_documents(window, cx)); + }) + }) + .unwrap(); + (handle, workspace) + }); + cx.run_until_parked(); + cx.update(|cx| { + assert!( + cx.windows().contains(&handle), + "a failed save must not destroy the live terminal" + ); + assert!(!workspace.read(cx).window_close_pending, "close must be retryable"); + }); + assert!(!session.exists(), "failed sidecar must not publish new session references"); + } + + #[gpui::test] + fn autosave_tick_publishes_through_background_output_store(cx: &mut gpui::TestAppContext) { + super::super::transfer_tests::initialize_test(cx); + let dir = tempfile::tempdir().unwrap(); + let output = dir.path().join("output.json"); + let session = dir.path().join("session.json"); + cx.update(|cx| { + super::super::transfer_tests::open_test_window(cx, 1); + let registry = cx.global_mut::(); + registry.session_persistence = + super::super::super::session_persistence::tests::ordinary_window(); + registry.output_persistence.store = OutputStore::new(output.clone()); + registry.output_persistence.session_path = session.clone(); + autosave_tick(cx); + assert!(!session.exists(), "autosave must not perform disk I/O in the UI callback"); + }); + cx.run_until_parked(); + assert!(output.is_file(), "autosave must write sidecar before session publication"); + let value: serde_json::Value = + serde_json::from_slice(&std::fs::read(session).unwrap()).unwrap(); + assert_eq!(value["tabs"].as_array().unwrap().len(), 1); + assert_eq!(value["clean_exit"], false); + } +} + +pub(super) fn checkpoint(cx: &mut App) { + let registry = cx.global::(); + if registry.quit_pending + || registry.output_persistence.tail.as_ref().is_some_and(|tail| tail.peek().is_none()) + { + return; + } + let save = save(None, SaveReason::Checkpoint, cx); + cx.spawn(async move |cx| match save.await { + Ok(true) => cx.update(|cx| super::acknowledge_session_restore(cx)), + Ok(false) => {}, + Err(error) => log::warn!("Could not checkpoint command output and session: {error}"), + }) + .detach(); +} diff --git a/nebula_app/src/gpui_shell/workspace/windowing/shutdown.rs b/nebula_app/src/gpui_shell/workspace/windowing/shutdown.rs index 934a054d3..0469160e4 100644 --- a/nebula_app/src/gpui_shell/workspace/windowing/shutdown.rs +++ b/nebula_app/src/gpui_shell/workspace/windowing/shutdown.rs @@ -53,7 +53,7 @@ fn request_quit(update: Option, cx: &mut App) } else { None }; - cx.update(|cx| { + let save = cx.update(|cx| { // Recheck the current pane set after asynchronous preparation. A // window/pane opened during the handshake also needs a native target. let identities_ready = cx @@ -71,15 +71,24 @@ fn request_quit(update: Option, cx: &mut App) }); if !ready || !identities_ready { abort_quit(Message::SessionIdentityPending, cx); - return; + return None; } if !documents_unchanged(&approved, cx) { abort_quit(Message::UpdateDraftChanged, cx); - return; + return None; } - if let Err(error) = save_combined_session(cx, true) { - log::warn!("Shutdown cancelled because session save failed: {error}"); - abort_quit(Message::SessionSaveFailed, cx); + Some(output_persistence::save(None, SaveReason::Quit, cx)) + }); + let Some(save) = save else { return }; + if !matches!(save.await, Ok(true)) { + cx.update(|cx| abort_quit(Message::SessionSaveFailed, cx)); + return; + } + cx.update(|cx| { + // A document can change while the output is being written. + if !documents_unchanged(&approved, cx) { + cx.global_mut::().session_persistence.cancel_quit(); + abort_quit(Message::UpdateDraftChanged, cx); return; } if let Some(prepared) = prepared.as_mut() { diff --git a/nebula_app/src/gpui_shell/workspace/windowing/transfer_tests.rs b/nebula_app/src/gpui_shell/workspace/windowing/transfer_tests.rs index 220c87da3..ba86382f3 100644 --- a/nebula_app/src/gpui_shell/workspace/windowing/transfer_tests.rs +++ b/nebula_app/src/gpui_shell/workspace/windowing/transfer_tests.rs @@ -2,7 +2,7 @@ use super::*; use crate::gpui_shell::terminal::view::TerminalLaunch; use gpui::TestAppContext; -fn initialize_test(cx: &mut TestAppContext) { +pub(super) fn initialize_test(cx: &mut TestAppContext) { cx.update(|cx| { gpui_component::init(cx); crate::gpui_shell::math_view::register(cx); @@ -12,7 +12,7 @@ fn initialize_test(cx: &mut TestAppContext) { }); } -fn open_test_window(cx: &mut App, count: usize) -> (u64, Entity) { +pub(super) fn open_test_window(cx: &mut App, count: usize) -> (u64, Entity) { let (id, workspace) = open_workspace_window(cx, WorkspaceStartup::Empty, None, None, false, WindowRole::Regular) .unwrap(); diff --git a/nebula_app/src/main.rs b/nebula_app/src/main.rs index cf44c5a22..d8a13224d 100644 --- a/nebula_app/src/main.rs +++ b/nebula_app/src/main.rs @@ -96,6 +96,7 @@ mod polling; mod process_tree; mod provider_test; mod proxy_test; +mod recent_output; mod remote_dirs; mod render_cache; #[cfg(feature = "legacy-shell")] diff --git a/nebula_app/src/recent_output.rs b/nebula_app/src/recent_output.rs new file mode 100644 index 000000000..a6c082268 --- /dev/null +++ b/nebula_app/src/recent_output.rs @@ -0,0 +1,256 @@ +//! 逐终端的有界命令显示记录;调用方只提交已确认的 shell 命令。 + +use nebula_terminal::grid::snapshot::DisplaySnapshot; +use nebula_terminal::grid::{Dimensions, Grid}; +use nebula_terminal::index::Line; +use nebula_terminal::term::cell::{Cell, Flags}; +use serde::{Deserialize, Serialize}; + +pub(crate) mod storage; + +const MAX_RECORD_BYTES: usize = 256 * 1024; +const MAX_CAPTURE_CELLS: usize = 4096; + +// 仅在保存边界编码,按整行缩小,避免切断 UTF-8 或宽字符。 +fn capture_bounded( + grid: &Grid, + range: std::ops::Range, + byte_budget: usize, +) -> DisplaySnapshot { + let mut low = 0; + let mut high = MAX_CAPTURE_CELLS / grid.columns(); + let mut best = DisplaySnapshot::capture(grid, range.clone(), 0); + while low <= high { + let rows = low + (high - low) / 2; + let candidate = DisplaySnapshot::capture(grid, range.clone(), rows * grid.columns()); + if serde_json::to_vec(&candidate).is_ok_and(|bytes| bytes.len() <= byte_budget) { + best = candidate; + low = rows + 1; + } else if rows == 0 { + break; + } else { + high = rows - 1; + } + } + best +} + +#[derive(Clone, Debug, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub(crate) struct CommandRecord { + #[serde(default)] + pub(crate) captured_at: u64, + prompt: DisplaySnapshot, + output: DisplaySnapshot, +} + +#[derive(Default)] +pub(crate) struct RecentOutput { + records: Vec, + active_output_start: Option, +} + +impl RecentOutput { + pub(crate) fn begin(&mut self, grid: &Grid) { + let mut start = grid.cursor.point.line; + while start.0 > -(grid.history_size() as i32) + && grid[Line(start.0 - 1)][nebula_terminal::index::Column(grid.columns() - 1)] + .flags + .contains(Flags::WRAPLINE) + { + start.0 -= 1; + } + let end = Line(grid.cursor.point.line.0 + 1); + if self.records.len() == 5 { + self.records.remove(0); + } + self.records.push(CommandRecord { + captured_at: std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .map_or(0, |duration| duration.as_micros().min(u64::MAX as u128) as u64), + prompt: capture_bounded(grid, start..end, MAX_RECORD_BYTES / 2), + output: DisplaySnapshot::capture(grid, end..end, 0), + }); + self.active_output_start = Some(grid.scrolled_out() + grid.history_size() + end.0 as usize); + } + + pub(crate) fn finish(&mut self, grid: &Grid) { + if let Some(output) = self.capture_active(grid, false) { + if let Some(record) = self.records.last_mut() { + record.output = output; + } + } + self.active_output_start = None; + } + + pub(crate) fn snapshot(&self, grid: &Grid) -> Vec { + let mut records = self.records.clone(); + if let Some(output) = self.capture_active(grid, true) { + if let Some(record) = records.last_mut() { + record.output = output; + } + } + records + } + + fn capture_active(&self, grid: &Grid, include_cursor: bool) -> Option { + let absolute = self.active_output_start?; + let origin = grid.scrolled_out() + grid.history_size(); + let start = (absolute as i128 - origin as i128).clamp(i32::MIN as i128, i32::MAX as i128); + let end = grid.cursor.point.line.0 + i32::from(include_cursor); + let prompt_bytes = serde_json::to_vec(&self.records.last()?.prompt).ok()?.len(); + // 为字段名、标点及采集时间预留空间,确保整条记录仍在预算内。 + let budget = MAX_RECORD_BYTES.saturating_sub(prompt_bytes + 64); + Some(capture_bounded(grid, Line(start as i32)..Line(end), budget)) + } + pub(crate) fn try_from_records(records: Vec) -> Result { + Self::validate_records(&records)?; + Ok(Self { records, active_output_start: None }) + } + + pub(crate) fn validate_records(records: &[CommandRecord]) -> Result<(), &'static str> { + if records.len() > 5 { + return Err("too many command records"); + } + for record in records { + let bytes = serde_json::to_vec(record).map_err(|_| "invalid command record")?; + if bytes.len() > MAX_RECORD_BYTES { + return Err("command record exceeds byte budget"); + } + } + Ok(()) + } + pub(crate) fn restore(&self, grid: &mut Grid) -> Result<(), &'static str> { + // 每次静态导入都插在现有历史之前,因此从最新记录的输出开始。 + for record in self.records.iter().rev() { + record.output.restore_scrollback(grid)?; + record.prompt.restore_scrollback(grid)?; + } + Ok(()) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use nebula_terminal::event::VoidListener; + use nebula_terminal::grid::Dimensions; + use nebula_terminal::index::{Column, Line}; + use nebula_terminal::term::{Config, Term}; + use nebula_terminal::vte::ansi; + + struct Size; + impl Dimensions for Size { + fn total_lines(&self) -> usize { + 4 + } + fn screen_lines(&self) -> usize { + 4 + } + fn columns(&self) -> usize { + 32 + } + } + + #[test] + fn retains_five_commands_with_output_in_order_without_reexecuting() { + let mut term = Term::new(Config::default(), &Size, VoidListener); + let mut parser: ansi::Processor = ansi::Processor::new(); + let mut recent = RecentOutput::default(); + for index in 0..7 { + parser.advance(&mut term, format!("C:>echo {index}").as_bytes()); + recent.begin(term.grid()); + parser.advance(&mut term, format!("\r\nresult{index}\r\n").as_bytes()); + recent.finish(term.grid()); + } + let records = recent.snapshot(term.grid()); + assert_eq!(records.len(), 5); + let mut target = Term::new(Config::default(), &Size, VoidListener); + RecentOutput::try_from_records(records).unwrap().restore(target.grid_mut()).unwrap(); + let text = target.bounds_to_string( + nebula_terminal::index::Point::new( + Line(-(target.grid().history_size() as i32)), + Column(0), + ), + nebula_terminal::index::Point::new(Line(-1), Column(31)), + ); + assert!(!text.contains("echo 1")); + assert!(text.contains("echo 2")); + assert!(text.contains("result6")); + assert!(text.find("result2").unwrap() < text.find("result6").unwrap()); + assert_eq!(target.grid().cursor.point.line, Line(0)); + assert_eq!(target.grid()[Line(0)][Column(0)].c, ' '); + } + + #[test] + fn loading_rejects_excess_records_instead_of_growing_on_next_command() { + let mut term = Term::new(Config::default(), &Size, VoidListener); + let mut parser: ansi::Processor = ansi::Processor::new(); + parser.advance(&mut term, b"C:>echo test"); + let mut recent = RecentOutput::default(); + recent.begin(term.grid()); + let record = recent.snapshot(term.grid()).remove(0); + assert!(RecentOutput::try_from_records(vec![record; 6]).is_err()); + } + + #[test] + fn loading_rejects_oversize_records_before_restore() { + let mut term = Term::new(Config::default(), &Size, VoidListener); + let mut parser: ansi::Processor = ansi::Processor::new(); + for _ in 0..200 { + parser.advance(&mut term, b"long unbounded output\r\n"); + } + let snapshot = DisplaySnapshot::capture(term.grid(), Line(-200)..Line(0), 6400); + let record = CommandRecord { captured_at: 0, prompt: snapshot.clone(), output: snapshot }; + assert!(serde_json::to_vec(&record).unwrap().len() > MAX_RECORD_BYTES); + assert!(RecentOutput::try_from_records(vec![record]).is_err()); + } + + #[test] + fn encoded_record_keeps_command_and_tail_within_256_kib() { + let mut term = Term::new(Config::default(), &Size, VoidListener); + let mut parser: ansi::Processor = ansi::Processor::new(); + parser.advance(&mut term, b"C:>large-tool"); + let mut recent = RecentOutput::default(); + recent.begin(term.grid()); + for index in 0..300 { + parser.advance( + &mut term, + format!("\r\n\x1b[38;2;123;234;245mrow{index:03} output\x1b[0m").as_bytes(), + ); + } + let records = recent.snapshot(term.grid()); + let encoded = serde_json::to_vec(&records[0]).unwrap(); + assert!(encoded.len() <= 256 * 1024, "{} encoded bytes", encoded.len()); + let mut target = Term::new(Config::default(), &Size, VoidListener); + RecentOutput::try_from_records(records).unwrap().restore(target.grid_mut()).unwrap(); + let text = target.bounds_to_string( + nebula_terminal::index::Point::new( + Line(-(target.grid().history_size() as i32)), + Column(0), + ), + nebula_terminal::index::Point::new(Line(-1), Column(31)), + ); + assert!(text.contains("C:>large-tool")); + assert!(text.contains("row299 output")); + assert!(!text.contains("row000 output")); + } + + #[test] + fn active_output_is_captured_and_two_restores_do_not_duplicate_records() { + let mut term = Term::new(Config::default(), &Size, VoidListener); + let mut parser: ansi::Processor = ansi::Processor::new(); + parser.advance(&mut term, b"C:>tool"); + let mut recent = RecentOutput::default(); + recent.begin(term.grid()); + parser.advance(&mut term, b"\r\npartial"); + let records = recent.snapshot(term.grid()); + assert_eq!(records.len(), 1); + let encoded = serde_json::to_vec(&records).unwrap(); + let restored = + RecentOutput::try_from_records(serde_json::from_slice(&encoded).unwrap()).unwrap(); + let empty = Term::new(Config::default(), &Size, VoidListener); + let encoded_again = serde_json::to_vec(&restored.snapshot(empty.grid())).unwrap(); + assert_eq!(encoded_again, encoded); + } +} diff --git a/nebula_app/src/recent_output/storage.rs b/nebula_app/src/recent_output/storage.rs new file mode 100644 index 000000000..27863051a --- /dev/null +++ b/nebula_app/src/recent_output/storage.rs @@ -0,0 +1,253 @@ +//! 本机 sidecar 编解码边界;调用方拥有保存顺序和清除代次。 + +use std::collections::BTreeMap; +use std::io::{self, Read, Write}; +use std::path::Path; + +use serde::{Deserialize, Serialize}; + +use super::CommandRecord; + +pub(crate) const MAX_STORE_BYTES: usize = 16 * 1024 * 1024; +const MAX_TRANSACTION_BYTES: usize = 2 * MAX_STORE_BYTES; + +pub(crate) fn archive_path() -> std::path::PathBuf { + crate::display::nebula_data_dir().join("command-output.json") +} + +#[derive(Clone, Debug, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub(crate) struct Archive { + version: u32, + panes: BTreeMap>, + #[serde(default, skip_serializing_if = "Option::is_none")] + previous: Option>, +} + +impl Archive { + pub(crate) fn new(panes: BTreeMap>) -> Self { + Self { version: 1, panes, previous: None } + } + + pub(crate) fn take_records(&mut self, id: &str) -> Option> { + self.panes.remove(id).or_else(|| self.previous.as_mut()?.take_records(id)) + } + + fn validate(&self) -> io::Result<()> { + if self.version != 1 || self.panes.len() > 4096 { + return Err(invalid("unsupported or oversized output archive")); + } + for (id, records) in &self.panes { + if id.is_empty() + || id.len() > 128 + || !id.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'-') + { + return Err(invalid("invalid pane reference")); + } + super::RecentOutput::validate_records(records).map_err(invalid)?; + } + Ok(()) + } + + fn encode(&self) -> io::Result> { + self.validate()?; + if let Some(previous) = &self.previous { + if previous.previous.is_some() { + return Err(invalid("nested output transaction")); + } + // 两代各自仍受正常上限约束,不能用交接额度保存一份过大的快照。 + previous.encode()?; + Self::new(self.panes.clone()).encode()?; + } + let limit = if self.previous.is_some() { MAX_TRANSACTION_BYTES } else { MAX_STORE_BYTES }; + let mut encoded = LimitedBuffer { bytes: Vec::new(), limit }; + serde_json::to_writer(&mut encoded, self).map_err(io::Error::other)?; + Ok(encoded.bytes) + } + + pub(crate) fn write_to(&self, path: &Path) -> io::Result<()> { + crate::atomic_file::write(path, &self.encode()?) + } + + /// 从中断的两代交接中只保留已发布会话实际引用的记录。 + fn retain_references(&mut self, references: &[String]) { + let mut panes = BTreeMap::new(); + for id in references { + if let Some(records) = self.take_records(id) { + panes.insert(id.clone(), records); + } + } + *self = Self::new(panes); + } + + pub(crate) fn read_from(path: &Path) -> io::Result { + let file = std::fs::File::open(path)?; + if file.metadata()?.len() > MAX_TRANSACTION_BYTES as u64 { + return Err(invalid("output archive exceeds byte budget")); + } + // metadata 之后仍可能增长,读取也必须限流。 + let mut bytes = Vec::new(); + file.take(MAX_TRANSACTION_BYTES as u64 + 1).read_to_end(&mut bytes)?; + if bytes.len() > MAX_TRANSACTION_BYTES { + return Err(invalid("output archive exceeds byte budget")); + } + let archive: Self = serde_json::from_slice(&bytes).map_err(invalid)?; + // 普通文件不能借助读入上限突破 16 MiB;交接文件逐代复核。 + if archive.previous.is_none() && bytes.len() > MAX_STORE_BYTES { + return Err(invalid("output archive exceeds byte budget")); + } + archive.encode().map_err(invalid)?; + Ok(archive) + } +} + +fn invalid(message: impl std::fmt::Display) -> io::Error { + io::Error::new(io::ErrorKind::InvalidData, message.to_string()) +} + +struct LimitedBuffer { + bytes: Vec, + limit: usize, +} + +impl Write for LimitedBuffer { + fn write(&mut self, bytes: &[u8]) -> io::Result { + if bytes.len() > self.limit.saturating_sub(self.bytes.len()) { + return Err(invalid("output archive exceeds byte budget")); + } + self.bytes.extend_from_slice(bytes); + Ok(bytes.len()) + } + + fn flush(&mut self) -> io::Result<()> { + Ok(()) + } +} + +mod lifecycle; +pub(crate) use lifecycle::OutputStore; + +#[cfg(test)] +mod tests { + use super::*; + use crate::recent_output::RecentOutput; + use nebula_terminal::event::VoidListener; + use nebula_terminal::grid::Dimensions; + use nebula_terminal::term::{Config, Term}; + use nebula_terminal::vte::ansi; + + struct Size; + impl Dimensions for Size { + fn total_lines(&self) -> usize { + 4 + } + fn screen_lines(&self) -> usize { + 4 + } + fn columns(&self) -> usize { + 32 + } + } + + pub(super) fn records(command: &str) -> Vec { + let mut term = Term::new(Config::default(), &Size, VoidListener); + let mut parser: ansi::Processor = ansi::Processor::new(); + parser.advance(&mut term, command.as_bytes()); + let mut recent = RecentOutput::default(); + recent.begin(term.grid()); + parser.advance(&mut term, b"\r\nresult\r\n"); + recent.finish(term.grid()); + let mut records = recent.snapshot(term.grid()); + for record in &mut records { + record.captured_at = 0; + } + records + } + + #[test] + fn atomic_round_trip_keeps_same_directory_panes_separate() { + let directory = tempfile::tempdir().unwrap(); + let path = directory.path().join("outputs.json"); + let archive = Archive::new(BTreeMap::from([ + ("pane-one".into(), records("C:>echo one")), + ("pane-two".into(), records("C:>echo two")), + ])); + archive.write_to(&path).unwrap(); + let loaded = Archive::read_from(&path).unwrap(); + assert_eq!(loaded.panes.len(), 2); + assert_eq!(serde_json::to_value(loaded).unwrap(), serde_json::to_value(archive).unwrap()); + } + + #[test] + fn restore_resolves_exact_identity_once_and_never_falls_back_to_another_pane() { + let mut archive = Archive::new(BTreeMap::from([ + ("pane-one".into(), records("C:>echo one")), + ("pane-two".into(), records("C:>echo two")), + ])); + assert!(archive.take_records("missing").is_none()); + let one = archive.take_records("pane-one").unwrap(); + assert!(archive.take_records("pane-one").is_none()); + assert_eq!( + serde_json::to_value(one).unwrap(), + serde_json::to_value(records("C:>echo one")).unwrap() + ); + assert!(archive.take_records("pane-two").is_some()); + } + + #[test] + fn invalid_write_does_not_replace_last_good_archive() { + let directory = tempfile::tempdir().unwrap(); + let path = directory.path().join("outputs.json"); + let mut archive = Archive::new(BTreeMap::from([("pane".into(), records("C:>good"))])); + archive.write_to(&path).unwrap(); + let before = std::fs::read(&path).unwrap(); + archive.version = 999; + assert!(archive.write_to(&path).is_err()); + assert_eq!(std::fs::read(path).unwrap(), before); + } + + #[test] + fn transaction_cannot_hide_oversized_generation_or_nested_transactions() { + let directory = tempfile::tempdir().unwrap(); + let path = directory.path().join("outputs.json"); + let record = records("C:>safe"); + let bytes = serde_json::to_vec(&record).unwrap().len(); + let oversized = Archive::new( + (0..(17 * 1024 * 1024 / bytes)) + .map(|index| (format!("pane-{index}"), record.clone())) + .collect(), + ); + let mut transaction = Archive::new(BTreeMap::new()); + transaction.previous = Some(Box::new(oversized)); + std::fs::write(&path, serde_json::to_vec(&transaction).unwrap()).unwrap(); + assert!(Archive::read_from(&path).is_err()); + assert!(transaction.write_to(&path).is_err()); + let mut nested = Archive::new(BTreeMap::new()); + nested.previous = Some(Box::new(Archive::new(BTreeMap::new()))); + transaction.previous = Some(Box::new(nested)); + std::fs::write(&path, serde_json::to_vec(&transaction).unwrap()).unwrap(); + assert!(Archive::read_from(&path).is_err()); + let oversized = std::fs::File::create(&path).unwrap(); + oversized.set_len(MAX_TRANSACTION_BYTES as u64 + 1).unwrap(); + drop(oversized); + assert!(Archive::read_from(&path).is_err()); + } + + #[test] + fn malformed_version_oversize_and_excess_records_are_rejected() { + let directory = tempfile::tempdir().unwrap(); + let path = directory.path().join("outputs.json"); + for contents in [b"broken".as_slice(), b"{\"version\":2,\"panes\":{}}"] { + std::fs::write(&path, contents).unwrap(); + assert!(Archive::read_from(&path).is_err()); + } + let oversized = std::fs::File::create(&path).unwrap(); + oversized.set_len(MAX_STORE_BYTES as u64 + 1).unwrap(); + drop(oversized); + assert!(Archive::read_from(&path).is_err()); + let record = records("C:>test").remove(0); + let archive = Archive::new(BTreeMap::from([("pane".into(), vec![record; 6])])); + std::fs::write(&path, serde_json::to_vec(&archive).unwrap()).unwrap(); + assert!(Archive::read_from(&path).is_err()); + } +} diff --git a/nebula_app/src/recent_output/storage/lifecycle.rs b/nebula_app/src/recent_output/storage/lifecycle.rs new file mode 100644 index 000000000..56fc05bf0 --- /dev/null +++ b/nebula_app/src/recent_output/storage/lifecycle.rs @@ -0,0 +1,418 @@ +//! 后台串行文件操作;UI 仅递增代次,不持有磁盘 I/O 锁。 + +use std::io; +use std::path::PathBuf; +use std::sync::atomic::{AtomicU64, Ordering}; +use std::sync::{Arc, Mutex}; + +use super::Archive; + +#[derive(Clone)] +pub(crate) struct OutputStore { + inner: Arc, +} + +struct StoreState { + path: PathBuf, + generation: AtomicU64, + writer: Mutex<()>, +} + +impl OutputStore { + pub(crate) fn new(path: PathBuf) -> Self { + Self { + inner: Arc::new(StoreState { + path, + generation: AtomicU64::new(0), + writer: Mutex::new(()), + }), + } + } + + pub(crate) fn next_generation(&self) -> u64 { + self.inner.generation.fetch_add(1, Ordering::SeqCst) + 1 + } + + /// 仅由后台执行器调用;返回 false 表示快照已被更新或清除取代。 + pub(crate) fn save(&self, generation: u64, archive: &Archive) -> io::Result { + self.with_generation(generation, || archive.write_to(&self.inner.path)) + } + + /// 后台保存 sidecar 后再发布本机会话引用;发布失败保留上一份有效输出。 + pub(crate) fn save_and_publish( + &self, + generation: u64, + archive: &Archive, + publish: impl FnOnce() -> io::Result<()>, + ) -> io::Result { + self.save_referenced(generation, archive, None, publish) + } + + pub(crate) fn save_referenced( + &self, + generation: u64, + archive: &Archive, + references: Option<&[String]>, + publish: impl FnOnce() -> io::Result<()>, + ) -> io::Result { + self.with_generation(generation, || { + // 新快照先校验,绝不因为旧文件损坏而接受无效的新内容。 + archive.encode()?; + let mut previous = match Archive::read_from(&self.inner.path) { + Ok(archive) => Some(archive), + Err(error) if error.kind() == io::ErrorKind::NotFound => None, + Err(error) if error.kind() == io::ErrorKind::InvalidData => { + log::warn!("Ignoring invalid command output archive: {error}"); + None + }, + Err(error) => return Err(error), + }; + // 引用必须标识不可变快照,提交期间两代同时可读。进程在发布前 + // 退出时旧 session 仍有效,发布后退出时新 session 也有效。 + if let Some(previous) = &mut previous { + if previous.previous.is_some() { + let references = references.ok_or_else(|| { + io::Error::new( + io::ErrorKind::InvalidData, + "interrupted output publication requires session references", + ) + })?; + previous.retain_references(references); + } + } + let mut staged = archive.clone(); + for (id, records) in &archive.panes { + if let Some(old) = previous.as_ref().and_then(|previous| previous.panes.get(id)) + && serde_json::to_vec(old)? != serde_json::to_vec(records)? + { + return Err(io::Error::new( + io::ErrorKind::InvalidData, + "output reference reused for different data", + )); + } + } + staged.previous = previous.clone().map(Box::new); + staged.write_to(&self.inner.path)?; + if generation != self.inner.generation.load(Ordering::SeqCst) { + return self.restore_previous(previous.as_ref()); + } + if let Err(error) = publish() { + self.restore_previous(previous.as_ref()).map_err(|rollback| { + io::Error::other(format!( + "session publish failed: {error}; output rollback failed: {rollback}" + )) + })?; + return Err(error); + } + // 发布已成功,压缩失败不回滚引用;旧数据留到下一次成功提交清理。 + if let Err(error) = archive.write_to(&self.inner.path) { + log::warn!("Could not prune previous command output: {error}"); + } + Ok(()) + }) + } + + fn restore_previous(&self, previous: Option<&Archive>) -> io::Result<()> { + match previous { + Some(archive) => archive.write_to(&self.inner.path), + None => std::fs::remove_file(&self.inner.path), + } + } + + /// 清除完成后旧写入不能重新出现;调用方须等待结果再显示成功。 + pub(crate) fn clear(&self, generation: u64) -> io::Result { + self.with_generation(generation, || match std::fs::remove_file(&self.inner.path) { + Ok(()) => Ok(()), + Err(error) if error.kind() == io::ErrorKind::NotFound => Ok(()), + Err(error) => Err(error), + }) + } + + fn with_generation( + &self, + generation: u64, + operation: impl FnOnce() -> io::Result<()>, + ) -> io::Result { + let _writer = + self.inner.writer.lock().map_err(|_| io::Error::other("output writer poisoned"))?; + if generation != self.inner.generation.load(Ordering::SeqCst) { + return Ok(false); + } + operation()?; + // UI 可在 I/O 中使代次失效;后续清除在同一锁之后执行。 + Ok(generation == self.inner.generation.load(Ordering::SeqCst)) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::recent_output::storage::{Archive, tests::records}; + use std::collections::BTreeMap; + + fn archive(id: &str) -> Archive { + Archive::new(BTreeMap::from([(id.into(), records("C:>echo safe"))])) + } + + #[test] + fn regression_corrupt_archive_does_not_block_new_session_publication() { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("outputs.json"); + std::fs::write(&path, b"{broken archive").unwrap(); + let store = OutputStore::new(path.clone()); + let published = std::cell::Cell::new(false); + assert!( + store + .save_and_publish(store.next_generation(), &archive("new"), || { + published.set(true); + Ok(()) + }) + .unwrap() + ); + assert!(published.get()); + assert!(Archive::read_from(&path).unwrap().panes.contains_key("new")); + } + + #[test] + fn regression_two_valid_large_generations_do_not_block_publication() { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("outputs.json"); + let records = records("C:>echo safe"); + let entry_bytes = serde_json::to_vec(&records).unwrap().len(); + let count = 9 * 1024 * 1024 / entry_bytes; + let large = |prefix: &str| { + Archive::new( + (0..count).map(|index| (format!("{prefix}-{index}"), records.clone())).collect(), + ) + }; + let previous = large("previous"); + let next = large("next"); + previous.write_to(&path).unwrap(); + let old_len = std::fs::metadata(&path).unwrap().len(); + assert!(old_len > 8 * 1024 * 1024 && old_len < 16 * 1024 * 1024); + let store = OutputStore::new(path.clone()); + assert!( + store + .save_and_publish(store.next_generation(), &next, || { + let staged = Archive::read_from(&path)?; + let mut staged = staged; + assert!(staged.take_records("previous-0").is_some()); + assert!(staged.take_records("next-0").is_some()); + Ok(()) + }) + .unwrap() + ); + let restored = Archive::read_from(&path).unwrap(); + assert!(restored.panes.contains_key("next-0")); + assert!(!restored.panes.contains_key("previous-0")); + } + + #[test] + fn interrupted_publication_keeps_only_referenced_generation_on_retry() { + for reference in ["previous", "next"] { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("outputs.json"); + let mut interrupted = archive("next"); + interrupted.previous = Some(Box::new(archive("previous"))); + interrupted.write_to(&path).unwrap(); + let store = OutputStore::new(path.clone()); + let references = vec![reference.to_string()]; + assert!( + store + .save_referenced( + store.next_generation(), + &archive("third"), + Some(&references), + || { + let mut during = Archive::read_from(&path)?; + assert!(during.take_records(reference).is_some()); + assert!(during.take_records("third").is_some()); + let unreferenced = + if reference == "previous" { "next" } else { "previous" }; + assert!(during.take_records(unreferenced).is_none()); + Ok(()) + } + ) + .unwrap() + ); + let after = Archive::read_from(&path).unwrap(); + assert!(after.previous.is_none()); + assert_eq!(after.panes.len(), 1); + } + } + + #[test] + fn interrupted_publication_failed_retry_preserves_referenced_output() { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("outputs.json"); + let mut interrupted = archive("next"); + interrupted.previous = Some(Box::new(archive("previous"))); + interrupted.write_to(&path).unwrap(); + let store = OutputStore::new(path.clone()); + assert!( + store + .save_referenced( + store.next_generation(), + &archive("third"), + Some(&["previous".into()]), + || { Err(io::Error::other("publication failed")) } + ) + .is_err() + ); + let mut after = Archive::read_from(&path).unwrap(); + assert!(after.take_records("previous").is_some()); + assert!(after.take_records("third").is_none()); + } + + #[test] + fn delayed_save_cannot_resurrect_cleared_output() { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("outputs.json"); + let store = OutputStore::new(path.clone()); + let old = store.next_generation(); + let clear = store.next_generation(); + store.clear(clear).unwrap(); + assert!(!store.save(old, &archive("old")).unwrap()); + assert!(!path.exists()); + let new = store.next_generation(); + assert!(store.save(new, &archive("new")).unwrap()); + assert!(Archive::read_from(&path).unwrap().panes.contains_key("new")); + } + + #[test] + fn out_of_order_save_cannot_reintroduce_closed_pane() { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("outputs.json"); + let store = OutputStore::new(path.clone()); + let old = store.next_generation(); + let new = store.next_generation(); + store.save(new, &archive("remaining")).unwrap(); + assert!(!store.save(old, &archive("closed")).unwrap()); + let archive = Archive::read_from(&path).unwrap(); + assert_eq!(archive.panes.len(), 1); + assert!(archive.panes.contains_key("remaining")); + } + + #[test] + fn checkpoint_publishes_references_only_after_output_is_durable() { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("outputs.json"); + let store = OutputStore::new(path.clone()); + let generation = store.next_generation(); + let published = std::cell::Cell::new(false); + assert!( + store + .save_and_publish(generation, &archive("new"), || { + assert!(Archive::read_from(&path)?.panes.contains_key("new")); + published.set(true); + Ok(()) + }) + .unwrap() + ); + assert!(published.get()); + assert!( + !store + .save_and_publish(generation - 1, &archive("stale"), || { + panic!("stale checkpoint must not publish session references") + }) + .unwrap() + ); + } + + #[test] + fn previous_references_remain_readable_until_new_session_is_published() { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("outputs.json"); + let store = OutputStore::new(path.clone()); + store.save(store.next_generation(), &archive("previous")).unwrap(); + let next = store.next_generation(); + store + .save_and_publish(next, &archive("new"), || { + let mut during = Archive::read_from(&path)?; + assert!( + during.take_records("previous").is_some(), + "old session must survive a crash before publication" + ); + assert!(during.panes.contains_key("new")); + Ok(()) + }) + .unwrap(); + let after = Archive::read_from(&path).unwrap(); + assert!(after.panes.contains_key("new")); + assert!(!after.panes.contains_key("previous")); + } + + #[test] + fn failed_session_publication_restores_previous_output_archive() { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("outputs.json"); + let store = OutputStore::new(path.clone()); + let old = store.next_generation(); + store.save(old, &archive("previous")).unwrap(); + let before = std::fs::read(&path).unwrap(); + let next = store.next_generation(); + assert!( + store + .save_and_publish(next, &archive("new"), || { + Err(io::Error::other("session write failed")) + }) + .is_err() + ); + assert_eq!(std::fs::read(&path).unwrap(), before); + assert!(store.save_and_publish(next, &archive("new"), || Ok(())).unwrap()); + } + + #[test] + fn reusing_reference_for_different_output_does_not_overwrite_previous_data() { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("outputs.json"); + let store = OutputStore::new(path.clone()); + store.save(store.next_generation(), &archive("same-id")).unwrap(); + let before = std::fs::read(&path).unwrap(); + let changed = + Archive::new(BTreeMap::from([("same-id".into(), records("C:>different command"))])); + assert!( + store + .save_and_publish(store.next_generation(), &changed, || { + panic!("a conflicting identity must never be published") + }) + .is_err() + ); + assert_eq!(std::fs::read(path).unwrap(), before); + } + + #[test] + fn invalidation_during_publication_does_not_acknowledge_or_resurrect_cleared_output() { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("outputs.json"); + let store = OutputStore::new(path.clone()); + let generation = store.next_generation(); + let clear = std::cell::Cell::new(0); + assert!( + !store + .save_and_publish(generation, &archive("new"), || { + clear.set(store.next_generation()); + Ok(()) + }) + .unwrap() + ); + assert!(store.clear(clear.get()).unwrap()); + assert!(!store.save(generation, &archive("new")).unwrap()); + assert!(!path.exists()); + } + + #[test] + fn failed_save_preserves_previous_archive_and_allows_retry() { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("outputs.json"); + let store = OutputStore::new(path.clone()); + let first = store.next_generation(); + store.save(first, &archive("before")).unwrap(); + let next = store.next_generation(); + let mut invalid = archive("after"); + invalid.version = 999; + assert!(store.save(next, &invalid).is_err()); + assert!(Archive::read_from(&path).unwrap().panes.contains_key("before")); + assert!(store.save(next, &archive("after")).unwrap()); + } +} diff --git a/nebula_app/src/session.rs b/nebula_app/src/session.rs index e02873827..0a865c1ba 100644 --- a/nebula_app/src/session.rs +++ b/nebula_app/src/session.rs @@ -20,6 +20,7 @@ use serde::{Deserialize, Serialize}; use crate::display::color::Rgb; +mod local_output; mod window_layout; pub use window_layout::WindowLayout; pub(crate) use window_layout::combine_sessions; @@ -199,12 +200,23 @@ pub struct TabSession { /// v4: focused leaf as a depth-first index into `layout`. #[serde(default)] pub active_pane: usize, + /// 本机 sidecar 的逐叶引用;共享工作区序列化始终排除。 + #[serde(skip)] + pub(crate) output_refs: Vec, } impl TabSession { /// A v3-shaped tab: one pane at `cwd`, default shell. pub fn single(cwd: String, custom_name: Option, color: Option) -> Self { - Self { cwd, custom_name, color, launch: None, layout: None, active_pane: 0 } + Self { + cwd, + custom_name, + color, + launch: None, + layout: None, + active_pane: 0, + output_refs: Vec::new(), + } } } @@ -261,7 +273,7 @@ impl Session { /// `%APPDATA%\Nebula\session.json` (or the `.config` fallback), next to the /// settings and history files. -fn session_path() -> PathBuf { +pub(crate) fn session_path() -> PathBuf { crate::display::nebula_data_dir().join("session.json") } @@ -278,7 +290,11 @@ fn parse(data: &str) -> Option { /// Load the previous session, if any and version-compatible. pub fn load() -> Option { - load_from(&session_path()) + load_local_from(&session_path()) +} + +pub(crate) fn load_local_from(path: &Path) -> Option { + local_output::parse(&std::fs::read_to_string(path).ok()?) } /// An update must not replace an unreadable workspace with an empty snapshot. @@ -290,7 +306,7 @@ pub(crate) fn load_update_windows() -> std::io::Result> { }, Err(error) => return Err(error), }; - let session = parse(&data).ok_or_else(|| { + let session = local_output::parse(&data).ok_or_else(|| { std::io::Error::new(std::io::ErrorKind::InvalidData, "Invalid saved workspace") })?; session.into_update_windows() @@ -311,8 +327,12 @@ pub fn save(session: &Session) { } pub(crate) fn try_save(session: &Session) -> std::io::Result<()> { - let json = serde_json::to_string(session).map_err(std::io::Error::other)?; - crate::atomic_file::write(&session_path(), json.as_bytes()) + save_local_to(&session_path(), session) +} + +pub(crate) fn save_local_to(path: &Path, session: &Session) -> std::io::Result<()> { + let json = local_output::encode(session).map_err(std::io::Error::other)?; + crate::atomic_file::write(path, json.as_bytes()) } /// Write a session as a named workspace file. Pretty-printed — workspace diff --git a/nebula_app/src/session/local_output.rs b/nebula_app/src/session/local_output.rs new file mode 100644 index 000000000..d63b1f7ae --- /dev/null +++ b/nebula_app/src/session/local_output.rs @@ -0,0 +1,97 @@ +//! 仅自动恢复文档携带输出引用;共享 Session 编码不含本机身份。 + +use super::Session; + +pub(super) fn encode(session: &Session) -> serde_json::Result { + #[derive(serde::Serialize)] + struct LocalSession<'a> { + #[serde(flatten)] + session: &'a Session, + local_output_refs: Vec<&'a [String]>, + } + serde_json::to_string(&LocalSession { + session, + local_output_refs: session.tabs.iter().map(|tab| tab.output_refs.as_slice()).collect(), + }) +} + +pub(super) fn parse(data: &str) -> Option { + let mut session = super::parse(data)?; + // 引用损坏仅丢弃历史,不使仍有效的布局与 AI 身份无法恢复。 + let value: serde_json::Value = serde_json::from_str(data).ok()?; + if let Some(refs) = value + .get("local_output_refs") + .and_then(|refs| serde_json::from_value::>>(refs.clone()).ok()) + { + let mut seen = std::collections::HashSet::new(); + let valid = refs.len() == session.tabs.len() + && refs.iter().zip(&session.tabs).all(|(ids, tab)| { + let leaves = tab.layout.as_ref().map_or(1, super::LayoutSession::pane_count); + (ids.is_empty() || ids.len() == leaves) + && ids.iter().all(|id| { + id.is_empty() + || (id.len() <= 128 + && id.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'-') + && seen.insert(id)) + }) + }); + if valid { + for (tab, ids) in session.tabs.iter_mut().zip(refs) { + tab.output_refs = ids; + } + } + } + Some(session) +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::session::{TabSession, combine_sessions}; + + fn saved(id: &str) -> Session { + let mut tab = TabSession::single("C:/same-directory".into(), None, None); + tab.output_refs = vec![id.into()]; + Session::new(0, vec![tab]) + } + + #[test] + fn local_output_refs_survive_local_save_but_never_workspace_export_or_import() { + let original = saved("pane-one"); + let encoded = encode(&original).unwrap(); + assert_eq!(parse(&encoded).unwrap().tabs[0].output_refs, ["pane-one"]); + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("workspace.json"); + crate::session::save_to(&path, &original).unwrap(); + let exported = std::fs::read_to_string(&path).unwrap(); + assert!(!exported.contains("pane-one")); + // 即使输入的是本机自动存档,手动工作区导入仍不能带入引用。 + std::fs::write(&path, encoded).unwrap(); + assert!(crate::session::load_from(&path).unwrap().tabs[0].output_refs.is_empty()); + } + + #[test] + fn local_output_refs_follow_tabs_when_combining_and_restoring_windows() { + let combined = + combine_sessions([(false, saved("pane-one")), (true, saved("pane-two"))]).unwrap(); + let windows = parse(&encode(&combined).unwrap()).unwrap().into_update_windows().unwrap(); + assert_eq!(windows[0].tabs[0].output_refs, ["pane-one"]); + assert_eq!(windows[1].tabs[0].output_refs, ["pane-two"]); + } + + #[test] + fn malformed_local_output_refs_do_not_break_layout_recovery() { + let mut value = serde_json::to_value(saved("unused")).unwrap(); + for invalid in [ + serde_json::json!([["../escape"]]), + serde_json::json!([["one", "two"]]), + serde_json::json!([["same"], ["extra-tab"]]), + serde_json::json!("broken"), + ] { + value["local_output_refs"] = invalid; + let session = parse(&value.to_string()).unwrap(); + assert_eq!(session.tabs.len(), 1); + assert!(session.tabs[0].output_refs.is_empty()); + } + } +} diff --git a/nebula_app/src/window_context/session_snapshot.rs b/nebula_app/src/window_context/session_snapshot.rs index c449b39bc..19ce8a194 100644 --- a/nebula_app/src/window_context/session_snapshot.rs +++ b/nebula_app/src/window_context/session_snapshot.rs @@ -77,6 +77,7 @@ impl WindowContext { launch: Some(Self::launch_session(&tab.launch)), layout: Some(Self::layout_session(&tab.layout, &pane_cwd, &pane_agent)), active_pane: leaves.iter().position(|id| *id == tab.active_pane).unwrap_or(0), + output_refs: Vec::new(), } } diff --git a/nebula_settings/src/lib.rs b/nebula_settings/src/lib.rs index 2df4bc670..66859e4d2 100644 --- a/nebula_settings/src/lib.rs +++ b/nebula_settings/src/lib.rs @@ -1019,6 +1019,8 @@ pub struct RuntimeSettings { /// Start the first window hidden when a system tray is available and enabled. pub silent_start: bool, pub restore_session: bool, + /// 仅本机有界命令输出;会话恢复关闭时不采集、不持久化。 + pub save_command_output: bool, pub resume_ai: bool, /// 常驻系统托盘图标。 pub tray: bool, @@ -1106,6 +1108,10 @@ pub const MIN_PANE_CARD_GUTTER: f32 = 0.0; pub const MAX_PANE_CARD_GUTTER: f32 = 32.0; pub const MAX_PANE_CARD_DIVIDER: f32 = 4.0; impl RuntimeSettings { + pub fn command_output_enabled(&self) -> bool { + self.restore_session && self.save_command_output + } + pub fn load() -> Self { Self::from_raw(&RawSettings::load()) } @@ -1196,6 +1202,7 @@ impl RuntimeSettings { keep_session: raw.bool_on("keep_session").unwrap_or(false), silent_start: raw.bool_on("silent_start").unwrap_or(false), restore_session: raw.bool_on("restore_session").unwrap_or(true), + save_command_output: raw.bool_on("save_command_output").unwrap_or(true), resume_ai: raw.bool_on("resume_ai").unwrap_or(true), tray: raw.bool_on("tray").unwrap_or(true), blur, @@ -1546,6 +1553,20 @@ mod tests { assert_eq!(settings.bell, BellModeName::Both); } + #[test] + fn recent_output_is_saved_only_when_both_recovery_switches_are_enabled() { + for (raw, enabled) in [ + ("", true), + ("save_command_output=0", false), + ("restore_session=0", false), + ("restore_session=0\nsave_command_output=1", false), + ("restore_session=1\nsave_command_output=1", true), + ] { + let settings = RuntimeSettings::from_raw(&RawSettings::from_text(raw)); + assert_eq!(settings.command_output_enabled(), enabled, "{raw}"); + } + } + #[test] fn automatic_update_checks_can_be_disabled_without_changing_the_default() { assert!(RuntimeSettings::from_raw(&RawSettings::default()).auto_check_updates); diff --git a/nebula_settings/src/reset.rs b/nebula_settings/src/reset.rs index cad23d848..d4571e9dc 100644 --- a/nebula_settings/src/reset.rs +++ b/nebula_settings/src/reset.rs @@ -48,6 +48,7 @@ const RESET_KEYS: &[&str] = &[ "auto_download_updates", "keep_session", "restore_session", + "save_command_output", "resume_ai", "tray", "silent_start", diff --git a/nebula_terminal/src/grid/mod.rs b/nebula_terminal/src/grid/mod.rs index dcde45a67..88afd649f 100644 --- a/nebula_terminal/src/grid/mod.rs +++ b/nebula_terminal/src/grid/mod.rs @@ -12,6 +12,7 @@ use crate::vte::ansi::{CharsetIndex, StandardCharset}; pub mod resize; mod row; +pub mod snapshot; mod storage; #[cfg(test)] mod tests; diff --git a/nebula_terminal/src/grid/snapshot.rs b/nebula_terminal/src/grid/snapshot.rs new file mode 100644 index 000000000..80ffdb9ba --- /dev/null +++ b/nebula_terminal/src/grid/snapshot.rs @@ -0,0 +1,254 @@ +//! 安全显示数据快照:不保存终端协议、链接动作或运行状态。 + +use super::{Dimensions, Grid}; +use crate::index::{Column, Line}; +use crate::term::cell::Cell; + +#[cfg(feature = "serde")] +mod serialization; + +// 解码后的防灾上限;持久化层还须独立限制每条记录的编码字节数。 +const MAX_SNAPSHOT_CELLS: usize = 262_144; + +#[derive(Clone, Debug, Default)] +pub struct DisplaySnapshot { + columns: usize, + rows: Vec>, +} + +impl DisplaySnapshot { + pub fn capture(grid: &Grid, range: std::ops::Range, max_cells: usize) -> Self { + let max_cells = max_cells.min(MAX_SNAPSHOT_CELLS); + let columns = grid.columns(); + let end = range.end.0.min(grid.screen_lines() as i32); + let start = range.start.0.max(-(grid.history_size() as i32)); + let start = + start.max(end.saturating_sub((max_cells / columns).min(i32::MAX as usize) as i32)); + let rows = (start..end) + .map(|line| { + (0..columns) + .map(|column| { + let mut cell = grid[Line(line)][Column(column)].clone(); + cell.set_hyperlink(None); + cell + }) + .collect() + }) + .collect(); + Self { columns, rows } + } + + fn validate(&self) -> Result<(), &'static str> { + if self.columns == 0 + || self.rows.len() > MAX_SNAPSHOT_CELLS / self.columns + || self.rows.iter().any(|row| { + row.len() != self.columns + || row.iter().any(|cell| { + (cell.c.is_control() && cell.c != '\t') + || cell.hyperlink().is_some() + || cell + .zerowidth() + .is_some_and(|chars| chars.iter().any(|c| c.is_control())) + }) + }) + { + return Err("invalid display snapshot"); + } + Ok(()) + } + + pub fn restore_scrollback(&self, grid: &mut Grid) -> Result<(), &'static str> { + self.validate()?; + if self.rows.is_empty() { + return Ok(()); + } + if self.columns != grid.columns() { + // 只重排快照,不 resize 活终端;复用已有宽字符/软换行规则。 + let reflow_capacity = self.rows.len().saturating_mul(self.columns); + let mut staging = Grid::::new(1, self.columns, reflow_capacity); + self.restore_scrollback(&mut staging)?; + staging.resize(true, 1, grid.columns()); + let reflowed = Self::capture( + &staging, + Line(-(staging.history_size() as i32))..Line(0), + usize::MAX, + ); + return reflowed.restore_scrollback(grid); + } + let old_history = grid.history_size(); + let count = self.rows.len().min(grid.max_scroll_limit.saturating_sub(old_history)); + grid.raw.initialize(count, grid.columns()); + let top = -((old_history + count) as i32); + for (index, row) in self.rows.iter().rev().take(count).rev().enumerate() { + for (column, cell) in row.iter().enumerate() { + grid[Line(top + index as i32)][Column(column)] = cell.clone(); + } + } + Ok(()) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::event::VoidListener; + use crate::term::{Config, Term, test::TermSize}; + use crate::vte::ansi; + + #[test] + fn restores_reflowed_unicode_before_existing_history_without_touching_prompt() { + let mut source = Term::new(Config::default(), &TermSize::new(8, 3), VoidListener); + let mut parser: ansi::Processor = ansi::Processor::new(); + parser.advance(&mut source, "ab中文e\u{301}XYZ\r\n".as_bytes()); + let snapshot = DisplaySnapshot::capture(source.grid(), Line(0)..Line(2), 100); + let mut target = Term::new(Config::default(), &TermSize::new(5, 2), VoidListener); + parser.advance(&mut target, b"keep\r\nlast\r\nnew>"); + snapshot.restore_scrollback(target.grid_mut()).unwrap(); + assert_eq!(target.grid().history_size(), 4); + let text: String = (-4..-1) + .flat_map(|line| (0..5).map(move |col| (line, col))) + .filter_map(|(line, col)| { + let cell = &target.grid()[Line(line)][Column(col)]; + (!cell.flags.intersects( + crate::term::cell::Flags::WIDE_CHAR_SPACER + | crate::term::cell::Flags::LEADING_WIDE_CHAR_SPACER, + ) && cell.c != ' ') + .then_some(cell.c) + }) + .collect(); + assert_eq!(text, "ab中文eXYZ"); + assert_eq!(target.grid()[Line(-3)][Column(2)].zerowidth(), Some(&['\u{301}'][..])); + assert_eq!(target.grid()[Line(-1)][Column(0)].c, 'k'); + assert_eq!(target.grid()[Line(1)][Column(0)].c, 'n'); + assert_eq!(target.grid().cursor.point, crate::index::Point::new(Line(1), Column(4))); + } + + #[cfg(feature = "serde")] + #[test] + fn serialized_snapshot_round_trips_display_only_and_rejects_actions() { + let mut source = Term::new(Config::default(), &TermSize::new(4, 2), VoidListener); + let mut parser: ansi::Processor = ansi::Processor::new(); + parser.advance(&mut source, "\x1b[38;2;12;34;56me\u{301}中".as_bytes()); + let snapshot = DisplaySnapshot::capture(source.grid(), Line(0)..Line(1), 4); + let value = serde_json::to_value(&snapshot).unwrap(); + let decoded: DisplaySnapshot = serde_json::from_value(value.clone()).unwrap(); + let mut target = Grid::::new(2, 4, 10); + decoded.restore_scrollback(&mut target).unwrap(); + assert_eq!(target[Line(-1)][Column(0)].zerowidth(), Some(&['\u{301}'][..])); + assert_eq!(target[Line(-1)][Column(1)].c, '中'); + assert_eq!( + target[Line(-1)][Column(0)].fg, + ansi::Color::Spec(crate::vte::ansi::Rgb { r: 12, g: 34, b: 56 }) + ); + assert!(value["rows"][0][0].get("extra").is_none()); + let mut invalid = value; + invalid["rows"][0][0]["hyperlink"] = serde_json::json!("https://example.invalid"); + assert!(serde_json::from_value::(invalid).is_err()); + } + + #[cfg(feature = "serde")] + #[test] + fn deserialization_rejects_invalid_dimensions_and_control_data() { + for value in [ + serde_json::json!({ "columns": 0, "rows": [[]] }), + serde_json::json!({ "columns": 4, "rows": [[]] }), + serde_json::json!({ "columns": 262145, "rows": [[]] }), + ] { + assert!(serde_json::from_value::(value).is_err()); + } + let snapshot = DisplaySnapshot { + columns: 1, + rows: vec![vec![Cell { c: '\u{1b}', ..Cell::default() }]], + }; + let value = serde_json::to_value(&snapshot).unwrap(); + assert!(serde_json::from_value::(value).is_err()); + } + + #[test] + fn rejects_malformed_rows_before_changing_live_grid() { + let mut target = Grid::::new(2, 4, 10); + target[Line(0)][Column(0)].c = 'x'; + let snapshot = DisplaySnapshot { columns: 4, rows: vec![vec![Cell::default(); 5]] }; + assert!(snapshot.restore_scrollback(&mut target).is_err()); + assert_eq!(target.history_size(), 0); + assert_eq!(target[Line(0)][Column(0)].c, 'x'); + } + + #[test] + fn rejects_actions_and_control_characters_before_restoring() { + let mut target = Grid::::new(2, 4, 10); + for cell in [Cell { c: '\u{1b}', ..Cell::default() }, { + let mut cell = Cell::default(); + cell.set_hyperlink(Some(crate::term::cell::Hyperlink::new( + None::, + "https://example.invalid".into(), + ))); + cell + }] { + let snapshot = DisplaySnapshot { columns: 4, rows: vec![vec![cell; 4]] }; + assert!(snapshot.restore_scrollback(&mut target).is_err()); + assert_eq!(target.history_size(), 0); + } + } + + #[test] + fn restores_parser_tab_cells_as_inert_display_data() { + let mut source = Term::new(Config::default(), &TermSize::new(12, 2), VoidListener); + let mut parser: ansi::Processor = ansi::Processor::new(); + parser.advance(&mut source, b"a\tb"); + let snapshot = DisplaySnapshot::capture(source.grid(), Line(0)..Line(1), 12); + let mut target = Grid::::new(2, 12, 10); + snapshot.restore_scrollback(&mut target).unwrap(); + assert_eq!(target[Line(-1)][Column(0)].c, 'a'); + assert_eq!(target[Line(-1)][Column(8)].c, 'b'); + } + + #[test] + fn rejects_oversized_snapshot_before_allocating_history() { + let snapshot = DisplaySnapshot { columns: 1, rows: vec![vec![Cell::default()]; 262_145] }; + let mut target = Grid::::new(2, 4, 10); + assert!(snapshot.restore_scrollback(&mut target).is_err()); + assert_eq!(target.history_size(), 0); + } + + #[test] + fn capture_keeps_only_complete_tail_rows_within_budget() { + let mut source = Term::new(Config::default(), &TermSize::new(4, 3), VoidListener); + let mut parser: ansi::Processor = ansi::Processor::new(); + parser.advance(&mut source, b"one\r\ntwo\r\nend"); + let snapshot = DisplaySnapshot::capture(source.grid(), Line(-100)..Line(100), 9); + let mut target = Grid::::new(2, 4, 10); + snapshot.restore_scrollback(&mut target).unwrap(); + assert_eq!(target.history_size(), 2); + assert_eq!(target[Line(-2)][Column(0)].c, 't'); + assert_eq!(target[Line(-1)][Column(0)].c, 'e'); + let empty = DisplaySnapshot::capture(source.grid(), Line(2)..Line(1), 9); + empty.restore_scrollback(&mut target).unwrap(); + assert_eq!(target.history_size(), 2); + } + + #[test] + fn restores_display_without_replaying_hyperlink_or_changing_live_screen() { + let mut source = Term::new(Config::default(), &TermSize::new(12, 3), VoidListener); + let mut parser: ansi::Processor = ansi::Processor::new(); + parser.advance( + &mut source, + b"\x1b]8;;https://example.invalid\x1b\\\x1b[31mold\x1b]8;;\x1b\\\r\n", + ); + let snapshot = DisplaySnapshot::capture(source.grid(), Line(0)..Line(1), 100); + let mut target = Term::new(Config::default(), &TermSize::new(12, 3), VoidListener); + parser.advance(&mut target, b"new>"); + let cursor = target.grid().cursor.clone(); + snapshot.restore_scrollback(target.grid_mut()).unwrap(); + assert_eq!(target.grid().history_size(), 1); + assert_eq!(target.grid()[Line(-1)][Column(0)].c, 'o'); + assert_eq!( + target.grid()[Line(-1)][Column(0)].fg, + ansi::Color::Named(ansi::NamedColor::Red) + ); + assert!(target.grid()[Line(-1)][Column(0)].hyperlink().is_none()); + assert_eq!(target.grid()[Line(0)][Column(0)].c, 'n'); + assert_eq!(target.grid().cursor.point, cursor.point); + assert_eq!(target.grid().cursor.template, cursor.template); + } +} diff --git a/nebula_terminal/src/grid/snapshot/serialization.rs b/nebula_terminal/src/grid/snapshot/serialization.rs new file mode 100644 index 000000000..05039bbec --- /dev/null +++ b/nebula_terminal/src/grid/snapshot/serialization.rs @@ -0,0 +1,85 @@ +//! 持久化只暴露显示字段;不沿用 Cell 的链接及未来协议字段。 + +use serde::{Deserialize, Deserializer, Serialize, Serializer}; + +use super::DisplaySnapshot; +use crate::term::cell::{Cell, Flags}; +use crate::vte::ansi::Color; + +#[derive(Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +struct DisplayCell { + c: char, + fg: Color, + bg: Color, + flags: Flags, + #[serde(default, skip_serializing_if = "Vec::is_empty")] + combining: Vec, + #[serde(default, skip_serializing_if = "Option::is_none")] + underline: Option, +} + +#[derive(Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +struct WireSnapshot { + columns: usize, + rows: Vec>, +} + +impl Serialize for DisplaySnapshot { + fn serialize(&self, serializer: S) -> Result { + WireSnapshot { + columns: self.columns, + rows: self + .rows + .iter() + .map(|row| { + row.iter() + .map(|cell| DisplayCell { + c: cell.c, + fg: cell.fg, + bg: cell.bg, + flags: cell.flags, + combining: cell.zerowidth().unwrap_or_default().to_vec(), + underline: cell.underline_color(), + }) + .collect() + }) + .collect(), + } + .serialize(serializer) + } +} + +impl<'de> Deserialize<'de> for DisplaySnapshot { + fn deserialize>(deserializer: D) -> Result { + let wire = WireSnapshot::deserialize(deserializer)?; + let snapshot = Self { + columns: wire.columns, + rows: wire + .rows + .into_iter() + .map(|row| { + row.into_iter() + .map(|value| { + let mut cell = Cell { + c: value.c, + fg: value.fg, + bg: value.bg, + flags: value.flags, + extra: None, + }; + for character in value.combining { + cell.push_zerowidth(character); + } + cell.set_underline_color(value.underline); + cell + }) + .collect() + }) + .collect(), + }; + snapshot.validate().map_err(serde::de::Error::custom)?; + Ok(snapshot) + } +} diff --git a/nebula_terminal/src/term/renderable.rs b/nebula_terminal/src/term/renderable.rs index 30049ba37..6f4f1ad59 100644 --- a/nebula_terminal/src/term/renderable.rs +++ b/nebula_terminal/src/term/renderable.rs @@ -1,6 +1,6 @@ //! Read-only terminal viewport assembled for the renderer. -use crate::grid::{Dimensions, GridIterator}; +use crate::grid::{Dimensions, Grid, GridIterator}; use crate::index::{Line, Point}; use crate::selection::SelectionRange; use crate::term::cell::{Cell, Flags}; @@ -8,6 +8,13 @@ use crate::term::color::Colors; use crate::term::{Term, TermMode}; use crate::vte::ansi::CursorShape; +impl Term { + /// 主屏显示数据;备用屏活动时仍保留普通命令的输出,不包含 TUI 内容。 + pub fn primary_grid(&self) -> &Grid { + if self.mode.contains(TermMode::ALT_SCREEN) { &self.inactive_grid } else { &self.grid } + } +} + /// Terminal cursor rendering information. #[derive(Copy, Clone, PartialEq, Eq)] pub struct RenderableCursor { From aa93047371e78772b4f711e5641c11c698544d15 Mon Sep 17 00:00:00 2001 From: galact <94279960+galact-byte@users.noreply.github.com> Date: Mon, 21 Sep 2026 13:47:13 +0800 Subject: [PATCH 02/13] docs(recent-output): fix decision note validation and refresh evidence --- .../2026-09-21-bounded-local-output.md | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/architecture/notes/nebula_app/recent_output/2026-09-21-bounded-local-output.md b/architecture/notes/nebula_app/recent_output/2026-09-21-bounded-local-output.md index 9c69753fb..3169475de 100644 --- a/architecture/notes/nebula_app/recent_output/2026-09-21-bounded-local-output.md +++ b/architecture/notes/nebula_app/recent_output/2026-09-21-bounded-local-output.md @@ -1,8 +1,9 @@ -# 本机有界命令输出恢复(#160) +# 本机有界命令输出恢复 ## Status -已实现并完成本机 Windows CMD 验证,待提交审核;尚未发布。 +已实现并完成本机 Windows CMD 验证,已提交至贡献分支供上游审核。 +对应 Issue #160;此记录不表示已合入上游或正式发布。 ## Context @@ -54,13 +55,17 @@ terminal 层只导出、导入静态显示数据,去除链接动作,不回 ## Validation -本机全量应用回归 1890 通过、0 失败、15 忽略;terminal 包 283 个单元测试、 -48 个集成测试及 1 个文档测试通过;i18n 合同 20 通过、1 忽略。 -架构检查使用基线 `5ce18ba0c4c82f13548ea2dca94d2078e22e11eb`,没有扩大预算。 +合并上游基线 `07afade392919c49b846c3e59556b43aef79be35` 后,另加入独立的 +CLI 补全修复 `f66ae68` 做组合应用回归:1948 通过、0 失败、15 忽略。 +本功能分支不包含该补全修复;此结果不表示未修复基线补全问题的独立分支全绿。 +terminal 包复测 284 个单元测试、48 个集成测试及 1 个文档测试通过。 +合并后 GPUI 构建、同一上游基线的架构检查和格式检查通过,没有扩大预算。 +i18n 合同此前为 20 通过、1 忽略,未将其计作合并后的重新执行结果。 实际 GPUI 构建验证 CMD 保存、关窗、重复重启、最近五条、多 pane 不串档、 恢复期变窄、备用屏排除和活跃 Pi 原生会话身份保持。Pi 使用本机合成服务, 不是云端兼容性证明。两 pane 大输出测试恢复各自尾部;本机计时不是通用性能保证。 +合并后新构建再次验证 CMD 保存、关窗、连续两次重启,原命令和输出各保留一份。 此前单线程全量测试曾超时,默认并行全量通过;没有删除或新增忽略该测试。 ## Supersedes From ec9fba4ba6d786665fbaa3935be010b36f26b40a Mon Sep 17 00:00:00 2001 From: galact <94279960+galact-byte@users.noreply.github.com> Date: Mon, 21 Sep 2026 15:22:37 +0800 Subject: [PATCH 03/13] fix(terminal): confirm recent output submissions on all platforms --- .../gpui_shell/terminal/view/completion.rs | 3 +- .../terminal/view/recent_output_tests.rs | 107 ++++++++++++++++++ 2 files changed, 108 insertions(+), 2 deletions(-) diff --git a/nebula_app/src/gpui_shell/terminal/view/completion.rs b/nebula_app/src/gpui_shell/terminal/view/completion.rs index 986a91d38..a80fbc605 100644 --- a/nebula_app/src/gpui_shell/terminal/view/completion.rs +++ b/nebula_app/src/gpui_shell/terminal/view/completion.rs @@ -6,7 +6,7 @@ use nebula_terminal::term::TermMode; impl TerminalView { /// Enter 提交:从 grid 读回显真值(screen truth)记入共享历史,然后清 - /// 行镜像。读法与旧壳 `nebula_commit_line` 的 Windows 契约一致:无法证明 + /// 行镜像。所有平台共享提示符/OSC 边界确认:无法证明 /// 是提示符的 REPL 行或中线编辑读不到就宁缺毋滥——键击重构的 /// line_buf 在光标移动/Tab 补全后就是拼接垃圾,不能进历史。Agent 已在 /// 前台时保留最初 shell 提示符,内部交互的 Enter 不得覆盖退出证据。 @@ -27,7 +27,6 @@ impl TerminalView { return; } self.suggest.pending_command_prompt = None; - #[cfg(windows)] if let Some(session) = &self.session { let term = session.term.lock(); if !term.mode().intersects(TermMode::ALT_SCREEN | TermMode::VI) { diff --git a/nebula_app/src/gpui_shell/terminal/view/recent_output_tests.rs b/nebula_app/src/gpui_shell/terminal/view/recent_output_tests.rs index 7c6617da5..096cab93e 100644 --- a/nebula_app/src/gpui_shell/terminal/view/recent_output_tests.rs +++ b/nebula_app/src/gpui_shell/terminal/view/recent_output_tests.rs @@ -350,6 +350,113 @@ fn batch_restore_reads_exact_references_and_skips_changed_panes(cx: &mut TestApp missing.update(first_window, |view, _| assert!(view.recent_output_snapshot().is_empty())); } +// Unlike startup_tests::feed, this drives the production OSC prompt lifecycle +// as well as VT parsing, without depending on the host OS or a native CMD marker. +fn shell_output(view: &mut TerminalView, bytes: &[u8], cx: &mut Context) { + let (_session, _input, mut events, proxy) = session::test_session_with_events(); + nebula_terminal::event_loop::StreamProcessor::default().feed( + &mut view.session.as_ref().unwrap().term.lock(), + &proxy, + bytes, + ); + while let Ok(event) = events.try_recv() { + view.process_event(event, cx); + } +} + +#[gpui::test] +fn local_unix_prompts_capture_commands_with_and_without_osc(cx: &mut TestAppContext) { + for (prefix, prompt) in [("", "dev@host:~/work$ "), ("\x1b]133;A\x07", "host% ")] { + let (view, window, _) = open(cx); + view.update(window, |view, cx| { + view.suggest.suggest_env = crate::display::SuggestEnv::Local; + shell_output(view, format!("{prefix}{prompt}printf saved").as_bytes(), cx); + view.suggest.line_buf = "printf saved".into(); + view.commit_line(cx); + assert_eq!(view.recent_output_snapshot().len(), 1); + view.write_input(b"\r".to_vec(), cx); + shell_output(view, b"\r\n\x1b]133;C\x07saved result\r\n\x1b]133;D;0\x07", cx); + shell_output(view, format!("{prefix}{prompt}not-submitted").as_bytes(), cx); + let text = restored_text(view); + assert!(text.contains("printf saved"), "{text:?}"); + assert!(text.contains("saved result"), "{text:?}"); + assert!(!text.contains("not-submitted"), "{text:?}"); + assert!(!view.command_running); + assert!(!view.native_prompt_seen); + }); + } +} + +#[gpui::test] +fn semantic_shell_prompt_uses_echo_not_stale_mirror_and_starts_next_record( + cx: &mut TestAppContext, +) { + let (view, window, _) = open(cx); + view.update(window, |view, cx| { + view.suggest.suggest_env = crate::display::SuggestEnv::Local; + for command in ["printf first", "printf second"] { + shell_output( + view, + format!("\x1b]133;A\x07custom :: \x1b]133;B\x07{command}").as_bytes(), + cx, + ); + view.suggest.line_buf = "stale-private-mirror".into(); + view.suggest.screen_line = "stale-screen".into(); + view.commit_line(cx); + assert_eq!(view.suggest.last_committed, command); + view.write_input(b"\r".to_vec(), cx); + shell_output(view, b"\r\n\x1b]133;C\x07result\r\n\x1b]133;D;0\x07", cx); + } + assert_eq!(view.recent_output_snapshot().len(), 2); + let text = restored_text(view); + assert!(text.find("printf first").unwrap() < text.find("printf second").unwrap()); + assert!(!text.contains("stale-private-mirror")); + assert!(!text.contains("stale-screen")); + }); +} + +#[gpui::test] +fn unconfirmed_unix_input_never_starts_output_capture(cx: &mut TestAppContext) { + for (screen, mirror) in [ + ("dev@host:~/work$ ", ""), + ("dev@host:~/work$ ", " "), + ("\x1b]133;A\x07custom :: \x1b]133;B\x07", "stale-private-mirror"), + ("Password: ", "invisible-secret"), + ("dev@host:~/work$ printf actual", "printf stale"), + ("\x1b]133;A\x07custom :: \x1b]133;B\x07\x1b]133;C\x07\r\nPassword: ", "invisible-secret"), + ("\x1b[?1049hdev@host:~/work$ tui-input", "tui-input"), + ] { + let (view, window, _) = open(cx); + view.update(window, |view, cx| { + view.suggest.suggest_env = crate::display::SuggestEnv::Local; + shell_output(view, screen.as_bytes(), cx); + view.suggest.line_buf = mirror.into(); + view.suggest.screen_line = "stale-screen".into(); + view.suggest.pending_command_prompt = Some("stale-prompt".into()); + view.commit_line(cx); + assert!(view.recent_output_snapshot().is_empty(), "{screen:?}"); + assert!(!view.recent_output_restore_closed, "{screen:?}"); + }); + } +} + +#[gpui::test] +fn agent_internal_enter_does_not_create_a_second_shell_record(cx: &mut TestAppContext) { + let (view, window, _) = open(cx); + view.update(window, |view, cx| { + view.suggest.suggest_env = crate::display::SuggestEnv::Local; + shell_output(view, b"\x1b]133;A\x07dev@host:~$ \x1b]133;B\x07pi", cx); + view.commit_line(cx); + view.write_input(b"\r".to_vec(), cx); + shell_output(view, b"\r\n\x1b]133;C\x07", cx); + feed(view, "❯ tool input".as_bytes()); + view.suggest.line_buf = "tool input".into(); + view.commit_line(cx); + assert_eq!(view.recent_output_snapshot().len(), 1); + assert_eq!(view.suggest.last_committed, "pi"); + }); +} + #[gpui::test] fn runtime_submission_records_echo_only_after_barrier(cx: &mut TestAppContext) { let (view, window, _) = open(cx); From 997e05fbcbfe8e247390f4939f2842c79c8c3334 Mon Sep 17 00:00:00 2001 From: galact <94279960+galact-byte@users.noreply.github.com> Date: Mon, 21 Sep 2026 15:44:36 +0800 Subject: [PATCH 04/13] fix(cli): sync Windows completions on output restore branch --- extra/completions/windows/_pebrel | 4 +++- extra/completions/windows/pebrel.bash | 10 +++++++++- extra/completions/windows/pebrel.fish | 2 ++ 3 files changed, 14 insertions(+), 2 deletions(-) diff --git a/extra/completions/windows/_pebrel b/extra/completions/windows/_pebrel index 6ae91d1e2..082fa2b22 100644 --- a/extra/completions/windows/_pebrel +++ b/extra/completions/windows/_pebrel @@ -1129,7 +1129,9 @@ _arguments "${_arguments_options[@]}" : \ ;; (setup-ai) _arguments "${_arguments_options[@]}" : \ -'--ssh=[Install or remove hooks on an SSH host (alias or user@host)]:DESTINATION:_default' \ +'(--wsl)--ssh=[Install or remove hooks on an SSH host (alias or user@host)]:DESTINATION:_default' \ +'--wsl=[Install or remove hooks in a WSL distribution'\''s own user configuration]:DISTRIBUTION:_default' \ +'--wsl-user=[WSL user; defaults to that distribution'\''s configured user]:USER:_default' \ '--remove[Remove Pebrel'\''s hooks from claude'\''s settings.json instead of installing them]' \ '-h[Print help]' \ '--help[Print help]' \ diff --git a/extra/completions/windows/pebrel.bash b/extra/completions/windows/pebrel.bash index 9f8c63f51..33b772210 100644 --- a/extra/completions/windows/pebrel.bash +++ b/extra/completions/windows/pebrel.bash @@ -3880,7 +3880,7 @@ _pebrel() { return 0 ;; pebrel__setup__ai) - opts="-h --remove --ssh --help" + opts="-h --remove --ssh --wsl --wsl-user --help" if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") ) return 0 @@ -3890,6 +3890,14 @@ _pebrel() { COMPREPLY=($(compgen -f "${cur}")) return 0 ;; + --wsl) + COMPREPLY=($(compgen -f "${cur}")) + return 0 + ;; + --wsl-user) + COMPREPLY=($(compgen -f "${cur}")) + return 0 + ;; *) COMPREPLY=() ;; diff --git a/extra/completions/windows/pebrel.fish b/extra/completions/windows/pebrel.fish index 7210a2be5..d1b4a4b76 100644 --- a/extra/completions/windows/pebrel.fish +++ b/extra/completions/windows/pebrel.fish @@ -519,6 +519,8 @@ complete -c pebrel -n "__fish_pebrel_using_subcommand config; and __fish_seen_su complete -c pebrel -n "__fish_pebrel_using_subcommand config; and __fish_seen_subcommand_from help" -f -a "help" -d 'Print this message or the help of the given subcommand(s)' complete -c pebrel -n "__fish_pebrel_using_subcommand notify-test" -s h -l help -d 'Print help' complete -c pebrel -n "__fish_pebrel_using_subcommand setup-ai" -l ssh -d 'Install or remove hooks on an SSH host (alias or user@host)' -r +complete -c pebrel -n "__fish_pebrel_using_subcommand setup-ai" -l wsl -d 'Install or remove hooks in a WSL distribution\'s own user configuration' -r +complete -c pebrel -n "__fish_pebrel_using_subcommand setup-ai" -l wsl-user -d 'WSL user; defaults to that distribution\'s configured user' -r complete -c pebrel -n "__fish_pebrel_using_subcommand setup-ai" -l remove -d 'Remove Pebrel\'s hooks from claude\'s settings.json instead of installing them' complete -c pebrel -n "__fish_pebrel_using_subcommand setup-ai" -s h -l help -d 'Print help' complete -c pebrel -n "__fish_pebrel_using_subcommand ssh" -s h -l help -d 'Print help' From ad812bb4ab9acce5581b6ad014ac8b6a69923759 Mon Sep 17 00:00:00 2001 From: galact <94279960+galact-byte@users.noreply.github.com> Date: Mon, 21 Sep 2026 23:12:58 +0800 Subject: [PATCH 05/13] test: fix Unix fixture collision and macOS path selection --- nebula_app/src/gpui_shell/workspace/details_panel_tests.rs | 5 +++-- nebula_app/src/platform/agent_integrations.rs | 2 +- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/nebula_app/src/gpui_shell/workspace/details_panel_tests.rs b/nebula_app/src/gpui_shell/workspace/details_panel_tests.rs index c679fe2ad..279a5545e 100644 --- a/nebula_app/src/gpui_shell/workspace/details_panel_tests.rs +++ b/nebula_app/src/gpui_shell/workspace/details_panel_tests.rs @@ -70,7 +70,8 @@ fn file_path_edit_navigates_and_keeps_the_last_directory_on_error_or_escape( cx.update(|window, cx| window.draw(cx).clear(cx)); let path_button = cx.debug_bounds("file-tree-path").unwrap(); cx.simulate_click(path_button.center(), Modifiers::default()); - cx.simulate_keystrokes("ctrl-a"); + let select_all = if cfg!(target_os = "macos") { "cmd-a" } else { "ctrl-a" }; + cx.simulate_keystrokes(select_all); cx.simulate_input("中文 folder"); cx.simulate_keystrokes("enter"); cx.run_until_parked(); @@ -103,7 +104,7 @@ fn file_path_edit_navigates_and_keeps_the_last_directory_on_error_or_escape( cx.update(|window, cx| window.draw(cx).clear(cx)); let path_button = cx.debug_bounds("file-tree-path").unwrap(); cx.simulate_click(path_button.center(), Modifiers::default()); - cx.simulate_keystrokes("ctrl-a"); + cx.simulate_keystrokes(select_all); cx.simulate_input("missing-directory"); cx.simulate_keystrokes("enter"); cx.run_until_parked(); diff --git a/nebula_app/src/platform/agent_integrations.rs b/nebula_app/src/platform/agent_integrations.rs index 01d5f92a5..1105be065 100644 --- a/nebula_app/src/platform/agent_integrations.rs +++ b/nebula_app/src/platform/agent_integrations.rs @@ -189,7 +189,7 @@ mod tests { let dir = tempfile::tempdir().unwrap(); let grok_dir = dir.path().join(".grok/bin"); let grok = executable(&grok_dir, "agent"); - let cursor_dir = dir.path().join("cursor-agent/versions/current"); + let cursor_dir = dir.path().join("installations/cursor-agent/versions/current"); let cursor = executable(&cursor_dir, "agent"); let dirs = vec![grok_dir, cursor_dir]; assert_eq!(find_executable(AgentKind::Cursor, &dirs), Some(cursor)); From 49a69428c22de0c78cd31aaff4337c109e1ed747 Mon Sep 17 00:00:00 2001 From: galact <94279960+galact-byte@users.noreply.github.com> Date: Wed, 23 Sep 2026 14:22:42 +0800 Subject: [PATCH 06/13] test: initialize output refs in workspace recovery fixture --- nebula_app/src/gpui_shell/workspace/tests.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/nebula_app/src/gpui_shell/workspace/tests.rs b/nebula_app/src/gpui_shell/workspace/tests.rs index a9da3d88f..8178dc3b0 100644 --- a/nebula_app/src/gpui_shell/workspace/tests.rs +++ b/nebula_app/src/gpui_shell/workspace/tests.rs @@ -867,6 +867,7 @@ mod boot_breaker_tests { launch: Some(launch), }), active_pane: 0, + output_refs: Vec::new(), }; // 第三次启动:磁盘上的计数已被 `mark_boot_attempt` 抬到 2。 let mut session = crate::session::Session::new(0, vec![tab]); From 5917c5f9c5c58d09da6cb8dddc8699546fdb9412 Mon Sep 17 00:00:00 2001 From: galact <94279960+galact-byte@users.noreply.github.com> Date: Sun, 27 Sep 2026 00:57:29 +0800 Subject: [PATCH 07/13] ci: rerun checks for recent output foundation From 2f9ae61982d977acc5c9d7fd9e8e36203459e436 Mon Sep 17 00:00:00 2001 From: galact <94279960+galact-byte@users.noreply.github.com> Date: Mon, 28 Sep 2026 16:18:33 +0800 Subject: [PATCH 08/13] fix: bound snapshot decoding and sanitize orphan wide-char flags Count rows, cells and per-cell combining characters while decoding and stop as soon as a budget is exceeded; charge the shared combining budget per cell. Capture and import share one wide-char flag normalization so an orphan leading spacer can no longer reach text extraction. Add a barrier test showing a clear queued during publication runs after it and keeps the output cleared. Local session references and primary-screen capture move to the pane-capture stage that uses them. --- .../2026-09-21-bounded-local-output.md | 4 +- ...09-28-bounded-display-snapshot-decoding.md | 59 ++++++++++ .../gpui_shell/workspace/session_recovery.rs | 1 - nebula_app/src/gpui_shell/workspace/tests.rs | 1 - .../src/recent_output/storage/lifecycle.rs | 54 +++++----- nebula_app/src/session.rs | 32 ++---- nebula_app/src/session/local_output.rs | 97 ----------------- .../src/window_context/session_snapshot.rs | 1 - nebula_terminal/src/grid/snapshot.rs | 102 ++++++++++++++---- .../src/grid/snapshot/serialization.rs | 96 ++++++++++++++++- nebula_terminal/src/term/renderable.rs | 9 +- 11 files changed, 274 insertions(+), 182 deletions(-) create mode 100644 architecture/notes/nebula_terminal/grid/2026-09-28-bounded-display-snapshot-decoding.md delete mode 100644 nebula_app/src/session/local_output.rs diff --git a/architecture/notes/nebula_app/recent_output/2026-09-21-bounded-local-output.md b/architecture/notes/nebula_app/recent_output/2026-09-21-bounded-local-output.md index 4223b6b5d..3b562ebb5 100644 --- a/architecture/notes/nebula_app/recent_output/2026-09-21-bounded-local-output.md +++ b/architecture/notes/nebula_app/recent_output/2026-09-21-bounded-local-output.md @@ -13,10 +13,10 @@ ## Evidence -- [显示快照与校验](../../../../nebula_terminal/src/grid/snapshot.rs)覆盖主屏、Unicode 重排、容量和控制数据拒绝。 +- [显示快照与校验](../../../../nebula_terminal/src/grid/snapshot.rs)覆盖 Unicode 重排、容量和控制数据拒绝;备用屏活动时读取主屏由第二项随采集接入。 - [有界输出存储](../../../../nebula_app/src/recent_output/storage.rs)复用原子文件写入。 - [发布生命周期](../../../../nebula_app/src/recent_output/storage/lifecycle.rs)的回归测试覆盖两代交接、失败重试和发布回调内失效。 -- [本机会话引用](../../../../nebula_app/src/session/local_output.rs)验证引用只随自动恢复格式保存,损坏引用不破坏布局恢复。 +- 本机会话引用(`session/local_output.rs`)随第二项的逐 pane 采集交付;本项存储测试以普通文件代替会话,只验证发布回调的提交语义。 ## Decision diff --git a/architecture/notes/nebula_terminal/grid/2026-09-28-bounded-display-snapshot-decoding.md b/architecture/notes/nebula_terminal/grid/2026-09-28-bounded-display-snapshot-decoding.md new file mode 100644 index 000000000..720e37f79 --- /dev/null +++ b/architecture/notes/nebula_terminal/grid/2026-09-28-bounded-display-snapshot-decoding.md @@ -0,0 +1,59 @@ +# 显示快照的有界解码与宽字符边界 + +## Status + +#235 的候选审计修正,待审核。沿用现有 JSON 字段,不改变后台发布协议。 + +## Context + +编码文件的字节限额不能代替解码对象限额。先反序列化嵌套 Vec 再 validate, +会在拒绝输入前分配大量空行、单元格或组合字符。宽字符占位参与文本提取和 +重排;行首孤立占位会使文本提取回退到负列。另一方面,终端删除半个宽字符 +后的重排可能留下孤立标志,严格拒绝会让正常编辑后的输出无法恢复。 + +## Evidence + +- [解码器](../../../../nebula_terminal/src/grid/snapshot/serialization.rs)原先先生成完整 WireSnapshot。 +- [快照回归测试](../../../../nebula_terminal/src/grid/snapshot.rs)用超限有效元素后接畸形尾部,证明解码必须先因预算失败;包括跨单元格累计组合字符。 +- 同处真实解析器测试覆盖中文、组合字符以及删除、插入、擦除后三种列宽的重排。 + +## Decision + +通过 serde DeserializeSeed 按行读取,每读入一个单元格即扣减预算。不信任 +size_hint,不按输入提示预分配。行、单元格与单格组合字符在读取中计数,累计组合 +字符在每个单元格读完后扣减;各项均不超过 262_144。后续 validate 仍检查尺寸和 +控制数据。保留 JSON 对象字段顺序无关的合同。 + +捕获与导入共用同一规范化:清除互斥宽字符标志、未配对的宽字符/占位以及错误位置 +的跨行前导占位,保留字符、颜色、组合字符和其他标志;末行跨行占位可以没有下一行。 +倒序处理确保前导占位看到已规范化的下一行。行首孤立占位因此不会进入文本提取; +活终端不变。 + +## Rejected alternatives + +- 只在整个 Vec 建成后校验:拒绝太晚,不能限制解码期间分配。 +- 每个单元格单独限制组合字符:无法限制所有单元格的累计量。 +- 导入严格拒绝畸形宽字符标志:需与捕获分设两套规则,且一个无效标志即丢弃整段输出。 +- 依赖 columns 已先读取:会破坏已有 JSON 字段顺序无关的格式。 +- 所有跨行占位必须有下一行:误拒绝合法的有界裁剪。 +- 直接修活网格:改变正常终端编辑行为。 + +## Consequences + +资源与结构校验属于 terminal 快照边界,不增加应用依赖、数据迁移或新配置。 +旧格式的正常快照继续可读;超预算或尺寸/控制数据畸形的快照拒绝,应用降级为无旧 +输出。无效宽字符标志仅从快照副本移除,不承诺修复终端核心的编辑行为。 + +## Validation + +`cargo test --offline --locked -p nebula_terminal --features serde` 全套通过。 +新测试在原解码器上失败(超限尾部被读取、孤立占位保留),并用真实解析器覆盖中文 +半字符删除/插入/擦除后在三种列宽下重排的正常快照不被改动。 + +## Supersedes + +None。 + +## Revisit when + +改变 wire 格式、快照资源上限、宽字符布局或主屏捕获边界时重新核验。 diff --git a/nebula_app/src/gpui_shell/workspace/session_recovery.rs b/nebula_app/src/gpui_shell/workspace/session_recovery.rs index 634bbbd4e..a529c7cc6 100644 --- a/nebula_app/src/gpui_shell/workspace/session_recovery.rs +++ b/nebula_app/src/gpui_shell/workspace/session_recovery.rs @@ -203,7 +203,6 @@ impl NebulaWorkspace { launch: Some(launch), layout: Some(layout), active_pane, - output_refs: Vec::new(), }); } Session::new(active_out, tabs) diff --git a/nebula_app/src/gpui_shell/workspace/tests.rs b/nebula_app/src/gpui_shell/workspace/tests.rs index 4f5d242f1..5d1769a92 100644 --- a/nebula_app/src/gpui_shell/workspace/tests.rs +++ b/nebula_app/src/gpui_shell/workspace/tests.rs @@ -914,7 +914,6 @@ mod boot_breaker_tests { launch: Some(launch), }), active_pane: 0, - output_refs: Vec::new(), }; // 第三次启动:磁盘上的计数已被 `mark_boot_attempt` 抬到 2。 let mut session = crate::session::Session::new(0, vec![tab]); diff --git a/nebula_app/src/recent_output/storage/lifecycle.rs b/nebula_app/src/recent_output/storage/lifecycle.rs index b71c255ee..08b83dfd9 100644 --- a/nebula_app/src/recent_output/storage/lifecycle.rs +++ b/nebula_app/src/recent_output/storage/lifecycle.rs @@ -415,29 +415,18 @@ mod tests { fn invalidation_inside_publication_reports_durable_session_and_keeps_old_reference() { let (dir, path, store) = store_fixture(); let session_path = dir.path().join("session.json"); - let mut old_session = crate::session::Session::new( - 0, - vec![crate::session::TabSession::single("C:/test".into(), None, None)], - ); - old_session.tabs[0].output_refs = vec!["old".into()]; archive("old").write_to(&path).unwrap(); - crate::session::save_local_to(&session_path, &old_session).unwrap(); - - let mut new_session = old_session.clone(); - new_session.tabs[0].output_refs = vec!["new".into()]; + std::fs::write(&session_path, "old").unwrap(); let generation = store.next_generation(); let published = store .save_referenced(generation, &archive("new"), Some(&["old".into()]), || { - crate::session::save_local_to(&session_path, &new_session)?; + std::fs::write(&session_path, "new")?; store.next_generation(); Ok(()) }) .unwrap(); assert!(published, "a written session cannot be reported as cancelled"); - assert_eq!( - crate::session::load_local_from(&session_path).unwrap().tabs[0].output_refs, - ["new"] - ); + assert_eq!(std::fs::read_to_string(&session_path).unwrap(), "new"); let mut staged = Archive::read_from(&path).unwrap(); assert!(staged.take_records("old").is_some()); assert!(staged.take_records("new").is_some()); @@ -456,21 +445,38 @@ mod tests { ); assert!(!session_path.exists()); let before = std::fs::read(&path).unwrap(); - let session = crate::session::Session::new( - 0, - vec![crate::session::TabSession::single("C:/test".into(), None, None)], - ); assert!( store - .publish_without_output(generation, || { - crate::session::save_local_to(&session_path, &session) - }) + .publish_without_output(generation, || std::fs::write(&session_path, "no refs")) .unwrap() ); assert_eq!(std::fs::read(&path).unwrap(), before); - assert!( - crate::session::load_local_from(&session_path).unwrap().tabs[0].output_refs.is_empty() - ); + assert_eq!(std::fs::read_to_string(&session_path).unwrap(), "no refs"); + } + + #[test] + fn clear_queued_during_publication_runs_after_it_and_stays_cleared() { + let (_dir, path, ref store) = store_fixture(); + let old = store.next_generation(); + let (entered, resume) = (std::sync::Barrier::new(2), std::sync::Barrier::new(2)); + std::thread::scope(|scope| { + let first = scope.spawn(|| { + store.save_and_publish(old, &archive("old"), || { + entered.wait(); + resume.wait(); + Ok(()) + }) + }); + entered.wait(); + // The UI invalidates without taking the disk writer lock. + let clear = store.next_generation(); + let second = scope.spawn(move || store.clear(clear)); + resume.wait(); + assert!(first.join().unwrap().unwrap(), "published session is durable"); + assert!(second.join().unwrap().unwrap()); + }); + assert!(!path.exists()); + assert!(!store.save(old, &archive("old")).unwrap()); } #[test] diff --git a/nebula_app/src/session.rs b/nebula_app/src/session.rs index 0277ba610..e58b6f61e 100644 --- a/nebula_app/src/session.rs +++ b/nebula_app/src/session.rs @@ -21,7 +21,6 @@ use serde::{Deserialize, Serialize}; use crate::display::color::Rgb; mod identity; -mod local_output; mod window_layout; pub(crate) use identity::codex_rollout_id; pub use window_layout::WindowLayout; @@ -207,23 +206,12 @@ pub struct TabSession { /// v4: focused leaf as a depth-first index into `layout`. #[serde(default)] pub active_pane: usize, - /// 本机 sidecar 的逐叶引用;共享工作区序列化始终排除。 - #[serde(skip)] - pub(crate) output_refs: Vec, } impl TabSession { /// A v3-shaped tab: one pane at `cwd`, default shell. pub fn single(cwd: String, custom_name: Option, color: Option) -> Self { - Self { - cwd, - custom_name, - color, - launch: None, - layout: None, - active_pane: 0, - output_refs: Vec::new(), - } + Self { cwd, custom_name, color, launch: None, layout: None, active_pane: 0 } } } @@ -280,7 +268,7 @@ impl Session { /// `%APPDATA%\Nebula\session.json` (or the `.config` fallback), next to the /// settings and history files. -pub(crate) fn session_path() -> PathBuf { +fn session_path() -> PathBuf { crate::display::nebula_data_dir().join("session.json") } @@ -297,11 +285,7 @@ fn parse(data: &str) -> Option { /// Load the previous session, if any and version-compatible. pub fn load() -> Option { - load_local_from(&session_path()) -} - -pub(crate) fn load_local_from(path: &Path) -> Option { - local_output::parse(&std::fs::read_to_string(path).ok()?) + load_from(&session_path()) } /// An update must not replace an unreadable workspace with an empty snapshot. @@ -313,7 +297,7 @@ pub(crate) fn load_update_windows() -> std::io::Result> { }, Err(error) => return Err(error), }; - let session = local_output::parse(&data).ok_or_else(|| { + let session = parse(&data).ok_or_else(|| { std::io::Error::new(std::io::ErrorKind::InvalidData, "Invalid saved workspace") })?; session.into_update_windows() @@ -334,12 +318,8 @@ pub fn save(session: &Session) { } pub(crate) fn try_save(session: &Session) -> std::io::Result<()> { - save_local_to(&session_path(), session) -} - -pub(crate) fn save_local_to(path: &Path, session: &Session) -> std::io::Result<()> { - let json = local_output::encode(session).map_err(std::io::Error::other)?; - crate::atomic_file::write(path, json.as_bytes()) + let json = serde_json::to_string(session).map_err(std::io::Error::other)?; + crate::atomic_file::write(&session_path(), json.as_bytes()) } /// Write a session as a named workspace file. Pretty-printed — workspace diff --git a/nebula_app/src/session/local_output.rs b/nebula_app/src/session/local_output.rs deleted file mode 100644 index d63b1f7ae..000000000 --- a/nebula_app/src/session/local_output.rs +++ /dev/null @@ -1,97 +0,0 @@ -//! 仅自动恢复文档携带输出引用;共享 Session 编码不含本机身份。 - -use super::Session; - -pub(super) fn encode(session: &Session) -> serde_json::Result { - #[derive(serde::Serialize)] - struct LocalSession<'a> { - #[serde(flatten)] - session: &'a Session, - local_output_refs: Vec<&'a [String]>, - } - serde_json::to_string(&LocalSession { - session, - local_output_refs: session.tabs.iter().map(|tab| tab.output_refs.as_slice()).collect(), - }) -} - -pub(super) fn parse(data: &str) -> Option { - let mut session = super::parse(data)?; - // 引用损坏仅丢弃历史,不使仍有效的布局与 AI 身份无法恢复。 - let value: serde_json::Value = serde_json::from_str(data).ok()?; - if let Some(refs) = value - .get("local_output_refs") - .and_then(|refs| serde_json::from_value::>>(refs.clone()).ok()) - { - let mut seen = std::collections::HashSet::new(); - let valid = refs.len() == session.tabs.len() - && refs.iter().zip(&session.tabs).all(|(ids, tab)| { - let leaves = tab.layout.as_ref().map_or(1, super::LayoutSession::pane_count); - (ids.is_empty() || ids.len() == leaves) - && ids.iter().all(|id| { - id.is_empty() - || (id.len() <= 128 - && id.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'-') - && seen.insert(id)) - }) - }); - if valid { - for (tab, ids) in session.tabs.iter_mut().zip(refs) { - tab.output_refs = ids; - } - } - } - Some(session) -} - -#[cfg(test)] -mod tests { - use super::*; - use crate::session::{TabSession, combine_sessions}; - - fn saved(id: &str) -> Session { - let mut tab = TabSession::single("C:/same-directory".into(), None, None); - tab.output_refs = vec![id.into()]; - Session::new(0, vec![tab]) - } - - #[test] - fn local_output_refs_survive_local_save_but_never_workspace_export_or_import() { - let original = saved("pane-one"); - let encoded = encode(&original).unwrap(); - assert_eq!(parse(&encoded).unwrap().tabs[0].output_refs, ["pane-one"]); - let dir = tempfile::tempdir().unwrap(); - let path = dir.path().join("workspace.json"); - crate::session::save_to(&path, &original).unwrap(); - let exported = std::fs::read_to_string(&path).unwrap(); - assert!(!exported.contains("pane-one")); - // 即使输入的是本机自动存档,手动工作区导入仍不能带入引用。 - std::fs::write(&path, encoded).unwrap(); - assert!(crate::session::load_from(&path).unwrap().tabs[0].output_refs.is_empty()); - } - - #[test] - fn local_output_refs_follow_tabs_when_combining_and_restoring_windows() { - let combined = - combine_sessions([(false, saved("pane-one")), (true, saved("pane-two"))]).unwrap(); - let windows = parse(&encode(&combined).unwrap()).unwrap().into_update_windows().unwrap(); - assert_eq!(windows[0].tabs[0].output_refs, ["pane-one"]); - assert_eq!(windows[1].tabs[0].output_refs, ["pane-two"]); - } - - #[test] - fn malformed_local_output_refs_do_not_break_layout_recovery() { - let mut value = serde_json::to_value(saved("unused")).unwrap(); - for invalid in [ - serde_json::json!([["../escape"]]), - serde_json::json!([["one", "two"]]), - serde_json::json!([["same"], ["extra-tab"]]), - serde_json::json!("broken"), - ] { - value["local_output_refs"] = invalid; - let session = parse(&value.to_string()).unwrap(); - assert_eq!(session.tabs.len(), 1); - assert!(session.tabs[0].output_refs.is_empty()); - } - } -} diff --git a/nebula_app/src/window_context/session_snapshot.rs b/nebula_app/src/window_context/session_snapshot.rs index 19ce8a194..c449b39bc 100644 --- a/nebula_app/src/window_context/session_snapshot.rs +++ b/nebula_app/src/window_context/session_snapshot.rs @@ -77,7 +77,6 @@ impl WindowContext { launch: Some(Self::launch_session(&tab.launch)), layout: Some(Self::layout_session(&tab.layout, &pane_cwd, &pane_agent)), active_pane: leaves.iter().position(|id| *id == tab.active_pane).unwrap_or(0), - output_refs: Vec::new(), } } diff --git a/nebula_terminal/src/grid/snapshot.rs b/nebula_terminal/src/grid/snapshot.rs index d0f6bb7c6..db4792b46 100644 --- a/nebula_terminal/src/grid/snapshot.rs +++ b/nebula_terminal/src/grid/snapshot.rs @@ -2,13 +2,15 @@ use super::{Dimensions, Grid}; use crate::index::{Column, Line}; -use crate::term::cell::Cell; +use crate::term::cell::{Cell, Flags}; #[cfg(feature = "serde")] mod serialization; // 解码后的防灾上限;持久化层还须独立限制每条记录的编码字节数。 const MAX_SNAPSHOT_CELLS: usize = 262_144; +const WIDE_FLAGS: Flags = + Flags::WIDE_CHAR.union(Flags::WIDE_CHAR_SPACER).union(Flags::LEADING_WIDE_CHAR_SPACER); #[derive(Clone, Debug, Default)] pub struct DisplaySnapshot { @@ -24,7 +26,7 @@ impl DisplaySnapshot { let start = range.start.0.max(-(grid.history_size() as i32)); let start = start.max(end.saturating_sub((max_cells / columns).min(i32::MAX as usize) as i32)); - let rows = (start..end) + let rows: Vec> = (start..end) .map(|line| { (0..columns) .map(|column| { @@ -35,7 +37,39 @@ impl DisplaySnapshot { .collect() }) .collect(); - Self { columns, rows } + let mut snapshot = Self { columns, rows }; + snapshot.sanitize_wide_flags(); + snapshot + } + + /// 删半个宽字符等编辑或外部文件会留下孤立标志;只清理副本,不动活终端。 + fn sanitize_wide_flags(&mut self) { + for line in (0..self.rows.len()).rev() { + for column in (0..self.rows[line].len()).rev() { + let row = &self.rows[line]; + let is = |cell: Option<&Cell>, flags| { + cell.is_some_and(|cell| cell.flags & WIDE_FLAGS == flags) + }; + let valid = match row[column].flags & WIDE_FLAGS { + Flags::WIDE_CHAR => is(row.get(column + 1), Flags::WIDE_CHAR_SPACER), + Flags::WIDE_CHAR_SPACER => { + is(column.checked_sub(1).and_then(|c| row.get(c)), Flags::WIDE_CHAR) + }, + Flags::LEADING_WIDE_CHAR_SPACER => { + column + 1 == self.columns + && row[column].flags.contains(Flags::WRAPLINE) + && self + .rows + .get(line + 1) + .is_none_or(|next| is(next.first(), Flags::WIDE_CHAR)) + }, + flags => flags.is_empty(), + }; + if !valid { + self.rows[line][column].flags.remove(WIDE_FLAGS); + } + } + } } fn validate(&self) -> Result<(), &'static str> { @@ -95,21 +129,6 @@ mod tests { use crate::term::{Config, Term, test::TermSize}; use crate::vte::ansi; - #[test] - fn captures_primary_screen_while_alternate_screen_is_active() { - let mut term = Term::new(Config::default(), &TermSize::new(8, 2), VoidListener); - let mut parser: ansi::Processor = ansi::Processor::new(); - parser.advance(&mut term, b"main"); - parser.advance(&mut term, b"\x1b[?1049halt"); - assert_eq!(term.grid()[Line(0)][Column(4)].c, 'a'); - - let snapshot = DisplaySnapshot::capture(term.primary_grid(), Line(0)..Line(1), 8); - let mut target = Grid::::new(2, 8, 10); - snapshot.restore_scrollback(&mut target).unwrap(); - assert_eq!(target[Line(-1)][Column(0)].c, 'm'); - assert_eq!(target[Line(-1)][Column(1)].c, 'a'); - } - #[test] fn restores_reflowed_unicode_before_existing_history_without_touching_prompt() { let mut source = Term::new(Config::default(), &TermSize::new(8, 3), VoidListener); @@ -179,6 +198,53 @@ mod tests { assert!(serde_json::from_value::(value).is_err()); } + #[cfg(feature = "serde")] + #[test] + fn decoding_stops_at_budget_before_reading_malformed_tail() { + let one = DisplaySnapshot { columns: 1, rows: vec![vec![Cell::default()]] }; + let cell = serde_json::to_value(&one).unwrap()["rows"][0][0].to_string(); + let cell = cell.trim_end_matches('}'); + let chars = |n| "\"a\",".repeat(n); + let half = format!(r#"{cell},"combining":[{}"a"]}}"#, chars(131_071)); + for input in [ + format!(r#"{{"columns":1,"rows":[{}"bad"]}}"#, "[],".repeat(262_145)), + format!(r#"{{"columns":1,"rows":[[{}"bad"]]}}"#, format!("{cell}}},").repeat(262_145)), + format!(r#"{{"columns":1,"rows":[[{cell},"combining":[{}"bad"]}}]]}}"#, chars(262_145)), + format!(r#"{{"columns":3,"rows":[[{half},{half},{cell},"combining":["a"]}},"bad"]]}}"#), + ] { + let error = serde_json::from_str::(&input).unwrap_err(); + assert!(error.to_string().contains("decode budget"), "{error}"); + } + } + + #[cfg(feature = "serde")] + #[test] + fn strips_orphan_wide_flags_from_files_and_edited_screens() { + let flags = [Flags::WIDE_CHAR_SPACER, Flags::WIDE_CHAR | Flags::WIDE_CHAR_SPACER]; + let malformed = DisplaySnapshot { + columns: 2, + rows: vec![flags.map(|flags| Cell { flags, ..Cell::default() }).to_vec()], + }; + let decoded: DisplaySnapshot = + serde_json::from_value(serde_json::to_value(&malformed).unwrap()).unwrap(); + assert!(decoded.rows[0].iter().all(|cell| !cell.flags.intersects(WIDE_FLAGS))); + for edit in ["", "\x1b[1;6H\x1b[P", "\x1b[1;5H\x1b[@", "\x1b[1;6H\x1b[K"] { + for columns in [3, 5, 12] { + let mut source = Term::new(Config::default(), &TermSize::new(8, 3), VoidListener); + let mut parser: ansi::Processor = ansi::Processor::new(); + parser.advance(&mut source, format!("abcd中文e\u{301}\r\n{edit}").as_bytes()); + source.resize(TermSize::new(columns, 3)); + let snapshot = DisplaySnapshot::capture(source.grid(), Line(-10)..Line(3), 100); + let mut copy = snapshot.clone(); + copy.sanitize_wide_flags(); + assert_eq!(format!("{copy:?}"), format!("{snapshot:?}"), "{edit:?} {columns}"); + let json = serde_json::to_value(&snapshot).unwrap(); + let rows_first = format!(r#"{{"rows":{},"columns":{columns}}}"#, json["rows"]); + serde_json::from_str::(&rows_first).unwrap(); + } + } + } + #[test] fn rejects_malformed_rows_before_changing_live_grid() { let mut target = Grid::::new(2, 4, 10); diff --git a/nebula_terminal/src/grid/snapshot/serialization.rs b/nebula_terminal/src/grid/snapshot/serialization.rs index 05039bbec..538890da6 100644 --- a/nebula_terminal/src/grid/snapshot/serialization.rs +++ b/nebula_terminal/src/grid/snapshot/serialization.rs @@ -1,8 +1,9 @@ //! 持久化只暴露显示字段;不沿用 Cell 的链接及未来协议字段。 +use serde::de::{DeserializeSeed, Error, SeqAccess, Visitor}; use serde::{Deserialize, Deserializer, Serialize, Serializer}; -use super::DisplaySnapshot; +use super::{DisplaySnapshot, MAX_SNAPSHOT_CELLS}; use crate::term::cell::{Cell, Flags}; use crate::vte::ansi::Color; @@ -13,7 +14,7 @@ struct DisplayCell { fg: Color, bg: Color, flags: Flags, - #[serde(default, skip_serializing_if = "Vec::is_empty")] + #[serde(default, deserialize_with = "decode_combining", skip_serializing_if = "Vec::is_empty")] combining: Vec, #[serde(default, skip_serializing_if = "Option::is_none")] underline: Option, @@ -23,9 +24,95 @@ struct DisplayCell { #[serde(deny_unknown_fields)] struct WireSnapshot { columns: usize, + #[serde(deserialize_with = "decode_rows")] rows: Vec>, } +// 解码中计数:字节上限挡不住 `[]` 空行等在内存中的放大。 +fn over() -> E { + E::custom("display snapshot exceeds decode budget") +} + +fn decode_combining<'de, D: Deserializer<'de>>(deserializer: D) -> Result, D::Error> { + struct Chars; + impl<'de> Visitor<'de> for Chars { + type Value = Vec; + + fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str("combining characters") + } + + fn visit_seq>(self, mut seq: A) -> Result, A::Error> { + let mut chars = Vec::new(); + while let Some(c) = seq.next_element()? { + if chars.len() == MAX_SNAPSHOT_CELLS { + return Err(over()); + } + chars.push(c); + } + Ok(chars) + } + } + deserializer.deserialize_seq(Chars) +} + +struct Budget { + cells: usize, + combining: usize, +} + +impl<'de> DeserializeSeed<'de> for &mut Budget { + type Value = Vec; + + fn deserialize>(self, deserializer: D) -> Result { + deserializer.deserialize_seq(self) + } +} + +impl<'de> Visitor<'de> for &mut Budget { + type Value = Vec; + + fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str("display row") + } + + fn visit_seq>(self, mut seq: A) -> Result { + let mut row = Vec::new(); + while let Some(cell) = seq.next_element::()? { + self.cells = self.cells.checked_sub(1).ok_or_else(over)?; + self.combining = self.combining.checked_sub(cell.combining.len()).ok_or_else(over)?; + row.push(cell); + } + Ok(row) + } +} + +fn decode_rows<'de, D: Deserializer<'de>>( + deserializer: D, +) -> Result>, D::Error> { + struct Rows; + impl<'de> Visitor<'de> for Rows { + type Value = Vec>; + + fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str("display rows") + } + + fn visit_seq>(self, mut seq: A) -> Result { + let mut budget = Budget { cells: MAX_SNAPSHOT_CELLS, combining: MAX_SNAPSHOT_CELLS }; + let mut rows = Vec::new(); + while let Some(row) = seq.next_element_seed(&mut budget)? { + if rows.len() == MAX_SNAPSHOT_CELLS { + return Err(over()); + } + rows.push(row); + } + Ok(rows) + } + } + deserializer.deserialize_seq(Rows) +} + impl Serialize for DisplaySnapshot { fn serialize(&self, serializer: S) -> Result { WireSnapshot { @@ -54,7 +141,7 @@ impl Serialize for DisplaySnapshot { impl<'de> Deserialize<'de> for DisplaySnapshot { fn deserialize>(deserializer: D) -> Result { let wire = WireSnapshot::deserialize(deserializer)?; - let snapshot = Self { + let mut snapshot = Self { columns: wire.columns, rows: wire .rows @@ -79,7 +166,8 @@ impl<'de> Deserialize<'de> for DisplaySnapshot { }) .collect(), }; - snapshot.validate().map_err(serde::de::Error::custom)?; + snapshot.sanitize_wide_flags(); + snapshot.validate().map_err(Error::custom)?; Ok(snapshot) } } diff --git a/nebula_terminal/src/term/renderable.rs b/nebula_terminal/src/term/renderable.rs index 6f4f1ad59..30049ba37 100644 --- a/nebula_terminal/src/term/renderable.rs +++ b/nebula_terminal/src/term/renderable.rs @@ -1,6 +1,6 @@ //! Read-only terminal viewport assembled for the renderer. -use crate::grid::{Dimensions, Grid, GridIterator}; +use crate::grid::{Dimensions, GridIterator}; use crate::index::{Line, Point}; use crate::selection::SelectionRange; use crate::term::cell::{Cell, Flags}; @@ -8,13 +8,6 @@ use crate::term::color::Colors; use crate::term::{Term, TermMode}; use crate::vte::ansi::CursorShape; -impl Term { - /// 主屏显示数据;备用屏活动时仍保留普通命令的输出,不包含 TUI 内容。 - pub fn primary_grid(&self) -> &Grid { - if self.mode.contains(TermMode::ALT_SCREEN) { &self.inactive_grid } else { &self.grid } - } -} - /// Terminal cursor rendering information. #[derive(Copy, Clone, PartialEq, Eq)] pub struct RenderableCursor { From 8f25ca1f5c5ca4a88db97a0c55c30112db93a867 Mon Sep 17 00:00:00 2001 From: galact <94279960+galact-byte@users.noreply.github.com> Date: Thu, 1 Oct 2026 14:20:18 +0800 Subject: [PATCH 09/13] ci: retrigger checks after windows-11-arm runner lost communication From 00eec872cac71e37ed061aa55032474b6b777869 Mon Sep 17 00:00:00 2001 From: galact <94279960+galact-byte@users.noreply.github.com> Date: Sun, 18 Oct 2026 19:49:55 +0800 Subject: [PATCH 10/13] ci: retry native checks after upstream animation test failure From a2b93a5ef1fe3040d6230c4d6674c2dfc42ec823 Mon Sep 17 00:00:00 2001 From: Aschenbath Date: Sat, 31 Oct 2026 18:35:19 +0000 Subject: [PATCH 11/13] feat(cli): allow explicit independent GPUI instances --- .../2026-10-31-explicit-new-instance.md | 79 +++++++++++++ docs/runtime-control-api.md | 10 ++ extra/completions/_pebrel | 1 + extra/completions/pebrel.bash | 2 +- extra/completions/pebrel.fish | 3 +- extra/completions/windows/_pebrel | 1 + extra/completions/windows/pebrel.bash | 2 +- extra/completions/windows/pebrel.fish | 3 +- nebula_app/AGENTS.md | 2 +- nebula_app/src/cli.rs | 25 ++++ nebula_app/src/gpui_shell/mod.rs | 18 +-- .../src/gpui_shell/workspace/residency.rs | 4 +- .../workspace/session_persistence.rs | 2 +- .../workspace/windowing/new_instance_tests.rs | 110 ++++++++++++++++++ .../gpui_shell/workspace/windowing/startup.rs | 10 +- .../workspace/windowing/startup_geometry.rs | 2 +- nebula_app/src/main.rs | 4 +- nebula_app/src/platform/startup.rs | 2 + nebula_app/src/platform/startup/instance.rs | 21 ++++ nebula_app/src/runtime_api/server.rs | 2 +- 20 files changed, 282 insertions(+), 21 deletions(-) create mode 100644 architecture/notes/nebula_app/platform/startup/2026-10-31-explicit-new-instance.md create mode 100644 nebula_app/src/gpui_shell/workspace/windowing/new_instance_tests.rs create mode 100644 nebula_app/src/platform/startup/instance.rs diff --git a/architecture/notes/nebula_app/platform/startup/2026-10-31-explicit-new-instance.md b/architecture/notes/nebula_app/platform/startup/2026-10-31-explicit-new-instance.md new file mode 100644 index 000000000..fcb235f11 --- /dev/null +++ b/architecture/notes/nebula_app/platform/startup/2026-10-31-explicit-new-instance.md @@ -0,0 +1,79 @@ +# Explicit independent GUI launches + +## Status + +Proposed in the implementation PR for issue #348. + +## Context + +Ordinary launches hand their directory and shell to the resident process. Issue +#348 requests a way to start another process. Skipping only the initial handover +is insufficient: GPUI also hands over after losing the runtime ownership lock. +Continuing without a runtime server would leave that process's panes without +their own control endpoint, while session checkpoints could overwrite the +resident's saved workspace. + +## Evidence + +[`main::try_hand_over_to_resident`](../../../../../nebula_app/src/main.rs) and +[`gpui_shell::run_shell`](../../../../../nebula_app/src/gpui_shell/mod.rs) implement +the two handover paths. +[`RuntimeServer::spawn_at`](../../../../../nebula_app/src/runtime_api/server.rs) +already supports an unpublished endpoint and exports it to terminal children. +[`SessionPersistence`](../../../../../nebula_app/src/gpui_shell/workspace/session_persistence.rs) +already supports in-memory snapshots for isolated windows. Both facilities previously selected +that scope only through the elevation policy. + +## Decision + +Record the explicit `--new-instance` intent once after CLI parsing. Startup +ownership uses one predicate combining that intent with the existing elevation +requirement. The explicit option is limited to GPUI launches. + +The process starts a fresh terminal, owns an unpublished runtime endpoint, and +keeps automatic workspace snapshots in memory. Its children receive that +endpoint even when the process was launched from another Pebrel terminal. +Closing its last window exits instead of hiding an undiscoverable resident. +Ordinary launches retain their current handover, discovery, and session policy. + +The explicit launch also bypasses elevated handover and automatic restoration +or installation of a previously scheduled update. Saved mobile connections are +not automatically resumed by the extra instance. Settings and other user data +remain shared; this option is not a separate configuration profile. + +## Rejected alternatives + +- Skip handover but keep shared discovery: the resident lock still prevents a + runtime server, and clients can target the wrong process. +- Overwrite `runtime.port`: redirects existing clients and competes with the + resident's cleanup. +- Export an inherited environment flag: every nested invocation would silently + acquire the same launch policy instead of requiring explicit intent. +- Create a temporary settings tree: changes configuration and persistence + semantics beyond the requested process separation. + +## Consequences + +Independent windows do not participate in ordinary session restoration. Users +can still explicitly export a workspace. No dependencies, protocol fields, or +new persisted settings are introduced. The startup flag is immutable for the +process lifetime and does not alter privilege detection. + +## Validation + +[CLI regression coverage](../../../../../nebula_app/src/cli.rs) checks terminal +launch arguments. The [independent-instance tests](../../../../../nebula_app/src/gpui_shell/workspace/windowing/new_instance_tests.rs) +check incompatible launch modes. A subprocess test uses the real startup +predicate and runtime constructor while the resident discovery lock is held, +verifies the child endpoint with a PING, and checks shared discovery and session +bytes after checkpoints, close, quit, and server drop. This is process and socket evidence, not native desktop +visual acceptance. + +## Supersedes + +None. + +## Revisit when + +Independent instances need persistent profiles or per-instance update recovery; +those need explicit storage ownership rather than shared-file overwrites. diff --git a/docs/runtime-control-api.md b/docs/runtime-control-api.md index a09a76658..0717e6198 100644 --- a/docs/runtime-control-api.md +++ b/docs/runtime-control-api.md @@ -59,6 +59,16 @@ CLI 路径由环境给出,调用方无需根据展示名称猜测文件名。 ## CLI +### 独立进程 + +`pebrel --new-instance` 在新的 GPUI 进程中打开一个全新终端。它支持通常的 +`--working-directory`、`--shell` 和 `-e` 参数,不交给已经运行的实例。 +配置仍然共享;该进程不恢复或自动保存普通工作区,关闭最后一个窗口时退出。 + +独立进程不替换共享的 `runtime.port`。它的本地终端通过继承的 +`PEBREL_RUNTIME_ENDPOINT` 访问自己的控制面,因此应在对应终端中运行 +`pebrel pane list` 等命令。已有实例及其终端继续使用自己的控制面。 + ### 资源 + 动词 面向"模型在 pane 里临时要派个活儿"这一种用法。命名用 CLI 界的通用惯例(资源在前、动词在后, diff --git a/extra/completions/_pebrel b/extra/completions/_pebrel index 5ea827504..f12c3f9aa 100644 --- a/extra/completions/_pebrel +++ b/extra/completions/_pebrel @@ -31,6 +31,7 @@ _pebrel() { '(--daemon)--ref-test[Generates ref test]' \ '--gpui[Launch the GPUI UI shell as the main window]' \ '--launched-at-login[Identify a launch from the per-user login item]' \ +'(--daemon --ref-test --launched-at-login)--new-instance[Start a separate GPUI process with a fresh, unsaved workspace]' \ '(-v)*-q[Reduces the level of verbosity (the min level is -qq)]' \ '(-q)*-v[Increases the level of verbosity (the max level is -vvv)]' \ '--daemon[Do not spawn an initial window]' \ diff --git a/extra/completions/pebrel.bash b/extra/completions/pebrel.bash index 3d4b977f2..d94c1bf77 100644 --- a/extra/completions/pebrel.bash +++ b/extra/completions/pebrel.bash @@ -677,7 +677,7 @@ _pebrel() { case "${cmd}" in pebrel) - opts="-q -v -e -T -o -h -V --print-events --ref-test --embed --gpui --launched-at-login --config-file --socket --daemon --working-directory --shell --hold --command --title --class --option --help --version [DIRECTORY] predict view ctl env window tab pane agent migrate config plugin theme setup-ai help" + opts="-q -v -e -T -o -h -V --print-events --ref-test --embed --gpui --launched-at-login --new-instance --config-file --socket --daemon --working-directory --shell --hold --command --title --class --option --help --version [DIRECTORY] predict view ctl env window tab pane agent migrate config plugin theme setup-ai help" if [[ ${cur} == -* || ${COMP_CWORD} -eq 1 ]] ; then COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") ) return 0 diff --git a/extra/completions/pebrel.fish b/extra/completions/pebrel.fish index 60d606f72..0dd0fe2a6 100644 --- a/extra/completions/pebrel.fish +++ b/extra/completions/pebrel.fish @@ -1,6 +1,6 @@ # Print an optspec for argparse to handle cmd's options that are independent of any subcommand. function __fish_pebrel_global_optspecs - string join \n print-events ref-test embed= gpui launched-at-login config-file= socket= q v daemon working-directory= shell= hold e/command= T/title= class= o/option= h/help V/version + string join \n print-events ref-test embed= gpui launched-at-login new-instance config-file= socket= q v daemon working-directory= shell= hold e/command= T/title= class= o/option= h/help V/version end function __fish_pebrel_needs_command @@ -37,6 +37,7 @@ complete -c pebrel -n "__fish_pebrel_needs_command" -l print-events -d 'Print al complete -c pebrel -n "__fish_pebrel_needs_command" -l ref-test -d 'Generates ref test' complete -c pebrel -n "__fish_pebrel_needs_command" -l gpui -d 'Launch the GPUI UI shell as the main window' complete -c pebrel -n "__fish_pebrel_needs_command" -l launched-at-login -d 'Identify a launch from the per-user login item' +complete -c pebrel -n "__fish_pebrel_needs_command" -l new-instance -d 'Start a separate GPUI process with a fresh, unsaved workspace' complete -c pebrel -n "__fish_pebrel_needs_command" -s q -d 'Reduces the level of verbosity (the min level is -qq)' complete -c pebrel -n "__fish_pebrel_needs_command" -s v -d 'Increases the level of verbosity (the max level is -vvv)' complete -c pebrel -n "__fish_pebrel_needs_command" -l daemon -d 'Do not spawn an initial window' diff --git a/extra/completions/windows/_pebrel b/extra/completions/windows/_pebrel index 2e29d9a74..d3d98b91c 100644 --- a/extra/completions/windows/_pebrel +++ b/extra/completions/windows/_pebrel @@ -30,6 +30,7 @@ _pebrel() { '(--daemon)--ref-test[Generates ref test]' \ '--gpui[Launch the GPUI UI shell as the main window]' \ '--launched-at-login[Identify a launch from the per-user login item]' \ +'(--daemon --ref-test --launched-at-login)--new-instance[Start a separate GPUI process with a fresh, unsaved workspace]' \ '(-v)*-q[Reduces the level of verbosity (the min level is -qq)]' \ '(-q)*-v[Increases the level of verbosity (the max level is -vvv)]' \ '--daemon[Do not spawn an initial window]' \ diff --git a/extra/completions/windows/pebrel.bash b/extra/completions/windows/pebrel.bash index 60a7d8ced..8b13024a0 100644 --- a/extra/completions/windows/pebrel.bash +++ b/extra/completions/windows/pebrel.bash @@ -689,7 +689,7 @@ _pebrel() { case "${cmd}" in pebrel) - opts="-q -v -e -T -o -h -V --print-events --ref-test --embed --gpui --launched-at-login --config-file --daemon --working-directory --shell --hold --command --title --class --option --help --version [DIRECTORY] predict view ctl env window tab pane agent migrate config plugin theme notify-test setup-ai ssh help" + opts="-q -v -e -T -o -h -V --print-events --ref-test --embed --gpui --launched-at-login --new-instance --config-file --daemon --working-directory --shell --hold --command --title --class --option --help --version [DIRECTORY] predict view ctl env window tab pane agent migrate config plugin theme notify-test setup-ai ssh help" if [[ ${cur} == -* || ${COMP_CWORD} -eq 1 ]] ; then COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") ) return 0 diff --git a/extra/completions/windows/pebrel.fish b/extra/completions/windows/pebrel.fish index 566e23b79..35e851260 100644 --- a/extra/completions/windows/pebrel.fish +++ b/extra/completions/windows/pebrel.fish @@ -1,6 +1,6 @@ # Print an optspec for argparse to handle cmd's options that are independent of any subcommand. function __fish_pebrel_global_optspecs - string join \n print-events ref-test embed= gpui launched-at-login config-file= q v daemon working-directory= shell= hold e/command= T/title= class= o/option= h/help V/version + string join \n print-events ref-test embed= gpui launched-at-login new-instance config-file= q v daemon working-directory= shell= hold e/command= T/title= class= o/option= h/help V/version end function __fish_pebrel_needs_command @@ -36,6 +36,7 @@ complete -c pebrel -n "__fish_pebrel_needs_command" -l print-events -d 'Print al complete -c pebrel -n "__fish_pebrel_needs_command" -l ref-test -d 'Generates ref test' complete -c pebrel -n "__fish_pebrel_needs_command" -l gpui -d 'Launch the GPUI UI shell as the main window' complete -c pebrel -n "__fish_pebrel_needs_command" -l launched-at-login -d 'Identify a launch from the per-user login item' +complete -c pebrel -n "__fish_pebrel_needs_command" -l new-instance -d 'Start a separate GPUI process with a fresh, unsaved workspace' complete -c pebrel -n "__fish_pebrel_needs_command" -s q -d 'Reduces the level of verbosity (the min level is -qq)' complete -c pebrel -n "__fish_pebrel_needs_command" -s v -d 'Increases the level of verbosity (the max level is -vvv)' complete -c pebrel -n "__fish_pebrel_needs_command" -l daemon -d 'Do not spawn an initial window' diff --git a/nebula_app/AGENTS.md b/nebula_app/AGENTS.md index 05bb3b298..a5a3edff3 100644 --- a/nebula_app/AGENTS.md +++ b/nebula_app/AGENTS.md @@ -28,4 +28,4 @@ - 管理员更新的受保护目录与会话恢复分别见 [`update_installation`](../architecture/notes/nebula_app/platform/update_installation/) 和 [`update_download`](../architecture/notes/nebula_app/update_download/),普通会话与管理员更新状态保持独立。 - Windows Acrylic 的运行库回退与窗口生命周期见 [`platform`](../architecture/notes/nebula_app/platform/2026-09-22-acrylic-controller.md)。 - Windows Acrylic 的动画期间透明回退与计时边界见 [`窗口状态切换`](../architecture/notes/nebula_app/platform/2026-09-22-acrylic-window-transitions.md)。 -- 登录项的启动意图与首窗静默边界见 [`登录启动`](../architecture/notes/nebula_app/platform/startup/2026-10-10-login-launch-intent.md)。 +- 登录项的启动意图、首窗静默与显式独立实例的运行时和会话归属见 [`启动边界`](../architecture/notes/nebula_app/platform/startup/)。 diff --git a/nebula_app/src/cli.rs b/nebula_app/src/cli.rs index 75a4ee1da..c3db37fe7 100644 --- a/nebula_app/src/cli.rs +++ b/nebula_app/src/cli.rs @@ -52,6 +52,14 @@ pub struct Options { #[clap(long = "launched-at-login", hide = true)] pub launched_at_login: bool, + /// Start a separate GPUI process with a fresh, unsaved workspace. + /// + /// Shares settings; leaves the resident instance and saved session untouched. + #[cfg(feature = "gpui-shell")] + #[clap(long, conflicts_with_all = ["daemon", "ref_test", "launched_at_login"])] + #[cfg_attr(feature = "legacy-shell", clap(conflicts_with = "legacy_shell"))] + pub new_instance: bool, + /// Launch the legacy winit shell instead of GPUI. #[cfg(all(feature = "gpui-shell", feature = "legacy-shell"))] #[clap(long = "legacy-shell")] @@ -1504,6 +1512,23 @@ mod tests { assert!(terminal.command.is_empty()); } + #[cfg(feature = "gpui-shell")] + #[test] + fn new_instance_accepts_explicit_terminal_options() { + let options = Options::try_parse_from([ + "pebrel", + "--new-instance", + "--working-directory", + ".", + "-e", + "sh", + "-l", + ]) + .expect("a separate GUI process accepts the usual terminal launch options"); + assert!(options.new_instance); + assert_eq!(options.window_options.terminal_options.command, ["sh", "-l"]); + } + #[test] fn dynamic_title_ignoring_options_by_default() { let mut config = UiConfig::default(); diff --git a/nebula_app/src/gpui_shell/mod.rs b/nebula_app/src/gpui_shell/mod.rs index d04136276..663f21563 100644 --- a/nebula_app/src/gpui_shell/mod.rs +++ b/nebula_app/src/gpui_shell/mod.rs @@ -58,6 +58,8 @@ use gpui::{App, AppContext as _}; use std::borrow::Cow; +use crate::platform::startup::instance; + /// GPUI 主窗没有可靠的标准错误句柄;保留父进程重定向诊断,但写失败不能 /// 再把非致命错误升级成应用 panic。 pub(crate) fn try_write_stderr(args: std::fmt::Arguments<'_>) { @@ -104,7 +106,9 @@ pub fn run_shell( } } let (shell_tx, shell_rx) = std::sync::mpsc::channel(); - let _elevated_handover = if crate::platform::elevation::is_elevated().is_ok_and(|value| value) { + let _elevated_handover = if !instance::explicitly_requested() + && crate::platform::elevation::is_elevated().is_ok_and(|value| value) + { use crate::platform::elevation::handover::{Request, Startup, start_or_forward}; let settings = nebula_settings::RuntimeSettings::load(); let request = Request { @@ -142,7 +146,8 @@ pub fn run_shell( None }; // 管理员重复启动先交给已有拥有者;不能提前消耗“下次启动安装”的预约。 - if crate::platform::CAPABILITIES.self_update_install + if !instance::explicitly_requested() + && crate::platform::CAPABILITIES.self_update_install && crate::update_download::handoff::apply_scheduled() { return; @@ -182,10 +187,7 @@ pub fn run_shell( }, runtime_hub.clone(), ); - if runtime_server.is_none() - && initial_command.is_none() - && !crate::platform::elevation::requires_isolation() - { + if runtime_server.is_none() && initial_command.is_none() && !instance::is_private() { // 与另一份进程同时启动时,对方可能已经拿到 owner lock、但尚未来得及 // 发布 endpoint。短暂等待并交接,避免继续打开一个无控制面的空窗口。 let settings = nebula_settings::RuntimeSettings::load(); @@ -219,7 +221,7 @@ pub fn run_shell( std::thread::sleep(std::time::Duration::from_millis(25)); } } - if runtime_server.is_some() { + if runtime_server.is_some() && !instance::explicitly_requested() { crate::mobile_connection::resume_saved(); } let _runtime_server = runtime_server; @@ -241,7 +243,7 @@ pub fn run_shell( if initial_cwd.is_some() || initial_command.is_some() || shell_id.is_some() - || crate::platform::elevation::requires_isolation() + || instance::is_private() || !crate::platform::startup::start_hidden( &nebula_settings::RuntimeSettings::load(), launched_at_login, diff --git a/nebula_app/src/gpui_shell/workspace/residency.rs b/nebula_app/src/gpui_shell/workspace/residency.rs index b3cd1d4fa..73d99388b 100644 --- a/nebula_app/src/gpui_shell/workspace/residency.rs +++ b/nebula_app/src/gpui_shell/workspace/residency.rs @@ -1068,9 +1068,9 @@ impl NebulaWorkspace { window: &mut Window, cx: &mut Context, ) -> bool { - // Private administrator windows have no public resident discovery path. + // Private windows have no public resident discovery path. if self.window_role != super::windowing::WindowRole::Regular - || crate::platform::elevation::requires_isolation() + || crate::platform::startup::instance::is_private() { return false; } diff --git a/nebula_app/src/gpui_shell/workspace/session_persistence.rs b/nebula_app/src/gpui_shell/workspace/session_persistence.rs index a61ad1fd2..e8e4b6ac4 100644 --- a/nebula_app/src/gpui_shell/workspace/session_persistence.rs +++ b/nebula_app/src/gpui_shell/workspace/session_persistence.rs @@ -22,7 +22,7 @@ impl Default for SessionPersistence { latest: None, saved: None, quitting: false, - isolated: crate::platform::elevation::requires_isolation(), + isolated: crate::platform::startup::instance::is_private(), } } } diff --git a/nebula_app/src/gpui_shell/workspace/windowing/new_instance_tests.rs b/nebula_app/src/gpui_shell/workspace/windowing/new_instance_tests.rs new file mode 100644 index 000000000..ff2ab9d31 --- /dev/null +++ b/nebula_app/src/gpui_shell/workspace/windowing/new_instance_tests.rs @@ -0,0 +1,110 @@ +use std::collections::HashMap; +use std::fs; +use std::io::{BufRead, BufReader, Write}; +use std::net::{Ipv4Addr, TcpStream}; +use std::process::Command; +use std::time::Duration; + +use clap::Parser; + +use super::*; +use crate::gpui_shell::workspace::session_persistence::{SaveReason, SessionPersistence}; +use crate::platform::startup::instance; +use crate::runtime_api::{ENDPOINT_ENV, RuntimeHub, RuntimeServer, apply_child_endpoint}; + +#[test] +fn new_instance_is_opt_in_and_conflicts_with_noninteractive_launch_modes() { + assert!(!crate::cli::Options::try_parse_from(["pebrel"]).unwrap().new_instance); + for conflicting in [ + "--daemon", + "--ref-test", + "--launched-at-login", + #[cfg(feature = "legacy-shell")] + "--legacy-shell", + ] { + assert!( + crate::cli::Options::try_parse_from(["pebrel", "--new-instance", conflicting]).is_err() + ); + } + let options = + crate::cli::Options::try_parse_from(["pebrel", "--new-instance", "--shell", "bash"]) + .unwrap(); + assert!(options.new_instance); + assert_eq!(options.window_options.terminal_options.shell_id().as_deref(), Some("bash")); +} + +#[test] +fn new_instance_process_keeps_shared_endpoint_and_session_untouched() { + const CHILD: &str = "PEBREL_TEST_NEW_INSTANCE"; + if std::env::var_os(CHILD).is_none() { + // A subprocess owns the real process-scoped launch intent and endpoint; + // parallel tests must never change those globals in the parent harness. + let directory = tempfile::tempdir().unwrap(); + let test_name = format!( + "{}::new_instance_process_keeps_shared_endpoint_and_session_untouched", + module_path!().split_once("::").unwrap().1 + ); + let output = Command::new(std::env::current_exe().unwrap()) + .args(["--exact", &test_name, "--nocapture"]) + .env(CHILD, "1") + .env("PEBREL_CONFIG_DIR", directory.path()) + .env("NEBULA_CONFIG_DIR", directory.path()) + .env(ENDPOINT_ENV, "12345 11111111111111111111111111111111") + .output() + .unwrap(); + assert!( + output.status.success() && String::from_utf8_lossy(&output.stdout).contains("1 passed"), + "child failed: {}\n{}", + String::from_utf8_lossy(&output.stdout), + String::from_utf8_lossy(&output.stderr) + ); + return; + } + + let options = crate::cli::Options::try_parse_from(["pebrel", "--new-instance"]).unwrap(); + instance::initialize(options.new_instance); + let directory = crate::display::nebula_data_dir(); + let discovery = directory.join("runtime.port"); + let saved = directory.join("session.json"); + let original_endpoint = b"12345 11111111111111111111111111111111 1\n"; + let original_session = b"existing resident workspace\n"; + fs::write(&discovery, original_endpoint).unwrap(); + fs::write(&saved, original_session).unwrap(); + // Holding the resident's actual lock catches accidental reuse of its scope. + let _resident = crate::atomic_file::try_lifetime_lock(&discovery).unwrap().unwrap(); + + assert!(instance::is_private()); + assert!(matches!( + initial_startup(None, None, instance::is_private()), + WorkspaceStartup::NewTerminal { cwd: None } + )); + let server = RuntimeServer::spawn_callback(|_| {}, RuntimeHub::new()) + .expect("an independent endpoint starts while the resident owns its lock"); + let mut env = HashMap::new(); + apply_child_endpoint(&mut env); + let mut endpoint = env[ENDPOINT_ENV].split_whitespace(); + let port = endpoint.next().unwrap().parse::().unwrap(); + let token = endpoint.next().unwrap(); + assert_ne!(token, "11111111111111111111111111111111"); + let mut stream = TcpStream::connect((Ipv4Addr::LOCALHOST, port)).unwrap(); + stream.set_read_timeout(Some(Duration::from_secs(5))).unwrap(); + writeln!(stream, "PING {token}").unwrap(); + let mut reply = String::new(); + BufReader::new(stream).read_line(&mut reply).unwrap(); + assert_eq!(reply.trim(), "OK"); + + let session = crate::session::Session::new( + 0, + vec![crate::session::TabSession::single("project".into(), None, None)], + ); + let mut persistence = SessionPersistence::default(); + for reason in + [SaveReason::Checkpoint, SaveReason::TabsClosed, SaveReason::WindowClose, SaveReason::Quit] + { + persistence.save(Some(session.clone()), reason).unwrap(); + assert_eq!(fs::read(&saved).unwrap(), original_session); + } + drop(server); + assert_eq!(fs::read(&discovery).unwrap(), original_endpoint); + assert_eq!(fs::read(&saved).unwrap(), original_session); +} diff --git a/nebula_app/src/gpui_shell/workspace/windowing/startup.rs b/nebula_app/src/gpui_shell/workspace/windowing/startup.rs index 788a95ff6..b1d9518c3 100644 --- a/nebula_app/src/gpui_shell/workspace/windowing/startup.rs +++ b/nebula_app/src/gpui_shell/workspace/windowing/startup.rs @@ -11,7 +11,9 @@ pub(crate) fn open_initial_window( shell_id: Option, launched_at_login: bool, ) { - if let Some(sessions) = crate::update_download::handoff::restore_ticket() { + if !crate::platform::startup::instance::explicitly_requested() + && let Some(sessions) = crate::update_download::handoff::restore_ticket() + { if let Err(error) = open_update_windows(sessions, Some(ai_events), Some(shell_events), cx) { log::error!("Could not reopen updated workspace: {}", error.message); assert!( @@ -33,7 +35,7 @@ pub(crate) fn open_initial_window( initial_startup( initial_cwd, initial_command, - crate::platform::elevation::requires_isolation(), + crate::platform::startup::instance::is_private(), ) }; let start_hidden = initial_window_hidden( @@ -95,6 +97,10 @@ pub(super) fn initial_startup( } } +#[cfg(test)] +#[path = "new_instance_tests.rs"] +mod new_instance_tests; + #[cfg(test)] mod startup_tests { use super::*; diff --git a/nebula_app/src/gpui_shell/workspace/windowing/startup_geometry.rs b/nebula_app/src/gpui_shell/workspace/windowing/startup_geometry.rs index 23ba1ddab..0354b6ffc 100644 --- a/nebula_app/src/gpui_shell/workspace/windowing/startup_geometry.rs +++ b/nebula_app/src/gpui_shell/workspace/windowing/startup_geometry.rs @@ -92,7 +92,7 @@ pub(super) fn load_restore(id: u64, startup: &WorkspaceStartup, role: WindowRole if id != 1 || role != WindowRole::Regular || !matches!(startup, WorkspaceStartup::RestoreOrDefault) - || crate::platform::elevation::requires_isolation() + || crate::platform::startup::instance::is_private() { return; } diff --git a/nebula_app/src/main.rs b/nebula_app/src/main.rs index dc611b853..087f31e37 100644 --- a/nebula_app/src/main.rs +++ b/nebula_app/src/main.rs @@ -206,6 +206,8 @@ fn main() -> Result<(), Box> { // Load command line options. let options = Options::new(); + #[cfg(feature = "gpui-shell")] + platform::startup::instance::initialize(options.new_instance); if let Err(error) = nebula_settings::migrate_legacy_data() { platform::startup::report_error(&error, options.subcommands.is_none()); return Err(error.into()); @@ -576,7 +578,7 @@ fn wants_gpui_shell(options: &Options) -> bool { /// 驻留进程,再 `tab.new`。GPUI 与 winit 共用,避免第二份进程无声退出。 #[cfg(windows)] fn try_hand_over_to_resident(options: &Options) -> bool { - if platform::elevation::requires_isolation() { + if platform::startup::instance::is_private() { return false; } let terminal_options = &options.window_options.terminal_options; diff --git a/nebula_app/src/platform/startup.rs b/nebula_app/src/platform/startup.rs index 84102180c..d8ba8397a 100644 --- a/nebula_app/src/platform/startup.rs +++ b/nebula_app/src/platform/startup.rs @@ -1,3 +1,5 @@ +pub(crate) mod instance; + /// Surface a pre-logger failure for a GUI launch; the caller also returns it on stderr. pub(crate) fn report_error(error: &dyn std::fmt::Display, gui_launch: bool) { #[cfg(windows)] diff --git a/nebula_app/src/platform/startup/instance.rs b/nebula_app/src/platform/startup/instance.rs new file mode 100644 index 000000000..b25471f4b --- /dev/null +++ b/nebula_app/src/platform/startup/instance.rs @@ -0,0 +1,21 @@ +//! Process launch intent shared by runtime discovery and workspace ownership. + +use std::sync::OnceLock; + +static NEW_INSTANCE: OnceLock = OnceLock::new(); + +/// Called once after CLI parsing, before runtime servers or windows exist. +#[cfg(feature = "gpui-shell")] +pub(crate) fn initialize(new_instance: bool) { + NEW_INSTANCE.set(new_instance).expect("instance launch intent initialized twice"); +} + +pub(crate) fn explicitly_requested() -> bool { + NEW_INSTANCE.get().copied().unwrap_or(false) +} + +/// Private instances own a child-only runtime endpoint and an unsaved workspace. +/// Elevation remains an independent reason to require the same isolation. +pub(crate) fn is_private() -> bool { + explicitly_requested() || crate::platform::elevation::requires_isolation() +} diff --git a/nebula_app/src/runtime_api/server.rs b/nebula_app/src/runtime_api/server.rs index 462fbcbd4..902bca37b 100644 --- a/nebula_app/src/runtime_api/server.rs +++ b/nebula_app/src/runtime_api/server.rs @@ -223,7 +223,7 @@ impl RuntimeServer { Self::spawn_at( sink, hub, - (!crate::platform::elevation::requires_isolation()).then(port_file), + (!crate::platform::startup::instance::is_private()).then(port_file), ) } From c2548ebc8b0914b597c0d0899d4887d8153a90d8 Mon Sep 17 00:00:00 2001 From: Kuddev <292709043+Kuddev@users.noreply.github.com> Date: Thu, 19 Nov 2026 15:21:19 +0800 Subject: [PATCH 12/13] Bound pane and record decoding in local output archives --- .../2026-09-21-bounded-local-output.md | 1 + pebrel_app/AGENTS.md | 2 + pebrel_app/src/recent_output.rs | 5 +- pebrel_app/src/recent_output/storage.rs | 49 +++++++++-- .../src/recent_output/storage/decode.rs | 88 +++++++++++++++++++ 5 files changed, 137 insertions(+), 8 deletions(-) create mode 100644 pebrel_app/src/recent_output/storage/decode.rs diff --git a/architecture/notes/pebrel_app/recent_output/2026-09-21-bounded-local-output.md b/architecture/notes/pebrel_app/recent_output/2026-09-21-bounded-local-output.md index 5d9591146..a7e48809c 100644 --- a/architecture/notes/pebrel_app/recent_output/2026-09-21-bounded-local-output.md +++ b/architecture/notes/pebrel_app/recent_output/2026-09-21-bounded-local-output.md @@ -25,6 +25,7 @@ terminal 层仅捕获和恢复主屏的静态显示字段,恢复到历史区 app 层以独立 sidecar 保存有界记录,每 pane 最多五条,每条最多 256 KiB。 正常归档最多 16 MiB,两代原子交接最多 32 MiB;超量先裁剪旧记录再生成引用。 +读取 sidecar 时,解码器逐项检查 pane 引用、每个 pane 的记录数和每条记录的编码大小。它只接收一代交接数据;重复引用会使归档无效。 精确引用只属于本机自动恢复文档,共享工作区的导入和导出不携带这些引用。 先持久化输出,再发布会话引用,发布成功前保留旧引用可读取的那一代。 diff --git a/pebrel_app/AGENTS.md b/pebrel_app/AGENTS.md index 2c76acdfe..e342a9661 100644 --- a/pebrel_app/AGENTS.md +++ b/pebrel_app/AGENTS.md @@ -38,3 +38,5 @@ - Windows Acrylic 的动画期间透明回退与计时边界见 [`窗口状态切换`](../architecture/notes/pebrel_app/platform/2026-09-22-acrylic-window-transitions.md)。 - 登录项的启动意图与首窗静默边界见 [`登录启动`](../architecture/notes/pebrel_app/platform/startup/2026-10-10-login-launch-intent.md)。 - OSC 8 本地链接的 C1 损坏恢复、显式链接身份与后台匹配边界见 [`file_uri`](../architecture/notes/pebrel_app/file_uri/2026-11-11-c1-corrupted-osc8-file-links.md)。 + +- 本机命令输出归档的代次、容量与发布顺序见 [最近输出的持久化边界](../architecture/notes/pebrel_app/recent_output/2026-09-21-bounded-local-output.md)。 diff --git a/pebrel_app/src/recent_output.rs b/pebrel_app/src/recent_output.rs index 0e82d361d..8816cbd7b 100644 --- a/pebrel_app/src/recent_output.rs +++ b/pebrel_app/src/recent_output.rs @@ -8,6 +8,7 @@ use serde::{Deserialize, Serialize}; pub(crate) mod storage; +const MAX_RECORDS: usize = 5; const MAX_RECORD_BYTES: usize = 256 * 1024; const MAX_CAPTURE_CELLS: usize = 4096; @@ -61,7 +62,7 @@ impl RecentOutput { start.0 -= 1; } let end = Line(grid.cursor.point.line.0 + 1); - if self.records.len() == 5 { + if self.records.len() == MAX_RECORDS { self.records.remove(0); } self.records.push(CommandRecord { @@ -109,7 +110,7 @@ impl RecentOutput { } pub(crate) fn validate_records(records: &[CommandRecord]) -> Result<(), &'static str> { - if records.len() > 5 { + if records.len() > MAX_RECORDS { return Err("too many command records"); } for record in records { diff --git a/pebrel_app/src/recent_output/storage.rs b/pebrel_app/src/recent_output/storage.rs index 9e97ce723..54ee02bcf 100644 --- a/pebrel_app/src/recent_output/storage.rs +++ b/pebrel_app/src/recent_output/storage.rs @@ -9,6 +9,7 @@ use serde::{Deserialize, Serialize}; use super::CommandRecord; pub(crate) const MAX_STORE_BYTES: usize = 16 * 1024 * 1024; +const MAX_PANES: usize = 4096; const MAX_TRANSACTION_BYTES: usize = 2 * MAX_STORE_BYTES; pub(crate) fn archive_path() -> std::path::PathBuf { @@ -19,8 +20,13 @@ pub(crate) fn archive_path() -> std::path::PathBuf { #[serde(deny_unknown_fields)] pub(crate) struct Archive { version: u32, + #[serde(deserialize_with = "decode::panes")] panes: BTreeMap>, - #[serde(default, skip_serializing_if = "Option::is_none")] + #[serde( + default, + deserialize_with = "decode::previous", + skip_serializing_if = "Option::is_none" + )] previous: Option>, } @@ -34,14 +40,11 @@ impl Archive { } fn validate(&self) -> io::Result<()> { - if self.version != 1 || self.panes.len() > 4096 { + if self.version != 1 || self.panes.len() > MAX_PANES { 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'-') - { + if !valid_pane_id(id) { return Err(invalid("invalid pane reference")); } super::RecentOutput::validate_records(records).map_err(invalid)?; @@ -101,6 +104,10 @@ impl Archive { } } +fn valid_pane_id(id: &str) -> bool { + !id.is_empty() && id.len() <= 128 && id.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'-') +} + fn invalid(message: impl std::fmt::Display) -> io::Error { io::Error::new(io::ErrorKind::InvalidData, message.to_string()) } @@ -124,6 +131,7 @@ impl Write for LimitedBuffer { } } +mod decode; mod lifecycle; pub(crate) use lifecycle::OutputStore; @@ -219,6 +227,35 @@ mod tests { assert!(Archive::read_from(&path).is_err()); } + #[test] + fn archive_decoder_checks_pane_and_record_limits_before_materializing_the_next_value() { + let entries = (0..MAX_PANES).map(|i| format!(r#""pane-{i}":[]"#)).collect::>(); + let prefix = format!(r#"{{"version":1,"panes":{{{}"#, entries.join(",")); + let full = format!("{prefix}}}}}"); + let archive: Archive = serde_json::from_str(&full).unwrap(); + assert_eq!(archive.panes.len(), MAX_PANES); + let extra = format!(r#"{prefix},"extra":false}}}}"#); + let error = serde_json::from_str::(&extra).unwrap_err(); + assert!(error.to_string().contains("too many panes"), "{error}"); + + let record = serde_json::to_string(&records("C:>test").remove(0)).unwrap(); + let mut values = vec![record; super::super::MAX_RECORDS]; + values.push("false".into()); + let full = format!(r#"{{"version":1,"panes":{{"pane":[{}]}}}}"#, values.join(",")); + let error = serde_json::from_str::(&full).unwrap_err(); + assert!(error.to_string().contains("too many command records"), "{error}"); + } + + #[test] + fn previous_generation_accepts_null_and_duplicate_pane_ids_are_rejected() { + let json = r#"{"previous":{"previous":null,"panes":{"earlier":[]},"version":1},"panes":{},"version":1}"#; + let mut archive: Archive = serde_json::from_str(json).unwrap(); + assert!(archive.take_records("earlier").is_some()); + let duplicate = r#"{"version":1,"panes":{"same":[],"same":[]}}"#; + let error = serde_json::from_str::(duplicate).unwrap_err(); + assert!(error.to_string().contains("duplicate pane reference"), "{error}"); + } + #[test] fn malformed_version_oversize_and_excess_records_are_rejected() { let directory = tempfile::tempdir().unwrap(); diff --git a/pebrel_app/src/recent_output/storage/decode.rs b/pebrel_app/src/recent_output/storage/decode.rs new file mode 100644 index 000000000..33d04a373 --- /dev/null +++ b/pebrel_app/src/recent_output/storage/decode.rs @@ -0,0 +1,88 @@ +//! Enforce archive cardinality while visiting the on-disk map and record arrays. +use std::collections::BTreeMap; +use std::fmt; + +use serde::de::{Error as _, IgnoredAny, MapAccess, SeqAccess, Visitor}; +use serde::{Deserialize, Deserializer}; + +use super::{Archive, CommandRecord, MAX_PANES, valid_pane_id}; +use crate::recent_output::{MAX_RECORDS, RecentOutput}; + +type Panes = BTreeMap>; + +pub(super) fn panes<'de, D: Deserializer<'de>>(deserializer: D) -> Result { + struct PaneMap; + + impl<'de> Visitor<'de> for PaneMap { + type Value = Panes; + + fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("a map of pane IDs to recent command records") + } + + fn visit_map>(self, mut map: A) -> Result { + let mut panes = Panes::new(); + while let Some(id) = map.next_key::()? { + if panes.len() == MAX_PANES { + return Err(A::Error::custom("too many panes in output archive")); + } + if !valid_pane_id(&id) || panes.contains_key(&id) { + return Err(A::Error::custom("invalid or duplicate pane reference")); + } + let records: Records = map.next_value()?; + panes.insert(id, records.0); + } + Ok(panes) + } + } + deserializer.deserialize_map(PaneMap) +} + +#[derive(Deserialize)] +struct Records(#[serde(deserialize_with = "records")] Vec); + +fn records<'de, D: Deserializer<'de>>(deserializer: D) -> Result, D::Error> { + struct RecordList; + + impl<'de> Visitor<'de> for RecordList { + type Value = Vec; + + fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("a bounded list of recent command records") + } + + fn visit_seq>(self, mut seq: A) -> Result { + let mut records = Vec::new(); + while records.len() < MAX_RECORDS { + let Some(record) = seq.next_element()? else { return Ok(records) }; + RecentOutput::validate_records(std::slice::from_ref(&record)) + .map_err(A::Error::custom)?; + records.push(record); + } + if seq.next_element::()?.is_some() { + return Err(A::Error::custom("too many command records")); + } + Ok(records) + } + } + deserializer.deserialize_seq(RecordList) +} + +pub(super) fn previous<'de, D: Deserializer<'de>>( + deserializer: D, +) -> Result>, D::Error> { + #[derive(Deserialize)] + #[serde(deny_unknown_fields)] + struct Previous { + version: u32, + #[serde(deserialize_with = "panes")] + panes: Panes, + // Older JSON can spell the absent generation as an explicit null. + #[serde(default, rename = "previous")] + _end: (), + } + + Ok(Option::::deserialize(deserializer)?.map(|generation| { + Box::new(Archive { version: generation.version, panes: generation.panes, previous: None }) + })) +} From f537dd7ee1ec43a30e107db21be81a3e9826e4f7 Mon Sep 17 00:00:00 2001 From: Kuddev <292709043+Kuddev@users.noreply.github.com> Date: Thu, 19 Nov 2026 18:17:22 +0800 Subject: [PATCH 13/13] Register file-configured shortcut aliases with their native key names --- .../gpui_shell/workspace/keyboard_bindings.rs | 6 ++++-- .../workspace/keyboard_bindings/tests.rs | 17 +++++++++++++++++ 2 files changed, 21 insertions(+), 2 deletions(-) diff --git a/pebrel_app/src/gpui_shell/workspace/keyboard_bindings.rs b/pebrel_app/src/gpui_shell/workspace/keyboard_bindings.rs index 67cc5cab2..e5b39b782 100644 --- a/pebrel_app/src/gpui_shell/workspace/keyboard_bindings.rs +++ b/pebrel_app/src/gpui_shell/workspace/keyboard_bindings.rs @@ -349,9 +349,11 @@ impl NebulaWorkspace { let mut current_bindings = Vec::new(); for (combo, action) in raw { let Some(action) = crate::display::keymap::parse_action(&action) else { continue }; - if crate::display::keymap::parse_combo(&combo).is_none() { + let Some(combo) = crate::display::keymap::parse_combo(&combo) + .and_then(|(mods, key)| crate::display::keymap::canonical_combo(mods, &key)) + else { continue; - } + }; // Terminal strings have one scoped binding; workspace actions also // need the root binding so they can override less-specific defaults. for scope in [None, Some(crate::gpui_shell::terminal::KEY_CONTEXT)] { diff --git a/pebrel_app/src/gpui_shell/workspace/keyboard_bindings/tests.rs b/pebrel_app/src/gpui_shell/workspace/keyboard_bindings/tests.rs index 9888d5e44..821ae0f74 100644 --- a/pebrel_app/src/gpui_shell/workspace/keyboard_bindings/tests.rs +++ b/pebrel_app/src/gpui_shell/workspace/keyboard_bindings/tests.rs @@ -699,6 +699,23 @@ mod dispatch { ); } + #[gpui::test] + fn file_escape_alias_registers_the_native_minimize_key(cx: &mut TestAppContext) { + let (_directory, workspace, mut cx) = open_workspace(1, cx); + workspace.update(&mut cx, |workspace, cx| { + workspace.update_keybinds(vec![("esc".into(), "Minimize".into())], cx); + let keymap = cx.key_bindings(); + let keymap = keymap.borrow(); + for context in ["Root", crate::gpui_shell::terminal::KEY_CONTEXT] { + let contexts = [gpui::KeyContext::parse(context).unwrap()]; + let keys = [gpui::Keystroke::parse("escape").unwrap()]; + let (bindings, pending) = keymap.bindings_for_input(&keys, &contexts); + assert!(!pending); + assert!(bindings.first().unwrap().action().as_any().is::()); + } + }); + } + #[gpui::test] fn command_shortcut_registration_follows_runtime_platform(cx: &mut TestAppContext) { let (_directory, workspace, mut cx) = open_workspace(1, cx);