diff --git a/docs/release-notes/unreleased.md b/docs/release-notes/unreleased.md index d0673e8..7d6b4dc 100644 --- a/docs/release-notes/unreleased.md +++ b/docs/release-notes/unreleased.md @@ -19,15 +19,39 @@ This file contains changes that are not part of a numbered release yet. - Fixed PowerShell profiles created through the alternate profile path missing the Nebula command-completion integration. - Disabled the `fmt` command from Nebula's shell-injected command surface. -- Fixed the GPUI Windows blur switch retaining Acrylic after it was disabled. - Nebula now applies an explicit zeroed `ACCENT_DISABLED` policy when turning - blur off, restores the Acrylic policy when turning it on, clears stale DWM - system backdrops, and flushes composition in both directions. +- Fixed the GPUI Windows background-blur switch doing nothing at runtime. The + window effects were applied inside `handle.update` while that same window was + already borrowed by the enclosing update, so the call always failed with + `window not found` and the error was discarded — blur only ever took effect at + startup, and once on it could not be turned off. Effects are now applied on a + deferred pass and update failures are logged. +- Fixed dragging the opacity sliders stuttering badly. Dragging no longer + reloads settings from disk, rebuilds every terminal's fonts and palette, + rebuilds the whole theme, re-bakes the wallpaper texture, or round-trips to + DWM on every event; it updates the shell alpha directly and persists once + after the drag settles. The blocking `DwmFlush` was removed and window-level + blur is only touched when the blur state actually changes. +- Fixed the WSL file tree showing "此目录为空" for guest directories. A fresh + `wsl.exe -d -- find` call takes about 7.5s on its cold path even when + the same distribution already has an interactive terminal running, so the 6s + budget always expired on the first snapshot, the worker was killed, and the + empty result was rendered as an empty directory. The budget is now 20s. +- The Files panel no longer re-scans the tree on a timer. It previously rebuilt + the whole snapshot (a WSL subprocess plus three git subprocesses) every 4 + seconds, which on WSL left the panel flipping between "正在读取目录…" and an + empty list. Refreshes are now driven by directory changes, the refresh button, + and finished git operations only. +- Fixed windows staying hidden when the tray was disabled while they were + minimized to it. The reveal path applied its effect inside `handle.update` on + an already-borrowed window, so it always failed silently while + `window_hidden` had already been cleared — leaving an app with no window and + no tray icon that could not restore itself. - Fixed the shared Files panel losing the active pane after tab/pane switches or manual tree navigation. WSL `/mnt/` paths map to the host drive, while `/`, `/home`, `/etc`, and other guest paths are enumerated inside the - selected distribution. Refresh now resumes following the active pane, and - timed-out WSL workers can no longer disable later refreshes. + selected distribution. Directory rows are published before the slower WSL + VCS probe, refresh resumes following the active pane, and timed-out workers + can no longer disable later refreshes. ### Improved @@ -64,13 +88,18 @@ This file contains changes that are not part of a numbered release yet. 时可用，不需要先发送一轮对话。 - 修复通过备用 profile 路径创建的 PowerShell 没有命令补齐的问题。 - 禁用 shell 注入命令面板中的 `fmt` 命令。 -- 修复 GPUI Windows 壳关闭背景模糊后仍残留 Acrylic 的问题。关闭时现在明确 - 写入全零 `ACCENT_DISABLED` policy，开启时恢复 Acrylic policy；两向切换都 - 清理遗留 DWM system backdrop 并刷新合成状态。 +- 修复 GPUI Windows 壳的背景模糊开关在运行中点了没反应的问题。窗口视效原先在 + `handle.update` 里应用，而那一刻这个窗口已经被外层 update 借出，调用必然返回 + `window not found`，错误又被丢弃——于是模糊只在启动时生效，一旦开着就再也 + 关不掉。现在改为延迟一帧统一应用，且 update 失败会留日志。 +- 修复拖动不透明度滑块严重卡顿的问题。拖拽过程不再每个事件都重新读设置文件、 + 重建每个终端的字体与调色板、重建整套主题、重烘焙壁纸纹理、以及和 DWM 往返； + 改为直接更新壳色 alpha，停手之后落盘一次。阻塞式 `DwmFlush` 已移除，窗口级 + 模糊只在模糊态真的改变时才动。 - 修复共享 Files 面板在切换 tab/pane 或手动浏览目录后不再跟随当前 pane 的 问题。WSL `/mnt/<盘>` 映射到宿主盘，`/`、`/home`、`/etc` 等来宾路径则在 - 对应发行版内枚举；刷新按钮会恢复跟随当前 pane，WSL 工人超时也不会再让 - 后续刷新永久失效。 + 对应发行版内枚举；目录行会先于较慢的 WSL VCS 探测发布，刷新按钮会恢复 + 跟随当前 pane，WSL 工人超时也不会再让后续刷新永久失效。 ### 改进 diff --git a/docs/runtime-api-v1.schema.json b/docs/runtime-api-v1.schema.json index 6844ebc..2d47765 100644 --- a/docs/runtime-api-v1.schema.json +++ b/docs/runtime-api-v1.schema.json @@ -57,6 +57,7 @@ "enum": [ "runtime.describe", "runtime.snapshot", + "runtime.orchestrate", "events.subscribe", "agents.list", "agent.start", @@ -87,6 +88,10 @@ "if": { "properties": { "method": { "enum": ["runtime.describe", "runtime.snapshot", "window.create"] } } }, "then": { "properties": { "params": { "$ref": "#/$defs/empty_params" } } } }, + { + "if": { "properties": { "method": { "const": "runtime.orchestrate" } } }, + "then": { "properties": { "params": { "$ref": "#/$defs/orchestrate_params" } } } + }, { "if": { "properties": { "method": { "const": "events.subscribe" } } }, "then": { "properties": { "params": { "$ref": "#/$defs/subscribe_params" } } } @@ -179,11 +184,135 @@ }, "additionalProperties": false }, + "orchestrate_params": { + "type": "object", + "required": ["steps"], + "properties": { + "steps": { + "type": "array", + "minItems": 1, + "maxItems": 32, + "items": { "$ref": "#/$defs/orchestrate_step" } + }, + "on_error": { "enum": ["stop", "continue"], "default": "stop" } + }, + "additionalProperties": false + }, + "orchestrate_step": { + "oneOf": [ + { "$ref": "#/$defs/orchestrate_new_tab" }, + { "$ref": "#/$defs/orchestrate_focus" }, + { "$ref": "#/$defs/orchestrate_split" }, + { "$ref": "#/$defs/orchestrate_prompt" }, + { "$ref": "#/$defs/orchestrate_run" }, + { "$ref": "#/$defs/orchestrate_agent_launch" } + ] + }, + "orchestrate_step_id": { + "type": "string", + "pattern": "^[A-Za-z_][A-Za-z0-9_-]{0,63}$" + }, + "orchestrate_pane_target": { + "oneOf": [ + { + "type": "object", + "required": ["step", "field"], + "properties": { + "step": { "$ref": "#/$defs/orchestrate_step_id" }, + "field": { "const": "pane_id" } + }, + "additionalProperties": false + }, + { + "type": "object", + "required": ["pane_id"], + "properties": { + "window_id": { "$ref": "#/$defs/nullable_window_id" }, + "pane_id": { "type": "integer", "minimum": 0 } + }, + "additionalProperties": false + } + ] + }, + "orchestrate_new_tab": { + "type": "object", + "required": ["id", "op"], + "properties": { + "id": { "$ref": "#/$defs/orchestrate_step_id" }, + "op": { "const": "new_tab" }, + "window_id": { "$ref": "#/$defs/nullable_window_id" }, + "cwd": { "type": ["string", "null"] } + }, + "additionalProperties": false + }, + "orchestrate_focus": { + "type": "object", + "required": ["id", "op", "target"], + "properties": { + "id": { "$ref": "#/$defs/orchestrate_step_id" }, + "op": { "const": "focus" }, + "target": { "$ref": "#/$defs/orchestrate_pane_target" } + }, + "additionalProperties": false + }, + "orchestrate_split": { + "type": "object", + "required": ["id", "op", "direction"], + "properties": { + "id": { "$ref": "#/$defs/orchestrate_step_id" }, + "op": { "const": "split" }, + "window_id": { "$ref": "#/$defs/nullable_window_id" }, + "target": { "$ref": "#/$defs/orchestrate_pane_target" }, + "direction": { "enum": ["left_right", "top_bottom"] } + }, + "additionalProperties": false + }, + "orchestrate_prompt": { + "type": "object", + "required": ["id", "op", "target", "text"], + "properties": { + "id": { "$ref": "#/$defs/orchestrate_step_id" }, + "op": { "const": "prompt" }, + "target": { "$ref": "#/$defs/orchestrate_pane_target" }, + "text": { "type": "string", "minLength": 1, "maxLength": 32768 }, + "submit": { "type": "boolean", "default": true } + }, + "additionalProperties": false + }, + "orchestrate_run": { + "type": "object", + "required": ["id", "op", "target", "command"], + "properties": { + "id": { "$ref": "#/$defs/orchestrate_step_id" }, + "op": { "const": "run" }, + "target": { "$ref": "#/$defs/orchestrate_pane_target" }, + "command": { "type": "string", "minLength": 1, "maxLength": 32768 }, + "wait": { "type": "boolean", "default": true }, + "timeout_ms": { "type": "integer", "minimum": 1, "maximum": 86400000, "default": 30000 } + }, + "additionalProperties": false + }, + "orchestrate_agent_launch": { + "type": "object", + "required": ["id", "op", "target", "name", "kind", "initial_prompt"], + "properties": { + "id": { "$ref": "#/$defs/orchestrate_step_id" }, + "op": { "const": "agent_launch" }, + "target": { "$ref": "#/$defs/orchestrate_pane_target" }, + "name": { "type": "string", "minLength": 1, "maxLength": 64 }, + "kind": { "enum": ["claude", "codex"] }, + "resume_session_id": { "type": ["string", "null"] }, + "initial_prompt": { "type": "string", "minLength": 1, "maxLength": 32768 }, + "ready_timeout_ms": { "type": "integer", "minimum": 1, "maximum": 86400000, "default": 10000 } + }, + "additionalProperties": false + }, "agent_start_params": { "type": "object", "required": ["name", "kind"], "properties": { "window_id": { "$ref": "#/$defs/nullable_window_id" }, + "pane_id": { "type": ["integer", "null"], "minimum": 0 }, "name": { "type": "string", "minLength": 1, "maxLength": 64 }, "kind": { "type": "string", "minLength": 1 }, "cwd": { "type": ["string", "null"] }, @@ -275,6 +404,7 @@ "required": ["direction"], "properties": { "window_id": { "$ref": "#/$defs/nullable_window_id" }, + "pane_id": { "type": ["integer", "null"], "minimum": 0 }, "direction": { "enum": ["left_right", "top_bottom"] } }, "additionalProperties": false diff --git a/docs/runtime-control-api.md b/docs/runtime-control-api.md index dc0a227..068510c 100644 --- a/docs/runtime-control-api.md +++ b/docs/runtime-control-api.md @@ -25,6 +25,7 @@ Nebula 的运行时控制面把 GUI、CLI、Agent 与未来插件统一到同一 ```powershell nebula ctl describe --pretty nebula ctl snapshot --pretty +nebula ctl orchestrate --file workflow.json --timeout-ms 30000 --pretty nebula ctl agents --pretty nebula ctl agent-fork --window --source-pane --name login-fixer --kind codex --pretty nebula ctl agent-get --agent login-fixer --pretty @@ -55,9 +56,10 @@ Pane ID 当前在 Window 内稳定，而不是进程内全局唯一。存在多 |---|---|---| | `runtime.describe` | 读取应用版本、协议版本和能力列表 | 无 | | `runtime.snapshot` | 读取完整运行时投影 | 无 | +| `runtime.orchestrate` | 一次提交强类型布局、PTY、命令与 Agent 首任务工作流 | `steps`, `on_error?` | | `events.subscribe` | 从 revision 开始订阅状态变化 | `since_revision?` | | `agents.list` | 只列出 Nebula 已识别的 Agent Pane、会话身份、状态和证据来源 | `window_id?` | -| `agent.start` | 在指定目录新建 Tab 并启动命名 Agent | `window_id?`, `name`, `kind`, `cwd?`, `resume_session_id?` | +| `agent.start` | 在新 Tab 或指定既有 Pane 中启动命名 Agent | `window_id?`, `pane_id?`, `name`, `kind`, `cwd?`, `resume_session_id?` | | `agent.fork` | 事务化创建独立 Git branch/worktree，再启动命名 Agent | `source_pane_id?`/`source_cwd?`, `name`, `kind`, `branch?`, `base?`, `path?`, `allow_dirty_source?` | | `agent.get` | 按稳定 id 或名称解析 Agent generation 与 worktree provenance | `agent`, `generation?` | | `agent.prompt` | 向同一 Agent generation 发送纯文本 Prompt | `agent`, `generation?`, `text`, `submit?` | @@ -66,7 +68,7 @@ Pane ID 当前在 Window 内稳定，而不是进程内全局唯一。存在多 | `window.create` | 创建新窗口 | 无 | | `window.focus` | 聚焦窗口或 Pane | `window_id?`, `pane_id?` | | `tab.new` | 创建默认 Shell 标签 | `window_id?` | -| `pane.split` | 向右或向下分屏 | `window_id?`, `direction` | +| `pane.split` | 从当前或指定 Pane 向右/向下分屏 | `window_id?`, `pane_id?`, `direction` | | `pane.prompt` | 写入一行纯文本，可追加 Enter | `window_id?`, `pane_id`, `text`, `submit` | | `pane.read` | 从真实终端 Grid 尾部读取最近逻辑行 | `window_id?`, `pane_id`, `lines` | | `pane.procs` | 读取本地 PTY shell 为根的真实进程树 | `window_id?`, `pane_id` | @@ -78,6 +80,51 @@ Pane ID 当前在 Window 内稳定，而不是进程内全局唯一。存在多 任意终端字节注入接口。控制键走 `pane.send_key`：只开放命名键，字母必须配 `control=true`，`repeat` 上限 64；API 不接受任意 bytes 或 ANSI 字符串。 +## 单请求编排 + +`runtime.orchestrate` 把模型已经确定的终端操作留在 Runtime 内执行，避免模型在每个步骤之间 +重复读取 snapshot、搬运 Pane ID 和再次推理。它不是通用脚本语言：每个步骤都是 Schema 中 +列出的强类型 `op`，步骤引用也是 `{ "step": "right", "field": "pane_id" }`，不执行字符串 +模板、任意方法名或嵌套 Runtime 请求。 + +```json +{ + "steps": [ + { "id": "right", "op": "split", "direction": "left_right" }, + { + "id": "weather", "op": "agent_launch", + "target": { "step": "right", "field": "pane_id" }, + "name": "weather", "kind": "claude", + "initial_prompt": "查询并简要回答今天的天气" + }, + { + "id": "bottom", "op": "split", + "target": { "step": "right", "field": "pane_id" }, + "direction": "top_bottom" + }, + { + "id": "formula", "op": "agent_launch", + "target": { "step": "bottom", "field": "pane_id" }, + "name": "formula", "kind": "codex", + "initial_prompt": "输出几组复杂数学公式供终端渲染测试" + } + ], + "on_error": "stop" +} +``` + +首个无 `target` 的 `split` 相对当前聚焦 Pane 执行，因此常见自然语言布局不需要先请求 +snapshot。后续步骤只引用前面成功步骤的 receipt；未来引用、不存在的步骤、重复 ID、未知字段 +都在任何 UI 动作发生前被拒绝。普通 Pane 不做隐式回滚：中途失败时已完成动作保留，receipt +返回 `failed_step`、逐步 `error` 和 `partial`，调用者可从失败点续作。 + +`agent_launch` 是“绑定既有 Pane 启动 Agent + ready 握手 + 投递首任务”的原子产品语义。 +Runtime 先启动 workflow 中的所有 Agent，再并行等待各自被 registry 观察到且离开启动中的 +`running` 状态，随后投递 `initial_prompt`。这让多个 Claude/Codex 的冷启动互相重叠，同时 +避免启动命令尚在 submit barrier 中时第二次输入触发 `input_in_progress`。成功 receipt 只返回 +`window_id`、`pane_id`、`agent_id`、`generation`、ready 状态和 `submitted` 等必要字段，不附带 +每一步的完整 snapshot。 + ## 命名 Agent 与隔离 worktree `agent.start` 提供稳定的 `agent_id + generation + name`，目前冷启动只开放经过验证的 Codex @@ -175,6 +222,7 @@ Shell/hook 结束事件归位；因此即使命令在 120ms Runtime pump 的两 - `invalid_request`：Envelope 或 JSON 无效。 - `invalid_params`：参数类型、Prompt 内容或超时范围无效。 +- `invalid_reference`：编排步骤引用了未来、失败或不含目标字段的步骤。 - `method_not_found`：方法不存在。 - `target_not_found`：Window 或 Pane 已消失。 - `ambiguous_target`：Pane ID 在多个窗口中重复，必须补 Window ID。 @@ -182,6 +230,7 @@ Shell/hook 结束事件归位；因此即使命令在 120ms Runtime pump 的两 - `action_failed`：窗口、Shell 或 Pane 创建失败。 - `agent_name_conflict` / `agent_identity_mismatch`：名称已被活跃 Agent 使用，或 generation 已变化。 - `agent_exited` / `agent_replaced`：等待的稳定 Agent 身份已退出或被同 Pane 中的新会话替换。 +- `agent_ready_timeout`：Agent 未在期限内完成进程身份观察与启动就绪握手。 - `dirty_source`：`agent.fork` 的源工作树有未提交变更，且调用者未显式允许。 - `branch_conflict` / `worktree_path_conflict`：目标分支或目录已存在；Nebula 不覆盖。 - `git_unavailable` / `invalid_base` / `invalid_branch`：Git 能力或 revision/ref 校验失败。 diff --git a/docs/skills/nebula-runtime/SKILL.md b/docs/skills/nebula-runtime/SKILL.md index a899068..a94a14d 100644 --- a/docs/skills/nebula-runtime/SKILL.md +++ b/docs/skills/nebula-runtime/SKILL.md @@ -19,24 +19,75 @@ The examples below use `nebula` as a readable placeholder for the resolved invoc ## Workflow -1. Run `nebula ctl describe --pretty`. Confirm every capability needed by the task is present. Require `agent.fork` for isolated workers and check `features` when relying on identity-aware waits. -2. Run `nebula ctl snapshot --pretty`. Use its authoritative active window, focused pane, cwd, task state, and `state_change_seq`; never infer identity from a title or terminal text. -3. Choose the narrow workflow below: direct pane layout for visible terminal work, or a named isolated Agent when the user explicitly asks for delegated repository work. +Choose one of these paths without exploratory process or source-code searches: -## Direct Pane Layout +1. For a natural-language request that creates or changes a visible layout, starts Claude/Codex, sends first tasks, or runs commands, issue **one** `runtime.orchestrate` request. The first untargeted split uses Nebula's current focused pane, so do not take a preliminary snapshot merely to rediscover it. +2. Use `snapshot`, `read`, `wait`, or `agent.get` only when the request depends on pre-existing identity/state, when observing work after the orchestration receipt, or when recovering from one named failed step. +3. Use `agent-fork` separately only when the user explicitly requests an isolated Git worktree. The current typed workflow deliberately does not hide worktree creation inside a generic step. +4. Run `describe` only for capability negotiation with an unknown/older Nebula build or after `method_not_found`; do not pay that round trip on every known v1 workflow. -Use this for requests such as "split right and open Codex", "show README below it", or "run tests in another pane". +## One-Request Layout And Dispatch -1. Run `nebula ctl split --window --direction right --pretty` or `--direction down`. The returned `result.pane_id` is the new focused pane; do not rediscover it by comparing titles. -2. Start an interactive CLI with `nebula ctl prompt --window --pane --text "codex" --wait idle --timeout-ms 60000 --pretty` (or `claude`). Then send the user's task with a second `prompt` call. -3. To add a pane relative to that CLI, first run `nebula ctl focus --window --pane --pretty`, then split again. A `down` split is placed below the focused pane. -4. For a visible README check, run one finite command in the new pane: PowerShell `Get-Content -Raw README.md`; POSIX `sed -n '1,240p' README.md`. Use `nebula ctl run --window --pane --command "..." --pretty`, then `read` to verify the displayed content. -5. Verify each requested pane with `nebula ctl read --window --pane --lines 120 --pretty`. Keep panes visible unless the user asks to close them. +Translate the user's whole deterministic terminal intent into one JSON object and invoke: + +```text +nebula ctl orchestrate --spec --timeout-ms 30000 --pretty +``` + +Use `--file ` instead when shell quoting would make the JSON ambiguous. `--spec` and `--file` are mutually exclusive; both still produce exactly one Runtime request. + +The step surface is intentionally closed and typed: + +- `new_tab`: optional `window_id` and `cwd`. +- `focus`: required direct or prior-step `target`. +- `split`: optional `window_id` or `target`, plus `direction: left_right|top_bottom`. +- `prompt`: required `target` and one plain-text `text` line; `submit` defaults true. +- `run`: required `target` and one command line; `wait` defaults true. +- `agent_launch`: required `target`, unique `name`, verified `kind: claude|codex`, and one-line `initial_prompt`. Nebula internally waits for the correct Agent generation to become ready before sending the prompt. + +References must be structured and point backward: + +```json +{ "step": "right", "field": "pane_id" } +``` + +Never emit `$right.pane_id`, a method name with arbitrary params, shell interpolation, or a future-step reference. + +For “右侧开 Claude 问天气，在它下面开 Codex 输出复杂数学公式”, submit this one workflow: + +```json +{ + "steps": [ + { "id": "right", "op": "split", "direction": "left_right" }, + { + "id": "weather", "op": "agent_launch", + "target": { "step": "right", "field": "pane_id" }, + "name": "weather", "kind": "claude", + "initial_prompt": "查询并简要回答今天的天气" + }, + { + "id": "bottom", "op": "split", + "target": { "step": "right", "field": "pane_id" }, + "direction": "top_bottom" + }, + { + "id": "formula", "op": "agent_launch", + "target": { "step": "bottom", "field": "pane_id" }, + "name": "formula", "kind": "codex", + "initial_prompt": "输出几组复杂数学公式供终端渲染测试" + } + ], + "on_error": "stop" +} +``` + +Nebula starts all declared Agents before waiting for readiness, so their cold starts overlap. Treat the returned workflow receipt as authoritative: `ok`, `partial`, `failed_step`, and each step's compact `action`/`error` replace intermediate snapshots. On partial failure, preserve successful panes and continue only from the named failed step; do not replay the whole workflow. Example intent mapping: -- "分屏开一个 codex，让它输出数学公式；在 codex 下面打开 README" means: snapshot -> split right -> launch Codex in returned pane -> prompt it for the formula -> focus that Codex pane -> split down -> run the finite README display command in the returned lower pane -> read both panes. -- "开一个 tab 让 codex 做 X" means `agent-start` when stable Agent identity is useful, or `new-tab` + `prompt` for an ordinary untracked CLI. Do not create a Git worktree unless isolation was requested. +- "分屏开一个 codex，让它输出数学公式；在 codex 下面显示 README" means one workflow: split right -> `agent_launch` Codex with the formula as `initial_prompt` -> split down by reference -> `run` the platform-appropriate finite README command. Read afterward only if the user also asked to inspect/verify its output. +- "开一个 tab 让 codex 做 X" means one workflow: `new_tab` -> `agent_launch` targeting its receipt. Do not create a Git worktree unless isolation was requested. +- "在已有 pane 42 跑测试" may use one `run` step with direct target `{ "window_id": 1, "pane_id": 42 }`; take a snapshot first only if that identity was not already supplied or verified. ## Named Isolated Agents diff --git a/docs/skills/nebula-runtime/agents/openai.yaml b/docs/skills/nebula-runtime/agents/openai.yaml index 6c30281..7c03463 100644 --- a/docs/skills/nebula-runtime/agents/openai.yaml +++ b/docs/skills/nebula-runtime/agents/openai.yaml @@ -1,4 +1,4 @@ interface: display_name: "Nebula Runtime" short_description: "Split panes and control Codex/Claude in Nebula" - default_prompt: "Use $nebula-runtime to control the live Nebula layout, start or prompt coding agents, wait for state changes, and verify terminal output." + default_prompt: "Use one typed Nebula runtime.orchestrate workflow for multi-step layout and first-task dispatch; use individual controls only for follow-up observation or recovery." diff --git a/nebula_app/src/ai_hook.rs b/nebula_app/src/ai_hook.rs index 24f5665..61d76df 100644 --- a/nebula_app/src/ai_hook.rs +++ b/nebula_app/src/ai_hook.rs @@ -75,14 +75,8 @@ const HELPER_MARK: &str = "nebula-hook"; /// Claude hook events we subscribe to. Session boundaries carry the id needed /// for resume/fork; PostToolUse lets a stale permission state return to working /// before the whole turn completes. -const CLAUDE_EVENTS: [&str; 6] = [ - "SessionStart", - "UserPromptSubmit", - "Notification", - "PostToolUse", - "Stop", - "SessionEnd", -]; +const CLAUDE_EVENTS: [&str; 6] = + ["SessionStart", "UserPromptSubmit", "Notification", "PostToolUse", "Stop", "SessionEnd"]; /// What a lifecycle event means for the pane's turn state. #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -311,10 +305,9 @@ mod remote_tests { .unwrap(); assert_eq!(done.kind, AiHookKind::TurnDone); - for (kind, expected) in [ - ("tool-complete", AiHookKind::ToolComplete), - ("session-end", AiHookKind::SessionEnd), - ] { + for (kind, expected) in + [("tool-complete", AiHookKind::ToolComplete), ("session-end", AiHookKind::SessionEnd)] + { let raw = format!("nebula-hook/1 source=pi pane=3\n{{\"kind\":\"{kind}\"}}"); assert_eq!(parse_remote_envelope(raw.as_bytes(), Some(3)).unwrap().kind, expected); } @@ -370,9 +363,7 @@ mod win { rx } - fn spawn_pipe_server( - sink: impl Fn(super::AiHookEvent) -> bool + Send + 'static, - ) { + fn spawn_pipe_server(sink: impl Fn(super::AiHookEvent) -> bool + Send + 'static) { let name = format!(r"\\.\pipe\nebula-notify-{}", std::process::id()); // SAFETY: single-threaded startup; no other thread reads the env yet. unsafe { std::env::set_var(PIPE_ENV, &name) }; @@ -1091,7 +1082,9 @@ export default function (pi: ExtensionAPI) { // 显式安装即重新授权：清掉 --remove 落下的持久开关，守护线程下次 // 启动恢复自愈。 if let Err(err) = nebula_settings::persist_keys(&[("ai_hooks", "1".to_owned())]) { - eprintln!("警告：无法写入 ai_hooks=1（{err}）；若之前执行过 --remove，自动接线仍是关闭状态。"); + eprintln!( + "警告：无法写入 ai_hooks=1（{err}）；若之前执行过 --remove，自动接线仍是关闭状态。" + ); } if dir.exists() { if ensure_claude_hooks() { @@ -1165,8 +1158,7 @@ export default function (pi: ExtensionAPI) { // ─── Runtime skill (Codex + Claude Code) ─────────────────────────────── - const RUNTIME_SKILL_MD: &str = - include_str!("../../docs/skills/nebula-runtime/SKILL.md"); + const RUNTIME_SKILL_MD: &str = include_str!("../../docs/skills/nebula-runtime/SKILL.md"); const RUNTIME_SKILL_OPENAI_YAML: &str = include_str!("../../docs/skills/nebula-runtime/agents/openai.yaml"); const RUNTIME_SKILL_MARKER: &str = ".nebula-managed"; @@ -1199,8 +1191,8 @@ export default function (pi: ExtensionAPI) { targets } - fn ensure_runtime_skills( - ) -> Vec<(&'static str, PathBuf, std::io::Result)> { + fn ensure_runtime_skills() -> Vec<(&'static str, PathBuf, std::io::Result)> + { runtime_skill_candidates() .into_iter() .filter(|(agent, _)| match *agent { @@ -1235,12 +1227,11 @@ export default function (pi: ExtensionAPI) { let skill_path = dir.join("SKILL.md"); let metadata_path = dir.join("agents").join("openai.yaml"); let marker_path = dir.join(RUNTIME_SKILL_MARKER); - let expected = skill_fingerprint( - RUNTIME_SKILL_MD.as_bytes(), - RUNTIME_SKILL_OPENAI_YAML.as_bytes(), - ); + let expected = + skill_fingerprint(RUNTIME_SKILL_MD.as_bytes(), RUNTIME_SKILL_OPENAI_YAML.as_bytes()); let current = read_skill_fingerprint(dir); - let marker = std::fs::read_to_string(&marker_path).ok().map(|value| value.trim().to_owned()); + let marker = + std::fs::read_to_string(&marker_path).ok().map(|value| value.trim().to_owned()); let exact_skill = std::fs::read(&skill_path) .is_ok_and(|contents| contents == RUNTIME_SKILL_MD.as_bytes()); let metadata_compatible = !metadata_path.exists() @@ -1268,9 +1259,8 @@ export default function (pi: ExtensionAPI) { fn remove_runtime_skill(dir: &Path) -> std::io::Result { let marker_path = dir.join(RUNTIME_SKILL_MARKER); - let Some(marker) = std::fs::read_to_string(&marker_path) - .ok() - .map(|value| value.trim().to_owned()) + let Some(marker) = + std::fs::read_to_string(&marker_path).ok().map(|value| value.trim().to_owned()) else { return Ok(ManagedSkillRemoval::Absent); }; @@ -1278,11 +1268,7 @@ export default function (pi: ExtensionAPI) { return Ok(ManagedSkillRemoval::Conflict); } - for path in [ - dir.join("SKILL.md"), - dir.join("agents").join("openai.yaml"), - marker_path, - ] { + for path in [dir.join("SKILL.md"), dir.join("agents").join("openai.yaml"), marker_path] { if path.exists() { std::fs::remove_file(path)?; } @@ -1300,8 +1286,8 @@ export default function (pi: ExtensionAPI) { #[cfg(test)] mod runtime_skill_tests { use super::{ - ManagedSkillInstall, ManagedSkillRemoval, RUNTIME_SKILL_MD, - ensure_runtime_skill, remove_runtime_skill, + ManagedSkillInstall, ManagedSkillRemoval, RUNTIME_SKILL_MD, ensure_runtime_skill, + remove_runtime_skill, }; #[test] @@ -1311,10 +1297,7 @@ export default function (pi: ExtensionAPI) { assert_eq!(ensure_runtime_skill(&dir).unwrap(), ManagedSkillInstall::Installed); assert_eq!(ensure_runtime_skill(&dir).unwrap(), ManagedSkillInstall::Current); - assert_eq!( - std::fs::read_to_string(dir.join("SKILL.md")).unwrap(), - RUNTIME_SKILL_MD - ); + assert_eq!(std::fs::read_to_string(dir.join("SKILL.md")).unwrap(), RUNTIME_SKILL_MD); assert_eq!(remove_runtime_skill(&dir).unwrap(), ManagedSkillRemoval::Removed); assert!(!dir.exists()); } @@ -1532,10 +1515,7 @@ export default function (pi: ExtensionAPI) { #[test] fn an_empty_slot_is_claimed_outright() { - assert_eq!( - desired_codex_notify(&[], HELPER), - Some(argv(&[HELPER, "codex"])) - ); + assert_eq!(desired_codex_notify(&[], HELPER), Some(argv(&[HELPER, "codex"]))); } #[test] diff --git a/nebula_app/src/ai_sessions.rs b/nebula_app/src/ai_sessions.rs index 53bd4f2..8752049 100644 --- a/nebula_app/src/ai_sessions.rs +++ b/nebula_app/src/ai_sessions.rs @@ -218,9 +218,7 @@ fn record_hook_session_at( fn valid_registry_id(id: &str) -> bool { !id.is_empty() && id.len() <= 64 - && id - .bytes() - .all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'-' | b'_' | b'.')) + && id.bytes().all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'-' | b'_' | b'.')) } fn load_registry(path: &Path) -> SessionRegistry { diff --git a/nebula_app/src/backup_remote.rs b/nebula_app/src/backup_remote.rs index 9b4dd6f..0b37314 100644 --- a/nebula_app/src/backup_remote.rs +++ b/nebula_app/src/backup_remote.rs @@ -307,7 +307,9 @@ fn utc_parts(secs: u64) -> (i64, u32, u32, u32, u32, u32) { fn archive_name(secs: u64) -> String { let (year, month, day, hour, minute, second) = utc_parts(secs); - format!("{ARCHIVE_PREFIX}{year:04}{month:02}{day:02}-{hour:02}{minute:02}{second:02}{ARCHIVE_SUFFIX}") + format!( + "{ARCHIVE_PREFIX}{year:04}{month:02}{day:02}-{hour:02}{minute:02}{second:02}{ARCHIVE_SUFFIX}" + ) } /// 只认我们自己的归档名（前后缀精确匹配）。列表、恢复与清理共用这一道 @@ -357,7 +359,8 @@ fn backend(cfg: &BackupRemoteConfig) -> Result, String> { if username.is_empty() { return Err("未配置 WebDAV 用户名".to_owned()); } - let password = webdav_password().ok_or("缺少 WebDAV 密码：在设置里输入或设 NEBULA_BACKUP_WEBDAV_PASSWORD")?; + let password = webdav_password() + .ok_or("缺少 WebDAV 密码：在设置里输入或设 NEBULA_BACKUP_WEBDAV_PASSWORD")?; Ok(Box::new(WebDavBackend { url, username, password })) }, BackupProtocol::S3 => { @@ -387,14 +390,16 @@ fn backend(cfg: &BackupRemoteConfig) -> Result, String> { if access_key.is_empty() { return Err("未配置 S3 Access Key".to_owned()); } - let secret_key = - s3_secret().ok_or("缺少 S3 Secret Key：在设置里输入或设 NEBULA_BACKUP_S3_SECRET")?; + let secret_key = s3_secret() + .ok_or("缺少 S3 Secret Key：在设置里输入或设 NEBULA_BACKUP_S3_SECRET")?; Ok(Box::new(S3Backend { endpoint, region, bucket, prefix, access_key, secret_key })) }, BackupProtocol::Sftp => { let destination = cfg.sftp_destination.trim().to_owned(); if destination.is_empty() { - return Err("未配置 SFTP 目标（user@host[:port]，认证复用 SSH 主机配置）".to_owned()); + return Err( + "未配置 SFTP 目标（user@host[:port]，认证复用 SSH 主机配置）".to_owned() + ); } let mut path = cfg.sftp_path.trim().trim_end_matches('/').to_owned(); if path.is_empty() { @@ -619,8 +624,7 @@ impl Backend for WebDavBackend { .header("Authorization", self.auth()) .body(Vec::new()) .map_err(|err| format!("构造删除请求失败：{err}"))?; - let response = - http_agent().run(request).map_err(|err| format!("删除旧备份失败：{err}"))?; + let response = http_agent().run(request).map_err(|err| format!("删除旧备份失败：{err}"))?; match response.status().as_u16() { 200 | 204 | 404 => Ok(()), status => Err(format!("删除旧备份失败：HTTP {status}")), @@ -846,11 +850,7 @@ fn sigv4_canonical_query(query: &[(&str, &str)]) -> String { .map(|(key, value)| (sigv4_uri_encode(key, true), sigv4_uri_encode(value, true))) .collect(); pairs.sort(); - pairs - .into_iter() - .map(|(key, value)| format!("{key}={value}")) - .collect::>() - .join("&") + pairs.into_iter().map(|(key, value)| format!("{key}={value}")).collect::>().join("&") } /// 组装 Authorization 头。签名头固定为 host + x-amz-content-sha256 + @@ -874,18 +874,21 @@ fn sigv4_authorization( sigv4_canonical_query(query), ); let scope = format!("{date}/{region}/s3/aws4_request"); - let string_to_sign = - format!("AWS4-HMAC-SHA256\n{amz_date}\n{scope}\n{}", sha256_hex(canonical_request.as_bytes())); + let string_to_sign = format!( + "AWS4-HMAC-SHA256\n{amz_date}\n{scope}\n{}", + sha256_hex(canonical_request.as_bytes()) + ); let key = hmac_sha256(format!("AWS4{secret_key}").as_bytes(), date.as_bytes()); let key = hmac_sha256(&key, region.as_bytes()); let key = hmac_sha256(&key, b"s3"); let key = hmac_sha256(&key, b"aws4_request"); - let signature = hmac_sha256(&key, string_to_sign.as_bytes()) - .iter() - .fold(String::with_capacity(64), |mut out, byte| { + let signature = hmac_sha256(&key, string_to_sign.as_bytes()).iter().fold( + String::with_capacity(64), + |mut out, byte| { out.push_str(&format!("{byte:02x}")); out - }); + }, + ); format!( "AWS4-HMAC-SHA256 Credential={access_key}/{scope}, SignedHeaders=host;x-amz-content-sha256;x-amz-date, Signature={signature}" ) @@ -1039,7 +1042,10 @@ mod tests { ); assert_eq!(BackupRemoteConfig::parse(&text), cfg); // 未知键与坏行安静跳过。 - assert_eq!(BackupRemoteConfig::parse("garbage\nunknown=1\n"), BackupRemoteConfig::default()); + assert_eq!( + BackupRemoteConfig::parse("garbage\nunknown=1\n"), + BackupRemoteConfig::default() + ); } #[test] diff --git a/nebula_app/src/cli.rs b/nebula_app/src/cli.rs index bd04081..ecbef00 100644 --- a/nebula_app/src/cli.rs +++ b/nebula_app/src/cli.rs @@ -400,6 +400,15 @@ pub enum ControlCommand { Describe, /// Read the authoritative window, tab, pane, and task-state projection. Snapshot, + /// Execute one typed multi-step terminal workflow in a single Runtime request. + Orchestrate { + /// Inline UTF-8 JSON object containing steps and on_error. + #[clap(long, conflicts_with = "file", required_unless_present = "file")] + spec: Option, + /// Read the UTF-8 workflow JSON object from a file. + #[clap(long, value_hint = ValueHint::FilePath, conflicts_with = "spec")] + file: Option, + }, /// List only panes Nebula recognizes as AI agents, with semantic state and session identity. Agents { #[clap(long)] @@ -503,6 +512,9 @@ pub enum ControlCommand { Split { #[clap(long)] window: Option, + /// Split this pane instead of the currently focused pane. + #[clap(long)] + pane: Option, #[clap(long, value_enum, default_value = "right")] direction: ControlSplitDirection, }, diff --git a/nebula_app/src/directory_history.rs b/nebula_app/src/directory_history.rs index 161a6f5..a128932 100644 --- a/nebula_app/src/directory_history.rs +++ b/nebula_app/src/directory_history.rs @@ -142,6 +142,21 @@ impl DirectoryHistory { } } + /// 空的内存实例，不碰磁盘。给**其它模块**的测试用（补齐引擎要一个不产出 + /// 任何 frecency 候选的数据源，好让断言只反映被测的那条分支）。 + #[cfg(test)] + pub(crate) fn empty() -> Self { + Self { + state: Arc::new(Mutex::new(ServiceState { + database: DirectoryDatabase { version: DATABASE_VERSION, entries: Vec::new() }, + pending: Vec::new(), + unsaved_seed: None, + path: PathBuf::new(), + persistence_enabled: false, + })), + } + } + /// Record a directory only after the shell reports it as the active cwd. pub(crate) fn record(&self, path: &str) -> bool { let Some(observation) = observation(path, current_time()) else { return false }; diff --git a/nebula_app/src/display/content.rs b/nebula_app/src/display/content.rs index a8d0c89..bcc4022 100644 --- a/nebula_app/src/display/content.rs +++ b/nebula_app/src/display/content.rs @@ -88,8 +88,10 @@ impl<'a> RenderableContent<'a> { // Convert terminal cursor point to viewport position. let cursor_point = terminal_content.cursor.point; - let cursor_point = term::point_to_viewport_from(terminal_content.viewport_origin, cursor_point) - .filter(|point| point.line < size.screen_lines() && point.column.0 < size.columns()); + let cursor_point = + term::point_to_viewport_from(terminal_content.viewport_origin, cursor_point).filter( + |point| point.line < size.screen_lines() && point.column.0 < size.columns(), + ); let hint = if display.hint_state.active() { display.hint_state.update_matches(term); @@ -585,7 +587,12 @@ pub(crate) fn cell_background_is_fixed( /// Alpha-compose a theme overlay over the cell's existing background. Keeping /// this in the render model preserves explicit ANSI cell backgrounds while /// still allowing the default transparent terminal surface/image to show. -pub(crate) fn composite_overlay(overlay: Rgb, overlay_alpha: f32, base: Rgb, base_alpha: f32) -> (Rgb, f32) { +pub(crate) fn composite_overlay( + overlay: Rgb, + overlay_alpha: f32, + base: Rgb, + base_alpha: f32, +) -> (Rgb, f32) { let oa = overlay_alpha.clamp(0.0, 1.0); let ba = base_alpha.clamp(0.0, 1.0); let out_a = oa + ba * (1.0 - oa); diff --git a/nebula_app/src/display/context_menu.rs b/nebula_app/src/display/context_menu.rs index 6a48426..825328d 100644 --- a/nebula_app/src/display/context_menu.rs +++ b/nebula_app/src/display/context_menu.rs @@ -493,11 +493,7 @@ pub(super) fn hit_test( return ContextMenuHit::Action(*action); } } - if contains(layout.panel, x, y) { - ContextMenuHit::Panel - } else { - ContextMenuHit::Outside - } + if contains(layout.panel, x, y) { ContextMenuHit::Panel } else { ContextMenuHit::Outside } } fn fade_ink(base: Rgba, ink: Rgb, opacity: f32) -> Rgb { @@ -707,8 +703,8 @@ mod tests { let plain = ContextMenu::new(ContextMenuTarget::Tab(3), (100.0, 100.0), None); assert_eq!(layout(&plain, size(), 1.0, 0.0).rows.len(), 6); - let forkable = ContextMenu::new(ContextMenuTarget::Tab(3), (100.0, 100.0), None) - .with_ai_fork(true); + let forkable = + ContextMenu::new(ContextMenuTarget::Tab(3), (100.0, 100.0), None).with_ai_fork(true); let layout = layout(&forkable, size(), 1.0, 0.0); assert_eq!(layout.rows.len(), 7); assert_eq!(layout.rows[0].action, ContextMenuAction::ForkAiSession(3)); diff --git a/nebula_app/src/display/file_dialog.rs b/nebula_app/src/display/file_dialog.rs index a0b19c0..626a015 100644 --- a/nebula_app/src/display/file_dialog.rs +++ b/nebula_app/src/display/file_dialog.rs @@ -136,8 +136,8 @@ pub(crate) fn pick_private_key_file_with_hwnd( /// both use this exact classifier so a `.pub` file can never silently enter a /// profile just because the shell used a different native file-dialog API. pub(crate) fn validate_private_key_path(path: &std::path::Path) -> Result { - let contents = std::fs::read(path) - .map_err(|err| format!("无法读取私钥 {}: {err}", path.display()))?; + let contents = + std::fs::read(path).map_err(|err| format!("无法读取私钥 {}: {err}", path.display()))?; match classify_private_key_contents(&contents) { PrivateKeyFileKind::PrivateKey => Ok(path.to_path_buf()), PrivateKeyFileKind::PublicKey => Err("请选择私钥文件，不要选择 .pub 公钥".to_owned()), diff --git a/nebula_app/src/display/keymap.rs b/nebula_app/src/display/keymap.rs index 36af5cd..eb28627 100644 --- a/nebula_app/src/display/keymap.rs +++ b/nebula_app/src/display/keymap.rs @@ -466,8 +466,8 @@ pub(crate) fn capture_gpui(keystroke: &::gpui::Keystroke) -> CaptureOutcome { "backspace" if mods.is_empty() => return CaptureOutcome::ClearCustom, // 裸修饰键按下在 Windows 走 ModifiersChanged 而非 KeyDown，这里 // 兜住其它平台的命名差异（"control"/"super"/"meta"…）。 - "control" | "ctrl" | "shift" | "alt" | "alternate" | "super" | "meta" - | "command" | "win" | "function" | "capslock" | "numlock" | "scrolllock" => { + "control" | "ctrl" | "shift" | "alt" | "alternate" | "super" | "meta" | "command" + | "win" | "function" | "capslock" | "numlock" | "scrolllock" => { return CaptureOutcome::Pending; }, _ => {}, @@ -551,6 +551,20 @@ mod tests { assert!(parse_combo("notakey").is_none()); } + #[cfg(feature = "gpui-shell")] + #[test] + fn gpui_capture_records_page_down_instead_of_leaving_it_pending() { + let keystroke = gpui::Keystroke { + modifiers: gpui::Modifiers::default(), + key: "pagedown".to_owned(), + key_char: None, + }; + let CaptureOutcome::Bind(combo) = capture_gpui(&keystroke) else { + panic!("PageDown 应结束录制并生成绑定"); + }; + assert_eq!(combo, "pagedown"); + } + #[test] fn action_names_roundtrip() { for (action, ..) in EDITABLE_ACTIONS { diff --git a/nebula_app/src/display/mod.rs b/nebula_app/src/display/mod.rs index bd5b446..cb324fe 100644 --- a/nebula_app/src/display/mod.rs +++ b/nebula_app/src/display/mod.rs @@ -108,6 +108,7 @@ pub use state::{ AcceptKey, AiSessionIdentity, CompletionStyle, NebulaCompletionItem, NebulaCompletionKind, NebulaConfirm, NebulaInlineImage, NebulaPaneState, NebulaShell, SplitDirection, SplitNav, }; +pub use suggest_engine::SuggestEnv; pub use toast::ToastKind; pub(crate) mod file_dialog; @@ -155,13 +156,13 @@ pub(crate) struct RemoteBackupRequest { pub(crate) fn caret_blink_on() -> bool { ui::caret::is_on() } -pub use settings::{ - BgPickerPart, NebulaSettingsSection, SettingsDropdown, SettingsHit, settings_hit, -}; pub(crate) use settings::{ BACKGROUND_SWATCHES, CellWidthMode, NewTabPosition, SettingsOpacityTarget, hsv_to_rgb, rgb_to_hsv, }; +pub use settings::{ + BgPickerPart, NebulaSettingsSection, SettingsDropdown, SettingsHit, settings_hit, +}; #[cfg(feature = "gpui-shell")] pub(crate) use settings::{ MANUAL_PROXY_PROTOCOL_OPTIONS, ManualProxyProtocol, ProxyTestStatus, manual_proxy_parts, @@ -360,10 +361,8 @@ fn apply_min_window_size( pad.1, nebula_terminal::term::MIN_SCREEN_LINES, ); - window.set_min_inner_size(Some(LogicalSize::new( - (min_w / scale) as f64, - (min_h / scale) as f64, - ))); + window + .set_min_inner_size(Some(LogicalSize::new((min_w / scale) as f64, (min_h / scale) as f64))); } /// 三条可拖拽的面板分界线（设置·交互的「拖拽调节」开关管辖）。 @@ -671,7 +670,11 @@ struct NebulaPowerlineIcon { /// the top in pin order. One function so startup and settings hot-reload /// build the exact same list — the GPUI shell reads the same authority /// (`pub(crate)`) instead of growing a second ordering policy. -pub(crate) fn merge_ssh_hosts(saved: &[String], pinned: &[String], hidden: &[String]) -> Vec { +pub(crate) fn merge_ssh_hosts( + saved: &[String], + pinned: &[String], + hidden: &[String], +) -> Vec { let mut hosts: Vec<_> = saved.iter().filter(|host| !hidden.contains(host)).cloned().collect(); for host in crate::ssh::ssh_config_hosts() { if !hidden.contains(&host) && !hosts.contains(&host) { @@ -1262,10 +1265,10 @@ fn nebula_command_hint<'a>(commands: &'a [String], prefix: &str) -> Option<&'a s return None; } let (head, rem) = command.split_at(prefix.len()); - #[cfg(windows)] - let matches = head.eq_ignore_ascii_case(prefix); - #[cfg(not(windows))] - let matches = head == prefix; + #[cfg(windows)] + let matches = head.eq_ignore_ascii_case(prefix); + #[cfg(not(windows))] + let matches = head == prefix; matches.then_some(rem) }) @@ -1294,10 +1297,10 @@ fn nebula_command_hints<'a>(commands: &'a [String], prefix: &str, limit: usize) if exact != exact_only { continue; } - #[cfg(windows)] - let matches = head.eq_ignore_ascii_case(prefix); - #[cfg(not(windows))] - let matches = head == prefix; + #[cfg(windows)] + let matches = head.eq_ignore_ascii_case(prefix); + #[cfg(not(windows))] + let matches = head == prefix; #[cfg(windows)] let duplicate = out.iter().any(|seen| seen.eq_ignore_ascii_case(command)); @@ -2194,13 +2197,7 @@ impl Display { // content into hundreds of soft-wrapped rows that overflow the // scrollback (data loss no reflow can undo). #[cfg(windows)] - apply_min_window_size( - &window, - config, - cell_width, - cell_height, - settings_init.sidebar_w, - ); + apply_min_window_size(&window, config, cell_width, cell_height, settings_init.sidebar_w); // Create renderer. let mut renderer = Renderer::new(&context, config.debug.renderer)?; @@ -3871,8 +3868,7 @@ impl Display { } // 密文槽允许内部空格（trim 在保存侧）；其余槽拒绝空白——URL、 // 路径、区域名里出现空格只会是误粘贴。 - let secret = - crate::backup_remote::secret_field(self.nebula_backup_protocol) == Some(index); + let secret = crate::backup_remote::secret_field(self.nebula_backup_protocol) == Some(index); if ch.is_whitespace() && !secret { return; } @@ -3913,12 +3909,10 @@ impl Display { &secret, ) }, - crate::backup_remote::BackupProtocol::S3 => { - crate::backup_remote::store_s3_secret( - self.nebula_backup_remote_inputs[3].trim(), - &secret, - ) - }, + crate::backup_remote::BackupProtocol::S3 => crate::backup_remote::store_s3_secret( + self.nebula_backup_remote_inputs[3].trim(), + &secret, + ), _ => return, }; match result { @@ -3974,11 +3968,8 @@ impl Display { self.window.request_redraw(); return; } - self.nebula_backup_operation = Some(if upload { - BackupOperation::RemotePush - } else { - BackupOperation::RemotePull - }); + self.nebula_backup_operation = + Some(if upload { BackupOperation::RemotePush } else { BackupOperation::RemotePull }); self.nebula_backup_passphrase.clear(); self.nebula_backup_passphrase_select_all.clear(); self.nebula_backup_status = None; @@ -4102,8 +4093,16 @@ impl Display { self.nebula_backup_status = Some(( self.ui_language() .pick( - if upload { "备份上传中…" } else { "正在取回远端备份…" }, - if upload { "Uploading backup…" } else { "Fetching remote backup…" }, + if upload { + "备份上传中…" + } else { + "正在取回远端备份…" + }, + if upload { + "Uploading backup…" + } else { + "Fetching remote backup…" + }, ) .to_owned(), false, @@ -8318,13 +8317,7 @@ impl Display { /// zooms to a 21px one. #[cfg(windows)] fn apply_min_window_size(&self, config: &UiConfig, cell_width: f32, cell_height: f32) { - apply_min_window_size( - &self.window, - config, - cell_width, - cell_height, - self.nebula_sidebar_w, - ); + apply_min_window_size(&self.window, config, cell_width, cell_height, self.nebula_sidebar_w); } /// Reset glyph cache. @@ -8628,7 +8621,9 @@ impl Display { && selection_range.is_none() { let visible_cursor = term::point_to_viewport_from(viewport_origin, cursor_point) - .filter(|point| point.line < view.screen_lines() && point.column.0 < view.columns()); + .filter(|point| { + point.line < view.screen_lines() && point.column.0 < view.columns() + }); terminal_math::scan_visible( &mut pane_state.terminal_math, &terminal, @@ -8762,8 +8757,9 @@ impl Display { self.damage_tracker.next_frame().mark_fully_damaged(); let vi_cursor_viewport_point = vi_cursor_point.and_then(|cursor| { - term::point_to_viewport_from(viewport_origin, cursor) - .filter(|point| point.line < size_info.screen_lines() && point.column.0 < size_info.columns()) + term::point_to_viewport_from(viewport_origin, cursor).filter(|point| { + point.line < size_info.screen_lines() && point.column.0 < size_info.columns() + }) }); self.damage_tracker.damage_vi_cursor(vi_cursor_viewport_point); self.damage_tracker.damage_selection(selection_range, display_offset); @@ -8966,8 +8962,9 @@ impl Display { None => { let num_lines = size_info.screen_lines(); match vi_cursor_viewport_point { - None => term::point_to_viewport_from(viewport_origin, cursor_point) - .filter(|point| point.line < num_lines && point.column.0 < size_info.columns()), + None => term::point_to_viewport_from(viewport_origin, cursor_point).filter( + |point| point.line < num_lines && point.column.0 < size_info.columns(), + ), point => point, } }, @@ -10405,7 +10402,7 @@ impl Display { state.suggestion.clear(); state.suggestion_key.clear(); state.completion_items.clear(); - state.completion_selected = 0; + state.completion_selected = None; nebula_debug_log(format!("input_char c={c:?} line_buf={:?}", state.line_buf)); } @@ -10646,7 +10643,7 @@ impl Display { fn draw_completion_popup( &mut self, items: &[NebulaCompletionItem], - selected: usize, + selected: Option, anchor: Point, size_info: &SizeInfo, term_bg: Rgb, @@ -10669,8 +10666,10 @@ impl Display { if rows == 0 { return; } - // When the list is cut short keep the selected row visible. - let offset = if selected >= rows { selected + 1 - rows } else { 0 }; + // When the list is cut short keep an explicitly selected row visible. + let selected = selected.filter(|index| *index < items.len()); + let offset = + selected.filter(|index| *index >= rows).map(|index| index + 1 - rows).unwrap_or(0); let language = self.nebula_language; let tag = |kind: NebulaCompletionKind| -> &'static str { @@ -10681,9 +10680,16 @@ impl Display { NebulaCompletionKind::File => language.pick("文件", "file"), } }; - let cell_width = |text: &str| -> usize { - text.chars().map(|c| c.width().unwrap_or(0)).sum() + let icon = |kind: NebulaCompletionKind| -> char { + match kind { + NebulaCompletionKind::History => '↶', + NebulaCompletionKind::Command => '›', + NebulaCompletionKind::Dir => '/', + NebulaCompletionKind::File => '·', + } }; + let cell_width = + |text: &str| -> usize { text.chars().map(|c| c.width().unwrap_or(0)).sum() }; let visible = &items[offset..(offset + rows).min(items.len())]; let tag_w = visible.iter().map(|item| cell_width(tag(item.kind))).max().unwrap_or(0); @@ -10701,7 +10707,7 @@ impl Display { } let width = full_w.min(avail); let label_w = width.saturating_sub(tag_w + 4); - if label_w < 4 { + if label_w == 0 { return; } @@ -10709,27 +10715,68 @@ impl Display { let opaque = |c: Rgb| Rgba::new(c.r, c.g, c.b, 255); let rgb = |c: Rgba| Rgb::new(c.r, c.g, c.b); let row_bg = rgb(ui::icons::blend_over(opaque(term_bg), sk.panel)); - let (sel_bg, sel_fg) = (sk.accent, sk.ink_on_accent); + let scale = self.window.scale_factor as f32; + let cell_w = size_info.cell_width(); + let cell_h = size_info.cell_height(); + let content_x = size_info.padding_x() + start_col as f32 * cell_w; + let content_y = size_info.padding_y() + start_line as f32 * cell_h; + let content_w = width as f32 * cell_w; + let content_h = rows as f32 * cell_h; + let panel_pad = (4.0 * scale).round(); + let panel = ( + content_x - panel_pad, + content_y - panel_pad, + content_w + panel_pad * 2.0, + content_h + panel_pad * 2.0, + ); + let mut quads = Vec::with_capacity(4); + ui::surface::push_surface_with_radius( + &mut quads, + panel, + (0.0, 0.0, size_info.width(), size_info.height()), + 0.0, + scale, + &sk, + ui::surface::Elevation::Menu, + 1.0, + 8.0, + ); + if let Some(selected) = selected.filter(|index| *index >= offset && *index < offset + rows) + { + let row = selected - offset; + quads.push(UiQuad::solid( + content_x, + content_y + row as f32 * cell_h, + content_w, + cell_h, + 6.0 * scale, + sk.accent_soft, + )); + } + self.renderer.draw_ui(size_info, &quads); for (row, item) in visible.iter().enumerate() { let line = start_line + row; if line >= screen_lines { break; } - let is_selected = offset + row == selected; - let (bg, label_fg, tag_fg) = if is_selected { - (sel_bg, sel_fg, sel_fg) + let is_selected = Some(offset + row) == selected; + let (label_fg, tag_fg, style) = if is_selected { + (sk.ink_strong, sk.ink_strong, Flags::BOLD) } else { - (row_bg, sk.ink, sk.ink_faint) + (sk.ink, sk.ink_faint, Flags::empty()) }; - let label = format!(" {}", nebula_pad_to_cells(&item.label, label_w + 2)); + let label = + format!("{} {}", icon(item.kind), nebula_pad_to_cells(&item.label, label_w + 1)); let tag_text = format!("{} ", nebula_pad_to_cells(tag(item.kind), tag_w)); let glyph_cache = &mut self.glyph_cache; - self.renderer.draw_string( + self.renderer.draw_string_styled( Point::new(line, Column(start_col)), label_fg, - bg, + row_bg, label.chars(), + style, + 0.0, size_info, glyph_cache, ); @@ -10737,11 +10784,13 @@ impl Display { // renderer clips at the grid edge regardless. let tag_col = start_col + 1 + label_w + 2; let glyph_cache = &mut self.glyph_cache; - self.renderer.draw_string( + self.renderer.draw_string_styled( Point::new(line, Column(tag_col)), tag_fg, - bg, + row_bg, tag_text.chars(), + Flags::empty(), + 0.0, size_info, glyph_cache, ); diff --git a/nebula_app/src/display/settings.rs b/nebula_app/src/display/settings.rs index 59fb50f..f580073 100644 --- a/nebula_app/src/display/settings.rs +++ b/nebula_app/src/display/settings.rs @@ -28,8 +28,8 @@ use super::keymap; use super::ui::theme::Skin; use super::ui::{icons, os_icons, surface, text_field, tokens, widgets}; use super::{ - chrome_settings_button_rect, contains_rect, nebula_data_dir, truncate_tab_label, AcceptKey, - CompletionStyle, LanguagePreference, NebulaShell, NebulaTheme, SizeInfo, UiLanguage, + AcceptKey, CompletionStyle, LanguagePreference, NebulaShell, NebulaTheme, SizeInfo, UiLanguage, + chrome_settings_button_rect, contains_rect, nebula_data_dir, truncate_tab_label, }; // Visual language: one flat panel color, one hairline, three text grays, ONE @@ -1014,8 +1014,8 @@ pub(super) fn nebula_settings_load(config: &UiConfig) -> NebulaRuntimeSettings { Some(("copy_on_select", v)) => settings.copy_on_select = parse_bool(v, true), Some(("cjk_bold_regular", v)) => settings.cjk_bold_regular = parse_bool(v, true), Some(("tabs_position", v)) => { - settings.tabs_position = nebula_settings::TabsPositionName::from_settings(v) - .unwrap_or_default(); + settings.tabs_position = + nebula_settings::TabsPositionName::from_settings(v).unwrap_or_default(); }, Some(("tab_reveal", v)) => { settings.tab_reveal = TabRevealMotion::parse(v).unwrap_or_default(); @@ -1439,11 +1439,7 @@ fn settings_viewport_h(popup_h: f32, scale_factor: f32) -> f32 { } fn advanced_content_end(advanced_y0: f32, sync_y0: f32, row_h: f32) -> f32 { - if SHOW_WEBDAV_SYNC_SETTINGS { - sync_y0 + 7.0 * row_h - } else { - advanced_y0 + 4.0 * row_h - } + if SHOW_WEBDAV_SYNC_SETTINGS { sync_y0 + 7.0 * row_h } else { advanced_y0 + 4.0 * row_h } } /// Max scroll offset for `section` at the current window size. The input @@ -3080,11 +3076,7 @@ pub fn settings_hit( } } - if contains_rect(geometry.popup, x, y) { - SettingsHit::Panel - } else { - SettingsHit::None - } + if contains_rect(geometry.popup, x, y) { SettingsHit::Panel } else { SettingsHit::None } } // ---- rendering ---- @@ -5597,11 +5589,7 @@ pub(super) fn draw_popup_text( icon_draws .push((id.clone(), (rx + s(8.0), ry + (rh - s(24.0)) / 2.0, s(24.0), s(24.0)))); text_x = rx + s(40.0); - if program.is_empty() { - name.clone() - } else { - format!("{name} · {program}") - } + if program.is_empty() { name.clone() } else { format!("{name} · {program}") } }, SettingsDropdown::Font => { // 第 0 行是搜索框：它的底与光标在 quads pass 里画，这里只 @@ -5923,11 +5911,7 @@ pub(super) fn draw_text( let clip_bot = py + ph - s(6.0); let visible = |ry: f32, rh: f32| ry >= clip_top && ry + rh <= clip_bot; let row_text_y = |ry: f32, rh: f32| { - if geometry.stacked_rows { - ry + s(9.0) - } else { - ry + (rh - cell_h) / 2.0 - } + if geometry.stacked_rows { ry + s(9.0) } else { ry + (rh - cell_h) / 2.0 } }; // 通用 combobox 的当前值：控件框内左对齐，截断在 chevron 井之前。 let combobox_value = |r: &mut Renderer, @@ -7497,11 +7481,7 @@ pub(super) fn draw_text( rect.0 + s(16.0), ty, if i == keymap::QUICK_TERMINAL_ROW && view.quick_hotkey_error.is_some() { - if sk.is_light { - Rgb::new(207, 34, 46) - } else { - Rgb::new(248, 81, 73) - } + if sk.is_light { Rgb::new(207, 34, 46) } else { Rgb::new(248, 81, 73) } } else { sk.ink }, @@ -8091,19 +8071,19 @@ pub(super) fn draw_text( #[cfg(test)] mod tests { use super::{ - advanced_content_end, background_color_popup, cell_width_mode_label, font_popup_row_count, - font_popup_slot, hsv_to_rgb, manual_proxy_parts, manual_proxy_value, - new_tab_position_label, opacity_from_pointer, proxy_section_title_y, rgb_to_hsv, - row_action_rect, settings_geometry, settings_hit, ssh_proxy_manual_controls, - ssh_proxy_mode_control, ssh_proxy_test_button, CellWidthMode, KeymapPaneState, - ManualProxyProtocol, NebulaSettingsSection, NewTabPosition, ProxyChoice, ProxyPaneState, - Rgb, SettingsHit, TabRevealMotion, UiLanguage, CELL_WIDTH_MODE_OPTIONS, - NEW_TAB_POSITION_OPTIONS, SHOW_BACKUP_SETTINGS, SHOW_WEBDAV_SYNC_SETTINGS, - STANDARD_ROW_ACTION_W, + CELL_WIDTH_MODE_OPTIONS, CellWidthMode, KeymapPaneState, ManualProxyProtocol, + NEW_TAB_POSITION_OPTIONS, NebulaSettingsSection, NewTabPosition, ProxyChoice, + ProxyPaneState, Rgb, SHOW_BACKUP_SETTINGS, SHOW_WEBDAV_SYNC_SETTINGS, + STANDARD_ROW_ACTION_W, SettingsHit, TabRevealMotion, UiLanguage, advanced_content_end, + background_color_popup, cell_width_mode_label, font_popup_row_count, font_popup_slot, + hsv_to_rgb, manual_proxy_parts, manual_proxy_value, new_tab_position_label, + opacity_from_pointer, proxy_section_title_y, rgb_to_hsv, row_action_rect, + settings_geometry, settings_hit, ssh_proxy_manual_controls, ssh_proxy_mode_control, + ssh_proxy_test_button, }; + use crate::display::SizeInfo; use crate::display::ui::tokens::Density; use crate::display::ui::widgets; - use crate::display::SizeInfo; #[test] fn hsv_rgb_round_trip_and_gray_hue_convention() { diff --git a/nebula_app/src/display/side_panel.rs b/nebula_app/src/display/side_panel.rs index 893d58e..84976b1 100644 --- a/nebula_app/src/display/side_panel.rs +++ b/nebula_app/src/display/side_panel.rs @@ -11,7 +11,7 @@ //! every frame. `git --no-optional-locks` keeps the status call from touching //! the index lock, so it can't corrupt or stall a concurrent git operation. -use std::collections::HashSet; +use std::collections::{HashMap, HashSet}; use std::ffi::OsString; use std::path::{Path, PathBuf}; use std::time::{Duration, Instant}; @@ -187,11 +187,21 @@ impl FileDrag { } } -/// Re-run the (throttled) refresh at most this often while the panel is open. -const REFRESH_EVERY: Duration = Duration::from_secs(4); -/// WSL terminal is already running when the drawer asks for a snapshot; a -/// longer wait means the worker is wedged and must not disable future refreshes. -const WSL_COMMAND_TIMEOUT: Duration = Duration::from_secs(6); +/// WSL 子命令预算。 +/// +/// 原值是 6s，注释里的假设是"抽屉要快照时 WSL 终端已经在跑，等更久说明工人卡死" +/// ——2026-08-21 实测推翻了这个假设。`wsl.exe -d Debian -- find /` 的耗时**高度 +/// 可变**：同一台机器上量到 346ms（VM 热）、7.5s（VM 热但要建新会话）、以及 +/// >20s（WSL2 的 VM 因空闲被整个关闭后冷启）。也就是说任何"短"预算都会在某些 +/// 时刻必然超时。 +/// +/// 超时的代价原本被完全隐藏：工人被 kill、[`wsl_read_dirs`] 返回空列表、UI 把空 +/// 结果显示成"此目录为空"——这就是 WSL 文件树空白的真正根因。 +/// +/// 现在预算给足，并且**失败不再伪装成空目录**（见 [`SidePanel::enumeration_failed`]）。 +/// 工人跑在后台线程，放宽预算不卡 UI；`snapshot_running` 保证同一时刻只有一个 +/// 工人；期间面板显示"正在读取目录…"，这是诚实的反馈。 +const WSL_COMMAND_TIMEOUT: Duration = Duration::from_secs(60); /// Hard cap on flattened tree rows, bounding both fs walking and rendering. const MAX_ROWS: usize = 1000; /// Hard cap on entries listed per directory. Applied *after* sorting, so the @@ -279,7 +289,9 @@ pub struct SidePanel { /// 切换视图/根不再同步跑 git——旧内容原样留在屏上，新快照落地后整体 /// 替换（VSCode 的树刷新模式）。 snapshot_slot: std::sync::Arc>>, - last_refresh: Option, + /// 上一份落地快照的枚举是否失败（WSL 超时 / find 非零退出）。UI 靠它区分 + /// "读不到"和"目录真的是空的"。 + enumeration_failed: bool, needs_refresh: bool, } @@ -292,7 +304,12 @@ struct PanelSnapshot { /// Files 快照所属的来宾位置；避免两个发行版恰好同为 `/home` 时串结果。 files_wsl: Option, rows: Vec, - git: Option, + /// 这次枚举是否全部成功。WSL 冷启动可能耗尽预算被 kill，那时 `rows` 是空的 + /// 但**不代表目录是空的**——UI 必须能区分，否则会把"读不到"说成"此目录为空"。 + enumeration_ok: bool, + /// `None` 表示目录行先行发布、VCS 仍在读取；`Some(None)` 才表示当前 + /// 目录不在仓库中。这样慢 WSL git 不会让 Files 一直显示空白。 + git: Option>, } /// 工人 panic/提前返回也必须解锁；否则一次异常会让此窗口今后的所有刷新失效。 @@ -532,7 +549,7 @@ impl SidePanel { op_error: Default::default(), snapshot_running: Default::default(), snapshot_slot: Default::default(), - last_refresh: None, + enumeration_failed: false, needs_refresh: false, } } @@ -625,19 +642,22 @@ impl SidePanel { .or_else(|| self.custom_wsl_root.as_ref().map(wsl_root_key)) .or_else(|| self.followed_tree_root()); let root_changed = next_root != self.root; - // While a filter query is live, skip the periodic re-snapshot: it - // would drop and rebuild the search index under the user's fingers. - let stale = self.search.trim().is_empty() - && self.last_refresh.is_none_or(|t| t.elapsed() >= REFRESH_EVERY); // A finished git mutation forces a refresh so the new state (staged // list, ahead count) shows on the next frame. if self.op_done.swap(false, std::sync::atomic::Ordering::Relaxed) { self.needs_refresh = true; } + // 目录内容**不做定时重扫**。这里原先有一条 `stale`（每 4 秒无条件重跑 + // 工人），代价是每 4 秒重新拉一遍 WSL 子进程 + 三个 git 子进程；配上 WSL + // 冷路径要 7.5s，面板就在"正在读取目录…"和结果之间反复闪——2026-08-21 + // 用户裁定：目录识别不要轮询。 + // + // 剩下的触发点全是明确事件：cwd/根变化、手动刷新按钮（`needs_refresh`）、 + // git 操作完成（`op_done`）、浏览覆盖失效。终端里新建/删除文件不再自动 + // 反映，由刷新按钮兜底——这是这条裁定的显式代价。 if !(root_changed || custom_invalidated || follow_override_cleared - || stale || wsl_changed || self.needs_refresh) { @@ -688,7 +708,10 @@ impl SidePanel { return false; } self.rows = snapshot.rows; - self.git = snapshot.git; + self.enumeration_failed = !snapshot.enumeration_ok; + if let Some(git) = snapshot.git { + self.git = git; + } // New snapshot → the filter index is stale; rebuild lazily on demand. self.search_index = None; true @@ -810,7 +833,6 @@ impl SidePanel { /// Rebuild the tree and git snapshot from `root`. fn refresh(&mut self) { self.needs_refresh = false; - self.last_refresh = Some(Instant::now()); let Some(root) = self.root.clone() else { // 没有根：清空是即时且无成本的，不需要工人。 self.rows.clear(); @@ -838,10 +860,21 @@ impl SidePanel { let slot = std::sync::Arc::clone(&self.snapshot_slot); std::thread::spawn(move || { let _running_guard = SnapshotRunningGuard(running); - let rows = match &files_wsl { + let (rows, enumeration_ok) = match &files_wsl { Some(located) => SidePanel::tree_rows_wsl(located, &expanded), - None => SidePanel::tree_rows(&root, &expanded), + None => (SidePanel::tree_rows(&root, &expanded), true), }; + // 文件列表是 Files 的主结果，不能被随后可能耗满超时预算的 WSL + // git 探测扣住。先发布目录行；VCS 完成后再用同一行集补全快照。 + if let Ok(mut slot) = slot.lock() { + *slot = Some(PanelSnapshot { + root: root.clone(), + files_wsl: files_wsl.clone(), + rows: rows.clone(), + enumeration_ok, + git: None, + }); + } // 设置可强制只认 Git / SVN（混合仓库场景）；Auto 保持既有探测： // a checkout nested inside a Git tree must remain visible as SVN. // Prefer SVN only when its metadata is in the current path's @@ -874,7 +907,8 @@ impl SidePanel { }, }; if let Ok(mut slot) = slot.lock() { - *slot = Some(PanelSnapshot { root, files_wsl, rows, git }); + *slot = + Some(PanelSnapshot { root, files_wsl, rows, enumeration_ok, git: Some(git) }); } }); } @@ -886,10 +920,17 @@ impl SidePanel { let Some(root) = self.root.clone() else { return }; let needle = self.search.trim().to_lowercase(); if needle.is_empty() { - self.rows = match self.file_wsl_root() { - Some(located) => Self::tree_rows_wsl(located, &self.expanded), - None => Self::tree_rows(&root, &self.expanded), - }; + match self.file_wsl_root() { + Some(located) => { + let (rows, ok) = Self::tree_rows_wsl(located, &self.expanded); + self.rows = rows; + self.enumeration_failed = !ok; + }, + None => { + self.rows = Self::tree_rows(&root, &self.expanded); + self.enumeration_failed = false; + }, + } return; } // Filter mode: string-match against the cached flat index. The index @@ -1330,10 +1371,14 @@ impl SidePanel { /// UNC 不可达时直接从 WSL guest 枚举 Files 树。命令参数逐项传给 /// `CreateProcessW`，不经过 shell，因此发行版名、路径和文件名都不会参与 /// 命令拼接。`find -printf` 用 NUL 分隔，换行文件名也不会破坏记录边界。 + /// 返回 `(行, 枚举是否全部成功)`。失败必须往上传，否则 UI 只能看到一个空 + /// 列表、把"读不到"说成"此目录为空"。 + /// + /// 整棵树只发**一条** `find`，见 [`wsl_read_dirs`]。 fn tree_rows_wsl( located: &crate::shell_detect::WslCwd, expanded: &HashSet, - ) -> Vec { + ) -> (Vec, bool) { let root = normalize_wsl_guest_path(&located.guest); let mut rows = Vec::new(); if let Some(parent) = wsl_guest_parent(&root) { @@ -1348,43 +1393,52 @@ impl SidePanel { ignored: false, }); } - Self::flatten_wsl_dir_into(&mut rows, expanded, &located.distro, &root, 0); - rows + let dirs = wsl_dirs_to_list(&root, expanded); + let Some(listing) = wsl_read_dirs(&located.distro, &dirs) else { + return (rows, false); + }; + Self::flatten_wsl_dir_into(&mut rows, expanded, &listing, &root, 0); + // 非零退出通常只是某个已展开的子目录在两帧之间被删了——那一条起点报错， + // 其余起点的输出照样在 stdout 里。只有**根**也没读出条目时才是真失败： + // 根为空的目录不可能有已展开的后代，所以这时起点只有根一个，非零退出 + // 就等于根读不到。 + let ok = listing.exit_ok || listing.by_dir.contains_key(&root); + (rows, ok) } + /// 把一趟 `find` 的结果摊平成树行。已经没有子进程了：所有层的条目都在 + /// `listing` 里，递归只是按 `expanded` 挑出要展开的桶。 fn flatten_wsl_dir_into( rows: &mut Vec, expanded: &HashSet, - distro: &str, + listing: &WslDirListing, guest_dir: &str, depth: usize, ) { if rows.len() >= MAX_ROWS { return; } - let mut entries = wsl_read_dir(distro, guest_dir); - entries.sort_by(|a, b| b.0.cmp(&a.0).then(a.1.to_lowercase().cmp(&b.1.to_lowercase()))); - entries.truncate(MAX_PER_DIR); + let Some(entries) = listing.by_dir.get(guest_dir) else { return }; for (is_dir, name, guest_path) in entries { if rows.len() >= MAX_ROWS { return; } // 该 PathBuf 只作为展开/选中的稳定键；真实来宾路径始终取 // `guest_path`，绝不把这个键交给宿主文件系统。 - let path_key = PathBuf::from(&guest_path); - let is_expanded = is_dir && expanded.contains(&path_key); + let path_key = PathBuf::from(guest_path); + let is_expanded = *is_dir && expanded.contains(&path_key); rows.push(FileRow { - path: path_key.clone(), + path: path_key, guest_path: Some(guest_path.clone()), - name, + name: name.clone(), depth, - is_dir, + is_dir: *is_dir, expanded: is_expanded, is_parent: false, ignored: false, }); if is_expanded { - Self::flatten_wsl_dir_into(rows, expanded, distro, &guest_path, depth + 1); + Self::flatten_wsl_dir_into(rows, expanded, listing, guest_path, depth + 1); } } } @@ -1562,6 +1616,17 @@ impl SidePanel { &self.rows } + /// 首份目录快照是否仍在后台读取。GPUI 用它区分“正在读取”和真空目录。 + pub fn snapshot_pending(&self) -> bool { + self.snapshot_running.load(std::sync::atomic::Ordering::Acquire) + } + + /// 上一次落地的枚举是否失败（WSL 冷启动耗尽预算、find 非零退出等）。 + /// 行为空且这里为真时，UI 必须提示可重试，而不是宣称“此目录为空”。 + pub fn enumeration_failed(&self) -> bool { + self.enumeration_failed + } + /// The tree row currently shown at visible index `idx` (post-scroll). pub fn visible_row(&self, idx: usize) -> Option<&FileRow> { if self.view != PanelView::Files { @@ -1850,7 +1915,10 @@ fn command_output_with_timeout( use std::io::Read as _; use std::process::Stdio; - command.stdout(Stdio::piped()).stderr(Stdio::piped()); + // stdin 显式关掉：这些子进程（`wsl.exe -d … -- find`、`git`）都不读 stdin， + // 而我们用 `CREATE_NO_WINDOW` 启动它们——不设置 stdin 会把父进程的控制台 + // 句柄继承给一个没有控制台的子进程。这是卫生问题，不是任何已知 bug 的根因。 + command.stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::piped()); let mut child = command.spawn()?; let stdout = child.stdout.take().ok_or_else(|| { std::io::Error::new(std::io::ErrorKind::BrokenPipe, "missing stdout pipe") @@ -1893,7 +1961,14 @@ fn command_output_with_timeout( Ok(std::process::Output { status, stdout: join(stdout_reader)?, stderr: join(stderr_reader)? }) } -fn run_wsl_find(distro: &str, args: impl IntoIterator) -> Option> { +/// 跑一条来宾 `find`，返回 `(stdout, 退出码是否为 0)`。 +/// +/// 非零退出**不丢 stdout**：多起点的 `find` 只要有一个起点不存在就整体非零， +/// 而其余起点的记录照样已经写出来了。调用方按自己的语义决定这算失败还是降级。 +fn run_wsl_find_lenient( + distro: &str, + args: impl IntoIterator, +) -> Option<(Vec, bool)> { let mut command = std::process::Command::new("wsl.exe"); command.args(["-d", distro, "--", "find"]).args(args); #[cfg(windows)] @@ -1908,28 +1983,139 @@ fn run_wsl_find(distro: &str, args: impl IntoIterator) -> Optio return None; }, }; - if !output.status.success() { + let exit_ok = output.status.success(); + if !exit_ok { let reason = String::from_utf8_lossy(&output.stderr); - log::debug!("WSL file tree find failed in {distro}: {}", reason.trim()); - return None; + log::debug!("WSL file tree find exited non-zero in {distro}: {}", reason.trim()); } - Some(output.stdout) + Some((output.stdout, exit_ok)) } -fn wsl_read_dir(distro: &str, guest_dir: &str) -> Vec<(bool, String, String)> { - let args = [guest_dir, "-mindepth", "1", "-maxdepth", "1", "-printf", r"%y\0%f\0"] - .into_iter() - .map(OsString::from); - let Some(output) = run_wsl_find(distro, args) else { return Vec::new() }; - parse_wsl_find_pairs(&output) - .into_iter() - .filter_map(|(kind, name)| { - (name != ".git").then(|| { - let guest_path = wsl_guest_join(guest_dir, &name); - (kind == b'd', name, guest_path) - }) - }) - .collect() +/// 退出码非零一律当失败的严格版；单起点调用（搜索索引）用它。 +fn run_wsl_find(distro: &str, args: impl IntoIterator) -> Option> { + let (stdout, exit_ok) = run_wsl_find_lenient(distro, args)?; + exit_ok.then_some(stdout) +} + +/// `find -printf` 的格式串：类型 + NUL + 全路径 + NUL。**反斜杠必须写两遍**。 +/// +/// 2026-08-21 实测：`wsl.exe -d <发行版> -- <命令>` 在把参数转发给来宾时会吞掉 +/// 一层反斜杠。同一条 find、同一个目录，三种写法的输出对照： +/// +/// | 传入 | NUL 个数 | 输出开头 | +/// |---|---|---| +/// | `%y\0%f\0` | **0** | `l0lib0d0opt0…` | +/// | `%y\\0%f\\0` | 54 | `l\0lib\0d\0opt\0…` | +/// | `sh -c` 包一层 | 54 | `l\0lib\0d\0opt\0…` | +/// +/// 也就是说单反斜杠版本让 find 收到的是 `%y0%f0`，输出用字面字符 `'0'` 分隔、 +/// 一个 NUL 都没有，[`parse_wsl_find_pairs`] 因此永远配不出记录、返回空列表—— +/// UI 再把空列表显示成"此目录为空"。这就是 WSL 文件树空白的根因。 +/// +/// 用双反斜杠而不是 `sh -c` 包装：后者要为含空格/引号的来宾路径再做一层 shell +/// 引用，而这里只需要把转义层数补对。 +const WSL_FIND_PATH_FORMAT: &str = r"%y\\0%p\\0"; + +/// 一趟 `find` 的结果，按父目录分桶。 +struct WslDirListing { + /// 来宾父目录 → 该层条目 `(is_dir, 名字, 来宾全路径)`，已按"目录在前、 + /// 名字不分大小写升序"排好并按 [`MAX_PER_DIR`] 截断。 + by_dir: HashMap>, + /// `find` 自身的退出码是否为 0。多起点时一个起点不存在就会让它非零， + /// 所以这只是降级信号，判断"树是否可用"要看根桶在不在。 + exit_ok: bool, +} + +/// 这一趟要枚举的来宾目录：根，加上 `expanded` 里位于根之下的每一个。 +/// +/// 祖先链是否也展开无所谓——多列一个目录在同一条命令里几乎免费，漏列一个却会 +/// 让那层显示成空目录。排序后返回：`expanded` 是 `HashSet`，遍历顺序不定，而 +/// 截断必须是确定的。根一定排在首位（它是所有后代的真前缀且更短），所以截断 +/// 永远不会把根本身丢掉。 +fn wsl_dirs_to_list(root: &str, expanded: &HashSet) -> Vec { + /// 命令行长度是有上限的（Windows 约 32 KiB）。来宾路径平均几十字节，256 个 + /// 起点离上限还很远，而真展开到 256 个目录本身已经超出 [`MAX_ROWS`] 的显示 + /// 能力了。 + const MAX_ROOTS: usize = 256; + + let mut dirs = vec![root.to_owned()]; + for path in expanded { + let Some(text) = path.to_str() else { continue }; + let guest = normalize_wsl_guest_path(text); + if !wsl_path_is_descendant(root, &guest) { + continue; + } + dirs.push(guest); + } + dirs.sort_unstable(); + dirs.dedup(); + dirs.truncate(MAX_ROOTS); + dirs +} + +/// `path` 是否严格位于 `root` 之下。两侧都已 [`normalize_wsl_guest_path`]。 +fn wsl_path_is_descendant(root: &str, path: &str) -> bool { + if root == "/" { + return path.starts_with('/') && path.len() > 1; + } + path.len() > root.len() + && path.starts_with(root) + && path.as_bytes().get(root.len()) == Some(&b'/') +} + +/// 一条 `find` 枚举全部给定目录。`None` = 这次来宾枚举**根本没跑成** +/// （wsl.exe 起不来 / 超时），与"目录真的是空的"必须区分：前者要让用户看到 +/// 可重试的提示，后者才是"此目录为空"。 +/// +/// # 为什么是一条而不是每层一条 +/// +/// 旧实现在递归里每展开一层就 fork 一次 `wsl.exe`。实测冷启动 7.5 秒、热约 +/// 300 ms，而快照工人每次重建整棵树都要把已展开的每一层重跑一遍——展开 5 层 +/// 就是 5 次串行往返。这就是"WSL 打开路径非常卡"的根因。`find` 原生接受多个 +/// 起点，而要枚举哪些目录**不需要先枚举才能知道**（`expanded` 集合已经持有）， +/// 所以一次调用就够。 +/// +/// 用 `%p`（全路径）而非 `%f`：多起点的输出是混在一起的，只有全路径才能按父 +/// 目录分桶还原成树。 +fn wsl_read_dirs(distro: &str, dirs: &[String]) -> Option { + if dirs.is_empty() { + return None; + } + let mut args: Vec = dirs.iter().map(OsString::from).collect(); + args.extend( + ["-mindepth", "1", "-maxdepth", "1", "-printf", WSL_FIND_PATH_FORMAT] + .into_iter() + .map(OsString::from), + ); + let (output, exit_ok) = run_wsl_find_lenient(distro, args)?; + Some(WslDirListing { by_dir: bucket_wsl_find_output(&output), exit_ok }) +} + +/// 把一趟多起点 `find` 的扁平输出按父目录分桶还原成树的各层。 +/// +/// 每桶按"目录在前、名字不分大小写升序"排好并按 [`MAX_PER_DIR`] 截断——截断 +/// 必须在排序**之后**，否则采样到的是文件系统顺序（见 +/// `per_directory_cap_keeps_the_ordered_head`）。 +fn bucket_wsl_find_output(output: &[u8]) -> HashMap> { + let mut by_dir: HashMap> = HashMap::new(); + for (kind, guest_path) in parse_wsl_find_pairs(output) { + let Some((parent, name)) = guest_path.rsplit_once('/') else { continue }; + if name.is_empty() || name == ".git" { + continue; + } + // 根下的条目（`/home`）切出来的父是空串，归一化回 `/`。 + let parent = if parent.is_empty() { "/" } else { parent }; + by_dir.entry(parent.to_owned()).or_default().push(( + kind == b'd', + name.to_owned(), + guest_path.clone(), + )); + } + for entries in by_dir.values_mut() { + entries.sort_by(|a, b| b.0.cmp(&a.0).then(a.1.to_lowercase().cmp(&b.1.to_lowercase()))); + entries.truncate(MAX_PER_DIR); + } + by_dir } fn build_wsl_search_index( @@ -1946,7 +2132,9 @@ fn build_wsl_search_index( for skipped in SEARCH_SKIP_DIRS.iter().filter(|name| !name.starts_with('.')) { args.extend([OsString::from("-o"), OsString::from("-name"), OsString::from(skipped)]); } - args.extend([")", "-prune", ")", "-o", "-printf", r"%y\0%p\0"].into_iter().map(OsString::from)); + args.extend( + [")", "-prune", ")", "-o", "-printf", WSL_FIND_PATH_FORMAT].into_iter().map(OsString::from), + ); let Some(output) = run_wsl_find(&located.distro, args) else { return }; for (kind, guest_path) in parse_wsl_find_pairs(&output) { if *budget == 0 || index.len() >= SEARCH_INDEX_CAP { @@ -3244,14 +3432,154 @@ mod tests { assert_eq!(parsed, vec![(b'd', "hello".to_owned()), (b'f', "line\nname.txt".to_owned())]); } + /// WSL 来宾根的枚举回归。依赖本机真实 Debian，所以默认忽略； + /// 用 `cargo test -p nebula --features gpui-shell -- --ignored` 手动跑。 + #[test] + #[ignore = "需要本机注册 Debian 发行版"] + fn wsl_guest_root_enumerates_entries() { + let located = + crate::shell_detect::WslCwd { distro: "Debian".to_owned(), guest: "/".to_owned() }; + let (rows, ok) = SidePanel::tree_rows_wsl(&located, &HashSet::new()); + assert!(ok, "枚举必须成功（失败通常是 WSL 冷启动耗尽预算）"); + assert!(!rows.is_empty(), "WSL `/` 必须枚举出来宾条目"); + assert!(rows.iter().any(|row| row.name == "home"), "应当含 home：{rows:?}"); + assert!(rows.iter().all(|row| !row.is_parent), "根目录不该有 `..` 行"); + } + + /// 展开多层的代价必须**不随层数增长**。 + /// + /// 旧实现在递归里每层 fork 一次 `wsl.exe`（冷启动实测 7.5 秒），展开 5 层 + /// 就是 5 次串行往返——这是"WSL 打开路径非常卡"的根因。现在整棵树只发一条 + /// 多起点 `find`，所以展开若干层的耗时应当和只读根同量级。 + /// + /// 判据用倍数而不是绝对秒数：`wsl.exe` 的耗时高度可变（346ms / 7.5s / >20s， + /// 见 [`WSL_COMMAND_TIMEOUT`] 的实测记录），任何硬编码的墙钟阈值都会在某些 + /// 时刻误报。基准跑在被测调用**之前**，把冷启动的一次性代价算进基准里。 + #[test] + #[ignore = "需要本机注册 Debian 发行版"] + fn expanding_many_levels_costs_one_find_not_one_per_level() { + let located = + crate::shell_detect::WslCwd { distro: "Debian".to_owned(), guest: "/".to_owned() }; + + let baseline_started = Instant::now(); + let (root_rows, ok) = SidePanel::tree_rows_wsl(&located, &HashSet::new()); + let baseline = baseline_started.elapsed(); + assert!(ok, "基准枚举必须成功"); + + // 从根的真实条目里挑目录来展开，避免钉死在某个发行版才有的路径上。 + let expanded: HashSet = + root_rows.iter().filter(|row| row.is_dir).take(5).map(|row| row.path.clone()).collect(); + assert!(expanded.len() >= 2, "根下至少要有两个目录才测得出层数效应"); + + let started = Instant::now(); + let (rows, ok) = SidePanel::tree_rows_wsl(&located, &expanded); + let elapsed = started.elapsed(); + assert!(ok, "多层枚举必须成功"); + assert!(rows.len() > root_rows.len(), "展开后应当多出子层的行"); + + let ceiling = baseline.mul_f32(1.8); + assert!( + elapsed <= ceiling, + "展开 {} 层花了 {elapsed:?}，基准（只读根）是 {baseline:?}——按每层一次 \ + 子进程算本该接近 {:?}，说明合并 find 没有生效", + expanded.len(), + baseline * (expanded.len() as u32 + 1) + ); + } + + #[test] + fn partial_file_snapshot_keeps_vcs_until_the_final_snapshot() { + let located = + crate::shell_detect::WslCwd { distro: "Debian".to_owned(), guest: "/".to_owned() }; + let root = PathBuf::from("/"); + let mut panel = SidePanel::new(); + panel.open = true; + panel.root = Some(root.clone()); + panel.followed_wsl = Some(located.clone()); + panel.git = Some(GitInfo { branch: "keep-until-ready".to_owned(), ..Default::default() }); + + *panel.snapshot_slot.lock().unwrap() = Some(PanelSnapshot { + root: root.clone(), + files_wsl: Some(located.clone()), + rows: Vec::new(), + enumeration_ok: true, + git: None, + }); + assert!(panel.harvest_snapshot()); + assert_eq!(panel.git().map(|git| git.branch.as_str()), Some("keep-until-ready")); + + *panel.snapshot_slot.lock().unwrap() = Some(PanelSnapshot { + root, + files_wsl: Some(located), + rows: Vec::new(), + enumeration_ok: true, + git: Some(None), + }); + assert!(panel.harvest_snapshot()); + assert!(panel.git().is_none()); + } + #[test] fn wsl_guest_path_helpers_keep_root_and_parent_boundaries() { assert_eq!(normalize_wsl_guest_path("/home/hello/"), "/home/hello"); assert_eq!(wsl_guest_parent("/home/hello"), Some("/home".to_owned())); assert_eq!(wsl_guest_parent("/home"), Some("/".to_owned())); assert_eq!(wsl_guest_parent("/"), None); - assert_eq!(wsl_guest_join("/", "home"), "/home"); - assert_eq!(wsl_guest_join("/home", "hello"), "/home/hello"); + } + + /// 起点集合决定这一趟 `find` 的覆盖面，所以边界只能是"严格后代"：把兄弟 + /// 目录（`/home/kudo` 之于 `/home/kud`）也塞进去会枚举出树上根本不存在的 + /// 层，漏掉真后代则让那层显示成空目录。 + #[test] + fn only_strict_descendants_of_the_root_join_the_find() { + assert!(wsl_path_is_descendant("/", "/home")); + assert!(!wsl_path_is_descendant("/", "/"), "根不是自己的后代"); + assert!(wsl_path_is_descendant("/home/kud", "/home/kud/src")); + assert!(!wsl_path_is_descendant("/home/kud", "/home/kud")); + assert!(!wsl_path_is_descendant("/home/kud", "/home/kudo"), "前缀相同但不是子目录"); + assert!(!wsl_path_is_descendant("/home/kud", "/etc")); + } + + /// 根必须排在起点表首位：`expanded` 是 `HashSet`，遍历顺序不定，而超出上限 + /// 的截断一旦把根切掉，整棵树就只剩 `..` 一行。 + #[test] + fn the_root_always_survives_the_start_point_cap() { + let expanded: HashSet = ["/home/kud/z", "/home/kud/a", "/elsewhere", "/home/kud"] + .into_iter() + .map(PathBuf::from) + .collect(); + let dirs = wsl_dirs_to_list("/home/kud", &expanded); + assert_eq!(dirs.first().map(String::as_str), Some("/home/kud")); + assert_eq!(dirs, vec!["/home/kud", "/home/kud/a", "/home/kud/z"], "根外的路径不参与"); + } + + /// 多起点的输出是混在一起的，只有全路径（`%p`）能分桶还原成树。 + #[test] + fn a_single_find_output_splits_back_into_per_directory_buckets() { + let mut output = Vec::new(); + for (kind, path) in [ + (b'd', "/home/kud/src"), + (b'f', "/home/kud/a.txt"), + (b'f', "/home/kud/src/main.rs"), + (b'd', "/home/kud/.git"), + (b'd', "/home"), + ] { + output.push(kind); + output.push(0); + output.extend_from_slice(path.as_bytes()); + output.push(0); + } + let by_dir = bucket_wsl_find_output(&output); + assert_eq!( + by_dir["/home/kud"], + vec![ + (true, "src".to_owned(), "/home/kud/src".to_owned()), + (false, "a.txt".to_owned(), "/home/kud/a.txt".to_owned()), + ], + "同层目录在前，`.git` 不进树：{by_dir:?}" + ); + assert_eq!(by_dir["/home/kud/src"].len(), 1, "子层单独成桶：{by_dir:?}"); + assert_eq!(by_dir["/"].len(), 1, "根下的条目父是 `/` 而不是空串：{by_dir:?}"); } /// The per-directory cap must be applied *after* ordering. Capping the diff --git a/nebula_app/src/display/ssh_connect.rs b/nebula_app/src/display/ssh_connect.rs index 75a3f17..bbe3417 100644 --- a/nebula_app/src/display/ssh_connect.rs +++ b/nebula_app/src/display/ssh_connect.rs @@ -58,6 +58,8 @@ pub(crate) enum SshConnectHit { Logs, /// 连接中：放弃这次连接。 Cancel, + /// 失败后：在当前 pane 原位重建同一目标的 SSH 会话。 + Retry, /// 失败后：关掉这个 pane。 Close, } @@ -250,17 +252,17 @@ pub(crate) struct Layout { pub(crate) pad: f32, } -/// 底部按钮的文案与语义，随状态切换：连接中只能放弃，失败后只剩收尾。 -/// -/// 这里**没有**「重试」——它要在同一个 tab 位上原子地重连，而 `Close` + -/// `NewSsh` 两个事件按序执行会先把最后一个 tab 连窗口一起关掉。宁可少一个 -/// 按钮，也不放一个按下去会出事的。 +/// 底部按钮的文案与语义，随状态切换：连接中只能放弃，失败后可在原 pane +/// 重试或关闭。返回顺序就是视觉上的从左到右顺序。 pub(crate) fn button_specs( state: &SshConnectState, language: UiLanguage, ) -> Vec<(String, SshConnectHit, bool)> { if state.failed() { - vec![(language.pick("关闭", "Close").to_owned(), SshConnectHit::Close, true)] + vec![ + (language.pick("重试", "Retry").to_owned(), SshConnectHit::Retry, false), + (language.pick("关闭", "Close").to_owned(), SshConnectHit::Close, true), + ] } else { vec![(language.pick("取消", "Cancel").to_owned(), SshConnectHit::Cancel, false)] } @@ -1249,28 +1251,33 @@ mod tests { } #[test] - fn failed_card_offers_close_instead_of_cancel() { + fn failed_card_offers_retry_to_the_left_of_close() { let size = probe_size(); let lang = UiLanguage::EnUs; let mut state = SshConnectState::new("root@h".into()); state.set_stage(SshStage::Failed("boom".into())); let l = layout(&state, &size, VIEW, 1.0, lang, Density::Standard); - let (rect, hit, primary) = l.buttons[0]; - assert_eq!(hit, SshConnectHit::Close); - assert!(primary, "唯一动作应当是主按钮"); - assert_eq!( - hit_test( - &state, - &size, - VIEW, - 1.0, - lang, - Density::Standard, - rect.0 + rect.2 * 0.5, - rect.1 + rect.3 * 0.5 - ), - SshConnectHit::Close - ); + assert_eq!(l.buttons.len(), 2, "失败态应同时提供重试与关闭"); + let retry = l.buttons.iter().find(|(_, hit, _)| *hit == SshConnectHit::Retry).unwrap(); + let close = l.buttons.iter().find(|(_, hit, _)| *hit == SshConnectHit::Close).unwrap(); + assert!(retry.0.0 < close.0.0, "重试必须位于关闭左侧"); + assert!(!retry.2, "重试使用次按钮，避免与关闭争夺主操作层级"); + assert!(close.2, "关闭保持失败态主按钮"); + for (rect, expected) in [(retry.0, SshConnectHit::Retry), (close.0, SshConnectHit::Close)] { + assert_eq!( + hit_test( + &state, + &size, + VIEW, + 1.0, + lang, + Density::Standard, + rect.0 + rect.2 * 0.5, + rect.1 + rect.3 * 0.5 + ), + expected + ); + } } #[test] diff --git a/nebula_app/src/display/state.rs b/nebula_app/src/display/state.rs index 156eb8e..ed65d36 100644 --- a/nebula_app/src/display/state.rs +++ b/nebula_app/src/display/state.rs @@ -209,14 +209,20 @@ pub(crate) struct RuntimeSubmitBarrier { pub struct NebulaPaneState { pub cwd: String, pub branch: String, + /// 这个 pane 的补齐面对哪台机器的文件系统与命令集。启动时由 shell 的 + /// program/args 定（`wsl.exe -d <发行版>` 认得出来），SSH 会话在连上后 + /// 改写。`cwd` 只说"在哪个目录"，这个说"在哪台机器"——两者都对了补齐才 + /// 补得对，见 [`crate::display::suggest_engine::SuggestEnv`]。 + pub suggest_env: crate::display::suggest_engine::SuggestEnv, pub suggestion: String, pub(super) suggestion_key: String, - /// Popup-style completion candidates for the current line (empty = no - /// popup). Mutually exclusive with `suggestion`: which one fills depends - /// on the configured [`CompletionStyle`]. + /// Popup-style completion candidates for the current line. A non-empty list + /// stays visible so users can discover completion without an extra action. + /// Mutually exclusive with `suggestion`: which one fills depends on the + /// configured [`CompletionStyle`]. pub completion_items: Vec, - /// Index of the highlighted popup row. - pub completion_selected: usize, + /// 用户尚未主动导航时不高亮任何候选；这保证 Enter 仍提交原始输入。 + pub completion_selected: Option, /// 用户已接受或主动关闭弹窗的整行。只要屏幕行未变化，即使命令目录的 /// 异步代次更新也不重新弹出；下一次真实输入会自然让行值失配并清除此项。 pub(crate) completion_suppressed_line: Option, @@ -286,7 +292,7 @@ impl NebulaPaneState { self.suggestion.clear(); self.suggestion_key.clear(); self.completion_items.clear(); - self.completion_selected = 0; + self.completion_selected = None; } pub(crate) fn terminal_math_source_point( diff --git a/nebula_app/src/display/suggest_engine.rs b/nebula_app/src/display/suggest_engine.rs index 03b56a0..81d39f6 100644 --- a/nebula_app/src/display/suggest_engine.rs +++ b/nebula_app/src/display/suggest_engine.rs @@ -23,6 +23,193 @@ pub(crate) struct SuggestSources<'a> { pub style: CompletionStyle, } +/// WSL / SSH pane 在命令位置能补的东西。 +/// +/// 本进程的 PATH 描述的是 Windows，里面一个 `notepad.exe` 在来宾或远端都不存在， +/// 拿它去补 tab 只会给出跑不起来的命令。真实的远端 PATH 要一次往返才问得到 +/// （见 [`SuggestEnv`] 的文档），在那之前这张表是诚实的兜底：全是 POSIX shell +/// 内置与几乎每台 Linux 都装了的工具。 +/// +/// 排序无所谓——[`nebula_command_hints`] 会自己按长度和字典序收敛。 +const POSIX_COMMANDS: &[&str] = &[ + // shell 内置 + "alias", + "bg", + "cd", + "declare", + "echo", + "eval", + "exec", + "exit", + "export", + "false", + "fg", + "history", + "jobs", + "kill", + "local", + "printf", + "pwd", + "read", + "return", + "set", + "shift", + "source", + "test", + "trap", + "true", + "type", + "umask", + "unalias", + "unset", + "wait", + "which", + // coreutils 与文件操作 + "basename", + "cat", + "chgrp", + "chmod", + "chown", + "cp", + "cut", + "df", + "dirname", + "du", + "find", + "grep", + "head", + "less", + "ln", + "ls", + "mkdir", + "more", + "mv", + "readlink", + "realpath", + "rm", + "rmdir", + "sed", + "sort", + "stat", + "tail", + "tee", + "touch", + "tr", + "uniq", + "wc", + "xargs", + // 进程 / 系统 + "chsh", + "env", + "free", + "htop", + "id", + "journalctl", + "man", + "mount", + "nohup", + "ps", + "service", + "su", + "sudo", + "systemctl", + "top", + "uname", + "uptime", + "whoami", + // 网络与传输 + "curl", + "dig", + "ip", + "netstat", + "ping", + "rsync", + "scp", + "ss", + "ssh", + "wget", + // 归档 + "gunzip", + "gzip", + "tar", + "unzip", + "xz", + "zip", + // 包管理 + "apt", + "apt-get", + "dnf", + "dpkg", + "pacman", + "snap", + "yum", + // 开发 + "awk", + "cargo", + "cmake", + "docker", + "g++", + "gcc", + "gdb", + "git", + "go", + "make", + "nano", + "node", + "npm", + "pip", + "pip3", + "pnpm", + "python", + "python3", + "rustc", + "rustup", + "vim", + "yarn", +]; + +/// [`POSIX_COMMANDS`] 的 `Vec` 视图。 +/// +/// `nebula_command_hint`/`_hints` 吃的是 `&[String]`（本机那份来自 PATH 探针）。 +/// 转换只做一次；等远端 PATH 真的探到了，替换的就是这个容器本身。 +fn posix_commands() -> &'static [String] { + static CACHE: std::sync::OnceLock> = std::sync::OnceLock::new(); + CACHE.get_or_init(|| POSIX_COMMANDS.iter().map(|name| (*name).to_owned()).collect()) +} + +/// 补齐面对的是**哪台机器**的文件系统与命令集。 +/// +/// 这是补齐正确性的根，不只是个功能开关。同一条 `ls /te`：本地 tab 该查 +/// `D:\te*`，WSL tab 该查来宾的 `/te*`，SSH tab 该问远端。走错机器不是"补不 +/// 出来"这么轻——它会**补出另一台机器上的路径**，而那条路径在当前 shell 里 +/// 根本不存在。 +/// +/// 这不是假想的失败模式。宿主把 `/temp_build` 解析成"当前盘符下的 +/// `\temp_build`"，而这台机器的 D 盘恰好就有 `D:\temp_build`，于是 +/// [`crate::directory_history::DirectoryHistory::hint`] 的 `is_dir` 把关会当成 +/// 命中，把宿主的目录补进 WSL 的命令行里。 +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub enum SuggestEnv { + /// 普通本地 tab：`std::fs` 与本进程 PATH 指向同一台机器。 + #[default] + Local, + /// WSL tab：cwd 是来宾的 Linux 绝对路径。宿主的 `std::fs` 读不到它——本机 + /// 的 9P 重定向不可用，`\\wsl.localhost\` 三条路实测全部失败，见 + /// [`crate::shell_detect::wsl_unc_cwd`] 的记录。要列来宾目录只能 + /// `wsl.exe -d <发行版> -- find`，那是子进程，冷启动可达数秒，绝不能挂在 + /// 按键路径上。 + Wsl { distro: String }, + /// SSH tab：文件系统只能经 SFTP 往返，命令集是远端的。 + Ssh, +} + +impl SuggestEnv { + /// 本进程的 `std::fs` 与 PATH 是否描述这个 pane 所在的机器。 + pub fn is_this_machine(&self) -> bool { + matches!(self, Self::Local) + } +} + /// Refresh the inline ghost remainder or the popup candidate list for the /// current prompt line. Cached on `cwd + line`; dismissal keeps the key so a /// closed popup stays closed until the line itself changes. @@ -49,7 +236,7 @@ pub(crate) fn suggest_update( state.suggestion_key = key; state.suggestion.clear(); state.completion_items.clear(); - state.completion_selected = 0; + state.completion_selected = None; return; } state.completion_suppressed_line = None; @@ -62,7 +249,7 @@ pub(crate) fn suggest_update( state.suggestion_key = key; state.suggestion.clear(); state.completion_items.clear(); - state.completion_selected = 0; + state.completion_selected = None; nebula_debug_log(format!( "suggest_begin cwd={:?} line={:?} line_buf={:?}", @@ -88,22 +275,34 @@ pub(crate) fn suggest_update( // slash style/case, so `cd D:\te` can pick a previous // `cd D:/temp_build/wuwei` before generic filesystem completion falls // back to alphabetic candidates like `D:\Telegram\`. - if let Some(rem) = sources.directories.hint(&line, &state.cwd) { - state.suggestion = clamp_ghost(&rem); - nebula_debug_log(format!("suggest_result kind=dir rem={:?}", state.suggestion)); - return; + // + // 只在本机：frecency 池里混着三台机器访问过的路径，条目自身没有环境标签， + // 而 `hint` 是拿**宿主的** `is_dir` 把关的——在 WSL tab 里 `/temp_build` + // 会被解析成 `D:\temp_build` 并当成命中（见 [`SuggestEnv`]）。 + if state.suggest_env.is_this_machine() { + if let Some(rem) = sources.directories.hint(&line, &state.cwd) { + state.suggestion = clamp_ghost(&rem); + nebula_debug_log(format!("suggest_result kind=dir rem={:?}", state.suggestion)); + return; + } } // First token with no path separators is a command position. Reuse the // process PATH inherited by the shell so typing `ca` can ghost `rgo` // even before that command has appeared in Nebula/Nushell history. + // WSL/SSH 的 shell 没继承这个 PATH，那边走 [`POSIX_COMMANDS`]。 if nebula_is_command_position(&line) { - if let Ok(commands) = sources.commands.lock() { - if let Some(rem) = nebula_command_hint(commands.as_slice(), &line) { - state.suggestion = clamp_ghost(rem); - nebula_debug_log(format!("suggest_result kind=command rem={:?}", state.suggestion)); - return; - } + let hinted = if state.suggest_env.is_this_machine() { + sources.commands.lock().ok().and_then(|commands| { + nebula_command_hint(commands.as_slice(), &line).map(str::to_owned) + }) + } else { + nebula_command_hint(posix_commands(), &line).map(str::to_owned) + }; + if let Some(rem) = hinted { + state.suggestion = clamp_ghost(&rem); + nebula_debug_log(format!("suggest_result kind=command rem={:?}", state.suggestion)); + return; } } @@ -114,8 +313,18 @@ pub(crate) fn suggest_update( if token.is_empty() { return; } - let absolute = - token.starts_with(['/', '\\', '~']) || token.as_bytes().get(1) == Some(&b':'); // Windows drive, e.g. `D:` + // 非本机的路径补齐要走各自的通道（来宾 `find` / SFTP），都是带往返的异步 + // 来源，接线见 `suggest_paths`。这里**必须直接返回**而不是"顺手用 + // `std::fs` 试试"：宿主会把 `/te` 解析成当前盘的 `\te`，补出来的是 + // `D:\temp_build` 这种当前 shell 里根本不存在的路径——比补不出来更糟。 + if !state.suggest_env.is_this_machine() { + nebula_debug_log(format!( + "suggest_result kind=none reason=foreign_fs env={:?} token={:?}", + state.suggest_env, token + )); + return; + } + let absolute = token.starts_with(['/', '\\', '~']) || token.as_bytes().get(1) == Some(&b':'); // Windows drive, e.g. `D:` if !absolute && state.cwd.is_empty() { return; } @@ -213,47 +422,68 @@ fn suggest_collect(sources: &SuggestSources<'_>, state: &mut NebulaPaneState, li // Whole-line history matches, newest first. for (full, rem) in sources.history.hints(line, 3) { - push(&mut items, NebulaCompletionItem { - label: elide_left(full, LABEL_MAX), - insert: rem.to_owned(), - kind: NebulaCompletionKind::History, - }); + push( + &mut items, + NebulaCompletionItem { + label: elide_left(full, LABEL_MAX), + insert: rem.to_owned(), + kind: NebulaCompletionKind::History, + }, + ); } let token = line.rsplit([' ', '\t']).next().unwrap_or(""); - // Frecency-ranked directory completion for cd-like commands. - if let Some(rem) = sources.directories.hint(line, &state.cwd) { - push(&mut items, NebulaCompletionItem { - label: elide_left(&format!("{token}{rem}"), LABEL_MAX), - insert: rem, - kind: NebulaCompletionKind::Dir, - }); + // Frecency-ranked directory completion for cd-like commands. 只在本机， + // 理由同 ghost 分支：frecency 池没有环境标签，而 `hint` 拿宿主的 `is_dir` + // 把关，会把 `D:\temp_build` 当成 WSL 的 `/temp_build`。 + if state.suggest_env.is_this_machine() { + if let Some(rem) = sources.directories.hint(line, &state.cwd) { + push( + &mut items, + NebulaCompletionItem { + label: elide_left(&format!("{token}{rem}"), LABEL_MAX), + insert: rem, + kind: NebulaCompletionKind::Dir, + }, + ); + } } - // PATH executables while the first token is being typed. + // PATH executables while the first token is being typed. 本机用 shell 继承 + // 的进程 PATH；WSL/SSH 的 shell 没继承它，走 [`POSIX_COMMANDS`]。 if nebula_is_command_position(line) { - if let Ok(commands) = sources.commands.lock() { - for command in nebula_command_hints(commands.as_slice(), line, POPUP_LIMIT) { - // 精确命令也必须成为可接受项；补一个空格既给用户明确反馈， - // 又让 Enter 只完成选择而不立刻执行命令。 - let insert = if command.len() == line.len() { - " ".to_owned() - } else { - command[line.len()..].to_owned() - }; - push(&mut items, NebulaCompletionItem { + let local = state.suggest_env.is_this_machine(); + let guard = local.then(|| sources.commands.lock().ok()).flatten(); + let commands: &[String] = match guard.as_deref() { + Some(commands) => commands, + None if local => &[], + None => posix_commands(), + }; + for command in nebula_command_hints(commands, line, POPUP_LIMIT) { + // 精确命令也必须成为可接受项；补一个空格既给用户明确反馈， + // 又让 Enter 只完成选择而不立刻执行命令。 + let insert = if command.len() == line.len() { + " ".to_owned() + } else { + command[line.len()..].to_owned() + }; + push( + &mut items, + NebulaCompletionItem { label: elide_left(command, LABEL_MAX), insert, kind: NebulaCompletionKind::Command, - }); - } + }, + ); } } // Filesystem candidates for the final token (same gating as the ghost // path: absolute tokens work without a cwd, relative ones need one). - if !token.is_empty() { + // 非本机一律跳过：这个进程的 `std::fs` 描述的是另一台机器，补出来的路径 + // 在当前 shell 里不存在（见 [`SuggestEnv`]）。 + if !token.is_empty() && state.suggest_env.is_this_machine() { let absolute = token.starts_with(['/', '\\', '~']) || token.as_bytes().get(1) == Some(&b':'); if absolute || !state.cwd.is_empty() { @@ -290,16 +520,138 @@ fn suggest_collect(sources: &SuggestSources<'_>, state: &mut NebulaPaneState, li } else { NebulaCompletionKind::File }; - push(&mut items, NebulaCompletionItem { - label: elide_left(&format!("{token}{insert}"), LABEL_MAX), - insert: insert.to_owned(), - kind, - }); + push( + &mut items, + NebulaCompletionItem { + label: elide_left(&format!("{token}{insert}"), LABEL_MAX), + insert: insert.to_owned(), + kind, + }, + ); } } } nebula_debug_log(format!("suggest_result kind=popup line={:?} items={}", line, items.len())); state.completion_items = items; - state.completion_selected = 0; + state.completion_selected = None; +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::directory_history::DirectoryHistory; + use crate::nebula_history::NebulaHistory; + + struct Fixture { + history: NebulaHistory, + directories: DirectoryHistory, + commands: std::sync::Arc>>, + } + + impl Fixture { + /// 历史与 frecency 都留空，断言才只反映被测的那条分支。`commands` 装的 + /// 是**这台机器**的 PATH 探针结果，所以放一个只有 Windows 才有的名字。 + fn new() -> Self { + Self { + history: NebulaHistory::default(), + directories: DirectoryHistory::empty(), + commands: std::sync::Arc::new(std::sync::Mutex::new(vec![ + "notepad.exe".to_owned(), + "grepwin.exe".to_owned(), + ])), + } + } + + fn sources(&self, style: CompletionStyle) -> SuggestSources<'_> { + SuggestSources { + history: &self.history, + directories: &self.directories, + commands: &self.commands, + enabled: true, + style, + } + } + + /// 在给定环境下算一次 ghost，返回补出的余量。 + fn ghost(&self, env: SuggestEnv, cwd: &str, line: &str) -> String { + let mut state = + NebulaPaneState { cwd: cwd.to_owned(), suggest_env: env, ..Default::default() }; + suggest_update( + &self.sources(CompletionStyle::Inline), + &mut state, + Some(line.to_owned()), + ); + state.suggestion + } + + /// 同上但走弹窗，返回候选的插入余量。 + fn popup(&self, env: SuggestEnv, cwd: &str, line: &str) -> Vec { + let mut state = + NebulaPaneState { cwd: cwd.to_owned(), suggest_env: env, ..Default::default() }; + suggest_update( + &self.sources(CompletionStyle::Popup), + &mut state, + Some(line.to_owned()), + ); + state.completion_items.into_iter().map(|item| item.insert).collect() + } + } + + /// 走错机器不是"补不出来"这么轻——它会把**宿主**的目录补进 WSL 的命令行。 + /// + /// 同一条命令、同一个 cwd，只有环境不同：本机该补出来，WSL 必须一无所获。 + /// 断言用的是同一份真实存在的宿主目录，所以"WSL 补不出"只可能来自环境 + /// 分流，不可能是路径碰巧不存在。 + #[test] + fn a_foreign_pane_never_completes_a_path_off_this_machine() { + let temp = tempfile::tempdir().unwrap(); + std::fs::create_dir(temp.path().join("host-only-dir")).unwrap(); + let cwd = temp.path().to_string_lossy().into_owned(); + let fixture = Fixture::new(); + + assert_eq!( + fixture.ghost(SuggestEnv::Local, &cwd, "ls host-only-"), + "dir\\", + "本机 tab 的 std::fs 就是这个 pane 的文件系统（补到目录带尾分隔符）" + ); + for env in [SuggestEnv::Wsl { distro: "Debian".to_owned() }, SuggestEnv::Ssh] { + assert_eq!( + fixture.ghost(env.clone(), &cwd, "ls host-only-"), + "", + "{env:?} 的文件系统这个进程碰不到，补出宿主路径比补不出来更糟" + ); + assert!( + fixture.popup(env.clone(), &cwd, "ls host-only-").is_empty(), + "弹窗与 ghost 必须同一套分流：{env:?}" + ); + } + } + + /// 进程 PATH 描述的是 Windows。把它当成来宾/远端的命令集，补出的 + /// `notepad.exe` 在那边根本不存在。 + #[test] + fn a_foreign_pane_completes_posix_commands_instead_of_this_machines_binaries() { + let fixture = Fixture::new(); + assert_eq!(fixture.ghost(SuggestEnv::Local, "", "notepad"), ".exe"); + + let wsl = SuggestEnv::Wsl { distro: "Debian".to_owned() }; + assert_eq!(fixture.ghost(wsl.clone(), "", "notepad"), "", "来宾没有 notepad.exe"); + assert_eq!(fixture.ghost(wsl.clone(), "", "grep"), "", "精确命令不再往更长的邻居补"); + assert_eq!(fixture.ghost(wsl.clone(), "", "systemc"), "tl"); + assert!(fixture.popup(wsl, "", "gre").contains(&"p".to_owned()), "弹窗同样走 POSIX 表"); + } + + /// 这张表是"远端 PATH 还没探到"时的兜底，所以里面只能是那边真有的东西。 + #[test] + fn the_posix_table_names_nothing_windows_only() { + assert!( + POSIX_COMMANDS.iter().all(|name| !name.ends_with(".exe")), + "Windows 可执行后缀不该出现在 POSIX 表里" + ); + for expected in ["ls", "grep", "sudo", "systemctl", "apt", "cargo"] { + assert!(POSIX_COMMANDS.contains(&expected), "缺少常用命令 {expected}"); + } + assert_eq!(posix_commands().len(), POSIX_COMMANDS.len(), "两个视图必须同源"); + } } diff --git a/nebula_app/src/display/terminal_math.rs b/nebula_app/src/display/terminal_math.rs index 8419104..1524084 100644 --- a/nebula_app/src/display/terminal_math.rs +++ b/nebula_app/src/display/terminal_math.rs @@ -1404,24 +1404,180 @@ fn find_bare_paren_formula( /// commands are excluded wholesale by the caller-side length check baked in /// here (every entry is ≥2 chars). const KNOWN_TEX_COMMANDS: &[&str] = &[ - "alpha", "approx", "arccos", "arcsin", "arctan", "bar", "begin", "beta", "big", "bigg", - "binom", "boldsymbol", "bullet", "cap", "cdot", "cdots", "chi", "circ", "cos", "cosh", "cot", - "csc", "cup", "ddot", "ddots", "delta", "det", "dfrac", "div", "dot", "dots", "emptyset", - "end", "epsilon", "equiv", "eta", "exists", "exp", "forall", "frac", "gamma", "gcd", "ge", - "geq", "gg", "hat", "iff", "iiint", "iint", "implies", "in", "inf", "infty", "int", "iota", - "kappa", "lambda", "land", "langle", "lceil", "ldots", "le", "left", "leftarrow", - "leftrightarrow", "leq", "lfloor", "lg", "lim", "liminf", "limsup", "ll", "ln", "log", "lor", - "mapsto", "mathbb", "mathbf", "mathcal", "mathfrak", "mathit", "mathrm", "mathsf", "max", - "min", "mp", "mu", "nabla", "ne", "neg", "neq", "notin", "nu", "odot", "oint", "omega", - "ominus", "operatorname", "oplus", "otimes", "overbrace", "overline", "partial", "phi", "pi", - "pm", "prod", "propto", "psi", "qquad", "quad", "rangle", "rceil", "rfloor", "rho", "right", - "rightarrow", "sec", "sigma", "sim", "simeq", "sin", "sinh", "sqrt", "subset", "subseteq", - "sum", "sup", "supset", "supseteq", "tan", "tanh", "tau", "text", "textbf", "textit", - "textrm", "theta", "tilde", "times", "to", "underbrace", "underline", "upsilon", "varepsilon", - "varnothing", "varphi", "varpi", "varrho", "varsigma", "vartheta", "vec", "vert", "widehat", - "widetilde", "xi", "zeta", "Big", "Bigg", "Delta", "Gamma", "Lambda", "Leftarrow", - "Leftrightarrow", "Omega", "Phi", "Pi", "Psi", "Rightarrow", "Sigma", "Theta", "Upsilon", - "Vert", "Xi", + "alpha", + "approx", + "arccos", + "arcsin", + "arctan", + "bar", + "begin", + "beta", + "big", + "bigg", + "binom", + "boldsymbol", + "bullet", + "cap", + "cdot", + "cdots", + "chi", + "circ", + "cos", + "cosh", + "cot", + "csc", + "cup", + "ddot", + "ddots", + "delta", + "det", + "dfrac", + "div", + "dot", + "dots", + "emptyset", + "end", + "epsilon", + "equiv", + "eta", + "exists", + "exp", + "forall", + "frac", + "gamma", + "gcd", + "ge", + "geq", + "gg", + "hat", + "iff", + "iiint", + "iint", + "implies", + "in", + "inf", + "infty", + "int", + "iota", + "kappa", + "lambda", + "land", + "langle", + "lceil", + "ldots", + "le", + "left", + "leftarrow", + "leftrightarrow", + "leq", + "lfloor", + "lg", + "lim", + "liminf", + "limsup", + "ll", + "ln", + "log", + "lor", + "mapsto", + "mathbb", + "mathbf", + "mathcal", + "mathfrak", + "mathit", + "mathrm", + "mathsf", + "max", + "min", + "mp", + "mu", + "nabla", + "ne", + "neg", + "neq", + "notin", + "nu", + "odot", + "oint", + "omega", + "ominus", + "operatorname", + "oplus", + "otimes", + "overbrace", + "overline", + "partial", + "phi", + "pi", + "pm", + "prod", + "propto", + "psi", + "qquad", + "quad", + "rangle", + "rceil", + "rfloor", + "rho", + "right", + "rightarrow", + "sec", + "sigma", + "sim", + "simeq", + "sin", + "sinh", + "sqrt", + "subset", + "subseteq", + "sum", + "sup", + "supset", + "supseteq", + "tan", + "tanh", + "tau", + "text", + "textbf", + "textit", + "textrm", + "theta", + "tilde", + "times", + "to", + "underbrace", + "underline", + "upsilon", + "varepsilon", + "varnothing", + "varphi", + "varpi", + "varrho", + "varsigma", + "vartheta", + "vec", + "vert", + "widehat", + "widetilde", + "xi", + "zeta", + "Big", + "Bigg", + "Delta", + "Gamma", + "Lambda", + "Leftarrow", + "Leftrightarrow", + "Omega", + "Phi", + "Pi", + "Psi", + "Rightarrow", + "Sigma", + "Theta", + "Upsilon", + "Vert", + "Xi", ]; /// Whether `source` contains at least one whitelisted TeX command. Bare @@ -2115,8 +2271,7 @@ pub(crate) fn draw_overlays( let Some(prepared) = prepared else { continue; }; - let Some(plan) = plan_overlay_draw(state, overlay, prepared, size, pixels_per_point) - else { + let Some(plan) = plan_overlay_draw(state, overlay, prepared, size, pixels_per_point) else { // Repaint the skipped source cells rather than leave a hole. renderer.draw_cells(size, glyph_cache, overlay.fallback.iter().cloned()); continue; diff --git a/nebula_app/src/display/ui/icons.rs b/nebula_app/src/display/ui/icons.rs index 95bb1ab..b5be476 100644 --- a/nebula_app/src/display/ui/icons.rs +++ b/nebula_app/src/display/ui/icons.rs @@ -371,13 +371,7 @@ pub(crate) fn push_row_action_icon( let tip = (cx - 4.4 * scale, cy + 4.4 * scale); let tail = (cx + 4.4 * scale, cy - 4.4 * scale); push_segment(quads, tip, tail, stroke, ink); - push_segment( - quads, - tip, - (tip.0 + 1.8 * scale, tip.1 - 1.8 * scale), - stroke * 2.1, - ink, - ); + push_segment(quads, tip, (tip.0 + 1.8 * scale, tip.1 - 1.8 * scale), stroke * 2.1, ink); }, RowActionIcon::Delete => { // 盖沿横线略宽于桶身，桶身用挖空矩形读作"容器"而不是方框； diff --git a/nebula_app/src/event.rs b/nebula_app/src/event.rs index be8932d..56ee7fc 100644 --- a/nebula_app/src/event.rs +++ b/nebula_app/src/event.rs @@ -552,16 +552,16 @@ impl Processor { "pane_id": pane_id })) }, - RuntimeCommand::Split { window_id, direction } => { - let id = self.runtime_target_window(*window_id, None)?; - let pane_id = self + RuntimeCommand::Split { window_id, pane_id, direction } => { + let id = self.runtime_target_window(*window_id, *pane_id)?; + let (source_pane_id, pane_id) = self .windows .get_mut(&id) .expect("resolved runtime window exists") - .runtime_split(*direction)?; + .runtime_split(*pane_id, *direction)?; self.runtime_result(serde_json::json!({ "window_id": u64::from(id), - "pane_id": pane_id + "source_pane_id": source_pane_id, "pane_id": pane_id })) }, RuntimeCommand::Prompt { window_id, pane_id, text, submit } => { @@ -1803,19 +1803,21 @@ impl<'a, N: Notify + 'a, T: EventListener> input::ActionContext for ActionCon if len == 0 { return; } - let current = self.nebula_state.completion_selected as isize; - self.nebula_state.completion_selected = (current + delta).rem_euclid(len as isize) as usize; + self.nebula_state.completion_selected = Some(match self.nebula_state.completion_selected { + Some(current) => (current as isize + delta).rem_euclid(len as isize) as usize, + None => 0, + }); *self.dirty = true; } fn nebula_completion_popup_take(&mut self) -> Option { let state = &mut self.nebula_state; - let insert = - state.completion_items.get(state.completion_selected).map(|item| item.insert.clone()); + let index = state.completion_selected?; + let insert = state.completion_items.get(index)?.insert.clone(); state.completion_items.clear(); - state.completion_selected = 0; + state.completion_selected = None; *self.dirty = true; - insert + Some(insert) } fn nebula_completion_popup_dismiss(&mut self) -> bool { @@ -1827,7 +1829,7 @@ impl<'a, N: Notify + 'a, T: EventListener> input::ActionContext for ActionCon // `nebula_update_suggestion` then keeps the list closed until the // line itself changes. state.completion_items.clear(); - state.completion_selected = 0; + state.completion_selected = None; *self.dirty = true; true } diff --git a/nebula_app/src/event/agent_runtime.rs b/nebula_app/src/event/agent_runtime.rs index 8f85453..f603237 100644 --- a/nebula_app/src/event/agent_runtime.rs +++ b/nebula_app/src/event/agent_runtime.rs @@ -37,6 +37,7 @@ impl Processor { match command { RuntimeCommand::AgentStart { window_id, + pane_id, name, kind, cwd, @@ -44,13 +45,17 @@ impl Processor { command, worktree, } => { - let id = self.runtime_target_window(*window_id, None)?; + let id = self.runtime_target_window(*window_id, *pane_id)?; self.runtime_hub.ensure_agent_name_available(name)?; - let pane_id = self - .windows - .get_mut(&id) - .expect("resolved runtime window exists") - .runtime_new_tab(cwd.clone())?; + let created_tab = pane_id.is_none(); + let pane_id = match pane_id { + Some(pane_id) => *pane_id, + None => self + .windows + .get_mut(&id) + .expect("resolved runtime window exists") + .runtime_new_tab(cwd.clone())?, + }; let agent = match self.runtime_hub.register_agent( name.clone(), *kind, @@ -61,30 +66,37 @@ impl Processor { ) { Ok(agent) => agent, Err(error) => { + if created_tab { + self.windows + .get_mut(&id) + .expect("resolved runtime window exists") + .runtime_discard_agent_tab(pane_id); + } + return Err(error); + }, + }; + let launch = if created_tab { + self.windows + .get_mut(&id) + .expect("resolved runtime window exists") + .runtime_set_tab_name(pane_id, name.clone()) + } else { + Ok(()) + } + .and_then(|_| { + self.windows + .get_mut(&id) + .expect("resolved runtime window exists") + .runtime_prompt(pane_id, command.clone(), true) + }); + if let Err(error) = launch { + self.runtime_hub.close_agent(&agent.agent_id, "launch_failed"); + if created_tab { self.windows .get_mut(&id) .expect("resolved runtime window exists") .runtime_discard_agent_tab(pane_id); - return Err(error); - }, - }; - let launch = self - .windows - .get_mut(&id) - .expect("resolved runtime window exists") - .runtime_set_tab_name(pane_id, name.clone()) - .and_then(|_| { - self.windows - .get_mut(&id) - .expect("resolved runtime window exists") - .runtime_prompt(pane_id, command.clone(), true) - }); - if let Err(error) = launch { - self.runtime_hub.close_agent(&agent.agent_id, "launch_failed"); - self.windows - .get_mut(&id) - .expect("resolved runtime window exists") - .runtime_discard_agent_tab(pane_id); + } return Err(error); } self.runtime_result(serde_json::json!({ diff --git a/nebula_app/src/event/types.rs b/nebula_app/src/event/types.rs index 3f009d1..fec085a 100644 --- a/nebula_app/src/event/types.rs +++ b/nebula_app/src/event/types.rs @@ -159,6 +159,8 @@ pub enum TabRequest { shell: nebula_terminal::tty::Shell, }, NewSsh(String), + /// 在当前布局叶位置重建失败的 SSH pane，不经过关闭 tab 的路径。 + RetrySsh(String), OpenDoc(PathBuf), OpenSettings, Close, diff --git a/nebula_app/src/gpui_shell/doc_tabs.rs b/nebula_app/src/gpui_shell/doc_tabs.rs index 37e0dcd..4bbf85a 100644 --- a/nebula_app/src/gpui_shell/doc_tabs.rs +++ b/nebula_app/src/gpui_shell/doc_tabs.rs @@ -324,16 +324,13 @@ impl Render for DocTabView { /// 仍会播 GIF，markdown 多图共用 element id 时越界 panic。 fn rewrite_doc_images(text: &str, base: Option<&Path>) -> String { use std::sync::LazyLock; - static MARKDOWN_IMG: LazyLock = LazyLock::new(|| { - regex::Regex::new(r#"(!\[[^\]]*\]\()([^)\s]+)"#).unwrap() - }); + static MARKDOWN_IMG: LazyLock = + LazyLock::new(|| regex::Regex::new(r#"(!\[[^\]]*\]\()([^)\s]+)"#).unwrap()); // `regex` crate 不支持反向引用 `\2`，双引号/单引号拆开写。 - static HTML_IMG_DQ: LazyLock = LazyLock::new(|| { - regex::Regex::new(r#"(?i)(]*?\bsrc\s*=\s*")([^"]+)""#).unwrap() - }); - static HTML_IMG_SQ: LazyLock = LazyLock::new(|| { - regex::Regex::new(r#"(?i)(]*?\bsrc\s*=\s*')([^']+)'"#).unwrap() - }); + static HTML_IMG_DQ: LazyLock = + LazyLock::new(|| regex::Regex::new(r#"(?i)(]*?\bsrc\s*=\s*")([^"]+)""#).unwrap()); + static HTML_IMG_SQ: LazyLock = + LazyLock::new(|| regex::Regex::new(r#"(?i)(]*?\bsrc\s*=\s*')([^']+)'"#).unwrap()); let rewritten = MARKDOWN_IMG.replace_all(text, |caps: ®ex::Captures<'_>| { format!("{}{}", &caps[1], flatten_local_image_url(&caps[2], base)) }); diff --git a/nebula_app/src/gpui_shell/http.rs b/nebula_app/src/gpui_shell/http.rs index 9496632..c4c36ee 100644 --- a/nebula_app/src/gpui_shell/http.rs +++ b/nebula_app/src/gpui_shell/http.rs @@ -48,15 +48,12 @@ fn fetch_blocking( parts: gpui::http_client::http::request::Parts, request_bytes: Vec, ) -> HttpResult { - let mut builder = ureq::http::Request::builder() - .method(parts.method.as_str()) - .uri(parts.uri.to_string()); + let mut builder = + ureq::http::Request::builder().method(parts.method.as_str()).uri(parts.uri.to_string()); for (name, value) in parts.headers.iter() { builder = builder.header(name.as_str(), value.as_bytes()); } - let request = builder - .body(request_bytes) - .map_err(|error| anyhow!("构造请求失败: {error}"))?; + let request = builder.body(request_bytes).map_err(|error| anyhow!("构造请求失败: {error}"))?; let mut response = agent.run(request).map_err(|error| anyhow!("{error}"))?; let status = response.status().as_u16(); let mut header_pairs: Vec<(String, Vec)> = Vec::new(); @@ -168,9 +165,7 @@ impl HttpClient for UreqClient { for (name, value) in header_pairs { builder = builder.header(name, value); } - builder - .body(AsyncBody::from(bytes)) - .map_err(|error| anyhow!("构造响应失败: {error}")) + builder.body(AsyncBody::from(bytes)).map_err(|error| anyhow!("构造响应失败: {error}")) }) } } diff --git a/nebula_app/src/gpui_shell/mod.rs b/nebula_app/src/gpui_shell/mod.rs index bcaffbd..670f694 100644 --- a/nebula_app/src/gpui_shell/mod.rs +++ b/nebula_app/src/gpui_shell/mod.rs @@ -234,12 +234,29 @@ pub(crate) fn show_native_window(window: &gpui::Window) { window.activate_window(); } +/// 把藏起来的窗口全部显示出来。 +/// +/// 必须 `defer`：本函数会从 `apply_runtime_settings` → +/// `reveal_if_tray_disabled` 被调到，而那条链路正处在某个窗口自己的 update +/// 回调里（设置页事件）。此刻该窗口已被 `App::update_window` 从 slot 里 take +/// 走，对同一 handle 再 update 只会拿到 `Err("window not found")`。 +/// +/// 2026-08-21：这里原先是 `let _ = handle.update(..)`，吞掉那个错误的后果很重 +/// ——「窗口已最小化到托盘 + 在设置页关掉托盘」时，托盘图标按设置消失了，窗口 +/// 却没被显示出来，而 `reveal_session` 已经把 `window_hidden` 置回 false， +/// 守卫 `if self.window_hidden && ..` 从此永假、不再重试：应用变成既无窗口也无 +/// 托盘图标、只能从任务管理器结束的僵尸。与 `wallpaper::apply_window_effects` +/// 同一个根因、同一个修法。 pub(crate) fn reveal_all_windows(cx: &mut App) { - for handle in cx.windows() { - let _ = handle.update(cx, |_, window, _| { - show_native_window(window); - }); - } + cx.defer(|cx| { + for handle in cx.windows() { + if let Err(err) = handle.update(cx, |_, window, _| { + show_native_window(window); + }) { + log::warn!("failed to reveal window: {err}"); + } + } + }); } #[cfg(windows)] diff --git a/nebula_app/src/gpui_shell/settings_pane.rs b/nebula_app/src/gpui_shell/settings_pane.rs index cd54aa8..a21c9f1 100644 --- a/nebula_app/src/gpui_shell/settings_pane.rs +++ b/nebula_app/src/gpui_shell/settings_pane.rs @@ -19,13 +19,14 @@ use gpui::{ App, AppContext as _, Context, Entity, EventEmitter, FocusHandle, Focusable, Hsla, Image, ImageFormat, InteractiveElement as _, IntoElement, KeyDownEvent, ModifiersChangedEvent, MouseButton, MouseMoveEvent, ParentElement as _, Render, RenderImage, Rgba as GpuiRgba, - SharedString, StatefulInteractiveElement as _, Styled as _, Subscription, Window, anchored, - deferred, div, img, px, + SharedString, StatefulInteractiveElement as _, Styled as _, Subscription, Task, Window, + anchored, deferred, div, img, px, }; use gpui_component::input::InputEvent; use gpui_component::select::{SelectEvent, SelectItem}; use nebula_settings::{RuntimeSettings, ThemeName, format_hex_rgb, persist_keys}; use std::sync::Arc; +use std::time::Duration; use crate::gpui_shell::prelude::*; use crate::gpui_shell::widgets::NebulaButton; @@ -440,6 +441,12 @@ pub struct SettingsPane { keymap_capture: Option, keymap_capture_preview: String, keymap_binds: Vec<(String, String)>, + /// 不透明度滑块的落盘 debounce。滑块只有 `Change` 事件（没有"松手"）， + /// 而 [`Self::persist`] 是重操作：写盘 + 三次设置重载 + 每个终端 + /// `apply_settings`（含四次字体构造）+ 主题全量重建 + 壁纸重烘焙。拖拽期间 + /// 每帧走一遍就会卡死，所以拖拽只更新内存视效，落盘挪到停手之后。 + /// 覆盖这个字段即取消上一个待落盘任务（旧 `Task` drop = 取消）。 + slider_persist: Option>, _subscriptions: Vec, } @@ -677,7 +684,7 @@ impl SettingsPane { input }; let opacity_slider = cx.new(|_| { - SliderState::new().min(0.20).max(1.00).step(0.05).default_value(runtime.opacity) + SliderState::new().min(0.00).max(1.00).step(0.05).default_value(runtime.opacity) }); subscriptions.push(cx.subscribe(&opacity_slider, |this, _, event: &SliderEvent, cx| { match event { @@ -825,6 +832,17 @@ impl SettingsPane { crate::display::rgb_to_hsv(crate::display::color::Rgb::new(rgb[0], rgb[1], rgb[2])) }; + // GPUI 会先匹配 KeyBinding action，再派发元素的 capture/bubble KeyDown。 + // 因此录制 PageDown 等已有快捷键必须在应用级 interceptor 提前截住； + // 焦点检查保证后台设置标签或普通设置输入不受影响。 + let keymap_interceptor = cx.listener(|this, event: &gpui::KeystrokeEvent, window, cx| { + if this.keymap_capture.is_some() && this.focus_handle.contains_focused(window, cx) { + cx.stop_propagation(); + this.handle_keymap_capture(&event.keystroke, cx); + } + }); + subscriptions.push(cx.intercept_keystrokes(keymap_interceptor)); + Self { focus_handle: cx.focus_handle(), runtime, @@ -923,6 +941,7 @@ impl SettingsPane { keymap_capture: None, keymap_capture_preview: String::new(), keymap_binds: nebula_settings::keybind_pairs(), + slider_persist: None, _subscriptions: subscriptions, } } @@ -1057,14 +1076,61 @@ impl SettingsPane { self.persist(&[("font_size", format!("{size:.2}"))], cx); } + /// 拖拽期间只做"改 alpha + 重绘"这两件必须的事，落盘与整套热应用 + /// 交给 [`Self::schedule_slider_persist`]。旧壳拖 opacity 就是改内存 + 重绘， + /// 这条快路径是为了对回那个手感。 fn set_opacity(&mut self, opacity: f32, cx: &mut Context) { - let opacity = opacity.clamp(0.2, 1.0); - self.persist(&[("opacity", format!("{opacity:.2}"))], cx); + let opacity = opacity.clamp(0.0, 1.0); + if (self.runtime.opacity - opacity).abs() < 1e-4 { + return; + } + self.runtime.opacity = opacity; + crate::gpui_shell::wallpaper::set_opacity_live(opacity, cx); + crate::gpui_shell::theme::reapply_shell_opacity( + self.runtime.theme, + self.runtime.follow_system_theme, + cx, + ); + // 壳色是全局 token：只 `notify` 设置页不会让终端窗口的背景重绘。 + // `refresh_windows` 只推一个 effect，同一 update cycle 内多次调用会合并 + // 成一次重绘，所以每帧调是安全的。 + cx.refresh_windows(); + cx.notify(); + self.schedule_slider_persist("opacity", format!("{opacity:.2}"), cx); } + /// 背景图透明度是**烘焙进纹理**的（decode + 长边压到 2560 + 逐像素乘 + /// alpha），没有便宜的实时路径：每帧重烘焙一次会直接卡死。所以拖拽期间 + /// 只让滑块跟手，图面在停手后随一次落盘统一重建。 fn set_wallpaper_opacity(&mut self, opacity: f32, cx: &mut Context) { let opacity = opacity.clamp(0.05, 1.0); - self.persist(&[("background_image_opacity", format!("{opacity:.2}"))], cx); + if (self.runtime.background_image_opacity - opacity).abs() < 1e-4 { + return; + } + self.runtime.background_image_opacity = opacity; + cx.notify(); + self.schedule_slider_persist("background_image_opacity", format!("{opacity:.2}"), cx); + } + + /// 滑块停手后才落盘。滑块只有 `Change` 事件（组件库没有"松手"信号）， + /// 所以用 debounce：每个新事件覆盖上一个待落盘任务，旧 `Task` drop 即取消。 + /// + /// 落盘那一次会走完整的 [`Self::persist`]（写盘 + 设置重载 + 每终端 + /// `apply_settings` + 主题重建 + 壁纸重烘焙），跑一次没问题；每帧跑就是 + /// 2026-08-21 报的"拖拽卡顿的要死"。 + fn schedule_slider_persist( + &mut self, + key: &'static str, + value: String, + cx: &mut Context, + ) { + let executor = cx.background_executor().clone(); + self.slider_persist = Some(cx.spawn(async move |this, cx| { + executor.timer(Duration::from_millis(180)).await; + let _ = this.update(cx, |this, cx| { + this.persist(&[(key, value)], cx); + }); + })); } // ---- 字体选择器（旧壳 toggle_font_picker / font_catalog 的 GPUI 形态）---- @@ -1871,10 +1937,8 @@ impl SettingsPane { .map(str::trim) .filter(|path| !path.is_empty()); let has_dir = current.is_some(); - let label: SharedString = current - .map(str::to_owned) - .unwrap_or_else(|| "继承当前目录".to_owned()) - .into(); + let label: SharedString = + current.map(str::to_owned).unwrap_or_else(|| "继承当前目录".to_owned()).into(); let color = if has_dir { cx.theme().link } else { cx.theme().muted_foreground }; self.row( "启动目录", @@ -1895,13 +1959,11 @@ impl SettingsPane { })), ) .when(has_dir, |row| { - row.child( - NebulaButton::new("startup-directory-clear").label("清除").on_click( - cx.listener(|this, _, _, cx| { - this.clear_startup_directory(cx); - }), - ), - ) + row.child(NebulaButton::new("startup-directory-clear").label("清除").on_click( + cx.listener(|this, _, _, cx| { + this.clear_startup_directory(cx); + }), + )) }), ) } @@ -3264,6 +3326,26 @@ impl SettingsPane { (rows, note) } + /// interceptor 与修饰键预览共用的录制状态机；按键是否应被独占由调用 + /// 方在进入这里前裁定，避免数据转换层意外吞掉普通设置输入。 + fn handle_keymap_capture(&mut self, keystroke: &gpui::Keystroke, cx: &mut Context) { + let Some(row) = self.keymap_capture else { return }; + match crate::display::keymap::capture_gpui(keystroke) { + crate::display::keymap::CaptureOutcome::Cancel => { + self.keymap_capture = None; + self.keymap_capture_preview.clear(); + cx.notify(); + }, + crate::display::keymap::CaptureOutcome::ClearCustom => { + self.keymap_clear_custom(row, cx); + }, + crate::display::keymap::CaptureOutcome::Bind(combo) => { + self.keymap_assign(row, combo, cx); + }, + crate::display::keymap::CaptureOutcome::Pending => {}, + } + } + /// 捕获完成：一个动作只保留一条自定义绑定，但同一 combo 可以同时归属 /// 多个动作。冲突不再靠静默注销旧动作来“解决”，而是由 /// `keymap_clashes` 标记双方并显示警告条，让用户自己决定改哪一行。 @@ -3689,32 +3771,10 @@ impl Render for SettingsPane { } }), ) - // 按键捕获态的键盘独占：焦点在本根 div（点行时收进来），键盘 - // 事件沿焦点路径冒泡到这里；捕获未激活时不挂处理器，输入框、 - // 下拉等组件照常吃键。修饰键实时回显同址（ModifiersChanged - // 不是 KeyDown，走独立通道）。 + // KeyDown 已由构造期注册的 interceptor 在 action 前独占；这里仅 + // 处理不走 KeystrokeEvent 的修饰键变化，用于实时回显 "Ctrl+…"。 .when_some(self.keymap_capture, |root, _| { - root.on_key_down(cx.listener( - |this, event: &KeyDownEvent, _window, cx| { - let Some(row) = this.keymap_capture else { return }; - cx.stop_propagation(); - match crate::display::keymap::capture_gpui(&event.keystroke) { - crate::display::keymap::CaptureOutcome::Cancel => { - this.keymap_capture = None; - this.keymap_capture_preview.clear(); - cx.notify(); - }, - crate::display::keymap::CaptureOutcome::ClearCustom => { - this.keymap_clear_custom(row, cx); - }, - crate::display::keymap::CaptureOutcome::Bind(combo) => { - this.keymap_assign(row, combo, cx); - }, - crate::display::keymap::CaptureOutcome::Pending => {}, - } - }, - )) - .on_modifiers_changed(cx.listener( + root.on_modifiers_changed(cx.listener( |this, event: &ModifiersChangedEvent, _window, cx| { if this.keymap_capture.is_none() { return; diff --git a/nebula_app/src/gpui_shell/ssh_settings.rs b/nebula_app/src/gpui_shell/ssh_settings.rs index 2c1971e..157eeb7 100644 --- a/nebula_app/src/gpui_shell/ssh_settings.rs +++ b/nebula_app/src/gpui_shell/ssh_settings.rs @@ -563,7 +563,9 @@ impl SettingsPane { .justify_center() .rounded(px(4.0)) .cursor_pointer() - .when(selected, |chip| chip.bg(theme.background).font_weight(gpui::FontWeight::MEDIUM)) + .when(selected, |chip| { + chip.bg(theme.background).font_weight(gpui::FontWeight::MEDIUM) + }) .when(!selected, |chip| { chip.text_color(muted).hover(|chip| chip.bg(theme.list_hover)) }) @@ -571,12 +573,8 @@ impl SettingsPane { .on_click(select_auth(mode)) }; let visible_start = editor.private_keys.len().saturating_sub(SSH_EDITOR_KEY_ROWS_MAX); - let key_rows = editor - .private_keys - .iter() - .enumerate() - .skip(visible_start) - .map(|(index, path)| { + let key_rows = + editor.private_keys.iter().enumerate().skip(visible_start).map(|(index, path)| { let shown: SharedString = ssh_key_path_tail(path, 36).into(); h_flex() .id(SharedString::from(format!("ssh-key-{index}"))) @@ -649,13 +647,7 @@ impl SettingsPane { .h(px(SSH_EDITOR_CTL_H)) .gap(px(SSH_EDITOR_SPACE_S)) .items_center() - .child( - div() - .w(px(SSH_EDITOR_LABEL_W)) - .flex_shrink_0() - .text_sm() - .child(label), - ) + .child(div().w(px(SSH_EDITOR_LABEL_W)).flex_shrink_0().text_sm().child(label)) .child(div().flex_1().min_w_0().child(control)) }; let dest_hint = dest_error.as_deref().unwrap_or("支持 user@host，也可粘贴 ssh://host:2222"); @@ -1074,9 +1066,14 @@ impl SettingsPane { icon: &'static crate::display::ui::os_icons::OsIcon, cx: &mut Context, ) -> gpui::AnyElement { + const BASE_ICON_SIZE: f32 = 22.0; + let theme = cx.theme(); let open = self.ssh_icon_picker_open; let pane = cx.entity().downgrade(); + let target_ink_width = SSH_EDITOR_AVATAR_H * 0.46; + let icon_size = BASE_ICON_SIZE + * crate::display::ui::os_icons::scale_for(icon, BASE_ICON_SIZE * 0.6, target_ink_width); div() .id("ssh-icon-avatar") .relative() @@ -1091,9 +1088,16 @@ impl SettingsPane { .justify_center() .cursor_pointer() .hover(|avatar| avatar.bg(theme.list_hover)) - .font_family(self.current_font_chain(cx)) - .text_size(px(22.0)) - .child(icon.glyph.to_string()) + // Nerd Font 的 advance 固定为 0.6em，墨迹却能宽到 1.2em；直接 + // 居中文本盒会把溢出的那一半全留在右边。固定墨迹槽后，视觉中心 + // 才不会随图标变化。 + .child( + div() + .w(px(target_ink_width)) + .font_family(self.current_font_chain(cx)) + .text_size(px(icon_size)) + .child(icon.glyph.to_string()), + ) .on_click(cx.listener(|this, _, window, cx| { this.toggle_ssh_icon_picker(window, cx); })) @@ -1146,7 +1150,13 @@ impl SettingsPane { /// 弹出的图标选择器：顶部搜索框 + 分组过的目录，锚在头像下方。 /// 返回 `None` 表示收起态（或头像还没量到坐标）。 fn ssh_icon_popup(&mut self, cx: &mut Context) -> Option { - use crate::display::ui::os_icons::{AUTO_ID, CATALOG, PickerRow, picker_rows}; + use crate::display::ui::os_icons::{ + AUTO_ID, CATALOG, PickerRow, picker_rows, resolve, scale_for, + }; + + const PICKER_ICON_SLOT_W: f32 = 22.0; + const PICKER_ICON_INK_W: f32 = 16.0; + const PICKER_ICON_BASE_SIZE: f32 = 15.0; if !self.ssh_icon_picker_open { return None; @@ -1179,10 +1189,14 @@ impl SettingsPane { .child(title) .into_any_element(), PickerRow::Option(option) => { - let (glyph, name, id) = match option.and_then(|index| CATALOG.get(index)) { - Some(icon) => (icon.glyph.to_string(), icon.zh, Some(icon.id)), - None => ("\u{ea85}".to_owned(), "自动识别", None), + let (icon, name, id) = match option.and_then(|index| CATALOG.get(index)) { + Some(icon) => (icon, icon.zh, Some(icon.id)), + // 未识别时头像本来就回落到 DEFAULT_ID；选择器也显示 + // 同一张脸，避免挑选前后出现两枚不同的“终端”图标。 + None => (resolve(None), "自动识别", None), }; + let icon_size = PICKER_ICON_BASE_SIZE + * scale_for(icon, PICKER_ICON_BASE_SIZE * 0.6, PICKER_ICON_INK_W); let selected = match id { Some(id) => current.as_deref() == Some(id), None => current.is_none(), @@ -1201,13 +1215,19 @@ impl SettingsPane { .hover(|row| row.bg(hover_bg)) .child( div() - .w(px(22.0)) + .w(px(PICKER_ICON_SLOT_W)) + .h_full() .flex_shrink_0() .flex() + .items_center() .justify_center() - .font_family(font_chain.clone()) - .text_size(px(15.0)) - .child(glyph), + .child( + div() + .w(px(PICKER_ICON_INK_W)) + .font_family(font_chain.clone()) + .text_size(px(icon_size)) + .child(icon.glyph.to_string()), + ), ) .child(div().flex_1().min_w_0().truncate().text_sm().child(name)) .on_click(cx.listener(move |this, _, window, cx| { diff --git a/nebula_app/src/gpui_shell/terminal/element.rs b/nebula_app/src/gpui_shell/terminal/element.rs index b6c0e2f..1f2f4b3 100644 --- a/nebula_app/src/gpui_shell/terminal/element.rs +++ b/nebula_app/src/gpui_shell/terminal/element.rs @@ -189,7 +189,9 @@ impl Element for TerminalElement { let focused = focus_handle.is_focused(window); // 旧壳只让光标本身参与闪烁；ghost、弹窗补齐和 IME 仍复用同一个坐标锚点。 let cursor_visible = self.view.read(cx).cursor_visible(); - let Some((snap, prompt_line, history, dashed)) = self.snapshot(layout.rows, layout.cols, cx) else { + let Some((snap, prompt_line, history, dashed)) = + self.snapshot(layout.rows, layout.cols, cx) + else { return; }; let suggest_anchor = @@ -526,7 +528,7 @@ impl Element for TerminalElement { let same_frame = view.suggest_anchor == Some((cursor.row as usize, cursor.col as usize)); if ime_active || !same_frame { - (None, Vec::new(), 0) + (None, Vec::new(), None) } else { ( (!view.suggest.suggestion.is_empty()) @@ -570,6 +572,7 @@ impl Element for TerminalElement { &bounds, &colors, &font, + &bold_font, font_size, ); } @@ -721,11 +724,8 @@ fn paint_link_preview( font: &gpui::Font, font_size: Pixels, ) { - let line = if anchor_row + 1 < layout.rows { - anchor_row + 1 - } else { - anchor_row.saturating_sub(1) - }; + let line = + if anchor_row + 1 < layout.rows { anchor_row + 1 } else { anchor_row.saturating_sub(1) }; let label_size = px(font_size.as_f32() * 0.85); let run = TextRun { len: preview.len(), @@ -735,17 +735,30 @@ fn paint_link_preview( underline: None, strikethrough: None, }; - let shaped = window.text_system().shape_line(SharedString::from(preview.to_owned()), label_size, &[run], None); + let shaped = window.text_system().shape_line( + SharedString::from(preview.to_owned()), + label_size, + &[run], + None, + ); let pad = px(8.0); let bubble_w = shaped.width + pad * 2.0; let bubble_h = layout.line_height * 0.85 + pad; let max_x = (bounds.origin.x + bounds.size.width - bubble_w).max(bounds.origin.x); let x = (bounds.origin.x + layout.cell_width * anchor_col as f32).min(max_x); - let y = bounds.origin.y + layout.line_height * line as f32 + (layout.line_height - bubble_h) * 0.5; + let y = + bounds.origin.y + layout.line_height * line as f32 + (layout.line_height - bubble_h) * 0.5; let bubble = Bounds::new(point(x, y), size(bubble_w, bubble_h)); window.paint_quad(fill(bubble, cx.theme().popover).corner_radii(px(6.0))); - window.paint_quad(outline(bubble, cx.theme().border, gpui::BorderStyle::Solid).corner_radii(px(6.0))); - let _ = shaped.paint(point(x + pad, y + (bubble_h - layout.line_height * 0.85) * 0.5), layout.line_height * 0.85, window, cx); + window.paint_quad( + outline(bubble, cx.theme().border, gpui::BorderStyle::Solid).corner_radii(px(6.0)), + ); + let _ = shaped.paint( + point(x + pad, y + (bubble_h - layout.line_height * 0.85) * 0.5), + layout.line_height * 0.85, + window, + cx, + ); } /// 唯一的 cell 文本落笔原语：单 cell 文本塑形后从调用方给定的整数 cell @@ -829,12 +842,12 @@ pub(super) struct CompletionPopupLayout { pub width: usize, pub label_width: usize, pub tag_width: usize, - pub selected: usize, + pub selected: Option, } pub(super) fn completion_popup_layout( items: &[crate::display::NebulaCompletionItem], - selected: usize, + selected: Option, cursor_row: usize, cursor_col: usize, screen_lines: usize, @@ -859,8 +872,8 @@ pub(super) fn completion_popup_layout( return None; } - let selected = selected.min(items.len() - 1); - let offset = if selected >= rows { selected + 1 - rows } else { 0 }; + let selected = selected.filter(|index| *index < items.len()); + let offset = selected.filter(|index| *index >= rows).map(|index| index + 1 - rows).unwrap_or(0); let visible = &items[offset..(offset + rows).min(items.len())]; let tag = |kind: crate::display::NebulaCompletionKind| -> &'static str { match kind { @@ -907,13 +920,14 @@ fn paint_completion_popup( window: &mut Window, cx: &mut App, items: &[crate::display::NebulaCompletionItem], - selected: usize, + selected: Option, cursor_row: usize, cursor_col: usize, layout: &TermLayout, bounds: &Bounds, colors: &crate::gpui_shell::theme::CompletionColors, font: &gpui::Font, + bold_font: &gpui::Font, font_size: Pixels, ) { let columns = layout.cols; @@ -931,6 +945,14 @@ fn paint_completion_popup( crate::display::NebulaCompletionKind::File => "文件", } }; + let icon = |kind: crate::display::NebulaCompletionKind| -> &'static str { + match kind { + crate::display::NebulaCompletionKind::History => "↶", + crate::display::NebulaCompletionKind::Command => "›", + crate::display::NebulaCompletionKind::Dir => "/", + crate::display::NebulaCompletionKind::File => "·", + } + }; let visible = &items[popup.offset..(popup.offset + popup.rows).min(items.len())]; // 四周留出少量呼吸边，圆角和边框不会压到候选文字。 @@ -946,9 +968,29 @@ fn paint_completion_popup( layout.line_height * popup.rows as f32 + panel_pad * 2.0, ), ); - window.paint_quad(fill(panel_bounds, colors.panel_bg).corner_radii(px(8.0))); + let panel_radius = px(8.0); + window.paint_shadows( + panel_bounds, + panel_radius.into(), + &[ + gpui::BoxShadow { + color: colors.panel_shadow, + offset: point(px(0.0), px(8.0)), + blur_radius: px(30.0), + spread_radius: px(-2.0), + }, + gpui::BoxShadow { + color: colors.panel_shadow.opacity(0.72), + offset: point(px(0.0), px(3.0)), + blur_radius: px(10.0), + spread_radius: px(-1.0), + }, + ], + ); + window.paint_quad(fill(panel_bounds, colors.panel_bg).corner_radii(panel_radius)); window.paint_quad( - outline(panel_bounds, colors.panel_border, gpui::BorderStyle::Solid).corner_radii(px(8.0)), + outline(panel_bounds, colors.panel_border, gpui::BorderStyle::Solid) + .corner_radii(panel_radius), ); for (row, item) in visible.iter().enumerate() { @@ -956,7 +998,7 @@ fn paint_completion_popup( if line >= screen_lines { break; } - let is_selected = popup.offset + row == popup.selected; + let is_selected = Some(popup.offset + row) == popup.selected; let (bg, label_fg, tag_fg) = if is_selected { (colors.selected_bg, colors.selected_fg, colors.selected_fg) } else { @@ -966,15 +1008,34 @@ fn paint_completion_popup( bounds.origin.x + layout.cell_width * popup.start_col as f32, bounds.origin.y + layout.line_height * line as f32, ); - window.paint_quad(fill( - Bounds::new(origin, size(layout.cell_width * popup.width as f32, layout.line_height)), - bg, - )); + let row_radius = if is_selected { px(6.0) } else { px(0.0) }; + window.paint_quad( + fill( + Bounds::new( + origin, + size(layout.cell_width * popup.width as f32, layout.line_height), + ), + bg, + ) + .corner_radii(row_radius), + ); + grid_text( + window, + cx, + icon(item.kind), + font, + font_size, + tag_fg, + origin, + layout.cell_width, + layout.line_height, + 1, + ); grid_text( window, cx, &item.label, - font, + if is_selected { bold_font } else { font }, font_size, label_fg, point(origin.x + layout.cell_width, origin.y), @@ -1087,9 +1148,23 @@ mod tests { kind: NebulaCompletionKind::Command, }]; - let popup = completion_popup_layout(&items, 0, 2, 7, 24, 80) + let popup = completion_popup_layout(&items, Some(0), 2, 7, 24, 80) .expect("短命令的精确候选也必须形成可见面板"); assert_eq!(popup.rows, 1); assert_eq!(popup.label_width, 3); } + + #[test] + fn popup_layout_preserves_the_unselected_state() { + let items = [NebulaCompletionItem { + label: "git pull upstream".to_owned(), + insert: " upstream".to_owned(), + kind: NebulaCompletionKind::History, + }]; + + let popup = + completion_popup_layout(&items, None, 2, 7, 24, 80).expect("空选中态仍应显示候选面板"); + assert_eq!(popup.selected, None); + assert_eq!(popup.offset, 0); + } } diff --git a/nebula_app/src/gpui_shell/terminal/math_overlay.rs b/nebula_app/src/gpui_shell/terminal/math_overlay.rs index 120d080..25ee0cd 100644 --- a/nebula_app/src/gpui_shell/terminal/math_overlay.rs +++ b/nebula_app/src/gpui_shell/terminal/math_overlay.rs @@ -92,8 +92,10 @@ impl MathOverlay { let allow_inline_dollar = self.state.inline_dollar_enabled(); let origin = term.viewport_origin_for(size.screen_lines()); - let cursor = nebula_terminal::term::point_to_viewport_from(origin, term.grid().cursor.point) - .filter(|point| point.line < size.screen_lines() && point.column.0 < size.columns()); + let cursor = + nebula_terminal::term::point_to_viewport_from(origin, term.grid().cursor.point).filter( + |point| point.line < size.screen_lines() && point.column.0 < size.columns(), + ); let rendered_cells = scan_cells_from_term(term, size, default_foreground); let overlays = terminal_math::scan_visible( &mut self.state, @@ -190,10 +192,7 @@ fn scan_cells_from_term( let line = origin + row as i32; for column in 0..columns { let cell = &grid[line][Column(column)]; - if cell - .flags - .intersects(Flags::WIDE_CHAR_SPACER | Flags::LEADING_WIDE_CHAR_SPACER) - { + if cell.flags.intersects(Flags::WIDE_CHAR_SPACER | Flags::LEADING_WIDE_CHAR_SPACER) { continue; } let bg_alpha = if cell.flags.contains(Flags::INVERSE) { @@ -470,11 +469,8 @@ mod tests { fn empty_selection_does_not_disable_overlays() { let mut overlay = MathOverlay::default(); let mut term = term_with(16, 4, &[r"\[x\]", "", "prompt"]); - term.selection = Some(Selection::new( - SelectionType::Simple, - Point::new(Line(2), Column(0)), - Side::Left, - )); + term.selection = + Some(Selection::new(SelectionType::Simple, Point::new(Line(2), Column(0)), Side::Left)); let frame = plan(&mut overlay, &term, 16, 4); assert!(!frame.is_empty(), "zero-width leftover selection must not gate the frame"); } @@ -505,8 +501,7 @@ mod tests { // AI CLI 的 markdown 渲染吃掉 `\[` `\]` `\,` 的反斜杠后屏幕上只剩 // 裸 `[` 块（`\int`/`\frac` 幸存）；全链路必须照常出覆盖层。 let mut overlay = MathOverlay::default(); - let term = - term_with(40, 6, &["[", r"\int_0^1 x^2,dx = \frac{1}{3}", "]", "", "prompt"]); + let term = term_with(40, 6, &["[", r"\int_0^1 x^2,dx = \frac{1}{3}", "]", "", "prompt"]); let frame = plan(&mut overlay, &term, 40, 6); assert!(!frame.is_empty(), "markdown-unescaped bare bracket block must overlay"); assert_eq!(frame.formulas[0].source.as_ref(), r"\int_0^1 x^2,dx = \frac{1}{3}"); diff --git a/nebula_app/src/gpui_shell/terminal/mod.rs b/nebula_app/src/gpui_shell/terminal/mod.rs index 9286f5d..d271fe2 100644 --- a/nebula_app/src/gpui_shell/terminal/mod.rs +++ b/nebula_app/src/gpui_shell/terminal/mod.rs @@ -7,8 +7,8 @@ pub mod colors; pub mod element; pub mod keymap; pub mod math_overlay; -mod osc_links; pub mod mouse_protocol; +mod osc_links; pub mod session; mod ssh_connect_overlay; pub mod suggest; diff --git a/nebula_app/src/gpui_shell/terminal/osc_links.rs b/nebula_app/src/gpui_shell/terminal/osc_links.rs index 7caa6d8..5393252 100644 --- a/nebula_app/src/gpui_shell/terminal/osc_links.rs +++ b/nebula_app/src/gpui_shell/terminal/osc_links.rs @@ -1,133 +1,132 @@ -//! GPUI 壳的 OSC 8 / 正则 hint 接线：虚线下划线、悬停预览、Ctrl+点击打开。 -//! -//! 匹配与动作全部复用旧壳 `display::hint` + `file_uri` + `daemon`，这里只做 -//! 视口坐标、GPUI 修饰键和打开入口。 - -use std::collections::HashSet; -use std::sync::Arc; - -use gpui::{App, ClipboardItem}; -use nebula_terminal::event::EventListener; -use nebula_terminal::index::Point; -use nebula_terminal::term::{point_to_viewport_from, Term}; -use unicode_width::UnicodeWidthChar; -use winit::keyboard::ModifiersState; - -use crate::config::UiConfig; -use crate::config::ui_config::{HintAction, HintInternalAction}; -use crate::display::hint::{self, HintMatch}; - -/// 悬停目标：旧壳 `highlighted_hint` + 已经解码好的预览文案。 -#[derive(Clone)] -pub(super) struct LinkHover { - pub hint: HintMatch, - pub preview: String, - pub anchor_row: u16, - pub anchor_col: u16, -} - -pub(super) fn hint_config() -> Arc { - Arc::new(UiConfig::default()) -} - -pub(super) fn winit_mouse_mods(mods: &gpui::Modifiers) -> ModifiersState { - let mut state = ModifiersState::empty(); - if mods.shift { - state |= ModifiersState::SHIFT; - } - if mods.control { - state |= ModifiersState::CONTROL; - } - if mods.alt { - state |= ModifiersState::ALT; - } - if mods.platform { - state |= ModifiersState::SUPER; - } - state -} - -/// 可见可点范围（OSC 8 + 正则 URL）映射到当前视口格子，供虚线下划线使用。 -pub(super) fn dashed_cells( - term: &Term, - config: &UiConfig, - rows: usize, - cols: usize, -) -> HashSet<(u16, u16)> { - let matches = hint::visible_clickable_matches(term, config); - if matches.is_empty() { - return HashSet::new(); - } - let origin = term.viewport_origin_for(rows); - let mut cells = HashSet::new(); - for indexed in term.grid().display_iter() { - if !matches.iter().any(|bounds| bounds.contains(&indexed.point)) { - continue; - } - let Some(vp) = point_to_viewport_from(origin, indexed.point) else { continue }; - if vp.line < rows && vp.column.0 < cols { - cells.insert((vp.line as u16, vp.column.0 as u16)); - } - } - cells -} - -pub(super) fn highlighted_at( - term: &Term, - config: &UiConfig, - point: Point, - mods: &gpui::Modifiers, -) -> Option { - hint::highlighted_at(term, config, point, winit_mouse_mods(mods)) -} - -pub(super) fn hover_from_hint( - term: &Term, - hint: HintMatch, - rows: usize, - cols: usize, -) -> Option { - let uri = hint - .hyperlink() - .map(|link| link.uri().to_owned()) - .or_else(|| hint.text(term).map(|text| text.into_owned()))?; - let origin = term.viewport_origin_for(rows); - let start = *hint.bounds().start(); - let vp = point_to_viewport_from(origin, start).filter(|vp| vp.line < rows && vp.column.0 < cols); - let (anchor_row, anchor_col) = vp - .map(|vp| (vp.line as u16, vp.column.0 as u16)) - .unwrap_or((0, 0)); - const HINT: &str = " · Ctrl+点击"; - let width = |s: &str| -> usize { s.chars().map(|c| c.width().unwrap_or(0)).sum() }; - let target = crate::display::strip_file_scheme(&uri); - let budget = cols.saturating_sub(width(HINT) + 1); - let target = crate::display::fit_tail(&target, budget); - Some(LinkHover { - hint, - preview: format!("{target}{HINT}"), - anchor_row, - anchor_col, - }) -} - -pub(super) fn open_hint(hint: &HintMatch, term: &Term, cx: &App) { - let Some(text) = hint.text(term) else { return }; - #[cfg(windows)] - if let Some(path) = crate::file_uri::file_uri_to_local_path(&text) { - let _ = crate::daemon::spawn_daemon("explorer.exe", &[path.as_os_str()]); - return; - } - match hint.action() { - HintAction::Command(command) => { - let mut args = command.args().to_vec(); - args.push(text.into_owned()); - let _ = crate::daemon::spawn_daemon(command.program(), &args); - }, - HintAction::Action(HintInternalAction::Copy) => { - cx.write_to_clipboard(ClipboardItem::new_string(text.into_owned())); - }, - HintAction::Action(HintInternalAction::Paste | HintInternalAction::Select | HintInternalAction::MoveViModeCursor) => { - // 默认 hint 走 Command（打开 URI）。这三项仍由旧壳键盘 hint 使用。 - }, - } -} +//! GPUI 壳的 OSC 8 / 正则 hint 接线：虚线下划线、悬停预览、Ctrl+点击打开。 +//! +//! 匹配与动作全部复用旧壳 `display::hint` + `file_uri` + `daemon`，这里只做 +//! 视口坐标、GPUI 修饰键和打开入口。 + +use std::collections::HashSet; +use std::sync::Arc; + +use gpui::{App, ClipboardItem}; +use nebula_terminal::event::EventListener; +use nebula_terminal::index::Point; +use nebula_terminal::term::{Term, point_to_viewport_from}; +use unicode_width::UnicodeWidthChar; +use winit::keyboard::ModifiersState; + +use crate::config::UiConfig; +use crate::config::ui_config::{HintAction, HintInternalAction}; +use crate::display::hint::{self, HintMatch}; + +/// 悬停目标：旧壳 `highlighted_hint` + 已经解码好的预览文案。 +#[derive(Clone)] +pub(super) struct LinkHover { + pub hint: HintMatch, + pub preview: String, + pub anchor_row: u16, + pub anchor_col: u16, +} + +pub(super) fn hint_config() -> Arc { + Arc::new(UiConfig::default()) +} + +pub(super) fn winit_mouse_mods(mods: &gpui::Modifiers) -> ModifiersState { + let mut state = ModifiersState::empty(); + if mods.shift { + state |= ModifiersState::SHIFT; + } + if mods.control { + state |= ModifiersState::CONTROL; + } + if mods.alt { + state |= ModifiersState::ALT; + } + if mods.platform { + state |= ModifiersState::SUPER; + } + state +} + +/// 可见可点范围（OSC 8 + 正则 URL）映射到当前视口格子，供虚线下划线使用。 +pub(super) fn dashed_cells( + term: &Term, + config: &UiConfig, + rows: usize, + cols: usize, +) -> HashSet<(u16, u16)> { + let matches = hint::visible_clickable_matches(term, config); + if matches.is_empty() { + return HashSet::new(); + } + let origin = term.viewport_origin_for(rows); + let mut cells = HashSet::new(); + for indexed in term.grid().display_iter() { + if !matches.iter().any(|bounds| bounds.contains(&indexed.point)) { + continue; + } + let Some(vp) = point_to_viewport_from(origin, indexed.point) else { continue }; + if vp.line < rows && vp.column.0 < cols { + cells.insert((vp.line as u16, vp.column.0 as u16)); + } + } + cells +} + +pub(super) fn highlighted_at( + term: &Term, + config: &UiConfig, + point: Point, + mods: &gpui::Modifiers, +) -> Option { + hint::highlighted_at(term, config, point, winit_mouse_mods(mods)) +} + +pub(super) fn hover_from_hint( + term: &Term, + hint: HintMatch, + rows: usize, + cols: usize, +) -> Option { + let uri = hint + .hyperlink() + .map(|link| link.uri().to_owned()) + .or_else(|| hint.text(term).map(|text| text.into_owned()))?; + let origin = term.viewport_origin_for(rows); + let start = *hint.bounds().start(); + let vp = + point_to_viewport_from(origin, start).filter(|vp| vp.line < rows && vp.column.0 < cols); + let (anchor_row, anchor_col) = + vp.map(|vp| (vp.line as u16, vp.column.0 as u16)).unwrap_or((0, 0)); + const HINT: &str = " · Ctrl+点击"; + let width = |s: &str| -> usize { s.chars().map(|c| c.width().unwrap_or(0)).sum() }; + let target = crate::display::strip_file_scheme(&uri); + let budget = cols.saturating_sub(width(HINT) + 1); + let target = crate::display::fit_tail(&target, budget); + Some(LinkHover { hint, preview: format!("{target}{HINT}"), anchor_row, anchor_col }) +} + +pub(super) fn open_hint(hint: &HintMatch, term: &Term, cx: &App) { + let Some(text) = hint.text(term) else { return }; + #[cfg(windows)] + if let Some(path) = crate::file_uri::file_uri_to_local_path(&text) { + let _ = crate::daemon::spawn_daemon("explorer.exe", &[path.as_os_str()]); + return; + } + match hint.action() { + HintAction::Command(command) => { + let mut args = command.args().to_vec(); + args.push(text.into_owned()); + let _ = crate::daemon::spawn_daemon(command.program(), &args); + }, + HintAction::Action(HintInternalAction::Copy) => { + cx.write_to_clipboard(ClipboardItem::new_string(text.into_owned())); + }, + HintAction::Action( + HintInternalAction::Paste + | HintInternalAction::Select + | HintInternalAction::MoveViModeCursor, + ) => { + // 默认 hint 走 Command（打开 URI）。这三项仍由旧壳键盘 hint 使用。 + }, + } +} diff --git a/nebula_app/src/gpui_shell/terminal/ssh_connect_overlay.rs b/nebula_app/src/gpui_shell/terminal/ssh_connect_overlay.rs index dd1e296..440a9a3 100644 --- a/nebula_app/src/gpui_shell/terminal/ssh_connect_overlay.rs +++ b/nebula_app/src/gpui_shell/terminal/ssh_connect_overlay.rs @@ -507,7 +507,7 @@ pub(super) fn overlay( ) }); - // ── 底部按钮（旧裁定：没有重试；连接中=取消，失败=关闭=主按钮）── + // ── 底部按钮：连接中只有取消；失败后重试在关闭左侧 ── let action_label: SharedString = if state.failed() { lang.pick("关闭", "Close").into() } else { @@ -515,7 +515,7 @@ pub(super) fn overlay( }; let failed = state.failed(); let action_target = cx.entity().downgrade(); - let buttons = h_flex().w_full().mt(px(24.0)).justify_end().child({ + let action_button = { let button = crate::gpui_shell::widgets::NebulaButton::new("ssh-connect-action").label(action_label); let button = if failed { button.primary() } else { button.outline() }; @@ -530,7 +530,38 @@ pub(super) fn overlay( }); } }) - }); + }; + let retry_target = cx.entity().downgrade(); + let retry_destination = state.destination().to_owned(); + let buttons = h_flex() + .w_full() + .mt(px(24.0)) + .gap(px(12.0)) + .justify_end() + .when(failed, |buttons| { + buttons.child( + crate::gpui_shell::widgets::NebulaButton::new("ssh-connect-retry") + .label(lang.pick("重试", "Retry")) + .outline() + .on_click(move |_, _, cx| { + if let Some(view) = retry_target.upgrade() { + view.update(cx, |this, cx| { + let still_same_failure = + this.ssh_connect.as_ref().is_some_and(|state| { + state.failed() + && state.destination() == retry_destination.as_str() + }); + if still_same_failure { + cx.emit(super::view::TerminalViewEvent::RetrySsh( + retry_destination.clone(), + )); + } + }); + } + }), + ) + }) + .child(action_button); // ── 组装 ── div() diff --git a/nebula_app/src/gpui_shell/terminal/suggest.rs b/nebula_app/src/gpui_shell/terminal/suggest.rs index c730d31..ad6ba16 100644 --- a/nebula_app/src/gpui_shell/terminal/suggest.rs +++ b/nebula_app/src/gpui_shell/terminal/suggest.rs @@ -86,23 +86,26 @@ pub fn popup_active(state: &NebulaPaneState) -> bool { !state.completion_items.is_empty() } -/// 弹窗高亮行循环移动。 +/// 弹窗高亮行循环移动。初始没有选中项；首次向任一方向导航都从首项进入， +/// 避免 Up 在无选择态直接跳到列表末尾。 pub fn popup_move(state: &mut NebulaPaneState, delta: isize) { let len = state.completion_items.len(); if len == 0 { return; } - let current = state.completion_selected as isize; - state.completion_selected = (current + delta).rem_euclid(len as isize) as usize; + state.completion_selected = Some(match state.completion_selected { + Some(current) => (current as isize + delta).rem_euclid(len as isize) as usize, + None => 0, + }); } /// 取走选中候选要键入的余量并关闭列表。 pub fn popup_take(state: &mut NebulaPaneState) -> Option { - let insert = - state.completion_items.get(state.completion_selected).map(|item| item.insert.clone()); + let index = state.completion_selected?; + let insert = state.completion_items.get(index)?.insert.clone(); state.completion_items.clear(); - state.completion_selected = 0; - insert + state.completion_selected = None; + Some(insert) } /// Esc 关闭列表；候选清空但重算键保留，列表在行变化前不会复开（与旧壳 @@ -116,10 +119,53 @@ pub fn popup_dismiss(state: &mut NebulaPaneState) -> bool { state.completion_suppressed_line = Some(line.clone()); } state.completion_items.clear(); - state.completion_selected = 0; + state.completion_selected = None; true } +#[cfg(test)] +mod tests { + use super::{popup_active, popup_move, popup_take}; + use crate::display::{NebulaCompletionItem, NebulaCompletionKind, NebulaPaneState}; + + fn popup_state() -> NebulaPaneState { + let mut state = NebulaPaneState::default(); + state.completion_items = vec![ + NebulaCompletionItem { + label: "git pull upstream".to_owned(), + insert: " upstream".to_owned(), + kind: NebulaCompletionKind::History, + }, + NebulaCompletionItem { + label: "git pull --rebase".to_owned(), + insert: " --rebase".to_owned(), + kind: NebulaCompletionKind::Command, + }, + ]; + state + } + + #[test] + fn popup_does_not_accept_before_explicit_navigation() { + let mut state = popup_state(); + assert!(popup_active(&state)); + assert_eq!(state.completion_selected, None); + assert_eq!(popup_take(&mut state), None); + assert!(popup_active(&state)); + } + + #[test] + fn popup_first_navigation_enters_at_the_first_item() { + for delta in [-1, 1] { + let mut state = popup_state(); + popup_move(&mut state, delta); + assert_eq!(state.completion_selected, Some(0)); + assert_eq!(popup_take(&mut state).as_deref(), Some(" upstream")); + assert!(!popup_active(&state)); + } + } +} + /// 接受键（Tab/Right/Both）的判定复用旧壳 [`AcceptKey`]。 pub fn accepts(accept: AcceptKey, key: &str) -> bool { match key { diff --git a/nebula_app/src/gpui_shell/terminal/view.rs b/nebula_app/src/gpui_shell/terminal/view.rs index a77bf6b..42ac01c 100644 --- a/nebula_app/src/gpui_shell/terminal/view.rs +++ b/nebula_app/src/gpui_shell/terminal/view.rs @@ -62,6 +62,31 @@ const SCROLLBAR_W: f32 = 4.0; const SCROLLBAR_MIN_THUMB: f32 = 24.0; const SCROLLBAR_SLOP: f32 = 8.0; +/// 拖选越过网格上/下边界后的自动回滚：tick 间隔与「每远离 20px 加一行」的 +/// 速度分档取自旧壳 `SELECTION_SCROLLING_INTERVAL` / `SELECTION_SCROLLING_STEP` +/// （旧壳按设备像素存常量再乘 DPI；GPUI 的 `Pixels` 本就是逻辑像素，这里直接 +/// 是逻辑口径）。 +const SELECTION_SCROLL_INTERVAL: std::time::Duration = std::time::Duration::from_millis(15); +const SELECTION_SCROLL_STEP: f32 = 20.0; + +/// 一次自动回滚该滚几行：指针在网格上方为正（往回滚历史）、下方为负，网格 +/// 内为 0。贴边即 1 行，之后每远离 `SELECTION_SCROLL_STEP` 像素加一档。 +/// +/// `max_lines` 是每 tick 的上限。旧壳不需要它——winit 不捕获指针，`mouse_y` +/// 永远落在窗口内；GPUI 在 Windows 上按下即 `SetCapture`，指针甩到屏幕外时 +/// y 可以是很大的负数，不封顶就会「一抖到底」。 +fn selection_scroll_lines(y: f32, top: f32, bottom: f32, max_lines: i32) -> i32 { + let step = SELECTION_SCROLL_STEP.max(1.0); + let max = max_lines.max(1); + if y < top { + (1 + ((top - y) / step) as i32).min(max) + } else if y >= bottom { + -((1 + ((y - bottom) / step) as i32).min(max)) + } else { + 0 + } +} + /// 粘贴体量按「落到终端算几行」数，不用 `str::lines`。 /// /// `str::lines` 只认 `\n`，纯 `\r` 的剪贴板内容（老式 Mac 换行、部分 Windows @@ -97,6 +122,8 @@ pub enum TerminalViewEvent { FocusRequested, /// 连接卡片的取消/关闭（旧壳 TabRequest::Close 的对应物）。 RequestClose, + /// 失败后在当前分屏叶原位重建同一 SSH 目标。 + RetrySsh(String), /// Ctrl+滚轮改了终端字号：宿主应对所有 pane 热应用并写盘。 FontSizeChanged, /// BEL（`^G`）。后台 tab 记铃点；本 tab 的闪烁/声音由视图自己处理。 @@ -238,6 +265,11 @@ pub struct TerminalView { resize_epoch: u64, scroll_px: f32, selecting: bool, + /// 拖选越界后的自动回滚 tick 世代：停止或重开一轮就 +1，让在途的旧 + /// 定时器链自行失效（同 `cursor_blink_epoch` 的模式）。 + selection_scroll_epoch: u64, + /// 是否已有一条自动回滚定时器链在跑——每次 move 都开一条会叠出 N 倍速。 + selection_scroll_active: bool, /// OSC 8 / 正则 URL：虚线下划线、悬停预览、Ctrl+点击打开。 pub(super) hint_config: Arc, pub(super) link_hover: Option, @@ -466,25 +498,36 @@ impl TerminalView { }, TerminalLaunch::Ssh { destination } => destination.clone(), }; - let (ssh_destination, initial_title, intro_shell_name, spawned) = match launch { - TerminalLaunch::Local { cwd, shell: launch_shell, shell_name } => ( - None, - String::from("shell"), - shell_name, - session::spawn( - initial, - term_config, - // 显式 launch（会话恢复/创建时冻结）优先；只有旧会话没有 - // 身份时才回退当前设置。这正是共享 v4 的 Default 语义。 - launch_shell.or(shell), - pane_id, - cwd, - ), - ), + let (ssh_destination, initial_title, intro_shell_name, suggest_env, spawned) = match launch + { + TerminalLaunch::Local { cwd, shell: launch_shell, shell_name } => { + // 显式 launch（会话恢复/创建时冻结）优先；只有旧会话没有 + // 身份时才回退当前设置。这正是共享 v4 的 Default 语义。 + let effective = launch_shell.or(shell); + // 补齐要知道这个 pane 面对**哪台机器**：`wsl.exe -d <发行版>` + // 启动的 tab，文件系统和命令集都在来宾里，本进程的 `std::fs` + // 和 PATH 描述的是另一台机器。 + let suggest_env = effective + .as_ref() + .and_then(|shell| { + crate::shell_detect::wsl_launch_distro(shell.program(), shell.args()) + }) + .map_or(crate::display::SuggestEnv::Local, |distro| { + crate::display::SuggestEnv::Wsl { distro: distro.to_owned() } + }); + ( + None, + String::from("shell"), + shell_name, + suggest_env, + session::spawn(initial, term_config, effective, pane_id, cwd), + ) + }, TerminalLaunch::Ssh { destination } => ( Some(destination.clone()), destination.clone(), None, + SuggestEnv::Ssh, session::spawn_ssh(destination, initial, term_config), ), }; @@ -656,6 +699,8 @@ impl TerminalView { resize_epoch: 0, scroll_px: 0.0, selecting: false, + selection_scroll_epoch: 0, + selection_scroll_active: false, hint_config: super::osc_links::hint_config(), link_hover: None, pending_link_open: false, @@ -664,7 +709,7 @@ impl TerminalView { cursor_visible: true, cursor_blink_epoch: 0, default_cursor_style, - suggest: Default::default(), + suggest: crate::display::NebulaPaneState { suggest_env, ..Default::default() }, suggest_anchor: None, ghost_enabled, accept, @@ -1230,32 +1275,35 @@ impl TerminalView { self.session.as_ref().map(|s| *s.term.lock().mode()).unwrap_or_default() } - /// 复制选区。`notify`：显式复制（Ctrl+Shift+C、右键复制）弹「已复制 - /// N 行」的确认 toast——键盘与右键共用这一条通知路径；copy_on_select - /// 的选区存储刻意静默（旧壳 `copy_selection` 同合同，抬手一次就可能 - /// 触发，弹起来会刷屏）。 - pub fn copy_selection(&mut self, notify: bool, window: &mut Window, cx: &mut Context) { - if let Some(session) = &self.session { - let text = session.term.lock().selection_to_string(); - if let Some(text) = text.filter(|t| !t.is_empty()) { - let lines = text.lines().count().max(1); - cx.write_to_clipboard(ClipboardItem::new_string(text)); - if notify { - let message = match ui_language() { - crate::display::UiLanguage::EnUs => { - format!("Copied {lines} lines to clipboard") - }, - _ => format!("已复制 {lines} 行到剪贴板"), - }; - crate::gpui_shell::toast::toast( - window, - cx, - crate::display::ToastKind::Info, - message, - ); - } - } + /// 复制选区并返回是否实际写入剪贴板。`notify` 表示显式复制 + /// （Ctrl+Shift+C、右键或自定义 Copy）：成功后清除选区并弹确认 toast； + /// copy_on_select 刻意静默且保留选区，避免鼠标抬手后立刻失去视觉反馈。 + pub fn copy_selection( + &mut self, + notify: bool, + window: &mut Window, + cx: &mut Context, + ) -> bool { + let Some(session) = &self.session else { return false }; + let text = session.term.lock().selection_to_string(); + let Some(text) = text.filter(|text| !text.is_empty()) else { return false }; + + let lines = text.lines().count().max(1); + cx.write_to_clipboard(ClipboardItem::new_string(text)); + if notify { + // 原始按键可能紧接着再次到来；先清除选区，下一次 Copy 才能按 + // “未处理”传播回终端，而不是重复复制并再次弹 toast。 + session.term.lock().selection = None; + let message = match ui_language() { + crate::display::UiLanguage::EnUs => { + format!("Copied {lines} lines to clipboard") + }, + _ => format!("已复制 {lines} 行到剪贴板"), + }; + crate::gpui_shell::toast::toast(window, cx, crate::display::ToastKind::Info, message); + cx.notify(); } + true } /// 读剪贴板并粘贴。体量达到 [`PASTE_CONFIRM_LINES`] 时先弹确认模态，确认 @@ -1806,6 +1854,9 @@ impl TerminalView { /// 像素命中与绘制共用同一份候选几何，截短列表或上翻时也不会点错行。 fn completion_popup_hit(&self, position: Point) -> Option { + if !suggest::popup_active(&self.suggest) { + return None; + } let (cursor_row, cursor_col) = self.suggest_anchor?; let popup = completion_popup_layout( &self.suggest.completion_items, @@ -1829,6 +1880,9 @@ impl TerminalView { /// 右侧窄条不覆盖候选字符列；点击轨道按指针比例跳到完整候选集中的位置。 fn completion_popup_scrollbar_target(&self, position: Point) -> Option { + if !suggest::popup_active(&self.suggest) { + return None; + } let (cursor_row, cursor_col) = self.suggest_anchor?; let popup = completion_popup_layout( &self.suggest.completion_items, @@ -1890,7 +1944,7 @@ impl TerminalView { if event.button == MouseButton::Left && let Some(index) = self.completion_popup_scrollbar_target(event.position) { - self.suggest.completion_selected = index; + self.suggest.completion_selected = Some(index); cx.notify(); cx.stop_propagation(); return; @@ -1898,7 +1952,7 @@ impl TerminalView { if event.button == MouseButton::Left && let Some(index) = self.completion_popup_hit(event.position) { - self.suggest.completion_selected = index; + self.suggest.completion_selected = Some(index); if self.accept_completion_popup(cx) { cx.notify(); cx.stop_propagation(); @@ -1967,13 +2021,19 @@ impl TerminalView { } } self.selecting = true; + // 自动回滚在这里就上弦，而不是等第一次「拖出网格」的移动事件：指针 + // 一旦离开元素 hitbox 就不再有 move 送进来，一甩到顶的拖法最后一个 + // 元素内事件往往还在网格中间，等 move 判定＝永远等不到（用户报的 + // 「甩到顶不动，往下再往上才滚」）。tick 自己看指针位置，网格内是 + // 一次比较就返回的空转。 + self.start_selection_scroll(window, cx); cx.notify(); } fn on_mouse_move( &mut self, event: &MouseMoveEvent, - _window: &mut Window, + window: &mut Window, cx: &mut Context, ) { // 候选行 hover 与键盘高亮共用选中索引；这样鼠标所见即 Enter 所收。 @@ -1981,8 +2041,8 @@ impl TerminalView { if event.pressed_button.is_none() && let Some(index) = self.completion_popup_hit(event.position) { - if self.suggest.completion_selected != index { - self.suggest.completion_selected = index; + if self.suggest.completion_selected != Some(index) { + self.suggest.completion_selected = Some(index); cx.notify(); } return; @@ -2009,6 +2069,10 @@ impl TerminalView { selection.update(point, side); } } + // 拖到网格上/下边界之外＝继续选下去，回滚由定时器接手（旧壳 + // `update_selection_scrolling`）。指针一旦离开元素 hitbox 就不再 + // 有 move 事件，所以判据也只能在这里「上弦」，续力靠 tick。 + self.update_selection_scroll(event.position.y.as_f32(), window, cx); cx.notify(); return; } @@ -2048,6 +2112,7 @@ impl TerminalView { } fn on_mouse_up(&mut self, event: &MouseUpEvent, window: &mut Window, cx: &mut Context) { + self.stop_selection_scroll(); if self.scrollbar_drag.take().is_some() { cx.notify(); return; @@ -2074,6 +2139,128 @@ impl TerminalView { cx.notify(); } + /// 指针在终端之外松手（拖到 tab 栏、别的 pane，或按下后甩出窗口—— + /// Windows 平台按下即 `SetCapture`，事件仍会送达）。GPUI 的 `on_mouse_up` + /// 只在 hitbox 命中时派发，没有这条兜底，`selecting` 会一直停在按下态： + /// 自动回滚停不下来，下一次移动还会继续改选区。 + fn on_mouse_up_out( + &mut self, + _event: &MouseUpEvent, + window: &mut Window, + cx: &mut Context, + ) { + self.stop_selection_scroll(); + let dragging_scrollbar = self.scrollbar_drag.take().is_some(); + if !self.selecting { + if dragging_scrollbar { + cx.notify(); + } + return; + } + self.selecting = false; + self.pending_link_open = false; + // 指针不在终端上，链接打开不该发生；只补选中即复制这一条收尾。 + if self.copy_on_select { + self.copy_selection(false, window, cx); + } + cx.notify(); + } + + /// 网格的上下边界（窗口坐标），自动回滚的触发线。旧壳用的是 + /// `padding_y` 与文本区底边，这里同义：卡内 8px 呼吸边距之内就已经 + /// 算「出了网格」。 + fn grid_vertical_bounds(&self) -> (f32, f32) { + let top = self.origin.y.as_f32(); + (top, top + self.line_height.as_f32() * self.rows as f32) + } + + fn selection_scroll_lines_at(&self, y: f32) -> i32 { + let (top, bottom) = self.grid_vertical_bounds(); + selection_scroll_lines(y, top, bottom, self.rows as i32) + } + + /// 选区拖拽全程常驻的自动回滚链：按下即起，松手才停。 + /// + /// 不用「移动越界才起链」是因为那条判据依赖 move 事件送得到——指针离开 + /// 元素 hitbox 后 GPUI 就不再派发，一甩到顶的拖法最后一个元素内事件通常 + /// 还在网格中间，链于是永远起不来。常驻链把「是否越界」挪进 tick，指针 + /// 在网格内时它只是一次比较加返回，不重绘也不取 Term 锁。 + fn start_selection_scroll(&mut self, window: &Window, cx: &mut Context) { + if self.selection_scroll_active { + return; + } + self.selection_scroll_active = true; + self.selection_scroll_epoch = self.selection_scroll_epoch.wrapping_add(1); + let epoch = self.selection_scroll_epoch; + let executor = cx.background_executor().clone(); + cx.spawn_in(window, async move |this, cx| { + loop { + executor.timer(SELECTION_SCROLL_INTERVAL).await; + let keep = this + .update_in(cx, |view, window, cx| view.selection_scroll_tick(epoch, window, cx)); + if !matches!(keep, Ok(true)) { + break; + } + } + }) + .detach(); + } + + fn stop_selection_scroll(&mut self) { + if !self.selection_scroll_active { + return; + } + self.selection_scroll_active = false; + self.selection_scroll_epoch = self.selection_scroll_epoch.wrapping_add(1); + } + + /// 一次自动回滚 tick：越界就滚 N 行，并把选区末端跟到指针**此刻**所在 + /// 的格；没越界就什么都不做，等下一次 tick。 + /// + /// 位置每 tick 从 `window.mouse_position()` 现取而不是沿用最后一次 move： + /// 指针停在元素外（tab 栏、下方的 pane）时根本不会再有 move 事件，沿用 + /// 旧值就等于速度被钉死在贴边那一档，旧壳「越拖越快」的手感会丢。 + /// + /// 返回 `false` 表示这条定时器链该结束（松手、换会话，或被新链顶掉）。 + fn selection_scroll_tick( + &mut self, + epoch: u64, + window: &Window, + cx: &mut Context, + ) -> bool { + if epoch != self.selection_scroll_epoch || !self.selection_scroll_active { + return false; + } + if !self.selecting || self.session.is_none() { + self.stop_selection_scroll(); + return false; + } + // 按下但还没拖出一个格：旧壳同样要求选区非空才滚，否则在卡片边距上 + // 按一下不动就会开始翻历史。 + if self.selection_is_empty() { + return true; + } + let position = window.mouse_position(); + let lines = self.selection_scroll_lines_at(position.y.as_f32()); + if lines == 0 { + return true; + } + if let Some(session) = &self.session { + session.term.lock().scroll_display(Scroll::Delta(lines)); + } + // 滚动换了视口到绝对行的映射，选区末端必须按滚动后的网格重算—— + // 否则视口滑过去了，选区还钉在原来那几行。两段各自取一次锁： + // `grid_point` 内部还要读 Term，握着锁进去会自锁。 + let (point, side) = self.grid_point(position); + if let Some(session) = &self.session + && let Some(selection) = session.term.lock().selection.as_mut() + { + selection.update(point, side); + } + cx.notify(); + true + } + /// 右键（旧壳 Windows 惯例）：有选区 → 复制并清除；无选区 → 粘贴。 /// 应用接管鼠标时上报给应用。 fn on_right_down( @@ -2401,6 +2588,8 @@ impl Render for TerminalView { .on_mouse_down(MouseButton::Middle, cx.listener(Self::on_middle_down)) .on_mouse_move(cx.listener(Self::on_mouse_move)) .on_mouse_up(MouseButton::Left, cx.listener(Self::on_mouse_up)) + // 拖出终端范围松手的兜底（含拖到窗口外）：见 `on_mouse_up_out`。 + .on_mouse_up_out(MouseButton::Left, cx.listener(Self::on_mouse_up_out)) .on_mouse_up(MouseButton::Right, cx.listener(Self::on_right_up)) .on_mouse_up(MouseButton::Middle, cx.listener(Self::on_middle_up)) .on_scroll_wheel(cx.listener(Self::on_scroll)) @@ -2459,7 +2648,30 @@ impl Render for TerminalView { mod tests { use gpui::{FontStyle, FontWeight}; - use super::{PASTE_CONFIRM_LINES, TerminalView, mono_font, paste_line_count}; + use super::{ + PASTE_CONFIRM_LINES, TerminalView, mono_font, paste_line_count, selection_scroll_lines, + }; + + /// 拖选自动回滚的判据（旧壳 `update_selection_scrolling` 的数值合同）： + /// 网格内不滚，越过上边界往回滚历史、越过下边界往前滚，贴边 1 行、每远离 + /// 20px 加一档，并且封顶在一屏——指针甩出窗口不该一抖到底。 + #[test] + fn selection_scroll_speed_scales_with_distance_past_the_grid() { + let (top, bottom, rows) = (100.0, 500.0, 30); + assert_eq!(selection_scroll_lines(300.0, top, bottom, rows), 0, "网格内不滚"); + assert_eq!(selection_scroll_lines(top, top, bottom, rows), 0, "上边界本身仍在网格内"); + assert_eq!(selection_scroll_lines(top - 1.0, top, bottom, rows), 1, "刚越界＝最慢一档"); + assert_eq!(selection_scroll_lines(top - 20.0, top, bottom, rows), 2); + assert_eq!(selection_scroll_lines(top - 40.0, top, bottom, rows), 3); + assert_eq!(selection_scroll_lines(bottom, top, bottom, rows), -1, "底边像素属于下方"); + assert_eq!(selection_scroll_lines(bottom + 20.0, top, bottom, rows), -2); + assert_eq!( + selection_scroll_lines(-10_000.0, top, bottom, rows), + rows, + "甩到屏幕外也每 tick 最多一屏" + ); + assert_eq!(selection_scroll_lines(10_000.0, top, bottom, rows), -rows); + } /// 行数判据数的是「落到终端算几行」，不是 `str::lines`：CRLF 一次换行、 /// 裸 CR 也是换行（`str::lines` 会把它整段算成 1 行）、末尾那个换行不多 diff --git a/nebula_app/src/gpui_shell/theme.rs b/nebula_app/src/gpui_shell/theme.rs index 082170a..4471c7a 100644 --- a/nebula_app/src/gpui_shell/theme.rs +++ b/nebula_app/src/gpui_shell/theme.rs @@ -272,6 +272,7 @@ pub(crate) struct CompletionColors { pub ghost: Hsla, pub panel_bg: Hsla, pub panel_border: Hsla, + pub panel_shadow: Hsla, pub row_bg: Hsla, pub row_fg: Hsla, pub tag_fg: Hsla, @@ -298,11 +299,12 @@ pub(crate) fn completion_colors(cx: &App, term_bg: GpuiRgba) -> CompletionColors ghost: ink(sk.ink_faint), panel_bg: row_bg, panel_border: accent.opacity(if sk.is_light { 0.28 } else { 0.34 }), + panel_shadow: hsla(0.0, 0.0, 0.0, if sk.is_light { 0.18 } else { 0.42 }), row_bg, row_fg: ink(sk.ink), tag_fg: ink(sk.ink_faint), selected_bg, - selected_fg: ink(sk.ink), + selected_fg: ink(sk.ink_strong), scroll_track: ink(sk.ink_faint).opacity(if sk.is_light { 0.24 } else { 0.32 }), scroll_thumb: ink(sk.ink_dim).opacity(if sk.is_light { 0.62 } else { 0.72 }), } @@ -332,10 +334,27 @@ pub fn apply_chrome_theme(cx: &mut App) { let mode = if chrome.skin().is_light { ThemeMode::Light } else { ThemeMode::Dark }; Theme::change(mode, None, cx); apply_skin_tokens(chrome, cx); + apply_shell_opacity(chrome, cx); +} - // 一体化外壳（对齐旧壳 draw_chrome）：窗口背景、侧栏、顶栏是同一块 - // 壳色，各自的分隔线取同色隐形；唯一的结构分界是内容区那张圆角卡。 - // 壳色带用户透明度（文字 token 不带——对比度不塌，旧壳裁定）。 +/// 只按当前不透明度重算壳色，不做别的。 +/// +/// 拖不透明度滑块的快路径：[`apply_chrome_theme`] 那一整套（读设置文件、 +/// 重建壁纸纹理、`Theme::change`、四十来个 token 重写、窗口级模糊）对"只改了 +/// alpha"这件事是纯浪费，而滑块一次拖拽会发几十上百个事件。2026-08-21 定案： +/// 拖拽走这里，落盘与整套热应用等停手之后。 +/// +/// 主题名由调用方传入：[`effective_theme_name`] 内部会 `RuntimeSettings::load()` +/// 读盘一次，那正是这条路径要避开的东西。设置页自己持有 `runtime` 镜像。 +pub fn reapply_shell_opacity(name: ThemeName, follow_system: bool, cx: &mut App) { + let chrome = chrome_theme(resolve_theme_name(name, follow_system, system_is_light(cx))); + apply_shell_opacity(chrome, cx); +} + +/// 一体化外壳（对齐旧壳 draw_chrome）：窗口背景、侧栏、顶栏是同一块 +/// 壳色，各自的分隔线取同色隐形；唯一的结构分界是内容区那张圆角卡。 +/// 壳色带用户透明度（文字 token 不带——对比度不塌，旧壳裁定）。 +fn apply_shell_opacity(chrome: NebulaTheme, cx: &mut App) { let opacity = crate::gpui_shell::wallpaper::chrome_surface_opacity(cx); let mut shell = shell_color(chrome); shell.a *= opacity; diff --git a/nebula_app/src/gpui_shell/wallpaper.rs b/nebula_app/src/gpui_shell/wallpaper.rs index df51429..285b052 100644 --- a/nebula_app/src/gpui_shell/wallpaper.rs +++ b/nebula_app/src/gpui_shell/wallpaper.rs @@ -139,6 +139,17 @@ pub fn window_opacity(cx: &App) -> f32 { cx.try_global::().map(|v| v.opacity).unwrap_or(1.0) } +/// 拖不透明度滑块的快路径：只把新值写进视效全局。 +/// +/// 不读设置文件、不重建壁纸纹理、不碰窗口级模糊——透明度只影响我们自己绘制的 +/// 像素 alpha 与壳色 token，那些都是纯浪费。调用方负责紧接着调 +/// [`crate::gpui_shell::theme::reapply_shell_opacity`] 与 `cx.notify()`。 +pub fn set_opacity_live(opacity: f32, cx: &mut App) { + if cx.has_global::() { + cx.global_mut::().opacity = opacity.clamp(0.0, 1.0); + } +} + /// 壳/卡透明度严格跟随用户滑块。模糊是独立的窗口背景外观属性，不能反向 /// 篡改透明度；否则打开模糊会把用户设置的 100% 偷改成 88%，与旧壳语义 /// 不一致。铺满 chrome 的壁纸仍沿用自己的可见性上限。 @@ -169,11 +180,21 @@ pub fn initial_background_appearance() -> WindowBackgroundAppearance { /// /// 旧壳（winit）用 `DwmSetWindowAttribute(DWMWA_SYSTEMBACKDROP_TYPE, /// DWMSBT_TRANSIENTWINDOW)` 三行就拿到 Acrylic。同一段代码搬到 GPUI 壳上 -/// 调用成功、画面零变化——**因为窗口的合成结构不同**：GPUI 只要没禁用 -/// DirectComposition 就给窗口加 `WS_EX_NOREDIRECTIONBITMAP` -/// （`gpui/src/platform/windows/window.rs`），DWM 因此不为它创建重定向 -/// 表面，system backdrop 材质没有挂载点，`DwmSetWindowAttribute` 返回 -/// `S_OK` 却什么都不画。旧壳是普通重定向窗口，才没这个问题。 +/// **比无效更糟**——2026-08-21 同窗对照实测（`opacity=0`、后方放高频视频画面）： +/// 写 `DWMSBT_TRANSIENTWINDOW` 后 `HRESULT=0`、属性能读回 3，但画面变成一块 +/// **不透明浅灰色板**，后方内容整块消失（既不透明也不模糊）；改回 +/// `DWMSBT_NONE` 并只写 AccentPolicy Acrylic，同一窗口立刻恢复真模糊。 +/// +/// 根因是合成结构不同：GPUI 只要没禁用 DirectComposition 就给窗口加 +/// `WS_EX_NOREDIRECTIONBITMAP`（`gpui/src/platform/windows/window.rs`），DWM +/// 不为它创建重定向表面，system backdrop 没有正确的挂载点。旧壳是普通重定向 +/// 窗口，才没这个问题。 +/// +/// 两条已被实测否决、不要再试的"修法"： +/// 1. 运行时 `SetWindowLongPtrW` 清掉 `WS_EX_NOREDIRECTIONBITMAP` 再配 +/// `SWP_FRAMECHANGED`——该样式在 `CreateWindowEx` 时就被 DWM 消费，事后改 +/// 不回来（实测调用后读回样式位仍然置位），窗口内容也仍走 DComp visual。 +/// 2. 用 system backdrop "替代" AccentPolicy——见上，结果是不透明色板。 /// /// 上游 Zed 走过同一条弯路：PR #41842 第一版把 `Blurred` 改成 /// `DWMSBT_TRANSIENTWINDOW`，第二版又改回 `SetWindowCompositionAttribute`， @@ -182,6 +203,13 @@ pub fn initial_background_appearance() -> WindowBackgroundAppearance { /// `ACCENT_ENABLE_ACRYLICBLURBEHIND`（且已处理 tint alpha 为 0 时 DWM 跳过 /// 模糊的坑），macOS / Linux 各自落到原生毛玻璃。一处开关，三平台生效， /// 不必碰 fork 也不必自写 FFI。 +/// +/// # 不透明度 100% 时看不到模糊是正交结果，不是失效 +/// +/// Acrylic 层在窗口内容**下方**。`opacity=1.00` 下我们画的像素完全不透明， +/// 模糊层被整块盖住——此时开关在画面上零变化是必然的。验收模糊必须先把 +/// 不透明度调到 100% 以下，否则任何实现都会被判成"没修复"。 + /// /// # 关闭时为什么是 `Opaque` 而不是 `Transparent` /// @@ -203,27 +231,83 @@ fn background_appearance(blur: bool) -> WindowBackgroundAppearance { } } +/// 已经真正落到窗口上的模糊态。拖不透明度滑块会每帧走一遍 [`refresh`]，而 +/// 窗口级模糊是**跨进程**调用（`SetWindowCompositionAttribute` 两次 + +/// `DwmSetWindowAttribute`）。不做门控就等于每帧和 DWM 往返三次，滑块直接 +/// 拖成幻灯片——2026-08-21 实测。模糊态没变时一次都不碰。 +struct AppliedBlur(bool); + +impl gpui::Global for AppliedBlur {} + /// 把窗口层效果应用到所有窗口。透明度完全由绘制像素 alpha 控制，因此模糊 /// 开关与 0%..100% 透明度互不绑死、无需跨帧时序补丁。 +/// +/// # 必须 `defer`：否则热切换整条链路静默失效 +/// +/// 设置页开关是在**某个窗口自己的 update 回调里**点的（点击 → `toggle` → +/// `persist` → `emit(Changed)` → `on_settings_event` → `apply_runtime_settings` +/// → `apply_chrome_theme` → [`refresh`] → 这里），此时该窗口已经被 +/// `App::update_window` 从 slot 里 take 出来（`gpui/src/app.rs`： +/// `cx.windows.get_mut(id)?.take()?`），对同一 handle 再 update 只会拿到 +/// `Err("window not found")`。 +/// +/// 2026-08-21 定案：这里原先写的是 `let _ = handle.update(..)`，把那个 Err 连同 +/// 整个 `set_background_appearance` 一起吞掉了——**启动时模糊有效（走 +/// `WindowOptions` 的 [`initial_background_appearance`]，不经过 update），运行中 +/// 点开关却完全没反应，且已经开着的 Acrylic 也关不掉**。这正是"关了还带模糊" +/// 和"不切换实时生效"的同一个根因；旧壳 winit 直接对 HWND 落 API，没有这层 +/// 借用模型，所以一直是丝滑的。 +/// +/// [`App::defer`] 把应用推到本轮 effect cycle 末尾，那时窗口已归还 slot。 +/// update 失败不再静默：留 warn，避免同一个坑第三次被当成"DWM 不生效"。 +/// +/// # 模糊态没变就直接返回 +/// +/// 不透明度/壁纸改动也会走到这里，但它们只影响我们自己绘制的像素，窗口级 +/// 模糊属性一个字节都不用改。透明度是滑块，一次拖拽几十上百个事件，所以这条 +/// 短路是拖拽手感的必要条件，不是可选优化。重绘由调用链上的 `cx.notify()` +/// 与主题重建负责。 fn apply_window_effects(cx: &mut App) { let blur = cx.try_global::().map(|v| v.blur).unwrap_or(false); - let appearance = background_appearance(blur); - for handle in cx.windows() { - let _ = handle.update(cx, |_, window, _| { - window.set_background_appearance(appearance); - #[cfg(windows)] - apply_windows_accent_policy(window, blur); - window.refresh(); - }); + if cx.try_global::().map(|applied| applied.0) == Some(blur) { + return; } + cx.set_global(AppliedBlur(blur)); + let appearance = background_appearance(blur); + cx.defer(move |cx| { + for handle in cx.windows() { + if let Err(err) = handle.update(cx, |_, window, _| { + window.set_background_appearance(appearance); + #[cfg(windows)] + apply_windows_accent_policy(window, blur); + window.refresh(); + }) { + log::warn!("failed to apply window visual effects: {err}"); + } + } + }); } -/// 明确落下 Windows AccentPolicy，并清掉可能残留的 system backdrop。 +/// 显式落下 Windows AccentPolicy，并把 system backdrop 钉死在 `DWMSBT_NONE`。 /// -/// 当前锁定的 GPUI 后端在关闭时写的是 `state=0, flags=2`。2026-08-20 -/// 实机探针证明 DWM 会因此保留已有 Acrylic；同一 HWND 改写为全零 policy 后 -/// 画面立即去模糊。这里仍先走 GPUI 的跨平台入口，再只在 Windows 对齐它本应 -/// 写入的精确字段：关闭 = 全零，开启 = Acrylic(state 4) + 非零 alpha。 +/// # 这段 FFI 保留的理由（不是因为 GPUI 关不掉） +/// +/// 2026-08-20 曾记录"GPUI 关闭时写 `state=0, flags=2`，DWM 会因此保留已有 +/// Acrylic"。**2026-08-21 同窗实测证伪**：在同一 HWND 上写 `state=0, flags=2` +/// 画面立刻恢复清晰，与全零 policy 无差别。也就是说 GPUI 上游两个方向本来都 +/// 正确（`Blurred` → state 4 且已把 tint alpha 0 修正成 1，`Opaque` → state 0）。 +/// +/// 保留这段的真实理由只有两条： +/// 1. **钉死 backdrop**：`DWMSBT_AUTO` 会把决定权交回系统，而 system backdrop +/// 在本壳的 DComp 窗口上表现为不透明色板（见 [`background_appearance`]）。 +/// 显式写 `DWMSBT_NONE` 保证不论系统默认如何，都不会冒出那块色板。 +/// 2. **对 pin 漂移的防御**：上游在 `Blurred` 该用 AccentPolicy 还是 DWM +/// backdrop 之间反复改过（PR #41842）。这里显式写下已实测生效的字段， +/// GPUI pin 升级后即使上游再摆回 backdrop，本壳行为也不变。 +/// +/// 因此本函数的字段必须与实测生效值一致：关闭 = 全零，开启 = Acrylic(state 4) +/// + 非零 alpha。**绝不要在这里写 `DWMSBT_TRANSIENTWINDOW` 或任何非 NONE 的 +/// system backdrop**——那正是 2026-08-21 那轮把模糊改成灰色色板的原因。 /// /// `SetWindowCompositionAttribute` 未进入公开 SDK，所以和 GPUI 上游一样动态取 /// 函数地址；`DWMSBT_NONE` 与 `DwmFlush` 则用公开 DWM API。任一步失败都留日志， @@ -232,7 +316,7 @@ fn apply_window_effects(cx: &mut App) { fn apply_windows_accent_policy(window: &Window, blur: bool) { use windows_sys::Win32::Foundation::{BOOL, HWND}; use windows_sys::Win32::Graphics::Dwm::{ - DWMSBT_NONE, DWMWA_SYSTEMBACKDROP_TYPE, DwmFlush, DwmSetWindowAttribute, + DWMSBT_NONE, DWMWA_SYSTEMBACKDROP_TYPE, DwmSetWindowAttribute, }; use windows_sys::Win32::System::LibraryLoader::{GetModuleHandleA, GetProcAddress}; use winit::raw_window_handle::{HasWindowHandle, RawWindowHandle}; @@ -282,7 +366,12 @@ fn apply_windows_accent_policy(window: &Window, blur: bool) { // SAFETY: hwnd 来自当前存活的 GPUI 窗口；DWM 属性值、AccentPolicy 与 // WCA 数据布局均与 Windows ABI/GPUI 后端一致。无效句柄由返回值安全报告。 - let (backdrop_result, accent_result, flush_result) = unsafe { + // + // 这里**不要**再调 `DwmFlush`：它会阻塞等待下一次 DWM 合成（一个 vsync， + // 约 8~16ms）。AccentPolicy 与 backdrop 的改动本来就在下一帧生效，配合 + // 调用方的 `window.refresh()` 已经即时；而 2026-08-21 实测，一旦这条路径 + // 被每帧走到（拖不透明度滑块），那次 flush 就把滑块拖成了幻灯片。 + let (backdrop_result, accent_result) = unsafe { let backdrop_result = DwmSetWindowAttribute( hwnd, DWMWA_SYSTEMBACKDROP_TYPE as u32, @@ -302,7 +391,7 @@ fn apply_windows_accent_policy(window: &Window, blur: bool) { }, ) }; - (backdrop_result, accent_result, DwmFlush()) + (backdrop_result, accent_result) }; if backdrop_result < 0 { log::warn!( @@ -315,9 +404,6 @@ fn apply_windows_accent_policy(window: &Window, blur: bool) { None => log::warn!("SetWindowCompositionAttribute is unavailable in user32.dll"), Some(_) => {}, } - if flush_result < 0 { - log::warn!("DwmFlush failed: HRESULT=0x{:08X}", flush_result as u32); - } } /// 解码壁纸：RGBA8 → 把图片透明度烘进 alpha → BGRA（gpui 图像帧的 diff --git a/nebula_app/src/gpui_shell/widgets.rs b/nebula_app/src/gpui_shell/widgets.rs index 27e98ae..2b143d3 100644 --- a/nebula_app/src/gpui_shell/widgets.rs +++ b/nebula_app/src/gpui_shell/widgets.rs @@ -14,10 +14,10 @@ use std::time::Duration; use gpui::prelude::FluentBuilder as _; use gpui::{ - Animation, AnimationExt as _, App, Bounds, ClickEvent, ElementId, Hsla, InteractiveElement as _, - IntoElement, ParentElement as _, RenderImage, RenderOnce, SharedString, - StatefulInteractiveElement as _, Styled as _, Window, canvas, div, ease_in_out, fill, point, px, - size, + Animation, AnimationExt as _, App, Bounds, ClickEvent, ElementId, Hsla, + InteractiveElement as _, IntoElement, ParentElement as _, RenderImage, RenderOnce, + SharedString, StatefulInteractiveElement as _, Styled as _, Window, canvas, div, ease_in_out, + fill, point, px, size, }; use image::Frame; @@ -253,7 +253,12 @@ impl RenderOnce for NebulaSwitch { ); let track = mix(sk.toggle_track_off, sk.toggle_track_on, motion.color); let track = over( - Rgba::new(sk.icon_hover.r, sk.icon_hover.g, sk.icon_hover.b, (motion.hover * 12.0) as u8), + Rgba::new( + sk.icon_hover.r, + sk.icon_hover.g, + sk.icon_hover.b, + (motion.hover * 12.0) as u8, + ), track, ); let knob = mix(sk.knob_off, sk.knob_on, motion.color); diff --git a/nebula_app/src/gpui_shell/workspace.rs b/nebula_app/src/gpui_shell/workspace.rs index e351c2c..70dc63a 100644 --- a/nebula_app/src/gpui_shell/workspace.rs +++ b/nebula_app/src/gpui_shell/workspace.rs @@ -54,9 +54,9 @@ mod top_tabs; use tab_drag::{TabDrag, TabDragAxis}; -use agents::{ai_session_palette_rows, restored_agent_command}; #[cfg(test)] use agents::ai_hook_target_pane; +use agents::{ai_session_palette_rows, restored_agent_command}; gpui::actions!( nebula_workspace, @@ -123,6 +123,7 @@ const STATIC_DEFAULT_COMBOS: &[&str] = &[ "ctrl--", "ctrl-0", "ctrl-shift-c", + "ctrl-v", "ctrl-shift-v", "alt-enter", "ctrl-shift-o", @@ -210,6 +211,7 @@ pub fn init(cx: &mut App) { KeyBinding::new("ctrl--", DecreaseFontSize, None), KeyBinding::new("ctrl-0", ResetFontSize, None), KeyBinding::new("ctrl-shift-c", CopySelection, None), + KeyBinding::new("ctrl-v", PasteClipboard, None), KeyBinding::new("ctrl-shift-v", PasteClipboard, None), KeyBinding::new("alt-enter", ToggleFullscreen, None), KeyBinding::new("ctrl-shift-o", OpenQuickJump, None), @@ -540,8 +542,8 @@ fn shell_palette_rows( } let ssh_icons = ssh_host_icon_ids(); rows.extend(ssh_hosts.into_iter().map(|host| { - let glyph = crate::display::ui::os_icons::resolve(ssh_icons.get(&host).map(String::as_str)) - .glyph; + let glyph = + crate::display::ui::os_icons::resolve(ssh_icons.get(&host).map(String::as_str)).glyph; WorkspacePaletteRow { group_order: 2, group: ssh_group.to_owned(), @@ -1245,6 +1247,63 @@ impl NebulaWorkspace { cx.notify(); } + /// 在同一 tab、同一分屏位置替换失败的 SSH pane。先把新实体及订阅完整 + /// 建好，再原子替换树叶和 pane 所有权；旧实体的异步泵只会更新旧 Entity， + /// 因而无法把迟到的 Failed/Ready 写进新连接。 + fn retry_ssh_pane( + &mut self, + tab_ix: usize, + pane_id: u64, + destination: String, + window: &mut Window, + cx: &mut Context, + ) { + let Some(WorkspaceTab::Terminal { panes, .. }) = self.tabs.get(tab_ix) else { return }; + let Some(old) = panes.iter().find(|pane| pane.id == pane_id) else { return }; + let grid = { + let view = old.view.read(cx); + if view.ssh_destination.as_deref() != Some(destination.as_str()) { + return; + } + (view.grid_cols() as u16, view.grid_rows() as u16) + }; + + let launch = crate::gpui_shell::terminal::view::TerminalLaunch::Ssh { + destination: destination.clone(), + }; + let replacement = self.new_pane(grid, launch, None, window, cx); + let replacement_id = replacement.id; + let old = { + let Some(WorkspaceTab::Terminal { panes, tree, focused, .. }) = + self.tabs.get_mut(tab_ix) + else { + replacement.view.read(cx).shutdown(); + return; + }; + let Some(index) = panes.iter().position(|pane| pane.id == pane_id) else { + replacement.view.read(cx).shutdown(); + return; + }; + if !tree.replace_leaf(pane_id, replacement_id) { + replacement.view.read(cx).shutdown(); + return; + } + if *focused == pane_id { + *focused = replacement_id; + } + std::mem::replace(&mut panes[index], replacement) + }; + + self.runtime_hub.record_pane_closed(self.runtime_window_id, pane_id); + self.pane_bounds.borrow_mut().remove(&pane_id); + old.view.read(cx).shutdown(); + if tab_ix == self.active { + self.focus_active(window, cx); + self.sync_side_panel_to_active(true, cx); + } + cx.notify(); + } + /// 在聚焦 pane 上开分屏（ctrl+shift+d / ctrl+shift+s，对齐旧壳 /// SplitRight/SplitDown）：新 pane 继承聚焦 pane 的 cwd，spawn 网格按 /// 切割方向对半预估——首帧 prepaint 回写真实矩形后自动收敛。 @@ -1634,9 +1693,10 @@ impl NebulaWorkspace { let pane = self.new_pane(grid, launch, command, window, cx); // 冷恢复已经知道这段对话的 hook 身份：种回 view，右键「分叉 // AI 会话」不必再等下一条带 session_id 的 hook。 - if let Some((source, session_id)) = agent.as_ref().and_then(|agent| { - Some((agent.source.clone(), agent.session_id.clone()?)) - }) { + if let Some((source, session_id)) = agent + .as_ref() + .and_then(|agent| Some((agent.source.clone(), agent.session_id.clone()?))) + { pane.view.update(cx, |view, cx| view.seed_ai_session(source, session_id, cx)); } panes.push(pane); @@ -1793,10 +1853,8 @@ impl NebulaWorkspace { window: &mut Window, cx: &mut Context, ) { - let is_markdown = path - .extension() - .and_then(|extension| extension.to_str()) - .is_some_and(|extension| { + let is_markdown = + path.extension().and_then(|extension| extension.to_str()).is_some_and(|extension| { matches!(extension.to_ascii_lowercase().as_str(), "md" | "markdown") }); if crate::display::image_viewer::viewable_file(&path) { @@ -1929,6 +1987,11 @@ impl NebulaWorkspace { self.request_close_pane(tab_ix, pane_id, window, cx); } }, + TerminalViewEvent::RetrySsh(destination) => { + if let Some((tab_ix, pane_id)) = self.locate_pane(view.entity_id()) { + self.retry_ssh_pane(tab_ix, pane_id, destination.clone(), window, cx); + } + }, TerminalViewEvent::FontSizeChanged => self.apply_runtime_settings(cx), TerminalViewEvent::Bell => { if let Some((tab_ix, _)) = self.locate_pane(view.entity_id()) @@ -2829,9 +2892,7 @@ impl NebulaWorkspace { .when(is_git_vcs, |button| button.icon(IconName::GitHub)) .small() .selected(git) - .when(git_count > 0, |button| { - button.label(format!("{vcs_name} {git_count}")) - }) + .when(git_count > 0, |button| button.label(format!("{vcs_name} {git_count}"))) .on_click(cx.listener(|this, _, _, cx| { this.select_side_panel_view(PanelView::Git, cx); })), @@ -3019,15 +3080,21 @@ impl NebulaWorkspace { .map(|button| { if discard_armed { button - .label(if svn_revert { "确认还原" } else { "确认丢弃" }) + .label(if svn_revert { + "确认还原" + } else { + "确认丢弃" + }) .danger() .xsmall() } else { - button - .icon(IconName::Undo2) - .ghost() - .xsmall() - .tooltip(if svn_revert { "还原 SVN 改动" } else { "丢弃改动" }) + button.icon(IconName::Undo2).ghost().xsmall().tooltip( + if svn_revert { + "还原 SVN 改动" + } else { + "丢弃改动" + }, + ) } }) .when(!discard_armed, |button| { @@ -3088,11 +3155,13 @@ impl NebulaWorkspace { .tooltip("添加到 SVN") .invisible() .group_hover(row_group.clone(), |button| button.visible()) - .on_click(cx.listener(move |this, _, _, cx| { - this.vcs_discard_confirm = None; - this.side_panel.svn_add_path(&svn_add_path); - cx.notify(); - })), + .on_click(cx.listener( + move |this, _, _, cx| { + this.vcs_discard_confirm = None; + this.side_panel.svn_add_path(&svn_add_path); + cx.notify(); + }, + )), ) }) .when(svn_resolve, |row| { @@ -3106,11 +3175,13 @@ impl NebulaWorkspace { .tooltip("保留当前内容并标记冲突已解决") .invisible() .group_hover(row_group.clone(), |button| button.visible()) - .on_click(cx.listener(move |this, _, _, cx| { - this.vcs_discard_confirm = None; - this.side_panel.svn_resolve_path(&resolve_path); - cx.notify(); - })), + .on_click(cx.listener( + move |this, _, _, cx| { + this.vcs_discard_confirm = None; + this.side_panel.svn_resolve_path(&resolve_path); + cx.notify(); + }, + )), ) }) .when(ops == RowOps::Staged, |row| { @@ -3138,9 +3209,7 @@ impl NebulaWorkspace { cx.notify(); })) .on_double_click(cx.listener(move |this, _, window, cx| { - if !svn_diff - || !this.side_panel.svn_diff_path(&diff_path) - { + if !svn_diff || !this.side_panel.svn_diff_path(&diff_path) { // Git 与未版本化 SVN 文件仍走现有文档路由。 this.open_document_path(open_path.clone(), window, cx); } @@ -3180,10 +3249,8 @@ impl NebulaWorkspace { }) }); - let repository_notice = git - .as_ref() - .filter(|info| info.vcs == VcsKind::SvnRepository) - .map(|info| { + let repository_notice = + git.as_ref().filter(|info| info.vcs == VcsKind::SvnRepository).map(|info| { let path = info .repository_root .as_ref() @@ -3210,24 +3277,21 @@ impl NebulaWorkspace { VcsKind::SvnRepository => false, }); let svn_add_ready = git.as_ref().is_some_and(|info| info.svn_add_ready()); - let commit_row = git - .as_ref() - .filter(|info| info.vcs != VcsKind::SvnRepository) - .map(|_| { - h_flex() - .gap_1() - .items_center() - .child(div().flex_1().min_w_0().child(Input::new(&self.git_commit_input))) - .child( - Button::new("vcs-commit") - .label("提交") - .small() - .disabled(!commit_ready) - .on_click(cx.listener(|this, _, window, cx| { - this.submit_vcs_commit(window, cx); - })), - ) - }); + let commit_row = git.as_ref().filter(|info| info.vcs != VcsKind::SvnRepository).map(|_| { + h_flex() + .gap_1() + .items_center() + .child(div().flex_1().min_w_0().child(Input::new(&self.git_commit_input))) + .child( + Button::new("vcs-commit") + .label("提交") + .small() + .disabled(!commit_ready) + .on_click(cx.listener(|this, _, window, cx| { + this.submit_vcs_commit(window, cx); + })), + ) + }); let action_strip = match vcs { Some(VcsKind::Git) => Some( h_flex() @@ -3295,14 +3359,12 @@ impl NebulaWorkspace { })), ) .child( - Button::new("svn-log") - .label("日志") - .small() - .disabled(op_running) - .on_click(cx.listener(|this, _, _, cx| { + Button::new("svn-log").label("日志").small().disabled(op_running).on_click( + cx.listener(|this, _, _, cx| { this.side_panel.svn_log(); cx.notify(); - })), + }), + ), ) .child( Button::new("svn-cleanup") @@ -3321,15 +3383,12 @@ impl NebulaWorkspace { h_flex() .gap_1() .items_center() - .child( - Button::new("svn-browse-repository") - .label("浏览仓库") - .small() - .on_click(cx.listener(|this, _, _, cx| { - this.side_panel.svn_browse_repository(); - cx.notify(); - })), - ) + .child(Button::new("svn-browse-repository").label("浏览仓库").small().on_click( + cx.listener(|this, _, _, cx| { + this.side_panel.svn_browse_repository(); + cx.notify(); + }), + )) .child( Button::new("svn-checkout-repository") .label("检出工作副本") @@ -3343,11 +3402,8 @@ impl NebulaWorkspace { ), None => None, }; - let vcs_label = if matches!(vcs, Some(VcsKind::Svn | VcsKind::SvnRepository)) { - "SVN" - } else { - "Git" - }; + let vcs_label = + if matches!(vcs, Some(VcsKind::Svn | VcsKind::SvnRepository)) { "SVN" } else { "Git" }; v_flex() .h_full() @@ -3638,7 +3694,6 @@ impl NebulaWorkspace { .detach(); } - /// Terminal tab 的内容区：单叶直渲、缩放态聚焦 pane 满卡，否则按 /// 分屏树递归铺陈。 fn render_terminal_tab(&self, tab_ix: usize, cx: &mut Context) -> gpui::AnyElement { @@ -3976,10 +4031,16 @@ impl Render for NebulaWorkspace { .on_mouse_move(cx.listener(|this, event, window, cx| { this.continue_pending_tab_drag(event, window, cx); })) - .on_mouse_up( - MouseButton::Left, - cx.listener(|this, _, window, cx| this.release_tab_drag(window, cx)), - ) + // 旧壳在窗口级 mouse-up 无条件结束 tab drag。这里必须走 capture： + // TerminalView 可能在 bubble phase 消费释放，导致 dock 永远不提交。 + .capture_any_mouse_up(cx.listener(|this, event: &gpui::MouseUpEvent, window, cx| { + if event.button == MouseButton::Left + && this.release_tab_drag_at(event.position, window, cx) + { + // 真拖拽已经完成，不能再让源 tab 的 click 或终端选择收到释放。 + cx.stop_propagation(); + } + })) .on_action(cx.listener(|this, _: &NewTerminal, window, cx| { this.add_terminal(window, cx); })) @@ -4056,7 +4117,11 @@ impl Render for NebulaWorkspace { this.bump_font_size(0.0, cx); })) .on_action(cx.listener(|this, _: &CopySelection, window, cx| { - this.copy_focused_terminal(window, cx); + if !this.copy_focused_terminal(window, cx) { + // Copy 是条件动作：无有效选区时继续派发原始 KeyDownEvent， + // 让 Ctrl+C 等自定义组合键按终端原义进入 PTY。 + cx.propagate(); + } })) .on_action(cx.listener(|this, _: &PasteClipboard, window, cx| { this.paste_focused_terminal(window, cx); diff --git a/nebula_app/src/gpui_shell/workspace/file_tree.rs b/nebula_app/src/gpui_shell/workspace/file_tree.rs index 0a0bb43..4eacac6 100644 --- a/nebula_app/src/gpui_shell/workspace/file_tree.rs +++ b/nebula_app/src/gpui_shell/workspace/file_tree.rs @@ -46,6 +46,9 @@ impl NebulaWorkspace { .map(|path| path.display().to_string()) .unwrap_or_else(|| "等待终端上报工作目录…".to_owned()); let rows: Vec<_> = self.side_panel.file_rows().iter().skip(scroll).cloned().collect(); + let rows_empty = rows.is_empty(); + let snapshot_pending = self.side_panel.snapshot_pending(); + let enumeration_failed = self.side_panel.enumeration_failed(); let row_elements = rows.into_iter().enumerate().map(|(visible_ix, row)| { let path = row.path.clone(); @@ -227,7 +230,32 @@ impl NebulaWorkspace { .flex_1() .min_h_0() .overflow_y_scrollbar() - .child(v_flex().w_full().gap_1().children(row_elements)), + .child( + v_flex() + .w_full() + .gap_1() + .children(row_elements) + .when(rows_empty, |list| { + list.child( + div() + .w_full() + .py_4() + .px_2() + .text_center() + .text_xs() + .text_color(muted) + .child(if snapshot_pending { + "正在读取目录…" + } else if enumeration_failed { + // 读不到 ≠ 目录是空的。WSL 冷启动可能 + // 耗尽预算，那时必须给可重试的提示。 + "读取目录失败，点上方刷新重试" + } else { + "此目录为空" + }), + ) + }), + ), ) .into_any_element() } diff --git a/nebula_app/src/gpui_shell/workspace/key_actions.rs b/nebula_app/src/gpui_shell/workspace/key_actions.rs index 2a17d81..cf922cc 100644 --- a/nebula_app/src/gpui_shell/workspace/key_actions.rs +++ b/nebula_app/src/gpui_shell/workspace/key_actions.rs @@ -38,10 +38,15 @@ impl NebulaWorkspace { self.apply_runtime_settings(cx); } - pub(super) fn copy_focused_terminal(&mut self, window: &mut Window, cx: &mut Context) { - if let Some(view) = self.tabs.get(self.active).and_then(WorkspaceTab::focused_view) { - view.update(cx, |view, cx| view.copy_selection(true, window, cx)); - } + pub(super) fn copy_focused_terminal( + &mut self, + window: &mut Window, + cx: &mut Context, + ) -> bool { + self.tabs + .get(self.active) + .and_then(WorkspaceTab::focused_view) + .is_some_and(|view| view.update(cx, |view, cx| view.copy_selection(true, window, cx))) } pub(super) fn paste_focused_terminal(&mut self, window: &mut Window, cx: &mut Context) { diff --git a/nebula_app/src/gpui_shell/workspace/residency.rs b/nebula_app/src/gpui_shell/workspace/residency.rs index 3b0e499..83ceb26 100644 --- a/nebula_app/src/gpui_shell/workspace/residency.rs +++ b/nebula_app/src/gpui_shell/workspace/residency.rs @@ -174,15 +174,50 @@ impl NebulaWorkspace { cx, ) }, - RuntimeCommand::Split { window_id, direction } => { + RuntimeCommand::Split { window_id, pane_id, direction } => { self.runtime_window_requested(*window_id)?; + let source_pane_id = match pane_id { + Some(pane_id) => { + let Some(tab_ix) = self.tab_of_pane(*pane_id) else { + return Err(ApiError::new( + "target_not_found", + format!("pane {pane_id} does not exist"), + )); + }; + self.active = tab_ix; + let Some(WorkspaceTab::Terminal { focused, zoomed, .. }) = + self.tabs.get_mut(tab_ix) + else { + return Err(ApiError::new( + "invalid_state", + "only terminal panes can be split", + )); + }; + *focused = *pane_id; + *zoomed = false; + *pane_id + }, + None => match self.tabs.get(self.active) { + Some(WorkspaceTab::Terminal { focused, .. }) => *focused, + _ => { + return Err(ApiError::new( + "invalid_state", + "the active tab is not a terminal tab", + )); + }, + }, + }; let direction = match direction { RuntimeSplitDirection::LeftRight => SplitDirection::LeftRight, RuntimeSplitDirection::TopBottom => SplitDirection::TopBottom, }; let pane_id = self.split_focused(direction, window, cx)?; self.runtime_result( - json!({ "window_id": self.runtime_window_id, "pane_id": pane_id }), + json!({ + "window_id": self.runtime_window_id, + "source_pane_id": source_pane_id, + "pane_id": pane_id + }), window, cx, ) @@ -316,6 +351,7 @@ impl NebulaWorkspace { }, RuntimeCommand::AgentStart { window_id, + pane_id, name, kind, cwd, @@ -325,7 +361,19 @@ impl NebulaWorkspace { } => { self.runtime_window_requested(*window_id)?; self.runtime_hub.ensure_agent_name_available(name)?; - let pane_id = self.add_terminal_at(cwd.clone(), None, window, cx); + let created_tab = pane_id.is_none(); + let pane_id = match pane_id { + Some(pane_id) => { + if self.tab_of_pane(*pane_id).is_none() { + return Err(ApiError::new( + "target_not_found", + format!("pane {pane_id} does not exist"), + )); + } + *pane_id + }, + None => self.add_terminal_at(cwd.clone(), None, window, cx), + }; let agent = match self.runtime_hub.register_agent( name.clone(), *kind, @@ -336,16 +384,20 @@ impl NebulaWorkspace { ) { Ok(agent) => agent, Err(error) => { - self.discard_runtime_agent_tab(pane_id, window, cx); + if created_tab { + self.discard_runtime_agent_tab(pane_id, window, cx); + } return Err(error); }, }; - if let Some(meta) = self.tab_meta.get_mut(self.active) { + if created_tab && let Some(meta) = self.tab_meta.get_mut(self.active) { meta.custom_name = Some(name.clone()); } let Some(tab_ix) = self.tab_of_pane(pane_id) else { self.runtime_hub.close_agent(&agent.agent_id, "launch_failed"); - self.discard_runtime_agent_tab(pane_id, window, cx); + if created_tab { + self.discard_runtime_agent_tab(pane_id, window, cx); + } return Err(ApiError::new( "action_failed", "the new agent pane was not registered in the workspace", @@ -364,7 +416,9 @@ impl NebulaWorkspace { view.update(cx, |view, cx| view.runtime_prompt(command.clone(), true, cx)) { self.runtime_hub.close_agent(&agent.agent_id, "launch_failed"); - self.discard_runtime_agent_tab(pane_id, window, cx); + if created_tab { + self.discard_runtime_agent_tab(pane_id, window, cx); + } return Err(error); } self.runtime_result( diff --git a/nebula_app/src/gpui_shell/workspace/tab_drag.rs b/nebula_app/src/gpui_shell/workspace/tab_drag.rs index 83f5cb9..04854e5 100644 --- a/nebula_app/src/gpui_shell/workspace/tab_drag.rs +++ b/nebula_app/src/gpui_shell/workspace/tab_drag.rs @@ -3,7 +3,7 @@ //! 左侧栏和顶部栏共享同一套存储顺序与 dock 语义；差别只有列表轴和每格 //! 步距，因此拖拽状态捕获这两个量，而不是复制两套状态机。 -use gpui::{Context, MouseButton, Window}; +use gpui::{Context, MouseButton, Pixels, Point, Window}; use nebula_split::{SplitNav, SplitTree}; use super::{NebulaWorkspace, TAB_DRAG_THRESHOLD, WorkspaceTab, dock_tree}; @@ -54,6 +54,24 @@ impl NebulaWorkspace { } } + /// 释放事件走 workspace 根节点的 capture phase，确保终端子元素即使吞掉 + /// bubble 事件，dock 仍能按松手位置完成。最后位置必须再算一次：激活 + /// overlay 需要下一帧，快速拖放可能没有任何一次 move 落到 overlay 上。 + pub(super) fn release_tab_drag_at( + &mut self, + position: Point, + window: &mut Window, + cx: &mut Context, + ) -> bool { + if self.tab_drag.is_none() { + return false; + } + self.update_tab_drag_position(f32::from(position.x), f32::from(position.y), cx); + let active = self.tab_drag.as_ref().is_some_and(|drag| drag.active); + self.release_tab_drag(window, cx); + active + } + /// 源下标加单轴位移换算出的整槽数；越过半格即换位。 pub(super) fn drag_slot(drag: &TabDrag, len: usize) -> usize { let slots = (drag.offset / drag.pitch.max(1.0)).round() as isize; @@ -73,15 +91,18 @@ impl NebulaWorkspace { self.finish_tab_drag(window, cx); return; } + self.update_tab_drag_position(f32::from(event.position.x), f32::from(event.position.y), cx); + } + + fn update_tab_drag_position(&mut self, x: f32, y: f32, cx: &mut Context) { let len = self.tabs.len(); // dock 必须在可变借用 drag 前计算；只有两个 Terminal tab 之间允许。 let source = self.tab_drag.as_ref().map(|drag| drag.source); - let dock = source.filter(|&source| self.dock_allowed(source)).and_then(|_| { - self.dock_nav_at(f32::from(event.position.x), f32::from(event.position.y)) - }); + let dock = + source.filter(|&source| self.dock_allowed(source)).and_then(|_| self.dock_nav_at(x, y)); let drag = self.tab_drag.as_mut().expect("checked above"); - let dx = f32::from(event.position.x) - drag.press_x; - let dy = f32::from(event.position.y) - drag.press_y; + let dx = x - drag.press_x; + let dy = y - drag.press_y; if !drag.active && (dy.abs() >= TAB_DRAG_THRESHOLD || dx.abs() >= TAB_DRAG_THRESHOLD) { drag.active = true; } diff --git a/nebula_app/src/gpui_shell/workspace/tab_scroll.rs b/nebula_app/src/gpui_shell/workspace/tab_scroll.rs index cc82268..daff0aa 100644 --- a/nebula_app/src/gpui_shell/workspace/tab_scroll.rs +++ b/nebula_app/src/gpui_shell/workspace/tab_scroll.rs @@ -1,394 +1,396 @@ -//! 侧栏 TABS 列表的整行滚动（旧壳 `chrome_tab_layout` + `nebula_tabs_scroll`）。 -//! -//! 标签多到超出侧栏剩余高度时，只画一个连续窗口，右侧贴覆盖式 thumb -//! （`overlay_scrollbar`）：不占行宽、不压状态徽章。滚轮按整行步进；thumb -//! 仅在列表悬停或拖拽时绘制。 - -use gpui::prelude::FluentBuilder as _; -use gpui::{ - AppContext as _, Bounds, Context, InteractiveElement as _, IntoElement as _, MouseButton, - MouseDownEvent, ParentElement as _, Pixels, Point, ScrollWheelEvent, - StatefulInteractiveElement as _, Styled as _, Window, canvas, div, px, -}; - -use crate::display::ui::widgets::{self, OverlayScrollbar}; -use crate::gpui_shell::prelude::*; - -use super::{NebulaWorkspace, TAB_ROW_H, TAB_ROW_PITCH}; - -/// 行间距（pitch − 行高）。旧壳 `gap = s(8)`。 -const TAB_ROW_GAP: f32 = TAB_ROW_PITCH - TAB_ROW_H; -/// 旧壳 `tab_right_pad`：给覆盖式滚动条留的恒定沟槽，出现与否都不改行宽。 +//! 侧栏 TABS 列表的整行滚动（旧壳 `chrome_tab_layout` + `nebula_tabs_scroll`）。 +//! +//! 标签多到超出侧栏剩余高度时，只画一个连续窗口，右侧贴覆盖式 thumb +//! （`overlay_scrollbar`）：不占行宽、不压状态徽章。滚轮按整行步进；thumb +//! 仅在列表悬停或拖拽时绘制。 + +use gpui::prelude::FluentBuilder as _; +use gpui::{ + AppContext as _, Bounds, Context, InteractiveElement as _, IntoElement as _, MouseButton, + MouseDownEvent, ParentElement as _, Pixels, Point, ScrollWheelEvent, + StatefulInteractiveElement as _, Styled as _, Window, canvas, div, px, +}; + +use crate::display::ui::widgets::{self, OverlayScrollbar}; +use crate::gpui_shell::prelude::*; + +use super::{NebulaWorkspace, TAB_ROW_H, TAB_ROW_PITCH}; + +/// 行间距（pitch − 行高）。旧壳 `gap = s(8)`。 +const TAB_ROW_GAP: f32 = TAB_ROW_PITCH - TAB_ROW_H; +/// 旧壳 `tab_right_pad`：给覆盖式滚动条留的恒定沟槽，出现与否都不改行宽。 pub(super) const TAB_SCROLL_GUTTER: f32 = 9.0; - -/// n 行占的高度：间距只在行之间，末行后面不留。 -pub(super) fn rows_h(n: usize, pitch: f32, gap: f32) -> f32 { - if n == 0 { 0.0 } else { n as f32 * pitch - gap } -} - -/// 视口里能放下几行。尚未量到高度时先展示全部，避免首帧空列表。 -/// -/// 与旧壳 `chrome_tab_layout` 同一条规则：不够一行就是 0，**绝不**退成 -/// 一行。折叠动画若把裁剪高度写回来，强制 1 行会把整列锁成一行滚动区。 -pub(super) fn visible_count(want: usize, avail_h: f32, pitch: f32, gap: f32) -> usize { - if want == 0 { - return 0; - } - if avail_h <= 1.0 { - return want; - } - let mut show = want; - while show > 0 && rows_h(show, pitch, gap) > avail_h + 0.5 { - show -= 1; - } - show -} - -pub(super) fn max_scroll(want: usize, show: usize) -> usize { - want.saturating_sub(show) -} - -pub(super) fn clamp_scroll(scroll: usize, max: usize) -> usize { - scroll.min(max) -} - -pub(super) fn index_visible(ix: usize, scroll: usize, show: usize) -> bool { - show > 0 && ix >= scroll && ix < scroll + show -} - -/// 激活项滚进窗口：在窗口上方则对齐窗口顶，在下方则对齐窗口底。 -pub(super) fn reveal_index(ix: usize, scroll: usize, show: usize) -> usize { - if show == 0 { - return 0; - } - if ix < scroll { - ix - } else if ix >= scroll + show { - ix + 1 - show - } else { - scroll - } -} - -/// 旧壳 `sidebar_wheel`：一次手势一行，符号与 winit 的 `-signum` 一致。 -pub(super) fn wheel_rows(delta_y: f32) -> i32 { - if delta_y > 0.0 { - -1 - } else if delta_y < 0.0 { - 1 - } else { - 0 - } -} - -pub(super) fn apply_wheel(scroll: usize, max: usize, rows: i32) -> usize { - (scroll as i32 + rows).clamp(0, max as i32) as usize -} - -fn point_in_rect((rx, ry, rw, rh): (f32, f32, f32, f32), x: f32, y: f32) -> bool { - x >= rx && y >= ry && x < rx + rw && y < ry + rh -} - -struct TabsWindow { - scroll: usize, - show: usize, - max: usize, - want: usize, -} - -impl NebulaWorkspace { - fn tabs_window(&self) -> TabsWindow { - let want = self.tabs.len(); - let show = visible_count(want, self.tabs_viewport_h, TAB_ROW_PITCH, TAB_ROW_GAP); - let max = max_scroll(want, show); - let scroll = clamp_scroll(self.tabs_scroll, max); - TabsWindow { scroll, show, max, want } - } - - pub(super) fn tabs_visible_window(&self) -> (usize, usize) { - let window = self.tabs_window(); - (window.scroll, window.show) - } - - pub(super) fn clamp_tabs_scroll(&mut self) { - let max = self.tabs_window().max; - let next = clamp_scroll(self.tabs_scroll, max); - if next != self.tabs_scroll { - self.tabs_scroll = next; - } - } - + +/// n 行占的高度：间距只在行之间，末行后面不留。 +pub(super) fn rows_h(n: usize, pitch: f32, gap: f32) -> f32 { + if n == 0 { 0.0 } else { n as f32 * pitch - gap } +} + +/// 视口里能放下几行。尚未量到高度时先展示全部，避免首帧空列表。 +/// +/// 与旧壳 `chrome_tab_layout` 同一条规则：不够一行就是 0，**绝不**退成 +/// 一行。折叠动画若把裁剪高度写回来，强制 1 行会把整列锁成一行滚动区。 +pub(super) fn visible_count(want: usize, avail_h: f32, pitch: f32, gap: f32) -> usize { + if want == 0 { + return 0; + } + if avail_h <= 1.0 { + return want; + } + let mut show = want; + while show > 0 && rows_h(show, pitch, gap) > avail_h + 0.5 { + show -= 1; + } + show +} + +pub(super) fn max_scroll(want: usize, show: usize) -> usize { + want.saturating_sub(show) +} + +pub(super) fn clamp_scroll(scroll: usize, max: usize) -> usize { + scroll.min(max) +} + +pub(super) fn index_visible(ix: usize, scroll: usize, show: usize) -> bool { + show > 0 && ix >= scroll && ix < scroll + show +} + +/// 激活项滚进窗口：在窗口上方则对齐窗口顶，在下方则对齐窗口底。 +pub(super) fn reveal_index(ix: usize, scroll: usize, show: usize) -> usize { + if show == 0 { + return 0; + } + if ix < scroll { + ix + } else if ix >= scroll + show { + ix + 1 - show + } else { + scroll + } +} + +/// 旧壳 `sidebar_wheel`：一次手势一行，符号与 winit 的 `-signum` 一致。 +pub(super) fn wheel_rows(delta_y: f32) -> i32 { + if delta_y > 0.0 { + -1 + } else if delta_y < 0.0 { + 1 + } else { + 0 + } +} + +pub(super) fn apply_wheel(scroll: usize, max: usize, rows: i32) -> usize { + (scroll as i32 + rows).clamp(0, max as i32) as usize +} + +fn point_in_rect((rx, ry, rw, rh): (f32, f32, f32, f32), x: f32, y: f32) -> bool { + x >= rx && y >= ry && x < rx + rw && y < ry + rh +} + +struct TabsWindow { + scroll: usize, + show: usize, + max: usize, + want: usize, +} + +impl NebulaWorkspace { + fn tabs_window(&self) -> TabsWindow { + let want = self.tabs.len(); + let show = visible_count(want, self.tabs_viewport_h, TAB_ROW_PITCH, TAB_ROW_GAP); + let max = max_scroll(want, show); + let scroll = clamp_scroll(self.tabs_scroll, max); + TabsWindow { scroll, show, max, want } + } + + pub(super) fn tabs_visible_window(&self) -> (usize, usize) { + let window = self.tabs_window(); + (window.scroll, window.show) + } + + pub(super) fn clamp_tabs_scroll(&mut self) { + let max = self.tabs_window().max; + let next = clamp_scroll(self.tabs_scroll, max); + if next != self.tabs_scroll { + self.tabs_scroll = next; + } + } + pub(super) fn reveal_active_tab(&mut self) { let window = self.tabs_window(); let next = reveal_index(self.active, window.scroll, window.show); self.tabs_scroll = clamp_scroll(next, window.max); self.top_tabs_scroll.scroll_to_item(self.active); } - - fn tabs_overlay_bar(&self) -> Option { - if self.tabs_section_collapsed { - return None; - } - let window = self.tabs_window(); - if window.show == 0 || window.want <= window.show { - return None; - } - let viewport = rows_h(window.show, TAB_ROW_PITCH, TAB_ROW_GAP).max(1.0); - let content = rows_h(window.want, TAB_ROW_PITCH, TAB_ROW_GAP); - let width = self.tabs_list_width.max(1.0); - let height = self.tabs_viewport_h.max(viewport); - widgets::overlay_scrollbar( - (0.0, 0.0, width, height), - viewport, - content, - window.scroll as f32 * TAB_ROW_PITCH, - 1.0, - ) - } - - fn local_tabs_point(&self, position: Point) -> (f32, f32) { - (f32::from(position.x - self.tabs_list_origin.x), f32::from(position.y - self.tabs_list_origin.y)) - } - - fn press_tabs_scrollbar(&mut self, event: &MouseDownEvent) -> bool { - let Some(bar) = self.tabs_overlay_bar() else { return false }; - let (x, y) = self.local_tabs_point(event.position); - if !bar.hit_test(x, y) { - return false; - } - let grab = if point_in_rect(bar.thumb, x, y) { - y - bar.thumb.1 - } else { - bar.thumb.3 * 0.5 - }; - self.tabs_scroll_grab = Some(grab); - self.tabs_scroll = bar.target_offset(y, grab, self.tabs_window().max); - true - } - - fn drag_tabs_scrollbar_to(&mut self, position: Point) -> bool { - let Some(grab) = self.tabs_scroll_grab else { return false }; - let Some(bar) = self.tabs_overlay_bar() else { return false }; - let (_, y) = self.local_tabs_point(position); - let next = bar.target_offset(y, grab, self.tabs_window().max); - if next == self.tabs_scroll { - return false; - } - self.tabs_scroll = next; - true - } - - fn end_tabs_scrollbar_drag(&mut self) -> bool { - self.tabs_scroll_grab.take().is_some() - } - - fn on_tabs_wheel( - &mut self, - event: &ScrollWheelEvent, - _window: &mut Window, - cx: &mut Context, - ) { - let delta_y = f32::from(event.delta.pixel_delta(px(TAB_ROW_PITCH)).y); - let rows = wheel_rows(delta_y); - if rows == 0 { - return; - } - let max = self.tabs_window().max; - let next = apply_wheel(self.tabs_scroll, max, rows); - if next != self.tabs_scroll { - self.tabs_scroll = next; - cx.notify(); - } - cx.stop_propagation(); - } - - /// 列表槽：恒定右沟槽 + 覆盖 thumb + 滚轮。`items` 已是可见窗口。 - pub(super) fn wrap_tabs_scroll_list( - &self, - items: impl IntoIterator, - cx: &mut Context, - ) -> gpui::AnyElement { - let bar = self.tabs_overlay_bar(); - let dragging = self.tabs_scroll_grab.is_some(); - let show_thumb = bar.is_some() && (self.tabs_list_hot || dragging); - let workspace = cx.entity().downgrade(); - let thumb_color = { - let theme = cx.theme(); - let alpha = if dragging { - 0.78 - } else if self.tabs_list_hot { - 0.64 - } else { - 0.46 - }; - theme.scrollbar_thumb.opacity(alpha) - }; - - div() - .id("sidebar-tabs-list") - .flex_1() - .w_full() - .min_h_0() - .relative() - .overflow_hidden() - .pr(px(TAB_SCROLL_GUTTER)) - .on_scroll_wheel(cx.listener(Self::on_tabs_wheel)) - .on_hover(cx.listener(|this, hovered: &bool, _, cx| { - if this.tabs_list_hot != *hovered { - this.tabs_list_hot = *hovered; - cx.notify(); - } - })) - .child( - canvas( - move |bounds, _, cx| { - let _ = workspace.update(cx, |this, cx| { - this.remember_tabs_list_bounds(bounds, cx); - }); - }, - |_, _, _, _| {}, - ) - .absolute() - .size_full(), - ) - .child(v_flex().w_full().gap_2().children(items)) - .when_some(bar.filter(|_| show_thumb), |list, bar| { - list.child( - div() - .absolute() - .left(px(bar.thumb.0)) - .top(px(bar.thumb.1)) - .w(px(bar.thumb.2)) - .h(px(bar.thumb.3)) - .rounded_full() - .bg(thumb_color) - .occlude(), - ) - }) - .when_some(bar, |list, bar| { - list.child( - div() - .id("sidebar-tabs-scrollbar") - .absolute() - .left(px(bar.hit.0)) - .top(px(bar.hit.1)) - .w(px(bar.hit.2)) - .h(px(bar.hit.3)) - .cursor_pointer() - .on_mouse_down( - MouseButton::Left, - cx.listener(|this, event: &MouseDownEvent, _, cx| { - if this.press_tabs_scrollbar(event) { - cx.stop_propagation(); - cx.notify(); - } - }), - ), - ) - }) - .into_any_element() - } - - fn remember_tabs_list_bounds(&mut self, bounds: Bounds, cx: &mut Context) { - let h = f32::from(bounds.size.height); - let w = f32::from(bounds.size.width); - let origin = bounds.origin; - let height_changed = (self.tabs_viewport_h - h).abs() > 0.5; - let width_changed = (self.tabs_list_width - w).abs() > 0.5; - self.tabs_list_origin = origin; - if !height_changed && !width_changed { - return; - } - // 折叠中/已折叠：裁剪高度不是 `tabs_avail`。写回去会让 - // `visible_count` 按 20–40px 算出 0/1 行，展开后整列锁死。 - if !self.tabs_section_collapsed && !self.tabs_fold_frozen && h >= TAB_ROW_H { - self.tabs_viewport_h = h; - } - self.tabs_list_width = w; - self.clamp_tabs_scroll(); - cx.notify(); - } - - pub(super) fn tabs_scrollbar_drag_overlay( - &self, - cx: &mut Context, - ) -> Option { - if self.tabs_scroll_grab.is_none() { - return None; - } - Some( - div() - .absolute() - .inset_0() - .occlude() - .on_mouse_move(cx.listener(|this, event: &gpui::MouseMoveEvent, _, cx| { - if this.drag_tabs_scrollbar_to(event.position) { - cx.notify(); - } - })) - .on_mouse_up( - MouseButton::Left, - cx.listener(|this, _, _, cx| { - if this.end_tabs_scrollbar_drag() { - cx.notify(); - } - }), - ) - .into_any_element(), - ) - } -} - -#[cfg(test)] -mod tests { - use super::{apply_wheel, clamp_scroll, index_visible, max_scroll, reveal_index, rows_h, visible_count, wheel_rows}; - - const PITCH: f32 = 42.0; - const GAP: f32 = 8.0; - - #[test] - fn row_height_drops_the_trailing_gap() { - assert_eq!(rows_h(0, PITCH, GAP), 0.0); - assert_eq!(rows_h(1, PITCH, GAP), 34.0); - assert_eq!(rows_h(3, PITCH, GAP), 3.0 * PITCH - GAP); - } - - #[test] - fn visible_count_fits_whole_rows_into_the_band() { - // 100px 放下 2 行（76px），放不下 3 行（118px）。 - assert_eq!(visible_count(10, 100.0, PITCH, GAP), 2); - assert_eq!(visible_count(2, 100.0, PITCH, GAP), 2); - assert_eq!(visible_count(10, 0.0, PITCH, GAP), 10); - assert_eq!(visible_count(0, 100.0, PITCH, GAP), 0); - // 旧壳：不够一行就是 0，不能退成「一行滚动区」。 - assert_eq!(visible_count(10, 20.0, PITCH, GAP), 0); - } - - #[test] - fn scrollbar_only_exists_when_the_window_overflows() { - assert_eq!(max_scroll(10, 10), 0); - assert_eq!(max_scroll(10, 3), 7); - assert_eq!(clamp_scroll(9, 7), 7); - assert!(!index_visible(0, 2, 3)); - assert!(index_visible(2, 2, 3)); - assert!(index_visible(4, 2, 3)); - assert!(!index_visible(5, 2, 3)); - } - - #[test] - fn activating_a_scrolled_out_tab_moves_the_window() { - assert_eq!(reveal_index(0, 2, 3), 0); - assert_eq!(reveal_index(3, 2, 3), 2); - assert_eq!(reveal_index(9, 0, 3), 7); - } - - #[test] - fn wheel_steps_one_row_and_clamps() { - assert_eq!(wheel_rows(12.0), -1); - assert_eq!(wheel_rows(-3.0), 1); - assert_eq!(wheel_rows(0.0), 0); - assert_eq!(apply_wheel(0, 5, -1), 0); - assert_eq!(apply_wheel(5, 5, 1), 5); - assert_eq!(apply_wheel(2, 5, 1), 3); - } -} + + fn tabs_overlay_bar(&self) -> Option { + if self.tabs_section_collapsed { + return None; + } + let window = self.tabs_window(); + if window.show == 0 || window.want <= window.show { + return None; + } + let viewport = rows_h(window.show, TAB_ROW_PITCH, TAB_ROW_GAP).max(1.0); + let content = rows_h(window.want, TAB_ROW_PITCH, TAB_ROW_GAP); + let width = self.tabs_list_width.max(1.0); + let height = self.tabs_viewport_h.max(viewport); + widgets::overlay_scrollbar( + (0.0, 0.0, width, height), + viewport, + content, + window.scroll as f32 * TAB_ROW_PITCH, + 1.0, + ) + } + + fn local_tabs_point(&self, position: Point) -> (f32, f32) { + ( + f32::from(position.x - self.tabs_list_origin.x), + f32::from(position.y - self.tabs_list_origin.y), + ) + } + + fn press_tabs_scrollbar(&mut self, event: &MouseDownEvent) -> bool { + let Some(bar) = self.tabs_overlay_bar() else { return false }; + let (x, y) = self.local_tabs_point(event.position); + if !bar.hit_test(x, y) { + return false; + } + let grab = if point_in_rect(bar.thumb, x, y) { y - bar.thumb.1 } else { bar.thumb.3 * 0.5 }; + self.tabs_scroll_grab = Some(grab); + self.tabs_scroll = bar.target_offset(y, grab, self.tabs_window().max); + true + } + + fn drag_tabs_scrollbar_to(&mut self, position: Point) -> bool { + let Some(grab) = self.tabs_scroll_grab else { return false }; + let Some(bar) = self.tabs_overlay_bar() else { return false }; + let (_, y) = self.local_tabs_point(position); + let next = bar.target_offset(y, grab, self.tabs_window().max); + if next == self.tabs_scroll { + return false; + } + self.tabs_scroll = next; + true + } + + fn end_tabs_scrollbar_drag(&mut self) -> bool { + self.tabs_scroll_grab.take().is_some() + } + + fn on_tabs_wheel( + &mut self, + event: &ScrollWheelEvent, + _window: &mut Window, + cx: &mut Context, + ) { + let delta_y = f32::from(event.delta.pixel_delta(px(TAB_ROW_PITCH)).y); + let rows = wheel_rows(delta_y); + if rows == 0 { + return; + } + let max = self.tabs_window().max; + let next = apply_wheel(self.tabs_scroll, max, rows); + if next != self.tabs_scroll { + self.tabs_scroll = next; + cx.notify(); + } + cx.stop_propagation(); + } + + /// 列表槽：恒定右沟槽 + 覆盖 thumb + 滚轮。`items` 已是可见窗口。 + pub(super) fn wrap_tabs_scroll_list( + &self, + items: impl IntoIterator, + cx: &mut Context, + ) -> gpui::AnyElement { + let bar = self.tabs_overlay_bar(); + let dragging = self.tabs_scroll_grab.is_some(); + let show_thumb = bar.is_some() && (self.tabs_list_hot || dragging); + let workspace = cx.entity().downgrade(); + let thumb_color = { + let theme = cx.theme(); + let alpha = if dragging { + 0.78 + } else if self.tabs_list_hot { + 0.64 + } else { + 0.46 + }; + theme.scrollbar_thumb.opacity(alpha) + }; + + div() + .id("sidebar-tabs-list") + .flex_1() + .w_full() + .min_h_0() + .relative() + .overflow_hidden() + .pr(px(TAB_SCROLL_GUTTER)) + .on_scroll_wheel(cx.listener(Self::on_tabs_wheel)) + .on_hover(cx.listener(|this, hovered: &bool, _, cx| { + if this.tabs_list_hot != *hovered { + this.tabs_list_hot = *hovered; + cx.notify(); + } + })) + .child( + canvas( + move |bounds, _, cx| { + let _ = workspace.update(cx, |this, cx| { + this.remember_tabs_list_bounds(bounds, cx); + }); + }, + |_, _, _, _| {}, + ) + .absolute() + .size_full(), + ) + .child(v_flex().w_full().gap_2().children(items)) + .when_some(bar.filter(|_| show_thumb), |list, bar| { + list.child( + div() + .absolute() + .left(px(bar.thumb.0)) + .top(px(bar.thumb.1)) + .w(px(bar.thumb.2)) + .h(px(bar.thumb.3)) + .rounded_full() + .bg(thumb_color) + .occlude(), + ) + }) + .when_some(bar, |list, bar| { + list.child( + div() + .id("sidebar-tabs-scrollbar") + .absolute() + .left(px(bar.hit.0)) + .top(px(bar.hit.1)) + .w(px(bar.hit.2)) + .h(px(bar.hit.3)) + .cursor_pointer() + .on_mouse_down( + MouseButton::Left, + cx.listener(|this, event: &MouseDownEvent, _, cx| { + if this.press_tabs_scrollbar(event) { + cx.stop_propagation(); + cx.notify(); + } + }), + ), + ) + }) + .into_any_element() + } + + fn remember_tabs_list_bounds(&mut self, bounds: Bounds, cx: &mut Context) { + let h = f32::from(bounds.size.height); + let w = f32::from(bounds.size.width); + let origin = bounds.origin; + let height_changed = (self.tabs_viewport_h - h).abs() > 0.5; + let width_changed = (self.tabs_list_width - w).abs() > 0.5; + self.tabs_list_origin = origin; + if !height_changed && !width_changed { + return; + } + // 折叠中/已折叠：裁剪高度不是 `tabs_avail`。写回去会让 + // `visible_count` 按 20–40px 算出 0/1 行，展开后整列锁死。 + if !self.tabs_section_collapsed && !self.tabs_fold_frozen && h >= TAB_ROW_H { + self.tabs_viewport_h = h; + } + self.tabs_list_width = w; + self.clamp_tabs_scroll(); + cx.notify(); + } + + pub(super) fn tabs_scrollbar_drag_overlay( + &self, + cx: &mut Context, + ) -> Option { + if self.tabs_scroll_grab.is_none() { + return None; + } + Some( + div() + .absolute() + .inset_0() + .occlude() + .on_mouse_move(cx.listener(|this, event: &gpui::MouseMoveEvent, _, cx| { + if this.drag_tabs_scrollbar_to(event.position) { + cx.notify(); + } + })) + .on_mouse_up( + MouseButton::Left, + cx.listener(|this, _, _, cx| { + if this.end_tabs_scrollbar_drag() { + cx.notify(); + } + }), + ) + .into_any_element(), + ) + } +} + +#[cfg(test)] +mod tests { + use super::{ + apply_wheel, clamp_scroll, index_visible, max_scroll, reveal_index, rows_h, visible_count, + wheel_rows, + }; + + const PITCH: f32 = 42.0; + const GAP: f32 = 8.0; + + #[test] + fn row_height_drops_the_trailing_gap() { + assert_eq!(rows_h(0, PITCH, GAP), 0.0); + assert_eq!(rows_h(1, PITCH, GAP), 34.0); + assert_eq!(rows_h(3, PITCH, GAP), 3.0 * PITCH - GAP); + } + + #[test] + fn visible_count_fits_whole_rows_into_the_band() { + // 100px 放下 2 行（76px），放不下 3 行（118px）。 + assert_eq!(visible_count(10, 100.0, PITCH, GAP), 2); + assert_eq!(visible_count(2, 100.0, PITCH, GAP), 2); + assert_eq!(visible_count(10, 0.0, PITCH, GAP), 10); + assert_eq!(visible_count(0, 100.0, PITCH, GAP), 0); + // 旧壳：不够一行就是 0，不能退成「一行滚动区」。 + assert_eq!(visible_count(10, 20.0, PITCH, GAP), 0); + } + + #[test] + fn scrollbar_only_exists_when_the_window_overflows() { + assert_eq!(max_scroll(10, 10), 0); + assert_eq!(max_scroll(10, 3), 7); + assert_eq!(clamp_scroll(9, 7), 7); + assert!(!index_visible(0, 2, 3)); + assert!(index_visible(2, 2, 3)); + assert!(index_visible(4, 2, 3)); + assert!(!index_visible(5, 2, 3)); + } + + #[test] + fn activating_a_scrolled_out_tab_moves_the_window() { + assert_eq!(reveal_index(0, 2, 3), 0); + assert_eq!(reveal_index(3, 2, 3), 2); + assert_eq!(reveal_index(9, 0, 3), 7); + } + + #[test] + fn wheel_steps_one_row_and_clamps() { + assert_eq!(wheel_rows(12.0), -1); + assert_eq!(wheel_rows(-3.0), 1); + assert_eq!(wheel_rows(0.0), 0); + assert_eq!(apply_wheel(0, 5, -1), 0); + assert_eq!(apply_wheel(5, 5, 1), 5); + assert_eq!(apply_wheel(2, 5, 1), 3); + } +} diff --git a/nebula_app/src/gpui_shell/workspace/tests.rs b/nebula_app/src/gpui_shell/workspace/tests.rs index 01e156c..7658302 100644 --- a/nebula_app/src/gpui_shell/workspace/tests.rs +++ b/nebula_app/src/gpui_shell/workspace/tests.rs @@ -236,10 +236,7 @@ fn tab_chrome_commit_empty_clears_custom_name() { /// 旧壳 CancelRename：丢掉缓冲，custom_name 原样保留（含启动时写入的「分叉」）。 #[test] fn tab_chrome_cancel_leaves_custom_name() { - let mut named = TabMeta { - custom_name: Some("Claude 分叉".to_owned()), - ..TabMeta::default() - }; + let mut named = TabMeta { custom_name: Some("Claude 分叉".to_owned()), ..TabMeta::default() }; apply_cancel_rename(&mut named); assert_eq!(named.custom_name.as_deref(), Some("Claude 分叉")); diff --git a/nebula_app/src/input/chrome.rs b/nebula_app/src/input/chrome.rs index d2fe975..1623e5d 100644 --- a/nebula_app/src/input/chrome.rs +++ b/nebula_app/src/input/chrome.rs @@ -441,6 +441,15 @@ impl> Processor { self.ctx.display().ssh_connect_toggle_logs(); self.ctx.mark_dirty(); }, + SshConnectHit::Retry => { + if let Some(destination) = + self.ctx.display().ssh_connect_destination() + { + self.ctx.nebula_tab(crate::event::TabRequest::RetrySsh( + destination, + )); + } + }, // 取消与关闭是同一个动作：这个 pane 除了这条连接 // 没有别的内容，留着它没有意义。 SshConnectHit::Cancel | SshConnectHit::Close => { @@ -899,9 +908,9 @@ impl> Processor { return; }, crate::display::SettingsHit::BackupProtocolCycle => { - self.ctx - .display() - .toggle_settings_dropdown(crate::display::SettingsDropdown::BackupProtocol); + self.ctx.display().toggle_settings_dropdown( + crate::display::SettingsDropdown::BackupProtocol, + ); self.ctx.mark_dirty(); return; }, @@ -1361,16 +1370,20 @@ impl> Processor { return; }, crate::display::SettingsHit::BackgroundSvPlane => { - self.ctx - .display() - .begin_bg_picker_drag(crate::display::BgPickerPart::Sv, x, y); + self.ctx.display().begin_bg_picker_drag( + crate::display::BgPickerPart::Sv, + x, + y, + ); self.ctx.mark_dirty(); return; }, crate::display::SettingsHit::BackgroundHueBar => { - self.ctx - .display() - .begin_bg_picker_drag(crate::display::BgPickerPart::Hue, x, y); + self.ctx.display().begin_bg_picker_drag( + crate::display::BgPickerPart::Hue, + x, + y, + ); self.ctx.mark_dirty(); return; }, diff --git a/nebula_app/src/input/keyboard.rs b/nebula_app/src/input/keyboard.rs index 205209a..29b70aa 100644 --- a/nebula_app/src/input/keyboard.rs +++ b/nebula_app/src/input/keyboard.rs @@ -986,13 +986,13 @@ impl> Processor { // `nebula_settings.txt` `keybind=` overrides + TOML remaps all funnel // through `process_key_bindings` below (spec 002). - // 弹窗补齐：列表可见时接管上下键（选行）、接受键（按 accept 配置的 - // Tab/Right 键入选中候选的余量）和 Esc（关闭）。其余按键穿透——字符 - // 照常进 shell 并触发重算，Enter 照常执行当前行。列表关闭后按键立即 - // 恢复原义（上下键回到 shell 历史）。 + // 弹窗补齐：出现时先保持空选中，Enter 因而提交用户实际输入；只有用户 + // 用 Up/Down/Tab 主动进入列表后，Enter/Right 才接受候选。列表关闭后 + // 按键立即恢复原义（上下键回到 shell 历史）。 let accept = self.ctx.nebula_accept(); + let popup_active = self.ctx.nebula_completion_popup_active(); if mods.is_empty() - && self.ctx.nebula_completion_popup_active() + && popup_active && !self.ctx.display().hint_state.active() && !self.ctx.search_active() { @@ -1005,13 +1005,17 @@ impl> Processor { self.ctx.nebula_completion_popup_move(-1); return; }, + Key::Named(NamedKey::Tab) => { + self.ctx.nebula_completion_popup_move(1); + return; + }, Key::Named(NamedKey::Escape) => { if self.ctx.nebula_completion_popup_dismiss() { return; } false }, - Key::Named(NamedKey::Tab) => accept.accepts_tab(), + Key::Named(NamedKey::Enter) => true, Key::Named(NamedKey::ArrowRight) => accept.accepts_right(), _ => false, }; @@ -1022,8 +1026,8 @@ impl> Processor { self.ctx.nebula_input_char(c); } self.ctx.write_to_pty(insert.into_bytes()); - return; } + return; } } } diff --git a/nebula_app/src/main.rs b/nebula_app/src/main.rs index 5322a39..4d44e8a 100644 --- a/nebula_app/src/main.rs +++ b/nebula_app/src/main.rs @@ -27,8 +27,8 @@ use winit::raw_window_handle::{HasDisplayHandle, RawDisplayHandle}; use nebula_terminal::tty; -mod ai_assistant; mod ai_agents; +mod ai_assistant; mod ai_hook; mod ai_providers; mod ai_sessions; @@ -60,6 +60,7 @@ mod math; mod message_bar; mod migrate; mod motion; +mod mux; mod nebula_history; mod notify; #[cfg(windows)] @@ -69,14 +70,12 @@ mod platform; mod polling; mod process_tree; mod renderer; -mod mux; mod runtime_api; mod scheduler; mod session; mod shell_detect; #[cfg(windows)] mod ssh; -mod svn_status; #[cfg(windows)] mod ssh_credentials; #[cfg(windows)] @@ -87,6 +86,7 @@ mod ssh_session; #[cfg(windows)] mod ssh_sftp; mod string; +mod svn_status; mod sync; mod terminal_profiles; mod tray; diff --git a/nebula_app/src/mux.rs b/nebula_app/src/mux.rs index 0a49476..8fa429b 100644 --- a/nebula_app/src/mux.rs +++ b/nebula_app/src/mux.rs @@ -153,8 +153,8 @@ fn serve_callback(listener: TcpListener, token: String, on_attach: impl Fn()) { #[cfg(test)] mod tests { use super::*; - use std::sync::atomic::{AtomicUsize, Ordering}; use std::sync::Arc; + use std::sync::atomic::{AtomicUsize, Ordering}; #[test] fn callback_server_writes_port_file_and_answers_ping_and_attach() { diff --git a/nebula_app/src/nebula_history.rs b/nebula_app/src/nebula_history.rs index 39a6f9b..f690def 100644 --- a/nebula_app/src/nebula_history.rs +++ b/nebula_app/src/nebula_history.rs @@ -97,11 +97,7 @@ impl NebulaHistory { matches.push((pos, cmd.as_str())); } matches.sort_unstable_by(|a, b| b.0.cmp(&a.0)); - matches - .into_iter() - .take(limit) - .map(|(_, cmd)| (cmd, &cmd[prefix.len()..])) - .collect() + matches.into_iter().take(limit).map(|(_, cmd)| (cmd, &cmd[prefix.len()..])).collect() } /// Insert a command, deduplicating and rebuilding the index when an old diff --git a/nebula_app/src/renderer/mod.rs b/nebula_app/src/renderer/mod.rs index 9e46065..99c8d71 100644 --- a/nebula_app/src/renderer/mod.rs +++ b/nebula_app/src/renderer/mod.rs @@ -245,6 +245,33 @@ impl Renderer { string_chars: impl Iterator, size_info: &SizeInfo, glyph_cache: &mut GlyphCache, + ) { + self.draw_string_styled( + point, + fg, + bg, + string_chars, + Flags::empty(), + 1.0, + size_info, + glyph_cache, + ); + } + + /// Grid-aligned string with explicit typeface flags and background alpha. + /// Completion popovers use transparent cells so their rounded surface and + /// selection quads are not overwritten by rectangular glyph backgrounds. + #[allow(clippy::too_many_arguments)] + pub fn draw_string_styled( + &mut self, + point: Point, + fg: Rgb, + bg: Rgb, + string_chars: impl Iterator, + style: Flags, + bg_alpha: f32, + size_info: &SizeInfo, + glyph_cache: &mut GlyphCache, ) { // Lay out by display width: a wide char occupies two columns and is // flagged so the glyph rasterizes double-width. The input is a plain @@ -260,13 +287,16 @@ impl Renderer { if width == 0 || point.column.0 + offset + width > columns { return None; } - let flags = if width == 2 { Flags::WIDE_CHAR } else { Flags::empty() }; + let mut flags = style; + if width == 2 { + flags.insert(Flags::WIDE_CHAR); + } let cell = RenderableCell { point: Point::new(point.line, point.column + offset), character, extra: None, flags, - bg_alpha: 1.0, + bg_alpha, fg, bg, underline: fg, diff --git a/nebula_app/src/runtime_api.rs b/nebula_app/src/runtime_api.rs index c21e13e..f13a53a 100644 --- a/nebula_app/src/runtime_api.rs +++ b/nebula_app/src/runtime_api.rs @@ -8,6 +8,7 @@ mod agent_api; mod cli; mod command; +mod orchestrate; mod server; #[cfg(test)] mod tests; @@ -677,6 +678,7 @@ pub enum RuntimeCommand { }, Split { window_id: Option, + pane_id: Option, direction: RuntimeSplitDirection, }, Prompt { @@ -710,6 +712,7 @@ pub enum RuntimeCommand { }, AgentStart { window_id: Option, + pane_id: Option, name: String, kind: crate::ai_agents::AgentKind, cwd: Option, @@ -1496,6 +1499,9 @@ fn handle_connection( "agent.get" => agent_api::agent_get_connection(&mut stream, request, hub), "agent.wait" => agent_api::agent_wait_connection(&mut stream, request, hub), "pane.wait" => wait_connection(&mut stream, request, hub), + "runtime.orchestrate" => { + orchestrate::orchestrate_connection(&mut stream, request, sink, hub) + }, _ => dispatch_connection(&mut stream, request, sink, hub), } } @@ -1531,6 +1537,7 @@ fn runtime_description() -> Value { "capabilities": [ "runtime.describe", "runtime.snapshot", + "runtime.orchestrate", "events.subscribe", "agents.list", "agent.start", @@ -1560,6 +1567,8 @@ fn runtime_description() -> Value { "agent.fork.transactional_worktree", "agent.worktree.provenance", "events.pane_lifecycle" + ,"runtime.orchestrate.typed_steps" + ,"runtime.orchestrate.agent_ready" ] }) } @@ -1724,11 +1733,6 @@ fn dispatch_connection( Ok(command) => command, Err(error) => return write_response(stream, &ApiResponse::failure(request.id, error)), }; - let (command, mut worktree_transaction) = - match agent_api::prepare_dispatch_command(command, hub) { - Ok(prepared) => prepared, - Err(error) => return write_response(stream, &ApiResponse::failure(request.id, error)), - }; match &command { RuntimeCommand::SendKey { window_id, pane_id, key, modifiers, repeat } => { info!( @@ -1740,9 +1744,11 @@ fn dispatch_connection( modifiers.control, ); }, - RuntimeCommand::AgentStart { window_id, name, kind, session_id, worktree, .. } => { + RuntimeCommand::AgentStart { + window_id, pane_id, name, kind, session_id, worktree, .. + } => { info!( - "runtime agent.start request_id={} window_id={window_id:?} name={} kind={} resume={} worktree={}", + "runtime agent.start request_id={} window_id={window_id:?} pane_id={pane_id:?} name={} kind={} resume={} worktree={}", request.id, name, kind.slug(), @@ -1750,8 +1756,13 @@ fn dispatch_connection( worktree.is_some() ); }, - RuntimeCommand::AgentFork { .. } => { - unreachable!("agent.fork must be prepared before UI dispatch") + RuntimeCommand::AgentFork { name, kind, .. } => { + info!( + "runtime agent.fork request_id={} name={} kind={}", + request.id, + name, + kind.slug() + ); }, RuntimeCommand::AgentPrompt { agent, generation, text, submit } => { info!( @@ -1769,6 +1780,21 @@ fn dispatch_connection( }, _ => {}, } + let response = match dispatch_runtime_command(command, sink, hub) { + Ok(result) => ApiResponse::success(request.id, result), + Err(error) => ApiResponse::failure(request.id, error), + }; + write_response(stream, &response) +} + +/// 执行一个已经解析的 Runtime 原语。普通请求与编排步骤共享这里，避免 +/// worktree 事务、run 等待和 UI 超时在两条路径上逐渐产生不同语义。 +fn dispatch_runtime_command( + command: RuntimeCommand, + sink: &EventSink, + hub: &RuntimeHub, +) -> Result { + let (command, mut worktree_transaction) = agent_api::prepare_dispatch_command(command, hub)?; let run_wait = match &command { RuntimeCommand::Run { wait: true, timeout_ms, .. } => { Some(Duration::from_millis(*timeout_ms)) @@ -1777,13 +1803,12 @@ fn dispatch_connection( }; let (dispatch, receiver) = RuntimeDispatch::new(command); if !sink.emit_control(dispatch) { - let error = agent_api::rollback_prepared_worktree( + return Err(agent_api::rollback_prepared_worktree( ApiError::new("runtime_unavailable", "Nebula's event loop is not available"), worktree_transaction.take(), - ); - return write_response(stream, &ApiResponse::failure(request.id, error)); + )); } - let response = match receiver.recv_timeout(COMMAND_TIMEOUT) { + match receiver.recv_timeout(COMMAND_TIMEOUT) { Ok(Ok(mut result)) => { if let Some(transaction) = worktree_transaction.take() { let provenance = transaction.commit(); @@ -1798,30 +1823,21 @@ fn dispatch_connection( ); match target { (Some(window_id), Some(pane_id), Some(run_id)) => { - match hub.wait_run(window_id, pane_id, run_id, timeout) { - Ok(run) => ApiResponse::success( - request.id, - json!({ "run": run, "snapshot": hub.current() }), - ), - Err(error) => ApiResponse::failure(request.id, error), - } + let run = hub.wait_run(window_id, pane_id, run_id, timeout)?; + Ok(json!({ "run": run, "snapshot": hub.current() })) }, - _ => ApiResponse::failure( - request.id, - ApiError::new( - "invalid_runtime_response", - "pane.run did not return its window, pane, and run identity", - ), - ), + _ => Err(ApiError::new( + "invalid_runtime_response", + "pane.run did not return its window, pane, and run identity", + )), } } else { - ApiResponse::success(request.id, result) + Ok(result) } }, - Ok(Err(error)) => ApiResponse::failure( - request.id, - agent_api::rollback_prepared_worktree(error, worktree_transaction.take()), - ), + Ok(Err(error)) => { + Err(agent_api::rollback_prepared_worktree(error, worktree_transaction.take())) + }, Err(_) => { let mut error = ApiError::new("runtime_timeout", "runtime event thread did not answer in time"); @@ -1835,10 +1851,9 @@ fn dispatch_connection( "reason": "the UI outcome is unknown; Nebula did not remove the worktree" })); } - ApiResponse::failure(request.id, error) + Err(error) }, - }; - write_response(stream, &response) + } } fn write_response(stream: &mut TcpStream, response: &ApiResponse) -> Result<(), IoError> { diff --git a/nebula_app/src/runtime_api/agent_api.rs b/nebula_app/src/runtime_api/agent_api.rs index 5fbc4cb..f6425a9 100644 --- a/nebula_app/src/runtime_api/agent_api.rs +++ b/nebula_app/src/runtime_api/agent_api.rs @@ -14,6 +14,8 @@ struct AgentsParams { struct AgentStartParams { #[serde(default)] window_id: Option, + #[serde(default)] + pane_id: Option, name: String, kind: String, #[serde(default)] @@ -90,10 +92,16 @@ pub(super) fn command_from_request(request: &ApiRequest) -> Result { let params: AgentStartParams = parse_params(&request.params)?; validate_agent_name(¶ms.name)?; + if params.pane_id.is_some() && params.cwd.is_some() { + return Err(ApiError::invalid_params( + "agent.start cannot combine pane_id with cwd; an existing pane keeps its shell cwd", + )); + } let (kind, session_id, command) = verified_agent_launch(¶ms.kind, params.resume_session_id)?; Ok(RuntimeCommand::AgentStart { window_id: params.window_id, + pane_id: params.pane_id, name: params.name, kind, cwd: params.cwd, @@ -255,6 +263,7 @@ pub(super) fn prepare_dispatch_command( Ok(( RuntimeCommand::AgentStart { window_id, + pane_id: None, name, kind, cwd: Some(cwd), diff --git a/nebula_app/src/runtime_api/cli.rs b/nebula_app/src/runtime_api/cli.rs index 3b90bb8..a2fe74b 100644 --- a/nebula_app/src/runtime_api/cli.rs +++ b/nebula_app/src/runtime_api/cli.rs @@ -85,6 +85,31 @@ fn run_cli_inner(options: ControlOptions) -> Result<(), Box> { let response = request_once("runtime.snapshot", json!({}), timeout)?; print_response(&response, options.pretty) }, + CliCommand::Orchestrate { spec, file } => { + let source = match (spec, file) { + (Some(spec), None) => spec, + (None, Some(path)) => std::fs::read_to_string(path)?, + _ => { + return Err(CliError::new( + "invalid_params", + "exactly one of --spec or --file is required", + ) + .into()); + }, + }; + let params: Value = serde_json::from_str(&source).map_err(|error| { + CliError::new( + "invalid_params", + format!("workflow is not valid UTF-8 JSON: {error}"), + ) + })?; + let response = request_once( + "runtime.orchestrate", + params, + timeout.saturating_add(Duration::from_secs(1)), + )?; + print_response(&response, options.pretty) + }, CliCommand::Agents { window } => { let response = request_once("agents.list", json!({ "window_id": window }), timeout)?; print_response(&response, options.pretty) @@ -195,14 +220,14 @@ fn run_cli_inner(options: ControlOptions) -> Result<(), Box> { let response = request_once("tab.new", json!({ "window_id": window }), timeout)?; print_response(&response, options.pretty) }, - CliCommand::Split { window, direction } => { + CliCommand::Split { window, pane, direction } => { let direction = match direction { ControlSplitDirection::Right => RuntimeSplitDirection::LeftRight, ControlSplitDirection::Down => RuntimeSplitDirection::TopBottom, }; let response = request_once( "pane.split", - json!({ "window_id": window, "direction": direction }), + json!({ "window_id": window, "pane_id": pane, "direction": direction }), timeout, )?; print_response(&response, options.pretty) diff --git a/nebula_app/src/runtime_api/command.rs b/nebula_app/src/runtime_api/command.rs index 424210a..d2f50f5 100644 --- a/nebula_app/src/runtime_api/command.rs +++ b/nebula_app/src/runtime_api/command.rs @@ -26,6 +26,8 @@ struct WindowParams { struct SplitParams { #[serde(default)] window_id: Option, + #[serde(default)] + pane_id: Option, direction: RuntimeSplitDirection, } @@ -150,7 +152,11 @@ impl RuntimeCommand { }, "pane.split" => { let params: SplitParams = parse_params(&request.params)?; - Ok(Self::Split { window_id: params.window_id, direction: params.direction }) + Ok(Self::Split { + window_id: params.window_id, + pane_id: params.pane_id, + direction: params.direction, + }) }, "pane.prompt" => { let params: PromptParams = parse_params(&request.params)?; diff --git a/nebula_app/src/runtime_api/tests.rs b/nebula_app/src/runtime_api/tests.rs index 3e83de3..0165000 100644 --- a/nebula_app/src/runtime_api/tests.rs +++ b/nebula_app/src/runtime_api/tests.rs @@ -661,3 +661,246 @@ fn agents_list_projection_keeps_window_and_tab_identity() { Some("thread-7") ); } + +#[test] +fn orchestrate_accepts_typed_backward_references() { + let params = json!({ + "steps": [ + { "id": "right", "op": "split", "direction": "left_right" }, + { + "id": "weather", + "op": "agent_launch", + "target": { "step": "right", "field": "pane_id" }, + "name": "weather", + "kind": "claude", + "initial_prompt": "查询天气" + } + ] + }); + super::orchestrate::validate_params(¶ms).unwrap(); +} + +#[test] +fn orchestrate_rejects_unknown_fields_duplicate_ids_and_future_references() { + let unknown = json!({ + "steps": [ + { "id": "right", "op": "split", "direction": "left_right", "method": "pane.split" } + ] + }); + assert_eq!(super::orchestrate::validate_params(&unknown).unwrap_err().code, "invalid_params"); + + let duplicate = json!({ + "steps": [ + { "id": "same", "op": "new_tab" }, + { "id": "same", "op": "split", "direction": "top_bottom" } + ] + }); + assert_eq!(super::orchestrate::validate_params(&duplicate).unwrap_err().code, "invalid_params"); + + let future = json!({ + "steps": [ + { + "id": "prompt", + "op": "prompt", + "target": { "step": "later", "field": "pane_id" }, + "text": "hello" + }, + { "id": "later", "op": "new_tab" } + ] + }); + assert_eq!(super::orchestrate::validate_params(&future).unwrap_err().code, "invalid_reference"); + + let self_reference = json!({ + "steps": [{ + "id": "self", + "op": "prompt", + "target": { "step": "self", "field": "pane_id" }, + "text": "hello" + }] + }); + assert_eq!( + super::orchestrate::validate_params(&self_reference).unwrap_err().code, + "invalid_reference" + ); +} + +#[test] +fn orchestrate_keeps_prompt_and_command_input_boundaries() { + let multiline_prompt = json!({ + "steps": [{ + "id": "prompt", + "op": "prompt", + "target": { "pane_id": 3 }, + "text": "first\nsecond" + }] + }); + assert_eq!( + super::orchestrate::validate_params(&multiline_prompt).unwrap_err().code, + "invalid_params" + ); + + let escaped_command = json!({ + "steps": [{ + "id": "run", + "op": "run", + "target": { "pane_id": 3 }, + "command": "echo ok\u{001b}[2J" + }] + }); + assert_eq!( + super::orchestrate::validate_params(&escaped_command).unwrap_err().code, + "invalid_params" + ); +} + +#[test] +fn agent_start_can_bind_an_existing_pane_but_not_replace_its_cwd() { + let existing = ApiRequest::new( + "token".into(), + "agent.start", + json!({ "window_id": 7, "pane_id": 3, "name": "worker", "kind": "codex" }), + ); + assert!(matches!( + RuntimeCommand::from_request(&existing), + Ok(RuntimeCommand::AgentStart { window_id: Some(7), pane_id: Some(3), .. }) + )); + + let invalid = ApiRequest::new( + "token".into(), + "agent.start", + json!({ + "window_id": 7, + "pane_id": 3, + "name": "worker", + "kind": "codex", + "cwd": "D:/other" + }), + ); + assert_eq!(RuntimeCommand::from_request(&invalid).unwrap_err().code, "invalid_params"); +} + +#[test] +fn agent_ready_requires_observed_process_identity() { + let hub = RuntimeHub::new(); + let agent = hub + .register_agent("worker".into(), crate::ai_agents::AgentKind::Codex, 7, 3, None, None) + .unwrap(); + hub.publish(snapshot(RuntimeTaskState::Idle)); + let error = super::orchestrate::wait_agent_ready( + &hub, + &agent.agent_id, + agent.generation, + Instant::now() + Duration::from_millis(5), + ) + .unwrap_err(); + assert_eq!(error.code, "agent_ready_timeout"); + + let mut detected = snapshot(RuntimeTaskState::Idle); + detected.windows[0].tabs[0].panes[0].agent = Some(detected_agent("codex", None)); + hub.publish(detected); + let (ready, state) = super::orchestrate::wait_agent_ready( + &hub, + &agent.agent_id, + agent.generation, + Instant::now() + Duration::from_millis(50), + ) + .unwrap(); + assert!(ready.observed); + assert_eq!(state, RuntimeTaskState::Idle); +} + +#[test] +fn orchestrate_receipt_preserves_partial_success() { + let sink = EventSink::Callback(Arc::new(|callback| { + let RuntimeCallback::Control(dispatch) = callback else { return }; + match &dispatch.command { + RuntimeCommand::NewTab { .. } => dispatch.respond(Ok(json!({ + "action": { "window_id": 7, "pane_id": 9 }, + "snapshot": null + }))), + RuntimeCommand::Prompt { .. } => { + dispatch.respond(Err(ApiError::new("input_in_progress", "pane is busy"))) + }, + command => panic!("unexpected command: {command:?}"), + } + })); + let receipt = super::orchestrate::execute_for_test( + &json!({ + "steps": [ + { "id": "tab", "op": "new_tab" }, + { + "id": "prompt", + "op": "prompt", + "target": { "step": "tab", "field": "pane_id" }, + "text": "hello" + } + ] + }), + &sink, + &RuntimeHub::new(), + ) + .unwrap(); + assert_eq!(receipt["ok"], false); + assert_eq!(receipt["partial"], true); + assert_eq!(receipt["completed"], 1); + assert_eq!(receipt["failed_step"], "prompt"); + assert_eq!(receipt["steps"][0]["action"]["pane_id"], 9); + assert_eq!(receipt["steps"][1]["error"]["code"], "input_in_progress"); +} + +#[test] +fn orchestrate_does_not_expose_agent_receipt_before_ready() { + let hub = RuntimeHub::new(); + hub.publish(snapshot(RuntimeTaskState::Idle)); + let prompt_dispatches = Arc::new(AtomicUsize::new(0)); + let sink_hub = hub.clone(); + let sink_prompt_dispatches = prompt_dispatches.clone(); + let sink = EventSink::Callback(Arc::new(move |callback| { + let RuntimeCallback::Control(dispatch) = callback else { + return; + }; + match &dispatch.command { + RuntimeCommand::AgentStart { pane_id: Some(pane_id), name, kind, .. } => { + let agent = + sink_hub.register_agent(name.clone(), *kind, 7, *pane_id, None, None).unwrap(); + dispatch.respond(Ok(json!({ + "action": { "agent": agent, "window_id": 7, "pane_id": pane_id }, + "snapshot": null + }))); + }, + RuntimeCommand::Prompt { .. } | RuntimeCommand::AgentPrompt { .. } => { + sink_prompt_dispatches.fetch_add(1, Ordering::Relaxed); + dispatch.respond(Ok(json!({ "action": {} }))); + }, + command => panic!("unexpected command: {command:?}"), + } + })); + let receipt = super::orchestrate::execute_for_test( + &json!({ + "steps": [ + { + "id": "agent", + "op": "agent_launch", + "target": { "window_id": 7, "pane_id": 3 }, + "name": "worker", + "kind": "codex", + "initial_prompt": "first task", + "ready_timeout_ms": 5 + }, + { + "id": "too_early", + "op": "prompt", + "target": { "step": "agent", "field": "pane_id" }, + "text": "must not dispatch" + } + ] + }), + &sink, + &hub, + ) + .unwrap(); + assert_eq!(prompt_dispatches.load(Ordering::Relaxed), 0); + assert_eq!(receipt["failed_step"], "agent"); + assert_eq!(receipt["steps"].as_array().unwrap().len(), 1); + assert_eq!(receipt["steps"][0]["error"]["code"], "agent_ready_timeout"); +} diff --git a/nebula_app/src/session.rs b/nebula_app/src/session.rs index 797646a..4dd85c3 100644 --- a/nebula_app/src/session.rs +++ b/nebula_app/src/session.rs @@ -95,7 +95,6 @@ impl AgentSession { _ => None, } } - } /// A tab's pane tree. Leaves carry each pane's working directory; splits carry @@ -466,12 +465,11 @@ mod tests { agent("claude", Some("abc-123")).resume_command().as_deref(), Some("claude --resume abc-123") ); + assert_eq!(agent("claude", None).resume_command().as_deref(), Some("claude --continue")); assert_eq!( - agent("claude", None).resume_command().as_deref(), - Some("claude --continue") - ); - assert_eq!( - agent("codex", Some("b5f6c1c2-1111-2222-3333-444455556666")).resume_command().as_deref(), + agent("codex", Some("b5f6c1c2-1111-2222-3333-444455556666")) + .resume_command() + .as_deref(), Some("codex resume b5f6c1c2-1111-2222-3333-444455556666") ); assert_eq!(agent("codex", None).resume_command(), None); diff --git a/nebula_app/src/ssh_credentials.rs b/nebula_app/src/ssh_credentials.rs index 7b54fc6..14c6984 100644 --- a/nebula_app/src/ssh_credentials.rs +++ b/nebula_app/src/ssh_credentials.rs @@ -196,9 +196,7 @@ pub(crate) mod windows_store { } let end = password.iter().position(|x| *x == 0).unwrap_or(password.len()); let bytes = String::from_utf16(&password[..end]) - .map_err(|_| { - io::Error::new(io::ErrorKind::InvalidData, "secret is not valid UTF-16") - })? + .map_err(|_| io::Error::new(io::ErrorKind::InvalidData, "secret is not valid UTF-16"))? .into_bytes(); password.fill(0); Ok(Some(bytes)) diff --git a/nebula_app/src/ssh_session.rs b/nebula_app/src/ssh_session.rs index 43940c5..7eb28c5 100644 --- a/nebula_app/src/ssh_session.rs +++ b/nebula_app/src/ssh_session.rs @@ -3,6 +3,7 @@ //! 远端 Pane 不创建本地伪终端，但继续使用统一的输入、缩放和关闭消息协议， //! 从而让渲染与键盘处理保持传输层无关。 +use std::borrow::Cow; use std::collections::HashMap; use std::io; use std::path::{Path, PathBuf}; @@ -176,7 +177,13 @@ impl SshDestination { return Err(io::Error::new(io::ErrorKind::InvalidInput, "SSH 地址为空")); } - let output = Command::new(find_ssh()).arg("-G").arg("--").arg(&original).output(); + // OpenSSH 不把裸 `user@host:port` 识别为端口语法，而会原样输出成 + // `hostname host:port`。后续把它交给 socket 就会在 Windows 上得到 + // WSAHOST_NOT_FOUND。只规范化配置探测参数，保留 original 作为列表、 + // Profile 与凭据的稳定身份。 + let config_target = ssh_config_probe_target(&original); + let output = + Command::new(find_ssh()).arg("-G").arg("--").arg(config_target.as_ref()).output(); if let Ok(output) = output { if output.status.success() { let text = String::from_utf8_lossy(&output.stdout); @@ -210,6 +217,27 @@ impl SshDestination { } } +/// 给 `ssh -G` 的离线配置探测目标。Nebula 历史存盘格式允许 +/// `user@host:port`，而 OpenSSH 只会从 `ssh://user@host:port` URI 中拆出 +/// 端口；无显式端口、已有 URI 与裸 IPv6 都保持原样，避免改变 Host 匹配。 +fn ssh_config_probe_target(value: &str) -> Cow<'_, str> { + if value.starts_with("ssh://") { + return Cow::Borrowed(value); + } + let host_port = value.rsplit_once('@').map_or(value, |(_, host_port)| host_port); + let has_explicit_port = if let Some(rest) = host_port.strip_prefix('[') { + rest.split_once(']') + .and_then(|(_, suffix)| suffix.strip_prefix(':')) + .is_some_and(|port| port.parse::().is_ok()) + } else if let Some((host, port)) = host_port.rsplit_once(':') { + !host.is_empty() && !host.contains(':') && port.parse::().is_ok() + } else { + false + }; + + if has_explicit_port { Cow::Owned(format!("ssh://{value}")) } else { Cow::Borrowed(value) } +} + fn parse_host_port(host_port: &str) -> io::Result<(String, u16)> { let (host, port) = if let Some(rest) = host_port.strip_prefix('[') { let (host, suffix) = rest @@ -1456,7 +1484,7 @@ fn wide(value: &str) -> Vec { mod tests { use super::{ AuthMethod, SshDestination, authentication_plan, parse_resolved_config, - resolve_network_proxy, + resolve_network_proxy, ssh_config_probe_target, }; use crate::ssh_profiles::SshAuthMode; use crate::ssh_proxy::{ProxyLink, ProxyMode, SshProxyConfig}; @@ -1491,6 +1519,24 @@ mod tests { assert_eq!(destination.identity_files.len(), 1); } + #[test] + fn openssh_probe_normalizes_legacy_destinations_with_explicit_ports() { + assert_eq!( + ssh_config_probe_target("root@154.64.232.109:20222"), + "ssh://root@154.64.232.109:20222" + ); + assert_eq!( + ssh_config_probe_target("root@[2001:db8::1]:20222"), + "ssh://root@[2001:db8::1]:20222" + ); + assert_eq!( + ssh_config_probe_target("ssh://root@example.com:20222"), + "ssh://root@example.com:20222" + ); + assert_eq!(ssh_config_probe_target("root@example.com"), "root@example.com"); + assert_eq!(ssh_config_probe_target("root@2001:db8::1"), "root@2001:db8::1"); + } + #[test] fn proxy_test_timeout_copy_matches_shared_budget() { assert_eq!(super::proxy_test_timeout_message(), "网络测试超时（12 秒无响应）"); diff --git a/nebula_app/src/svn_status.rs b/nebula_app/src/svn_status.rs index 9764360..280d0b4 100644 --- a/nebula_app/src/svn_status.rs +++ b/nebula_app/src/svn_status.rs @@ -93,11 +93,9 @@ pub struct SvnChange { /// 只有内容真的不同才报 Modified（touch 过的文件不误报）。 pub fn working_copy_status(root: &Path) -> Result, String> { let db_path = root.join(".svn").join("wc.db"); - let connection = rusqlite::Connection::open_with_flags( - &db_path, - rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY, - ) - .map_err(|error| format!("无法打开 {}: {error}", db_path.display()))?; + let connection = + rusqlite::Connection::open_with_flags(&db_path, rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY) + .map_err(|error| format!("无法打开 {}: {error}", db_path.display()))?; // svn 客户端可能正持有写锁；等一小会而不是立刻失败。 connection.busy_timeout(std::time::Duration::from_millis(300)).ok(); @@ -162,8 +160,8 @@ pub fn working_copy_status(root: &Path) -> Result, String> { // 冲突从 ACTUAL_NODE 来（树冲突/文本冲突统一报 Conflicted）。 let mut conflicted: HashSet = HashSet::new(); - if let Ok(mut statement) = connection - .prepare("SELECT local_relpath FROM actual_node WHERE conflict_data IS NOT NULL") + if let Ok(mut statement) = + connection.prepare("SELECT local_relpath FROM actual_node WHERE conflict_data IS NOT NULL") { if let Ok(rows) = statement.query_map([], |row| row.get::<_, String>(0)) { for relpath in rows.flatten() { @@ -204,9 +202,15 @@ pub fn working_copy_status(root: &Path) -> Result, String> { changes.push(SvnChange { rel_path: relpath.clone(), state: SvnState::Missing }); continue; }; - if is_modified(&disk, &metadata, node.recorded_size, node.recorded_time, node.checksum.as_deref()) - { - changes.push(SvnChange { rel_path: relpath.clone(), state: SvnState::Modified }); + if is_modified( + &disk, + &metadata, + node.recorded_size, + node.recorded_time, + node.checksum.as_deref(), + ) { + changes + .push(SvnChange { rel_path: relpath.clone(), state: SvnState::Modified }); } }, // excluded/server-excluded/not-present 等：本地无实体，不报告。 @@ -216,8 +220,11 @@ pub fn working_copy_status(root: &Path) -> Result, String> { // 未版本化：已版本化目录的磁盘直接子项里，不在 NODES 且不是 .svn 的。 for dir in versioned_dirs { - let disk_dir = - if dir.is_empty() { root.to_owned() } else { root.join(dir.replace('/', std::path::MAIN_SEPARATOR_STR)) }; + let disk_dir = if dir.is_empty() { + root.to_owned() + } else { + root.join(dir.replace('/', std::path::MAIN_SEPARATOR_STR)) + }; let Ok(entries) = std::fs::read_dir(&disk_dir) else { continue }; for entry in entries.flatten() { let name = entry.file_name(); @@ -225,8 +232,7 @@ pub fn working_copy_status(root: &Path) -> Result, String> { if name == ".svn" { continue; } - let relpath = - if dir.is_empty() { name.to_string() } else { format!("{dir}/{name}") }; + let relpath = if dir.is_empty() { name.to_string() } else { format!("{dir}/{name}") }; if !nodes.contains_key(&relpath) { changes.push(SvnChange { rel_path: relpath, state: SvnState::Unversioned }); } @@ -428,25 +434,11 @@ mod tests { insert_node(&connection, "replaced.txt", 1, "normal", "file", None, None, None); insert_node(&connection, "deleted.txt", 0, "normal", "file", None, Some(1), Some(1)); insert_node(&connection, "deleted.txt", 1, "base-deleted", "file", None, None, None); - insert_node( - &connection, - "missing.txt", - 0, - "normal", - "file", - None, - Some(1), - Some(1), - ); + insert_node(&connection, "missing.txt", 0, "normal", "file", None, Some(1), Some(1)); // 冲突覆盖其他状态。 std::fs::write(root.join("conflict.txt"), "x").unwrap(); insert_node(&connection, "conflict.txt", 0, "normal", "file", None, Some(1), Some(1)); - connection - .execute( - "INSERT INTO actual_node VALUES ('conflict.txt', x'00')", - [], - ) - .unwrap(); + connection.execute("INSERT INTO actual_node VALUES ('conflict.txt', x'00')", []).unwrap(); // 未版本化的散文件。 std::fs::write(root.join("stray.txt"), "?").unwrap(); drop(connection); diff --git a/nebula_app/src/tray.rs b/nebula_app/src/tray.rs index e9f8cd3..4052bac 100644 --- a/nebula_app/src/tray.rs +++ b/nebula_app/src/tray.rs @@ -95,7 +95,8 @@ mod win { static PROXY: OnceLock> = OnceLock::new(); /// GPUI 主窗没有 winit `EventLoopProxy`：点击托盘时走命令回调。 - static GPUI_COMMAND: OnceLock> = OnceLock::new(); + static GPUI_COMMAND: OnceLock> = + OnceLock::new(); static STATE: Mutex = Mutex::new(Shared { agents: Vec::new(), enabled: false }); /// 托盘窗口句柄（isize 形态跨线程存取；0 = 线程未起或窗口未建）。 static HWND: AtomicIsize = AtomicIsize::new(0); diff --git a/nebula_app/src/window_context.rs b/nebula_app/src/window_context.rs index c4fcf23..98ba014 100644 --- a/nebula_app/src/window_context.rs +++ b/nebula_app/src/window_context.rs @@ -47,9 +47,9 @@ use crate::message_bar::MessageBuffer; use crate::scheduler::{Scheduler, TimerId, Topic}; use crate::{input, renderer, session}; +mod agents; mod model; mod nebula_fetch_art; -mod agents; mod runtime; /// New-tab welcome page (Windows logo + fastfetch intro). Stateless helpers. pub(crate) mod welcome; @@ -692,6 +692,10 @@ impl WindowContext { self.spawn_tab_ssh(host, TabPlacement::Created); false }, + TabRequest::RetrySsh(host) => { + self.retry_focused_ssh(host); + false + }, TabRequest::OpenDoc(path) => { if crate::display::image_viewer::viewable_file(&path) { self.open_image_tab(path); @@ -1164,6 +1168,71 @@ impl WindowContext { } } + /// 用新的 pane id 在当前布局叶原位重建失败的 SSH 会话。先成功创建替代 + /// 会话、再一次性换树和 pane 池，避免“关闭最后一个 tab 后再新建”导致 + /// 窗口提前退出；新 id 也会隔离旧 runtime 的迟到阶段事件。 + fn retry_focused_ssh(&mut self, destination: String) { + #[cfg(windows)] + { + let old_id = self.focused_pane_id(); + let Some(old_index) = self.pane_index(old_id) else { return }; + if self.panes[old_index].ssh_destination.as_deref() != Some(destination.as_str()) { + return; + } + let view = self + .layout_geometry(false) + .0 + .into_iter() + .find_map(|(id, view)| (id == old_id).then_some(view)) + .unwrap_or(self.display.size_info); + let new_id = self.next_pane_id; + let new_pane = match Self::create_ssh_pane( + &view, + self.display.window.id(), + &self.config, + &self.proxy, + new_id, + destination.clone(), + ) { + Ok(pane) => pane, + Err(error) => { + self.display.ssh_connect_stage( + old_id, + destination, + crate::ssh_session::SshStage::Failed(format!("无法重试 SSH 连接: {error}")), + ); + self.dirty = true; + self.display.window.request_redraw(); + return; + }, + }; + + let tab = &mut self.tabs[self.active_tab]; + if !tab.layout.replace_leaf(old_id, new_id) { + let _ = new_pane.notifier.0.send(nebula_terminal::event_loop::Msg::Shutdown); + return; + } + tab.active_pane = new_id; + if self.zoom == Some(old_id) { + self.zoom = Some(new_id); + } + self.next_pane_id = self.next_pane_id.saturating_add(1); + let old_pane = std::mem::replace(&mut self.panes[old_index], new_pane); + self.display.forget_ssh_connect(old_id); + self.display.ssh_connect_stage( + new_id, + destination, + crate::ssh_session::SshStage::Resolve, + ); + let _ = old_pane.notifier.0.send(nebula_terminal::event_loop::Msg::Shutdown); + self.resize_active_layout(); + self.dirty = true; + self.display.window.request_redraw(); + } + #[cfg(not(windows))] + let _ = destination; + } + /// Open `path` in a read-only document viewer tab. A tab already viewing /// this file is re-focused (and re-read, so the view is fresh) instead of /// duplicated — double-click twice shouldn't litter the bar. @@ -1352,7 +1421,8 @@ impl WindowContext { TabLaunch::Shell { shell, .. } => Some(shell.clone()), _ => unreachable!("launch was restricted above"), }; - let Some(pane_id) = self.spawn_pane_detached_with(cwd, self.display.size_info, shell) else { + let Some(pane_id) = self.spawn_pane_detached_with(cwd, self.display.size_info, shell) + else { return; }; self.insert_tab( @@ -1816,10 +1886,9 @@ impl WindowContext { source: identity.source.clone(), session_id: Some(identity.session_id.clone()), }), - _ if matches!(program, "claude" | "codex") => Some(session::AgentSession { - source: program.to_owned(), - session_id: None, - }), + _ if matches!(program, "claude" | "codex") => { + Some(session::AgentSession { source: program.to_owned(), session_id: None }) + }, _ => None, } }; @@ -2180,8 +2249,7 @@ impl WindowContext { } if let Some(id) = ev.session_id.as_deref() { let cwd = self.panes[idx].nebula_state.cwd.clone(); - if let Err(error) = - crate::ai_sessions::record_hook_session(&ev.source, id, &cwd, None) + if let Err(error) = crate::ai_sessions::record_hook_session(&ev.source, id, &cwd, None) { log::warn!("agent session index: could not record {} {id}: {error}", ev.source); } @@ -2412,8 +2480,7 @@ impl WindowContext { state.finished_at = Some(Instant::now()); } }, - crate::ai_agents::AgentStatus::Done - | crate::ai_agents::AgentStatus::Unknown => {}, + crate::ai_agents::AgentStatus::Done | crate::ai_agents::AgentStatus::Unknown => {}, } } // Chrome/tray read the established fields; rebuilding their compact diff --git a/nebula_app/src/window_context/runtime.rs b/nebula_app/src/window_context/runtime.rs index 213580c..91a97f7 100644 --- a/nebula_app/src/window_context/runtime.rs +++ b/nebula_app/src/window_context/runtime.rs @@ -158,8 +158,24 @@ impl WindowContext { pub(crate) fn runtime_split( &mut self, + pane_id: Option, direction: RuntimeSplitDirection, - ) -> Result { + ) -> Result<(u64, u64), ApiError> { + if let Some(pane_id) = pane_id { + let tab_index = self.tabs.iter().position(|tab| { + let mut ids = Vec::new(); + tab.layout.leaves(&mut ids); + ids.contains(&pane_id) + }); + let Some(tab_index) = tab_index else { + return Err(ApiError::new( + "target_not_found", + format!("pane {pane_id} does not belong to the target window"), + )); + }; + self.select_tab(tab_index); + self.tabs[tab_index].active_pane = pane_id; + } let special = self .tabs .get(self.active_tab) @@ -170,6 +186,7 @@ impl WindowContext { "document, image, and settings tabs cannot be split", )); } + let source_pane_id = self.tabs[self.active_tab].active_pane; let before = self.panes.len(); let direction = match direction { RuntimeSplitDirection::LeftRight => SplitDirection::LeftRight, @@ -182,7 +199,7 @@ impl WindowContext { "the default shell could not be started for a new pane", )); } - Ok(self.tabs[self.active_tab].active_pane) + Ok((source_pane_id, self.tabs[self.active_tab].active_pane)) } pub(crate) fn runtime_prompt( diff --git a/nebula_app/src/window_context/split.rs b/nebula_app/src/window_context/split.rs index e6c2eb7..aff6aa3 100644 --- a/nebula_app/src/window_context/split.rs +++ b/nebula_app/src/window_context/split.rs @@ -85,6 +85,21 @@ impl Layout { } } + /// 原位替换一个布局叶。SSH 重试用新 pane id 隔离旧会话的迟到事件，但 + /// 必须保留原来的分屏位置、比例与兄弟节点。 + pub(super) fn replace_leaf(&mut self, target: PaneId, replacement: PaneId) -> bool { + match self { + Layout::Leaf(id) if *id == target => { + *id = replacement; + true + }, + Layout::Leaf(_) => false, + Layout::Split { first, second, .. } => { + first.replace_leaf(target, replacement) || second.replace_leaf(target, replacement) + }, + } + } + /// Replace the `target` leaf with a `Split` of `[target, new]`. Returns /// `true` if `target` was found. fn split_leaf( @@ -871,6 +886,17 @@ mod resize_layout_tests { use crate::display::{SizeInfo, SplitDirection}; use crate::window_context::pane_focus_button; + #[test] + fn replacing_a_leaf_preserves_its_split_position() { + let mut layout = Layout::Leaf(1); + assert!(layout.split_leaf(1, 2, SplitDirection::LeftRight, 0.5)); + assert!(layout.replace_leaf(1, 9)); + let mut leaves = Vec::new(); + layout.leaves(&mut leaves); + assert_eq!(leaves, vec![9, 2]); + assert!(!layout.replace_leaf(7, 8)); + } + #[test] fn all_terminal_mouse_buttons_move_split_focus_before_routing() { assert!(pane_focus_button(&MouseButton::Left)); diff --git a/nebula_app/tests/file_line_budget.rs b/nebula_app/tests/file_line_budget.rs index a18fae9..d25cba1 100644 --- a/nebula_app/tests/file_line_budget.rs +++ b/nebula_app/tests/file_line_budget.rs @@ -1,122 +1,118 @@ -//! 文件行数预算守护（docs/project-constraints.md 第 1 条）。 -//! -//! 单个 `.rs` 文件硬上限 2000 行；存量超标文件在 [`GRANDFATHERED`] 登记， -//! 登记值只允许下调。测试失败的正确动作是拆文件，不是上调预算。 - -use std::fs; -use std::path::{Path, PathBuf}; - -/// 新代码红线：超过它就必须拆（docs/project-constraints.md）。 -const MAX_LINES: usize = 2000; - -/// 存量豁免清单（相对仓库根，正斜杠路径 → 行数上限）。 -/// -/// 登记值 = 收录当天的行数加不足百行的呼吸空间：小修小补不触线，成规模 -/// 新增必须伴随拆分。拆小后同步下调或删除对应条目。 -const GRANDFATHERED: &[(&str, usize)] = &[ - ("nebula_app/src/display/mod.rs", 12000), - ("nebula_app/src/display/settings.rs", 8650), - // 2026-08-17 上调（4850 → 5150）：git 树 VS Code 化 + 源码 tab 接线； - // 下一步应把 VCS 面板拆成独立文件后下调。 - ("nebula_app/src/gpui_shell/workspace.rs", 5150), - // 2026-08-17 下调（3600 → 3550）：网络区拆到 network_settings.rs。 - ("nebula_app/src/gpui_shell/settings_pane.rs", 3550), - ("nebula_app/src/display/command_palette.rs", 3980), - ("nebula_app/src/window_context.rs", 3800), - ("nebula_app/src/event.rs", 3780), - ("nebula_terminal/src/term/mod.rs", 3650), - // 2026-08-17 上调（2900 → 2970）：draw_overlays 几何抽成两壳共享的 plan。 - ("nebula_app/src/display/terminal_math.rs", 2970), - // 2026-08-17 上调（2680 → 2760）：SVN wc.db 回退 + 单文件 stage/discard。 - ("nebula_app/src/display/side_panel.rs", 2760), - ("nebula_app/src/gpui_shell/terminal/view.rs", 2540), - ("nebula_app/src/display/chrome.rs", 2550), - ("nebula_app/src/display/markdown_view.rs", 2150), -]; - -/// 这些目录不受预算约束：构建产物、vendored 第三方代码、版本库内部。 -fn excluded(component: &str) -> bool { - component == ".git" - || component == "third_party" - || component == "target" - || component.starts_with(".target") -} - -fn collect_rust_files(root: &Path, out: &mut Vec) { - let Ok(entries) = fs::read_dir(root) else { - return; - }; - for entry in entries.flatten() { - let path = entry.path(); - let name = entry.file_name(); - let name = name.to_string_lossy(); - // 隐藏项（.git、.tmp_* 草稿等）不是源码，不受预算约束。 - if name.starts_with('.') { - continue; - } - if path.is_dir() { - if !excluded(&name) { - collect_rust_files(&path, out); - } - } else if path.extension().is_some_and(|extension| extension == "rs") { - out.push(path); - } - } -} - -#[test] -fn every_source_file_respects_its_line_budget() { - let repo_root = Path::new(env!("CARGO_MANIFEST_DIR")) - .parent() - .expect("nebula_app sits directly under the repo root") - .to_path_buf(); - - let mut files = Vec::new(); - collect_rust_files(&repo_root, &mut files); - assert!( - files.len() > 100, - "行数守护扫到的文件数异常（{}），排除规则可能吞掉了源码目录", - files.len() - ); - - let mut violations = Vec::new(); - let mut stale_grants = Vec::new(); - for path in files { - let relative = path - .strip_prefix(&repo_root) - .expect("collected files live under the repo root") - .to_string_lossy() - .replace('\\', "/"); - let Ok(content) = fs::read(&path) else { - panic!("无法读取 {relative}"); - }; - // 按换行字节计数：与编码无关，空文件为 0 行。 - let lines = content.iter().filter(|byte| **byte == b'\n').count() - + usize::from(!content.is_empty() && content.last() != Some(&b'\n')); - let grant = GRANDFATHERED - .iter() - .find(|(name, _)| *name == relative) - .map(|(_, budget)| *budget); - let budget = grant.unwrap_or(MAX_LINES); - if lines > budget { - violations.push(format!("{relative}: {lines} 行 > 预算 {budget}")); - } - // 豁免文件瘦身到红线以内后，条目必须删除，防止预算复胖。 - if let Some(budget) = grant - && lines <= MAX_LINES - { - stale_grants.push(format!("{relative}: 已降到 {lines} 行（≤{MAX_LINES}），豁免条目（{budget}）应删除")); - } - } - - assert!( - violations.is_empty(), - "以下文件超出行数预算（docs/project-constraints.md 第 1 条，正确动作是拆文件）：\n{}", - violations.join("\n") - ); - assert!( - stale_grants.is_empty(), - "以下豁免条目已过期：\n{}", - stale_grants.join("\n") - ); -} +//! 文件行数预算守护（docs/project-constraints.md 第 1 条）。 +//! +//! 单个 `.rs` 文件硬上限 2000 行；存量超标文件在 [`GRANDFATHERED`] 登记， +//! 登记值只允许下调。测试失败的正确动作是拆文件，不是上调预算。 + +use std::fs; +use std::path::{Path, PathBuf}; + +/// 新代码红线：超过它就必须拆（docs/project-constraints.md）。 +const MAX_LINES: usize = 2000; + +/// 存量豁免清单（相对仓库根，正斜杠路径 → 行数上限）。 +/// +/// 登记值 = 收录当天的行数加不足百行的呼吸空间：小修小补不触线，成规模 +/// 新增必须伴随拆分。拆小后同步下调或删除对应条目。 +const GRANDFATHERED: &[(&str, usize)] = &[ + ("nebula_app/src/display/mod.rs", 12000), + ("nebula_app/src/display/settings.rs", 8650), + // 2026-08-17 上调（4850 → 5150）：git 树 VS Code 化 + 源码 tab 接线； + // 下一步应把 VCS 面板拆成独立文件后下调。 + ("nebula_app/src/gpui_shell/workspace.rs", 5150), + // 2026-08-17 下调（3600 → 3550）：网络区拆到 network_settings.rs。 + ("nebula_app/src/gpui_shell/settings_pane.rs", 3550), + ("nebula_app/src/display/command_palette.rs", 3980), + ("nebula_app/src/window_context.rs", 3800), + ("nebula_app/src/event.rs", 3780), + ("nebula_terminal/src/term/mod.rs", 3650), + // 2026-08-17 上调（2900 → 2970）：draw_overlays 几何抽成两壳共享的 plan。 + ("nebula_app/src/display/terminal_math.rs", 2970), + // 2026-08-17 上调（2680 → 2760）：SVN wc.db 回退 + 单文件 stage/discard。 + ("nebula_app/src/display/side_panel.rs", 2760), + ("nebula_app/src/gpui_shell/terminal/view.rs", 2540), + ("nebula_app/src/display/chrome.rs", 2550), + ("nebula_app/src/display/markdown_view.rs", 2150), +]; + +/// 这些目录不受预算约束：构建产物、vendored 第三方代码、版本库内部。 +fn excluded(component: &str) -> bool { + component == ".git" + || component == "third_party" + || component == "target" + || component.starts_with(".target") +} + +fn collect_rust_files(root: &Path, out: &mut Vec) { + let Ok(entries) = fs::read_dir(root) else { + return; + }; + for entry in entries.flatten() { + let path = entry.path(); + let name = entry.file_name(); + let name = name.to_string_lossy(); + // 隐藏项（.git、.tmp_* 草稿等）不是源码，不受预算约束。 + if name.starts_with('.') { + continue; + } + if path.is_dir() { + if !excluded(&name) { + collect_rust_files(&path, out); + } + } else if path.extension().is_some_and(|extension| extension == "rs") { + out.push(path); + } + } +} + +#[test] +fn every_source_file_respects_its_line_budget() { + let repo_root = Path::new(env!("CARGO_MANIFEST_DIR")) + .parent() + .expect("nebula_app sits directly under the repo root") + .to_path_buf(); + + let mut files = Vec::new(); + collect_rust_files(&repo_root, &mut files); + assert!( + files.len() > 100, + "行数守护扫到的文件数异常（{}），排除规则可能吞掉了源码目录", + files.len() + ); + + let mut violations = Vec::new(); + let mut stale_grants = Vec::new(); + for path in files { + let relative = path + .strip_prefix(&repo_root) + .expect("collected files live under the repo root") + .to_string_lossy() + .replace('\\', "/"); + let Ok(content) = fs::read(&path) else { + panic!("无法读取 {relative}"); + }; + // 按换行字节计数：与编码无关，空文件为 0 行。 + let lines = content.iter().filter(|byte| **byte == b'\n').count() + + usize::from(!content.is_empty() && content.last() != Some(&b'\n')); + let grant = + GRANDFATHERED.iter().find(|(name, _)| *name == relative).map(|(_, budget)| *budget); + let budget = grant.unwrap_or(MAX_LINES); + if lines > budget { + violations.push(format!("{relative}: {lines} 行 > 预算 {budget}")); + } + // 豁免文件瘦身到红线以内后，条目必须删除，防止预算复胖。 + if let Some(budget) = grant + && lines <= MAX_LINES + { + stale_grants.push(format!( + "{relative}: 已降到 {lines} 行（≤{MAX_LINES}），豁免条目（{budget}）应删除" + )); + } + } + + assert!( + violations.is_empty(), + "以下文件超出行数预算（docs/project-constraints.md 第 1 条，正确动作是拆文件）：\n{}", + violations.join("\n") + ); + assert!(stale_grants.is_empty(), "以下豁免条目已过期：\n{}", stale_grants.join("\n")); +} diff --git a/nebula_gpui/src/ui/prelude.rs b/nebula_gpui/src/ui/prelude.rs index 2da8b3f..934067d 100644 --- a/nebula_gpui/src/ui/prelude.rs +++ b/nebula_gpui/src/ui/prelude.rs @@ -9,7 +9,9 @@ pub use gpui_component::{ button::{Button, ButtonVariants as _}, checkbox::Checkbox, dialog::{Dialog, DialogButtonProps}, - dock::{DockArea, DockAreaState, DockItem, Panel, PanelControl, PanelEvent, PanelState, TabPanel}, + dock::{ + DockArea, DockAreaState, DockItem, Panel, PanelControl, PanelEvent, PanelState, TabPanel, + }, h_flex, input::{Input, InputState}, menu::{ContextMenuExt as _, PopupMenu}, diff --git a/nebula_settings/src/lib.rs b/nebula_settings/src/lib.rs index bfec89e..78ae286 100644 --- a/nebula_settings/src/lib.rs +++ b/nebula_settings/src/lib.rs @@ -132,9 +132,8 @@ pub fn persist_keybinds(pairs: &[(String, String)]) -> std::io::Result<()> { pub fn apply_keybinds(text: &str, pairs: &[(String, String)]) -> String { let mut out = String::with_capacity(text.len() + 64); for line in text.lines() { - let is_keybind = line - .split_once('=') - .is_some_and(|(key, _)| key.trim().eq_ignore_ascii_case("keybind")); + let is_keybind = + line.split_once('=').is_some_and(|(key, _)| key.trim().eq_ignore_ascii_case("keybind")); if !is_keybind { out.push_str(line); out.push('\n'); @@ -157,9 +156,9 @@ pub fn apply_updates(text: &str, updates: &[(&str, String)]) -> String { for line in text.lines() { let key = line.split_once('=').map(|(key, _)| key.trim().to_ascii_lowercase()); - let hit = key.as_deref().and_then(|key| { - pending.iter().position(|(_, (k, _))| k.eq_ignore_ascii_case(key)) - }); + let hit = key + .as_deref() + .and_then(|key| pending.iter().position(|(_, (k, _))| k.eq_ignore_ascii_case(key))); match hit { Some(ix) => { let (_, (key, value)) = pending.remove(ix); @@ -815,10 +814,7 @@ impl RuntimeSettings { .value("vcs_display") .and_then(VcsDisplayName::from_settings) .unwrap_or_default(), - bell: raw - .value("bell") - .and_then(BellModeName::from_settings) - .unwrap_or_default(), + bell: raw.value("bell").and_then(BellModeName::from_settings).unwrap_or_default(), fetch: raw.bool_on("fetch").unwrap_or(false), keep_session: raw.bool_on("keep_session").unwrap_or(false), restore_session: raw.bool_on("restore_session").unwrap_or(true), @@ -838,9 +834,7 @@ impl RuntimeSettings { .map(|o| o.clamp(0.0, 1.0)) .unwrap_or(0.38), background_image_fit: raw.value("background_image_fit").map(str::to_owned), - background_image_alignment: raw - .value("background_image_alignment") - .map(str::to_owned), + background_image_alignment: raw.value("background_image_alignment").map(str::to_owned), background_image_cover_chrome: raw .bool_on("background_image_cover_chrome") .unwrap_or(false), @@ -1008,10 +1002,7 @@ mod tests { #[test] fn tabs_position_parses_supported_values_and_defaults_to_sidebar() { - assert_eq!( - TabsPositionName::from_settings("sidebar"), - Some(TabsPositionName::Sidebar) - ); + assert_eq!(TabsPositionName::from_settings("sidebar"), Some(TabsPositionName::Sidebar)); assert_eq!(TabsPositionName::from_settings("TOP"), Some(TabsPositionName::Top)); assert_eq!(TabsPositionName::from_settings("bottom"), None); assert_eq!( @@ -1066,10 +1057,8 @@ mod tests { #[test] fn apply_updates_replaces_in_place_and_appends_missing() { let text = "language=system\ntheme=Nebula\nshell=powershell\n"; - let updated = apply_updates( - text, - &[("theme", "SilverLight".into()), ("cursor_blink", "1".into())], - ); + let updated = + apply_updates(text, &[("theme", "SilverLight".into()), ("cursor_blink", "1".into())]); assert_eq!( updated, "language=system\ntheme=SilverLight\nshell=powershell\ncursor_blink=1\n" @@ -1087,10 +1076,7 @@ mod tests { ] ); let rewritten = apply_keybinds(text, &[("ctrl+y".to_owned(), "Paste".to_owned())]); - assert_eq!( - rewritten, - "theme=Nebula\n# comment\nkeybind=ctrl+y:Paste\n" - ); + assert_eq!(rewritten, "theme=Nebula\n# comment\nkeybind=ctrl+y:Paste\n"); } #[test] diff --git a/nebula_split/src/lib.rs b/nebula_split/src/lib.rs index 2a32655..84af9b3 100644 --- a/nebula_split/src/lib.rs +++ b/nebula_split/src/lib.rs @@ -145,14 +145,22 @@ impl SplitTree { } } + /// 原位替换一个叶值，保留完整树形、分割方向和比例。 + pub fn replace_leaf(&mut self, target: T, replacement: T) -> bool { + match self { + SplitTree::Leaf(id) if *id == target => { + *id = replacement; + true + }, + SplitTree::Leaf(_) => false, + SplitTree::Split { first, second, .. } => { + first.replace_leaf(target, replacement) || second.replace_leaf(target, replacement) + }, + } + } + /// 把 `target` 叶子替换成 `[target, new]` 的 Split。找到返回 `true`。 - pub fn split_leaf( - &mut self, - target: T, - new: T, - direction: SplitDirection, - ratio: f32, - ) -> bool { + pub fn split_leaf(&mut self, target: T, new: T, direction: SplitDirection, ratio: f32) -> bool { match self { SplitTree::Leaf(id) if *id == target => { let old = *id; @@ -464,6 +472,16 @@ mod tests { assert_eq!(tree.remove_leaf(3), RemoveOutcome::WasRoot); } + #[test] + fn replace_leaf_preserves_depth_first_position() { + let mut tree = SplitTree::leaf(1u32); + assert!(tree.split_leaf(1, 2, SplitDirection::LeftRight, 0.5)); + assert!(tree.split_leaf(2, 3, SplitDirection::TopBottom, 0.5)); + assert!(tree.replace_leaf(2, 9)); + assert_eq!(tree.leaves(), vec![1, 9, 3]); + assert!(!tree.replace_leaf(7, 8)); + } + #[test] fn layout_splits_left_right_with_floor_and_divider() { let tree = lr(0.5, SplitTree::Leaf(1), SplitTree::Leaf(2)); diff --git a/nebula_terminal/src/event_loop.rs b/nebula_terminal/src/event_loop.rs index c5161bb..7543365 100644 --- a/nebula_terminal/src/event_loop.rs +++ b/nebula_terminal/src/event_loop.rs @@ -475,7 +475,8 @@ where // 一坐标系（机理见 `Term::conpty_realign`）。 if state.align_at.is_some_and(|at| Instant::now() >= at) { state.align_at = None; - if let Some(target) = self.pty.child_pid().and_then(conpty_cursor_viewport_row) { + if let Some(target) = self.pty.child_pid().and_then(conpty_cursor_viewport_row) + { let mut terminal = self.terminal.lock(); trace_terminal_state("before-align", &terminal); terminal.conpty_realign(target); diff --git a/nebula_terminal/src/grid/mod.rs b/nebula_terminal/src/grid/mod.rs index 981a469..dcde45a 100644 --- a/nebula_terminal/src/grid/mod.rs +++ b/nebula_terminal/src/grid/mod.rs @@ -485,7 +485,12 @@ impl Grid { /// the iterator bounded here avoids allocating a projected grid just to /// render the clipped viewport. #[inline] - pub fn display_iter_from(&self, top: Line, lines: usize, columns: usize) -> GridIterator<'_, T> { + pub fn display_iter_from( + &self, + top: Line, + lines: usize, + columns: usize, + ) -> GridIterator<'_, T> { debug_assert!(lines > 0); debug_assert!(columns > 0); diff --git a/nebula_terminal/src/tty/windows/blocking.rs b/nebula_terminal/src/tty/windows/blocking.rs index 21dac28..2579141 100644 --- a/nebula_terminal/src/tty/windows/blocking.rs +++ b/nebula_terminal/src/tty/windows/blocking.rs @@ -6,7 +6,7 @@ use std::sync::{Arc, Mutex}; use std::task::{Context, Poll, Wake, Waker}; use std::{io, thread}; -use piper::{pipe, Reader, Writer}; +use piper::{Reader, Writer, pipe}; use polling::os::iocp::{CompletionPacket, PollerIocpExt}; use polling::{Event, PollMode, Poller}; @@ -122,10 +122,27 @@ impl UnblockedReader { pub fn try_read(&mut self, buf: &mut [u8]) -> usize { let waker = Waker::from(self.interest.clone()); - match self.pipe.poll_drain_bytes(&mut Context::from_waker(&waker), buf) { + let read = match self.pipe.poll_drain_bytes(&mut Context::from_waker(&waker), buf) { Poll::Pending => 0, Poll::Ready(n) => n, + }; + + // piper 只在「管道为空」的那次读取里注册 read waker，一旦读到数据就 + // 立刻把它 take 掉，而写入侧的 `wake()` 对空 waker 是 no-op。于是调用 + // 方在管道仍有数据时停止读取（`pty_read` 到 `MAX_LOCKED_READ` 就会 + // 返回）时，会同时失去 waker 和待投递的 readable 事件 —— 对端随后一 + // 静默（AI CLI 答完就不再输出），这批字节便永久留在管道里：画面停在 + // 一个画到一半的残帧，滚动条却仍在底部，只有按键或 resize 能救回来 + // （前者触发 reregister 补投，后者走 resize 前的强制排空循环）。 + // + // `PollMode::Level` 承诺的是「只要还有数据就保持可读」，这里补上 + // piper 不会替我们做的那次投递。正常读取路径下调用方的缓冲远大于 + // 管道存量，一次就能读空，因此不会产生多余事件。 + if read > 0 && !self.pipe.is_empty() { + waker.wake_by_ref(); } + + read } /// Hand the receiving end to a detached thread that keeps consuming until diff --git a/nebula_terminal/src/tty/windows/child.rs b/nebula_terminal/src/tty/windows/child.rs index e034b1c..9d1a49a 100644 --- a/nebula_terminal/src/tty/windows/child.rs +++ b/nebula_terminal/src/tty/windows/child.rs @@ -5,14 +5,14 @@ use std::os::windows::process::ExitStatusExt; use std::process::ExitStatus; use std::ptr; use std::sync::atomic::{AtomicPtr, Ordering}; -use std::sync::{mpsc, Arc, Mutex}; +use std::sync::{Arc, Mutex, mpsc}; use polling::os::iocp::{CompletionPacket, PollerIocpExt}; use polling::{Event, Poller}; use windows_sys::Win32::Foundation::{BOOLEAN, FALSE, HANDLE}; use windows_sys::Win32::System::Threading::{ - GetExitCodeProcess, GetProcessId, RegisterWaitForSingleObject, UnregisterWait, INFINITE, + GetExitCodeProcess, GetProcessId, INFINITE, RegisterWaitForSingleObject, UnregisterWait, WT_EXECUTEINWAITTHREAD, WT_EXECUTEONLYONCE, }; diff --git a/nebula_terminal/src/tty/windows/conpty.rs b/nebula_terminal/src/tty/windows/conpty.rs index 0223913..1a82a91 100644 --- a/nebula_terminal/src/tty/windows/conpty.rs +++ b/nebula_terminal/src/tty/windows/conpty.rs @@ -7,25 +7,25 @@ use std::os::windows::io::IntoRawHandle; use std::path::{Path, PathBuf}; use std::{mem, ptr}; -use windows_sys::core::{HRESULT, PWSTR}; -use windows_sys::s; use windows_sys::Win32::Foundation::{HANDLE, S_OK}; use windows_sys::Win32::System::Console::{ - ClosePseudoConsole, CreatePseudoConsole, ResizePseudoConsole, COORD, HPCON, + COORD, ClosePseudoConsole, CreatePseudoConsole, HPCON, ResizePseudoConsole, }; use windows_sys::Win32::System::LibraryLoader::{GetProcAddress, LoadLibraryW}; +use windows_sys::core::{HRESULT, PWSTR}; +use windows_sys::s; use windows_sys::Win32::System::Threading::{ - CreateProcessW, InitializeProcThreadAttributeList, UpdateProcThreadAttribute, - CREATE_UNICODE_ENVIRONMENT, EXTENDED_STARTUPINFO_PRESENT, PROCESS_INFORMATION, - PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE, STARTF_USESTDHANDLES, STARTUPINFOEXW, STARTUPINFOW, + CREATE_UNICODE_ENVIRONMENT, CreateProcessW, EXTENDED_STARTUPINFO_PRESENT, + InitializeProcThreadAttributeList, PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE, PROCESS_INFORMATION, + STARTF_USESTDHANDLES, STARTUPINFOEXW, STARTUPINFOW, UpdateProcThreadAttribute, }; use crate::event::{OnResize, WindowSize}; +use crate::tty::Options; use crate::tty::windows::blocking::{UnblockedReader, UnblockedWriter}; use crate::tty::windows::child::ChildExitWatcher; -use crate::tty::windows::{cmdline, win32_string, Pty}; -use crate::tty::Options; +use crate::tty::windows::{Pty, cmdline, win32_string}; const PIPE_CAPACITY: usize = crate::event_loop::READ_BUFFER_SIZE; diff --git a/nebula_terminal/src/tty/windows/mod.rs b/nebula_terminal/src/tty/windows/mod.rs index 72486e8..61ef7a7 100644 --- a/nebula_terminal/src/tty/windows/mod.rs +++ b/nebula_terminal/src/tty/windows/mod.rs @@ -3,8 +3,8 @@ use std::io::{self, Result}; use std::iter::once; use std::os::windows::ffi::OsStrExt; use std::path::PathBuf; -use std::sync::mpsc::TryRecvError; use std::sync::Arc; +use std::sync::mpsc::TryRecvError; use windows_sys::Win32::System::Threading::TerminateProcess; @@ -1008,9 +1008,9 @@ mod test { use std::process::{Command, Stdio}; use crate::tty::windows::{ - cmdline, explicit_bash_integration_args, nebula_default_shell, nebula_find_bash, - powershell_integration_args, push_escaped_arg, NebulaRuntimeSettings, NebulaShellExecutor, - NEBULA_BASH_RC, NEBULA_PROMPT_PS1, + NEBULA_BASH_RC, NEBULA_PROMPT_PS1, NebulaRuntimeSettings, NebulaShellExecutor, cmdline, + explicit_bash_integration_args, nebula_default_shell, nebula_find_bash, + powershell_integration_args, push_escaped_arg, }; use crate::tty::{Options, Shell};