diff options
97 files changed, 32952 insertions, 18579 deletions
diff --git a/CHANGELOG.md b/CHANGELOG.md index 6b8943c7..c96ec07d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,21 @@ ## Unreleased +### Added +- herdr now defaults to a persistent server/client session model. launching `herdr` starts or reattaches to a background session server, and `herdr server stop` shuts that server down explicitly. +- The thin client, headless server, and their integration coverage are now part of the main product, including detach and reattach flows, multi-client attach, and auto-detect launch. + +### Changed +- In persistence mode, in-app quit actions now detach the current client by default instead of shutting down the whole background server. +- The current persistence model is a shared session view across attached clients. It is not yet full tmux-style per-client independent navigation. + +### Fixed +- Headless client input routing now re-encodes keys for the focused pane's negotiated keyboard protocol, fixing broken modified keys like Ghostty CSI-u `Ctrl-C` sequences reaching panes as literal text. +- Thin-client frame blitting now resets style state correctly between cells, fixing modifier leakage artifacts such as long underline-like horizontal lines. +- Client/server mode now restores the host terminal default foreground and background theme sync, so libghostty panes no longer fall back to a black background when attached through the persistence client. +- Client-side persistence notifications no longer leak plain text into the pane area. +- Clipboard copy in persistence mode now routes through attached clients correctly, and SSH sessions prefer OSC 52 over remote clipboard helpers. + ## [0.4.11] - 2026-04-16 ### Breaking Changes Please Read diff --git a/CONFIGURATION.md b/CONFIGURATION.md index fac2dd57..3396cc33 100644 --- a/CONFIGURATION.md +++ b/CONFIGURATION.md @@ -53,7 +53,7 @@ example: prefix = "ctrl+b" new_workspace = "n" rename_workspace = "shift+n" -close_workspace = "d" +close_workspace = "shift+d" new_tab = "c" split_vertical = "v" split_horizontal = "-" @@ -71,35 +71,6 @@ focus_pane_up = "alt+k" focus_pane_right = "alt+l" ``` -### custom command bindings - -custom commands also live under `[keys]`, but use repeated `[[keys.command]]` tables. - -each binding runs after pressing the prefix key and then the configured command key. - -actions: -- `type = "shell"` launches a detached `/bin/sh -lc ...` command in the background -- `type = "pane"` opens a temporary overlay pane, runs the command there, then restores the previous pane focus when it exits - -example: - -```toml -[[keys.command]] -key = "g" -type = "pane" -command = "lazygit" - -[[keys.command]] -key = "o" -command = "~/bin/herdr-open-current \"$HERDR_ACTIVE_WORKSPACE_ID\" \"$HERDR_ACTIVE_TAB_ID\" \"$HERDR_ACTIVE_PANE_ID\" \"$HERDR_ACTIVE_PANE_CWD\"" -``` - -notes: -- `type` defaults to `"shell"` -- custom command keys share the same navigate-mode key namespace as built-in actions, so conflicts are rejected as config errors -- `pane` commands require an active workspace and focused pane -- shell commands inherit useful context through environment variables listed below - ### key reference | key | default | action | @@ -107,7 +78,8 @@ notes: | `prefix` | `ctrl+b` | enter or leave navigate mode | | `new_workspace` | `n` | create a new workspace | | `rename_workspace` | `shift+n` | rename selected workspace | -| `close_workspace` | `d` | close selected workspace | +| `close_workspace` | `shift+d` | close selected workspace | +| `detach` | unset | optional explicit detach shortcut in the persistent session | | `previous_workspace` | unset | switch to the previous workspace directly from terminal mode | | `next_workspace` | unset | switch to the next workspace directly from terminal mode | | `new_tab` | `c` | create a new tab | @@ -292,18 +264,13 @@ notes: - this matches Ghostty's default `scrollback-limit` value - set `scrollback_limit_bytes = 0` to disable pane scrollback entirely - the old `advanced.scrollback_lines` key is still accepted as a compatibility alias, but it uses the same byte-based value +- in default persistence mode, quitting the ui detaches the current client; use `herdr server stop` to stop the shared background server ## environment variables | variable | description | |----------|-------------| | `HERDR_LOG` | log level filter (default: `herdr=info`) | -| `HERDR_SOCKET_PATH` | socket path for `herdr` cli subcommands and scripts started from inside herdr | -| `HERDR_BIN_PATH` | absolute path to the running herdr binary | -| `HERDR_ACTIVE_WORKSPACE_ID` | active workspace id when a custom command is launched | -| `HERDR_ACTIVE_TAB_ID` | active tab id when a custom command is launched | -| `HERDR_ACTIVE_PANE_ID` | focused pane id when a custom command is launched | -| `HERDR_ACTIVE_PANE_CWD` | focused pane cwd when available; shell commands also use it as their working directory | logs are written to: @@ -45,6 +45,26 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6" [[package]] +name = "bincode" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "36eaf5d7b090263e8150820482d5d93cd964a81e4019913c972f4edcc6edb740" +dependencies = [ + "bincode_derive", + "serde", + "unty", +] + +[[package]] +name = "bincode_derive" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bf95709a440f45e986983918d0e8a1f30a9b1df04918fc828670606804ac3c09" +dependencies = [ + "virtue", +] + +[[package]] name = "bit-set" version = "0.5.3" source = "registry+https://github.com/rust-lang/crates.io-index" @@ -81,6 +101,15 @@ dependencies = [ ] [[package]] +name = "block2" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cdeb9d870516001442e364c5220d3574d2da8dc765554b4a617230d33fa58ef5" +dependencies = [ + "objc2", +] + +[[package]] name = "bumpalo" version = "3.20.2" source = "registry+https://github.com/rust-lang/crates.io-index" @@ -205,6 +234,17 @@ dependencies = [ ] [[package]] +name = "ctrlc" +version = "3.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e0b1fab2ae45819af2d0731d60f2afe17227ebb1a1538a236da84c93e9a60162" +dependencies = [ + "dispatch2", + "nix 0.31.2", + "windows-sys", +] + +[[package]] name = "darling" version = "0.23.0" source = "registry+https://github.com/rust-lang/crates.io-index" @@ -286,6 +326,18 @@ dependencies = [ ] [[package]] +name = "dispatch2" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e0e367e4e7da84520dedcac1901e4da967309406d1e51017ae1abfb97adbd38" +dependencies = [ + "bitflags 2.11.0", + "block2", + "libc", + "objc2", +] + +[[package]] name = "document-features" version = "0.2.12" source = "registry+https://github.com/rust-lang/crates.io-index" @@ -448,8 +500,10 @@ name = "herdr" version = "0.4.11" dependencies = [ "base64", + "bincode", "bytes", "crossterm", + "ctrlc", "libc", "portable-pty", "ratatui", @@ -704,6 +758,18 @@ dependencies = [ ] [[package]] +name = "nix" +version = "0.31.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d6d0705320c1e6ba1d912b5e37cf18071b6c2e9b7fa8215a1e8a7651966f5d3" +dependencies = [ + "bitflags 2.11.0", + "cfg-if", + "cfg_aliases 0.2.1", + "libc", +] + +[[package]] name = "nom" version = "7.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" @@ -758,6 +824,21 @@ dependencies = [ ] [[package]] +name = "objc2" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3a12a8ed07aefc768292f076dc3ac8c48f3781c8f2d5851dd3d98950e8c5a89f" +dependencies = [ + "objc2-encode", +] + +[[package]] +name = "objc2-encode" +version = "4.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef25abbcd74fb2609453eb695bd2f860d389e457f67dc17cafc8b8cbc89d0c33" + +[[package]] name = "once_cell" version = "1.21.4" source = "registry+https://github.com/rust-lang/crates.io-index" @@ -1654,6 +1735,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853" [[package]] +name = "unty" +version = "0.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d49784317cd0d1ee7ec5c716dd598ec5b4483ea832a2dced265471cc0f690ae" + +[[package]] name = "utf8parse" version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" @@ -1684,6 +1771,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" [[package]] +name = "virtue" +version = "0.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "051eb1abcf10076295e815102942cc58f9d5e3b4560e46e53c21e8ff6f3af7b1" + +[[package]] name = "vtparse" version = "0.6.2" source = "registry+https://github.com/rust-lang/crates.io-index" @@ -13,8 +13,10 @@ include = ["src/**/*", "assets/sounds/*", "README.md", "LICENSE", "Cargo.toml"] [dependencies] base64 = "0.22.1" +bincode = { version = "2", features = ["serde"] } bytes = "1" crossterm = "0.29" +ctrlc = "3" libc = "0.2" portable-pty = "0.9" ratatui = "0.30" @@ -1,40 +1,25 @@ -<p align="center"> - <img src="assets/logo.png" alt="herdr" width="120" /> -</p> - -<h1 align="center">herdr</h1> +# herdr -<p align="center"><strong>supervise multiple coding agents in one terminal.</strong></p> -<p align="center">herd your agents.</p> +<p align="center"> + <img src="assets/logo.png" alt="herdr" width="100" /> +</p> <p align="center"> - <a href="https://herdr.dev">herdr.dev</a> · <a href="#install">install</a> · <a href="#quick-start">quick start</a> · <a href="#supported-agents">supported agents</a> · <a href="./INTEGRATIONS.md">integrations</a> · <a href="./CONFIGURATION.md">configuration</a> · <a href="./SKILL.md">agent skill</a> · <a href="./SOCKET_API.md">socket api</a> + <a href="https://herdr.dev">herdr.dev</a> · <a href="#install">install</a> · <a href="#quick-start">quick start</a> · <a href="#supported-agents">supported agents</a> · <a href="./INTEGRATIONS.md">integrations</a> · <a href="./CONFIGURATION.md">configuration</a> · <a href="./SOCKET_API.md">socket api</a> </p> --- -herdr is a terminal-native workspace manager for coding agents. - -run Claude Code, Codex, pi, opencode, droid, amp and plain shells side by side in your existing terminal. herdr gives you workspaces, tabs, panes, automatic agent detection, and notification alerts so you can see which agent is blocked, done, or still working without leaving the command line. - -it runs inside ghostty, alacritty, kitty, wezterm, and even inside tmux. it is a single Rust binary, not a separate GUI window, electron wrapper, or web dashboard. - -https://github.com/user-attachments/assets/043ec09f-4bdd-41d5-aee0-8fda6b83e267 - -## why herdr - -running one coding agent is easy. running several in parallel gets messy fast. +<p align="center"> + <img src="https://github.com/user-attachments/assets/043ec09f-4bdd-41d5-aee0-8fda6b83e267" alt="herdr demo" width="700" /> +</p> -most tools in this space either replace your environment or give you panes without any awareness of what those panes are doing. herdr stays inside your terminal and adds the missing layer: supervision. +**agent multiplexer that lives in your terminal.** -with herdr you can: +workspaces, tabs, panes. mouse-native: click, drag, split. every agent at a glance: blocked, working, done. detach and reattach, agents keep running. no gui app, no electron, no mac-only native wrapper. you see the agent's own terminal, not someone's interpretation of it. -- run multiple coding agents in parallel in one terminal-native workspace -- scan workspaces quickly and see which one needs attention -- spot whether an agent is blocked, finished, working, or idle -- jump between repos, tabs, and panes without losing context -- let agents create panes, spawn helpers, read output, and wait on each other through the local api +--- ## install @@ -42,15 +27,11 @@ with herdr you can: curl -fsSL https://herdr.dev/install.sh | sh ``` -or download the binary directly from [releases](https://github.com/ogulcancelik/herdr/releases). - -requirements: linux or macos. +or download the binary from [releases](https://github.com/ogulcancelik/herdr/releases). requires linux or macos. ### update -herdr checks for updates automatically in the background. when a new version is ready, you'll see a notification in the ui. restart to apply it. - -for a manual update: +herdr notifies you when a new version is available. run manually to update: ```bash herdr update @@ -58,82 +39,102 @@ herdr update ## quick start -launch herdr: - ```bash herdr ``` -then do this: +by default herdr launches or attaches to a background session server. `ctrl+b q` detaches the client. agents keep running. use `herdr server stop` to stop the server. use `--no-session` for the old single-process mode. 1. press `n` to create a workspace 2. run an agent in the root pane 3. press `ctrl+b` to enter navigate mode 4. use `v` or `-` to split panes, or `c` to create a new tab -5. run more agents side by side -6. watch the sidebar to see which workspace or agent needs attention +5. watch the sidebar for blocked, working, and done states -on first run, herdr opens a short onboarding flow so you can choose your notification style. after that, if a session is restored you'll land in terminal mode; otherwise you'll start in **navigate mode**. +on first run herdr opens a short onboarding flow. after that, restored sessions land in terminal mode; fresh sessions start in **navigate mode**. -## what you get +## how it compares -### workspaces, tabs, and panes +| | tmux | gui managers | herdr | +|--------------------------|------|--------------|-------| +| persistent sessions | ✓ | — | ✓ | +| detach / reattach | ✓ | — | ✓ | +| panes, tabs, workspaces | ✓ | ✓ | ✓ | +| agent awareness | — | ✓ | ✓ | +| lives in your terminal | ✓ | — | ✓ | +| real terminal views | ✓ | — | ✓ | +| mouse-native | — | ✓ | ✓ | +| lightweight binary | ✓ | — | ✓ | +| agents can orchestrate | ? | ? | ✓ | -herdr is organized around workspaces. each workspace can contain multiple tabs, and each tab can contain multiple panes. +tmux gives you persistence and panes, but it was built before agents existed. gui managers show agent state, but they make you leave your terminal and use their wrapped view. herdr is persistence and awareness in one tool that stays out of your way. -workspaces open immediately as real terminal contexts. the first pane in a workspace is the **root pane**. it anchors the workspace and gives it its default identity: +## persistence -- if the root pane is inside a git repo, the workspace label defaults to the repo name -- otherwise it falls back to the current folder name -- manual rename is supported, but the default model is repo or folder first +start herdr on your desktop or server. run your agents, split panes, do your work. press `ctrl+b q` to detach. close your terminal, close your laptop; your agents keep running. open a new terminal, run `herdr`, you're back. same session, same panes, same agents. -this keeps workspaces lightweight. they are project contexts first, labels second. +### from anywhere -### awareness and notifications +need to check on your agents from your phone? just ssh in and run herdr. any ssh client works. no app to download, no account to create. -the sidebar is split into two layers: +``` +ssh you@yourserver +herdr +``` -- **top:** workspaces, each with one aggregate state dot -- **bottom:** detected agents inside the selected workspace, or across all workspaces when you switch the agent panel scope +same session, same agents, same state. -herdr automatically detects running agents by looking at the foreground process and reading terminal output. workspace rollups surface the most urgent thing happening in each workspace so you can scan the full list quickly. +## agent awareness -in expanded view, the workspace list and agent list have their own resizable sections. in collapsed view, you still get compact per-pane agent indicators. +the sidebar shows which agents are blocked, working, or done. workspaces roll up to their most urgent state so you can scan the full list at a glance. -states map to: +states: - 🔴 **blocked** — agent needs input or approval -- 🔵 **done** — work finished and you have not looked at it yet - 🟡 **working** — agent is actively running -- 🟢 **idle** — done, seen, and calm +- 🔵 **done** — work finished, you have not looked at it yet +- 🟢 **idle** — done and seen -rollups prefer the most urgent state in a workspace: blocked first, then unseen finished work, then working, then idle. +detection works by reading foreground process and terminal output. zero config, no hooks required. for agents that expose hooks, the socket api integration gives more robust state reporting. -plain shells still matter to the workspace itself, but the sidebar stays focused on actual agents. +## lives in your terminal -if ambient sidebar awareness is not enough, herdr can also play sounds or show top-right toast notifications for background events. notification suppression is tab-aware: the active tab stays quiet, but background tabs in the same workspace can still alert. +not a gui window, not a web dashboard, not electron. herdr runs inside whatever terminal you already use. single rust binary, no dependencies. works inside tmux. -### agents can use herdr too +## what you get -herdr is not only for humans supervising agents. it is also becoming a shared control surface for the agents themselves. +- **workspaces** — organized around git repos or folder names, each with its own tabs and panes +- **tabs** — first-class in the socket api and cli +- **mouse-native** — click panes, drag borders, select text to copy; not keyboard-only +- **notifications** — sounds and toasts for background events; tab-aware suppression +- **9 built-in themes** — catppuccin (default), tokyo night, dracula, nord, gruvbox, one dark, solarized, kanagawa, rosé pine +- **session persistence** — pane processes survive client detach; sessions restore after full restart -agents running inside herdr can use the local socket api and cli wrappers to: +## agents can use herdr too -- create new workspaces for parallel tasks -- create, focus, rename, and close tabs -- split panes for servers, logs, tests, or scratch work -- spawn other agents in sibling panes -- read pane output or wait for output matches -- send text and keys into other panes -- wait for another agent to finish before continuing +the local unix socket lets agents create workspaces, split panes, spawn helpers, read output, and wait for state changes. -for that workflow, start with [`SKILL.md`](./SKILL.md) if you want a reusable agent skill, or [`SOCKET_API.md`](./SOCKET_API.md) if you want the low-level socket protocol and cli wrapper reference. +```bash +# create a workspace and tab +herdr workspace create --cwd ~/project --label "api" +herdr tab create --label "logs" -## supported agents +# split a pane and run +herdr pane split 1-1 --direction right +herdr pane run 1-2 "npm test" + +# wait for an agent +herdr wait agent-status 1-1 --status done + +# read output +herdr pane read 1-2 --source recent --lines 50 +``` -herdr detects supported agents automatically with zero setup. it identifies the foreground process in each pane and reads the live bottom of the terminal buffer to infer agent state. for agents that expose hooks or plugins, direct integrations are the more robust path because they forward semantic state to herdr over the local socket api. +full reference: [`SOCKET_API.md`](./SOCKET_API.md) and [`SKILL.md`](./SKILL.md). -the following agents have been tested: +## supported agents + +automatic detection works out of the box. process name matching plus terminal output heuristics. | agent | idle / done | working | blocked | |-------|-------------|---------|---------| @@ -144,30 +145,13 @@ the following agents have been tested: | [amp](https://ampcode.com) | ✓ | ✓ | ✓ | | [opencode](https://github.com/anomalyco/opencode) | ✓ | ✓ | ✓ | -heuristics also exist for these agents but have not been fully tested yet: - -- [gemini cli](https://github.com/google-gemini/gemini-cli) -- [cursor agent](https://cursor.com/cli) -- [cline](https://github.com/cline/cline) -- [kimi](https://kimi.ai) -- [github copilot cli](https://cli.github.com) - -for any other cli agent, herdr still works as a terminal-native multiplexer. you still get workspaces, panes, tiling, and notifications even when richer state detection is not available yet. - -for agents outside the built-in list, herdr also supports custom hook or plugin integrations over the local socket api. a custom integration can report any non-empty agent label, and that label will appear in pane info, events, and the sidebar without needing first-party built-in detection. see [`SOCKET_API.md`](./SOCKET_API.md) for the raw api surface. +detected but not fully tested: gemini cli, cursor agent, cline, kimi, github copilot cli. -## optional direct integrations +for agents outside the built-in list, herdr still works as a terminal multiplexer with workspaces, panes, and tiling. custom integrations can report agent labels over the socket api. see [`SOCKET_API.md`](./SOCKET_API.md). -automatic detection works out of the box. if an agent exposes hooks or plugins, the better path is to let it report state to herdr over the local socket api. +### direct integrations -herdr ships one-command integrations for: - -- [pi](./INTEGRATIONS.md#pi) -- [claude code](./INTEGRATIONS.md#claude-code) -- [codex](./INTEGRATIONS.md#codex) -- [opencode](./INTEGRATIONS.md#opencode) - -install them with: +the built-in pi, claude code, codex, and opencode integrations forward semantic state to herdr over the socket api. install with: ```bash herdr integration install pi @@ -176,170 +160,45 @@ herdr integration install codex herdr integration install opencode ``` -remove them with: - -```bash -herdr integration uninstall pi -herdr integration uninstall claude -herdr integration uninstall codex -herdr integration uninstall opencode -``` - -these integrations forward semantic state to herdr over the local socket api. that gives you more robust status reporting, but it does not replace herdr's core process detection model. for setup details, installed file locations, caveats, and the exact bundled hook or plugin source files, see [`INTEGRATIONS.md`](./INTEGRATIONS.md). - -known codex caveat: codex currently renders hook lifecycle lines in its own tui when hooks are enabled. that noise is upstream codex behavior, not herdr-specific. - -## usage - -### navigate mode - -navigate mode is the workspace control layer. press `ctrl+b` to enter it. +see [`INTEGRATIONS.md`](./INTEGRATIONS.md) for setup details. -movement actions stay in navigate mode. mutating actions like split, close, new workspace, new tab, and sidebar toggle return you to terminal mode. +## keybindings -common defaults: - -- `n` new workspace -- `shift+n` rename workspace -- `d` close workspace -- `c` new tab -- `v` / `-` split pane -- `x` close pane -- `f` fullscreen -- `r` resize mode -- `b` toggle sidebar - -optional direct bindings are available but **unset by default**. you can bind workspace, tab, and pane switching directly in terminal mode without going through the prefix first. - -prefix mode also supports custom commands with `[[keys.command]]`. that lets you launch detached shell helpers or temporary overlay panes. two common examples are opening `lazygit` in a pane and running your own script with the active herdr ids and cwd. - -example: - -```toml -[keys] -previous_workspace = "ctrl+alt+[" -next_workspace = "ctrl+alt+]" -previous_tab = "alt+[" -next_tab = "alt+]" -focus_pane_left = "alt+h" -focus_pane_down = "alt+j" -focus_pane_up = "alt+k" -focus_pane_right = "alt+l" - -[[keys.command]] -key = "g" -type = "pane" -command = "lazygit" - -[[keys.command]] -key = "o" -command = "~/bin/herdr-open-current \"$HERDR_ACTIVE_WORKSPACE_ID\" \"$HERDR_ACTIVE_TAB_ID\" \"$HERDR_ACTIVE_PANE_ID\" \"$HERDR_ACTIVE_PANE_CWD\"" -``` - -full keybinding and config reference: [`CONFIGURATION.md`](./CONFIGURATION.md) - -### resize mode +press `ctrl+b` to enter navigate mode. | key | action | |-----|--------| -| `h` `l` | resize width | -| `j` `k` | resize height | -| `esc` | exit resize mode | +| `n` | new workspace | +| `shift+n` | rename workspace | +| `shift+d` | close workspace | +| `c` | new tab | +| `v` / `-` | split pane | +| `x` | close pane | +| `b` | toggle sidebar | +| `f` | fullscreen pane | +| `r` | resize mode | +| `q` | detach (quit client) | -### mouse +resize mode: `h`/`l` resize width, `j`/`k` resize height, `esc` exit. -mouse support is built in. herdr is not keyboard-only. - -- click a workspace in the sidebar to switch -- click tabs to switch within the active workspace -- click the tab-bar `<` / `>` buttons to scroll overflowing tabs -- drag tabs to reorder them -- click a pane to focus it -- drag split borders to resize -- drag in a pane to select text; release to copy it to your system clipboard -- right-click a workspace for a context menu -- scroll in the sidebar to navigate workspaces -- click `«` / `»` at the sidebar bottom to collapse or expand it - -text copy uses OSC 52, so it depends on your terminal's clipboard support. - -### terminal mode - -terminal mode is a real terminal. your shell, vim, htop, ssh, and other full-screen tools work normally. press the prefix key (`ctrl+b`) to go back to navigate mode. - -## docs map - -use the dedicated docs for detailed setup and automation work: - -- [`CONFIGURATION.md`](./CONFIGURATION.md) — config file, keybindings, themes, notifications, onboarding, ui options, and environment variables -- [`INTEGRATIONS.md`](./INTEGRATIONS.md) — install and behavior notes for pi, Claude Code, Codex, and opencode integrations -- [`SKILL.md`](./SKILL.md) — reusable agent skill for agents already running inside herdr -- [`SOCKET_API.md`](./SOCKET_API.md) — canonical socket protocol and the `herdr workspace`, `herdr tab`, `herdr pane`, and `herdr wait` cli wrappers +mouse is supported throughout. full reference: [`CONFIGURATION.md`](./CONFIGURATION.md). ## configuration config file: `~/.config/herdr/config.toml` -print the full default config with: - ```bash -herdr --default-config -``` - -### themes - -herdr ships with 9 built-in themes: catppuccin (default), tokyo night, dracula, nord, gruvbox, one dark, solarized, kanagawa, and rosé pine. - -```toml -[theme] -name = "tokyo-night" +herdr --default-config # print full default config ``` -you can also override individual color tokens on top of any base theme. see [`CONFIGURATION.md`](./CONFIGURATION.md) for the full token reference. - -for day-to-day changes, you do not have to edit the config by hand. herdr also has an in-app settings screen for theme, sound, and toast preferences. - -## session persistence - -herdr saves your workspaces, tabs, pane layouts, pane working directories, and focused tab or pane automatically as you work, then restores them on restart. sessions are stored at `~/.config/herdr/session.json`. - -through the socket api, tabs are first-class too. raw integrations and cli wrappers can list, create, focus, rename, and close tabs directly while pane ids stay workspace-scoped. - -use `--no-session` to start fresh. - -## how agent detection works - -herdr does not require hooks or agent-side configuration for built-in detection. automatic detection works by: - -1. identifying the foreground process of each pane's pty via `/proc` on linux or `proc_pidinfo` on macos -2. matching the process name against known agents -3. reading the live bottom of the terminal buffer and applying per-agent heuristics to determine state - -this means detection works with any supported agent, installed any way, with zero setup. if it runs in a terminal, herdr can see it. - -when an agent exposes hooks or plugins, the more robust option is to forward state to herdr over the local socket api. that is what the built-in pi, claude code, codex, and opencode integrations do. - -the heuristics are matched against each agent's real terminal output: prompt boxes, spinners, waiting-for-input messages, and tool execution indicators. detection runs on a separate async task per pane, polled every 300 to 500 ms, decoupled from terminal rendering. - -## cli wrappers - -herdr's workspace, tab, pane, and wait commands are documented in [`SOCKET_API.md`](./SOCKET_API.md) together with the socket methods they wrap. - -both `workspace create` and `tab create` support optional `--label` flags, so scripts and agents can name contexts immediately instead of renaming them after creation. both create commands also return the created root pane in their json response, so clients can act on the new pane without an extra lookup. - -workspace ids are compact public ids like `1`, `2`, `3`. -tab ids are compact public ids like `1:1`, `1:2`, `2:1`. -pane ids are compact public ids like `1-1`, `1-2`, `2-1`. - -even with tabs enabled, pane ids remain workspace-scoped public ids rather than `workspace-tab-pane` triples. both tab ids and pane ids are positional within the current live session, so numbering compacts when tabs, workspaces, or panes are closed. - -## built with agents - -i had never written Rust before starting this project. herdr was built almost entirely through ai coding agents, the same ones it is designed to multiplex. i supervised the architecture and specs. agents wrote the code. +in-app settings screen for theme, sound, and toast preferences. full reference: [`CONFIGURATION.md`](./CONFIGURATION.md). -that is part of the point here. herdr is a useful tool, but it is also a proof of what current coding agents can build when they are directed carefully inside a real workflow. +## docs -there will be rough edges. if you hit one, [open an issue](https://github.com/ogulcancelik/herdr/issues). +- [`CONFIGURATION.md`](./CONFIGURATION.md) — keybindings, themes, notifications, environment variables +- [`INTEGRATIONS.md`](./INTEGRATIONS.md) — pi, claude code, codex, opencode integrations +- [`SKILL.md`](./SKILL.md) — reusable agent skill +- [`SOCKET_API.md`](./SOCKET_API.md) — socket protocol and cli reference ## building from source @@ -353,10 +212,10 @@ cargo build --release ## testing ```bash -just test # unit tests -just test-all # full local test suite +just test # unit tests +just test-all # full local test suite ``` ## license -AGPL-3.0: free to use, modify, and distribute. if you distribute a modified version, you must open-source your changes under the same license. +AGPL-3.0: free to use, modify, and distribute. modified versions must be open-sourced under the same license. diff --git a/SOCKET_API.md b/SOCKET_API.md index a7805cee..3ee1cfcc 100644 --- a/SOCKET_API.md +++ b/SOCKET_API.md @@ -9,7 +9,7 @@ if you are teaching an agent that is already running inside herdr, start with [` there are three practical ways to integrate with herdr: - **agent skill** — [`SKILL.md`](./SKILL.md). best when an agent inside herdr just needs to learn the workflow quickly. -- **cli wrappers** — `herdr workspace ...`, `herdr tab ...`, `herdr pane ...`, `herdr wait ...`. best for shell scripts and simple orchestration. +- **cli wrappers** — `herdr server stop`, `herdr workspace ...`, `herdr tab ...`, `herdr pane ...`, `herdr wait ...`. best for shell scripts and simple orchestration. - **raw socket api** — best when you want direct request/response control or long-lived event subscriptions. these layers are intentionally stacked on top of the same control surface. @@ -177,6 +177,7 @@ for backward compatibility, requests also accept the older positional forms like | method | purpose | success result type | |---|---|---| | `ping` | health check / version | `pong` | +| `server.stop` | gracefully stop the running background server | `ok` | | `workspace.list` | list workspaces | `workspace_list` | | `workspace.get` | inspect one workspace | `workspace_info` | | `workspace.create` | create a workspace | `workspace_info` | @@ -203,6 +204,22 @@ for backward compatibility, requests also accept the older positional forms like | `pane.wait_for_output` | one-shot blocking wait for text | `output_matched` | | `events.subscribe` | start a long-lived subscription stream | `subscription_started` ack | +### `server.stop` + +request: + +```json +{ + "id": "req_stop", + "method": "server.stop", + "params": {} +} +``` + +returns `ok` and asks the running background server to shut down cleanly. + +this is the explicit server-level shutdown path for persistence mode. normal in-app quit actions detach the current client instead of sending this request. + ## workspace methods ### `workspace.list` diff --git a/src/api/mod.rs b/src/api/mod.rs index 1b81e09c..437a616e 100644 --- a/src/api/mod.rs +++ b/src/api/mod.rs @@ -2,7 +2,6 @@ pub mod schema; use std::fs; use std::io::{BufRead, BufReader, Read, Write}; -use std::os::unix::fs::PermissionsExt; use std::os::unix::net::{UnixListener, UnixStream}; use std::path::{Path, PathBuf}; use std::sync::atomic::{AtomicBool, Ordering}; @@ -28,6 +27,25 @@ const APP_RESPONSE_TIMEOUT: Duration = Duration::from_secs(5); const INITIAL_REQUEST_TIMEOUT: Duration = Duration::from_secs(5); const STREAM_WRITE_TIMEOUT: Duration = Duration::from_secs(5); +pub(crate) fn request_changes_ui(request: &Request) -> bool { + matches!( + &request.method, + Method::WorkspaceCreate(_) + | Method::WorkspaceFocus(_) + | Method::WorkspaceRename(_) + | Method::WorkspaceClose(_) + | Method::TabCreate(_) + | Method::TabFocus(_) + | Method::TabRename(_) + | Method::TabClose(_) + | Method::PaneSplit(_) + | Method::PaneReportAgent(_) + | Method::PaneClearAgentAuthority(_) + | Method::PaneReleaseAgent(_) + | Method::PaneClose(_) + ) +} + pub struct ApiRequestMessage { pub request: Request, pub respond_to: std::sync::mpsc::Sender<String>, @@ -80,16 +98,6 @@ pub fn socket_path() -> PathBuf { return PathBuf::from(path); } - let socket_name = if crate::config::app_dir_name() == "herdr" { - "herdr.sock" - } else { - "herdr-dev.sock" - }; - - if let Ok(dir) = std::env::var("XDG_RUNTIME_DIR") { - return PathBuf::from(dir).join(socket_name); - } - crate::config::config_dir().join("herdr.sock") } @@ -156,47 +164,16 @@ pub fn start_server( } fn prepare_socket_path(path: &Path) -> std::io::Result<()> { - if let Some(parent) = path.parent() { - fs::create_dir_all(parent)?; - } - - if !path.exists() { - return Ok(()); - } - - match UnixStream::connect(path) { - Ok(_) => { - return Err(std::io::Error::new( - std::io::ErrorKind::AddrInUse, - format!( - "herdr is already running (socket busy at {})", - path.display() - ), - )); - } - Err(err) - if matches!( - err.kind(), - std::io::ErrorKind::ConnectionRefused - | std::io::ErrorKind::NotFound - | std::io::ErrorKind::TimedOut - ) => {} - Err(err) => return Err(err), - } - - if let Err(err) = fs::remove_file(path) { - if err.kind() != std::io::ErrorKind::NotFound { - return Err(err); - } - } - - Ok(()) + crate::ipc::prepare_socket_path(path, |path| { + format!( + "herdr is already running (socket busy at {})", + path.display() + ) + }) } fn restrict_socket_permissions(path: &Path) -> std::io::Result<()> { - let mut permissions = fs::metadata(path)?.permissions(); - permissions.set_mode(SOCKET_PERMISSION_MODE); - fs::set_permissions(path, permissions) + crate::ipc::restrict_socket_permissions(path, SOCKET_PERMISSION_MODE) } fn handle_connection( @@ -947,6 +924,13 @@ fn error_response_json(id: String, code: &str, message: String) -> String { #[cfg(test)] mod tests { use super::*; + use std::os::unix::fs::PermissionsExt; + use std::sync::{Mutex, OnceLock}; + + fn env_lock() -> &'static Mutex<()> { + static LOCK: OnceLock<Mutex<()>> = OnceLock::new(); + LOCK.get_or_init(|| Mutex::new(())) + } fn unique_test_path(name: &str) -> PathBuf { let nanos = std::time::SystemTime::now() @@ -965,6 +949,7 @@ mod tests { #[test] fn socket_path_prefers_explicit_env_override() { + let _guard = env_lock().lock().unwrap(); let unique = format!("/tmp/herdr-test-{}.sock", std::process::id()); std::env::set_var(SOCKET_PATH_ENV_VAR, &unique); assert_eq!(socket_path(), PathBuf::from(&unique)); @@ -972,6 +957,24 @@ mod tests { } #[test] + fn socket_path_defaults_to_config_dir_even_when_xdg_runtime_dir_is_set() { + let _guard = env_lock().lock().unwrap(); + let config_home = unique_test_path("socket-default-config-home"); + let runtime_dir = unique_test_path("socket-default-runtime"); + std::env::remove_var(SOCKET_PATH_ENV_VAR); + std::env::set_var("XDG_CONFIG_HOME", &config_home); + std::env::set_var("XDG_RUNTIME_DIR", &runtime_dir); + + let expected = config_home + .join(crate::config::app_dir_name()) + .join("herdr.sock"); + assert_eq!(socket_path(), expected); + + std::env::remove_var("XDG_CONFIG_HOME"); + std::env::remove_var("XDG_RUNTIME_DIR"); + } + + #[test] fn restrict_socket_permissions_sets_user_only_mode() { let dir = unique_test_path("socket-perms"); fs::create_dir_all(&dir).unwrap(); diff --git a/src/api/schema.rs b/src/api/schema.rs index 38393141..6cb81c12 100644 --- a/src/api/schema.rs +++ b/src/api/schema.rs @@ -12,6 +12,8 @@ pub struct Request { pub enum Method { #[serde(rename = "ping")] Ping(PingParams), + #[serde(rename = "server.stop")] + ServerStop(EmptyParams), #[serde(rename = "workspace.create")] WorkspaceCreate(WorkspaceCreateParams), #[serde(rename = "workspace.list")] @@ -64,6 +66,10 @@ pub enum Method { EventsWait(EventsWaitParams), #[serde(rename = "pane.wait_for_output")] PaneWaitForOutput(PaneWaitForOutputParams), + #[serde(rename = "integration.install")] + IntegrationInstall(IntegrationInstallParams), + #[serde(rename = "integration.uninstall")] + IntegrationUninstall(IntegrationUninstallParams), } #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)] @@ -286,6 +292,25 @@ pub struct PaneWaitForOutputParams { } #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct IntegrationInstallParams { + pub target: IntegrationTarget, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct IntegrationUninstallParams { + pub target: IntegrationTarget, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum IntegrationTarget { + Pi, + Claude, + Codex, + Opencode, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] #[serde(tag = "type", rename_all = "snake_case")] pub enum OutputMatch { Substring { value: String }, @@ -442,6 +467,14 @@ pub enum ResponseResult { matched_line: Option<String>, read: PaneReadResult, }, + IntegrationInstall { + target: IntegrationTarget, + details: IntegrationInstallResult, + }, + IntegrationUninstall { + target: IntegrationTarget, + details: IntegrationUninstallResult, + }, Ok {}, } @@ -494,6 +527,16 @@ pub struct PaneReadResult { } #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct IntegrationInstallResult { + pub messages: Vec<String>, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct IntegrationUninstallResult { + pub messages: Vec<String>, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] pub struct EventEnvelope { pub event: EventKind, pub data: EventData, @@ -710,6 +753,19 @@ mod tests { } #[test] + fn request_round_trips_for_server_stop() { + let request = Request { + id: "req_stop".into(), + method: Method::ServerStop(EmptyParams::default()), + }; + + let json = serde_json::to_value(&request).unwrap(); + assert_eq!(json["method"], "server.stop"); + let restored: Request = serde_json::from_value(json).unwrap(); + assert_eq!(restored, request); + } + + #[test] fn unknown_method_is_rejected() { let json = r#"{"id":"req_1","method":"nope","params":{}}"#; let err = serde_json::from_str::<Request>(json) diff --git a/src/app/actions.rs b/src/app/actions.rs index 3617bb07..f9136b9c 100644 --- a/src/app/actions.rs +++ b/src/app/actions.rs @@ -15,7 +15,7 @@ fn is_background_completion_transition(prev_state: AgentState, new_state: AgentS && matches!(prev_state, AgentState::Working | AgentState::Blocked) } -fn notification_sound_for_state_change( +pub fn notification_sound_for_state_change( is_active_tab: bool, prev_state: AgentState, new_state: AgentState, @@ -89,7 +89,7 @@ pub struct PaneStateUpdate { // --------------------------------------------------------------------------- impl AppState { - fn pane_is_in_active_tab(&self, ws_idx: usize, pane_id: PaneId) -> bool { + pub(crate) fn pane_is_in_active_tab(&self, ws_idx: usize, pane_id: PaneId) -> bool { let Some(active_ws_idx) = self.active else { return false; }; @@ -445,8 +445,8 @@ impl AppState { if let Some(text) = text { if !text.is_empty() { - crate::selection::write_osc52(&text); - info!(len = text.len(), "copied selection to clipboard"); + self.request_clipboard_write = Some(text.into_bytes()); + info!("copied selection to clipboard"); } } @@ -472,7 +472,7 @@ impl AppState { self.toast = Some(ToastNotification { kind: ToastKind::UpdateInstalled, title: format!("v{version} available"), - context: "run `herdr update`".to_string(), + context: "detach, then run `herdr update`".to_string(), }); Vec::new() } @@ -663,6 +663,22 @@ mod tests { } #[test] + fn update_ready_sets_explicit_upgrade_toast() { + let mut state = AppState::test_new(); + + let updates = state.handle_app_event(crate::events::AppEvent::UpdateReady { + version: "0.5.0".into(), + }); + + assert!(updates.is_empty()); + assert_eq!(state.update_available.as_deref(), Some("0.5.0")); + assert!(state.latest_release_notes_available); + let toast = state.toast.as_ref().expect("update toast"); + assert_eq!(toast.title, "v0.5.0 available"); + assert_eq!(toast.context, "detach, then run `herdr update`"); + } + + #[test] fn switch_workspace_updates_active_and_selected() { let mut state = app_with_workspaces(&["a", "b", "c"]); state.switch_workspace(2); @@ -1038,7 +1054,7 @@ mod tests { let toast = state.toast.as_ref().expect("update toast"); assert_eq!(toast.kind, ToastKind::UpdateInstalled); assert_eq!(toast.title, "v0.5.0 available"); - assert_eq!(toast.context, "run `herdr update`"); + assert_eq!(toast.context, "detach, then run `herdr update`"); } #[test] diff --git a/src/app/api.rs b/src/app/api.rs index 2ed224c7..e47eb452 100644 --- a/src/app/api.rs +++ b/src/app/api.rs @@ -1,131 +1,230 @@ -//! API request handling and response building for [`App`]. +use std::time::{Duration, Instant}; use super::{ - detect_state_from_api, encode_api_keys, encode_api_text, pane_agent_status, - tab_attention_priority, App, Mode, + api_helpers::{ + detect_state_from_api, encode_api_keys, encode_api_text, normalize_reported_agent_label, + pane_agent_status, + }, + App, Mode, OverlayPaneState, ToastKind, }; +use crate::events::AppEvent; -fn normalize_reported_agent_label(agent: &str) -> Option<String> { - let trimmed = agent.trim(); - if trimmed.is_empty() { - return None; - } - if let Some(agent) = crate::detect::parse_agent_label(trimmed) { - return Some(crate::detect::agent_label(agent).to_string()); - } - Some(trimmed.to_string()) -} +impl App { + pub(crate) fn handle_internal_event(&mut self, ev: AppEvent) { + if let AppEvent::ClipboardWrite { content } = ev { + crate::selection::write_osc52_bytes(&content); + return; + } -pub(super) fn api_request_changes_ui(request: &crate::api::schema::Request) -> bool { - use crate::api::schema::Method; + let overlay_state = if let AppEvent::PaneDied { pane_id } = &ev { + self.overlay_panes.remove(pane_id) + } else { + None + }; - matches!( - &request.method, - Method::WorkspaceCreate(_) - | Method::WorkspaceFocus(_) - | Method::WorkspaceRename(_) - | Method::WorkspaceClose(_) - | Method::TabCreate(_) - | Method::TabFocus(_) - | Method::TabRename(_) - | Method::TabClose(_) - | Method::PaneSplit(_) - | Method::PaneReportAgent(_) - | Method::PaneClearAgentAuthority(_) - | Method::PaneReleaseAgent(_) - | Method::PaneClose(_) - ) -} + if let AppEvent::PaneDied { pane_id } = &ev { + if let Some((ws_idx, _)) = self.find_pane(*pane_id) { + if let Some(public_pane_id) = self.public_pane_id(ws_idx, *pane_id) { + self.emit_event(crate::api::schema::EventEnvelope { + event: crate::api::schema::EventKind::PaneExited, + data: crate::api::schema::EventData::PaneExited { + pane_id: public_pane_id, + workspace_id: self.public_workspace_id(ws_idx), + }, + }); + } + } + } -impl App { - pub(super) fn handle_api_request_message( - &mut self, - msg: crate::api::ApiRequestMessage, - ) -> bool { - let changed = api_request_changes_ui(&msg.request); - let response = self.handle_api_request(msg.request); - let _ = msg.respond_to.send(response); - changed - } + let released_agent = if let AppEvent::HookAgentReleased { + pane_id, + known_agent, + .. + } = &ev + { + known_agent.map(|agent| (*pane_id, agent)) + } else { + None + }; - pub(super) fn public_workspace_id(&self, ws_idx: usize) -> String { - self.state.workspaces[ws_idx].id.clone() + let previous_toast = self.state.toast.clone(); + let pane_updates = self.state.handle_app_event(ev); + for update in &pane_updates { + self.emit_pane_state_update(update); + } + if let Some((pane_id, agent)) = released_agent { + if pane_updates.iter().any(|update| update.pane_id == pane_id) { + if let Some((ws_idx, _)) = self.find_pane(pane_id) { + if let Some(runtime) = self.state.workspaces[ws_idx].runtimes.get(&pane_id) { + runtime.begin_graceful_release(agent); + } + } + } + } + if let Some(overlay) = overlay_state { + self.restore_overlay_after_exit(overlay); + } + self.sync_toast_deadline(previous_toast); } - pub(super) fn public_tab_id(&self, ws_idx: usize, tab_idx: usize) -> Option<String> { - let ws = self.state.workspaces.get(ws_idx)?; - ws.tabs.get(tab_idx)?; - Some(format!("{}:{}", ws.id, tab_idx + 1)) - } + fn restore_overlay_after_exit(&mut self, overlay: OverlayPaneState) { + let Some(ws) = self.state.workspaces.get_mut(overlay.ws_idx) else { + return; + }; + if overlay.tab_idx >= ws.tabs.len() { + return; + } - pub(super) fn public_pane_id( - &self, - ws_idx: usize, - pane_id: crate::layout::PaneId, - ) -> Option<String> { - let ws = self.state.workspaces.get(ws_idx)?; - let pane_number = ws.public_pane_number(pane_id)?; - Some(format!("{}-{pane_number}", ws.id)) + ws.active_tab = overlay.tab_idx; + let tab = &mut ws.tabs[overlay.tab_idx]; + if tab.panes.contains_key(&overlay.previous_focus) { + tab.layout.focus_pane(overlay.previous_focus); + } + tab.zoomed = overlay.previous_zoomed; + + if self.state.active == Some(overlay.ws_idx) { + self.state.mode = Mode::Terminal; + } } - pub(super) fn parse_workspace_id(&self, id: &str) -> Option<usize> { - self.state - .workspaces - .iter() - .position(|workspace| workspace.id == id) - .or_else(|| id.strip_prefix("w_")?.parse::<usize>().ok()?.checked_sub(1)) - .or_else(|| id.parse::<usize>().ok()?.checked_sub(1)) + fn emit_pane_state_update(&self, update: &crate::app::actions::PaneStateUpdate) { + let Some(pane_id) = self.public_pane_id(update.ws_idx, update.pane_id) else { + return; + }; + let workspace_id = self.public_workspace_id(update.ws_idx); + + if update.previous_agent_label != update.agent_label { + self.emit_event(crate::api::schema::EventEnvelope { + event: crate::api::schema::EventKind::PaneAgentDetected, + data: crate::api::schema::EventData::PaneAgentDetected { + pane_id: pane_id.clone(), + workspace_id: workspace_id.clone(), + agent: update.agent_label.clone(), + }, + }); + } + + if update.previous_state != update.state { + let agent_status = self + .state + .workspaces + .get(update.ws_idx) + .and_then(|ws| ws.pane_state(update.pane_id)) + .map(|pane| pane_agent_status(pane.state, pane.seen)) + .unwrap_or_else(|| pane_agent_status(update.state, true)); + self.emit_event(crate::api::schema::EventEnvelope { + event: crate::api::schema::EventKind::PaneAgentStatusChanged, + data: crate::api::schema::EventData::PaneAgentStatusChanged { + pane_id, + workspace_id, + agent_status, + }, + }); + } } - pub(super) fn parse_tab_id(&self, id: &str) -> Option<(usize, usize)> { - if let Some(rest) = id.strip_prefix("t_") { - let (ws_raw, tab_raw) = rest.rsplit_once('_')?; - let ws_idx = self.parse_workspace_id(ws_raw)?; - let tab_idx = tab_raw.parse::<usize>().ok()?.checked_sub(1)?; - self.state.workspaces.get(ws_idx)?.tabs.get(tab_idx)?; - return Some((ws_idx, tab_idx)); + pub(super) fn sync_toast_deadline( + &mut self, + previous_toast: Option<crate::app::state::ToastNotification>, + ) { + if self.state.toast != previous_toast { + self.toast_deadline = self.state.toast.as_ref().map(|toast| { + let duration = match toast.kind { + ToastKind::NeedsAttention => Duration::from_secs(8), + ToastKind::Finished => Duration::from_secs(5), + ToastKind::UpdateInstalled => Duration::from_secs(3), + }; + Instant::now() + duration + }); } + } - let (ws_raw, tab_raw) = id.rsplit_once(':')?; - let ws_idx = self.parse_workspace_id(ws_raw)?; - let tab_idx = tab_raw.parse::<usize>().ok()?.checked_sub(1)?; - self.state.workspaces.get(ws_idx)?.tabs.get(tab_idx)?; - Some((ws_idx, tab_idx)) + pub(super) fn emit_event(&self, event: crate::api::schema::EventEnvelope) { + self.event_hub.push(event); } - pub(super) fn parse_pane_id(&self, id: &str) -> Option<(usize, crate::layout::PaneId)> { - if let Some(rest) = id.strip_prefix("p_") { - if let Some((ws_raw, pane_raw)) = rest.rsplit_once('_') { - let ws_idx = self.parse_workspace_id(ws_raw)?; - let pane_id = crate::layout::PaneId::from_raw(pane_raw.parse::<u32>().ok()?); - return Some((ws_idx, pane_id)); - } + pub(crate) fn sync_focus_events(&mut self) { + let current_focus = self.state.active.and_then(|idx| { + self.state + .workspaces + .get(idx) + .and_then(|ws| ws.focused_pane_id().map(|pane_id| (idx, pane_id))) + }); + if current_focus == self.last_focus { + return; + } - let pane_id = crate::layout::PaneId::from_raw(rest.parse::<u32>().ok()?); - return self.find_pane(pane_id).map(|(ws_idx, _)| (ws_idx, pane_id)); + if let Some((ws_idx, pane_id)) = self.last_focus { + self.send_pane_focus_event(ws_idx, pane_id, crate::ghostty::FocusEvent::Lost); + } + if let Some((ws_idx, pane_id)) = current_focus { + self.send_pane_focus_event(ws_idx, pane_id, crate::ghostty::FocusEvent::Gained); + self.emit_event(crate::api::schema::EventEnvelope { + event: crate::api::schema::EventKind::WorkspaceFocused, + data: crate::api::schema::EventData::WorkspaceFocused { + workspace_id: self.public_workspace_id(ws_idx), + }, + }); + if let Some(tab_id) = + self.public_tab_id(ws_idx, self.state.workspaces[ws_idx].active_tab) + { + self.emit_event(crate::api::schema::EventEnvelope { + event: crate::api::schema::EventKind::TabFocused, + data: crate::api::schema::EventData::TabFocused { + tab_id, + workspace_id: self.public_workspace_id(ws_idx), + }, + }); + } + if let Some(public_pane_id) = self.public_pane_id(ws_idx, pane_id) { + self.emit_event(crate::api::schema::EventEnvelope { + event: crate::api::schema::EventKind::PaneFocused, + data: crate::api::schema::EventData::PaneFocused { + pane_id: public_pane_id, + workspace_id: self.public_workspace_id(ws_idx), + }, + }); + } } - let (ws_raw, pane_number_raw) = id.rsplit_once('-')?; - let ws_idx = self.parse_workspace_id(ws_raw)?; - let pane_number = pane_number_raw.parse::<usize>().ok()?; - let ws = self.state.workspaces.get(ws_idx)?; - let pane_id = ws - .public_pane_numbers - .iter() - .find_map(|(pane_id, number)| (*number == pane_number).then_some(*pane_id))?; - Some((ws_idx, pane_id)) + self.last_focus = current_focus; + } + + fn send_pane_focus_event( + &self, + ws_idx: usize, + pane_id: crate::layout::PaneId, + event: crate::ghostty::FocusEvent, + ) { + let Some(runtime) = self + .state + .workspaces + .get(ws_idx) + .and_then(|ws| ws.runtime(pane_id)) + else { + return; + }; + runtime.try_send_focus_event(event); } - pub(super) fn handle_api_request(&mut self, request: crate::api::schema::Request) -> String { + pub(crate) fn handle_api_request(&mut self, request: crate::api::schema::Request) -> String { self.drain_internal_events(); use bytes::Bytes; use crate::api::schema::{ - ErrorBody, ErrorResponse, Method, PaneListParams, PaneReadResult, ReadSource, + ErrorBody, ErrorResponse, IntegrationInstallResult, IntegrationTarget, + IntegrationUninstallResult, Method, PaneListParams, PaneReadResult, ReadSource, ResponseResult, SuccessResponse, TabListParams, }; let response = match request.method { + Method::ServerStop(_) => { + self.state.should_quit = true; + SuccessResponse { + id: request.id, + result: ResponseResult::Ok {}, + } + } Method::WorkspaceList(_) => SuccessResponse { id: request.id, result: ResponseResult::WorkspaceList { @@ -1065,6 +1164,265 @@ impl App { result: ResponseResult::Ok {}, } } + Method::IntegrationInstall(params) => { + let target = params.target; + let messages = match target { + IntegrationTarget::Pi => { + let path = crate::integration::install_pi().map_err(|err| { + serde_json::to_string(&ErrorResponse { + id: request.id.clone(), + error: ErrorBody { + code: "integration_install_failed".into(), + message: err.to_string(), + }, + }) + .unwrap() + }); + match path { + Ok(path) => { + vec![format!("installed pi integration to {}", path.display())] + } + Err(response) => return response, + } + } + IntegrationTarget::Claude => { + let installed = crate::integration::install_claude().map_err(|err| { + serde_json::to_string(&ErrorResponse { + id: request.id.clone(), + error: ErrorBody { + code: "integration_install_failed".into(), + message: err.to_string(), + }, + }) + .unwrap() + }); + match installed { + Ok(installed) => vec![ + format!( + "installed claude integration hook to {}", + installed.hook_path.display() + ), + format!( + "ensured claude settings at {}", + installed.settings_path.display() + ), + ], + Err(response) => return response, + } + } + IntegrationTarget::Codex => { + let installed = crate::integration::install_codex().map_err(|err| { + serde_json::to_string(&ErrorResponse { + id: request.id.clone(), + error: ErrorBody { + code: "integration_install_failed".into(), + message: err.to_string(), + }, + }) + .unwrap() + }); + match installed { + Ok(installed) => vec![ + format!( + "installed codex integration hook to {}", + installed.hook_path.display() + ), + format!( + "ensured codex hooks at {}", + installed.hooks_path.display() + ), + format!( + "ensured codex config at {}", + installed.config_path.display() + ), + ], + Err(response) => return response, + } + } + IntegrationTarget::Opencode => { + let installed = crate::integration::install_opencode().map_err(|err| { + serde_json::to_string(&ErrorResponse { + id: request.id.clone(), + error: ErrorBody { + code: "integration_install_failed".into(), + message: err.to_string(), + }, + }) + .unwrap() + }); + match installed { + Ok(installed) => vec![format!( + "installed opencode integration plugin to {}", + installed.plugin_path.display() + )], + Err(response) => return response, + } + } + }; + + SuccessResponse { + id: request.id, + result: ResponseResult::IntegrationInstall { + target, + details: IntegrationInstallResult { messages }, + }, + } + } + Method::IntegrationUninstall(params) => { + let target = params.target; + let messages = match target { + IntegrationTarget::Pi => { + let result = crate::integration::uninstall_pi().map_err(|err| { + serde_json::to_string(&ErrorResponse { + id: request.id.clone(), + error: ErrorBody { + code: "integration_uninstall_failed".into(), + message: err.to_string(), + }, + }) + .unwrap() + }); + match result { + Ok(result) => { + if result.removed_extension { + vec![format!( + "removed pi integration extension at {}", + result.extension_path.display() + )] + } else { + vec![format!( + "no pi integration extension found at {}", + result.extension_path.display() + )] + } + } + Err(response) => return response, + } + } + IntegrationTarget::Claude => { + let result = crate::integration::uninstall_claude().map_err(|err| { + serde_json::to_string(&ErrorResponse { + id: request.id.clone(), + error: ErrorBody { + code: "integration_uninstall_failed".into(), + message: err.to_string(), + }, + }) + .unwrap() + }); + match result { + Ok(result) => { + let mut messages = Vec::new(); + if result.removed_hook_file { + messages.push(format!( + "removed claude hook at {}", + result.hook_path.display() + )); + } else { + messages.push(format!( + "no claude hook found at {}", + result.hook_path.display() + )); + } + if result.updated_settings { + messages.push(format!( + "removed herdr claude hook entries from {}", + result.settings_path.display() + )); + } else { + messages.push(format!( + "no herdr claude hook entries found in {}", + result.settings_path.display() + )); + } + messages + } + Err(response) => return response, + } + } + IntegrationTarget::Codex => { + let result = crate::integration::uninstall_codex().map_err(|err| { + serde_json::to_string(&ErrorResponse { + id: request.id.clone(), + error: ErrorBody { + code: "integration_uninstall_failed".into(), + message: err.to_string(), + }, + }) + .unwrap() + }); + match result { + Ok(result) => { + let mut messages = Vec::new(); + if result.removed_hook_file { + messages.push(format!( + "removed codex hook at {}", + result.hook_path.display() + )); + } else { + messages.push(format!( + "no codex hook found at {}", + result.hook_path.display() + )); + } + if result.updated_hooks { + messages.push(format!( + "removed herdr codex hook entries from {}", + result.hooks_path.display() + )); + } else { + messages.push(format!( + "no herdr codex hook entries found in {}", + result.hooks_path.display() + )); + } + messages.push(format!( + "left codex config unchanged at {}", + result.config_path.display() + )); + messages + } + Err(response) => return response, + } + } + IntegrationTarget::Opencode => { + let result = crate::integration::uninstall_opencode().map_err(|err| { + serde_json::to_string(&ErrorResponse { + id: request.id.clone(), + error: ErrorBody { + code: "integration_uninstall_failed".into(), + message: err.to_string(), + }, + }) + .unwrap() + }); + match result { + Ok(result) => { + if result.removed_plugin { + vec![format!( + "removed opencode integration plugin at {}", + result.plugin_path.display() + )] + } else { + vec![format!( + "no opencode integration plugin found at {}", + result.plugin_path.display() + )] + } + } + Err(response) => return response, + } + } + }; + + SuccessResponse { + id: request.id, + result: ResponseResult::IntegrationUninstall { + target, + details: IntegrationUninstallResult { messages }, + }, + } + } _ => { return serde_json::to_string(&ErrorResponse { id: request.id, @@ -1079,163 +1437,4 @@ impl App { serde_json::to_string(&response).unwrap() } - - pub(super) fn collect_panes_for_workspace( - &self, - workspace_id: Option<&str>, - ) -> Result<Vec<crate::api::schema::PaneInfo>, (String, String)> { - if let Some(workspace_id) = workspace_id { - let Some(ws_idx) = self.parse_workspace_id(workspace_id) else { - return Err(( - "workspace_not_found".into(), - format!("workspace {workspace_id} not found"), - )); - }; - let Some(ws) = self.state.workspaces.get(ws_idx) else { - return Err(( - "workspace_not_found".into(), - format!("workspace {workspace_id} not found"), - )); - }; - Ok(ws - .tabs - .iter() - .flat_map(|tab| tab.layout.pane_ids().into_iter()) - .filter_map(|pane_id| self.pane_info(ws_idx, pane_id)) - .collect()) - } else { - Ok(self - .state - .workspaces - .iter() - .enumerate() - .flat_map(|(ws_idx, ws)| { - ws.tabs - .iter() - .flat_map(|tab| tab.layout.pane_ids().into_iter()) - .filter_map(move |pane_id| self.pane_info(ws_idx, pane_id)) - }) - .collect()) - } - } - - pub(super) fn tab_info( - &self, - ws_idx: usize, - tab_idx: usize, - ) -> Option<crate::api::schema::TabInfo> { - let ws = self.state.workspaces.get(ws_idx)?; - let tab = ws.tabs.get(tab_idx)?; - let (agg_state, seen) = tab - .panes - .values() - .map(|pane| (pane.state, pane.seen)) - .max_by_key(|(state, seen)| tab_attention_priority(*state, *seen)) - .unwrap_or((crate::detect::AgentState::Unknown, true)); - Some(crate::api::schema::TabInfo { - tab_id: self.public_tab_id(ws_idx, tab_idx)?, - workspace_id: self.public_workspace_id(ws_idx), - number: tab_idx + 1, - label: tab.display_name(), - focused: self.state.active == Some(ws_idx) && ws.active_tab == tab_idx, - pane_count: tab.panes.len(), - agent_status: pane_agent_status(agg_state, seen), - }) - } - - pub(super) fn workspace_created_result( - &self, - ws_idx: usize, - ) -> Option<crate::api::schema::ResponseResult> { - Some(crate::api::schema::ResponseResult::WorkspaceCreated { - workspace: self.workspace_info(ws_idx), - tab: self.tab_info(ws_idx, 0)?, - root_pane: self.root_pane_info(ws_idx, 0)?, - }) - } - - pub(super) fn tab_created_result( - &self, - ws_idx: usize, - tab_idx: usize, - ) -> Option<crate::api::schema::ResponseResult> { - Some(crate::api::schema::ResponseResult::TabCreated { - tab: self.tab_info(ws_idx, tab_idx)?, - root_pane: self.root_pane_info(ws_idx, tab_idx)?, - }) - } - - pub(super) fn root_pane_info( - &self, - ws_idx: usize, - tab_idx: usize, - ) -> Option<crate::api::schema::PaneInfo> { - let ws = self.state.workspaces.get(ws_idx)?; - let tab = ws.tabs.get(tab_idx)?; - self.pane_info(ws_idx, tab.root_pane) - } - - pub(super) fn pane_info( - &self, - ws_idx: usize, - pane_id: crate::layout::PaneId, - ) -> Option<crate::api::schema::PaneInfo> { - let ws = self.state.workspaces.get(ws_idx)?; - let pane = ws.pane_state(pane_id)?; - let runtime = ws.runtime(pane_id); - let tab_idx = ws.find_tab_index_for_pane(pane_id)?; - let focused = self.state.active == Some(ws_idx) - && ws.active_tab == tab_idx - && ws - .focused_pane_id() - .is_some_and(|focused| focused == pane_id); - Some(crate::api::schema::PaneInfo { - pane_id: self.public_pane_id(ws_idx, pane_id)?, - workspace_id: self.public_workspace_id(ws_idx), - tab_id: self.public_tab_id(ws_idx, tab_idx)?, - focused, - cwd: runtime - .and_then(|rt| rt.cwd()) - .map(|cwd| cwd.display().to_string()), - agent: pane.effective_agent_label().map(str::to_string), - agent_status: pane_agent_status(pane.state, pane.seen), - revision: 0, - }) - } - - pub(super) fn lookup_runtime( - &self, - ws_idx: usize, - pane_id: crate::layout::PaneId, - ) -> Option<(&crate::pane::PaneRuntime, String)> { - let ws = self.state.workspaces.get(ws_idx)?; - let runtime = ws.runtime(pane_id)?; - Some((runtime, self.public_workspace_id(ws_idx))) - } - - pub(super) fn lookup_runtime_sender( - &self, - ws_idx: usize, - pane_id: crate::layout::PaneId, - ) -> Option<&crate::pane::PaneRuntime> { - let ws = self.state.workspaces.get(ws_idx)?; - ws.runtime(pane_id) - } - - pub(super) fn workspace_info(&self, index: usize) -> crate::api::schema::WorkspaceInfo { - let ws = &self.state.workspaces[index]; - let (agg_state, seen) = ws.aggregate_state(); - crate::api::schema::WorkspaceInfo { - workspace_id: self.public_workspace_id(index), - number: index + 1, - label: ws.display_name(), - focused: self.state.active == Some(index), - pane_count: ws.public_pane_numbers.len(), - tab_count: ws.tabs.len(), - active_tab_id: self - .public_tab_id(index, ws.active_tab) - .unwrap_or_else(|| format!("{}:{}", ws.id, ws.active_tab + 1)), - agent_status: pane_agent_status(agg_state, seen), - } - } } diff --git a/src/app/api_helpers.rs b/src/app/api_helpers.rs new file mode 100644 index 00000000..011e5ccb --- /dev/null +++ b/src/app/api_helpers.rs @@ -0,0 +1,92 @@ +pub(super) fn tab_attention_priority(state: crate::detect::AgentState, seen: bool) -> u8 { + match (state, seen) { + (crate::detect::AgentState::Blocked, _) => 4, + (crate::detect::AgentState::Idle, false) => 3, + (crate::detect::AgentState::Working, _) => 2, + (crate::detect::AgentState::Idle, true) => 1, + (crate::detect::AgentState::Unknown, _) => 0, + } +} + +fn parse_api_key(key: &str) -> Option<crossterm::event::KeyEvent> { + use crossterm::event::{KeyCode, KeyEvent, KeyModifiers}; + + let normalized = key.trim(); + match normalized { + "Enter" | "enter" => Some(KeyEvent::new(KeyCode::Enter, KeyModifiers::empty())), + "Tab" | "tab" => Some(KeyEvent::new(KeyCode::Tab, KeyModifiers::empty())), + "Esc" | "esc" => Some(KeyEvent::new(KeyCode::Esc, KeyModifiers::empty())), + "Backspace" | "backspace" => Some(KeyEvent::new(KeyCode::Backspace, KeyModifiers::empty())), + "Up" | "up" => Some(KeyEvent::new(KeyCode::Up, KeyModifiers::empty())), + "Down" | "down" => Some(KeyEvent::new(KeyCode::Down, KeyModifiers::empty())), + "Left" | "left" => Some(KeyEvent::new(KeyCode::Left, KeyModifiers::empty())), + "Right" | "right" => Some(KeyEvent::new(KeyCode::Right, KeyModifiers::empty())), + "C-c" | "c-c" | "ctrl+c" => Some(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL)), + _ if normalized.len() == 1 => normalized + .chars() + .next() + .map(|ch| KeyEvent::new(KeyCode::Char(ch), KeyModifiers::empty())), + _ => None, + } +} + +pub(super) fn encode_api_text(runtime: &crate::pane::PaneRuntime, text: &str) -> Vec<u8> { + let bracketed = runtime + .input_state() + .map(|state| state.bracketed_paste) + .unwrap_or(false); + if bracketed { + format!("\x1b[200~{text}\x1b[201~").into_bytes() + } else { + text.as_bytes().to_vec() + } +} + +pub(super) fn encode_api_keys( + runtime: &crate::pane::PaneRuntime, + keys: &[String], +) -> Result<Vec<Vec<u8>>, String> { + let mut encoded_keys = Vec::with_capacity(keys.len()); + for key in keys { + let Some(key_event) = parse_api_key(key) else { + return Err(key.clone()); + }; + encoded_keys.push(runtime.encode_terminal_key(key_event.into())); + } + Ok(encoded_keys) +} + +pub(super) fn detect_state_from_api( + state: crate::api::schema::PaneAgentState, +) -> crate::detect::AgentState { + match state { + crate::api::schema::PaneAgentState::Idle => crate::detect::AgentState::Idle, + crate::api::schema::PaneAgentState::Working => crate::detect::AgentState::Working, + crate::api::schema::PaneAgentState::Blocked => crate::detect::AgentState::Blocked, + crate::api::schema::PaneAgentState::Unknown => crate::detect::AgentState::Unknown, + } +} + +pub(super) fn pane_agent_status( + state: crate::detect::AgentState, + seen: bool, +) -> crate::api::schema::AgentStatus { + match (state, seen) { + (crate::detect::AgentState::Idle, false) => crate::api::schema::AgentStatus::Done, + (crate::detect::AgentState::Idle, true) => crate::api::schema::AgentStatus::Idle, + (crate::detect::AgentState::Working, _) => crate::api::schema::AgentStatus::Working, + (crate::detect::AgentState::Blocked, _) => crate::api::schema::AgentStatus::Blocked, + (crate::detect::AgentState::Unknown, _) => crate::api::schema::AgentStatus::Unknown, + } +} + +pub(super) fn normalize_reported_agent_label(agent: &str) -> Option<String> { + let trimmed = agent.trim(); + if trimmed.is_empty() { + return None; + } + if let Some(agent) = crate::detect::parse_agent_label(trimmed) { + return Some(crate::detect::agent_label(agent).to_string()); + } + Some(trimmed.to_string()) +} diff --git a/src/app/config_io.rs b/src/app/config_io.rs new file mode 100644 index 00000000..21d4365b --- /dev/null +++ b/src/app/config_io.rs @@ -0,0 +1,45 @@ +use super::App; + +impl App { + pub(super) fn update_config_file<F>(&mut self, error_context: &str, update: F) + where + F: FnOnce(&str) -> String, + { + let path = crate::config::config_path(); + if let Some(parent) = path.parent() { + if let Err(err) = std::fs::create_dir_all(parent) { + self.state.config_diagnostic = + Some(format!("failed to save {error_context}: {err}")); + self.config_diagnostic_deadline = + Some(std::time::Instant::now() + std::time::Duration::from_secs(5)); + return; + } + } + + let content = std::fs::read_to_string(&path).unwrap_or_default(); + let new_content = update(&content); + if let Err(err) = std::fs::write(&path, new_content) { + self.state.config_diagnostic = Some(format!("failed to save {error_context}: {err}")); + self.config_diagnostic_deadline = + Some(std::time::Instant::now() + std::time::Duration::from_secs(5)); + } + } + + pub(super) fn save_theme(&mut self, name: &str) { + self.update_config_file("theme", |content| { + crate::config::upsert_section_value(content, "theme", "name", &format!("\"{name}\"")) + }); + } + + pub(super) fn save_sound(&mut self, enabled: bool) { + self.update_config_file("sound setting", |content| { + crate::config::upsert_section_bool(content, "ui.sound", "enabled", enabled) + }); + } + + pub(super) fn save_toast(&mut self, enabled: bool) { + self.update_config_file("toast setting", |content| { + crate::config::upsert_section_bool(content, "ui.toast", "enabled", enabled) + }); + } +} diff --git a/src/app/creation.rs b/src/app/creation.rs new file mode 100644 index 00000000..dd2833e0 --- /dev/null +++ b/src/app/creation.rs @@ -0,0 +1,281 @@ +use tracing::error; + +use super::{ + api_helpers::{pane_agent_status, tab_attention_priority}, + App, Mode, +}; +use crate::workspace::Workspace; + +impl App { + pub(super) fn seed_cwd_from_workspace(&self, ws_idx: usize) -> Option<std::path::PathBuf> { + self.state.workspaces.get(ws_idx)?.resolved_identity_cwd() + } + + pub(super) fn workspace_creation_source(&self) -> Option<usize> { + if self.state.mode == Mode::Navigate + && self.state.workspaces.get(self.state.selected).is_some() + { + return Some(self.state.selected); + } + + self.state.active.or_else(|| { + self.state + .workspaces + .get(self.state.selected) + .map(|_| self.state.selected) + }) + } + + /// Create a workspace with a real PTY (needs event_tx). + pub(crate) fn create_workspace(&mut self) { + let initial_cwd = self + .workspace_creation_source() + .and_then(|ws_idx| self.seed_cwd_from_workspace(ws_idx)) + .or_else(|| std::env::current_dir().ok()) + .unwrap_or_else(|| std::path::PathBuf::from("/")); + if let Err(e) = self.create_workspace_with_options(initial_cwd, true) { + error!(err = %e, "failed to create workspace"); + self.state.mode = Mode::Navigate; + } + } + + pub(crate) fn create_tab(&mut self) { + let custom_name = self.state.requested_new_tab_name.take(); + let initial_cwd = self + .state + .active + .and_then(|ws_idx| self.seed_cwd_from_workspace(ws_idx)) + .or_else(|| std::env::current_dir().ok()) + .unwrap_or_else(|| std::path::PathBuf::from("/")); + match self.create_tab_with_options(initial_cwd, true) { + Ok(tab_idx) => { + if let Some(name) = custom_name { + if let Some(ws) = self + .state + .active + .and_then(|ws_idx| self.state.workspaces.get_mut(ws_idx)) + { + if let Some(tab) = ws.tabs.get_mut(tab_idx) { + tab.set_custom_name(name); + } + self.schedule_session_save(); + } + } + } + Err(e) => { + error!(err = %e, "failed to create tab"); + } + } + } + + pub(super) fn create_tab_with_options( + &mut self, + initial_cwd: std::path::PathBuf, + focus: bool, + ) -> std::io::Result<usize> { + let Some(ws_idx) = self.state.active else { + return self.create_workspace_with_options(initial_cwd, focus); + }; + let (rows, cols) = self.state.estimate_pane_size(); + let ws = &mut self.state.workspaces[ws_idx]; + let idx = ws.create_tab( + rows, + cols, + initial_cwd, + self.state.pane_scrollback_limit_bytes, + self.state.host_terminal_theme, + )?; + if focus { + ws.switch_tab(idx); + self.state.mode = Mode::Terminal; + } + self.schedule_session_save(); + Ok(idx) + } + + pub(super) fn create_workspace_with_options( + &mut self, + initial_cwd: std::path::PathBuf, + focus: bool, + ) -> std::io::Result<usize> { + let (rows, cols) = self.state.estimate_pane_size(); + let mut ws = Workspace::new( + initial_cwd, + rows, + cols, + self.state.pane_scrollback_limit_bytes, + self.state.host_terminal_theme, + self.event_tx.clone(), + self.render_notify.clone(), + self.render_dirty.clone(), + )?; + ws.refresh_git_ahead_behind(); + self.state.workspaces.push(ws); + let idx = self.state.workspaces.len() - 1; + if focus || self.state.active.is_none() { + self.state.switch_workspace(idx); + self.state.mode = Mode::Terminal; + } + self.schedule_session_save(); + Ok(idx) + } + + pub(super) fn collect_panes_for_workspace( + &self, + workspace_id: Option<&str>, + ) -> Result<Vec<crate::api::schema::PaneInfo>, (String, String)> { + if let Some(workspace_id) = workspace_id { + let Some(ws_idx) = self.parse_workspace_id(workspace_id) else { + return Err(( + "workspace_not_found".into(), + format!("workspace {workspace_id} not found"), + )); + }; + let Some(ws) = self.state.workspaces.get(ws_idx) else { + return Err(( + "workspace_not_found".into(), + format!("workspace {workspace_id} not found"), + )); + }; + Ok(ws + .tabs + .iter() + .flat_map(|tab| tab.layout.pane_ids().into_iter()) + .filter_map(|pane_id| self.pane_info(ws_idx, pane_id)) + .collect()) + } else { + Ok(self + .state + .workspaces + .iter() + .enumerate() + .flat_map(|(ws_idx, ws)| { + ws.tabs + .iter() + .flat_map(|tab| tab.layout.pane_ids().into_iter()) + .filter_map(move |pane_id| self.pane_info(ws_idx, pane_id)) + }) + .collect()) + } + } + + pub(super) fn tab_info( + &self, + ws_idx: usize, + tab_idx: usize, + ) -> Option<crate::api::schema::TabInfo> { + let ws = self.state.workspaces.get(ws_idx)?; + let tab = ws.tabs.get(tab_idx)?; + let (agg_state, seen) = tab + .panes + .values() + .map(|pane| (pane.state, pane.seen)) + .max_by_key(|(state, seen)| tab_attention_priority(*state, *seen)) + .unwrap_or((crate::detect::AgentState::Unknown, true)); + Some(crate::api::schema::TabInfo { + tab_id: self.public_tab_id(ws_idx, tab_idx)?, + workspace_id: self.public_workspace_id(ws_idx), + number: tab_idx + 1, + label: tab.display_name(), + focused: self.state.active == Some(ws_idx) && ws.active_tab == tab_idx, + pane_count: tab.panes.len(), + agent_status: pane_agent_status(agg_state, seen), + }) + } + + pub(super) fn workspace_created_result( + &self, + ws_idx: usize, + ) -> Option<crate::api::schema::ResponseResult> { + Some(crate::api::schema::ResponseResult::WorkspaceCreated { + workspace: self.workspace_info(ws_idx), + tab: self.tab_info(ws_idx, 0)?, + root_pane: self.root_pane_info(ws_idx, 0)?, + }) + } + + pub(super) fn tab_created_result( + &self, + ws_idx: usize, + tab_idx: usize, + ) -> Option<crate::api::schema::ResponseResult> { + Some(crate::api::schema::ResponseResult::TabCreated { + tab: self.tab_info(ws_idx, tab_idx)?, + root_pane: self.root_pane_info(ws_idx, tab_idx)?, + }) + } + + pub(super) fn root_pane_info( + &self, + ws_idx: usize, + tab_idx: usize, + ) -> Option<crate::api::schema::PaneInfo> { + let ws = self.state.workspaces.get(ws_idx)?; + let tab = ws.tabs.get(tab_idx)?; + self.pane_info(ws_idx, tab.root_pane) + } + + pub(super) fn pane_info( + &self, + ws_idx: usize, + pane_id: crate::layout::PaneId, + ) -> Option<crate::api::schema::PaneInfo> { + let ws = self.state.workspaces.get(ws_idx)?; + let pane = ws.pane_state(pane_id)?; + let runtime = ws.runtime(pane_id); + let tab_idx = ws.find_tab_index_for_pane(pane_id)?; + let focused = self.state.active == Some(ws_idx) + && ws.active_tab == tab_idx + && ws + .focused_pane_id() + .is_some_and(|focused| focused == pane_id); + Some(crate::api::schema::PaneInfo { + pane_id: self.public_pane_id(ws_idx, pane_id)?, + workspace_id: self.public_workspace_id(ws_idx), + tab_id: self.public_tab_id(ws_idx, tab_idx)?, + focused, + cwd: runtime + .and_then(|rt| rt.cwd()) + .map(|cwd| cwd.display().to_string()), + agent: pane.effective_agent_label().map(str::to_string), + agent_status: pane_agent_status(pane.state, pane.seen), + revision: 0, + }) + } + + pub(super) fn lookup_runtime( + &self, + ws_idx: usize, + pane_id: crate::layout::PaneId, + ) -> Option<(&crate::pane::PaneRuntime, String)> { + let ws = self.state.workspaces.get(ws_idx)?; + let runtime = ws.runtime(pane_id)?; + Some((runtime, self.public_workspace_id(ws_idx))) + } + + pub(super) fn lookup_runtime_sender( + &self, + ws_idx: usize, + pane_id: crate::layout::PaneId, + ) -> Option<&crate::pane::PaneRuntime> { + let ws = self.state.workspaces.get(ws_idx)?; + ws.runtime(pane_id) + } + + pub(super) fn workspace_info(&self, index: usize) -> crate::api::schema::WorkspaceInfo { + let ws = &self.state.workspaces[index]; + let (agg_state, seen) = ws.aggregate_state(); + crate::api::schema::WorkspaceInfo { + workspace_id: self.public_workspace_id(index), + number: index + 1, + label: ws.display_name(), + focused: self.state.active == Some(index), + pane_count: ws.public_pane_numbers.len(), + tab_count: ws.tabs.len(), + active_tab_id: self + .public_tab_id(index, ws.active_tab) + .unwrap_or_else(|| format!("{}:{}", ws.id, ws.active_tab + 1)), + agent_status: pane_agent_status(agg_state, seen), + } + } +} diff --git a/src/app/ids.rs b/src/app/ids.rs new file mode 100644 index 00000000..490e6051 --- /dev/null +++ b/src/app/ids.rs @@ -0,0 +1,82 @@ +use super::App; + +impl App { + pub(super) fn find_pane( + &self, + pane_id: crate::layout::PaneId, + ) -> Option<(usize, &crate::pane::PaneState)> { + self.state + .workspaces + .iter() + .enumerate() + .find_map(|(ws_idx, ws)| ws.pane_state(pane_id).map(|pane| (ws_idx, pane))) + } + + pub(super) fn public_workspace_id(&self, ws_idx: usize) -> String { + self.state.workspaces[ws_idx].id.clone() + } + + pub(super) fn public_tab_id(&self, ws_idx: usize, tab_idx: usize) -> Option<String> { + let ws = self.state.workspaces.get(ws_idx)?; + ws.tabs.get(tab_idx)?; + Some(format!("{}:{}", ws.id, tab_idx + 1)) + } + + pub(super) fn public_pane_id( + &self, + ws_idx: usize, + pane_id: crate::layout::PaneId, + ) -> Option<String> { + let ws = self.state.workspaces.get(ws_idx)?; + let pane_number = ws.public_pane_number(pane_id)?; + Some(format!("{}-{pane_number}", ws.id)) + } + + pub(super) fn parse_workspace_id(&self, id: &str) -> Option<usize> { + self.state + .workspaces + .iter() + .position(|workspace| workspace.id == id) + .or_else(|| id.strip_prefix("w_")?.parse::<usize>().ok()?.checked_sub(1)) + .or_else(|| id.parse::<usize>().ok()?.checked_sub(1)) + } + + pub(super) fn parse_tab_id(&self, id: &str) -> Option<(usize, usize)> { + if let Some(rest) = id.strip_prefix("t_") { + let (ws_raw, tab_raw) = rest.rsplit_once('_')?; + let ws_idx = self.parse_workspace_id(ws_raw)?; + let tab_idx = tab_raw.parse::<usize>().ok()?.checked_sub(1)?; + self.state.workspaces.get(ws_idx)?.tabs.get(tab_idx)?; + return Some((ws_idx, tab_idx)); + } + + let (ws_raw, tab_raw) = id.rsplit_once(':')?; + let ws_idx = self.parse_workspace_id(ws_raw)?; + let tab_idx = tab_raw.parse::<usize>().ok()?.checked_sub(1)?; + self.state.workspaces.get(ws_idx)?.tabs.get(tab_idx)?; + Some((ws_idx, tab_idx)) + } + + pub(super) fn parse_pane_id(&self, id: &str) -> Option<(usize, crate::layout::PaneId)> { + if let Some(rest) = id.strip_prefix("p_") { + if let Some((ws_raw, pane_raw)) = rest.rsplit_once('_') { + let ws_idx = self.parse_workspace_id(ws_raw)?; + let pane_id = crate::layout::PaneId::from_raw(pane_raw.parse::<u32>().ok()?); + return Some((ws_idx, pane_id)); + } + + let pane_id = crate::layout::PaneId::from_raw(rest.parse::<u32>().ok()?); + return self.find_pane(pane_id).map(|(ws_idx, _)| (ws_idx, pane_id)); + } + + let (ws_raw, pane_number_raw) = id.rsplit_once('-')?; + let ws_idx = self.parse_workspace_id(ws_raw)?; + let pane_number = pane_number_raw.parse::<usize>().ok()?; + let ws = self.state.workspaces.get(ws_idx)?; + let pane_id = ws + .public_pane_numbers + .iter() + .find_map(|(pane_id, number)| (*number == pane_number).then_some(*pane_id))?; + Some((ws_idx, pane_id)) + } +} diff --git a/src/app/input.rs b/src/app/input.rs deleted file mode 100644 index dbc2547d..00000000 --- a/src/app/input.rs +++ /dev/null @@ -1,5416 +0,0 @@ -//! Input handling — translates crossterm key/mouse events into state mutations. - -use bytes::Bytes; -use crossterm::event::{KeyCode, KeyEvent, MouseButton, MouseEvent, MouseEventKind}; - -use crate::input::TerminalKey; -use ratatui::layout::{Direction, Rect}; -use tracing::{debug, warn}; - -use crate::layout::{NavDirection, PaneInfo, SplitBorder}; -use crate::selection::Selection; - -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -enum ScrollbarClickTarget { - Thumb { grab_row_offset: u16 }, - Track { offset_from_bottom: usize }, -} - -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -#[cfg(test)] -enum WheelRouting { - HostScroll, - MouseReport, - AlternateScroll, -} - -const WORKSPACE_DRAG_THRESHOLD: u16 = 1; -const TAB_DRAG_THRESHOLD: u16 = 1; - -use super::state::{ - AgentPanelScope, AppState, ContextMenuKind, ContextMenuState, DragState, DragTarget, - MenuListState, Mode, TabPressState, WorkspacePressState, -}; -use super::App; - -// --------------------------------------------------------------------------- -// Key handling -// --------------------------------------------------------------------------- - -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -struct AppKey { - raw: KeyEvent, - code: KeyCode, - modifiers: crossterm::event::KeyModifiers, -} - -impl AppKey { - fn code(self) -> KeyCode { - self.code - } - - fn modifiers(self) -> crossterm::event::KeyModifiers { - self.modifiers - } - - fn raw_event(self) -> KeyEvent { - self.raw - } - - fn matches_binding( - self, - expected_code: KeyCode, - expected_modifiers: crossterm::event::KeyModifiers, - ) -> bool { - let (expected_code, expected_modifiers) = - crate::input::normalize_app_key_binding(expected_code, expected_modifiers, None); - self.code == expected_code && self.modifiers == expected_modifiers - } - - fn text_char(self) -> Option<char> { - match self.code { - KeyCode::Char(ch) if self.modifiers.is_empty() => Some(ch), - _ => None, - } - } -} - -impl From<TerminalKey> for AppKey { - fn from(value: TerminalKey) -> Self { - let raw = value.as_key_event(); - let (code, modifiers) = crate::input::normalize_app_key_binding( - value.code, - value.modifiers, - value.shifted_codepoint, - ); - Self { - raw, - code, - modifiers, - } - } -} - -impl From<KeyEvent> for AppKey { - fn from(value: KeyEvent) -> Self { - let (code, modifiers) = - crate::input::normalize_app_key_binding(value.code, value.modifiers, None); - Self { - raw: value, - code, - modifiers, - } - } -} - -fn is_modifier_only_key(code: &KeyCode) -> bool { - matches!(code, KeyCode::Modifier(_)) -} - -fn terminal_direct_navigation_action(state: &AppState, key: &AppKey) -> Option<NavigateAction> { - let kb = &state.keybinds; - if kb - .previous_workspace - .is_some_and(|(code, mods)| key.matches_binding(code, mods)) - { - return Some(NavigateAction::PreviousWorkspace); - } - if kb - .next_workspace - .is_some_and(|(code, mods)| key.matches_binding(code, mods)) - { - return Some(NavigateAction::NextWorkspace); - } - if kb - .previous_tab - .is_some_and(|(code, mods)| key.matches_binding(code, mods)) - { - return Some(NavigateAction::PreviousTab); - } - if kb - .next_tab - .is_some_and(|(code, mods)| key.matches_binding(code, mods)) - { - return Some(NavigateAction::NextTab); - } - if kb - .focus_pane_left - .is_some_and(|(code, mods)| key.matches_binding(code, mods)) - { - return Some(NavigateAction::FocusPaneLeft); - } - if kb - .focus_pane_down - .is_some_and(|(code, mods)| key.matches_binding(code, mods)) - { - return Some(NavigateAction::FocusPaneDown); - } - if kb - .focus_pane_up - .is_some_and(|(code, mods)| key.matches_binding(code, mods)) - { - return Some(NavigateAction::FocusPaneUp); - } - if kb - .focus_pane_right - .is_some_and(|(code, mods)| key.matches_binding(code, mods)) - { - return Some(NavigateAction::FocusPaneRight); - } - None -} - -impl App { - pub(super) async fn handle_key(&mut self, key: TerminalKey) { - match self.state.mode { - Mode::Terminal => self.handle_terminal_key(key).await, - Mode::Navigate => self.handle_navigate_key(key), - _ => { - let key = AppKey::from(key); - match self.state.mode { - Mode::Onboarding => self.handle_onboarding_key(key), - Mode::ReleaseNotes => self.handle_release_notes_key(key), - Mode::RenameWorkspace | Mode::RenameTab => { - handle_rename_key(&mut self.state, key) - } - Mode::Resize => handle_resize_key(&mut self.state, key), - Mode::ConfirmClose => handle_confirm_close_key(&mut self.state, key), - Mode::ContextMenu => handle_context_menu_key(&mut self.state, key), - Mode::Settings => self.handle_settings_key(key), - Mode::GlobalMenu => handle_global_menu_key(&mut self.state, key), - Mode::KeybindHelp => handle_keybind_help_key(&mut self.state, key), - Mode::Terminal | Mode::Navigate => unreachable!(), - } - } - } - } - - pub(super) async fn handle_paste(&mut self, text: String) { - if self.state.mode != Mode::Terminal { - return; - } - if let Some(ws) = self.state.active.and_then(|i| self.state.workspaces.get(i)) { - if let Some(rt) = ws.focused_runtime() { - let _ = rt.send_paste(text).await; - } - } - } - - fn handle_onboarding_key(&mut self, key: AppKey) { - match self.state.onboarding_step { - 0 => match key.code() { - KeyCode::Right | KeyCode::Char('l') => { - self.state.onboarding_step = 1; - } - _ => match modal_action_from_key(&key, ONBOARDING_WELCOME_ACTIONS) { - Some(ModalAction::Continue) => self.state.onboarding_step = 1, - _ => {} - }, - }, - _ => match key.code() { - KeyCode::Up | KeyCode::Char('k') => self.state.onboarding_list.move_prev(), - KeyCode::Down | KeyCode::Char('j') => self.state.onboarding_list.move_next(4), - KeyCode::Left | KeyCode::Char('h') => { - self.state.onboarding_step = 0; - } - KeyCode::Char(c) if ('1'..='4').contains(&c) => { - self.state - .onboarding_list - .select((c as usize) - ('1' as usize)); - } - _ => match modal_action_from_key(&key, ONBOARDING_NOTIFICATION_ACTIONS) { - Some(ModalAction::Back) => self.state.onboarding_step = 0, - Some(ModalAction::Save) => self.complete_onboarding(), - _ => {} - }, - }, - } - } - - fn handle_release_notes_key(&mut self, key: AppKey) { - match key.code() { - KeyCode::Up | KeyCode::Char('k') => self.scroll_release_notes(-1), - KeyCode::Down | KeyCode::Char('j') => self.scroll_release_notes(1), - KeyCode::PageUp => self.scroll_release_notes(-8), - KeyCode::PageDown => self.scroll_release_notes(8), - KeyCode::Home => { - if let Some(notes) = &mut self.state.release_notes { - notes.scroll = 0; - } - } - KeyCode::End => { - let max_scroll = self.state.release_notes_max_scroll(); - if let Some(notes) = &mut self.state.release_notes { - notes.scroll = max_scroll; - } - } - _ => match modal_action_from_key(&key, RELEASE_NOTES_ACTIONS) { - Some(ModalAction::Close) => self.dismiss_release_notes(), - _ => {} - }, - } - } - - fn handle_settings_key(&mut self, key: AppKey) { - if let Some(action) = update_settings_state(&mut self.state, key) { - match action { - SettingsAction::SaveTheme(name) => self.save_theme(&name), - SettingsAction::SaveSound(enabled) => self.save_sound(enabled), - SettingsAction::SaveToast(enabled) => self.save_toast(enabled), - } - } - } - - fn handle_navigate_key(&mut self, raw_key: TerminalKey) { - let key = AppKey::from(raw_key); - self.state.update_dismissed = true; - - if key.matches_binding(self.state.prefix_code, self.state.prefix_mods) { - if !self.pass_through_key_to_focused_pane(raw_key) { - leave_navigate_mode(&mut self.state); - } - return; - } - - if key.code() == KeyCode::Esc { - leave_navigate_mode(&mut self.state); - return; - } - - if let Some(action) = navigate_action_for_key(&self.state, &key) { - execute_navigate_action(&mut self.state, action); - return; - } - - if handle_navigate_reserved_key(&mut self.state, key) { - return; - } - - if let Some(binding) = navigate_custom_command_for_key(&self.state, &key) { - self.launch_custom_command(binding); - } - } - - pub(super) fn handle_mouse(&mut self, mouse: MouseEvent) { - if self.state.mode == Mode::ReleaseNotes { - match mouse.kind { - MouseEventKind::Down(MouseButton::Left) - if self - .state - .release_notes_close_button_at(mouse.column, mouse.row) => - { - self.dismiss_release_notes(); - } - MouseEventKind::Down(MouseButton::Left) => { - if let Some(target) = self - .state - .release_notes_scrollbar_target_at(mouse.column, mouse.row) - { - match target { - ScrollbarClickTarget::Thumb { grab_row_offset } => { - self.state.drag = Some(DragState { - target: DragTarget::ReleaseNotesScrollbar { grab_row_offset }, - }); - } - ScrollbarClickTarget::Track { offset_from_bottom } => { - self.state - .set_release_notes_offset_from_bottom(offset_from_bottom); - } - } - } - } - MouseEventKind::Drag(MouseButton::Left) => { - if let Some(DragState { - target: DragTarget::ReleaseNotesScrollbar { grab_row_offset }, - }) = &self.state.drag - { - if let Some(offset_from_bottom) = self - .state - .release_notes_offset_for_drag_row(mouse.row, *grab_row_offset) - { - self.state - .set_release_notes_offset_from_bottom(offset_from_bottom); - } - } - } - MouseEventKind::Up(MouseButton::Left) => { - self.state.drag = None; - } - MouseEventKind::ScrollUp => self.scroll_release_notes(-3), - MouseEventKind::ScrollDown => self.scroll_release_notes(3), - _ => {} - } - return; - } - - if self.state.mode == Mode::KeybindHelp { - match mouse.kind { - MouseEventKind::Down(MouseButton::Left) - if self - .state - .keybind_help_close_button_at(mouse.column, mouse.row) => - { - leave_modal(&mut self.state); - } - MouseEventKind::Down(MouseButton::Left) => { - if let Some(target) = self - .state - .keybind_help_scrollbar_target_at(mouse.column, mouse.row) - { - match target { - ScrollbarClickTarget::Thumb { grab_row_offset } => { - self.state.drag = Some(DragState { - target: DragTarget::KeybindHelpScrollbar { grab_row_offset }, - }); - } - ScrollbarClickTarget::Track { offset_from_bottom } => { - self.state - .set_keybind_help_offset_from_bottom(offset_from_bottom); - } - } - } else { - let rect = self.state.keybind_help_popup_rect(); - let inside = mouse.column >= rect.x - && mouse.column < rect.x + rect.width - && mouse.row >= rect.y - && mouse.row < rect.y + rect.height; - if !inside { - leave_modal(&mut self.state); - } - } - } - MouseEventKind::Drag(MouseButton::Left) => { - if let Some(DragState { - target: DragTarget::KeybindHelpScrollbar { grab_row_offset }, - }) = &self.state.drag - { - if let Some(offset_from_bottom) = self - .state - .keybind_help_offset_for_drag_row(mouse.row, *grab_row_offset) - { - self.state - .set_keybind_help_offset_from_bottom(offset_from_bottom); - } - } - } - MouseEventKind::Up(MouseButton::Left) => { - self.state.drag = None; - } - MouseEventKind::ScrollUp => self.state.scroll_keybind_help(-3), - MouseEventKind::ScrollDown => self.state.scroll_keybind_help(3), - _ => {} - } - return; - } - - if matches!(mouse.kind, MouseEventKind::Down(MouseButton::Left)) - && self.state.on_sidebar_divider(mouse.column, mouse.row) - { - let now = std::time::Instant::now(); - let is_double_click = self - .last_sidebar_divider_click - .is_some_and(|last| now.duration_since(last) <= super::SIDEBAR_DOUBLE_CLICK_WINDOW); - self.last_sidebar_divider_click = Some(now); - - if is_double_click { - self.state.sidebar_width = self.state.default_sidebar_width; - self.state.sidebar_width_auto = false; - self.state.mark_session_dirty(); - self.state.drag = None; - return; - } - } - - if let Some(action) = self.state.handle_mouse(mouse) { - match action { - SettingsAction::SaveTheme(name) => self.save_theme(&name), - SettingsAction::SaveSound(enabled) => self.save_sound(enabled), - SettingsAction::SaveToast(enabled) => self.save_toast(enabled), - } - } - } - - fn pass_through_key_to_focused_pane(&mut self, key: TerminalKey) -> bool { - let Some(ws) = self.state.active.and_then(|i| self.state.workspaces.get(i)) else { - return false; - }; - let Some(rt) = ws.focused_runtime() else { - return false; - }; - - let bytes = rt.encode_terminal_key(key); - if bytes.is_empty() { - return false; - } - if rt.try_send_bytes(Bytes::from(bytes)).is_err() { - return false; - } - - self.state.mode = Mode::Terminal; - true - } - - async fn handle_terminal_key(&mut self, key: TerminalKey) { - self.state.clear_selection(); - self.state.update_dismissed = true; - - let app_key = AppKey::from(key); - let key_event = app_key.raw_event(); - - if let Some(action) = terminal_direct_navigation_action(&self.state, &app_key) { - debug!( - code = ?key_event.code, - modifiers = ?key_event.modifiers, - kind = ?key_event.kind, - action = ?action, - "intercepted terminal direct navigation key before forwarding to pane" - ); - execute_navigate_action(&mut self.state, action); - return; - } - - if app_key.matches_binding(self.state.prefix_code, self.state.prefix_mods) { - self.state.mode = Mode::Navigate; - return; - } - - if is_modifier_only_key(&key_event.code) { - debug!( - code = ?key_event.code, - modifiers = ?key_event.modifiers, - kind = ?key_event.kind, - "dropping modifier-only terminal key event instead of forwarding it to pane" - ); - return; - } - - if let Some(ws) = self.state.active.and_then(|i| self.state.workspaces.get(i)) { - if let Some(rt) = ws.focused_runtime() { - rt.scroll_reset(); - let protocol = rt.keyboard_protocol(); - let bytes = rt.encode_terminal_key(key); - if matches!(key_event.code, KeyCode::Esc) - || key_event - .modifiers - .contains(crossterm::event::KeyModifiers::ALT) - { - debug!( - code = ?key_event.code, - modifiers = ?key_event.modifiers, - kind = ?key_event.kind, - protocol = ?protocol, - encoded = ?bytes, - "forwarding potentially-ambiguous terminal key to pane" - ); - } - if bytes.is_empty() { - if key.kind != crossterm::event::KeyEventKind::Release - && !matches!( - key.code, - KeyCode::CapsLock - | KeyCode::ScrollLock - | KeyCode::NumLock - | KeyCode::PrintScreen - | KeyCode::Pause - | KeyCode::Menu - | KeyCode::KeypadBegin - | KeyCode::Media(_) - | KeyCode::Modifier(_) - ) - { - warn!(code = ?key_event.code, mods = ?key_event.modifiers, state = ?key_event.state, "key produced empty encoding"); - } - } else { - let _ = rt.send_bytes(Bytes::from(bytes)).await; - } - } - } - } -} - -#[derive(Debug, Clone, PartialEq, Eq)] -enum SettingsAction { - SaveTheme(String), - SaveSound(bool), - SaveToast(bool), -} - -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -enum ModalAction { - Continue, - Back, - Save, - Clear, - Cancel, - Confirm, - Apply, - Close, -} - -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -enum ModalKeyBinding { - Enter, - Esc, - CtrlC, -} - -impl ModalKeyBinding { - fn matches(self, key: &AppKey) -> bool { - match self { - Self::Enter => key.code() == KeyCode::Enter, - Self::Esc => key.code() == KeyCode::Esc, - Self::CtrlC => { - key.code() == KeyCode::Char('c') - && key.modifiers() == crossterm::event::KeyModifiers::CONTROL - } - } - } -} - -#[derive(Debug, Clone, Copy)] -struct ModalActionSpec<A> { - action: A, - bindings: &'static [ModalKeyBinding], -} - -fn modal_action_from_key<A: Copy>(key: &AppKey, specs: &[ModalActionSpec<A>]) -> Option<A> { - specs - .iter() - .find(|spec| spec.bindings.iter().any(|binding| binding.matches(key))) - .map(|spec| spec.action) -} - -fn modal_action_from_buttons<A: Copy>(col: u16, row: u16, buttons: &[(Rect, A)]) -> Option<A> { - buttons.iter().find_map(|(rect, action)| { - (col >= rect.x && col < rect.x + rect.width && row >= rect.y && row < rect.y + rect.height) - .then_some(*action) - }) -} - -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -enum GlobalMenuAction { - Quit, - WhatsNew, - Keybinds, - ReloadKeybinds, - Settings, -} - -fn global_menu_actions(state: &AppState) -> Vec<GlobalMenuAction> { - let mut actions = vec![ - GlobalMenuAction::Settings, - GlobalMenuAction::Keybinds, - GlobalMenuAction::ReloadKeybinds, - ]; - if state.latest_release_notes_available || state.update_available.is_some() { - actions.push(GlobalMenuAction::WhatsNew); - } - actions.push(GlobalMenuAction::Quit); - actions -} - -fn normalize_theme_name(name: &str) -> String { - name.to_lowercase().replace([' ', '_'], "-") -} - -fn current_theme_index(theme_name: &str) -> usize { - use crate::app::state::THEME_NAMES; - - let normalized = normalize_theme_name(theme_name); - THEME_NAMES - .iter() - .position(|name| normalize_theme_name(name) == normalized) - .unwrap_or(0) -} - -fn preview_selected_theme(state: &mut AppState) { - use crate::app::state::{Palette, THEME_NAMES}; - - let name = THEME_NAMES[state.settings.list.selected]; - if let Some(palette) = Palette::from_name(name) { - state.palette = palette; - state.theme_name = name.to_string(); - } -} - -fn cancel_settings(state: &mut AppState) { - if let Some(palette) = state.settings.original_palette.take() { - state.palette = palette; - } - if let Some(theme_name) = state.settings.original_theme.take() { - state.theme_name = theme_name; - } - leave_modal(state); -} - -fn apply_settings(state: &mut AppState) -> Option<SettingsAction> { - match state.settings.section { - crate::app::state::SettingsSection::Theme => { - let theme_name = state.theme_name.clone(); - state.settings.original_palette = None; - state.settings.original_theme = None; - leave_modal(state); - Some(SettingsAction::SaveTheme(theme_name)) - } - _ => { - leave_modal(state); - None - } - } -} - -fn update_settings_state(state: &mut AppState, key: impl Into<AppKey>) -> Option<SettingsAction> { - use crate::app::state::SettingsSection; - - let key = key.into(); - - match state.settings.section { - SettingsSection::Theme => match key.code() { - KeyCode::Up | KeyCode::Char('k') => { - let previous = state.settings.list.selected; - state.settings.list.move_prev(); - if state.settings.list.selected != previous { - preview_selected_theme(state); - } - } - KeyCode::Down | KeyCode::Char('j') => { - let previous = state.settings.list.selected; - state - .settings - .list - .move_next(crate::app::state::THEME_NAMES.len()); - if state.settings.list.selected != previous { - preview_selected_theme(state); - } - } - KeyCode::Tab | KeyCode::Right | KeyCode::Char('l') => { - state.settings.section = SettingsSection::Sound; - state.settings.list.selected = usize::from(!state.sound_enabled()); - } - _ => match modal_action_from_key(&key, SETTINGS_ACTIONS) { - Some(ModalAction::Apply) => return apply_settings(state), - Some(ModalAction::Close) => cancel_settings(state), - _ => {} - }, - }, - SettingsSection::Sound => match key.code() { - KeyCode::Up | KeyCode::Char('k') | KeyCode::Down | KeyCode::Char('j') => { - state.settings.list.selected = 1 - state.settings.list.selected.min(1); - } - KeyCode::Enter | KeyCode::Char(' ') => { - let enabled = state.settings.list.selected == 0; - state.sound.enabled = enabled; - return Some(SettingsAction::SaveSound(enabled)); - } - KeyCode::Tab | KeyCode::Right | KeyCode::Char('l') => { - state.settings.section = SettingsSection::Toast; - state.settings.list.selected = usize::from(!state.toast_config.enabled); - } - KeyCode::BackTab | KeyCode::Left | KeyCode::Char('h') => { - state.settings.section = SettingsSection::Theme; - state.settings.list.selected = current_theme_index(&state.theme_name); - } - _ => match modal_action_from_key(&key, SETTINGS_ACTIONS) { - Some(ModalAction::Close) => cancel_settings(state), - _ => {} - }, - }, - SettingsSection::Toast => match key.code() { - KeyCode::Up | KeyCode::Char('k') | KeyCode::Down | KeyCode::Char('j') => { - state.settings.list.selected = 1 - state.settings.list.selected.min(1); - } - KeyCode::Enter | KeyCode::Char(' ') => { - let enabled = state.settings.list.selected == 0; - state.toast_config.enabled = enabled; - return Some(SettingsAction::SaveToast(enabled)); - } - KeyCode::BackTab | KeyCode::Left | KeyCode::Char('h') => { - state.settings.section = SettingsSection::Sound; - state.settings.list.selected = usize::from(!state.sound_enabled()); - } - KeyCode::Tab | KeyCode::Right | KeyCode::Char('l') => { - state.settings.section = SettingsSection::Theme; - state.settings.list.selected = current_theme_index(&state.theme_name); - } - _ => match modal_action_from_key(&key, SETTINGS_ACTIONS) { - Some(ModalAction::Close) => cancel_settings(state), - _ => {} - }, - }, - } - - None -} - -fn open_global_menu(state: &mut AppState) { - state.global_menu = MenuListState::new(0); - state.mode = Mode::GlobalMenu; -} - -fn open_keybind_help(state: &mut AppState) { - state.keybind_help.scroll = 0; - state.mode = Mode::KeybindHelp; -} - -fn open_update_release_notes(state: &mut AppState) { - let Some(notes) = crate::release_notes::load_latest() else { - return; - }; - - state.release_notes = Some(crate::app::state::ReleaseNotesState { - version: notes.version, - body: notes.body, - scroll: 0, - preview: notes.preview, - }); - state.mode = Mode::ReleaseNotes; -} - -fn apply_global_menu_action(state: &mut AppState, action: GlobalMenuAction) { - match action { - GlobalMenuAction::Quit => state.should_quit = true, - GlobalMenuAction::WhatsNew => open_update_release_notes(state), - GlobalMenuAction::Keybinds => open_keybind_help(state), - GlobalMenuAction::ReloadKeybinds => { - state.request_reload_keybinds = true; - leave_modal(state); - } - GlobalMenuAction::Settings => open_settings(state), - } -} - -fn handle_global_menu_key(state: &mut AppState, key: impl Into<AppKey>) { - let key = key.into(); - let actions = global_menu_actions(state); - match key.code() { - KeyCode::Esc => leave_modal(state), - KeyCode::Up | KeyCode::Char('k') => state.global_menu.move_prev(), - KeyCode::Down | KeyCode::Char('j') => state.global_menu.move_next(actions.len()), - KeyCode::Enter => { - if let Some(action) = actions.get(state.global_menu.highlighted).copied() { - apply_global_menu_action(state, action); - } - } - _ => {} - } -} - -fn handle_keybind_help_key(state: &mut AppState, key: impl Into<AppKey>) { - let key = key.into(); - match key.code() { - KeyCode::Up | KeyCode::Char('k') => state.scroll_keybind_help(-1), - KeyCode::Down | KeyCode::Char('j') => state.scroll_keybind_help(1), - KeyCode::PageUp => state.scroll_keybind_help(-8), - KeyCode::PageDown => state.scroll_keybind_help(8), - KeyCode::Home => state.keybind_help.scroll = 0, - KeyCode::End => state.keybind_help.scroll = state.keybind_help_max_scroll(), - KeyCode::Esc | KeyCode::Enter | KeyCode::Char('?') => leave_modal(state), - _ => {} - } -} - -fn navigate_custom_command_for_key( - state: &AppState, - key: &AppKey, -) -> Option<crate::config::CustomCommandKeybind> { - state - .keybinds - .custom_commands - .iter() - .find(|binding| key.matches_binding(binding.key.0, binding.key.1)) - .cloned() -} - -fn handle_navigate_reserved_key(state: &mut AppState, key: impl Into<AppKey>) -> bool { - let key = key.into(); - match key.code() { - KeyCode::Char('q') => { - state.should_quit = true; - true - } - KeyCode::Enter => { - if !state.workspaces.is_empty() { - state.switch_workspace(state.selected); - leave_navigate_mode(state); - } - true - } - KeyCode::Char(c @ '1'..='9') => { - let idx = (c as usize) - ('1' as usize); - if idx < state.workspaces.len() { - state.switch_workspace(idx); - leave_navigate_mode(state); - } - true - } - KeyCode::Char('s') => { - open_settings(state); - true - } - KeyCode::Char('?') => { - open_keybind_help(state); - true - } - KeyCode::Up => { - if state.selected > 0 { - state.selected -= 1; - state.ensure_workspace_visible(state.selected); - } - true - } - KeyCode::Down => { - if !state.workspaces.is_empty() && state.selected < state.workspaces.len() - 1 { - state.selected += 1; - state.ensure_workspace_visible(state.selected); - } - true - } - KeyCode::Char('h') | KeyCode::Left => { - state.navigate_pane(NavDirection::Left); - true - } - KeyCode::Char('j') => { - state.navigate_pane(NavDirection::Down); - true - } - KeyCode::Char('k') => { - state.navigate_pane(NavDirection::Up); - true - } - KeyCode::Char('l') | KeyCode::Right => { - state.navigate_pane(NavDirection::Right); - true - } - KeyCode::Tab => { - state.cycle_pane(false); - true - } - KeyCode::BackTab => { - state.cycle_pane(true); - true - } - _ => false, - } -} - -#[allow(dead_code)] // exercised in input unit tests; production uses App::handle_navigate_key -fn handle_navigate_key(state: &mut AppState, key: impl Into<AppKey>) { - let key = key.into(); - state.update_dismissed = true; - - if key.matches_binding(state.prefix_code, state.prefix_mods) || key.code() == KeyCode::Esc { - leave_navigate_mode(state); - return; - } - - if let Some(action) = navigate_action_for_key(state, &key) { - execute_navigate_action(state, action); - return; - } - - let _ = handle_navigate_reserved_key(state, key); -} - -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -enum NavigateAction { - NewWorkspace, - RenameWorkspace, - CloseWorkspace, - PreviousWorkspace, - NextWorkspace, - NewTab, - RenameTab, - PreviousTab, - NextTab, - CloseTab, - FocusPaneLeft, - FocusPaneDown, - FocusPaneUp, - FocusPaneRight, - SplitVertical, - SplitHorizontal, - ClosePane, - Fullscreen, - EnterResizeMode, - ToggleSidebar, -} - -fn navigate_action_for_key(state: &AppState, key: &AppKey) -> Option<NavigateAction> { - let kb = &state.keybinds; - if key.matches_binding(kb.new_workspace.0, kb.new_workspace.1) { - return Some(NavigateAction::NewWorkspace); - } - if key.matches_binding(kb.rename_workspace.0, kb.rename_workspace.1) { - return Some(NavigateAction::RenameWorkspace); - } - if key.matches_binding(kb.close_workspace.0, kb.close_workspace.1) { - return Some(NavigateAction::CloseWorkspace); - } - if kb - .previous_workspace - .is_some_and(|(code, mods)| key.matches_binding(code, mods)) - { - return Some(NavigateAction::PreviousWorkspace); - } - if kb - .next_workspace - .is_some_and(|(code, mods)| key.matches_binding(code, mods)) - { - return Some(NavigateAction::NextWorkspace); - } - if key.matches_binding(kb.new_tab.0, kb.new_tab.1) { - return Some(NavigateAction::NewTab); - } - if kb - .rename_tab - .is_some_and(|(code, mods)| key.matches_binding(code, mods)) - { - return Some(NavigateAction::RenameTab); - } - if kb - .previous_tab - .is_some_and(|(code, mods)| key.matches_binding(code, mods)) - { - return Some(NavigateAction::PreviousTab); - } - if kb - .next_tab - .is_some_and(|(code, mods)| key.matches_binding(code, mods)) - { - return Some(NavigateAction::NextTab); - } - if kb - .close_tab - .is_some_and(|(code, mods)| key.matches_binding(code, mods)) - { - return Some(NavigateAction::CloseTab); - } - if key.matches_binding(kb.split_vertical.0, kb.split_vertical.1) { - return Some(NavigateAction::SplitVertical); - } - if key.matches_binding(kb.split_horizontal.0, kb.split_horizontal.1) { - return Some(NavigateAction::SplitHorizontal); - } - if key.matches_binding(kb.close_pane.0, kb.close_pane.1) { - return Some(NavigateAction::ClosePane); - } - if key.matches_binding(kb.fullscreen.0, kb.fullscreen.1) { - return Some(NavigateAction::Fullscreen); - } - if key.matches_binding(kb.resize_mode.0, kb.resize_mode.1) { - return Some(NavigateAction::EnterResizeMode); - } - if key.matches_binding(kb.toggle_sidebar.0, kb.toggle_sidebar.1) { - return Some(NavigateAction::ToggleSidebar); - } - None -} - -fn execute_navigate_action(state: &mut AppState, action: NavigateAction) { - match action { - NavigateAction::NewWorkspace => { - state.request_new_workspace = true; - leave_navigate_mode(state); - } - NavigateAction::RenameWorkspace => { - if !state.workspaces.is_empty() { - open_rename_workspace(state, state.selected); - } - } - NavigateAction::CloseWorkspace => { - if !state.workspaces.is_empty() { - if state.confirm_close { - open_confirm_close(state); - } else { - state.close_selected_workspace(); - leave_navigate_mode(state); - } - } - } - NavigateAction::PreviousWorkspace => { - state.previous_workspace(); - leave_navigate_mode(state); - } - NavigateAction::NextWorkspace => { - state.next_workspace(); - leave_navigate_mode(state); - } - NavigateAction::NewTab => open_new_tab_dialog(state), - NavigateAction::RenameTab => open_rename_active_tab(state, false), - NavigateAction::PreviousTab => { - state.previous_tab(); - leave_navigate_mode(state); - } - NavigateAction::NextTab => { - state.next_tab(); - leave_navigate_mode(state); - } - NavigateAction::CloseTab => { - state.close_tab(); - leave_navigate_mode(state); - } - NavigateAction::FocusPaneLeft => state.navigate_pane(NavDirection::Left), - NavigateAction::FocusPaneDown => state.navigate_pane(NavDirection::Down), - NavigateAction::FocusPaneUp => state.navigate_pane(NavDirection::Up), - NavigateAction::FocusPaneRight => state.navigate_pane(NavDirection::Right), - NavigateAction::SplitVertical => { - state.split_pane(Direction::Horizontal); - leave_navigate_mode(state); - } - NavigateAction::SplitHorizontal => { - state.split_pane(Direction::Vertical); - leave_navigate_mode(state); - } - NavigateAction::ClosePane => { - state.close_pane(); - leave_navigate_mode(state); - } - NavigateAction::Fullscreen => { - state.toggle_fullscreen(); - leave_navigate_mode(state); - } - NavigateAction::EnterResizeMode => state.mode = Mode::Resize, - NavigateAction::ToggleSidebar => { - state.sidebar_collapsed = !state.sidebar_collapsed; - leave_navigate_mode(state); - } - } -} - -fn leave_navigate_mode(state: &mut AppState) { - if state.active.is_some() { - state.mode = Mode::Terminal; - } -} - -fn open_rename_workspace(state: &mut AppState, ws_idx: usize) { - state.selected = ws_idx; - state.name_input = state.workspaces[ws_idx].display_name(); - state.name_input_replace_on_type = false; - state.mode = Mode::RenameWorkspace; -} - -fn open_rename_active_tab(state: &mut AppState, replace_on_type: bool) { - state.creating_new_tab = false; - state.requested_new_tab_name = None; - if let Some(ws) = state.active.and_then(|i| state.workspaces.get(i)) { - if let Some(name) = ws.active_tab_display_name() { - state.name_input = name; - state.name_input_replace_on_type = replace_on_type; - state.mode = Mode::RenameTab; - } - } -} - -fn next_new_tab_default_name(state: &AppState) -> String { - state - .active - .and_then(|i| state.workspaces.get(i)) - .map(|ws| (ws.tabs.len() + 1).to_string()) - .unwrap_or_else(|| "1".to_string()) -} - -fn open_new_tab_dialog(state: &mut AppState) { - state.creating_new_tab = true; - state.requested_new_tab_name = None; - state.name_input = next_new_tab_default_name(state); - state.name_input_replace_on_type = true; - state.mode = Mode::RenameTab; -} - -/// Return to the appropriate mode after completing a modal action. -/// Goes to Terminal if a workspace is active, otherwise Navigate. -fn leave_modal(state: &mut AppState) { - if state.active.is_some() { - state.mode = Mode::Terminal; - } else { - state.mode = Mode::Navigate; - } -} - -const ONBOARDING_WELCOME_ACTIONS: &[ModalActionSpec<ModalAction>] = &[ModalActionSpec { - action: ModalAction::Continue, - bindings: &[ModalKeyBinding::Enter], -}]; - -const ONBOARDING_NOTIFICATION_ACTIONS: &[ModalActionSpec<ModalAction>] = &[ - ModalActionSpec { - action: ModalAction::Back, - bindings: &[ModalKeyBinding::Esc], - }, - ModalActionSpec { - action: ModalAction::Save, - bindings: &[ModalKeyBinding::Enter], - }, -]; - -const RELEASE_NOTES_ACTIONS: &[ModalActionSpec<ModalAction>] = &[ModalActionSpec { - action: ModalAction::Close, - bindings: &[ModalKeyBinding::Enter, ModalKeyBinding::Esc], -}]; - -const RENAME_ACTIONS: &[ModalActionSpec<ModalAction>] = &[ - ModalActionSpec { - action: ModalAction::Save, - bindings: &[ModalKeyBinding::Enter], - }, - ModalActionSpec { - action: ModalAction::Clear, - bindings: &[ModalKeyBinding::CtrlC], - }, - ModalActionSpec { - action: ModalAction::Cancel, - bindings: &[ModalKeyBinding::Esc], - }, -]; - -const CONFIRM_CLOSE_ACTIONS: &[ModalActionSpec<ModalAction>] = &[ - ModalActionSpec { - action: ModalAction::Confirm, - bindings: &[ModalKeyBinding::Enter], - }, - ModalActionSpec { - action: ModalAction::Cancel, - bindings: &[ModalKeyBinding::Esc], - }, -]; - -const SETTINGS_ACTIONS: &[ModalActionSpec<ModalAction>] = &[ - ModalActionSpec { - action: ModalAction::Apply, - bindings: &[ModalKeyBinding::Enter], - }, - ModalActionSpec { - action: ModalAction::Close, - bindings: &[ModalKeyBinding::Esc], - }, -]; - -fn open_settings(state: &mut AppState) { - use crate::app::state::SettingsSection; - - // Save current state for cancel - state.settings.original_palette = Some(state.palette.clone()); - state.settings.original_theme = Some(state.theme_name.clone()); - state.settings.section = SettingsSection::Theme; - state.settings.list.selected = current_theme_index(&state.theme_name); - state.mode = Mode::Settings; -} - -fn apply_rename_action(state: &mut AppState, action: ModalAction) { - match action { - ModalAction::Save => { - let new_name = if state.name_input.trim().is_empty() { - state.name_input.clone() - } else { - state.name_input.trim().to_string() - }; - match state.mode { - Mode::RenameWorkspace if !state.workspaces.is_empty() => { - if !new_name.is_empty() { - state.workspaces[state.selected].set_custom_name(new_name); - state.mark_session_dirty(); - } - } - Mode::RenameTab if state.creating_new_tab => { - state.request_new_tab = true; - let default_name = next_new_tab_default_name(state); - state.requested_new_tab_name = - if new_name.is_empty() || new_name == default_name { - None - } else { - Some(new_name) - }; - } - Mode::RenameTab => { - if let Some(ws) = state.active.and_then(|i| state.workspaces.get_mut(i)) { - if let Some(tab) = ws.active_tab_mut() { - let keep_auto_name = - tab.is_auto_named() && new_name == tab.number.to_string(); - if !new_name.is_empty() && !keep_auto_name { - tab.set_custom_name(new_name); - state.mark_session_dirty(); - } - } - } - } - _ => {} - } - state.creating_new_tab = false; - state.name_input.clear(); - state.name_input_replace_on_type = false; - leave_modal(state); - } - ModalAction::Clear => { - state.name_input.clear(); - state.name_input_replace_on_type = false; - } - ModalAction::Cancel => { - state.creating_new_tab = false; - state.requested_new_tab_name = None; - state.name_input.clear(); - state.name_input_replace_on_type = false; - leave_modal(state); - } - _ => {} - } -} - -fn handle_rename_key(state: &mut AppState, key: impl Into<AppKey>) { - let key = key.into(); - if let Some(action) = modal_action_from_key(&key, RENAME_ACTIONS) { - apply_rename_action(state, action); - return; - } - - match key.code() { - KeyCode::Backspace => { - if state.name_input_replace_on_type { - state.name_input.clear(); - state.name_input_replace_on_type = false; - } else { - state.name_input.pop(); - } - } - _ => { - if let Some(c) = key.text_char() { - if state.name_input_replace_on_type { - state.name_input.clear(); - state.name_input_replace_on_type = false; - } - state.name_input.push(c); - } - } - } -} - -fn handle_resize_key(state: &mut AppState, key: impl Into<AppKey>) { - let key = key.into(); - if key.code() == KeyCode::Esc - || key.code() == KeyCode::Enter - || key.matches_binding(state.keybinds.resize_mode.0, state.keybinds.resize_mode.1) - { - if state.active.is_some() { - state.mode = Mode::Terminal; - } else { - state.mode = Mode::Navigate; - } - return; - } - - match key.code() { - KeyCode::Char('h') | KeyCode::Left => state.resize_pane(NavDirection::Left), - KeyCode::Char('l') | KeyCode::Right => state.resize_pane(NavDirection::Right), - KeyCode::Char('j') | KeyCode::Down => state.resize_pane(NavDirection::Down), - KeyCode::Char('k') | KeyCode::Up => state.resize_pane(NavDirection::Up), - _ => {} - } -} - -fn open_confirm_close(state: &mut AppState) { - state.mode = Mode::ConfirmClose; -} - -fn confirm_close_accept(state: &mut AppState) { - state.close_selected_workspace(); - if state.workspaces.is_empty() { - state.mode = Mode::Navigate; - } else { - state.mode = Mode::Terminal; - } -} - -fn confirm_close_cancel(state: &mut AppState) { - state.mode = Mode::Navigate; -} - -fn handle_confirm_close_key(state: &mut AppState, key: impl Into<AppKey>) { - let key = key.into(); - match modal_action_from_key(&key, CONFIRM_CLOSE_ACTIONS) { - Some(ModalAction::Confirm) => confirm_close_accept(state), - Some(ModalAction::Cancel) => confirm_close_cancel(state), - _ => {} - } -} - -fn apply_context_menu_action(state: &mut AppState, menu: ContextMenuState, idx: usize) { - let item = menu.items().get(idx).copied(); - match (menu.kind, item) { - (ContextMenuKind::Workspace { ws_idx }, Some("Rename")) => { - open_rename_workspace(state, ws_idx); - } - (ContextMenuKind::Workspace { ws_idx }, Some("Close")) => { - state.selected = ws_idx; - if state.confirm_close { - open_confirm_close(state); - } else { - state.close_selected_workspace(); - state.mode = Mode::Navigate; - } - } - (ContextMenuKind::Tab { ws_idx, tab_idx }, Some("New tab")) => { - state.selected = ws_idx; - state.active = Some(ws_idx); - state.switch_tab(tab_idx); - open_new_tab_dialog(state); - } - (ContextMenuKind::Tab { ws_idx, tab_idx }, Some("Rename")) => { - state.selected = ws_idx; - state.active = Some(ws_idx); - state.switch_tab(tab_idx); - open_rename_active_tab(state, false); - } - (ContextMenuKind::Tab { ws_idx, tab_idx }, Some("Close")) => { - state.selected = ws_idx; - state.active = Some(ws_idx); - state.switch_tab(tab_idx); - state.close_tab(); - state.mode = if state.active.is_some() { - Mode::Terminal - } else { - Mode::Navigate - }; - } - (ContextMenuKind::Pane, Some("Split vertical")) => { - state.split_pane(Direction::Horizontal); - state.mode = Mode::Terminal; - } - (ContextMenuKind::Pane, Some("Split horizontal")) => { - state.split_pane(Direction::Vertical); - state.mode = Mode::Terminal; - } - (ContextMenuKind::Pane, Some("Fullscreen")) => { - state.toggle_fullscreen(); - state.mode = Mode::Terminal; - } - (ContextMenuKind::Pane, Some("Close pane")) => { - state.close_pane(); - state.mode = if state.active.is_some() { - Mode::Terminal - } else { - Mode::Navigate - }; - } - _ => leave_modal(state), - } -} - -fn handle_context_menu_key(state: &mut AppState, key: impl Into<AppKey>) { - let key = key.into(); - match key.code() { - KeyCode::Esc => { - state.context_menu = None; - leave_modal(state); - } - KeyCode::Up => { - if let Some(menu) = &mut state.context_menu { - menu.list.move_prev(); - } - } - KeyCode::Down => { - if let Some(menu) = &mut state.context_menu { - menu.list.move_next(menu.items().len()); - } - } - KeyCode::Enter => { - if let Some(menu) = state.context_menu.take() { - let idx = menu.list.highlighted; - apply_context_menu_action(state, menu, idx); - } - } - _ => {} - } -} - -// --------------------------------------------------------------------------- -// Mouse handling -// --------------------------------------------------------------------------- - -impl AppState { - fn onboarding_full_area(&self) -> ratatui::layout::Rect { - self.view.sidebar_rect.union(self.view.terminal_area) - } - - fn onboarding_modal_inner(&self, popup_w: u16, popup_h: u16) -> Option<ratatui::layout::Rect> { - let area = self.onboarding_full_area(); - let popup_w = popup_w.min(area.width.saturating_sub(4)); - let popup_h = popup_h.min(area.height.saturating_sub(2)); - if popup_w < 4 || popup_h < 4 { - return None; - } - let popup_x = area.x + (area.width.saturating_sub(popup_w)) / 2; - let popup_y = area.y + (area.height.saturating_sub(popup_h)) / 2; - let popup = ratatui::layout::Rect::new(popup_x, popup_y, popup_w, popup_h); - let block = ratatui::widgets::Block::default().borders(ratatui::widgets::Borders::ALL); - Some(block.inner(popup)) - } - - fn release_notes_modal_inner(&self) -> Option<ratatui::layout::Rect> { - self.onboarding_modal_inner( - crate::ui::RELEASE_NOTES_MODAL_SIZE.0, - crate::ui::RELEASE_NOTES_MODAL_SIZE.1, - ) - } - - fn release_notes_close_button_at(&self, col: u16, row: u16) -> bool { - let Some(inner) = self.release_notes_modal_inner() else { - return false; - }; - if inner.height < 4 || inner.width < 12 { - return false; - } - let button = - crate::ui::release_notes_close_button_rect(Rect::new(inner.x, inner.y, inner.width, 1)); - col >= button.x - && col < button.x + button.width - && row >= button.y - && row < button.y + button.height - } - - fn rename_modal_inner(&self) -> Option<Rect> { - self.onboarding_modal_inner(56, 7) - } - - fn release_notes_body_rect(&self) -> Option<Rect> { - let inner = self.release_notes_modal_inner()?; - if inner.height < 8 || inner.width < 4 { - return None; - } - let body = crate::ui::modal_stack_areas(inner, 2, 1, 0, 1).content; - let preview = self - .release_notes - .as_ref() - .is_some_and(|notes| notes.preview); - Some(crate::ui::release_notes_sections(body, preview).notes_body) - } - - fn release_notes_scroll_metrics(&self) -> Option<crate::pane::ScrollMetrics> { - let notes = self.release_notes.as_ref()?; - let body = self.release_notes_body_rect()?; - let viewport_rows = body.height.max(1) as usize; - let lines = crate::ui::release_notes_lines(¬es.body, &self.palette); - - let rows_for_width = |wrap_width: usize| { - lines - .iter() - .map(|(width, _)| width.max(&1).div_ceil(wrap_width.max(1))) - .sum::<usize>() - }; - - let full_width = body.width.max(1) as usize; - let mut total_rows = rows_for_width(full_width); - let wrap_width = if total_rows > viewport_rows && full_width > 1 { - body.width.saturating_sub(1).max(1) as usize - } else { - full_width - }; - total_rows = rows_for_width(wrap_width); - - let max_offset_from_bottom = total_rows.saturating_sub(viewport_rows); - Some(crate::pane::ScrollMetrics { - offset_from_bottom: max_offset_from_bottom.saturating_sub(notes.scroll as usize), - max_offset_from_bottom, - viewport_rows, - }) - } - - pub(crate) fn release_notes_max_scroll(&self) -> u16 { - self.release_notes_scroll_metrics() - .map(|metrics| metrics.max_offset_from_bottom as u16) - .unwrap_or(0) - } - - fn release_notes_scrollbar_target_at( - &self, - col: u16, - row: u16, - ) -> Option<ScrollbarClickTarget> { - let body = self.release_notes_body_rect()?; - let metrics = self.release_notes_scroll_metrics()?; - let track = crate::ui::release_notes_scrollbar_rect(body, metrics)?; - if !(col >= track.x - && col < track.x + track.width - && row >= track.y - && row < track.y + track.height) - { - return None; - } - if let Some(grab_row_offset) = crate::ui::scrollbar_thumb_grab_offset(metrics, track, row) { - Some(ScrollbarClickTarget::Thumb { grab_row_offset }) - } else { - Some(ScrollbarClickTarget::Track { - offset_from_bottom: crate::ui::scrollbar_offset_from_row(metrics, track, row), - }) - } - } - - fn release_notes_offset_for_drag_row(&self, row: u16, grab_row_offset: u16) -> Option<usize> { - let body = self.release_notes_body_rect()?; - let metrics = self.release_notes_scroll_metrics()?; - let track = crate::ui::release_notes_scrollbar_rect(body, metrics)?; - Some(crate::ui::scrollbar_offset_from_drag_row( - metrics, - track, - row, - grab_row_offset, - )) - } - - fn set_release_notes_offset_from_bottom(&mut self, offset_from_bottom: usize) { - let max_scroll = self.release_notes_max_scroll() as usize; - if let Some(notes) = &mut self.release_notes { - notes.scroll = max_scroll.saturating_sub(offset_from_bottom) as u16; - } - } - - fn handle_onboarding_mouse(&mut self, mouse: MouseEvent) { - if !matches!(mouse.kind, MouseEventKind::Down(MouseButton::Left)) { - return; - } - - match self.onboarding_step { - 0 => { - let Some(inner) = self.onboarding_modal_inner(64, 16) else { - return; - }; - let actions = crate::ui::modal_stack_areas(inner, 2, 0, 1, 1) - .actions - .unwrap_or_default(); - let button = crate::ui::onboarding_welcome_continue_rect(actions); - if matches!(mouse.kind, MouseEventKind::Down(MouseButton::Left)) - && modal_action_from_buttons( - mouse.column, - mouse.row, - &[(button, ModalAction::Continue)], - ) == Some(ModalAction::Continue) - { - self.onboarding_step = 1; - } - } - _ => { - let Some(inner) = self.onboarding_modal_inner(56, 14) else { - return; - }; - let stack = crate::ui::modal_stack_areas(inner, 3, 0, 1, 1); - if mouse.row >= stack.content.y && mouse.row < stack.content.y + 4 { - self.onboarding_list - .select((mouse.row - stack.content.y) as usize); - return; - } - - let (back, save) = crate::ui::onboarding_notification_button_rects( - stack.actions.unwrap_or_default(), - ); - if matches!(mouse.kind, MouseEventKind::Down(MouseButton::Left)) { - match modal_action_from_buttons( - mouse.column, - mouse.row, - &[(back, ModalAction::Back), (save, ModalAction::Save)], - ) { - Some(ModalAction::Back) => self.onboarding_step = 0, - Some(ModalAction::Save) => self.request_complete_onboarding = true, - _ => {} - } - } - } - } - } - - fn workspace_list_rect(&self) -> Rect { - let sidebar = self.view.sidebar_rect; - if self.sidebar_collapsed || sidebar.width <= 1 || sidebar.height == 0 { - return Rect::default(); - } - crate::ui::workspace_list_rect(sidebar, self.sidebar_section_split) - } - - fn agent_panel_rect(&self) -> Rect { - let sidebar = self.view.sidebar_rect; - if self.sidebar_collapsed || sidebar.width <= 1 || sidebar.height == 0 { - return Rect::default(); - } - let (_, detail_area) = - crate::ui::expanded_sidebar_sections(sidebar, self.sidebar_section_split); - detail_area - } - - fn workspace_list_scrollbar_target_at( - &self, - col: u16, - row: u16, - ) -> Option<ScrollbarClickTarget> { - let area = self.workspace_list_rect(); - let metrics = crate::ui::workspace_list_scroll_metrics(self, area); - let track = crate::ui::workspace_list_scrollbar_rect(self, area)?; - if col < track.x - || col >= track.x + track.width - || row < track.y - || row >= track.y + track.height - { - return None; - } - if let Some(grab_row_offset) = crate::ui::scrollbar_thumb_grab_offset(metrics, track, row) { - Some(ScrollbarClickTarget::Thumb { grab_row_offset }) - } else { - Some(ScrollbarClickTarget::Track { - offset_from_bottom: crate::ui::scrollbar_offset_from_row(metrics, track, row), - }) - } - } - - fn workspace_list_offset_for_drag_row(&self, row: u16, grab_row_offset: u16) -> Option<usize> { - let area = self.workspace_list_rect(); - let metrics = crate::ui::workspace_list_scroll_metrics(self, area); - let track = crate::ui::workspace_list_scrollbar_rect(self, area)?; - Some(crate::ui::scrollbar_offset_from_drag_row( - metrics, - track, - row, - grab_row_offset, - )) - } - - fn set_workspace_list_offset_from_bottom(&mut self, offset_from_bottom: usize) { - let area = self.workspace_list_rect(); - let metrics = crate::ui::workspace_list_scroll_metrics(self, area); - self.workspace_scroll = metrics - .max_offset_from_bottom - .saturating_sub(offset_from_bottom); - } - - fn scroll_workspace_list(&mut self, delta: i16) { - if delta.is_negative() { - self.workspace_scroll = self - .workspace_scroll - .saturating_sub(delta.unsigned_abs() as usize); - return; - } - - for _ in 0..delta as usize { - let cards = crate::ui::compute_workspace_card_areas(self, self.view.sidebar_rect); - let Some(last) = cards.last() else { - break; - }; - if last.ws_idx + 1 >= self.workspaces.len() { - break; - } - self.workspace_scroll = self.workspace_scroll.saturating_add(1); - } - } - - fn agent_panel_scrollbar_target_at(&self, col: u16, row: u16) -> Option<ScrollbarClickTarget> { - let area = self.agent_panel_rect(); - let metrics = crate::ui::agent_panel_scroll_metrics(self, area); - let track = crate::ui::agent_panel_scrollbar_rect(self, area)?; - if col < track.x - || col >= track.x + track.width - || row < track.y - || row >= track.y + track.height - { - return None; - } - if let Some(grab_row_offset) = crate::ui::scrollbar_thumb_grab_offset(metrics, track, row) { - Some(ScrollbarClickTarget::Thumb { grab_row_offset }) - } else { - Some(ScrollbarClickTarget::Track { - offset_from_bottom: crate::ui::scrollbar_offset_from_row(metrics, track, row), - }) - } - } - - fn agent_panel_offset_for_drag_row(&self, row: u16, grab_row_offset: u16) -> Option<usize> { - let area = self.agent_panel_rect(); - let metrics = crate::ui::agent_panel_scroll_metrics(self, area); - let track = crate::ui::agent_panel_scrollbar_rect(self, area)?; - Some(crate::ui::scrollbar_offset_from_drag_row( - metrics, - track, - row, - grab_row_offset, - )) - } - - fn set_agent_panel_offset_from_bottom(&mut self, offset_from_bottom: usize) { - let area = self.agent_panel_rect(); - let metrics = crate::ui::agent_panel_scroll_metrics(self, area); - self.agent_panel_scroll = metrics - .max_offset_from_bottom - .saturating_sub(offset_from_bottom); - } - - fn scroll_agent_panel(&mut self, delta: i16) { - let area = self.agent_panel_rect(); - let max_scroll = crate::ui::agent_panel_scroll_metrics(self, area).max_offset_from_bottom; - if delta.is_negative() { - self.agent_panel_scroll = self - .agent_panel_scroll - .saturating_sub(delta.unsigned_abs() as usize); - } else { - self.agent_panel_scroll = self - .agent_panel_scroll - .saturating_add(delta as usize) - .min(max_scroll); - } - } - - pub(crate) fn sidebar_footer_rect(&self) -> Rect { - let ws_area = self.workspace_list_rect(); - if ws_area == Rect::default() { - return Rect::default(); - } - let y = ws_area.y + ws_area.height.saturating_sub(1); - Rect::new(ws_area.x, y, ws_area.width, 1) - } - - pub(crate) fn sidebar_new_button_rect(&self) -> Rect { - let footer = self.sidebar_footer_rect(); - let width = 5u16.min(footer.width.max(1)); - Rect::new(footer.x, footer.y, width, footer.height) - } - - pub(crate) fn global_launcher_rect(&self) -> Rect { - let footer = self.sidebar_footer_rect(); - let width = if self.update_available.is_some() { - 8 - } else { - 6 - } - .min(footer.width.max(1)); - let x = footer.x + footer.width.saturating_sub(width); - Rect::new(x, footer.y, width, footer.height) - } - - pub(crate) fn global_menu_labels(&self) -> Vec<&'static str> { - let mut labels = vec!["settings", "keybinds", "reload keybinds"]; - if self.update_available.is_some() { - labels.push("update available"); - } else if self.latest_release_notes_available { - labels.push("what's new"); - } - labels.push("quit"); - labels - } - - pub(crate) fn global_menu_rect(&self) -> Rect { - let screen = self.screen_rect(); - let launcher = self.global_launcher_rect(); - let labels = self.global_menu_labels(); - let content_width = labels - .iter() - .map(|label| { - let extra = if *label == "update available" { 2 } else { 0 }; - label.chars().count() as u16 + extra - }) - .max() - .unwrap_or(8) - .saturating_add(2); - let menu_w = content_width.saturating_add(2).min(screen.width.max(1)); - let menu_h = (labels.len() as u16 + 2).min(screen.height.max(1)); - let max_x = screen.x + screen.width.saturating_sub(menu_w); - let desired_x = launcher.x + launcher.width.saturating_sub(menu_w); - let x = desired_x.min(max_x); - let y = launcher.y.saturating_sub(menu_h); - Rect::new(x, y, menu_w, menu_h) - } - - fn global_menu_item_at(&self, col: u16, row: u16) -> Option<GlobalMenuAction> { - let rect = self.global_menu_rect(); - if col <= rect.x - || col >= rect.x + rect.width.saturating_sub(1) - || row <= rect.y - || row >= rect.y + rect.height.saturating_sub(1) - { - return None; - } - let idx = (row - rect.y - 1) as usize; - global_menu_actions(self).get(idx).copied() - } - - pub(crate) fn keybind_help_popup_rect(&self) -> Rect { - crate::ui::centered_popup_rect(self.screen_rect(), 76, 22).unwrap_or_default() - } - - fn keybind_help_modal_inner(&self) -> Option<Rect> { - self.onboarding_modal_inner(76, 22) - } - - fn keybind_help_close_button_at(&self, col: u16, row: u16) -> bool { - let Some(inner) = self.keybind_help_modal_inner() else { - return false; - }; - if inner.height < 4 || inner.width < 12 { - return false; - } - let button = - crate::ui::release_notes_close_button_rect(Rect::new(inner.x, inner.y, inner.width, 1)); - col >= button.x - && col < button.x + button.width - && row >= button.y - && row < button.y + button.height - } - - fn keybind_help_body_rect(&self) -> Option<Rect> { - let inner = self.keybind_help_modal_inner()?; - if inner.height < 6 || inner.width < 4 { - return None; - } - Some(crate::ui::modal_stack_areas(inner, 2, 1, 0, 1).content) - } - - fn keybind_help_scroll_metrics(&self) -> Option<crate::pane::ScrollMetrics> { - let body = self.keybind_help_body_rect()?; - let viewport_rows = body.height.max(1) as usize; - let wrap_width = body.width.max(1) as usize; - let total_rows = crate::ui::keybind_help_lines(self) - .into_iter() - .map(|(width, _)| width.max(1).div_ceil(wrap_width)) - .sum::<usize>(); - let max_offset_from_bottom = total_rows.saturating_sub(viewport_rows); - Some(crate::pane::ScrollMetrics { - offset_from_bottom: max_offset_from_bottom - .saturating_sub(self.keybind_help.scroll as usize), - max_offset_from_bottom, - viewport_rows, - }) - } - - fn keybind_help_scrollbar_target_at(&self, col: u16, row: u16) -> Option<ScrollbarClickTarget> { - let body = self.keybind_help_body_rect()?; - let metrics = self.keybind_help_scroll_metrics()?; - let track = crate::ui::release_notes_scrollbar_rect(body, metrics)?; - if !(col >= track.x - && col < track.x + track.width - && row >= track.y - && row < track.y + track.height) - { - return None; - } - if let Some(grab_row_offset) = crate::ui::scrollbar_thumb_grab_offset(metrics, track, row) { - Some(ScrollbarClickTarget::Thumb { grab_row_offset }) - } else { - Some(ScrollbarClickTarget::Track { - offset_from_bottom: crate::ui::scrollbar_offset_from_row(metrics, track, row), - }) - } - } - - fn keybind_help_offset_for_drag_row(&self, row: u16, grab_row_offset: u16) -> Option<usize> { - let body = self.keybind_help_body_rect()?; - let metrics = self.keybind_help_scroll_metrics()?; - let track = crate::ui::release_notes_scrollbar_rect(body, metrics)?; - Some(crate::ui::scrollbar_offset_from_drag_row( - metrics, - track, - row, - grab_row_offset, - )) - } - - pub(crate) fn keybind_help_max_scroll(&self) -> u16 { - self.keybind_help_scroll_metrics() - .map(|metrics| metrics.max_offset_from_bottom as u16) - .unwrap_or(0) - } - - fn set_keybind_help_offset_from_bottom(&mut self, offset_from_bottom: usize) { - let max_scroll = self.keybind_help_max_scroll() as usize; - self.keybind_help.scroll = max_scroll.saturating_sub(offset_from_bottom) as u16; - } - - fn scroll_keybind_help(&mut self, delta: i16) { - let max_scroll = self.keybind_help_max_scroll(); - let current = self.keybind_help.scroll as i16; - self.keybind_help.scroll = current.saturating_add(delta).clamp(0, max_scroll as i16) as u16; - } - - fn settings_popup_rect(&self) -> Rect { - crate::ui::centered_popup_rect(self.screen_rect(), 56, 20).unwrap_or_default() - } - - fn settings_inner_rect(&self) -> Rect { - let popup = self.settings_popup_rect(); - Rect::new( - popup.x + 1, - popup.y + 1, - popup.width.saturating_sub(2), - popup.height.saturating_sub(2), - ) - } - - fn settings_tab_at(&self, col: u16, row: u16) -> Option<crate::app::state::SettingsSection> { - use crate::app::state::SettingsSection; - - let inner = self.settings_inner_rect(); - let tab_y = inner.y + 1; - if row != tab_y { - return None; - } - let mut x = inner.x; - for section in SettingsSection::ALL { - let width = section.label().len() as u16 + 2; - if col >= x && col < x + width { - return Some(*section); - } - x += width + 1; - } - None - } - - fn settings_content_rect(&self) -> Rect { - let inner = self.settings_inner_rect(); - crate::ui::modal_stack_areas(inner, 3, 2, 0, 1).content - } - - fn settings_list_index_at(&self, col: u16, row: u16) -> Option<usize> { - let area = self.settings_content_rect(); - if row < area.y || row >= area.y + area.height || col < area.x || col >= area.x + area.width - { - return None; - } - - match self.settings.section { - crate::app::state::SettingsSection::Theme => { - let max_visible = area.height as usize; - let scroll = if self.settings.list.selected >= max_visible { - self.settings.list.selected - max_visible + 1 - } else { - 0 - }; - let idx = scroll + (row - area.y) as usize; - (idx < crate::app::state::THEME_NAMES.len()).then_some(idx) - } - crate::app::state::SettingsSection::Sound - | crate::app::state::SettingsSection::Toast => { - let list_y = area.y + 2; - if row >= list_y && row < list_y + 2 { - Some((row - list_y) as usize) - } else { - None - } - } - } - } - - fn handle_settings_mouse(&mut self, mouse: MouseEvent) -> Option<SettingsAction> { - use crate::app::state::SettingsSection; - - match mouse.kind { - MouseEventKind::Down(MouseButton::Left) => { - if let Some(section) = self.settings_tab_at(mouse.column, mouse.row) { - self.settings.section = section; - self.settings.list.select(match section { - SettingsSection::Theme => current_theme_index(&self.theme_name), - SettingsSection::Sound => usize::from(!self.sound_enabled()), - SettingsSection::Toast => usize::from(!self.toast_config.enabled), - }); - return None; - } - if let Some(idx) = self.settings_list_index_at(mouse.column, mouse.row) { - self.settings.list.select(idx); - return match self.settings.section { - SettingsSection::Theme => { - preview_selected_theme(self); - None - } - SettingsSection::Sound => { - let enabled = idx == 0; - self.sound.enabled = enabled; - Some(SettingsAction::SaveSound(enabled)) - } - SettingsSection::Toast => { - let enabled = idx == 0; - self.toast_config.enabled = enabled; - Some(SettingsAction::SaveToast(enabled)) - } - }; - } - - let inner = self.settings_inner_rect(); - let (apply, close) = crate::ui::settings_button_rects(inner); - match modal_action_from_buttons( - mouse.column, - mouse.row, - &[(apply, ModalAction::Apply), (close, ModalAction::Close)], - ) { - Some(ModalAction::Apply) => apply_settings(self), - Some(ModalAction::Close) => { - cancel_settings(self); - None - } - _ => { - cancel_settings(self); - None - } - } - } - _ => None, - } - } - - fn handle_mouse(&mut self, mouse: MouseEvent) -> Option<SettingsAction> { - if self.mode == Mode::Onboarding { - self.handle_onboarding_mouse(mouse); - return None; - } - - if self.mode == Mode::Settings { - return self.handle_settings_mouse(mouse); - } - - let launcher_enabled = !self.sidebar_collapsed - && matches!( - self.mode, - Mode::Terminal - | Mode::Navigate - | Mode::Resize - | Mode::GlobalMenu - | Mode::KeybindHelp - ); - let launcher = self.global_launcher_rect(); - let launcher_hit = launcher_enabled - && mouse.column >= launcher.x - && mouse.column < launcher.x + launcher.width - && mouse.row >= launcher.y - && mouse.row < launcher.y + launcher.height; - - if matches!(mouse.kind, MouseEventKind::Moved) && self.mode == Mode::GlobalMenu { - let actions = global_menu_actions(self); - let hovered = self - .global_menu_item_at(mouse.column, mouse.row) - .and_then(|action| actions.iter().position(|item| *item == action)); - self.global_menu.hover(hovered); - return None; - } - - if matches!(mouse.kind, MouseEventKind::Down(MouseButton::Left)) && launcher_hit { - if self.mode == Mode::GlobalMenu { - leave_modal(self); - } else { - open_global_menu(self); - } - return None; - } - - if self.mode == Mode::GlobalMenu { - if matches!(mouse.kind, MouseEventKind::Down(MouseButton::Left)) { - if let Some(action) = self.global_menu_item_at(mouse.column, mouse.row) { - apply_global_menu_action(self, action); - } else { - leave_modal(self); - } - } - return None; - } - - if self.mode == Mode::KeybindHelp { - return None; - } - - let sidebar = self.view.sidebar_rect; - let in_sidebar = mouse.column >= sidebar.x - && mouse.column < sidebar.x + sidebar.width - && mouse.row >= sidebar.y - && mouse.row < sidebar.y + sidebar.height; - - match mouse.kind { - MouseEventKind::Down(MouseButton::Left) => { - self.selection = None; - self.workspace_press = None; - - if self.mode == Mode::ConfirmClose { - let popup = self.confirm_close_rect(); - let inner = Rect::new( - popup.x + 1, - popup.y + 1, - popup.width.saturating_sub(2), - popup.height.saturating_sub(2), - ); - let (confirm, cancel) = crate::ui::confirm_close_button_rects(inner); - match modal_action_from_buttons( - mouse.column, - mouse.row, - &[ - (confirm, ModalAction::Confirm), - (cancel, ModalAction::Cancel), - ], - ) { - Some(ModalAction::Confirm) => confirm_close_accept(self), - Some(ModalAction::Cancel) | None => confirm_close_cancel(self), - _ => {} - } - return None; - } - - if matches!(self.mode, Mode::RenameWorkspace | Mode::RenameTab) { - let action = self - .rename_modal_inner() - .map(crate::ui::rename_button_rects) - .and_then(|(save, clear, cancel)| { - modal_action_from_buttons( - mouse.column, - mouse.row, - &[ - (save, ModalAction::Save), - (clear, ModalAction::Clear), - (cancel, ModalAction::Cancel), - ], - ) - }) - .unwrap_or(ModalAction::Cancel); - apply_rename_action(self, action); - return None; - } - - if self.mode == Mode::ContextMenu { - let item_idx = self.context_menu_item_at(mouse.column, mouse.row); - if let Some(menu) = self.context_menu.take() { - if let Some(idx) = item_idx { - apply_context_menu_action(self, menu, idx); - } else { - leave_modal(self); - } - } - return None; - } - - if self.on_sidebar_divider(mouse.column, mouse.row) { - self.drag = Some(DragState { - target: DragTarget::SidebarDivider, - }); - self.set_manual_sidebar_width(mouse.column); - return None; - } - - if self.on_sidebar_section_divider(mouse.column, mouse.row) { - self.drag = Some(DragState { - target: DragTarget::SidebarSectionDivider, - }); - self.set_sidebar_section_split(mouse.row); - return None; - } - - if !in_sidebar { - if let Some(border) = self.find_border_at(mouse.column, mouse.row) { - self.drag = Some(DragState { - target: DragTarget::PaneSplit { - path: border.path.clone(), - direction: border.direction, - area: border.area, - }, - }); - return None; - } - - if let Some((pane_id, target)) = - self.scrollbar_target_at(mouse.column, mouse.row) - { - self.focus_pane(pane_id); - match target { - ScrollbarClickTarget::Thumb { grab_row_offset } => { - self.drag = Some(DragState { - target: DragTarget::PaneScrollbar { - pane_id, - grab_row_offset, - }, - }); - } - ScrollbarClickTarget::Track { offset_from_bottom } => { - self.set_pane_scroll_offset(pane_id, offset_from_bottom); - } - } - if self.mode != Mode::Terminal { - self.mode = Mode::Terminal; - } - return None; - } - } - - if self.on_tab_scroll_left_button(mouse.column, mouse.row) { - self.scroll_tabs_left(); - return None; - } - if self.on_tab_scroll_right_button(mouse.column, mouse.row) { - self.scroll_tabs_right(); - return None; - } - if let (Some(ws_idx), Some(tab_idx)) = - (self.active, self.tab_at(mouse.column, mouse.row)) - { - self.tab_press = Some(TabPressState { - ws_idx, - tab_idx, - start_col: mouse.column, - start_row: mouse.row, - }); - return None; - } - if self.on_new_tab_button(mouse.column, mouse.row) { - open_new_tab_dialog(self); - return None; - } - - if in_sidebar { - if self.sidebar_collapsed { - if self.on_collapsed_sidebar_toggle(mouse.column, mouse.row) { - self.sidebar_collapsed = false; - return None; - } - - if let Some(idx) = self.collapsed_workspace_at_row(mouse.row) { - self.switch_workspace(idx); - self.mode = Mode::Terminal; - return None; - } - - if let Some((ws_idx, tab_idx, pane_id)) = - self.collapsed_agent_detail_target_at(mouse.row) - { - self.switch_workspace(ws_idx); - self.switch_tab(tab_idx); - self.focus_pane(pane_id); - self.mode = Mode::Terminal; - } - return None; - } - - let new_button = self.sidebar_new_button_rect(); - let on_new_button = mouse.row >= new_button.y - && mouse.row < new_button.y + new_button.height - && mouse.column >= new_button.x - && mouse.column < new_button.x + new_button.width; - if on_new_button { - self.request_new_workspace = true; - return None; - } - - if let Some(target) = - self.workspace_list_scrollbar_target_at(mouse.column, mouse.row) - { - match target { - ScrollbarClickTarget::Thumb { grab_row_offset } => { - self.drag = Some(DragState { - target: DragTarget::WorkspaceListScrollbar { grab_row_offset }, - }); - } - ScrollbarClickTarget::Track { offset_from_bottom } => { - self.set_workspace_list_offset_from_bottom(offset_from_bottom); - } - } - return None; - } - - if let Some(idx) = self.workspace_at_row(mouse.row) { - self.workspace_press = Some(WorkspacePressState { - ws_idx: idx, - start_col: mouse.column, - start_row: mouse.row, - }); - return None; - } - - if self.on_agent_panel_scope_toggle(mouse.column, mouse.row) { - self.agent_panel_scope = match self.agent_panel_scope { - AgentPanelScope::CurrentWorkspace => AgentPanelScope::AllWorkspaces, - AgentPanelScope::AllWorkspaces => AgentPanelScope::CurrentWorkspace, - }; - self.agent_panel_scroll = 0; - self.mark_session_dirty(); - return None; - } - - if let Some(target) = - self.agent_panel_scrollbar_target_at(mouse.column, mouse.row) - { - match target { - ScrollbarClickTarget::Thumb { grab_row_offset } => { - self.drag = Some(DragState { - target: DragTarget::AgentPanelScrollbar { grab_row_offset }, - }); - } - ScrollbarClickTarget::Track { offset_from_bottom } => { - self.set_agent_panel_offset_from_bottom(offset_from_bottom); - } - } - return None; - } - - if let Some((ws_idx, tab_idx, pane_id)) = self.agent_detail_target_at(mouse.row) - { - self.switch_workspace(ws_idx); - self.switch_tab(tab_idx); - self.focus_pane(pane_id); - self.mode = Mode::Terminal; - return None; - } - } else if let Some(info) = self.pane_at(mouse.column, mouse.row).cloned() { - self.focus_pane(info.id); - if self.mode != Mode::Terminal { - self.mode = Mode::Terminal; - } - - if self.forward_pane_mouse_button(&info, mouse) { - self.selection = None; - return None; - } - - let (row, col) = ( - mouse.row - info.inner_rect.y, - mouse.column - info.inner_rect.x, - ); - self.selection = Some(Selection::anchor( - info.id, - row, - col, - self.pane_scroll_metrics(info.id), - )); - } else if let Some(info) = self.view.pane_infos.iter().find(|p| { - mouse.column >= p.rect.x - && mouse.column < p.rect.x + p.rect.width - && mouse.row >= p.rect.y - && mouse.row < p.rect.y + p.rect.height - }) { - let id = info.id; - self.focus_pane(id); - if self.mode != Mode::Terminal { - self.mode = Mode::Terminal; - } - } - } - - MouseEventKind::Drag(MouseButton::Left) => { - if self.selection.is_some() { - self.update_selection_drag(mouse.column, mouse.row); - return None; - } - - if let Some(info) = self.pane_mouse_target(mouse.column, mouse.row).cloned() { - if self.forward_pane_mouse_button(&info, mouse) { - self.selection = None; - return None; - } - } - - let workspace_drop_index = self.workspace_drop_index_at_row(mouse.row); - let tab_drop_index = self.tab_drop_index_at(mouse.column, mouse.row); - if self.drag.is_none() { - if let Some(press) = &self.workspace_press { - let delta_col = mouse.column.abs_diff(press.start_col); - let delta_row = mouse.row.abs_diff(press.start_row); - if delta_col.max(delta_row) >= WORKSPACE_DRAG_THRESHOLD { - self.drag = Some(DragState { - target: DragTarget::WorkspaceReorder { - source_ws_idx: press.ws_idx, - insert_idx: workspace_drop_index, - }, - }); - } - } else if let Some(press) = &self.tab_press { - let delta_col = mouse.column.abs_diff(press.start_col); - let delta_row = mouse.row.abs_diff(press.start_row); - if delta_col.max(delta_row) >= TAB_DRAG_THRESHOLD { - self.drag = Some(DragState { - target: DragTarget::TabReorder { - ws_idx: press.ws_idx, - source_tab_idx: press.tab_idx, - insert_idx: tab_drop_index, - }, - }); - } - } - } - - if let Some(DragState { - target: DragTarget::WorkspaceReorder { insert_idx, .. }, - }) = &mut self.drag - { - *insert_idx = workspace_drop_index; - } else if let Some(DragState { - target: - DragTarget::TabReorder { - ws_idx, insert_idx, .. - }, - }) = &mut self.drag - { - if self.active == Some(*ws_idx) { - *insert_idx = tab_drop_index; - } - } else if let Some(drag) = &self.drag { - match &drag.target { - DragTarget::WorkspaceReorder { .. } | DragTarget::TabReorder { .. } => {} - DragTarget::WorkspaceListScrollbar { grab_row_offset } => { - if let Some(offset_from_bottom) = - self.workspace_list_offset_for_drag_row(mouse.row, *grab_row_offset) - { - self.set_workspace_list_offset_from_bottom(offset_from_bottom); - } - } - DragTarget::AgentPanelScrollbar { grab_row_offset } => { - if let Some(offset_from_bottom) = - self.agent_panel_offset_for_drag_row(mouse.row, *grab_row_offset) - { - self.set_agent_panel_offset_from_bottom(offset_from_bottom); - } - } - DragTarget::PaneSplit { - path, - direction, - area, - } => { - let ratio = match direction { - Direction::Horizontal => { - (mouse.column.saturating_sub(area.x)) as f32 - / area.width.max(1) as f32 - } - Direction::Vertical => { - (mouse.row.saturating_sub(area.y)) as f32 - / area.height.max(1) as f32 - } - }; - let ratio = ratio.clamp(0.1, 0.9); - let path = path.clone(); - if let Some(ws) = self.active.and_then(|i| self.workspaces.get_mut(i)) { - ws.layout.set_ratio_at(&path, ratio); - self.mark_session_dirty(); - } - } - DragTarget::PaneScrollbar { - pane_id, - grab_row_offset, - } => { - if let Some(offset_from_bottom) = self.scrollbar_offset_for_pane_row( - *pane_id, - mouse.row, - *grab_row_offset, - ) { - self.set_pane_scroll_offset(*pane_id, offset_from_bottom); - } - } - DragTarget::SidebarDivider => { - self.set_manual_sidebar_width(mouse.column); - } - DragTarget::SidebarSectionDivider => { - self.set_sidebar_section_split(mouse.row); - } - DragTarget::ReleaseNotesScrollbar { .. } - | DragTarget::KeybindHelpScrollbar { .. } => {} - } - } - } - - MouseEventKind::Up(MouseButton::Left) => { - if self.selection.is_some() { - self.workspace_press = None; - self.tab_press = None; - self.drag = None; - let was_click = self.selection.as_ref().is_some_and(|s| s.was_just_click()); - if was_click { - self.selection = None; - } else { - self.copy_selection(); - } - return None; - } - - if let Some(info) = self.pane_mouse_target(mouse.column, mouse.row).cloned() { - if self.forward_pane_mouse_button(&info, mouse) { - self.selection = None; - self.workspace_press = None; - self.tab_press = None; - self.drag = None; - return None; - } - } - - let workspace_press = self.workspace_press.take(); - let tab_press = self.tab_press.take(); - match self.drag.take() { - Some(DragState { - target: - DragTarget::WorkspaceReorder { - source_ws_idx, - insert_idx: Some(insert_idx), - }, - }) => { - self.move_workspace(source_ws_idx, insert_idx); - } - Some(DragState { - target: - DragTarget::TabReorder { - ws_idx, - source_tab_idx, - insert_idx: Some(insert_idx), - }, - }) => { - if self.active == Some(ws_idx) { - self.move_tab(source_tab_idx, insert_idx); - self.mode = Mode::Terminal; - } - } - Some(_) => {} - None => { - if let Some(press) = workspace_press { - self.switch_workspace(press.ws_idx); - self.mode = Mode::Terminal; - return None; - } - if let Some(press) = tab_press { - if self.active == Some(press.ws_idx) { - self.switch_tab(press.tab_idx); - self.mode = Mode::Terminal; - return None; - } - } - let was_click = self.selection.as_ref().is_some_and(|s| s.was_just_click()); - if was_click { - self.selection = None; - } else { - self.copy_selection(); - } - } - } - } - - MouseEventKind::Up(MouseButton::Middle) | MouseEventKind::Drag(MouseButton::Middle) - if !in_sidebar => - { - if let Some(info) = self.pane_mouse_target(mouse.column, mouse.row).cloned() { - let _ = self.forward_pane_mouse_button(&info, mouse); - } - } - - MouseEventKind::ScrollUp | MouseEventKind::ScrollDown if !in_sidebar => { - if self.on_tab_bar(mouse.column, mouse.row) { - match mouse.kind { - MouseEventKind::ScrollUp => self.scroll_tabs_left(), - MouseEventKind::ScrollDown => self.scroll_tabs_right(), - _ => {} - } - } else if !self.scroll_selection_with_wheel(mouse) { - self.selection = None; - self.handle_terminal_wheel(mouse); - } - } - - MouseEventKind::ScrollUp if in_sidebar => { - let agent_area = self.agent_panel_rect(); - let over_agent_panel = agent_area != Rect::default() - && mouse.row >= agent_area.y - && mouse.row < agent_area.y + agent_area.height; - if over_agent_panel { - if crate::ui::should_show_scrollbar(crate::ui::agent_panel_scroll_metrics( - self, agent_area, - )) { - self.scroll_agent_panel(-1); - } - } else if crate::ui::should_show_scrollbar( - crate::ui::workspace_list_scroll_metrics(self, self.workspace_list_rect()), - ) { - self.scroll_workspace_list(-1); - } else if self.selected > 0 { - self.selected -= 1; - self.ensure_workspace_visible(self.selected); - } - } - MouseEventKind::ScrollDown if in_sidebar => { - let agent_area = self.agent_panel_rect(); - let over_agent_panel = agent_area != Rect::default() - && mouse.row >= agent_area.y - && mouse.row < agent_area.y + agent_area.height; - if over_agent_panel { - if crate::ui::should_show_scrollbar(crate::ui::agent_panel_scroll_metrics( - self, agent_area, - )) { - self.scroll_agent_panel(1); - } - } else if crate::ui::should_show_scrollbar( - crate::ui::workspace_list_scroll_metrics(self, self.workspace_list_rect()), - ) { - self.scroll_workspace_list(1); - } else if !self.workspaces.is_empty() && self.selected < self.workspaces.len() - 1 { - self.selected += 1; - self.ensure_workspace_visible(self.selected); - } - } - - MouseEventKind::Moved if self.mode == Mode::ContextMenu => { - let hovered = self.context_menu_item_at(mouse.column, mouse.row); - if let Some(menu) = &mut self.context_menu { - menu.list.hover(hovered); - } - } - - MouseEventKind::Down(MouseButton::Right) if in_sidebar && !self.sidebar_collapsed => { - if self - .workspace_list_scrollbar_target_at(mouse.column, mouse.row) - .is_some() - { - return None; - } - if let Some(idx) = self.workspace_at_row(mouse.row) { - self.selected = idx; - self.context_menu = Some(ContextMenuState { - kind: ContextMenuKind::Workspace { ws_idx: idx }, - x: mouse.column, - y: mouse.row, - list: MenuListState::new(0), - }); - self.mode = Mode::ContextMenu; - } - } - - MouseEventKind::Down(MouseButton::Right) - if self.tab_at(mouse.column, mouse.row).is_some() => - { - if let (Some(ws_idx), Some(tab_idx)) = - (self.active, self.tab_at(mouse.column, mouse.row)) - { - self.switch_tab(tab_idx); - self.context_menu = Some(ContextMenuState { - kind: ContextMenuKind::Tab { ws_idx, tab_idx }, - x: mouse.column, - y: mouse.row, - list: MenuListState::new(0), - }); - self.mode = Mode::ContextMenu; - } - } - - MouseEventKind::Down(MouseButton::Right) if !in_sidebar => { - if let Some(info) = self.pane_mouse_target(mouse.column, mouse.row).cloned() { - self.focus_pane(info.id); - self.context_menu = Some(ContextMenuState { - kind: ContextMenuKind::Pane, - x: mouse.column, - y: mouse.row, - list: MenuListState::new(0), - }); - self.mode = Mode::ContextMenu; - } - } - - _ => {} - } - - None - } - - fn on_sidebar_divider(&self, col: u16, row: u16) -> bool { - if self.sidebar_collapsed { - return false; - } - let sidebar = self.view.sidebar_rect; - sidebar.width > 0 - && col == sidebar.x + sidebar.width.saturating_sub(1) - && row >= sidebar.y - && row < sidebar.y + sidebar.height - } - - fn on_collapsed_sidebar_toggle(&self, col: u16, row: u16) -> bool { - if !self.sidebar_collapsed { - return false; - } - let rect = crate::ui::collapsed_sidebar_toggle_rect(self.view.sidebar_rect); - rect.width > 0 - && col >= rect.x - && col < rect.x + rect.width - && row >= rect.y - && row < rect.y + rect.height - } - - fn set_manual_sidebar_width(&mut self, divider_col: u16) { - let sidebar = self.view.sidebar_rect; - let width = divider_col.saturating_sub(sidebar.x).saturating_add(1); - self.sidebar_width = - width.clamp(crate::ui::MIN_SIDEBAR_WIDTH, crate::ui::MAX_SIDEBAR_WIDTH); - self.mark_session_dirty(); - } - - fn on_sidebar_section_divider(&self, col: u16, row: u16) -> bool { - if self.sidebar_collapsed { - return false; - } - let rect = crate::ui::sidebar_section_divider_rect( - self.view.sidebar_rect, - self.sidebar_section_split, - ); - rect.width > 0 - && col >= rect.x - && col < rect.x + rect.width - && row >= rect.y - && row < rect.y + rect.height - } - - fn set_sidebar_section_split(&mut self, row: u16) { - let sidebar = self.view.sidebar_rect; - let content_height = sidebar.height; - if content_height < 6 { - return; - } - let relative_y = row.saturating_sub(sidebar.y); - let ratio = (relative_y as f32) / (content_height as f32); - self.sidebar_section_split = ratio.clamp(0.1, 0.9); - self.mark_session_dirty(); - } - - /// Find which workspace index a sidebar row belongs to (two-section layout). - fn tab_at(&self, col: u16, row: u16) -> Option<usize> { - self.view - .tab_hit_areas - .iter() - .enumerate() - .find_map(|(idx, area)| { - (area.width > 0 - && row >= area.y - && row < area.y + area.height - && col >= area.x - && col < area.x + area.width) - .then_some(idx) - }) - } - - fn on_tab_bar(&self, col: u16, row: u16) -> bool { - let area = self.view.tab_bar_rect; - area.width > 0 - && row >= area.y - && row < area.y + area.height - && col >= area.x - && col < area.x + area.width - } - - fn on_tab_scroll_left_button(&self, col: u16, row: u16) -> bool { - let area = self.view.tab_scroll_left_hit_area; - area.width > 0 - && row >= area.y - && row < area.y + area.height - && col >= area.x - && col < area.x + area.width - } - - fn on_tab_scroll_right_button(&self, col: u16, row: u16) -> bool { - let area = self.view.tab_scroll_right_hit_area; - area.width > 0 - && row >= area.y - && row < area.y + area.height - && col >= area.x - && col < area.x + area.width - } - - fn tab_drop_index_at(&self, col: u16, row: u16) -> Option<usize> { - if !self.on_tab_bar(col, row) { - return None; - } - - let visible_tabs: Vec<_> = self - .view - .tab_hit_areas - .iter() - .enumerate() - .filter(|(_, rect)| rect.width > 0) - .collect(); - let (first_idx, first_rect) = *visible_tabs.first()?; - let (last_idx, last_rect) = *visible_tabs.last()?; - - if self.on_tab_scroll_left_button(col, row) { - return Some(0); - } - if self.on_tab_scroll_right_button(col, row) { - return self - .active - .and_then(|idx| self.workspaces.get(idx)) - .map(|ws| ws.tabs.len()); - } - - let left_edge = if first_idx == 0 { - first_rect.x - } else { - self.view.tab_scroll_left_hit_area.x + self.view.tab_scroll_left_hit_area.width - }; - let right_edge = if self - .active - .and_then(|idx| self.workspaces.get(idx)) - .is_some_and(|ws| last_idx + 1 >= ws.tabs.len()) - { - last_rect.x + last_rect.width - } else { - self.view.tab_scroll_right_hit_area.x.saturating_sub(1) - }; - - if col <= left_edge { - return Some(first_idx); - } - if col >= right_edge { - return Some(last_idx + 1); - } - - for (idx, rect) in visible_tabs { - let midpoint = rect.x + rect.width / 2; - if col < midpoint { - return Some(idx); - } - if col < rect.x + rect.width { - return Some(idx + 1); - } - } - - Some(last_idx + 1) - } - - fn on_new_tab_button(&self, col: u16, row: u16) -> bool { - let area = self.view.new_tab_hit_area; - area.width > 0 - && row >= area.y - && row < area.y + area.height - && col >= area.x - && col < area.x + area.width - } - - fn workspace_at_row(&self, row: u16) -> Option<usize> { - let footer = self.sidebar_footer_rect(); - if footer == Rect::default() { - return None; - } - - let cards = if self.view.workspace_card_areas.is_empty() { - crate::ui::compute_workspace_card_areas(self, self.view.sidebar_rect) - } else { - self.view.workspace_card_areas.clone() - }; - - cards.iter().find_map(|card| { - (row >= card.rect.y && row < card.rect.y + card.rect.height).then_some(card.ws_idx) - }) - } - - fn collapsed_workspace_at_row(&self, row: u16) -> Option<usize> { - if !self.sidebar_collapsed { - return None; - } - - let (ws_area, _, _) = crate::ui::collapsed_sidebar_sections(self.view.sidebar_rect); - if ws_area == Rect::default() || row < ws_area.y || row >= ws_area.y + ws_area.height { - return None; - } - - let idx = (row - ws_area.y) as usize; - (idx < self.workspaces.len()).then_some(idx) - } - - fn collapsed_detail_workspace_idx(&self) -> Option<usize> { - if matches!( - self.mode, - Mode::Navigate - | Mode::RenameWorkspace - | Mode::Resize - | Mode::ConfirmClose - | Mode::ContextMenu - | Mode::Settings - | Mode::GlobalMenu - | Mode::KeybindHelp - ) { - Some(self.selected) - } else { - self.active - } - } - - fn collapsed_agent_detail_target_at( - &self, - row: u16, - ) -> Option<(usize, usize, crate::layout::PaneId)> { - if !self.sidebar_collapsed { - return None; - } - - let (_, _, detail_area) = crate::ui::collapsed_sidebar_sections(self.view.sidebar_rect); - let detail_content_area = Rect::new( - detail_area.x, - detail_area.y, - detail_area.width, - detail_area.height.saturating_sub(1), - ); - if detail_content_area == Rect::default() - || row < detail_content_area.y - || row >= detail_content_area.y + detail_content_area.height - { - return None; - } - - let ws_idx = self.collapsed_detail_workspace_idx()?; - let ws = self.workspaces.get(ws_idx)?; - let detail_idx = (row - detail_content_area.y) as usize; - let details = ws.pane_details(); - let detail = details.get(detail_idx)?; - Some((ws_idx, detail.tab_idx, detail.pane_id)) - } - - fn workspace_drop_index_at_row(&self, row: u16) -> Option<usize> { - let area = self.workspace_list_rect(); - let footer = self.sidebar_footer_rect(); - if area == Rect::default() || row < area.y || row >= footer.y { - return None; - } - - let cards = if self.view.workspace_card_areas.is_empty() { - crate::ui::compute_workspace_card_areas(self, self.view.sidebar_rect) - } else { - self.view.workspace_card_areas.clone() - }; - if cards.is_empty() { - return Some(0); - } - - let mut insert_indices = Vec::with_capacity(cards.len() + 1); - insert_indices.push(cards[0].ws_idx); - insert_indices.extend(cards.iter().skip(1).map(|card| card.ws_idx)); - insert_indices.push(cards.last().map(|card| card.ws_idx + 1).unwrap_or(0)); - - let mut best: Option<(usize, u16)> = None; - for insert_idx in insert_indices { - let Some(slot_row) = crate::ui::workspace_drop_indicator_row(&cards, area, insert_idx) - else { - continue; - }; - let distance = row.abs_diff(slot_row); - match best { - Some((best_idx, best_distance)) - if distance > best_distance - || (distance == best_distance && insert_idx < best_idx) => {} - _ => best = Some((insert_idx, distance)), - } - } - - best.map(|(insert_idx, _)| insert_idx) - } - - fn on_agent_panel_scope_toggle(&self, col: u16, row: u16) -> bool { - if self.sidebar_collapsed { - return false; - } - - let (_, detail_area) = crate::ui::expanded_sidebar_sections( - self.view.sidebar_rect, - self.sidebar_section_split, - ); - let rect = crate::ui::agent_panel_toggle_rect(detail_area, self.agent_panel_scope); - rect.width > 0 - && col >= rect.x - && col < rect.x + rect.width - && row >= rect.y - && row < rect.y + rect.height - } - - fn agent_detail_target_at(&self, row: u16) -> Option<(usize, usize, crate::layout::PaneId)> { - if self.sidebar_collapsed { - return None; - } - - let detail_area = self.agent_panel_rect(); - let metrics = crate::ui::agent_panel_scroll_metrics(self, detail_area); - let body = crate::ui::agent_panel_body_rect( - detail_area, - crate::ui::should_show_scrollbar(metrics), - ); - if body.height < 2 || row < body.y || row >= body.y + body.height { - return None; - } - - let mut row_y = body.y; - for detail in crate::ui::agent_panel_entries(self) - .into_iter() - .skip(self.agent_panel_scroll) - { - if row_y.saturating_add(1) >= body.y + body.height { - break; - } - if row == row_y || row == row_y + 1 { - return Some((detail.ws_idx, detail.tab_idx, detail.pane_id)); - } - row_y = row_y.saturating_add(2); - if row_y < body.y + body.height { - row_y = row_y.saturating_add(1); - } - } - None - } - - fn screen_rect(&self) -> Rect { - let sidebar = self.view.sidebar_rect; - let terminal = self.view.terminal_area; - let x = sidebar.x.min(terminal.x); - let y = sidebar.y.min(terminal.y); - let right = (sidebar.x + sidebar.width).max(terminal.x + terminal.width); - let bottom = (sidebar.y + sidebar.height).max(terminal.y + terminal.height); - Rect::new(x, y, right.saturating_sub(x), bottom.saturating_sub(y)) - } - - pub(crate) fn context_menu_rect(&self) -> Option<Rect> { - let menu = self.context_menu.as_ref()?; - let screen = self.screen_rect(); - let max_item_w = menu - .items() - .iter() - .map(|item| item.len() as u16) - .max() - .unwrap_or(0); - let menu_w = (max_item_w + 4).max(14).min(screen.width.max(1)); - let menu_h = (menu.items().len() as u16 + 2).min(screen.height.max(1)); - let x = menu.x.min(screen.x + screen.width.saturating_sub(menu_w)); - let y = menu.y.min(screen.y + screen.height.saturating_sub(menu_h)); - Some(Rect::new(x, y, menu_w, menu_h)) - } - - pub(crate) fn confirm_close_rect(&self) -> Rect { - crate::ui::confirm_close_popup_rect(self.view.terminal_area).unwrap_or_default() - } - - fn context_menu_item_at(&self, col: u16, row: u16) -> Option<usize> { - let menu_rect = self.context_menu_rect()?; - let inner_x = menu_rect.x + 1; - let inner_y = menu_rect.y + 1; - let inner_w = menu_rect.width.saturating_sub(2); - let inner_h = menu_rect.height.saturating_sub(2); - let item_count = self - .context_menu - .as_ref() - .map(|menu| menu.items().len() as u16) - .unwrap_or(0); - if col >= inner_x - && col < inner_x + inner_w - && row >= inner_y - && row < inner_y + inner_h.min(item_count) - { - Some((row - inner_y) as usize) - } else { - None - } - } - - fn find_border_at(&self, col: u16, row: u16) -> Option<&SplitBorder> { - self.view.split_borders.iter().find(|b| match b.direction { - Direction::Horizontal => { - (col as i32 - b.pos as i32).unsigned_abs() <= 1 - && row >= b.area.y - && row < b.area.y + b.area.height - } - Direction::Vertical => { - (row as i32 - b.pos as i32).unsigned_abs() <= 1 - && col >= b.area.x - && col < b.area.x + b.area.width - } - }) - } - - fn pane_at(&self, col: u16, row: u16) -> Option<&PaneInfo> { - self.view.pane_infos.iter().find(|p| { - col >= p.inner_rect.x - && col < p.inner_rect.x + p.inner_rect.width - && row >= p.inner_rect.y - && row < p.inner_rect.y + p.inner_rect.height - }) - } - - fn pane_mouse_target(&self, col: u16, row: u16) -> Option<&PaneInfo> { - self.pane_at(col, row) - .or_else(|| self.pane_frame_at(col, row)) - } - - fn pane_info_by_id(&self, pane_id: crate::layout::PaneId) -> Option<&PaneInfo> { - self.view.pane_infos.iter().find(|info| info.id == pane_id) - } - - fn pane_frame_at(&self, col: u16, row: u16) -> Option<&PaneInfo> { - self.view.pane_infos.iter().find(|p| { - col >= p.rect.x - && col < p.rect.x + p.rect.width - && row >= p.rect.y - && row < p.rect.y + p.rect.height - }) - } - - fn focus_pane(&mut self, pane_id: crate::layout::PaneId) { - if let Some(ws) = self.active.and_then(|i| self.workspaces.get_mut(i)) { - if ws.layout.focused() != pane_id { - ws.layout.focus_pane(pane_id); - self.mark_session_dirty(); - } - } - } - - fn scroll_pane_up(&self, pane_id: crate::layout::PaneId, lines: usize) { - if let Some(ws) = self.active.and_then(|i| self.workspaces.get(i)) { - if let Some(rt) = ws.runtimes.get(&pane_id) { - rt.scroll_up(lines); - } - } - } - - fn scroll_pane_down(&self, pane_id: crate::layout::PaneId, lines: usize) { - if let Some(ws) = self.active.and_then(|i| self.workspaces.get(i)) { - if let Some(rt) = ws.runtimes.get(&pane_id) { - rt.scroll_down(lines); - } - } - } - - fn pane_scroll_metrics( - &self, - pane_id: crate::layout::PaneId, - ) -> Option<crate::pane::ScrollMetrics> { - self.active - .and_then(|i| self.workspaces.get(i)) - .and_then(|ws| ws.runtime(pane_id)) - .and_then(crate::pane::PaneRuntime::scroll_metrics) - } - - fn update_selection_cursor( - &mut self, - pane_id: crate::layout::PaneId, - screen_col: u16, - screen_row: u16, - ) { - let Some(info) = self.pane_info_by_id(pane_id).cloned() else { - return; - }; - let metrics = self.pane_scroll_metrics(pane_id); - if let Some(selection) = self.selection.as_mut() { - selection.drag(screen_col, screen_row, info.inner_rect, metrics); - } - } - - fn selection_edge_scroll_lines(distance: u16) -> usize { - usize::from(distance).saturating_mul(3).clamp(3, 15) - } - - fn update_selection_drag(&mut self, screen_col: u16, screen_row: u16) { - let Some(pane_id) = self.selection.as_ref().map(|selection| selection.pane_id) else { - return; - }; - let Some(info) = self.pane_info_by_id(pane_id).cloned() else { - return; - }; - - let bottom = info.inner_rect.y + info.inner_rect.height.saturating_sub(1); - if screen_row < info.inner_rect.y { - self.scroll_pane_up( - pane_id, - Self::selection_edge_scroll_lines(info.inner_rect.y - screen_row), - ); - } else if screen_row > bottom { - self.scroll_pane_down( - pane_id, - Self::selection_edge_scroll_lines(screen_row - bottom), - ); - } - - self.update_selection_cursor(pane_id, screen_col, screen_row); - } - - fn scroll_selection_with_wheel(&mut self, mouse: MouseEvent) -> bool { - const LINES_PER_NOTCH: usize = 3; - - let Some(selection) = self.selection.as_ref() else { - return false; - }; - if !selection.is_in_progress() { - return false; - } - let pane_id = selection.pane_id; - self.focus_pane(pane_id); - match mouse.kind { - MouseEventKind::ScrollUp => self.scroll_pane_up(pane_id, LINES_PER_NOTCH), - MouseEventKind::ScrollDown => self.scroll_pane_down(pane_id, LINES_PER_NOTCH), - _ => return false, - } - self.update_selection_cursor(pane_id, mouse.column, mouse.row); - true - } - - fn handle_terminal_wheel(&mut self, mouse: MouseEvent) { - const LINES_PER_NOTCH: usize = 3; - - if let Some(info) = self.pane_at(mouse.column, mouse.row).cloned() { - self.focus_pane(info.id); - if self.forward_pane_wheel(&info, mouse) { - return; - } - match mouse.kind { - MouseEventKind::ScrollUp => self.scroll_pane_up(info.id, LINES_PER_NOTCH), - MouseEventKind::ScrollDown => self.scroll_pane_down(info.id, LINES_PER_NOTCH), - _ => {} - } - return; - } - - if let Some(info) = self.pane_frame_at(mouse.column, mouse.row).cloned() { - self.focus_pane(info.id); - match mouse.kind { - MouseEventKind::ScrollUp => self.scroll_pane_up(info.id, LINES_PER_NOTCH), - MouseEventKind::ScrollDown => self.scroll_pane_down(info.id, LINES_PER_NOTCH), - _ => {} - } - return; - } - - if let Some(ws) = self.active.and_then(|i| self.workspaces.get(i)) { - if let Some(rt) = ws.focused_runtime() { - match mouse.kind { - MouseEventKind::ScrollUp => rt.scroll_up(LINES_PER_NOTCH), - MouseEventKind::ScrollDown => rt.scroll_down(LINES_PER_NOTCH), - _ => {} - } - } - } - } - - fn forward_pane_mouse_button(&self, info: &PaneInfo, mouse: MouseEvent) -> bool { - let Some(ws) = self.active.and_then(|i| self.workspaces.get(i)) else { - return false; - }; - let Some(rt) = ws.runtimes.get(&info.id) else { - return false; - }; - let column = mouse.column.saturating_sub(info.inner_rect.x); - let row = mouse.row.saturating_sub(info.inner_rect.y); - let Some(bytes) = rt.encode_mouse_button(mouse.kind, column, row, mouse.modifiers) else { - return false; - }; - rt.scroll_reset(); - if let Err(err) = rt.try_send_bytes(Bytes::from(bytes)) { - warn!(pane = info.id.raw(), err = %err, kind = ?mouse.kind, "failed to forward mouse button event"); - } - true - } - - fn forward_pane_wheel(&self, info: &PaneInfo, mouse: MouseEvent) -> bool { - let Some(ws) = self.active.and_then(|i| self.workspaces.get(i)) else { - return false; - }; - let Some(rt) = ws.runtimes.get(&info.id) else { - return false; - }; - match rt.wheel_routing() { - Some(crate::pane::WheelRouting::HostScroll) | None => false, - Some(crate::pane::WheelRouting::MouseReport) => { - rt.scroll_reset(); - let column = mouse.column.saturating_sub(info.inner_rect.x); - let row = mouse.row.saturating_sub(info.inner_rect.y); - let Some(bytes) = rt.encode_mouse_wheel(mouse.kind, column, row, mouse.modifiers) - else { - warn!(pane = info.id.raw(), kind = ?mouse.kind, "failed to encode mouse wheel event"); - return true; - }; - if let Err(err) = rt.try_send_bytes(Bytes::from(bytes)) { - warn!(pane = info.id.raw(), err = %err, "failed to forward mouse wheel event"); - } - true - } - Some(crate::pane::WheelRouting::AlternateScroll) => { - rt.scroll_reset(); - let Some(bytes) = rt.encode_alternate_scroll(mouse.kind) else { - return true; - }; - if let Err(err) = rt.try_send_bytes(Bytes::from(bytes)) { - warn!(pane = info.id.raw(), err = %err, "failed to forward alternate-scroll key"); - } - true - } - } - } - - fn set_pane_scroll_offset(&self, pane_id: crate::layout::PaneId, offset_from_bottom: usize) { - if let Some(ws) = self.active.and_then(|i| self.workspaces.get(i)) { - if let Some(rt) = ws.runtimes.get(&pane_id) { - rt.set_scroll_offset_from_bottom(offset_from_bottom); - } - } - } - - fn scrollbar_target_at( - &self, - col: u16, - row: u16, - ) -> Option<(crate::layout::PaneId, ScrollbarClickTarget)> { - let ws = self.active.and_then(|i| self.workspaces.get(i))?; - let info = self.view.pane_infos.iter().find(|info| { - crate::ui::pane_scrollbar_rect(info).is_some_and(|track| { - col >= track.x - && col < track.x + track.width - && row >= track.y - && row < track.y + track.height - }) - })?; - let rt = ws.runtimes.get(&info.id)?; - let metrics = rt.scroll_metrics()?; - if metrics.max_offset_from_bottom == 0 { - return None; - } - let track = crate::ui::pane_scrollbar_rect(info)?; - if let Some(grab_row_offset) = crate::ui::scrollbar_thumb_grab_offset(metrics, track, row) { - Some((info.id, ScrollbarClickTarget::Thumb { grab_row_offset })) - } else { - Some(( - info.id, - ScrollbarClickTarget::Track { - offset_from_bottom: crate::ui::scrollbar_offset_from_row(metrics, track, row), - }, - )) - } - } - - fn scrollbar_offset_for_pane_row( - &self, - pane_id: crate::layout::PaneId, - row: u16, - grab_row_offset: u16, - ) -> Option<usize> { - let ws = self.active.and_then(|i| self.workspaces.get(i))?; - let info = self - .view - .pane_infos - .iter() - .find(|info| info.id == pane_id)?; - let track = crate::ui::pane_scrollbar_rect(info)?; - let rt = ws.runtimes.get(&pane_id)?; - let metrics = rt.scroll_metrics()?; - if metrics.max_offset_from_bottom == 0 { - return None; - } - Some(crate::ui::scrollbar_offset_from_drag_row( - metrics, - track, - row, - grab_row_offset, - )) - } -} - -#[cfg(test)] -fn wheel_routing(input_state: crate::pane::InputState) -> WheelRouting { - if input_state.mouse_protocol_mode.reporting_enabled() { - WheelRouting::MouseReport - } else if input_state.alternate_screen && input_state.mouse_alternate_scroll { - WheelRouting::AlternateScroll - } else { - WheelRouting::HostScroll - } -} - -// Note: split_pane needs runtime (event_tx for PTY spawn), so it lives on App -impl AppState { - pub(crate) fn split_pane(&mut self, direction: Direction) { - // Actual PTY spawning happens in Workspace::split_focused - // which needs events channel — this is called from navigate_key - // where we don't have async context, so the workspace handles it - let (rows, cols) = self.estimate_pane_size(); - let new_rows = (rows / 2).max(4); - let new_cols = (cols / 2).max(10); - - let cwd = self - .active - .and_then(|i| self.workspaces.get(i)) - .and_then(|ws| ws.focused_runtime()) - .and_then(|rt| rt.cwd()); - - if let Some(ws) = self.active.and_then(|i| self.workspaces.get_mut(i)) { - if let Ok(new_id) = ws.split_focused( - direction, - new_rows, - new_cols, - cwd, - self.pane_scrollback_limit_bytes, - self.host_terminal_theme, - ) { - ws.layout.focus_pane(new_id); - self.mark_session_dirty(); - self.mode = Mode::Terminal; - } - } - } -} - -#[cfg(test)] -mod tests { - use super::*; - use std::{ - fs, - path::Path, - time::{Duration, SystemTime, UNIX_EPOCH}, - }; - - use crate::{config::Config, detect::Agent, workspace::Workspace}; - use crossterm::event::{KeyModifiers, MouseEvent}; - use ratatui::layout::Rect; - - fn state_with_workspaces(names: &[&str]) -> AppState { - let mut state = AppState::test_new(); - state.workspaces = names.iter().map(|name| Workspace::test_new(name)).collect(); - if !state.workspaces.is_empty() { - state.active = Some(0); - state.selected = 0; - state.mode = Mode::Navigate; - } - state - } - - fn app_for_mouse_test() -> App { - let (_api_tx, api_rx) = tokio::sync::mpsc::unbounded_channel(); - let mut app = App::new( - &Config::default(), - true, - None, - None, - api_rx, - crate::api::EventHub::default(), - ); - app.state.mode = Mode::Terminal; - app.state.update_available = None; - app.state.latest_release_notes_available = false; - app.state.view.sidebar_rect = Rect::new(0, 0, 26, 20); - app.state.view.terminal_area = Rect::new(26, 0, 80, 20); - app - } - - fn mouse(kind: MouseEventKind, col: u16, row: u16) -> MouseEvent { - MouseEvent { - kind, - column: col, - row, - modifiers: KeyModifiers::empty(), - } - } - - fn numbered_lines_bytes(count: usize) -> Vec<u8> { - (0..count) - .map(|i| format!("{i:06}\r\n")) - .collect::<String>() - .into_bytes() - } - - fn capture_snapshot(state: &AppState) -> crate::persist::SessionSnapshot { - crate::persist::capture( - &state.workspaces, - state.active, - state.selected, - state.agent_panel_scope, - state.sidebar_width, - state.sidebar_section_split, - ) - } - - fn unique_temp_path(name: &str) -> std::path::PathBuf { - let nanos = SystemTime::now() - .duration_since(UNIX_EPOCH) - .map(|d| d.as_nanos()) - .unwrap_or(0); - std::env::temp_dir().join(format!("herdr-{name}-{}-{nanos}", std::process::id())) - } - - fn wait_for_file(path: &Path) -> String { - let deadline = std::time::Instant::now() + Duration::from_secs(2); - while std::time::Instant::now() < deadline { - if let Ok(content) = fs::read_to_string(path) { - return content; - } - std::thread::sleep(Duration::from_millis(20)); - } - panic!("timed out waiting for {}", path.display()); - } - - fn root_layout_ratio(snapshot: &crate::persist::SessionSnapshot) -> Option<f32> { - match &snapshot.workspaces.first()?.tabs.first()?.layout { - crate::persist::LayoutSnapshot::Split { ratio, .. } => Some(*ratio), - crate::persist::LayoutSnapshot::Pane(_) => None, - } - } - - #[test] - fn custom_rename_key_enters_rename_mode() { - let mut state = state_with_workspaces(&["test"]); - state.keybinds.rename_workspace = (KeyCode::Char('g'), KeyModifiers::empty()); - state.keybinds.rename_workspace_label = "g".into(); - - handle_navigate_key( - &mut state, - KeyEvent::new(KeyCode::Char('g'), KeyModifiers::empty()), - ); - - assert_eq!(state.mode, Mode::RenameWorkspace); - assert_eq!(state.name_input, "test"); - } - - #[test] - fn custom_new_workspace_key_requests_and_exits_navigate() { - let mut state = state_with_workspaces(&["test"]); - state.keybinds.new_workspace = (KeyCode::Char('g'), KeyModifiers::empty()); - state.keybinds.new_workspace_label = "g".into(); - - handle_navigate_key( - &mut state, - KeyEvent::new(KeyCode::Char('g'), KeyModifiers::empty()), - ); - - assert!(state.request_new_workspace); - assert_eq!(state.mode, Mode::Terminal); - } - - #[test] - fn custom_sidebar_toggle_key_toggles_and_exits_navigate() { - let mut state = state_with_workspaces(&["test"]); - state.keybinds.toggle_sidebar = (KeyCode::Char('g'), KeyModifiers::empty()); - state.keybinds.toggle_sidebar_label = "g".into(); - assert!(!state.sidebar_collapsed); - - handle_navigate_key( - &mut state, - KeyEvent::new(KeyCode::Char('g'), KeyModifiers::empty()), - ); - - assert!(state.sidebar_collapsed); - assert_eq!(state.mode, Mode::Terminal); - } - - #[test] - fn custom_resize_key_enters_resize_mode() { - let mut state = state_with_workspaces(&["test"]); - state.keybinds.resize_mode = (KeyCode::Char('g'), KeyModifiers::empty()); - state.keybinds.resize_mode_label = "g".into(); - - handle_navigate_key( - &mut state, - KeyEvent::new(KeyCode::Char('g'), KeyModifiers::empty()), - ); - - assert_eq!(state.mode, Mode::Resize); - } - - #[test] - fn movement_action_stays_in_navigate_mode() { - let mut state = state_with_workspaces(&["a", "b"]); - state.selected = 0; - - handle_navigate_key( - &mut state, - KeyEvent::new(KeyCode::Down, KeyModifiers::empty()), - ); - - assert_eq!(state.selected, 1); - assert_eq!(state.mode, Mode::Navigate); - } - - #[test] - fn terminal_direct_focus_pane_shortcut_maps_to_navigation_action() { - let mut state = state_with_workspaces(&["test"]); - state.keybinds.focus_pane_left = Some((KeyCode::Left, KeyModifiers::ALT)); - state.keybinds.focus_pane_left_label = Some("alt+left".into()); - - let action = terminal_direct_navigation_action( - &state, - &AppKey::from(KeyEvent::new(KeyCode::Left, KeyModifiers::ALT)), - ); - - assert_eq!(action, Some(NavigateAction::FocusPaneLeft)); - } - - #[tokio::test] - async fn terminal_direct_focus_pane_shortcut_switches_focus_without_leaving_terminal_mode() { - let (_api_tx, api_rx) = tokio::sync::mpsc::unbounded_channel(); - let mut app = App::new( - &Config::default(), - true, - None, - None, - api_rx, - crate::api::EventHub::default(), - ); - app.state.workspaces = vec![Workspace::test_new("test")]; - app.state.active = Some(0); - app.state.selected = 0; - app.state.mode = Mode::Terminal; - app.state.workspaces[0].test_split(Direction::Horizontal); - app.state.view.pane_infos = app.state.workspaces[0] - .active_tab() - .unwrap() - .layout - .panes(Rect::new(0, 0, 80, 24)); - let focused_before = app.state.workspaces[0].layout.focused(); - app.state.keybinds.focus_pane_left = Some((KeyCode::Char('h'), KeyModifiers::ALT)); - app.state.keybinds.focus_pane_left_label = Some("alt+h".into()); - - app.handle_terminal_key(TerminalKey::new(KeyCode::Char('h'), KeyModifiers::ALT)) - .await; - - assert_ne!(app.state.workspaces[0].layout.focused(), focused_before); - assert_eq!(app.state.mode, Mode::Terminal); - } - - #[tokio::test] - async fn double_prefix_passes_prefix_through_to_focused_pane() { - let (_api_tx, api_rx) = tokio::sync::mpsc::unbounded_channel(); - let mut app = App::new( - &Config::default(), - true, - None, - None, - api_rx, - crate::api::EventHub::default(), - ); - let mut workspace = Workspace::test_new("test"); - let pane_id = workspace.tabs[0].root_pane; - let (runtime, mut rx) = - crate::pane::PaneRuntime::test_with_screen_bytes_and_receiver(20, 5, b""); - let expected = runtime - .encode_terminal_key(TerminalKey::new(KeyCode::Char('a'), KeyModifiers::CONTROL)); - workspace.tabs[0].runtimes.insert(pane_id, runtime); - - app.state.workspaces = vec![workspace]; - app.state.active = Some(0); - app.state.selected = 0; - app.state.mode = Mode::Terminal; - app.state.prefix_code = KeyCode::Char('a'); - app.state.prefix_mods = KeyModifiers::CONTROL; - - app.handle_key(TerminalKey::new(KeyCode::Char('a'), KeyModifiers::CONTROL)) - .await; - assert_eq!(app.state.mode, Mode::Navigate); - - app.handle_key(TerminalKey::new(KeyCode::Char('a'), KeyModifiers::CONTROL)) - .await; - assert_eq!(app.state.mode, Mode::Terminal); - - let forwarded = rx.try_recv().expect("prefix bytes should be forwarded"); - assert_eq!(forwarded.as_ref(), expected.as_slice()); - } - - #[tokio::test] - async fn double_shifted_prefix_preserves_shifted_codepoint_when_forwarded() { - let (_api_tx, api_rx) = tokio::sync::mpsc::unbounded_channel(); - let mut app = App::new( - &Config::default(), - true, - None, - None, - api_rx, - crate::api::EventHub::default(), - ); - let mut workspace = Workspace::test_new("test"); - let pane_id = workspace.tabs[0].root_pane; - let (runtime, mut rx) = - crate::pane::PaneRuntime::test_with_screen_bytes_and_receiver(20, 5, b""); - let prefix = TerminalKey::new(KeyCode::Char('/'), KeyModifiers::SHIFT) - .with_shifted_codepoint('?' as u32); - let expected = runtime.encode_terminal_key(prefix); - workspace.tabs[0].runtimes.insert(pane_id, runtime); - - app.state.workspaces = vec![workspace]; - app.state.active = Some(0); - app.state.selected = 0; - app.state.mode = Mode::Terminal; - app.state.prefix_code = KeyCode::Char('?'); - app.state.prefix_mods = KeyModifiers::empty(); - - app.handle_key(prefix).await; - assert_eq!(app.state.mode, Mode::Navigate); - - app.handle_key(prefix).await; - assert_eq!(app.state.mode, Mode::Terminal); - - let forwarded = rx - .try_recv() - .expect("shifted prefix bytes should be forwarded"); - assert_eq!(forwarded.as_ref(), expected.as_slice()); - } - - #[tokio::test] - async fn custom_command_runs_from_prefix_key_in_navigate_mode() { - let (_api_tx, api_rx) = tokio::sync::mpsc::unbounded_channel(); - let mut app = App::new( - &Config::default(), - true, - None, - None, - api_rx, - crate::api::EventHub::default(), - ); - app.state.workspaces = vec![Workspace::test_new("test")]; - app.state.active = Some(0); - app.state.selected = 0; - app.state.mode = Mode::Terminal; - - let output_path = unique_temp_path("custom-command-keybind"); - let command = format!( - "printf '%s\\n%s\\n%s\\n' \"$HERDR_ACTIVE_WORKSPACE_ID\" \"$HERDR_ACTIVE_TAB_ID\" \"$HERDR_ACTIVE_PANE_ID\" > '{}'", - output_path.display() - ); - app.state.keybinds.custom_commands = vec![crate::config::CustomCommandKeybind { - key: (KeyCode::Char('g'), KeyModifiers::empty()), - label: "g".into(), - command, - action: crate::config::CustomCommandAction::Shell, - }]; - - app.handle_key(TerminalKey::new( - app.state.prefix_code, - app.state.prefix_mods, - )) - .await; - assert_eq!(app.state.mode, Mode::Navigate); - - app.handle_key(TerminalKey::new(KeyCode::Char('g'), KeyModifiers::empty())) - .await; - - let content = wait_for_file(&output_path); - let lines: Vec<&str> = content.lines().collect(); - assert_eq!(lines.len(), 3); - assert_eq!(lines[0], app.state.workspaces[0].id); - assert_eq!(lines[1], format!("{}:1", app.state.workspaces[0].id)); - assert_eq!(lines[2], format!("{}-1", app.state.workspaces[0].id)); - assert_eq!(app.state.mode, Mode::Terminal); - - let _ = fs::remove_file(output_path); - } - - #[tokio::test] - async fn pane_overlay_command_opens_and_closes_after_exit() { - let (_api_tx, api_rx) = tokio::sync::mpsc::unbounded_channel(); - let mut app = App::new( - &Config::default(), - true, - None, - None, - api_rx, - crate::api::EventHub::default(), - ); - let workspace = Workspace::new( - std::env::current_dir().unwrap_or_else(|_| "/".into()), - 24, - 80, - app.state.pane_scrollback_limit_bytes, - app.state.host_terminal_theme, - app.event_tx.clone(), - app.render_notify.clone(), - app.render_dirty.clone(), - ) - .expect("workspace should spawn"); - app.state.workspaces = vec![workspace]; - app.state.active = Some(0); - app.state.selected = 0; - app.state.mode = Mode::Terminal; - - let output_path = unique_temp_path("custom-pane-command"); - let command = format!("printf done > '{}'", output_path.display()); - app.state.keybinds.custom_commands = vec![crate::config::CustomCommandKeybind { - key: (KeyCode::Char('g'), KeyModifiers::empty()), - label: "g".into(), - command, - action: crate::config::CustomCommandAction::Pane, - }]; - - app.handle_key(TerminalKey::new( - app.state.prefix_code, - app.state.prefix_mods, - )) - .await; - app.handle_key(TerminalKey::new(KeyCode::Char('g'), KeyModifiers::empty())) - .await; - - assert_eq!(app.state.workspaces[0].tabs[0].layout.pane_count(), 2); - assert!(app.state.workspaces[0].tabs[0].zoomed); - - let _ = wait_for_file(&output_path); - let deadline = std::time::Instant::now() + Duration::from_secs(2); - while std::time::Instant::now() < deadline { - if app.drain_internal_events() - && app.state.workspaces[0].tabs[0].layout.pane_count() == 1 - { - break; - } - std::thread::sleep(Duration::from_millis(20)); - } - - assert_eq!(app.state.workspaces[0].tabs[0].layout.pane_count(), 1); - assert!(!app.state.workspaces[0].tabs[0].zoomed); - assert_eq!(app.state.mode, Mode::Terminal); - let _ = fs::remove_file(output_path); - } - - #[test] - fn fullscreen_action_exits_navigate_mode() { - let mut state = state_with_workspaces(&["test"]); - state.workspaces[0].test_split(Direction::Horizontal); - state.keybinds.fullscreen = (KeyCode::Char('g'), KeyModifiers::empty()); - state.keybinds.fullscreen_label = "g".into(); - - handle_navigate_key( - &mut state, - KeyEvent::new(KeyCode::Char('g'), KeyModifiers::empty()), - ); - - assert!(state.workspaces[0].zoomed); - assert_eq!(state.mode, Mode::Terminal); - } - - #[test] - fn custom_resize_key_exits_resize_mode() { - let mut state = state_with_workspaces(&["test"]); - state.mode = Mode::Resize; - state.keybinds.resize_mode = (KeyCode::Char('g'), KeyModifiers::empty()); - state.keybinds.resize_mode_label = "g".into(); - - handle_resize_key( - &mut state, - KeyEvent::new(KeyCode::Char('g'), KeyModifiers::empty()), - ); - - assert_eq!(state.mode, Mode::Terminal); - } - - #[test] - fn settings_cancel_restores_previewed_theme_from_other_sections() { - let mut state = state_with_workspaces(&["test"]); - let original_palette = state.palette.clone(); - let original_theme = state.theme_name.clone(); - - open_settings(&mut state); - update_settings_state( - &mut state, - KeyEvent::new(KeyCode::Down, KeyModifiers::empty()), - ); - assert_ne!(state.theme_name, original_theme); - - update_settings_state( - &mut state, - KeyEvent::new(KeyCode::Tab, KeyModifiers::empty()), - ); - assert_eq!( - state.settings.section, - crate::app::state::SettingsSection::Sound - ); - - update_settings_state( - &mut state, - KeyEvent::new(KeyCode::Esc, KeyModifiers::empty()), - ); - - assert_eq!(state.mode, Mode::Terminal); - assert_eq!(state.theme_name, original_theme); - assert_eq!(state.palette.accent, original_palette.accent); - assert_eq!(state.palette.panel_bg, original_palette.panel_bg); - } - - #[test] - fn settings_sound_toggle_returns_save_action() { - let mut state = state_with_workspaces(&["test"]); - open_settings(&mut state); - state.settings.section = crate::app::state::SettingsSection::Sound; - state.settings.list.selected = 0; - - let action = update_settings_state( - &mut state, - KeyEvent::new(KeyCode::Enter, KeyModifiers::empty()), - ); - - assert_eq!(action, Some(SettingsAction::SaveSound(true))); - assert!(state.sound.enabled); - assert_eq!(state.mode, Mode::Settings); - } - - #[test] - fn question_mark_opens_keybind_help_from_navigate() { - let mut state = state_with_workspaces(&["test"]); - - handle_navigate_key( - &mut state, - KeyEvent::new(KeyCode::Char('?'), KeyModifiers::SHIFT), - ); - - assert_eq!(state.mode, Mode::KeybindHelp); - } - - #[test] - fn shifted_slash_terminal_key_opens_keybind_help_from_navigate() { - let mut state = state_with_workspaces(&["test"]); - - handle_navigate_key( - &mut state, - TerminalKey::new(KeyCode::Char('/'), KeyModifiers::SHIFT) - .with_shifted_codepoint('?' as u32), - ); - - assert_eq!(state.mode, Mode::KeybindHelp); - } - - #[test] - fn rename_modal_keyboard_and_mouse_share_actions() { - let mut state = state_with_workspaces(&["test"]); - state.mode = Mode::RenameWorkspace; - state.name_input = "hello".into(); - - handle_rename_key( - &mut state, - KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL), - ); - assert!(state.name_input.is_empty()); - - state.name_input = "renamed".into(); - handle_rename_key( - &mut state, - KeyEvent::new(KeyCode::Enter, KeyModifiers::empty()), - ); - assert_eq!(state.mode, Mode::Terminal); - assert_eq!(state.workspaces[0].display_name(), "renamed"); - let snapshot = capture_snapshot(&state); - assert_eq!( - snapshot.workspaces[0].custom_name.as_deref(), - Some("renamed") - ); - - state.view.sidebar_rect = Rect::new(0, 0, 26, 20); - state.view.terminal_area = Rect::new(26, 0, 80, 20); - state.mode = Mode::RenameWorkspace; - state.name_input = "mouse".into(); - let inner = state.rename_modal_inner().unwrap(); - let (save, _, _) = crate::ui::rename_button_rects(inner); - let action = modal_action_from_buttons(save.x, save.y, &[(save, ModalAction::Save)]); - assert_eq!(action, Some(ModalAction::Save)); - } - - #[test] - fn tab_rename_updates_captured_snapshot() { - let mut state = state_with_workspaces(&["test"]); - state.mode = Mode::RenameTab; - state.name_input = "logs".into(); - - handle_rename_key( - &mut state, - KeyEvent::new(KeyCode::Enter, KeyModifiers::empty()), - ); - - let snapshot = capture_snapshot(&state); - assert_eq!( - snapshot.workspaces[0].tabs[0].custom_name.as_deref(), - Some("logs") - ); - } - - #[test] - fn rename_cancel_returns_to_terminal_when_workspace_is_active() { - let mut state = state_with_workspaces(&["test"]); - state.mode = Mode::RenameTab; - state.name_input = "test".into(); - - handle_rename_key( - &mut state, - KeyEvent::new(KeyCode::Esc, KeyModifiers::empty()), - ); - - assert_eq!(state.mode, Mode::Terminal); - assert!(state.name_input.is_empty()); - } - - #[test] - fn rename_modal_replaces_prefilled_text_on_first_type() { - let mut state = state_with_workspaces(&["test"]); - state.mode = Mode::RenameTab; - state.name_input = "2".into(); - state.name_input_replace_on_type = true; - - handle_rename_key( - &mut state, - KeyEvent::new(KeyCode::Char('n'), KeyModifiers::empty()), - ); - assert_eq!(state.name_input, "n"); - assert!(!state.name_input_replace_on_type); - - handle_rename_key( - &mut state, - KeyEvent::new(KeyCode::Char('e'), KeyModifiers::empty()), - ); - assert_eq!(state.name_input, "ne"); - } - - #[test] - fn rename_modal_uses_shifted_terminal_text_for_app_input() { - let mut state = state_with_workspaces(&["test"]); - state.mode = Mode::RenameTab; - - handle_rename_key( - &mut state, - TerminalKey::new(KeyCode::Char('l'), KeyModifiers::SHIFT) - .with_shifted_codepoint('L' as u32), - ); - handle_rename_key( - &mut state, - TerminalKey::new(KeyCode::Char('/'), KeyModifiers::SHIFT) - .with_shifted_codepoint('?' as u32), - ); - - assert_eq!(state.name_input, "L?"); - } - - #[test] - fn open_rename_active_tab_can_prefill_default_new_tab_name() { - let mut state = state_with_workspaces(&["test"]); - state.workspaces[0].test_add_tab(None); - state.workspaces[0].switch_tab(1); - - open_rename_active_tab(&mut state, true); - - assert_eq!(state.mode, Mode::RenameTab); - assert_eq!(state.name_input, "2"); - assert!(state.name_input_replace_on_type); - } - - #[test] - fn new_tab_action_opens_dialog_without_creating_tab() { - let mut state = state_with_workspaces(&["test"]); - - execute_navigate_action(&mut state, NavigateAction::NewTab); - - assert_eq!(state.mode, Mode::RenameTab); - assert!(state.creating_new_tab); - assert_eq!(state.name_input, "2"); - assert!(state.name_input_replace_on_type); - assert!(!state.request_new_tab); - assert_eq!(state.workspaces[0].tabs.len(), 1); - } - - #[test] - fn cancel_new_tab_dialog_leaves_workspace_unchanged() { - let mut state = state_with_workspaces(&["test"]); - open_new_tab_dialog(&mut state); - - handle_rename_key( - &mut state, - KeyEvent::new(KeyCode::Esc, KeyModifiers::empty()), - ); - - assert_eq!(state.mode, Mode::Terminal); - assert!(!state.creating_new_tab); - assert!(!state.request_new_tab); - assert!(state.requested_new_tab_name.is_none()); - assert_eq!(state.workspaces[0].tabs.len(), 1); - } - - #[test] - fn saving_new_tab_dialog_requests_creation_with_name() { - let mut state = state_with_workspaces(&["test"]); - open_new_tab_dialog(&mut state); - state.name_input = "logs".into(); - state.name_input_replace_on_type = false; - - handle_rename_key( - &mut state, - KeyEvent::new(KeyCode::Enter, KeyModifiers::empty()), - ); - - assert_eq!(state.mode, Mode::Terminal); - assert!(!state.creating_new_tab); - assert!(state.request_new_tab); - assert_eq!(state.requested_new_tab_name.as_deref(), Some("logs")); - } - - #[test] - fn saving_new_tab_dialog_with_default_name_keeps_tab_auto_named() { - let mut state = state_with_workspaces(&["test"]); - open_new_tab_dialog(&mut state); - - handle_rename_key( - &mut state, - KeyEvent::new(KeyCode::Enter, KeyModifiers::empty()), - ); - - assert_eq!(state.mode, Mode::Terminal); - assert!(!state.creating_new_tab); - assert!(state.request_new_tab); - assert!(state.requested_new_tab_name.is_none()); - } - - #[test] - fn closing_first_auto_tab_resets_remaining_auto_tab_and_next_prompt() { - let mut state = state_with_workspaces(&["test"]); - open_new_tab_dialog(&mut state); - handle_rename_key( - &mut state, - KeyEvent::new(KeyCode::Enter, KeyModifiers::empty()), - ); - - state.workspaces[0].test_add_tab(state.requested_new_tab_name.as_deref()); - state.request_new_tab = false; - state.requested_new_tab_name = None; - - state.workspaces[0].close_tab(0); - state.workspaces[0].switch_tab(0); - - assert_eq!(state.workspaces[0].tabs[0].display_name(), "1"); - assert!(state.workspaces[0].tabs[0].custom_name.is_none()); - - open_new_tab_dialog(&mut state); - assert_eq!(state.name_input, "2"); - } - - #[test] - fn renaming_auto_tab_to_its_default_number_keeps_it_auto_named() { - let mut state = state_with_workspaces(&["test"]); - state.workspaces[0].test_add_tab(None); - state.workspaces[0].switch_tab(1); - - open_rename_active_tab(&mut state, false); - handle_rename_key( - &mut state, - KeyEvent::new(KeyCode::Enter, KeyModifiers::empty()), - ); - - assert_eq!(state.mode, Mode::Terminal); - assert!(state.workspaces[0].tabs[1].custom_name.is_none()); - assert_eq!(state.workspaces[0].tabs[1].display_name(), "2"); - } - - #[test] - fn confirm_close_keyboard_actions_are_direct_not_focused() { - let mut state = state_with_workspaces(&["a", "b"]); - state.mode = Mode::ConfirmClose; - state.selected = 1; - - handle_confirm_close_key( - &mut state, - KeyEvent::new(KeyCode::Esc, KeyModifiers::empty()), - ); - assert_eq!(state.mode, Mode::Navigate); - assert_eq!(state.workspaces.len(), 2); - - state.mode = Mode::ConfirmClose; - handle_confirm_close_key( - &mut state, - KeyEvent::new(KeyCode::Enter, KeyModifiers::empty()), - ); - assert_eq!(state.workspaces.len(), 1); - } - - #[test] - fn clicking_launcher_opens_global_menu() { - let mut app = app_for_mouse_test(); - let rect = app.state.global_launcher_rect(); - - app.handle_mouse(mouse( - MouseEventKind::Down(MouseButton::Left), - rect.x + rect.width.saturating_sub(1), - rect.y, - )); - - assert_eq!(app.state.mode, Mode::GlobalMenu); - } - - #[test] - fn hovering_global_menu_updates_highlight() { - let mut app = app_for_mouse_test(); - let launcher = app.state.global_launcher_rect(); - app.handle_mouse(mouse( - MouseEventKind::Down(MouseButton::Left), - launcher.x, - launcher.y, - )); - - let menu = app.state.global_menu_rect(); - app.handle_mouse(mouse(MouseEventKind::Moved, menu.x + 2, menu.y + 2)); - - assert_eq!(app.state.global_menu.highlighted, 1); - } - - #[test] - fn clicking_keybinds_menu_item_opens_help() { - let mut app = app_for_mouse_test(); - let launcher = app.state.global_launcher_rect(); - app.handle_mouse(mouse( - MouseEventKind::Down(MouseButton::Left), - launcher.x, - launcher.y, - )); - - let menu = app.state.global_menu_rect(); - app.handle_mouse(mouse( - MouseEventKind::Down(MouseButton::Left), - menu.x + 2, - menu.y + 2, - )); - - assert_eq!(app.state.mode, Mode::KeybindHelp); - } - - #[test] - fn clicking_settings_menu_item_opens_settings() { - let mut app = app_for_mouse_test(); - let launcher = app.state.global_launcher_rect(); - app.handle_mouse(mouse( - MouseEventKind::Down(MouseButton::Left), - launcher.x, - launcher.y, - )); - - let menu = app.state.global_menu_rect(); - app.handle_mouse(mouse( - MouseEventKind::Down(MouseButton::Left), - menu.x + 2, - menu.y + 1, - )); - - assert_eq!(app.state.mode, Mode::Settings); - } - - #[test] - fn clicking_reload_keybinds_menu_item_requests_reload() { - let mut app = app_for_mouse_test(); - let launcher = app.state.global_launcher_rect(); - app.handle_mouse(mouse( - MouseEventKind::Down(MouseButton::Left), - launcher.x, - launcher.y, - )); - - let menu = app.state.global_menu_rect(); - app.handle_mouse(mouse( - MouseEventKind::Down(MouseButton::Left), - menu.x + 2, - menu.y + 3, - )); - - assert!(app.state.request_reload_keybinds); - assert_eq!(app.state.mode, Mode::Navigate); - } - - #[test] - fn update_available_menu_surfaces_update_status_without_apply_action() { - let mut app = app_for_mouse_test(); - app.state.update_available = Some("0.3.2".into()); - app.state.latest_release_notes_available = true; - - let launcher = app.state.global_launcher_rect(); - app.handle_mouse(mouse( - MouseEventKind::Down(MouseButton::Left), - launcher.x, - launcher.y, - )); - - assert_eq!( - app.state.global_menu_labels(), - vec![ - "settings", - "keybinds", - "reload keybinds", - "update available", - "quit" - ] - ); - - let menu = app.state.global_menu_rect(); - app.handle_mouse(mouse( - MouseEventKind::Down(MouseButton::Left), - menu.x + 2, - menu.y + 5, - )); - - assert!(app.state.should_quit); - } - - #[test] - fn whats_new_remains_in_menu_for_latest_installed_release_notes() { - let mut app = app_for_mouse_test(); - app.state.latest_release_notes_available = true; - - assert_eq!( - app.state.global_menu_labels(), - vec![ - "settings", - "keybinds", - "reload keybinds", - "what's new", - "quit" - ] - ); - } - - #[test] - fn clicking_keybind_help_close_button_closes_overlay() { - let mut app = app_for_mouse_test(); - app.state.mode = Mode::KeybindHelp; - - let rect = app.state.keybind_help_popup_rect(); - let inner = Rect::new( - rect.x + 1, - rect.y + 1, - rect.width.saturating_sub(2), - rect.height.saturating_sub(2), - ); - let close = - crate::ui::release_notes_close_button_rect(Rect::new(inner.x, inner.y, inner.width, 1)); - app.handle_mouse(mouse( - MouseEventKind::Down(MouseButton::Left), - close.x, - close.y, - )); - - assert_eq!(app.state.mode, Mode::Navigate); - } - - #[test] - fn hovering_context_menu_updates_highlight() { - let mut app = app_for_mouse_test(); - app.state.context_menu = Some(ContextMenuState { - kind: ContextMenuKind::Workspace { ws_idx: 0 }, - x: 2, - y: 2, - list: MenuListState::new(0), - }); - app.state.mode = Mode::ContextMenu; - - let menu = app.state.context_menu_rect().unwrap(); - app.handle_mouse(mouse(MouseEventKind::Moved, menu.x + 2, menu.y + 2)); - - assert_eq!(app.state.context_menu.unwrap().list.highlighted, 1); - } - - #[test] - fn onboarding_hover_does_not_change_selection() { - let mut app = app_for_mouse_test(); - app.state.mode = Mode::Onboarding; - app.state.onboarding_step = 1; - app.state.onboarding_list.select(1); - - let inner = app.state.onboarding_modal_inner(56, 14).unwrap(); - let content = crate::ui::modal_stack_areas(inner, 3, 0, 1, 1).content; - app.handle_mouse(mouse(MouseEventKind::Moved, content.x + 2, content.y)); - - assert_eq!(app.state.onboarding_list.selected, 1); - } - - #[test] - fn onboarding_click_selects_notification_option() { - let mut app = app_for_mouse_test(); - app.state.mode = Mode::Onboarding; - app.state.onboarding_step = 1; - app.state.onboarding_list.select(0); - - let inner = app.state.onboarding_modal_inner(56, 14).unwrap(); - let content = crate::ui::modal_stack_areas(inner, 3, 0, 1, 1).content; - app.handle_mouse(mouse( - MouseEventKind::Down(MouseButton::Left), - content.x + 2, - content.y + 2, - )); - - assert_eq!(app.state.onboarding_list.selected, 2); - } - - #[test] - fn settings_hover_does_not_change_selection() { - let mut app = app_for_mouse_test(); - open_settings(&mut app.state); - app.state.settings.list.select(0); - - let area = app.state.settings_content_rect(); - app.handle_mouse(mouse(MouseEventKind::Moved, area.x + 2, area.y + 2)); - - assert_eq!(app.state.settings.list.selected, 0); - } - - #[test] - fn clicking_confirm_close_accepts_workspace_close() { - let mut app = app_for_mouse_test(); - app.state.workspaces = vec![Workspace::test_new("a"), Workspace::test_new("b")]; - app.state.active = Some(0); - app.state.selected = 1; - app.state.mode = Mode::ConfirmClose; - - let popup = app.state.confirm_close_rect(); - let inner = Rect::new( - popup.x + 1, - popup.y + 1, - popup.width.saturating_sub(2), - popup.height.saturating_sub(2), - ); - let (confirm, _) = crate::ui::confirm_close_button_rects(inner); - - app.handle_mouse(mouse( - MouseEventKind::Down(MouseButton::Left), - confirm.x, - confirm.y, - )); - - assert_eq!(app.state.workspaces.len(), 1); - assert_eq!(app.state.mode, Mode::Terminal); - } - - #[test] - fn clicking_confirm_close_accepts_after_workspace_context_menu_close() { - let mut app = app_for_mouse_test(); - app.state.workspaces = vec![Workspace::test_new("a"), Workspace::test_new("b")]; - app.state.active = Some(0); - app.state.selected = 0; - app.state.mode = Mode::Terminal; - - app.state.context_menu = Some(ContextMenuState { - kind: ContextMenuKind::Workspace { ws_idx: 1 }, - x: 2, - y: 2, - list: MenuListState::new(1), - }); - app.state.mode = Mode::ContextMenu; - handle_context_menu_key( - &mut app.state, - KeyEvent::new(KeyCode::Enter, KeyModifiers::empty()), - ); - assert_eq!(app.state.mode, Mode::ConfirmClose); - assert_eq!(app.state.selected, 1); - - let popup = app.state.confirm_close_rect(); - let inner = Rect::new( - popup.x + 1, - popup.y + 1, - popup.width.saturating_sub(2), - popup.height.saturating_sub(2), - ); - let (confirm, _) = crate::ui::confirm_close_button_rects(inner); - app.handle_mouse(mouse( - MouseEventKind::Down(MouseButton::Left), - confirm.x + 1, - confirm.y, - )); - - assert_eq!(app.state.workspaces.len(), 1); - assert_eq!(app.state.workspaces[0].display_name(), "a"); - } - - #[test] - fn clicking_agent_detail_row_switches_to_correct_tab_and_pane() { - let mut app = app_for_mouse_test(); - let mut ws = Workspace::test_new("test"); - ws.tabs[0].set_custom_name("main".into()); - let first_pane = ws.tabs[0].root_pane; - ws.tabs[0] - .panes - .get_mut(&first_pane) - .unwrap() - .detected_agent = Some(Agent::Pi); - let second_tab = ws.test_add_tab(Some("logs")); - let second_pane = ws.tabs[second_tab].root_pane; - ws.tabs[second_tab] - .panes - .get_mut(&second_pane) - .unwrap() - .detected_agent = Some(Agent::Claude); - app.state.workspaces = vec![ws]; - app.state.active = Some(0); - app.state.selected = 0; - app.state.mode = Mode::Terminal; - - app.handle_mouse(mouse(MouseEventKind::Down(MouseButton::Left), 2, 16)); - - assert_eq!(app.state.workspaces[0].active_tab, 1); - assert_eq!( - app.state.workspaces[0].tabs[1].layout.focused(), - second_pane - ); - assert_eq!(app.state.mode, Mode::Terminal); - let snapshot = capture_snapshot(&app.state); - assert_eq!(snapshot.workspaces[0].active_tab, second_tab); - assert_eq!( - snapshot.workspaces[0].tabs[second_tab].focused, - Some(second_pane.raw()) - ); - } - - #[test] - fn clicking_agent_panel_toggle_switches_scope() { - let mut app = app_for_mouse_test(); - app.state.workspaces = vec![Workspace::test_new("test")]; - app.state.active = Some(0); - app.state.selected = 0; - app.state.mode = Mode::Terminal; - app.state.agent_panel_scroll = 3; - - let (_, detail_area) = crate::ui::expanded_sidebar_sections( - app.state.view.sidebar_rect, - app.state.sidebar_section_split, - ); - let toggle = crate::ui::agent_panel_toggle_rect(detail_area, app.state.agent_panel_scope); - app.handle_mouse(mouse( - MouseEventKind::Down(MouseButton::Left), - toggle.x, - toggle.y, - )); - - assert_eq!(app.state.agent_panel_scope, AgentPanelScope::AllWorkspaces); - assert_eq!(app.state.agent_panel_scroll, 0); - let snapshot = capture_snapshot(&app.state); - assert_eq!(snapshot.agent_panel_scope, AgentPanelScope::AllWorkspaces); - } - - #[test] - fn clicking_all_workspaces_agent_row_switches_to_correct_workspace() { - let mut app = app_for_mouse_test(); - let mut first = Workspace::test_new("one"); - let first_pane = first.tabs[0].root_pane; - first.tabs[0] - .panes - .get_mut(&first_pane) - .unwrap() - .detected_agent = Some(Agent::Pi); - - let mut second = Workspace::test_new("two"); - let second_pane = second.tabs[0].root_pane; - second.tabs[0] - .panes - .get_mut(&second_pane) - .unwrap() - .detected_agent = Some(Agent::Claude); - - app.state.workspaces = vec![first, second]; - app.state.active = Some(0); - app.state.selected = 0; - app.state.mode = Mode::Terminal; - app.state.agent_panel_scope = AgentPanelScope::AllWorkspaces; - - let (_, detail_area) = crate::ui::expanded_sidebar_sections( - app.state.view.sidebar_rect, - app.state.sidebar_section_split, - ); - app.handle_mouse(mouse( - MouseEventKind::Down(MouseButton::Left), - detail_area.x + 2, - detail_area.y + 6, - )); - - assert_eq!(app.state.active, Some(1)); - assert_eq!(app.state.selected, 1); - assert_eq!(app.state.workspaces[1].active_tab, 0); - assert_eq!( - app.state.workspaces[1].tabs[0].layout.focused(), - second_pane - ); - } - - #[test] - fn scrolling_agent_panel_with_wheel_updates_agent_panel_scroll() { - let mut app = app_for_mouse_test(); - let mut ws = Workspace::test_new("test"); - let first_pane = ws.tabs[0].root_pane; - ws.tabs[0] - .panes - .get_mut(&first_pane) - .unwrap() - .detected_agent = Some(Agent::Pi); - - for (tab_name, agent) in [ - ("logs", Agent::Claude), - ("review", Agent::Codex), - ("ops", Agent::Gemini), - ] { - let tab_idx = ws.test_add_tab(Some(tab_name)); - let pane_id = ws.tabs[tab_idx].root_pane; - ws.tabs[tab_idx] - .panes - .get_mut(&pane_id) - .unwrap() - .detected_agent = Some(agent); - } - - app.state.workspaces = vec![ws]; - app.state.active = Some(0); - app.state.selected = 0; - app.state.mode = Mode::Terminal; - - let detail_area = app.state.agent_panel_rect(); - assert!(crate::ui::should_show_scrollbar( - crate::ui::agent_panel_scroll_metrics(&app.state, detail_area) - )); - - app.handle_mouse(mouse( - MouseEventKind::ScrollDown, - detail_area.x + 1, - detail_area.y + 4, - )); - - assert_eq!(app.state.agent_panel_scroll, 1); - assert_eq!(app.state.selected, 0); - } - - #[test] - fn clicking_scrolled_agent_detail_row_switches_to_correct_tab_and_pane() { - let mut app = app_for_mouse_test(); - let mut ws = Workspace::test_new("test"); - let first_pane = ws.tabs[0].root_pane; - ws.tabs[0] - .panes - .get_mut(&first_pane) - .unwrap() - .detected_agent = Some(Agent::Pi); - - let second_tab = ws.test_add_tab(Some("logs")); - let second_pane = ws.tabs[second_tab].root_pane; - ws.tabs[second_tab] - .panes - .get_mut(&second_pane) - .unwrap() - .detected_agent = Some(Agent::Claude); - - for (tab_name, agent) in [("review", Agent::Codex), ("ops", Agent::Gemini)] { - let tab_idx = ws.test_add_tab(Some(tab_name)); - let pane_id = ws.tabs[tab_idx].root_pane; - ws.tabs[tab_idx] - .panes - .get_mut(&pane_id) - .unwrap() - .detected_agent = Some(agent); - } - - app.state.workspaces = vec![ws]; - app.state.active = Some(0); - app.state.selected = 0; - app.state.mode = Mode::Terminal; - app.state.agent_panel_scroll = 1; - - let detail_area = app.state.agent_panel_rect(); - let body = crate::ui::agent_panel_body_rect(detail_area, true); - app.handle_mouse(mouse( - MouseEventKind::Down(MouseButton::Left), - body.x + 1, - body.y, - )); - - assert_eq!(app.state.workspaces[0].active_tab, second_tab); - assert_eq!( - app.state.workspaces[0].tabs[second_tab].layout.focused(), - second_pane - ); - assert_eq!(app.state.mode, Mode::Terminal); - } - - #[test] - fn clicking_collapsed_agent_row_switches_to_correct_tab_and_pane() { - let mut app = app_for_mouse_test(); - let mut ws = Workspace::test_new("test"); - let first_pane = ws.tabs[0].root_pane; - ws.tabs[0] - .panes - .get_mut(&first_pane) - .unwrap() - .detected_agent = Some(Agent::Pi); - let second_tab = ws.test_add_tab(Some("logs")); - let second_pane = ws.tabs[second_tab].root_pane; - ws.tabs[second_tab] - .panes - .get_mut(&second_pane) - .unwrap() - .detected_agent = Some(Agent::Claude); - app.state.workspaces = vec![ws]; - app.state.active = Some(0); - app.state.selected = 0; - app.state.mode = Mode::Terminal; - app.state.sidebar_collapsed = true; - app.state.view.sidebar_rect = Rect::new(0, 0, 4, 20); - app.state.view.terminal_area = Rect::new(4, 0, 80, 20); - - let (_, _, detail_area) = - crate::ui::collapsed_sidebar_sections(app.state.view.sidebar_rect); - app.handle_mouse(mouse( - MouseEventKind::Down(MouseButton::Left), - detail_area.x, - detail_area.y + 1, - )); - - assert_eq!(app.state.workspaces[0].active_tab, 1); - assert_eq!( - app.state.workspaces[0].tabs[1].layout.focused(), - second_pane - ); - assert_eq!(app.state.mode, Mode::Terminal); - } - - #[test] - fn clicking_collapsed_sidebar_toggle_expands_sidebar() { - let mut app = app_for_mouse_test(); - app.state.sidebar_collapsed = true; - app.state.view.sidebar_rect = Rect::new(0, 0, 4, 20); - app.state.view.terminal_area = Rect::new(4, 0, 80, 20); - - let toggle = crate::ui::collapsed_sidebar_toggle_rect(app.state.view.sidebar_rect); - app.handle_mouse(mouse( - MouseEventKind::Down(MouseButton::Left), - toggle.x, - toggle.y, - )); - - assert!(!app.state.sidebar_collapsed); - } - - #[tokio::test] - async fn dragging_selection_above_pane_autoscrolls_and_extends_into_scrollback() { - let mut app = app_for_mouse_test(); - let mut ws = Workspace::test_new("test"); - let pane_id = ws.tabs[0].root_pane; - let pane_infos = ws.tabs[0].layout.panes(Rect::new(26, 2, 80, 18)); - let info = pane_infos[0].clone(); - ws.tabs[0].runtimes.insert( - pane_id, - crate::pane::PaneRuntime::test_with_scrollback_bytes( - info.inner_rect.width, - info.inner_rect.height, - 16 * 1024, - &numbered_lines_bytes(64), - ), - ); - - app.state.workspaces = vec![ws]; - app.state.active = Some(0); - app.state.selected = 0; - app.state.mode = Mode::Terminal; - app.state.view.pane_infos = pane_infos; - - let start_metrics = app.state.workspaces[0] - .runtime(pane_id) - .and_then(crate::pane::PaneRuntime::scroll_metrics) - .expect("initial scroll metrics"); - let start_row = info.inner_rect.y; - let start_col = info.inner_rect.x + 2; - - app.handle_mouse(mouse( - MouseEventKind::Down(MouseButton::Left), - start_col, - start_row, - )); - app.handle_mouse(mouse( - MouseEventKind::Drag(MouseButton::Left), - start_col, - info.inner_rect.y.saturating_sub(1), - )); - - let end_metrics = app.state.workspaces[0] - .runtime(pane_id) - .and_then(crate::pane::PaneRuntime::scroll_metrics) - .expect("scroll metrics after drag"); - assert_eq!( - end_metrics.offset_from_bottom, - start_metrics.offset_from_bottom + 3 - ); - - let selection = app.state.selection.as_ref().expect("selection after drag"); - assert!(selection.is_visible()); - assert_eq!( - selection.ordered_cells(), - ( - ( - (start_metrics.max_offset_from_bottom - end_metrics.offset_from_bottom) as u32, - 2, - ), - (start_metrics.max_offset_from_bottom as u32, 2), - ) - ); - } - - #[tokio::test] - async fn releasing_dragged_selection_clears_highlight_after_copy() { - let mut app = app_for_mouse_test(); - let mut ws = Workspace::test_new("test"); - let pane_id = ws.tabs[0].root_pane; - let pane_infos = ws.tabs[0].layout.panes(Rect::new(26, 2, 80, 18)); - let info = pane_infos[0].clone(); - ws.tabs[0].runtimes.insert( - pane_id, - crate::pane::PaneRuntime::test_with_scrollback_bytes( - info.inner_rect.width, - info.inner_rect.height, - 16 * 1024, - &numbered_lines_bytes(64), - ), - ); - - app.state.workspaces = vec![ws]; - app.state.active = Some(0); - app.state.selected = 0; - app.state.mode = Mode::Terminal; - app.state.view.pane_infos = pane_infos; - - let row = info.inner_rect.y; - let start_col = info.inner_rect.x + 1; - let end_col = info.inner_rect.x + 4; - - app.handle_mouse(mouse( - MouseEventKind::Down(MouseButton::Left), - start_col, - row, - )); - app.handle_mouse(mouse(MouseEventKind::Drag(MouseButton::Left), end_col, row)); - assert!(app.state.selection.is_some()); - - app.handle_mouse(mouse(MouseEventKind::Up(MouseButton::Left), end_col, row)); - - assert!(app.state.selection.is_none()); - } - - #[tokio::test] - async fn wheel_scroll_keeps_in_progress_selection_and_extends_it() { - let mut app = app_for_mouse_test(); - let mut ws = Workspace::test_new("test"); - let pane_id = ws.tabs[0].root_pane; - let pane_infos = ws.tabs[0].layout.panes(Rect::new(26, 2, 80, 18)); - let info = pane_infos[0].clone(); - ws.tabs[0].runtimes.insert( - pane_id, - crate::pane::PaneRuntime::test_with_scrollback_bytes( - info.inner_rect.width, - info.inner_rect.height, - 16 * 1024, - &numbered_lines_bytes(64), - ), - ); - - app.state.workspaces = vec![ws]; - app.state.active = Some(0); - app.state.selected = 0; - app.state.mode = Mode::Terminal; - app.state.view.pane_infos = pane_infos; - - let start_metrics = app.state.workspaces[0] - .runtime(pane_id) - .and_then(crate::pane::PaneRuntime::scroll_metrics) - .expect("initial scroll metrics"); - let top_row = info.inner_rect.y; - let col = info.inner_rect.x + 2; - - app.handle_mouse(mouse(MouseEventKind::Down(MouseButton::Left), col, top_row)); - app.handle_mouse(mouse(MouseEventKind::ScrollUp, col, top_row)); - - let end_metrics = app.state.workspaces[0] - .runtime(pane_id) - .and_then(crate::pane::PaneRuntime::scroll_metrics) - .expect("scroll metrics after wheel"); - assert_eq!( - end_metrics.offset_from_bottom, - start_metrics.offset_from_bottom + 3 - ); - - let selection = app.state.selection.as_ref().expect("selection after wheel"); - assert!(selection.is_visible()); - assert_eq!( - selection.ordered_cells(), - ( - ( - (start_metrics.max_offset_from_bottom - end_metrics.offset_from_bottom) as u32, - 2, - ), - (start_metrics.max_offset_from_bottom as u32, 2), - ) - ); - } - - #[test] - fn clicking_workspace_switches_on_mouse_up() { - let mut app = app_for_mouse_test(); - app.state.workspaces = vec![Workspace::test_new("a"), Workspace::test_new("b")]; - app.state.active = Some(0); - app.state.selected = 0; - crate::ui::compute_view(&mut app.state, Rect::new(0, 0, 106, 20)); - let target_row = app.state.view.workspace_card_areas[1].rect.y; - - app.handle_mouse(mouse( - MouseEventKind::Down(MouseButton::Left), - 2, - target_row, - )); - assert_eq!(app.state.active, Some(0)); - assert!(app.state.workspace_press.is_some()); - - app.handle_mouse(mouse(MouseEventKind::Up(MouseButton::Left), 2, target_row)); - assert_eq!(app.state.active, Some(1)); - assert_eq!(app.state.selected, 1); - assert!(app.state.workspace_press.is_none()); - let snapshot = capture_snapshot(&app.state); - assert_eq!(snapshot.active, Some(1)); - assert_eq!(snapshot.selected, 1); - } - - #[test] - fn dragging_workspace_reorders_without_changing_identity() { - let mut app = app_for_mouse_test(); - app.state.workspaces = vec![ - Workspace::test_new("a"), - Workspace::test_new("b"), - Workspace::test_new("c"), - ]; - let active_id = app.state.workspaces[1].id.clone(); - let selected_id = app.state.workspaces[2].id.clone(); - app.state.active = Some(1); - app.state.selected = 2; - crate::ui::compute_view(&mut app.state, Rect::new(0, 0, 106, 20)); - let source_row = app.state.view.workspace_card_areas[1].rect.y; - let target_row = crate::ui::workspace_drop_indicator_row( - &app.state.view.workspace_card_areas, - app.state.workspace_list_rect(), - 0, - ) - .unwrap(); - - app.handle_mouse(mouse( - MouseEventKind::Down(MouseButton::Left), - 2, - source_row, - )); - app.handle_mouse(mouse( - MouseEventKind::Drag(MouseButton::Left), - 2, - target_row, - )); - assert!(matches!( - app.state.drag.as_ref().map(|drag| &drag.target), - Some(DragTarget::WorkspaceReorder { - source_ws_idx: 1, - insert_idx: Some(0), - }) - )); - app.handle_mouse(mouse(MouseEventKind::Up(MouseButton::Left), 2, target_row)); - - let names: Vec<_> = app - .state - .workspaces - .iter() - .map(|ws| ws.display_name()) - .collect(); - assert_eq!(names, vec!["b", "a", "c"]); - assert_eq!(app.state.active, Some(0)); - assert_eq!(app.state.selected, 2); - assert_eq!(app.state.workspaces[0].id, active_id); - assert_eq!(app.state.workspaces[2].id, selected_id); - let snapshot = capture_snapshot(&app.state); - let captured_names: Vec<_> = snapshot - .workspaces - .iter() - .map(|ws| ws.custom_name.clone().unwrap()) - .collect(); - assert_eq!(captured_names, vec!["b", "a", "c"]); - } - - #[test] - fn clicking_tab_scroll_button_reveals_hidden_tabs_without_renaming() { - let mut app = app_for_mouse_test(); - let mut ws = Workspace::test_new("test"); - ws.test_add_tab(Some("logs")); - ws.test_add_tab(Some("review")); - ws.test_add_tab(Some("ops")); - ws.test_add_tab(Some("notes")); - app.state.workspaces = vec![ws]; - app.state.active = Some(0); - app.state.selected = 0; - crate::ui::compute_view(&mut app.state, Rect::new(0, 0, 52, 20)); - - let right = app.state.view.tab_scroll_right_hit_area; - assert!(right.width > 0); - - app.handle_mouse(mouse( - MouseEventKind::Down(MouseButton::Left), - right.x + 1, - right.y, - )); - - assert_eq!(app.state.tab_scroll, 1); - assert!(!app.state.tab_scroll_follow_active); - assert_eq!(app.state.workspaces[0].active_tab, 0); - assert_eq!(app.state.view.tab_hit_areas[0].width, 0); - assert!(app.state.workspaces[0].tabs[0].custom_name.is_none()); - assert_eq!( - app.state.workspaces[0].tabs[1].custom_name.as_deref(), - Some("logs") - ); - } - - #[test] - fn clicking_last_visible_tab_at_right_edge_does_not_overscroll() { - let mut app = app_for_mouse_test(); - let mut ws = Workspace::test_new("test"); - for name in [ - "one", "two", "three", "four", "five", "six", "seven", "eight", - ] { - ws.test_add_tab(Some(name)); - } - app.state.workspaces = vec![ws]; - app.state.active = Some(0); - app.state.selected = 0; - app.state.tab_scroll = usize::MAX; - app.state.tab_scroll_follow_active = false; - crate::ui::compute_view(&mut app.state, Rect::new(0, 0, 52, 20)); - - let last_idx = app.state.workspaces[0].tabs.len() - 1; - let target = app.state.view.tab_hit_areas[last_idx]; - let clamped_scroll = app.state.tab_scroll; - assert!(target.width > 0, "last tab should already be visible"); - - app.handle_mouse(mouse( - MouseEventKind::Down(MouseButton::Left), - target.x + 1, - target.y, - )); - app.handle_mouse(mouse( - MouseEventKind::Up(MouseButton::Left), - target.x + 1, - target.y, - )); - - assert_eq!(app.state.workspaces[0].active_tab, last_idx); - assert_eq!(app.state.tab_scroll, clamped_scroll); - assert!(app.state.view.tab_hit_areas[last_idx].width > 0); - } - - #[test] - fn dragging_tab_reorders_auto_and_custom_names_without_materializing_numbers() { - let mut app = app_for_mouse_test(); - let mut ws = Workspace::test_new("test"); - ws.test_add_tab(Some("foo")); - ws.test_add_tab(None); - let moved_root = ws.tabs[0].root_pane; - app.state.workspaces = vec![ws]; - app.state.active = Some(0); - app.state.selected = 0; - crate::ui::compute_view(&mut app.state, Rect::new(0, 0, 106, 20)); - - let source = app.state.view.tab_hit_areas[0]; - let last = app.state.view.tab_hit_areas[2]; - let drop_col = last.x + last.width; - - app.handle_mouse(mouse( - MouseEventKind::Down(MouseButton::Left), - source.x + 1, - source.y, - )); - app.handle_mouse(mouse( - MouseEventKind::Drag(MouseButton::Left), - drop_col, - source.y, - )); - assert!(matches!( - app.state.drag.as_ref().map(|drag| &drag.target), - Some(DragTarget::TabReorder { - ws_idx: 0, - source_tab_idx: 0, - insert_idx: Some(3), - }) - )); - app.handle_mouse(mouse( - MouseEventKind::Up(MouseButton::Left), - drop_col, - source.y, - )); - - let labels: Vec<_> = app.state.workspaces[0] - .tabs - .iter() - .map(|tab| tab.display_name()) - .collect(); - assert_eq!(labels, vec!["foo", "2", "3"]); - assert_eq!( - app.state.workspaces[0].tabs[0].custom_name.as_deref(), - Some("foo") - ); - assert!(app.state.workspaces[0].tabs[1].custom_name.is_none()); - assert!(app.state.workspaces[0].tabs[2].custom_name.is_none()); - assert_eq!(app.state.workspaces[0].tabs[2].root_pane, moved_root); - assert_eq!(app.state.workspaces[0].active_tab, 2); - } - - #[test] - fn top_drop_slot_is_distinct_from_gap_below_first_workspace() { - let mut app = app_for_mouse_test(); - app.state.workspaces = vec![Workspace::test_new("a"), Workspace::test_new("b")]; - crate::ui::compute_view(&mut app.state, Rect::new(0, 0, 106, 20)); - - assert_eq!(app.state.workspace_drop_index_at_row(0), Some(0)); - assert_eq!(app.state.workspace_drop_index_at_row(1), Some(0)); - assert_eq!(app.state.workspace_drop_index_at_row(2), Some(0)); - assert_eq!(app.state.workspace_drop_index_at_row(3), Some(1)); - } - - #[test] - fn bottom_drop_slot_stays_below_last_workspace_not_footer() { - let mut app = app_for_mouse_test(); - app.state.workspaces = vec![ - Workspace::test_new("a"), - Workspace::test_new("b"), - Workspace::test_new("c"), - ]; - crate::ui::compute_view(&mut app.state, Rect::new(0, 0, 106, 20)); - - let cards = &app.state.view.workspace_card_areas; - let bottom_slot = crate::ui::workspace_drop_indicator_row( - cards, - app.state.workspace_list_rect(), - cards.len(), - ) - .unwrap(); - - let last = cards.last().unwrap().rect; - assert_eq!(bottom_slot, last.y + last.height); - assert!(bottom_slot < app.state.sidebar_footer_rect().y.saturating_sub(1)); - } - - #[test] - fn dragging_sidebar_divider_sets_manual_width() { - let mut app = app_for_mouse_test(); - - app.handle_mouse(mouse(MouseEventKind::Down(MouseButton::Left), 25, 5)); - app.handle_mouse(mouse(MouseEventKind::Drag(MouseButton::Left), 30, 5)); - - assert_eq!(app.state.sidebar_width, 31); - let snapshot = capture_snapshot(&app.state); - assert_eq!(snapshot.sidebar_width, Some(31)); - } - - #[test] - fn dragging_sidebar_section_divider_sets_split_ratio() { - let mut app = app_for_mouse_test(); - let divider = crate::ui::sidebar_section_divider_rect( - app.state.view.sidebar_rect, - app.state.sidebar_section_split, - ); - - app.handle_mouse(mouse( - MouseEventKind::Down(MouseButton::Left), - divider.x + 1, - divider.y, - )); - app.handle_mouse(mouse( - MouseEventKind::Drag(MouseButton::Left), - divider.x + 1, - divider.y + 4, - )); - - assert!(app.state.sidebar_section_split > 0.5); - let snapshot = capture_snapshot(&app.state); - assert_eq!( - snapshot.sidebar_section_split, - Some(app.state.sidebar_section_split) - ); - } - - #[test] - fn dragging_pane_split_updates_captured_layout_ratio() { - let mut app = app_for_mouse_test(); - app.state.workspaces = vec![Workspace::test_new("test")]; - app.state.active = Some(0); - app.state.selected = 0; - app.state.workspaces[0].test_split(Direction::Horizontal); - crate::ui::compute_view(&mut app.state, Rect::new(0, 0, 106, 20)); - let border = app.state.view.split_borders[0].clone(); - let before = capture_snapshot(&app.state); - let drag_row = border.area.y.saturating_add(1); - - app.handle_mouse(mouse( - MouseEventKind::Down(MouseButton::Left), - border.pos, - drag_row, - )); - app.handle_mouse(mouse( - MouseEventKind::Drag(MouseButton::Left), - border.pos.saturating_add(6), - drag_row, - )); - - let after = capture_snapshot(&app.state); - assert_ne!(root_layout_ratio(&before), root_layout_ratio(&after)); - } - - #[test] - fn double_clicking_sidebar_divider_resets_default_width() { - let mut app = app_for_mouse_test(); - app.state.default_sidebar_width = 26; - app.state.sidebar_width = 30; - - app.handle_mouse(mouse(MouseEventKind::Down(MouseButton::Left), 25, 5)); - app.handle_mouse(mouse(MouseEventKind::Up(MouseButton::Left), 25, 5)); - app.handle_mouse(mouse(MouseEventKind::Down(MouseButton::Left), 25, 5)); - - assert_eq!(app.state.sidebar_width, 26); - assert!(app.state.drag.is_none()); - let snapshot = capture_snapshot(&app.state); - assert_eq!(snapshot.sidebar_width, Some(26)); - } - - #[test] - fn wheel_routing_prefers_mouse_reporting() { - let input_state = crate::pane::InputState { - alternate_screen: true, - application_cursor: false, - bracketed_paste: false, - focus_reporting: false, - mouse_protocol_mode: crate::input::MouseProtocolMode::ButtonMotion, - mouse_protocol_encoding: crate::input::MouseProtocolEncoding::Sgr, - mouse_alternate_scroll: true, - }; - - assert_eq!(wheel_routing(input_state), WheelRouting::MouseReport); - } - - #[test] - fn wheel_routing_uses_alternate_scroll_in_fullscreen_without_mouse_reporting() { - let input_state = crate::pane::InputState { - alternate_screen: true, - application_cursor: false, - bracketed_paste: false, - focus_reporting: false, - mouse_protocol_mode: crate::input::MouseProtocolMode::None, - mouse_protocol_encoding: crate::input::MouseProtocolEncoding::Default, - mouse_alternate_scroll: true, - }; - - assert_eq!(wheel_routing(input_state), WheelRouting::AlternateScroll); - } - - #[test] - fn wheel_routing_falls_back_to_host_scrollback() { - let input_state = crate::pane::InputState { - alternate_screen: false, - application_cursor: false, - bracketed_paste: false, - focus_reporting: false, - mouse_protocol_mode: crate::input::MouseProtocolMode::None, - mouse_protocol_encoding: crate::input::MouseProtocolEncoding::Default, - mouse_alternate_scroll: true, - }; - - assert_eq!(wheel_routing(input_state), WheelRouting::HostScroll); - } - - #[tokio::test] - async fn clicking_unfocused_pane_with_mouse_reporting_focuses_it_via_left_button() { - let mut app = app_for_mouse_test(); - let mut ws = Workspace::test_new("test"); - let first_pane = ws.tabs[0].root_pane; - let second_pane = ws.test_split(ratatui::layout::Direction::Vertical); - - let terminal_area = Rect::new(26, 2, 80, 18); - let pane_infos = ws.tabs[0].layout.panes(terminal_area); - let first_info = pane_infos - .iter() - .find(|p| p.id == first_pane) - .expect("first pane info") - .clone(); - let second_info = pane_infos - .iter() - .find(|p| p.id == second_pane) - .expect("second pane info") - .clone(); - - ws.tabs[0].runtimes.insert( - first_pane, - crate::pane::PaneRuntime::test_with_screen_bytes( - first_info.inner_rect.width.max(1), - first_info.inner_rect.height.max(1), - b"", - ), - ); - ws.tabs[0].runtimes.insert( - second_pane, - crate::pane::PaneRuntime::test_with_screen_bytes( - second_info.inner_rect.width.max(1), - second_info.inner_rect.height.max(1), - b"\x1b[?1002h", - ), - ); - - ws.tabs[0].layout.focus_pane(first_pane); - - app.state.workspaces = vec![ws]; - app.state.active = Some(0); - app.state.selected = 0; - app.state.mode = Mode::Terminal; - app.state.view.pane_infos = pane_infos; - - assert_eq!( - app.state.workspaces[0].tabs[0].layout.focused(), - first_pane, - "first pane should be focused before click" - ); - - app.handle_mouse(mouse( - MouseEventKind::Down(MouseButton::Left), - second_info.inner_rect.x + 2, - second_info.inner_rect.y + 2, - )); - - assert_eq!( - app.state.workspaces[0].tabs[0].layout.focused(), - second_pane, - "left-clicking a pane with mouse reporting should move focus to it" - ); - assert_eq!(app.state.mode, Mode::Terminal); - } - - #[tokio::test] - async fn clicking_unfocused_pane_with_mouse_reporting_focuses_it_via_right_button() { - let mut app = app_for_mouse_test(); - let mut ws = Workspace::test_new("test"); - let first_pane = ws.tabs[0].root_pane; - let second_pane = ws.test_split(ratatui::layout::Direction::Vertical); - - let terminal_area = Rect::new(26, 2, 80, 18); - let pane_infos = ws.tabs[0].layout.panes(terminal_area); - let first_info = pane_infos - .iter() - .find(|p| p.id == first_pane) - .expect("first pane info") - .clone(); - let second_info = pane_infos - .iter() - .find(|p| p.id == second_pane) - .expect("second pane info") - .clone(); - - ws.tabs[0].runtimes.insert( - first_pane, - crate::pane::PaneRuntime::test_with_screen_bytes( - first_info.inner_rect.width.max(1), - first_info.inner_rect.height.max(1), - b"", - ), - ); - ws.tabs[0].runtimes.insert( - second_pane, - crate::pane::PaneRuntime::test_with_screen_bytes( - second_info.inner_rect.width.max(1), - second_info.inner_rect.height.max(1), - b"\x1b[?1002h", - ), - ); - - ws.tabs[0].layout.focus_pane(first_pane); - - app.state.workspaces = vec![ws]; - app.state.active = Some(0); - app.state.selected = 0; - app.state.mode = Mode::Terminal; - app.state.view.pane_infos = pane_infos; - - assert_eq!( - app.state.workspaces[0].tabs[0].layout.focused(), - first_pane, - "first pane should be focused before click" - ); - - app.handle_mouse(mouse( - MouseEventKind::Down(MouseButton::Right), - second_info.inner_rect.x + 2, - second_info.inner_rect.y + 2, - )); - - assert_eq!( - app.state.workspaces[0].tabs[0].layout.focused(), - second_pane, - "right-clicking a pane with mouse reporting should move focus to it" - ); - assert_eq!( - app.state.mode, - Mode::ContextMenu, - "right-click should enter ContextMenu mode" - ); - assert!( - app.state.context_menu.is_some(), - "right-click should populate context_menu state" - ); - } -} diff --git a/src/app/input/mod.rs b/src/app/input/mod.rs new file mode 100644 index 00000000..2f069fea --- /dev/null +++ b/src/app/input/mod.rs @@ -0,0 +1,321 @@ +//! Input handling — translates crossterm key/mouse events into state mutations. + +use crossterm::event::{KeyCode, KeyEvent, MouseButton, MouseEvent, MouseEventKind}; + +use crate::input::TerminalKey; +use ratatui::layout::Direction; + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +enum ScrollbarClickTarget { + Thumb { grab_row_offset: u16 }, + Track { offset_from_bottom: usize }, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[cfg(test)] +enum WheelRouting { + HostScroll, + MouseReport, + AlternateScroll, +} + +const WORKSPACE_DRAG_THRESHOLD: u16 = 1; +const TAB_DRAG_THRESHOLD: u16 = 1; + +mod modal; +mod mouse; +mod navigate; +mod overlays; +mod selection; +mod settings; +mod sidebar; +mod terminal; + +pub(crate) use self::{ + modal::{ + handle_confirm_close_key, handle_context_menu_key, handle_global_menu_key, + handle_keybind_help_key, handle_rename_key, handle_resize_key, + }, + navigate::{handle_navigate_key, terminal_direct_navigation_action}, +}; +use self::{ + modal::{ + modal_action_from_key, ModalAction, ONBOARDING_NOTIFICATION_ACTIONS, + ONBOARDING_WELCOME_ACTIONS, RELEASE_NOTES_ACTIONS, + }, + settings::SettingsAction, +}; +use super::state::{AppState, Mode}; +use super::App; + +// --------------------------------------------------------------------------- +// Key handling +// --------------------------------------------------------------------------- + +impl App { + pub(super) async fn handle_key(&mut self, key: TerminalKey) { + match self.state.mode { + Mode::Terminal => self.handle_terminal_key(key).await, + _ => { + let key = key.as_key_event(); + match self.state.mode { + Mode::Onboarding => self.handle_onboarding_key(key), + Mode::ReleaseNotes => self.handle_release_notes_key(key), + Mode::Navigate => self.handle_navigate_key(key), + Mode::RenameWorkspace | Mode::RenameTab => { + handle_rename_key(&mut self.state, key) + } + Mode::Resize => handle_resize_key(&mut self.state, key), + Mode::ConfirmClose => handle_confirm_close_key(&mut self.state, key), + Mode::ContextMenu => handle_context_menu_key(&mut self.state, key), + Mode::Settings => self.handle_settings_key(key), + Mode::GlobalMenu => handle_global_menu_key(&mut self.state, key), + Mode::KeybindHelp => handle_keybind_help_key(&mut self.state, key), + Mode::Terminal => unreachable!(), + } + } + } + } + + pub(super) async fn handle_paste(&mut self, text: String) { + if self.state.mode != Mode::Terminal { + return; + } + if let Some(ws) = self.state.active.and_then(|i| self.state.workspaces.get(i)) { + if let Some(rt) = ws.focused_runtime() { + let _ = rt.send_paste(text).await; + } + } + } + + pub(crate) fn handle_onboarding_key(&mut self, key: KeyEvent) { + match self.state.onboarding_step { + 0 => match key.code { + KeyCode::Right | KeyCode::Char('l') => { + self.state.onboarding_step = 1; + } + _ => match modal_action_from_key(&key, ONBOARDING_WELCOME_ACTIONS) { + Some(ModalAction::Continue) => self.state.onboarding_step = 1, + _ => {} + }, + }, + _ => match key.code { + KeyCode::Up | KeyCode::Char('k') => self.state.onboarding_list.move_prev(), + KeyCode::Down | KeyCode::Char('j') => self.state.onboarding_list.move_next(4), + KeyCode::Left | KeyCode::Char('h') => { + self.state.onboarding_step = 0; + } + KeyCode::Char(c) if ('1'..='4').contains(&c) => { + self.state + .onboarding_list + .select((c as usize) - ('1' as usize)); + } + _ => match modal_action_from_key(&key, ONBOARDING_NOTIFICATION_ACTIONS) { + Some(ModalAction::Back) => self.state.onboarding_step = 0, + Some(ModalAction::Save) => self.complete_onboarding(), + _ => {} + }, + }, + } + } + + pub(crate) fn handle_release_notes_key(&mut self, key: KeyEvent) { + match key.code { + KeyCode::Up | KeyCode::Char('k') => self.scroll_release_notes(-1), + KeyCode::Down | KeyCode::Char('j') => self.scroll_release_notes(1), + KeyCode::PageUp => self.scroll_release_notes(-8), + KeyCode::PageDown => self.scroll_release_notes(8), + KeyCode::Home => { + if let Some(notes) = &mut self.state.release_notes { + notes.scroll = 0; + } + } + KeyCode::End => { + let max_scroll = self.state.release_notes_max_scroll(); + if let Some(notes) = &mut self.state.release_notes { + notes.scroll = max_scroll; + } + } + _ => match modal_action_from_key(&key, RELEASE_NOTES_ACTIONS) { + Some(ModalAction::Close) => self.dismiss_release_notes(), + _ => {} + }, + } + } + + pub(super) fn handle_mouse(&mut self, mouse: MouseEvent) { + if self.handle_overlay_mouse(mouse) { + return; + } + + if matches!(mouse.kind, MouseEventKind::Down(MouseButton::Left)) + && self.state.on_sidebar_divider(mouse.column, mouse.row) + { + let now = std::time::Instant::now(); + let is_double_click = self + .last_sidebar_divider_click + .is_some_and(|last| now.duration_since(last) <= super::SIDEBAR_DOUBLE_CLICK_WINDOW); + self.last_sidebar_divider_click = Some(now); + + if is_double_click { + self.state.sidebar_width = self.state.default_sidebar_width; + self.state.sidebar_width_auto = false; + self.state.mark_session_dirty(); + self.state.drag = None; + return; + } + } + + if let Some(action) = self.state.handle_mouse(mouse) { + match action { + SettingsAction::SaveTheme(name) => self.save_theme(&name), + SettingsAction::SaveSound(enabled) => self.save_sound(enabled), + SettingsAction::SaveToast(enabled) => self.save_toast(enabled), + } + } + + if let Some(content) = self.state.request_clipboard_write.take() { + if self + .event_tx + .try_send(crate::events::AppEvent::ClipboardWrite { content }) + .is_err() + { + tracing::warn!("failed to queue clipboard write event"); + } + } + } +} + +// --------------------------------------------------------------------------- +// Mouse handling +// --------------------------------------------------------------------------- + +// Note: split_pane needs runtime (event_tx for PTY spawn), so it lives on App +impl AppState { + pub(crate) fn split_pane(&mut self, direction: Direction) { + // Actual PTY spawning happens in Workspace::split_focused + // which needs events channel — this is called from navigate_key + // where we don't have async context, so the workspace handles it + let (rows, cols) = self.estimate_pane_size(); + let new_rows = (rows / 2).max(4); + let new_cols = (cols / 2).max(10); + + let cwd = self + .active + .and_then(|i| self.workspaces.get(i)) + .and_then(|ws| ws.focused_runtime()) + .and_then(|rt| rt.cwd()); + + if let Some(ws) = self.active.and_then(|i| self.workspaces.get_mut(i)) { + if let Ok(new_id) = ws.split_focused( + direction, + new_rows, + new_cols, + cwd, + self.pane_scrollback_limit_bytes, + self.host_terminal_theme, + ) { + ws.layout.focus_pane(new_id); + self.mark_session_dirty(); + self.mode = Mode::Terminal; + } + } + } +} + +#[cfg(test)] +fn state_with_workspaces(names: &[&str]) -> AppState { + let mut state = AppState::test_new(); + state.workspaces = names + .iter() + .map(|name| crate::workspace::Workspace::test_new(name)) + .collect(); + if !state.workspaces.is_empty() { + state.active = Some(0); + state.selected = 0; + state.mode = Mode::Navigate; + } + state +} + +#[cfg(test)] +fn app_for_mouse_test() -> App { + let (_api_tx, api_rx) = tokio::sync::mpsc::unbounded_channel(); + let mut app = App::new( + &crate::config::Config::default(), + true, + None, + None, + api_rx, + crate::api::EventHub::default(), + ); + app.state.mode = Mode::Terminal; + app.state.update_available = None; + app.state.latest_release_notes_available = false; + app.state.view.sidebar_rect = ratatui::layout::Rect::new(0, 0, 26, 20); + app.state.view.terminal_area = ratatui::layout::Rect::new(26, 0, 80, 20); + app +} + +#[cfg(test)] +fn mouse( + kind: crossterm::event::MouseEventKind, + col: u16, + row: u16, +) -> crossterm::event::MouseEvent { + crossterm::event::MouseEvent { + kind, + column: col, + row, + modifiers: crossterm::event::KeyModifiers::empty(), + } +} + +#[cfg(test)] +fn numbered_lines_bytes(count: usize) -> Vec<u8> { + (0..count) + .map(|i| format!("{i:06}\r\n")) + .collect::<String>() + .into_bytes() +} + +#[cfg(test)] +fn capture_snapshot(state: &AppState) -> crate::persist::SessionSnapshot { + crate::persist::capture( + &state.workspaces, + state.active, + state.selected, + state.agent_panel_scope, + state.sidebar_width, + state.sidebar_section_split, + ) +} + +#[cfg(test)] +fn root_layout_ratio(snapshot: &crate::persist::SessionSnapshot) -> Option<f32> { + match &snapshot.workspaces.first()?.tabs.first()?.layout { + crate::persist::LayoutSnapshot::Split { ratio, .. } => Some(*ratio), + crate::persist::LayoutSnapshot::Pane(_) => None, + } +} + +#[cfg(test)] +fn unique_temp_path(name: &str) -> std::path::PathBuf { + let nanos = std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .map(|d| d.as_nanos()) + .unwrap_or(0); + std::env::temp_dir().join(format!("herdr-{name}-{}-{nanos}", std::process::id())) +} + +#[cfg(test)] +fn wait_for_file(path: &std::path::Path) -> String { + let deadline = std::time::Instant::now() + std::time::Duration::from_secs(2); + while std::time::Instant::now() < deadline { + if let Ok(content) = std::fs::read_to_string(path) { + return content; + } + std::thread::sleep(std::time::Duration::from_millis(20)); + } + panic!("timed out waiting for {}", path.display()); +} diff --git a/src/app/input/modal.rs b/src/app/input/modal.rs new file mode 100644 index 00000000..2ba9b6f4 --- /dev/null +++ b/src/app/input/modal.rs @@ -0,0 +1,739 @@ +use crossterm::event::{KeyCode, KeyEvent}; +use ratatui::layout::{Direction, Rect}; + +use crate::{ + app::state::{key_matches, AppState, ContextMenuKind, ContextMenuState, MenuListState, Mode}, + layout::NavDirection, +}; + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub(super) enum ModalAction { + Continue, + Back, + Save, + Clear, + Cancel, + Confirm, + Apply, + Close, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub(super) enum ModalKeyBinding { + Enter, + Esc, + CtrlC, +} + +impl ModalKeyBinding { + fn matches(self, key: &KeyEvent) -> bool { + match self { + Self::Enter => key.code == KeyCode::Enter, + Self::Esc => key.code == KeyCode::Esc, + Self::CtrlC => { + key.code == KeyCode::Char('c') + && key.modifiers == crossterm::event::KeyModifiers::CONTROL + } + } + } +} + +#[derive(Debug, Clone, Copy)] +pub(super) struct ModalActionSpec<A> { + pub action: A, + pub bindings: &'static [ModalKeyBinding], +} + +pub(super) fn modal_action_from_key<A: Copy>( + key: &KeyEvent, + specs: &[ModalActionSpec<A>], +) -> Option<A> { + specs + .iter() + .find(|spec| spec.bindings.iter().any(|binding| binding.matches(key))) + .map(|spec| spec.action) +} + +pub(super) fn modal_action_from_buttons<A: Copy>( + col: u16, + row: u16, + buttons: &[(Rect, A)], +) -> Option<A> { + buttons.iter().find_map(|(rect, action)| { + (col >= rect.x && col < rect.x + rect.width && row >= rect.y && row < rect.y + rect.height) + .then_some(*action) + }) +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub(crate) enum GlobalMenuAction { + Quit, + WhatsNew, + Keybinds, + ReloadKeybinds, + Settings, +} + +pub(super) fn global_menu_actions(state: &AppState) -> Vec<GlobalMenuAction> { + let mut actions = vec![ + GlobalMenuAction::Settings, + GlobalMenuAction::Keybinds, + GlobalMenuAction::ReloadKeybinds, + ]; + if state.update_available.is_some() || state.latest_release_notes_available { + actions.push(GlobalMenuAction::WhatsNew); + } + actions.push(GlobalMenuAction::Quit); + actions +} + +pub(super) fn open_global_menu(state: &mut AppState) { + state.global_menu = MenuListState::new(0); + state.mode = Mode::GlobalMenu; +} + +pub(super) fn open_keybind_help(state: &mut AppState) { + state.keybind_help.scroll = 0; + state.mode = Mode::KeybindHelp; +} + +fn open_update_release_notes(state: &mut AppState) { + let Some(notes) = crate::release_notes::load_latest() else { + return; + }; + + state.release_notes = Some(crate::app::state::ReleaseNotesState { + version: notes.version, + body: notes.body, + scroll: 0, + preview: notes.preview, + }); + state.mode = Mode::ReleaseNotes; +} + +pub(super) fn request_quit_or_detach(state: &mut AppState) { + if state.quit_detaches { + state.detach_requested = true; + } else { + state.should_quit = true; + } +} + +pub(super) fn apply_global_menu_action(state: &mut AppState, action: GlobalMenuAction) { + match action { + GlobalMenuAction::Quit => request_quit_or_detach(state), + GlobalMenuAction::WhatsNew => open_update_release_notes(state), + GlobalMenuAction::Keybinds => open_keybind_help(state), + GlobalMenuAction::ReloadKeybinds => { + state.request_reload_keybinds = true; + leave_modal(state); + } + GlobalMenuAction::Settings => super::settings::open_settings(state), + } +} + +pub(crate) fn handle_global_menu_key(state: &mut AppState, key: KeyEvent) { + let actions = global_menu_actions(state); + match key.code { + KeyCode::Esc => leave_modal(state), + KeyCode::Up | KeyCode::Char('k') => state.global_menu.move_prev(), + KeyCode::Down | KeyCode::Char('j') => state.global_menu.move_next(actions.len()), + KeyCode::Enter => { + if let Some(action) = actions.get(state.global_menu.highlighted).copied() { + apply_global_menu_action(state, action); + } + } + _ => {} + } +} + +pub(crate) fn handle_keybind_help_key(state: &mut AppState, key: KeyEvent) { + match key.code { + KeyCode::Up | KeyCode::Char('k') => state.scroll_keybind_help(-1), + KeyCode::Down | KeyCode::Char('j') => state.scroll_keybind_help(1), + KeyCode::PageUp => state.scroll_keybind_help(-8), + KeyCode::PageDown => state.scroll_keybind_help(8), + KeyCode::Home => state.keybind_help.scroll = 0, + KeyCode::End => state.keybind_help.scroll = state.keybind_help_max_scroll(), + KeyCode::Esc | KeyCode::Enter | KeyCode::Char('?') => leave_modal(state), + _ => {} + } +} + +pub(super) fn open_rename_workspace(state: &mut AppState, ws_idx: usize) { + state.selected = ws_idx; + state.name_input = state.workspaces[ws_idx].display_name(); + state.name_input_replace_on_type = false; + state.mode = Mode::RenameWorkspace; +} + +pub(super) fn open_rename_active_tab(state: &mut AppState, replace_on_type: bool) { + state.creating_new_tab = false; + state.requested_new_tab_name = None; + if let Some(ws) = state.active.and_then(|i| state.workspaces.get(i)) { + if let Some(name) = ws.active_tab_display_name() { + state.name_input = name; + state.name_input_replace_on_type = replace_on_type; + state.mode = Mode::RenameTab; + } + } +} + +fn next_new_tab_default_name(state: &AppState) -> String { + state + .active + .and_then(|i| state.workspaces.get(i)) + .map(|ws| (ws.tabs.len() + 1).to_string()) + .unwrap_or_else(|| "1".to_string()) +} + +pub(super) fn open_new_tab_dialog(state: &mut AppState) { + state.creating_new_tab = true; + state.requested_new_tab_name = None; + state.name_input = next_new_tab_default_name(state); + state.name_input_replace_on_type = true; + state.mode = Mode::RenameTab; +} + +pub(super) fn leave_modal(state: &mut AppState) { + if state.active.is_some() { + state.mode = Mode::Terminal; + } else { + state.mode = Mode::Navigate; + } +} + +pub(super) const ONBOARDING_WELCOME_ACTIONS: &[ModalActionSpec<ModalAction>] = &[ModalActionSpec { + action: ModalAction::Continue, + bindings: &[ModalKeyBinding::Enter], +}]; + +pub(super) const ONBOARDING_NOTIFICATION_ACTIONS: &[ModalActionSpec<ModalAction>] = &[ + ModalActionSpec { + action: ModalAction::Back, + bindings: &[ModalKeyBinding::Esc], + }, + ModalActionSpec { + action: ModalAction::Save, + bindings: &[ModalKeyBinding::Enter], + }, +]; + +pub(super) const RELEASE_NOTES_ACTIONS: &[ModalActionSpec<ModalAction>] = &[ModalActionSpec { + action: ModalAction::Close, + bindings: &[ModalKeyBinding::Enter, ModalKeyBinding::Esc], +}]; + +pub(super) const RENAME_ACTIONS: &[ModalActionSpec<ModalAction>] = &[ + ModalActionSpec { + action: ModalAction::Save, + bindings: &[ModalKeyBinding::Enter], + }, + ModalActionSpec { + action: ModalAction::Clear, + bindings: &[ModalKeyBinding::CtrlC], + }, + ModalActionSpec { + action: ModalAction::Cancel, + bindings: &[ModalKeyBinding::Esc], + }, +]; + +pub(super) const CONFIRM_CLOSE_ACTIONS: &[ModalActionSpec<ModalAction>] = &[ + ModalActionSpec { + action: ModalAction::Confirm, + bindings: &[ModalKeyBinding::Enter], + }, + ModalActionSpec { + action: ModalAction::Cancel, + bindings: &[ModalKeyBinding::Esc], + }, +]; + +pub(super) const SETTINGS_ACTIONS: &[ModalActionSpec<ModalAction>] = &[ + ModalActionSpec { + action: ModalAction::Apply, + bindings: &[ModalKeyBinding::Enter], + }, + ModalActionSpec { + action: ModalAction::Close, + bindings: &[ModalKeyBinding::Esc], + }, +]; + +pub(super) fn apply_rename_action(state: &mut AppState, action: ModalAction) { + match action { + ModalAction::Save => { + let new_name = if state.name_input.trim().is_empty() { + state.name_input.clone() + } else { + state.name_input.trim().to_string() + }; + match state.mode { + Mode::RenameWorkspace if !state.workspaces.is_empty() => { + if !new_name.is_empty() { + state.workspaces[state.selected].set_custom_name(new_name); + state.mark_session_dirty(); + } + } + Mode::RenameTab if state.creating_new_tab => { + state.request_new_tab = true; + let default_name = next_new_tab_default_name(state); + state.requested_new_tab_name = + if new_name.is_empty() || new_name == default_name { + None + } else { + Some(new_name) + }; + } + Mode::RenameTab => { + if let Some(ws) = state.active.and_then(|i| state.workspaces.get_mut(i)) { + if let Some(tab) = ws.active_tab_mut() { + let keep_auto_name = + tab.is_auto_named() && new_name == tab.number.to_string(); + if !new_name.is_empty() && !keep_auto_name { + tab.set_custom_name(new_name); + state.mark_session_dirty(); + } + } + } + } + _ => {} + } + state.creating_new_tab = false; + state.name_input.clear(); + state.name_input_replace_on_type = false; + leave_modal(state); + } + ModalAction::Clear => { + state.name_input.clear(); + state.name_input_replace_on_type = false; + } + ModalAction::Cancel => { + state.creating_new_tab = false; + state.requested_new_tab_name = None; + state.name_input.clear(); + state.name_input_replace_on_type = false; + leave_modal(state); + } + _ => {} + } +} + +pub(crate) fn handle_rename_key(state: &mut AppState, key: KeyEvent) { + if let Some(action) = modal_action_from_key(&key, RENAME_ACTIONS) { + apply_rename_action(state, action); + return; + } + + match key.code { + KeyCode::Backspace => { + if state.name_input_replace_on_type { + state.name_input.clear(); + state.name_input_replace_on_type = false; + } else { + state.name_input.pop(); + } + } + KeyCode::Char(c) => { + if state.name_input_replace_on_type { + state.name_input.clear(); + state.name_input_replace_on_type = false; + } + state.name_input.push(c); + } + _ => {} + } +} + +pub(crate) fn handle_resize_key(state: &mut AppState, key: KeyEvent) { + if key.code == KeyCode::Esc + || key.code == KeyCode::Enter + || key_matches( + &key, + state.keybinds.resize_mode.0, + state.keybinds.resize_mode.1, + ) + { + if state.active.is_some() { + state.mode = Mode::Terminal; + } else { + state.mode = Mode::Navigate; + } + return; + } + + match key.code { + KeyCode::Char('h') | KeyCode::Left => state.resize_pane(NavDirection::Left), + KeyCode::Char('l') | KeyCode::Right => state.resize_pane(NavDirection::Right), + KeyCode::Char('j') | KeyCode::Down => state.resize_pane(NavDirection::Down), + KeyCode::Char('k') | KeyCode::Up => state.resize_pane(NavDirection::Up), + _ => {} + } +} + +pub(super) fn open_confirm_close(state: &mut AppState) { + state.mode = Mode::ConfirmClose; +} + +pub(super) fn confirm_close_accept(state: &mut AppState) { + state.close_selected_workspace(); + if state.workspaces.is_empty() { + state.mode = Mode::Navigate; + } else { + state.mode = Mode::Terminal; + } +} + +pub(super) fn confirm_close_cancel(state: &mut AppState) { + state.mode = Mode::Navigate; +} + +pub(crate) fn handle_confirm_close_key(state: &mut AppState, key: KeyEvent) { + match modal_action_from_key(&key, CONFIRM_CLOSE_ACTIONS) { + Some(ModalAction::Confirm) => confirm_close_accept(state), + Some(ModalAction::Cancel) => confirm_close_cancel(state), + _ => {} + } +} + +pub(super) fn apply_context_menu_action(state: &mut AppState, menu: ContextMenuState, idx: usize) { + let item = menu.items().get(idx).copied(); + match (menu.kind, item) { + (ContextMenuKind::Workspace { ws_idx }, Some("Rename")) => { + open_rename_workspace(state, ws_idx); + } + (ContextMenuKind::Workspace { ws_idx }, Some("Close")) => { + state.selected = ws_idx; + if state.confirm_close { + open_confirm_close(state); + } else { + state.close_selected_workspace(); + state.mode = Mode::Navigate; + } + } + (ContextMenuKind::Tab { ws_idx, tab_idx }, Some("New tab")) => { + state.selected = ws_idx; + state.active = Some(ws_idx); + state.switch_tab(tab_idx); + open_new_tab_dialog(state); + } + (ContextMenuKind::Tab { ws_idx, tab_idx }, Some("Rename")) => { + state.selected = ws_idx; + state.active = Some(ws_idx); + state.switch_tab(tab_idx); + open_rename_active_tab(state, false); + } + (ContextMenuKind::Tab { ws_idx, tab_idx }, Some("Close")) => { + state.selected = ws_idx; + state.active = Some(ws_idx); + state.switch_tab(tab_idx); + state.close_tab(); + state.mode = if state.active.is_some() { + Mode::Terminal + } else { + Mode::Navigate + }; + } + (ContextMenuKind::Pane, Some("Split vertical")) => { + state.split_pane(Direction::Horizontal); + state.mode = Mode::Terminal; + } + (ContextMenuKind::Pane, Some("Split horizontal")) => { + state.split_pane(Direction::Vertical); + state.mode = Mode::Terminal; + } + (ContextMenuKind::Pane, Some("Fullscreen")) => { + state.toggle_fullscreen(); + state.mode = Mode::Terminal; + } + (ContextMenuKind::Pane, Some("Close pane")) => { + state.close_pane(); + state.mode = if state.active.is_some() { + Mode::Terminal + } else { + Mode::Navigate + }; + } + _ => leave_modal(state), + } +} + +pub(crate) fn handle_context_menu_key(state: &mut AppState, key: KeyEvent) { + match key.code { + KeyCode::Esc => { + state.context_menu = None; + leave_modal(state); + } + KeyCode::Up => { + if let Some(menu) = &mut state.context_menu { + menu.list.move_prev(); + } + } + KeyCode::Down => { + if let Some(menu) = &mut state.context_menu { + menu.list.move_next(menu.items().len()); + } + } + KeyCode::Enter => { + if let Some(menu) = state.context_menu.take() { + let idx = menu.list.highlighted; + apply_context_menu_action(state, menu, idx); + } + } + _ => {} + } +} + +impl AppState { + pub(super) fn global_menu_item_at(&self, col: u16, row: u16) -> Option<GlobalMenuAction> { + let rect = self.global_menu_rect(); + if col <= rect.x + || col >= rect.x + rect.width.saturating_sub(1) + || row <= rect.y + || row >= rect.y + rect.height.saturating_sub(1) + { + return None; + } + let idx = (row - rect.y - 1) as usize; + global_menu_actions(self).get(idx).copied() + } +} + +#[cfg(test)] +mod tests { + use crossterm::event::{KeyCode, KeyEvent, KeyModifiers}; + use ratatui::layout::Rect; + + use super::super::{capture_snapshot, state_with_workspaces}; + use super::*; + + #[test] + fn custom_resize_key_exits_resize_mode() { + let mut state = state_with_workspaces(&["test"]); + state.mode = Mode::Resize; + state.keybinds.resize_mode = (KeyCode::Char('g'), KeyModifiers::empty()); + state.keybinds.resize_mode_label = "g".into(); + + handle_resize_key( + &mut state, + KeyEvent::new(KeyCode::Char('g'), KeyModifiers::empty()), + ); + + assert_eq!(state.mode, Mode::Terminal); + } + + #[test] + fn rename_modal_keyboard_and_mouse_share_actions() { + let mut state = state_with_workspaces(&["test"]); + state.mode = Mode::RenameWorkspace; + state.name_input = "hello".into(); + + handle_rename_key( + &mut state, + KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL), + ); + assert!(state.name_input.is_empty()); + + state.name_input = "renamed".into(); + handle_rename_key( + &mut state, + KeyEvent::new(KeyCode::Enter, KeyModifiers::empty()), + ); + assert_eq!(state.mode, Mode::Terminal); + assert_eq!(state.workspaces[0].display_name(), "renamed"); + let snapshot = capture_snapshot(&state); + assert_eq!( + snapshot.workspaces[0].custom_name.as_deref(), + Some("renamed") + ); + + state.view.sidebar_rect = Rect::new(0, 0, 26, 20); + state.view.terminal_area = Rect::new(26, 0, 80, 20); + state.mode = Mode::RenameWorkspace; + state.name_input = "mouse".into(); + let inner = state.rename_modal_inner().unwrap(); + let (save, _, _) = crate::ui::rename_button_rects(inner); + let action = modal_action_from_buttons(save.x, save.y, &[(save, ModalAction::Save)]); + assert_eq!(action, Some(ModalAction::Save)); + } + + #[test] + fn tab_rename_updates_captured_snapshot() { + let mut state = state_with_workspaces(&["test"]); + state.mode = Mode::RenameTab; + state.name_input = "logs".into(); + + handle_rename_key( + &mut state, + KeyEvent::new(KeyCode::Enter, KeyModifiers::empty()), + ); + + let snapshot = capture_snapshot(&state); + assert_eq!( + snapshot.workspaces[0].tabs[0].custom_name.as_deref(), + Some("logs") + ); + } + + #[test] + fn rename_cancel_returns_to_terminal_when_workspace_is_active() { + let mut state = state_with_workspaces(&["test"]); + state.mode = Mode::RenameTab; + state.name_input = "test".into(); + + handle_rename_key( + &mut state, + KeyEvent::new(KeyCode::Esc, KeyModifiers::empty()), + ); + + assert_eq!(state.mode, Mode::Terminal); + assert!(state.name_input.is_empty()); + } + + #[test] + fn rename_modal_replaces_prefilled_text_on_first_type() { + let mut state = state_with_workspaces(&["test"]); + state.mode = Mode::RenameTab; + state.name_input = "2".into(); + state.name_input_replace_on_type = true; + + handle_rename_key( + &mut state, + KeyEvent::new(KeyCode::Char('n'), KeyModifiers::empty()), + ); + assert_eq!(state.name_input, "n"); + assert!(!state.name_input_replace_on_type); + + handle_rename_key( + &mut state, + KeyEvent::new(KeyCode::Char('e'), KeyModifiers::empty()), + ); + assert_eq!(state.name_input, "ne"); + } + + #[test] + fn open_rename_active_tab_can_prefill_default_new_tab_name() { + let mut state = state_with_workspaces(&["test"]); + state.workspaces[0].test_add_tab(None); + state.workspaces[0].switch_tab(1); + + open_rename_active_tab(&mut state, true); + + assert_eq!(state.mode, Mode::RenameTab); + assert_eq!(state.name_input, "2"); + assert!(state.name_input_replace_on_type); + } + + #[test] + fn cancel_new_tab_dialog_leaves_workspace_unchanged() { + let mut state = state_with_workspaces(&["test"]); + open_new_tab_dialog(&mut state); + + handle_rename_key( + &mut state, + KeyEvent::new(KeyCode::Esc, KeyModifiers::empty()), + ); + + assert_eq!(state.mode, Mode::Terminal); + assert!(!state.creating_new_tab); + assert!(!state.request_new_tab); + assert!(state.requested_new_tab_name.is_none()); + assert_eq!(state.workspaces[0].tabs.len(), 1); + } + + #[test] + fn saving_new_tab_dialog_requests_creation_with_name() { + let mut state = state_with_workspaces(&["test"]); + open_new_tab_dialog(&mut state); + state.name_input = "logs".into(); + state.name_input_replace_on_type = false; + + handle_rename_key( + &mut state, + KeyEvent::new(KeyCode::Enter, KeyModifiers::empty()), + ); + + assert_eq!(state.mode, Mode::Terminal); + assert!(!state.creating_new_tab); + assert!(state.request_new_tab); + assert_eq!(state.requested_new_tab_name.as_deref(), Some("logs")); + } + + #[test] + fn saving_new_tab_dialog_with_default_name_keeps_tab_auto_named() { + let mut state = state_with_workspaces(&["test"]); + open_new_tab_dialog(&mut state); + + handle_rename_key( + &mut state, + KeyEvent::new(KeyCode::Enter, KeyModifiers::empty()), + ); + + assert_eq!(state.mode, Mode::Terminal); + assert!(!state.creating_new_tab); + assert!(state.request_new_tab); + assert!(state.requested_new_tab_name.is_none()); + } + + #[test] + fn closing_first_auto_tab_resets_remaining_auto_tab_and_next_prompt() { + let mut state = state_with_workspaces(&["test"]); + open_new_tab_dialog(&mut state); + handle_rename_key( + &mut state, + KeyEvent::new(KeyCode::Enter, KeyModifiers::empty()), + ); + + state.workspaces[0].test_add_tab(state.requested_new_tab_name.as_deref()); + state.request_new_tab = false; + state.requested_new_tab_name = None; + + state.workspaces[0].close_tab(0); + state.workspaces[0].switch_tab(0); + + assert_eq!(state.workspaces[0].tabs[0].display_name(), "1"); + assert!(state.workspaces[0].tabs[0].custom_name.is_none()); + + open_new_tab_dialog(&mut state); + assert_eq!(state.name_input, "2"); + } + + #[test] + fn renaming_auto_tab_to_its_default_number_keeps_it_auto_named() { + let mut state = state_with_workspaces(&["test"]); + state.workspaces[0].test_add_tab(None); + state.workspaces[0].switch_tab(1); + + open_rename_active_tab(&mut state, false); + handle_rename_key( + &mut state, + KeyEvent::new(KeyCode::Enter, KeyModifiers::empty()), + ); + + assert_eq!(state.mode, Mode::Terminal); + assert!(state.workspaces[0].tabs[1].custom_name.is_none()); + assert_eq!(state.workspaces[0].tabs[1].display_name(), "2"); + } + + #[test] + fn confirm_close_keyboard_actions_are_direct_not_focused() { + let mut state = state_with_workspaces(&["a", "b"]); + state.mode = Mode::ConfirmClose; + state.selected = 1; + + handle_confirm_close_key( + &mut state, + KeyEvent::new(KeyCode::Esc, KeyModifiers::empty()), + ); + assert_eq!(state.mode, Mode::Navigate); + assert_eq!(state.workspaces.len(), 2); + + state.mode = Mode::ConfirmClose; + handle_confirm_close_key( + &mut state, + KeyEvent::new(KeyCode::Enter, KeyModifiers::empty()), + ); + assert_eq!(state.workspaces.len(), 1); + } +} diff --git a/src/app/input/mouse.rs b/src/app/input/mouse.rs new file mode 100644 index 00000000..0349d236 --- /dev/null +++ b/src/app/input/mouse.rs @@ -0,0 +1,1258 @@ +use bytes::Bytes; +use crossterm::event::{MouseButton, MouseEvent, MouseEventKind}; +use ratatui::layout::{Direction, Rect}; +use tracing::warn; + +use crate::{ + app::state::{ + AgentPanelScope, AppState, ContextMenuKind, ContextMenuState, DragState, DragTarget, + MenuListState, Mode, TabPressState, WorkspacePressState, + }, + layout::{PaneInfo, SplitBorder}, + selection::Selection, +}; + +#[cfg(test)] +use super::WheelRouting; +use super::{ + modal::{ + apply_context_menu_action, apply_global_menu_action, apply_rename_action, + confirm_close_accept, confirm_close_cancel, global_menu_actions, leave_modal, + modal_action_from_buttons, open_global_menu, open_new_tab_dialog, ModalAction, + }, + settings::SettingsAction, + ScrollbarClickTarget, TAB_DRAG_THRESHOLD, WORKSPACE_DRAG_THRESHOLD, +}; + +impl AppState { + pub(super) fn handle_mouse(&mut self, mouse: MouseEvent) -> Option<SettingsAction> { + if self.mode == Mode::Onboarding { + self.handle_onboarding_mouse(mouse); + return None; + } + + if self.mode == Mode::Settings { + return self.handle_settings_mouse(mouse); + } + + let launcher_enabled = !self.sidebar_collapsed + && matches!( + self.mode, + Mode::Terminal + | Mode::Navigate + | Mode::Resize + | Mode::GlobalMenu + | Mode::KeybindHelp + ); + let launcher = self.global_launcher_rect(); + let launcher_hit = launcher_enabled + && mouse.column >= launcher.x + && mouse.column < launcher.x + launcher.width + && mouse.row >= launcher.y + && mouse.row < launcher.y + launcher.height; + + if matches!(mouse.kind, MouseEventKind::Moved) && self.mode == Mode::GlobalMenu { + let actions = global_menu_actions(self); + let hovered = self + .global_menu_item_at(mouse.column, mouse.row) + .and_then(|action| actions.iter().position(|item| *item == action)); + self.global_menu.hover(hovered); + return None; + } + + if matches!(mouse.kind, MouseEventKind::Down(MouseButton::Left)) && launcher_hit { + if self.mode == Mode::GlobalMenu { + leave_modal(self); + } else { + open_global_menu(self); + } + return None; + } + + if self.mode == Mode::GlobalMenu { + if matches!(mouse.kind, MouseEventKind::Down(MouseButton::Left)) { + if let Some(action) = self.global_menu_item_at(mouse.column, mouse.row) { + apply_global_menu_action(self, action); + } else { + leave_modal(self); + } + } + return None; + } + + if self.mode == Mode::KeybindHelp { + return None; + } + + let sidebar = self.view.sidebar_rect; + let in_sidebar = mouse.column >= sidebar.x + && mouse.column < sidebar.x + sidebar.width + && mouse.row >= sidebar.y + && mouse.row < sidebar.y + sidebar.height; + + match mouse.kind { + MouseEventKind::Down(MouseButton::Left) => { + self.selection = None; + self.workspace_press = None; + + if self.mode == Mode::ConfirmClose { + let popup = self.confirm_close_rect(); + let inner = Rect::new( + popup.x + 1, + popup.y + 1, + popup.width.saturating_sub(2), + popup.height.saturating_sub(2), + ); + let (confirm, cancel) = crate::ui::confirm_close_button_rects(inner); + match modal_action_from_buttons( + mouse.column, + mouse.row, + &[ + (confirm, ModalAction::Confirm), + (cancel, ModalAction::Cancel), + ], + ) { + Some(ModalAction::Confirm) => confirm_close_accept(self), + Some(ModalAction::Cancel) | None => confirm_close_cancel(self), + _ => {} + } + return None; + } + + if matches!(self.mode, Mode::RenameWorkspace | Mode::RenameTab) { + let action = self + .rename_modal_inner() + .map(crate::ui::rename_button_rects) + .and_then(|(save, clear, cancel)| { + modal_action_from_buttons( + mouse.column, + mouse.row, + &[ + (save, ModalAction::Save), + (clear, ModalAction::Clear), + (cancel, ModalAction::Cancel), + ], + ) + }) + .unwrap_or(ModalAction::Cancel); + apply_rename_action(self, action); + return None; + } + + if self.mode == Mode::ContextMenu { + let item_idx = self.context_menu_item_at(mouse.column, mouse.row); + if let Some(menu) = self.context_menu.take() { + if let Some(idx) = item_idx { + apply_context_menu_action(self, menu, idx); + } else { + leave_modal(self); + } + } + return None; + } + + if self.on_sidebar_divider(mouse.column, mouse.row) { + self.drag = Some(DragState { + target: DragTarget::SidebarDivider, + }); + self.set_manual_sidebar_width(mouse.column); + return None; + } + + if self.on_sidebar_section_divider(mouse.column, mouse.row) { + self.drag = Some(DragState { + target: DragTarget::SidebarSectionDivider, + }); + self.set_sidebar_section_split(mouse.row); + return None; + } + + if !in_sidebar { + if let Some(border) = self.find_border_at(mouse.column, mouse.row) { + self.drag = Some(DragState { + target: DragTarget::PaneSplit { + path: border.path.clone(), + direction: border.direction, + area: border.area, + }, + }); + return None; + } + + if let Some((pane_id, target)) = + self.scrollbar_target_at(mouse.column, mouse.row) + { + self.focus_pane(pane_id); + match target { + ScrollbarClickTarget::Thumb { grab_row_offset } => { + self.drag = Some(DragState { + target: DragTarget::PaneScrollbar { + pane_id, + grab_row_offset, + }, + }); + } + ScrollbarClickTarget::Track { offset_from_bottom } => { + self.set_pane_scroll_offset(pane_id, offset_from_bottom); + } + } + if self.mode != Mode::Terminal { + self.mode = Mode::Terminal; + } + return None; + } + } + + if self.on_tab_scroll_left_button(mouse.column, mouse.row) { + self.scroll_tabs_left(); + return None; + } + if self.on_tab_scroll_right_button(mouse.column, mouse.row) { + self.scroll_tabs_right(); + return None; + } + if let (Some(ws_idx), Some(tab_idx)) = + (self.active, self.tab_at(mouse.column, mouse.row)) + { + self.tab_press = Some(TabPressState { + ws_idx, + tab_idx, + start_col: mouse.column, + start_row: mouse.row, + }); + return None; + } + if self.on_new_tab_button(mouse.column, mouse.row) { + open_new_tab_dialog(self); + return None; + } + + if in_sidebar { + if self.sidebar_collapsed { + if self.on_collapsed_sidebar_toggle(mouse.column, mouse.row) { + self.sidebar_collapsed = false; + return None; + } + + if let Some(idx) = self.collapsed_workspace_at_row(mouse.row) { + self.switch_workspace(idx); + self.mode = Mode::Terminal; + return None; + } + + if let Some((ws_idx, tab_idx, pane_id)) = + self.collapsed_agent_detail_target_at(mouse.row) + { + self.switch_workspace(ws_idx); + self.switch_tab(tab_idx); + self.focus_pane(pane_id); + self.mode = Mode::Terminal; + } + return None; + } + + let new_button = self.sidebar_new_button_rect(); + let on_new_button = mouse.row >= new_button.y + && mouse.row < new_button.y + new_button.height + && mouse.column >= new_button.x + && mouse.column < new_button.x + new_button.width; + if on_new_button { + self.request_new_workspace = true; + return None; + } + + if let Some(target) = + self.workspace_list_scrollbar_target_at(mouse.column, mouse.row) + { + match target { + ScrollbarClickTarget::Thumb { grab_row_offset } => { + self.drag = Some(DragState { + target: DragTarget::WorkspaceListScrollbar { grab_row_offset }, + }); + } + ScrollbarClickTarget::Track { offset_from_bottom } => { + self.set_workspace_list_offset_from_bottom(offset_from_bottom); + } + } + return None; + } + + if let Some(idx) = self.workspace_at_row(mouse.row) { + self.workspace_press = Some(WorkspacePressState { + ws_idx: idx, + start_col: mouse.column, + start_row: mouse.row, + }); + return None; + } + + if self.on_agent_panel_scope_toggle(mouse.column, mouse.row) { + self.agent_panel_scope = match self.agent_panel_scope { + AgentPanelScope::CurrentWorkspace => AgentPanelScope::AllWorkspaces, + AgentPanelScope::AllWorkspaces => AgentPanelScope::CurrentWorkspace, + }; + self.agent_panel_scroll = 0; + self.mark_session_dirty(); + return None; + } + + if let Some(target) = + self.agent_panel_scrollbar_target_at(mouse.column, mouse.row) + { + match target { + ScrollbarClickTarget::Thumb { grab_row_offset } => { + self.drag = Some(DragState { + target: DragTarget::AgentPanelScrollbar { grab_row_offset }, + }); + } + ScrollbarClickTarget::Track { offset_from_bottom } => { + self.set_agent_panel_offset_from_bottom(offset_from_bottom); + } + } + return None; + } + + if let Some((ws_idx, tab_idx, pane_id)) = self.agent_detail_target_at(mouse.row) + { + self.switch_workspace(ws_idx); + self.switch_tab(tab_idx); + self.focus_pane(pane_id); + self.mode = Mode::Terminal; + return None; + } + } else if let Some(info) = self.pane_at(mouse.column, mouse.row).cloned() { + self.focus_pane(info.id); + if self.mode != Mode::Terminal { + self.mode = Mode::Terminal; + } + + if self.forward_pane_mouse_button(&info, mouse) { + self.selection = None; + return None; + } + + let (row, col) = ( + mouse.row - info.inner_rect.y, + mouse.column - info.inner_rect.x, + ); + self.selection = Some(Selection::anchor( + info.id, + row, + col, + self.pane_scroll_metrics(info.id), + )); + } else if let Some(info) = self.view.pane_infos.iter().find(|p| { + mouse.column >= p.rect.x + && mouse.column < p.rect.x + p.rect.width + && mouse.row >= p.rect.y + && mouse.row < p.rect.y + p.rect.height + }) { + let id = info.id; + self.focus_pane(id); + if self.mode != Mode::Terminal { + self.mode = Mode::Terminal; + } + } + } + + MouseEventKind::Drag(MouseButton::Left) => { + if self.selection.is_some() { + self.update_selection_drag(mouse.column, mouse.row); + return None; + } + + if let Some(info) = self.pane_mouse_target(mouse.column, mouse.row).cloned() { + if self.forward_pane_mouse_button(&info, mouse) { + self.selection = None; + return None; + } + } + + let workspace_drop_index = self.workspace_drop_index_at_row(mouse.row); + let tab_drop_index = self.tab_drop_index_at(mouse.column, mouse.row); + if self.drag.is_none() { + if let Some(press) = &self.workspace_press { + let delta_col = mouse.column.abs_diff(press.start_col); + let delta_row = mouse.row.abs_diff(press.start_row); + if delta_col.max(delta_row) >= WORKSPACE_DRAG_THRESHOLD { + self.drag = Some(DragState { + target: DragTarget::WorkspaceReorder { + source_ws_idx: press.ws_idx, + insert_idx: workspace_drop_index, + }, + }); + } + } else if let Some(press) = &self.tab_press { + let delta_col = mouse.column.abs_diff(press.start_col); + let delta_row = mouse.row.abs_diff(press.start_row); + if delta_col.max(delta_row) >= TAB_DRAG_THRESHOLD { + self.drag = Some(DragState { + target: DragTarget::TabReorder { + ws_idx: press.ws_idx, + source_tab_idx: press.tab_idx, + insert_idx: tab_drop_index, + }, + }); + } + } + } + + if let Some(DragState { + target: DragTarget::WorkspaceReorder { insert_idx, .. }, + }) = &mut self.drag + { + *insert_idx = workspace_drop_index; + } else if let Some(DragState { + target: + DragTarget::TabReorder { + ws_idx, insert_idx, .. + }, + }) = &mut self.drag + { + if self.active == Some(*ws_idx) { + *insert_idx = tab_drop_index; + } + } else if let Some(drag) = &self.drag { + match &drag.target { + DragTarget::WorkspaceReorder { .. } | DragTarget::TabReorder { .. } => {} + DragTarget::WorkspaceListScrollbar { grab_row_offset } => { + if let Some(offset_from_bottom) = + self.workspace_list_offset_for_drag_row(mouse.row, *grab_row_offset) + { + self.set_workspace_list_offset_from_bottom(offset_from_bottom); + } + } + DragTarget::AgentPanelScrollbar { grab_row_offset } => { + if let Some(offset_from_bottom) = + self.agent_panel_offset_for_drag_row(mouse.row, *grab_row_offset) + { + self.set_agent_panel_offset_from_bottom(offset_from_bottom); + } + } + DragTarget::PaneSplit { + path, + direction, + area, + } => { + let ratio = match direction { + Direction::Horizontal => { + (mouse.column.saturating_sub(area.x)) as f32 + / area.width.max(1) as f32 + } + Direction::Vertical => { + (mouse.row.saturating_sub(area.y)) as f32 + / area.height.max(1) as f32 + } + }; + let ratio = ratio.clamp(0.1, 0.9); + let path = path.clone(); + if let Some(ws) = self.active.and_then(|i| self.workspaces.get_mut(i)) { + ws.layout.set_ratio_at(&path, ratio); + self.mark_session_dirty(); + } + } + DragTarget::PaneScrollbar { + pane_id, + grab_row_offset, + } => { + if let Some(offset_from_bottom) = self.scrollbar_offset_for_pane_row( + *pane_id, + mouse.row, + *grab_row_offset, + ) { + self.set_pane_scroll_offset(*pane_id, offset_from_bottom); + } + } + DragTarget::SidebarDivider => { + self.set_manual_sidebar_width(mouse.column); + } + DragTarget::SidebarSectionDivider => { + self.set_sidebar_section_split(mouse.row); + } + DragTarget::ReleaseNotesScrollbar { .. } + | DragTarget::KeybindHelpScrollbar { .. } => {} + } + } + } + + MouseEventKind::Up(MouseButton::Left) => { + if self.selection.is_some() { + self.workspace_press = None; + self.tab_press = None; + self.drag = None; + let was_click = self.selection.as_ref().is_some_and(|s| s.was_just_click()); + if was_click { + self.selection = None; + } else { + self.copy_selection(); + } + return None; + } + + if let Some(info) = self.pane_mouse_target(mouse.column, mouse.row).cloned() { + if self.forward_pane_mouse_button(&info, mouse) { + self.selection = None; + self.workspace_press = None; + self.tab_press = None; + self.drag = None; + return None; + } + } + + let workspace_press = self.workspace_press.take(); + let tab_press = self.tab_press.take(); + match self.drag.take() { + Some(DragState { + target: + DragTarget::WorkspaceReorder { + source_ws_idx, + insert_idx: Some(insert_idx), + }, + }) => { + self.move_workspace(source_ws_idx, insert_idx); + } + Some(DragState { + target: + DragTarget::TabReorder { + ws_idx, + source_tab_idx, + insert_idx: Some(insert_idx), + }, + }) => { + if self.active == Some(ws_idx) { + self.move_tab(source_tab_idx, insert_idx); + self.mode = Mode::Terminal; + } + } + Some(_) => {} + None => { + if let Some(press) = workspace_press { + self.switch_workspace(press.ws_idx); + self.mode = Mode::Terminal; + return None; + } + if let Some(press) = tab_press { + if self.active == Some(press.ws_idx) { + self.switch_tab(press.tab_idx); + self.mode = Mode::Terminal; + return None; + } + } + let was_click = self.selection.as_ref().is_some_and(|s| s.was_just_click()); + if was_click { + self.selection = None; + } else { + self.copy_selection(); + } + } + } + } + + MouseEventKind::Up(MouseButton::Middle) | MouseEventKind::Drag(MouseButton::Middle) + if !in_sidebar => + { + if let Some(info) = self.pane_mouse_target(mouse.column, mouse.row).cloned() { + let _ = self.forward_pane_mouse_button(&info, mouse); + } + } + + MouseEventKind::ScrollUp | MouseEventKind::ScrollDown if !in_sidebar => { + if self.on_tab_bar(mouse.column, mouse.row) { + match mouse.kind { + MouseEventKind::ScrollUp => self.scroll_tabs_left(), + MouseEventKind::ScrollDown => self.scroll_tabs_right(), + _ => {} + } + } else if !self.scroll_selection_with_wheel(mouse) { + self.selection = None; + self.handle_terminal_wheel(mouse); + } + } + + MouseEventKind::ScrollUp if in_sidebar => { + let agent_area = self.agent_panel_rect(); + let over_agent_panel = agent_area != Rect::default() + && mouse.row >= agent_area.y + && mouse.row < agent_area.y + agent_area.height; + if over_agent_panel { + if crate::ui::should_show_scrollbar(crate::ui::agent_panel_scroll_metrics( + self, agent_area, + )) { + self.scroll_agent_panel(-1); + } + } else if crate::ui::should_show_scrollbar( + crate::ui::workspace_list_scroll_metrics(self, self.workspace_list_rect()), + ) { + self.scroll_workspace_list(-1); + } else if self.selected > 0 { + self.selected -= 1; + self.ensure_workspace_visible(self.selected); + } + } + MouseEventKind::ScrollDown if in_sidebar => { + let agent_area = self.agent_panel_rect(); + let over_agent_panel = agent_area != Rect::default() + && mouse.row >= agent_area.y + && mouse.row < agent_area.y + agent_area.height; + if over_agent_panel { + if crate::ui::should_show_scrollbar(crate::ui::agent_panel_scroll_metrics( + self, agent_area, + )) { + self.scroll_agent_panel(1); + } + } else if crate::ui::should_show_scrollbar( + crate::ui::workspace_list_scroll_metrics(self, self.workspace_list_rect()), + ) { + self.scroll_workspace_list(1); + } else if !self.workspaces.is_empty() && self.selected < self.workspaces.len() - 1 { + self.selected += 1; + self.ensure_workspace_visible(self.selected); + } + } + + MouseEventKind::Moved if self.mode == Mode::ContextMenu => { + let hovered = self.context_menu_item_at(mouse.column, mouse.row); + if let Some(menu) = &mut self.context_menu { + menu.list.hover(hovered); + } + } + + MouseEventKind::Down(MouseButton::Right) if in_sidebar && !self.sidebar_collapsed => { + if self + .workspace_list_scrollbar_target_at(mouse.column, mouse.row) + .is_some() + { + return None; + } + if let Some(idx) = self.workspace_at_row(mouse.row) { + self.selected = idx; + self.context_menu = Some(ContextMenuState { + kind: ContextMenuKind::Workspace { ws_idx: idx }, + x: mouse.column, + y: mouse.row, + list: MenuListState::new(0), + }); + self.mode = Mode::ContextMenu; + } + } + + MouseEventKind::Down(MouseButton::Right) + if self.tab_at(mouse.column, mouse.row).is_some() => + { + if let (Some(ws_idx), Some(tab_idx)) = + (self.active, self.tab_at(mouse.column, mouse.row)) + { + self.switch_tab(tab_idx); + self.context_menu = Some(ContextMenuState { + kind: ContextMenuKind::Tab { ws_idx, tab_idx }, + x: mouse.column, + y: mouse.row, + list: MenuListState::new(0), + }); + self.mode = Mode::ContextMenu; + } + } + + MouseEventKind::Down(MouseButton::Right) if !in_sidebar => { + if let Some(info) = self.pane_mouse_target(mouse.column, mouse.row).cloned() { + self.focus_pane(info.id); + self.context_menu = Some(ContextMenuState { + kind: ContextMenuKind::Pane, + x: mouse.column, + y: mouse.row, + list: MenuListState::new(0), + }); + self.mode = Mode::ContextMenu; + } + } + + _ => {} + } + + None + } + + pub(super) fn screen_rect(&self) -> Rect { + let sidebar = self.view.sidebar_rect; + let terminal = self.view.terminal_area; + let x = sidebar.x.min(terminal.x); + let y = sidebar.y.min(terminal.y); + let right = (sidebar.x + sidebar.width).max(terminal.x + terminal.width); + let bottom = (sidebar.y + sidebar.height).max(terminal.y + terminal.height); + Rect::new(x, y, right.saturating_sub(x), bottom.saturating_sub(y)) + } + + pub(crate) fn context_menu_rect(&self) -> Option<Rect> { + let menu = self.context_menu.as_ref()?; + let screen = self.screen_rect(); + let max_item_w = menu + .items() + .iter() + .map(|item| item.len() as u16) + .max() + .unwrap_or(0); + let menu_w = (max_item_w + 4).max(14).min(screen.width.max(1)); + let menu_h = (menu.items().len() as u16 + 2).min(screen.height.max(1)); + let x = menu.x.min(screen.x + screen.width.saturating_sub(menu_w)); + let y = menu.y.min(screen.y + screen.height.saturating_sub(menu_h)); + Some(Rect::new(x, y, menu_w, menu_h)) + } + + pub(crate) fn confirm_close_rect(&self) -> Rect { + crate::ui::confirm_close_popup_rect(self.view.terminal_area).unwrap_or_default() + } + + fn context_menu_item_at(&self, col: u16, row: u16) -> Option<usize> { + let menu_rect = self.context_menu_rect()?; + let inner_x = menu_rect.x + 1; + let inner_y = menu_rect.y + 1; + let inner_w = menu_rect.width.saturating_sub(2); + let inner_h = menu_rect.height.saturating_sub(2); + let item_count = self + .context_menu + .as_ref() + .map(|menu| menu.items().len() as u16) + .unwrap_or(0); + if col >= inner_x + && col < inner_x + inner_w + && row >= inner_y + && row < inner_y + inner_h.min(item_count) + { + Some((row - inner_y) as usize) + } else { + None + } + } + + pub(super) fn tab_at(&self, col: u16, row: u16) -> Option<usize> { + self.view + .tab_hit_areas + .iter() + .enumerate() + .find_map(|(idx, area)| { + (area.width > 0 + && row >= area.y + && row < area.y + area.height + && col >= area.x + && col < area.x + area.width) + .then_some(idx) + }) + } + + pub(super) fn on_tab_bar(&self, col: u16, row: u16) -> bool { + let area = self.view.tab_bar_rect; + area.width > 0 + && row >= area.y + && row < area.y + area.height + && col >= area.x + && col < area.x + area.width + } + + pub(super) fn on_tab_scroll_left_button(&self, col: u16, row: u16) -> bool { + let area = self.view.tab_scroll_left_hit_area; + area.width > 0 + && row >= area.y + && row < area.y + area.height + && col >= area.x + && col < area.x + area.width + } + + pub(super) fn on_tab_scroll_right_button(&self, col: u16, row: u16) -> bool { + let area = self.view.tab_scroll_right_hit_area; + area.width > 0 + && row >= area.y + && row < area.y + area.height + && col >= area.x + && col < area.x + area.width + } + + pub(super) fn tab_drop_index_at(&self, col: u16, row: u16) -> Option<usize> { + if !self.on_tab_bar(col, row) { + return None; + } + + let visible_tabs: Vec<_> = self + .view + .tab_hit_areas + .iter() + .enumerate() + .filter(|(_, rect)| rect.width > 0) + .collect(); + let (first_idx, first_rect) = *visible_tabs.first()?; + let (last_idx, last_rect) = *visible_tabs.last()?; + + if self.on_tab_scroll_left_button(col, row) { + return Some(0); + } + if self.on_tab_scroll_right_button(col, row) { + return self + .active + .and_then(|idx| self.workspaces.get(idx)) + .map(|ws| ws.tabs.len()); + } + + let left_edge = if first_idx == 0 { + first_rect.x + } else { + self.view.tab_scroll_left_hit_area.x + self.view.tab_scroll_left_hit_area.width + }; + let right_edge = if self + .active + .and_then(|idx| self.workspaces.get(idx)) + .is_some_and(|ws| last_idx + 1 >= ws.tabs.len()) + { + last_rect.x + last_rect.width + } else { + self.view.tab_scroll_right_hit_area.x.saturating_sub(1) + }; + + if col <= left_edge { + return Some(first_idx); + } + if col >= right_edge { + return Some(last_idx + 1); + } + + for (idx, rect) in visible_tabs { + let midpoint = rect.x + rect.width / 2; + if col < midpoint { + return Some(idx); + } + if col < rect.x + rect.width { + return Some(idx + 1); + } + } + + Some(last_idx + 1) + } + + pub(super) fn on_new_tab_button(&self, col: u16, row: u16) -> bool { + let area = self.view.new_tab_hit_area; + area.width > 0 + && row >= area.y + && row < area.y + area.height + && col >= area.x + && col < area.x + area.width + } + + pub(super) fn find_border_at(&self, col: u16, row: u16) -> Option<&SplitBorder> { + self.view.split_borders.iter().find(|b| match b.direction { + Direction::Horizontal => { + (col as i32 - b.pos as i32).unsigned_abs() <= 1 + && row >= b.area.y + && row < b.area.y + b.area.height + } + Direction::Vertical => { + (row as i32 - b.pos as i32).unsigned_abs() <= 1 + && col >= b.area.x + && col < b.area.x + b.area.width + } + }) + } + + pub(super) fn pane_at(&self, col: u16, row: u16) -> Option<&PaneInfo> { + self.view.pane_infos.iter().find(|p| { + col >= p.inner_rect.x + && col < p.inner_rect.x + p.inner_rect.width + && row >= p.inner_rect.y + && row < p.inner_rect.y + p.inner_rect.height + }) + } + + pub(super) fn pane_mouse_target(&self, col: u16, row: u16) -> Option<&PaneInfo> { + self.pane_at(col, row) + .or_else(|| self.pane_frame_at(col, row)) + } + + pub(super) fn pane_info_by_id(&self, pane_id: crate::layout::PaneId) -> Option<&PaneInfo> { + self.view.pane_infos.iter().find(|info| info.id == pane_id) + } + + pub(super) fn pane_frame_at(&self, col: u16, row: u16) -> Option<&PaneInfo> { + self.view.pane_infos.iter().find(|p| { + col >= p.rect.x + && col < p.rect.x + p.rect.width + && row >= p.rect.y + && row < p.rect.y + p.rect.height + }) + } + + pub(super) fn focus_pane(&mut self, pane_id: crate::layout::PaneId) { + if let Some(ws) = self.active.and_then(|i| self.workspaces.get_mut(i)) { + if ws.layout.focused() != pane_id { + ws.layout.focus_pane(pane_id); + self.mark_session_dirty(); + } + } + } + + pub(super) fn scroll_pane_up(&self, pane_id: crate::layout::PaneId, lines: usize) { + if let Some(ws) = self.active.and_then(|i| self.workspaces.get(i)) { + if let Some(rt) = ws.runtimes.get(&pane_id) { + rt.scroll_up(lines); + } + } + } + + pub(super) fn scroll_pane_down(&self, pane_id: crate::layout::PaneId, lines: usize) { + if let Some(ws) = self.active.and_then(|i| self.workspaces.get(i)) { + if let Some(rt) = ws.runtimes.get(&pane_id) { + rt.scroll_down(lines); + } + } + } + + pub(super) fn pane_scroll_metrics( + &self, + pane_id: crate::layout::PaneId, + ) -> Option<crate::pane::ScrollMetrics> { + self.active + .and_then(|i| self.workspaces.get(i)) + .and_then(|ws| ws.runtime(pane_id)) + .and_then(crate::pane::PaneRuntime::scroll_metrics) + } + + pub(super) fn handle_terminal_wheel(&mut self, mouse: MouseEvent) { + const LINES_PER_NOTCH: usize = 3; + + if let Some(info) = self.pane_at(mouse.column, mouse.row).cloned() { + self.focus_pane(info.id); + if self.forward_pane_wheel(&info, mouse) { + return; + } + match mouse.kind { + MouseEventKind::ScrollUp => self.scroll_pane_up(info.id, LINES_PER_NOTCH), + MouseEventKind::ScrollDown => self.scroll_pane_down(info.id, LINES_PER_NOTCH), + _ => {} + } + return; + } + + if let Some(info) = self.pane_frame_at(mouse.column, mouse.row).cloned() { + self.focus_pane(info.id); + match mouse.kind { + MouseEventKind::ScrollUp => self.scroll_pane_up(info.id, LINES_PER_NOTCH), + MouseEventKind::ScrollDown => self.scroll_pane_down(info.id, LINES_PER_NOTCH), + _ => {} + } + return; + } + + if let Some(ws) = self.active.and_then(|i| self.workspaces.get(i)) { + if let Some(rt) = ws.focused_runtime() { + match mouse.kind { + MouseEventKind::ScrollUp => rt.scroll_up(LINES_PER_NOTCH), + MouseEventKind::ScrollDown => rt.scroll_down(LINES_PER_NOTCH), + _ => {} + } + } + } + } + + pub(super) fn forward_pane_mouse_button(&self, info: &PaneInfo, mouse: MouseEvent) -> bool { + let Some(ws) = self.active.and_then(|i| self.workspaces.get(i)) else { + return false; + }; + let Some(rt) = ws.runtimes.get(&info.id) else { + return false; + }; + let column = mouse.column.saturating_sub(info.inner_rect.x); + let row = mouse.row.saturating_sub(info.inner_rect.y); + let Some(bytes) = rt.encode_mouse_button(mouse.kind, column, row, mouse.modifiers) else { + return false; + }; + rt.scroll_reset(); + if let Err(err) = rt.try_send_bytes(Bytes::from(bytes)) { + warn!(pane = info.id.raw(), err = %err, kind = ?mouse.kind, "failed to forward mouse button event"); + } + true + } + + pub(super) fn forward_pane_wheel(&self, info: &PaneInfo, mouse: MouseEvent) -> bool { + let Some(ws) = self.active.and_then(|i| self.workspaces.get(i)) else { + return false; + }; + let Some(rt) = ws.runtimes.get(&info.id) else { + return false; + }; + match rt.wheel_routing() { + Some(crate::pane::WheelRouting::HostScroll) | None => false, + Some(crate::pane::WheelRouting::MouseReport) => { + rt.scroll_reset(); + let column = mouse.column.saturating_sub(info.inner_rect.x); + let row = mouse.row.saturating_sub(info.inner_rect.y); + let Some(bytes) = rt.encode_mouse_wheel(mouse.kind, column, row, mouse.modifiers) + else { + warn!(pane = info.id.raw(), kind = ?mouse.kind, "failed to encode mouse wheel event"); + return true; + }; + if let Err(err) = rt.try_send_bytes(Bytes::from(bytes)) { + warn!(pane = info.id.raw(), err = %err, "failed to forward mouse wheel event"); + } + true + } + Some(crate::pane::WheelRouting::AlternateScroll) => { + rt.scroll_reset(); + let Some(bytes) = rt.encode_alternate_scroll(mouse.kind) else { + return true; + }; + if let Err(err) = rt.try_send_bytes(Bytes::from(bytes)) { + warn!(pane = info.id.raw(), err = %err, "failed to forward alternate-scroll key"); + } + true + } + } + } + + pub(super) fn set_pane_scroll_offset( + &self, + pane_id: crate::layout::PaneId, + offset_from_bottom: usize, + ) { + if let Some(ws) = self.active.and_then(|i| self.workspaces.get(i)) { + if let Some(rt) = ws.runtimes.get(&pane_id) { + rt.set_scroll_offset_from_bottom(offset_from_bottom); + } + } + } + + pub(super) fn scrollbar_target_at( + &self, + col: u16, + row: u16, + ) -> Option<(crate::layout::PaneId, ScrollbarClickTarget)> { + let ws = self.active.and_then(|i| self.workspaces.get(i))?; + let info = self.view.pane_infos.iter().find(|info| { + crate::ui::pane_scrollbar_rect(info).is_some_and(|track| { + col >= track.x + && col < track.x + track.width + && row >= track.y + && row < track.y + track.height + }) + })?; + let rt = ws.runtimes.get(&info.id)?; + let metrics = rt.scroll_metrics()?; + if metrics.max_offset_from_bottom == 0 { + return None; + } + let track = crate::ui::pane_scrollbar_rect(info)?; + if let Some(grab_row_offset) = crate::ui::scrollbar_thumb_grab_offset(metrics, track, row) { + Some((info.id, ScrollbarClickTarget::Thumb { grab_row_offset })) + } else { + Some(( + info.id, + ScrollbarClickTarget::Track { + offset_from_bottom: crate::ui::scrollbar_offset_from_row(metrics, track, row), + }, + )) + } + } + + pub(super) fn scrollbar_offset_for_pane_row( + &self, + pane_id: crate::layout::PaneId, + row: u16, + grab_row_offset: u16, + ) -> Option<usize> { + let ws = self.active.and_then(|i| self.workspaces.get(i))?; + let info = self + .view + .pane_infos + .iter() + .find(|info| info.id == pane_id)?; + let track = crate::ui::pane_scrollbar_rect(info)?; + let rt = ws.runtimes.get(&pane_id)?; + let metrics = rt.scroll_metrics()?; + if metrics.max_offset_from_bottom == 0 { + return None; + } + Some(crate::ui::scrollbar_offset_from_drag_row( + metrics, + track, + row, + grab_row_offset, + )) + } +} + +#[cfg(test)] +pub(super) fn wheel_routing(input_state: crate::pane::InputState) -> WheelRouting { + if input_state.mouse_protocol_mode.reporting_enabled() { + WheelRouting::MouseReport + } else if input_state.alternate_screen && input_state.mouse_alternate_scroll { + WheelRouting::AlternateScroll + } else { + WheelRouting::HostScroll + } +} + +#[cfg(test)] +mod tests { + use crossterm::event::{KeyCode, KeyEvent, KeyModifiers, MouseButton, MouseEventKind}; + use ratatui::layout::{Direction, Rect}; + + use super::super::{ + app_for_mouse_test, capture_snapshot, handle_context_menu_key, mouse, root_layout_ratio, + }; + use super::*; + use crate::{ + app::state::{ContextMenuKind, ContextMenuState, MenuListState, Mode}, + workspace::Workspace, + }; + + #[test] + fn hovering_context_menu_updates_highlight() { + let mut app = app_for_mouse_test(); + app.state.context_menu = Some(ContextMenuState { + kind: ContextMenuKind::Workspace { ws_idx: 0 }, + x: 2, + y: 2, + list: MenuListState::new(0), + }); + app.state.mode = Mode::ContextMenu; + + let menu = app.state.context_menu_rect().unwrap(); + app.handle_mouse(mouse(MouseEventKind::Moved, menu.x + 2, menu.y + 2)); + + assert_eq!(app.state.context_menu.unwrap().list.highlighted, 1); + } + + #[test] + fn clicking_confirm_close_accepts_workspace_close() { + let mut app = app_for_mouse_test(); + app.state.workspaces = vec![Workspace::test_new("a"), Workspace::test_new("b")]; + app.state.active = Some(0); + app.state.selected = 1; + app.state.mode = Mode::ConfirmClose; + + let popup = app.state.confirm_close_rect(); + let inner = Rect::new( + popup.x + 1, + popup.y + 1, + popup.width.saturating_sub(2), + popup.height.saturating_sub(2), + ); + let (confirm, _) = crate::ui::confirm_close_button_rects(inner); + + app.handle_mouse(mouse( + MouseEventKind::Down(MouseButton::Left), + confirm.x, + confirm.y, + )); + + assert_eq!(app.state.workspaces.len(), 1); + assert_eq!(app.state.mode, Mode::Terminal); + } + + #[test] + fn clicking_confirm_close_accepts_after_workspace_context_menu_close() { + let mut app = app_for_mouse_test(); + app.state.workspaces = vec![Workspace::test_new("a"), Workspace::test_new("b")]; + app.state.active = Some(0); + app.state.selected = 0; + app.state.mode = Mode::Terminal; + + app.state.context_menu = Some(ContextMenuState { + kind: ContextMenuKind::Workspace { ws_idx: 1 }, + x: 2, + y: 2, + list: MenuListState::new(1), + }); + app.state.mode = Mode::ContextMenu; + handle_context_menu_key( + &mut app.state, + KeyEvent::new(KeyCode::Enter, KeyModifiers::empty()), + ); + assert_eq!(app.state.mode, Mode::ConfirmClose); + assert_eq!(app.state.selected, 1); + + let popup = app.state.confirm_close_rect(); + let inner = Rect::new( + popup.x + 1, + popup.y + 1, + popup.width.saturating_sub(2), + popup.height.saturating_sub(2), + ); + let (confirm, _) = crate::ui::confirm_close_button_rects(inner); + app.handle_mouse(mouse( + MouseEventKind::Down(MouseButton::Left), + confirm.x + 1, + confirm.y, + )); + + assert_eq!(app.state.workspaces.len(), 1); + assert_eq!(app.state.workspaces[0].display_name(), "a"); + } + + #[test] + fn dragging_pane_split_updates_captured_layout_ratio() { + let mut app = app_for_mouse_test(); + app.state.workspaces = vec![Workspace::test_new("test")]; + app.state.active = Some(0); + app.state.selected = 0; + app.state.workspaces[0].test_split(Direction::Horizontal); + crate::ui::compute_view(&mut app.state, Rect::new(0, 0, 106, 20)); + let border = app.state.view.split_borders[0].clone(); + let before = capture_snapshot(&app.state); + let drag_row = border.area.y.saturating_add(1); + + app.handle_mouse(mouse( + MouseEventKind::Down(MouseButton::Left), + border.pos, + drag_row, + )); + app.handle_mouse(mouse( + MouseEventKind::Drag(MouseButton::Left), + border.pos.saturating_add(6), + drag_row, + )); + + let after = capture_snapshot(&app.state); + assert_ne!(root_layout_ratio(&before), root_layout_ratio(&after)); + } + + #[test] + fn wheel_routing_prefers_mouse_reporting() { + let input_state = crate::pane::InputState { + alternate_screen: true, + application_cursor: false, + bracketed_paste: false, + focus_reporting: false, + mouse_protocol_mode: crate::input::MouseProtocolMode::ButtonMotion, + mouse_protocol_encoding: crate::input::MouseProtocolEncoding::Sgr, + mouse_alternate_scroll: true, + }; + + assert_eq!(wheel_routing(input_state), WheelRouting::MouseReport); + } + + #[test] + fn wheel_routing_uses_alternate_scroll_in_fullscreen_without_mouse_reporting() { + let input_state = crate::pane::InputState { + alternate_screen: true, + application_cursor: false, + bracketed_paste: false, + focus_reporting: false, + mouse_protocol_mode: crate::input::MouseProtocolMode::None, + mouse_protocol_encoding: crate::input::MouseProtocolEncoding::Default, + mouse_alternate_scroll: true, + }; + + assert_eq!(wheel_routing(input_state), WheelRouting::AlternateScroll); + } + + #[test] + fn wheel_routing_falls_back_to_host_scrollback() { + let input_state = crate::pane::InputState { + alternate_screen: false, + application_cursor: false, + bracketed_paste: false, + focus_reporting: false, + mouse_protocol_mode: crate::input::MouseProtocolMode::None, + mouse_protocol_encoding: crate::input::MouseProtocolEncoding::Default, + mouse_alternate_scroll: true, + }; + + assert_eq!(wheel_routing(input_state), WheelRouting::HostScroll); + } +} diff --git a/src/app/input/navigate.rs b/src/app/input/navigate.rs new file mode 100644 index 00000000..26769dfe --- /dev/null +++ b/src/app/input/navigate.rs @@ -0,0 +1,780 @@ +use std::process::{Command, Stdio}; + +use crossterm::event::{KeyCode, KeyEvent}; +use ratatui::layout::Direction; + +use crate::{ + app::{ + state::{key_matches, AppState, Mode}, + App, + }, + layout::NavDirection, +}; + +pub(crate) fn terminal_direct_navigation_action( + state: &AppState, + key: &KeyEvent, +) -> Option<NavigateAction> { + let kb = &state.keybinds; + if kb + .previous_workspace + .is_some_and(|(code, mods)| key_matches(key, code, mods)) + { + return Some(NavigateAction::PreviousWorkspace); + } + if kb + .next_workspace + .is_some_and(|(code, mods)| key_matches(key, code, mods)) + { + return Some(NavigateAction::NextWorkspace); + } + if kb + .previous_tab + .is_some_and(|(code, mods)| key_matches(key, code, mods)) + { + return Some(NavigateAction::PreviousTab); + } + if kb + .next_tab + .is_some_and(|(code, mods)| key_matches(key, code, mods)) + { + return Some(NavigateAction::NextTab); + } + if kb + .focus_pane_left + .is_some_and(|(code, mods)| key_matches(key, code, mods)) + { + return Some(NavigateAction::FocusPaneLeft); + } + if kb + .focus_pane_down + .is_some_and(|(code, mods)| key_matches(key, code, mods)) + { + return Some(NavigateAction::FocusPaneDown); + } + if kb + .focus_pane_up + .is_some_and(|(code, mods)| key_matches(key, code, mods)) + { + return Some(NavigateAction::FocusPaneUp); + } + if kb + .focus_pane_right + .is_some_and(|(code, mods)| key_matches(key, code, mods)) + { + return Some(NavigateAction::FocusPaneRight); + } + None +} + +impl App { + pub(super) fn handle_navigate_key(&mut self, key: KeyEvent) { + self.state.update_dismissed = true; + + if self.state.is_prefix(&key) || key.code == KeyCode::Esc { + leave_navigate_mode(&mut self.state); + return; + } + + if let Some(action) = navigate_action_for_key(&self.state, &key) { + execute_navigate_action(&mut self.state, action); + return; + } + + if handle_navigate_reserved_key(&mut self.state, key) { + return; + } + + if let Some(binding) = navigate_custom_command_for_key(&self.state, &key) { + self.launch_custom_command(binding); + } + } + + fn launch_custom_command(&mut self, binding: crate::config::CustomCommandKeybind) { + let previous_toast = self.state.toast.clone(); + let result = match binding.action { + crate::config::CustomCommandAction::Shell => self.spawn_custom_command(&binding), + crate::config::CustomCommandAction::Pane => self.spawn_pane_command(&binding.command), + }; + match result { + Ok(()) => leave_navigate_mode(&mut self.state), + Err(err) => { + self.state.toast = Some(crate::app::state::ToastNotification { + kind: crate::app::state::ToastKind::NeedsAttention, + title: "custom command failed".to_string(), + context: err.to_string(), + }); + self.sync_toast_deadline(previous_toast); + } + } + } + + fn custom_command_env(&self) -> (Vec<(String, String)>, Option<std::path::PathBuf>) { + let mut env = vec![( + crate::api::SOCKET_PATH_ENV_VAR.to_string(), + crate::api::socket_path().display().to_string(), + )]; + if let Ok(current_exe) = std::env::current_exe() { + env.push(( + "HERDR_BIN_PATH".to_string(), + current_exe.display().to_string(), + )); + } + + let mut cwd = None; + if let Some(ws_idx) = self.state.active { + env.push(( + "HERDR_ACTIVE_WORKSPACE_ID".to_string(), + self.public_workspace_id(ws_idx), + )); + if let Some(workspace) = self.state.workspaces.get(ws_idx) { + let tab_idx = workspace.active_tab_index(); + if let Some(tab_id) = self.public_tab_id(ws_idx, tab_idx) { + env.push(("HERDR_ACTIVE_TAB_ID".to_string(), tab_id)); + } + if let Some(pane_id) = workspace.focused_pane_id() { + if let Some(public_pane_id) = self.public_pane_id(ws_idx, pane_id) { + env.push(("HERDR_ACTIVE_PANE_ID".to_string(), public_pane_id)); + } + if let Some(pane_cwd) = workspace + .active_tab() + .and_then(|tab| tab.cwd_for_pane(pane_id)) + { + env.push(( + "HERDR_ACTIVE_PANE_CWD".to_string(), + pane_cwd.display().to_string(), + )); + if pane_cwd.is_dir() { + cwd = Some(pane_cwd); + } + } + } + } + } + (env, cwd) + } + + fn spawn_custom_command( + &self, + binding: &crate::config::CustomCommandKeybind, + ) -> std::io::Result<()> { + let mut command = Command::new("/bin/sh"); + command + .arg("-lc") + .arg(&binding.command) + .stdin(Stdio::null()) + .stdout(Stdio::null()) + .stderr(Stdio::null()); + let (env, cwd) = self.custom_command_env(); + command.envs(env); + if let Some(cwd) = cwd { + command.current_dir(cwd); + } + command.spawn()?; + Ok(()) + } + + fn spawn_pane_command(&mut self, command: &str) -> std::io::Result<()> { + let Some(ws_idx) = self.state.active else { + return Err(std::io::Error::other("no active workspace")); + }; + let (rows, cols) = self.state.estimate_pane_size(); + let new_rows = rows.max(4); + let new_cols = cols.max(10); + let (env, _) = self.custom_command_env(); + + let ws = self + .state + .workspaces + .get_mut(ws_idx) + .ok_or_else(|| std::io::Error::other("active workspace disappeared"))?; + let tab_idx = ws.active_tab_index(); + let previous_focus = ws + .focused_pane_id() + .ok_or_else(|| std::io::Error::other("no focused pane"))?; + let previous_zoomed = ws.active_tab().map(|tab| tab.zoomed).unwrap_or(false); + let cwd = ws + .active_tab() + .and_then(|tab| tab.cwd_for_pane(previous_focus)); + let new_pane_id = ws.split_focused_command( + Direction::Horizontal, + new_rows, + new_cols, + cwd, + command, + &env, + self.state.pane_scrollback_limit_bytes, + self.state.host_terminal_theme, + )?; + ws.active_tab_mut() + .expect("workspace must have an active tab") + .layout + .focus_pane(new_pane_id); + ws.active_tab_mut() + .expect("workspace must have an active tab") + .zoomed = true; + self.overlay_panes.insert( + new_pane_id, + super::super::OverlayPaneState { + ws_idx, + tab_idx, + previous_focus, + previous_zoomed, + }, + ); + self.state.mode = Mode::Terminal; + Ok(()) + } +} + +fn navigate_custom_command_for_key( + state: &AppState, + key: &KeyEvent, +) -> Option<crate::config::CustomCommandKeybind> { + state + .keybinds + .custom_commands + .iter() + .find(|binding| key_matches(key, binding.key.0, binding.key.1)) + .cloned() +} + +pub(super) fn handle_navigate_reserved_key(state: &mut AppState, key: KeyEvent) -> bool { + match key.code { + KeyCode::Char('q') => { + super::modal::request_quit_or_detach(state); + leave_navigate_mode(state); + true + } + KeyCode::Enter => { + if !state.workspaces.is_empty() { + state.switch_workspace(state.selected); + leave_navigate_mode(state); + } + true + } + KeyCode::Char(c @ '1'..='9') => { + let idx = (c as usize) - ('1' as usize); + if idx < state.workspaces.len() { + state.switch_workspace(idx); + leave_navigate_mode(state); + } + true + } + KeyCode::Char('s') => { + super::settings::open_settings(state); + true + } + KeyCode::Char('?') => { + super::modal::open_keybind_help(state); + true + } + KeyCode::Up => { + if state.selected > 0 { + state.selected -= 1; + state.ensure_workspace_visible(state.selected); + } + true + } + KeyCode::Down => { + if !state.workspaces.is_empty() && state.selected < state.workspaces.len() - 1 { + state.selected += 1; + state.ensure_workspace_visible(state.selected); + } + true + } + KeyCode::Char('h') | KeyCode::Left => { + state.navigate_pane(NavDirection::Left); + true + } + KeyCode::Char('j') => { + state.navigate_pane(NavDirection::Down); + true + } + KeyCode::Char('k') => { + state.navigate_pane(NavDirection::Up); + true + } + KeyCode::Char('l') | KeyCode::Right => { + state.navigate_pane(NavDirection::Right); + true + } + KeyCode::Tab => { + state.cycle_pane(false); + true + } + KeyCode::BackTab => { + state.cycle_pane(true); + true + } + _ => false, + } +} + +#[allow(dead_code)] // exercised in input unit tests; production uses App::handle_navigate_key +pub(crate) fn handle_navigate_key(state: &mut AppState, key: KeyEvent) { + state.update_dismissed = true; + + if state.is_prefix(&key) || key.code == KeyCode::Esc { + leave_navigate_mode(state); + return; + } + + if let Some(action) = navigate_action_for_key(state, &key) { + execute_navigate_action(state, action); + return; + } + + let _ = handle_navigate_reserved_key(state, key); +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub(crate) enum NavigateAction { + NewWorkspace, + RenameWorkspace, + CloseWorkspace, + PreviousWorkspace, + NextWorkspace, + NewTab, + RenameTab, + PreviousTab, + NextTab, + CloseTab, + FocusPaneLeft, + FocusPaneDown, + FocusPaneUp, + FocusPaneRight, + SplitVertical, + SplitHorizontal, + ClosePane, + Fullscreen, + EnterResizeMode, + ToggleSidebar, + Detach, +} + +fn navigate_action_for_key(state: &AppState, key: &KeyEvent) -> Option<NavigateAction> { + let kb = &state.keybinds; + if key_matches(key, kb.new_workspace.0, kb.new_workspace.1) { + return Some(NavigateAction::NewWorkspace); + } + if key_matches(key, kb.rename_workspace.0, kb.rename_workspace.1) { + return Some(NavigateAction::RenameWorkspace); + } + if key_matches(key, kb.close_workspace.0, kb.close_workspace.1) { + return Some(NavigateAction::CloseWorkspace); + } + if kb + .previous_workspace + .is_some_and(|(code, mods)| key_matches(key, code, mods)) + { + return Some(NavigateAction::PreviousWorkspace); + } + if kb + .next_workspace + .is_some_and(|(code, mods)| key_matches(key, code, mods)) + { + return Some(NavigateAction::NextWorkspace); + } + if key_matches(key, kb.new_tab.0, kb.new_tab.1) { + return Some(NavigateAction::NewTab); + } + if kb + .rename_tab + .is_some_and(|(code, mods)| key_matches(key, code, mods)) + { + return Some(NavigateAction::RenameTab); + } + if kb + .previous_tab + .is_some_and(|(code, mods)| key_matches(key, code, mods)) + { + return Some(NavigateAction::PreviousTab); + } + if kb + .next_tab + .is_some_and(|(code, mods)| key_matches(key, code, mods)) + { + return Some(NavigateAction::NextTab); + } + if kb + .close_tab + .is_some_and(|(code, mods)| key_matches(key, code, mods)) + { + return Some(NavigateAction::CloseTab); + } + if key_matches(key, kb.split_vertical.0, kb.split_vertical.1) { + return Some(NavigateAction::SplitVertical); + } + if key_matches(key, kb.split_horizontal.0, kb.split_horizontal.1) { + return Some(NavigateAction::SplitHorizontal); + } + if key_matches(key, kb.close_pane.0, kb.close_pane.1) { + return Some(NavigateAction::ClosePane); + } + if key_matches(key, kb.fullscreen.0, kb.fullscreen.1) { + return Some(NavigateAction::Fullscreen); + } + if key_matches(key, kb.resize_mode.0, kb.resize_mode.1) { + return Some(NavigateAction::EnterResizeMode); + } + if key_matches(key, kb.toggle_sidebar.0, kb.toggle_sidebar.1) { + return Some(NavigateAction::ToggleSidebar); + } + if kb + .detach + .is_some_and(|(code, mods)| key_matches(key, code, mods)) + { + return Some(NavigateAction::Detach); + } + None +} + +pub(super) fn execute_navigate_action(state: &mut AppState, action: NavigateAction) { + match action { + NavigateAction::NewWorkspace => { + state.request_new_workspace = true; + leave_navigate_mode(state); + } + NavigateAction::RenameWorkspace => { + if !state.workspaces.is_empty() { + super::modal::open_rename_workspace(state, state.selected); + } + } + NavigateAction::CloseWorkspace => { + if !state.workspaces.is_empty() { + if state.confirm_close { + super::modal::open_confirm_close(state); + } else { + state.close_selected_workspace(); + leave_navigate_mode(state); + } + } + } + NavigateAction::PreviousWorkspace => { + state.previous_workspace(); + leave_navigate_mode(state); + } + NavigateAction::NextWorkspace => { + state.next_workspace(); + leave_navigate_mode(state); + } + NavigateAction::NewTab => super::modal::open_new_tab_dialog(state), + NavigateAction::RenameTab => super::modal::open_rename_active_tab(state, false), + NavigateAction::PreviousTab => { + state.previous_tab(); + leave_navigate_mode(state); + } + NavigateAction::NextTab => { + state.next_tab(); + leave_navigate_mode(state); + } + NavigateAction::CloseTab => { + state.close_tab(); + leave_navigate_mode(state); + } + NavigateAction::FocusPaneLeft => state.navigate_pane(NavDirection::Left), + NavigateAction::FocusPaneDown => state.navigate_pane(NavDirection::Down), + NavigateAction::FocusPaneUp => state.navigate_pane(NavDirection::Up), + NavigateAction::FocusPaneRight => state.navigate_pane(NavDirection::Right), + NavigateAction::SplitVertical => { + state.split_pane(Direction::Horizontal); + leave_navigate_mode(state); + } + NavigateAction::SplitHorizontal => { + state.split_pane(Direction::Vertical); + leave_navigate_mode(state); + } + NavigateAction::ClosePane => { + state.close_pane(); + leave_navigate_mode(state); + } + NavigateAction::Fullscreen => { + state.toggle_fullscreen(); + leave_navigate_mode(state); + } + NavigateAction::EnterResizeMode => state.mode = Mode::Resize, + NavigateAction::ToggleSidebar => { + state.sidebar_collapsed = !state.sidebar_collapsed; + leave_navigate_mode(state); + } + NavigateAction::Detach => { + state.detach_requested = true; + leave_navigate_mode(state); + } + } +} + +fn leave_navigate_mode(state: &mut AppState) { + if state.active.is_some() { + state.mode = Mode::Terminal; + } +} + +#[cfg(test)] +mod tests { + use std::time::Duration; + + use crossterm::event::{KeyCode, KeyEvent, KeyModifiers}; + use ratatui::layout::{Direction, Rect}; + + use super::super::{state_with_workspaces, unique_temp_path, wait_for_file}; + use super::*; + use crate::{app::App, config::Config, input::TerminalKey, workspace::Workspace}; + + #[test] + fn custom_rename_key_enters_rename_mode() { + let mut state = state_with_workspaces(&["test"]); + state.keybinds.rename_workspace = (KeyCode::Char('g'), KeyModifiers::empty()); + state.keybinds.rename_workspace_label = "g".into(); + + handle_navigate_key( + &mut state, + KeyEvent::new(KeyCode::Char('g'), KeyModifiers::empty()), + ); + + assert_eq!(state.mode, Mode::RenameWorkspace); + assert_eq!(state.name_input, "test"); + } + + #[test] + fn custom_new_workspace_key_requests_and_exits_navigate() { + let mut state = state_with_workspaces(&["test"]); + state.keybinds.new_workspace = (KeyCode::Char('g'), KeyModifiers::empty()); + state.keybinds.new_workspace_label = "g".into(); + + handle_navigate_key( + &mut state, + KeyEvent::new(KeyCode::Char('g'), KeyModifiers::empty()), + ); + + assert!(state.request_new_workspace); + assert_eq!(state.mode, Mode::Terminal); + } + + #[test] + fn custom_sidebar_toggle_key_toggles_and_exits_navigate() { + let mut state = state_with_workspaces(&["test"]); + state.keybinds.toggle_sidebar = (KeyCode::Char('g'), KeyModifiers::empty()); + state.keybinds.toggle_sidebar_label = "g".into(); + assert!(!state.sidebar_collapsed); + + handle_navigate_key( + &mut state, + KeyEvent::new(KeyCode::Char('g'), KeyModifiers::empty()), + ); + + assert!(state.sidebar_collapsed); + assert_eq!(state.mode, Mode::Terminal); + } + + #[test] + fn custom_resize_key_enters_resize_mode() { + let mut state = state_with_workspaces(&["test"]); + state.keybinds.resize_mode = (KeyCode::Char('g'), KeyModifiers::empty()); + state.keybinds.resize_mode_label = "g".into(); + + handle_navigate_key( + &mut state, + KeyEvent::new(KeyCode::Char('g'), KeyModifiers::empty()), + ); + + assert_eq!(state.mode, Mode::Resize); + } + + #[test] + fn movement_action_stays_in_navigate_mode() { + let mut state = state_with_workspaces(&["a", "b"]); + state.selected = 0; + + handle_navigate_key( + &mut state, + KeyEvent::new(KeyCode::Down, KeyModifiers::empty()), + ); + + assert_eq!(state.selected, 1); + assert_eq!(state.mode, Mode::Navigate); + } + + #[test] + fn terminal_direct_focus_pane_shortcut_maps_to_navigation_action() { + let mut state = state_with_workspaces(&["test"]); + state.keybinds.focus_pane_left = Some((KeyCode::Left, KeyModifiers::ALT)); + state.keybinds.focus_pane_left_label = Some("alt+left".into()); + + let action = terminal_direct_navigation_action( + &state, + &KeyEvent::new(KeyCode::Left, KeyModifiers::ALT), + ); + + assert_eq!(action, Some(NavigateAction::FocusPaneLeft)); + } + + #[tokio::test] + async fn custom_command_runs_from_prefix_key_in_navigate_mode() { + let (_api_tx, api_rx) = tokio::sync::mpsc::unbounded_channel(); + let mut app = App::new( + &Config::default(), + true, + None, + None, + api_rx, + crate::api::EventHub::default(), + ); + app.state.workspaces = vec![Workspace::test_new("test")]; + app.state.active = Some(0); + app.state.selected = 0; + app.state.mode = Mode::Terminal; + + let output_path = unique_temp_path("custom-command-keybind"); + let command = format!( + "printf '%s\\n%s\\n%s\\n' \"$HERDR_ACTIVE_WORKSPACE_ID\" \"$HERDR_ACTIVE_TAB_ID\" \"$HERDR_ACTIVE_PANE_ID\" > '{}'", + output_path.display() + ); + app.state.keybinds.custom_commands = vec![crate::config::CustomCommandKeybind { + key: (KeyCode::Char('g'), KeyModifiers::empty()), + label: "g".into(), + command, + action: crate::config::CustomCommandAction::Shell, + }]; + + app.handle_key(TerminalKey::new( + app.state.prefix_code, + app.state.prefix_mods, + )) + .await; + assert_eq!(app.state.mode, Mode::Navigate); + + app.handle_key(TerminalKey::new(KeyCode::Char('g'), KeyModifiers::empty())) + .await; + + let content = wait_for_file(&output_path); + let lines: Vec<&str> = content.lines().collect(); + assert_eq!(lines.len(), 3); + assert_eq!(lines[0], app.state.workspaces[0].id); + assert_eq!(lines[1], format!("{}:1", app.state.workspaces[0].id)); + assert_eq!(lines[2], format!("{}-1", app.state.workspaces[0].id)); + assert_eq!(app.state.mode, Mode::Terminal); + + let _ = std::fs::remove_file(output_path); + } + + #[tokio::test] + async fn pane_overlay_command_opens_and_closes_after_exit() { + let (_api_tx, api_rx) = tokio::sync::mpsc::unbounded_channel(); + let mut app = App::new( + &Config::default(), + true, + None, + None, + api_rx, + crate::api::EventHub::default(), + ); + let workspace = Workspace::new( + std::env::current_dir().unwrap_or_else(|_| "/".into()), + 24, + 80, + app.state.pane_scrollback_limit_bytes, + app.state.host_terminal_theme, + app.event_tx.clone(), + app.render_notify.clone(), + app.render_dirty.clone(), + ) + .expect("workspace should spawn"); + app.state.workspaces = vec![workspace]; + app.state.active = Some(0); + app.state.selected = 0; + app.state.mode = Mode::Terminal; + + let output_path = unique_temp_path("custom-pane-command"); + let command = format!("printf done > '{}'", output_path.display()); + app.state.keybinds.custom_commands = vec![crate::config::CustomCommandKeybind { + key: (KeyCode::Char('g'), KeyModifiers::empty()), + label: "g".into(), + command, + action: crate::config::CustomCommandAction::Pane, + }]; + + app.handle_key(TerminalKey::new( + app.state.prefix_code, + app.state.prefix_mods, + )) + .await; + app.handle_key(TerminalKey::new(KeyCode::Char('g'), KeyModifiers::empty())) + .await; + + assert_eq!(app.state.workspaces[0].tabs[0].layout.pane_count(), 2); + assert!(app.state.workspaces[0].tabs[0].zoomed); + + let _ = wait_for_file(&output_path); + let deadline = std::time::Instant::now() + Duration::from_secs(2); + while std::time::Instant::now() < deadline { + if app.drain_internal_events() + && app.state.workspaces[0].tabs[0].layout.pane_count() == 1 + { + break; + } + std::thread::sleep(Duration::from_millis(20)); + } + + assert_eq!(app.state.workspaces[0].tabs[0].layout.pane_count(), 1); + assert!(!app.state.workspaces[0].tabs[0].zoomed); + assert_eq!(app.state.mode, Mode::Terminal); + let _ = std::fs::remove_file(output_path); + } + + #[test] + fn fullscreen_action_exits_navigate_mode() { + let mut state = state_with_workspaces(&["test"]); + state.workspaces[0].test_split(Direction::Horizontal); + state.keybinds.fullscreen = (KeyCode::Char('g'), KeyModifiers::empty()); + state.keybinds.fullscreen_label = "g".into(); + + handle_navigate_key( + &mut state, + KeyEvent::new(KeyCode::Char('g'), KeyModifiers::empty()), + ); + + assert!(state.workspaces[0].zoomed); + assert_eq!(state.mode, Mode::Terminal); + } + + #[test] + fn question_mark_opens_keybind_help_from_navigate() { + let mut state = state_with_workspaces(&["test"]); + + handle_navigate_key( + &mut state, + KeyEvent::new(KeyCode::Char('?'), KeyModifiers::SHIFT), + ); + + assert_eq!(state.mode, Mode::KeybindHelp); + } + + #[test] + fn new_tab_action_opens_dialog_without_creating_tab() { + let mut state = state_with_workspaces(&["test"]); + + execute_navigate_action(&mut state, NavigateAction::NewTab); + + assert_eq!(state.mode, Mode::RenameTab); + assert!(state.creating_new_tab); + assert_eq!(state.name_input, "2"); + assert!(state.name_input_replace_on_type); + assert!(!state.request_new_tab); + assert_eq!(state.workspaces[0].tabs.len(), 1); + } + + #[test] + fn persistence_mode_navigate_q_detaches_instead_of_quitting_server() { + let mut state = crate::app::state::AppState::test_new(); + state.quit_detaches = true; + + assert!(handle_navigate_reserved_key( + &mut state, + KeyEvent::new(KeyCode::Char('q'), KeyModifiers::empty()) + )); + assert!(state.detach_requested); + assert!(!state.should_quit); + } +} diff --git a/src/app/input/overlays.rs b/src/app/input/overlays.rs new file mode 100644 index 00000000..6475895e --- /dev/null +++ b/src/app/input/overlays.rs @@ -0,0 +1,483 @@ +use crossterm::event::{MouseButton, MouseEvent, MouseEventKind}; +use ratatui::{ + layout::Rect, + widgets::{Block, Borders}, +}; + +use crate::app::{ + state::{AppState, DragState, DragTarget, Mode}, + App, +}; + +use super::{ + modal::{leave_modal, modal_action_from_buttons, ModalAction}, + ScrollbarClickTarget, +}; + +impl App { + pub(super) fn handle_overlay_mouse(&mut self, mouse: MouseEvent) -> bool { + if self.state.mode == Mode::ReleaseNotes { + match mouse.kind { + MouseEventKind::Down(MouseButton::Left) + if self + .state + .release_notes_close_button_at(mouse.column, mouse.row) => + { + self.dismiss_release_notes(); + } + MouseEventKind::Down(MouseButton::Left) => { + if let Some(target) = self + .state + .release_notes_scrollbar_target_at(mouse.column, mouse.row) + { + match target { + ScrollbarClickTarget::Thumb { grab_row_offset } => { + self.state.drag = Some(DragState { + target: DragTarget::ReleaseNotesScrollbar { grab_row_offset }, + }); + } + ScrollbarClickTarget::Track { offset_from_bottom } => { + self.state + .set_release_notes_offset_from_bottom(offset_from_bottom); + } + } + } + } + MouseEventKind::Drag(MouseButton::Left) => { + if let Some(DragState { + target: DragTarget::ReleaseNotesScrollbar { grab_row_offset }, + }) = &self.state.drag + { + if let Some(offset_from_bottom) = self + .state + .release_notes_offset_for_drag_row(mouse.row, *grab_row_offset) + { + self.state + .set_release_notes_offset_from_bottom(offset_from_bottom); + } + } + } + MouseEventKind::Up(MouseButton::Left) => { + self.state.drag = None; + } + MouseEventKind::ScrollUp => self.scroll_release_notes(-3), + MouseEventKind::ScrollDown => self.scroll_release_notes(3), + _ => {} + } + return true; + } + + if self.state.mode == Mode::KeybindHelp { + match mouse.kind { + MouseEventKind::Down(MouseButton::Left) + if self + .state + .keybind_help_close_button_at(mouse.column, mouse.row) => + { + leave_modal(&mut self.state); + } + MouseEventKind::Down(MouseButton::Left) => { + if let Some(target) = self + .state + .keybind_help_scrollbar_target_at(mouse.column, mouse.row) + { + match target { + ScrollbarClickTarget::Thumb { grab_row_offset } => { + self.state.drag = Some(DragState { + target: DragTarget::KeybindHelpScrollbar { grab_row_offset }, + }); + } + ScrollbarClickTarget::Track { offset_from_bottom } => { + self.state + .set_keybind_help_offset_from_bottom(offset_from_bottom); + } + } + } else { + let rect = self.state.keybind_help_popup_rect(); + let inside = mouse.column >= rect.x + && mouse.column < rect.x + rect.width + && mouse.row >= rect.y + && mouse.row < rect.y + rect.height; + if !inside { + leave_modal(&mut self.state); + } + } + } + MouseEventKind::Drag(MouseButton::Left) => { + if let Some(DragState { + target: DragTarget::KeybindHelpScrollbar { grab_row_offset }, + }) = &self.state.drag + { + if let Some(offset_from_bottom) = self + .state + .keybind_help_offset_for_drag_row(mouse.row, *grab_row_offset) + { + self.state + .set_keybind_help_offset_from_bottom(offset_from_bottom); + } + } + } + MouseEventKind::Up(MouseButton::Left) => { + self.state.drag = None; + } + MouseEventKind::ScrollUp => self.state.scroll_keybind_help(-3), + MouseEventKind::ScrollDown => self.state.scroll_keybind_help(3), + _ => {} + } + return true; + } + + false + } +} + +impl AppState { + pub(super) fn onboarding_full_area(&self) -> Rect { + self.view.sidebar_rect.union(self.view.terminal_area) + } + + pub(super) fn onboarding_modal_inner(&self, popup_w: u16, popup_h: u16) -> Option<Rect> { + let area = self.onboarding_full_area(); + let popup_w = popup_w.min(area.width.saturating_sub(4)); + let popup_h = popup_h.min(area.height.saturating_sub(2)); + if popup_w < 4 || popup_h < 4 { + return None; + } + let popup_x = area.x + (area.width.saturating_sub(popup_w)) / 2; + let popup_y = area.y + (area.height.saturating_sub(popup_h)) / 2; + let popup = Rect::new(popup_x, popup_y, popup_w, popup_h); + Some(Block::default().borders(Borders::ALL).inner(popup)) + } + + fn release_notes_modal_inner(&self) -> Option<Rect> { + self.onboarding_modal_inner( + crate::ui::RELEASE_NOTES_MODAL_SIZE.0, + crate::ui::RELEASE_NOTES_MODAL_SIZE.1, + ) + } + + fn release_notes_close_button_at(&self, col: u16, row: u16) -> bool { + let Some(inner) = self.release_notes_modal_inner() else { + return false; + }; + if inner.height < 4 || inner.width < 12 { + return false; + } + let button = + crate::ui::release_notes_close_button_rect(Rect::new(inner.x, inner.y, inner.width, 1)); + col >= button.x + && col < button.x + button.width + && row >= button.y + && row < button.y + button.height + } + + pub(super) fn rename_modal_inner(&self) -> Option<Rect> { + self.onboarding_modal_inner(56, 7) + } + + fn release_notes_body_rect(&self) -> Option<Rect> { + let inner = self.release_notes_modal_inner()?; + if inner.height < 8 || inner.width < 4 { + return None; + } + let body = crate::ui::modal_stack_areas(inner, 2, 1, 0, 1).content; + let preview = self + .release_notes + .as_ref() + .is_some_and(|notes| notes.preview); + Some(crate::ui::release_notes_sections(body, preview).notes_body) + } + + fn release_notes_scroll_metrics(&self) -> Option<crate::pane::ScrollMetrics> { + let notes = self.release_notes.as_ref()?; + let body = self.release_notes_body_rect()?; + let viewport_rows = body.height.max(1) as usize; + let lines = crate::ui::release_notes_display_lines(notes, &self.palette); + + let rows_for_width = |wrap_width: usize| { + lines + .iter() + .map(|(width, _)| width.max(&1).div_ceil(wrap_width.max(1))) + .sum::<usize>() + }; + + let full_width = body.width.max(1) as usize; + let mut total_rows = rows_for_width(full_width); + let wrap_width = if total_rows > viewport_rows && full_width > 1 { + body.width.saturating_sub(1).max(1) as usize + } else { + full_width + }; + total_rows = rows_for_width(wrap_width); + + let max_offset_from_bottom = total_rows.saturating_sub(viewport_rows); + Some(crate::pane::ScrollMetrics { + offset_from_bottom: max_offset_from_bottom.saturating_sub(notes.scroll as usize), + max_offset_from_bottom, + viewport_rows, + }) + } + + pub(crate) fn release_notes_max_scroll(&self) -> u16 { + self.release_notes_scroll_metrics() + .map(|metrics| metrics.max_offset_from_bottom as u16) + .unwrap_or(0) + } + + fn release_notes_scrollbar_target_at( + &self, + col: u16, + row: u16, + ) -> Option<ScrollbarClickTarget> { + let body = self.release_notes_body_rect()?; + let metrics = self.release_notes_scroll_metrics()?; + let track = crate::ui::release_notes_scrollbar_rect(body, metrics)?; + if !(col >= track.x + && col < track.x + track.width + && row >= track.y + && row < track.y + track.height) + { + return None; + } + if let Some(grab_row_offset) = crate::ui::scrollbar_thumb_grab_offset(metrics, track, row) { + Some(ScrollbarClickTarget::Thumb { grab_row_offset }) + } else { + Some(ScrollbarClickTarget::Track { + offset_from_bottom: crate::ui::scrollbar_offset_from_row(metrics, track, row), + }) + } + } + + fn release_notes_offset_for_drag_row(&self, row: u16, grab_row_offset: u16) -> Option<usize> { + let body = self.release_notes_body_rect()?; + let metrics = self.release_notes_scroll_metrics()?; + let track = crate::ui::release_notes_scrollbar_rect(body, metrics)?; + Some(crate::ui::scrollbar_offset_from_drag_row( + metrics, + track, + row, + grab_row_offset, + )) + } + + fn set_release_notes_offset_from_bottom(&mut self, offset_from_bottom: usize) { + let max_scroll = self.release_notes_max_scroll() as usize; + if let Some(notes) = &mut self.release_notes { + notes.scroll = max_scroll.saturating_sub(offset_from_bottom) as u16; + } + } + + pub(super) fn handle_onboarding_mouse(&mut self, mouse: MouseEvent) { + if !matches!(mouse.kind, MouseEventKind::Down(MouseButton::Left)) { + return; + } + + match self.onboarding_step { + 0 => { + let Some(inner) = self.onboarding_modal_inner(64, 16) else { + return; + }; + let actions = crate::ui::modal_stack_areas(inner, 2, 0, 1, 1) + .actions + .unwrap_or_default(); + let button = crate::ui::onboarding_welcome_continue_rect(actions); + if matches!(mouse.kind, MouseEventKind::Down(MouseButton::Left)) + && modal_action_from_buttons( + mouse.column, + mouse.row, + &[(button, ModalAction::Continue)], + ) == Some(ModalAction::Continue) + { + self.onboarding_step = 1; + } + } + _ => { + let Some(inner) = self.onboarding_modal_inner(56, 14) else { + return; + }; + let stack = crate::ui::modal_stack_areas(inner, 3, 0, 1, 1); + if mouse.row >= stack.content.y && mouse.row < stack.content.y + 4 { + self.onboarding_list + .select((mouse.row - stack.content.y) as usize); + return; + } + + let (back, save) = crate::ui::onboarding_notification_button_rects( + stack.actions.unwrap_or_default(), + ); + if matches!(mouse.kind, MouseEventKind::Down(MouseButton::Left)) { + match modal_action_from_buttons( + mouse.column, + mouse.row, + &[(back, ModalAction::Back), (save, ModalAction::Save)], + ) { + Some(ModalAction::Back) => self.onboarding_step = 0, + Some(ModalAction::Save) => self.request_complete_onboarding = true, + _ => {} + } + } + } + } + } + + pub(super) fn keybind_help_popup_rect(&self) -> Rect { + crate::ui::centered_popup_rect(self.screen_rect(), 76, 22).unwrap_or_default() + } + + fn keybind_help_modal_inner(&self) -> Option<Rect> { + self.onboarding_modal_inner(76, 22) + } + + fn keybind_help_close_button_at(&self, col: u16, row: u16) -> bool { + let Some(inner) = self.keybind_help_modal_inner() else { + return false; + }; + if inner.height < 4 || inner.width < 12 { + return false; + } + let button = + crate::ui::release_notes_close_button_rect(Rect::new(inner.x, inner.y, inner.width, 1)); + col >= button.x + && col < button.x + button.width + && row >= button.y + && row < button.y + button.height + } + + fn keybind_help_body_rect(&self) -> Option<Rect> { + let inner = self.keybind_help_modal_inner()?; + if inner.height < 6 || inner.width < 4 { + return None; + } + Some(crate::ui::modal_stack_areas(inner, 2, 1, 0, 1).content) + } + + fn keybind_help_scroll_metrics(&self) -> Option<crate::pane::ScrollMetrics> { + let body = self.keybind_help_body_rect()?; + let viewport_rows = body.height.max(1) as usize; + let wrap_width = body.width.max(1) as usize; + let total_rows = crate::ui::keybind_help_lines(self) + .into_iter() + .map(|(width, _)| width.max(1).div_ceil(wrap_width)) + .sum::<usize>(); + let max_offset_from_bottom = total_rows.saturating_sub(viewport_rows); + Some(crate::pane::ScrollMetrics { + offset_from_bottom: max_offset_from_bottom + .saturating_sub(self.keybind_help.scroll as usize), + max_offset_from_bottom, + viewport_rows, + }) + } + + fn keybind_help_scrollbar_target_at(&self, col: u16, row: u16) -> Option<ScrollbarClickTarget> { + let body = self.keybind_help_body_rect()?; + let metrics = self.keybind_help_scroll_metrics()?; + let track = crate::ui::release_notes_scrollbar_rect(body, metrics)?; + if !(col >= track.x + && col < track.x + track.width + && row >= track.y + && row < track.y + track.height) + { + return None; + } + if let Some(grab_row_offset) = crate::ui::scrollbar_thumb_grab_offset(metrics, track, row) { + Some(ScrollbarClickTarget::Thumb { grab_row_offset }) + } else { + Some(ScrollbarClickTarget::Track { + offset_from_bottom: crate::ui::scrollbar_offset_from_row(metrics, track, row), + }) + } + } + + fn keybind_help_offset_for_drag_row(&self, row: u16, grab_row_offset: u16) -> Option<usize> { + let body = self.keybind_help_body_rect()?; + let metrics = self.keybind_help_scroll_metrics()?; + let track = crate::ui::release_notes_scrollbar_rect(body, metrics)?; + Some(crate::ui::scrollbar_offset_from_drag_row( + metrics, + track, + row, + grab_row_offset, + )) + } + + pub(crate) fn keybind_help_max_scroll(&self) -> u16 { + self.keybind_help_scroll_metrics() + .map(|metrics| metrics.max_offset_from_bottom as u16) + .unwrap_or(0) + } + + fn set_keybind_help_offset_from_bottom(&mut self, offset_from_bottom: usize) { + let max_scroll = self.keybind_help_max_scroll() as usize; + self.keybind_help.scroll = max_scroll.saturating_sub(offset_from_bottom) as u16; + } + + pub(super) fn scroll_keybind_help(&mut self, delta: i16) { + let max_scroll = self.keybind_help_max_scroll(); + let current = self.keybind_help.scroll as i16; + self.keybind_help.scroll = current.saturating_add(delta).clamp(0, max_scroll as i16) as u16; + } +} + +#[cfg(test)] +mod tests { + use crossterm::event::{MouseButton, MouseEventKind}; + use ratatui::layout::Rect; + + use super::super::{app_for_mouse_test, mouse}; + use super::*; + + #[test] + fn clicking_keybind_help_close_button_closes_overlay() { + let mut app = app_for_mouse_test(); + app.state.mode = Mode::KeybindHelp; + + let rect = app.state.keybind_help_popup_rect(); + let inner = Rect::new( + rect.x + 1, + rect.y + 1, + rect.width.saturating_sub(2), + rect.height.saturating_sub(2), + ); + let close = + crate::ui::release_notes_close_button_rect(Rect::new(inner.x, inner.y, inner.width, 1)); + app.handle_mouse(mouse( + MouseEventKind::Down(MouseButton::Left), + close.x, + close.y, + )); + + assert_eq!(app.state.mode, Mode::Navigate); + } + + #[test] + fn onboarding_hover_does_not_change_selection() { + let mut app = app_for_mouse_test(); + app.state.mode = Mode::Onboarding; + app.state.onboarding_step = 1; + app.state.onboarding_list.select(1); + + let inner = app.state.onboarding_modal_inner(56, 14).unwrap(); + let content = crate::ui::modal_stack_areas(inner, 3, 0, 1, 1).content; + app.handle_mouse(mouse(MouseEventKind::Moved, content.x + 2, content.y)); + + assert_eq!(app.state.onboarding_list.selected, 1); + } + + #[test] + fn onboarding_click_selects_notification_option() { + let mut app = app_for_mouse_test(); + app.state.mode = Mode::Onboarding; + app.state.onboarding_step = 1; + app.state.onboarding_list.select(0); + + let inner = app.state.onboarding_modal_inner(56, 14).unwrap(); + let content = crate::ui::modal_stack_areas(inner, 3, 0, 1, 1).content; + app.handle_mouse(mouse( + MouseEventKind::Down(MouseButton::Left), + content.x + 2, + content.y + 2, + )); + + assert_eq!(app.state.onboarding_list.selected, 2); + } +} diff --git a/src/app/input/selection.rs b/src/app/input/selection.rs new file mode 100644 index 00000000..953e9b26 --- /dev/null +++ b/src/app/input/selection.rs @@ -0,0 +1,68 @@ +use crossterm::event::{MouseEvent, MouseEventKind}; + +use crate::app::state::AppState; + +impl AppState { + fn update_selection_cursor( + &mut self, + pane_id: crate::layout::PaneId, + screen_col: u16, + screen_row: u16, + ) { + let Some(info) = self.pane_info_by_id(pane_id).cloned() else { + return; + }; + let metrics = self.pane_scroll_metrics(pane_id); + if let Some(selection) = self.selection.as_mut() { + selection.drag(screen_col, screen_row, info.inner_rect, metrics); + } + } + + fn selection_edge_scroll_lines(distance: u16) -> usize { + usize::from(distance).saturating_mul(3).clamp(3, 15) + } + + pub(super) fn update_selection_drag(&mut self, screen_col: u16, screen_row: u16) { + let Some(pane_id) = self.selection.as_ref().map(|selection| selection.pane_id) else { + return; + }; + let Some(info) = self.pane_info_by_id(pane_id).cloned() else { + return; + }; + + let bottom = info.inner_rect.y + info.inner_rect.height.saturating_sub(1); + if screen_row < info.inner_rect.y { + self.scroll_pane_up( + pane_id, + Self::selection_edge_scroll_lines(info.inner_rect.y - screen_row), + ); + } else if screen_row > bottom { + self.scroll_pane_down( + pane_id, + Self::selection_edge_scroll_lines(screen_row - bottom), + ); + } + + self.update_selection_cursor(pane_id, screen_col, screen_row); + } + + pub(super) fn scroll_selection_with_wheel(&mut self, mouse: MouseEvent) -> bool { + const LINES_PER_NOTCH: usize = 3; + + let Some(selection) = self.selection.as_ref() else { + return false; + }; + if !selection.is_in_progress() { + return false; + } + let pane_id = selection.pane_id; + self.focus_pane(pane_id); + match mouse.kind { + MouseEventKind::ScrollUp => self.scroll_pane_up(pane_id, LINES_PER_NOTCH), + MouseEventKind::ScrollDown => self.scroll_pane_down(pane_id, LINES_PER_NOTCH), + _ => return false, + } + self.update_selection_cursor(pane_id, mouse.column, mouse.row); + true + } +} diff --git a/src/app/input/settings.rs b/src/app/input/settings.rs new file mode 100644 index 00000000..9433b7d8 --- /dev/null +++ b/src/app/input/settings.rs @@ -0,0 +1,352 @@ +use crossterm::event::{KeyCode, KeyEvent, MouseButton, MouseEvent, MouseEventKind}; +use ratatui::layout::Rect; + +use crate::app::{ + state::{AppState, SettingsSection, THEME_NAMES}, + App, Mode, +}; + +#[derive(Debug, Clone, PartialEq, Eq)] +pub(super) enum SettingsAction { + SaveTheme(String), + SaveSound(bool), + SaveToast(bool), +} + +impl App { + pub(crate) fn handle_settings_key(&mut self, key: KeyEvent) { + if let Some(action) = update_settings_state(&mut self.state, key) { + match action { + SettingsAction::SaveTheme(name) => self.save_theme(&name), + SettingsAction::SaveSound(enabled) => self.save_sound(enabled), + SettingsAction::SaveToast(enabled) => self.save_toast(enabled), + } + } + } +} + +fn normalize_theme_name(name: &str) -> String { + name.to_lowercase().replace([' ', '_'], "-") +} + +fn current_theme_index(theme_name: &str) -> usize { + let normalized = normalize_theme_name(theme_name); + THEME_NAMES + .iter() + .position(|name| normalize_theme_name(name) == normalized) + .unwrap_or(0) +} + +fn preview_selected_theme(state: &mut AppState) { + use crate::app::state::Palette; + + let name = THEME_NAMES[state.settings.list.selected]; + if let Some(palette) = Palette::from_name(name) { + state.palette = palette; + state.theme_name = name.to_string(); + } +} + +fn cancel_settings(state: &mut AppState) { + if let Some(palette) = state.settings.original_palette.take() { + state.palette = palette; + } + if let Some(theme_name) = state.settings.original_theme.take() { + state.theme_name = theme_name; + } + super::modal::leave_modal(state); +} + +fn apply_settings(state: &mut AppState) -> Option<SettingsAction> { + match state.settings.section { + SettingsSection::Theme => { + let theme_name = state.theme_name.clone(); + state.settings.original_palette = None; + state.settings.original_theme = None; + super::modal::leave_modal(state); + Some(SettingsAction::SaveTheme(theme_name)) + } + _ => { + super::modal::leave_modal(state); + None + } + } +} + +pub(super) fn update_settings_state(state: &mut AppState, key: KeyEvent) -> Option<SettingsAction> { + match state.settings.section { + SettingsSection::Theme => match key.code { + KeyCode::Up | KeyCode::Char('k') => { + let previous = state.settings.list.selected; + state.settings.list.move_prev(); + if state.settings.list.selected != previous { + preview_selected_theme(state); + } + } + KeyCode::Down | KeyCode::Char('j') => { + let previous = state.settings.list.selected; + state.settings.list.move_next(THEME_NAMES.len()); + if state.settings.list.selected != previous { + preview_selected_theme(state); + } + } + KeyCode::Tab | KeyCode::Right | KeyCode::Char('l') => { + state.settings.section = SettingsSection::Sound; + state.settings.list.selected = usize::from(!state.sound_enabled()); + } + _ => match super::modal::modal_action_from_key(&key, super::modal::SETTINGS_ACTIONS) { + Some(super::modal::ModalAction::Apply) => return apply_settings(state), + Some(super::modal::ModalAction::Close) => cancel_settings(state), + _ => {} + }, + }, + SettingsSection::Sound => match key.code { + KeyCode::Up | KeyCode::Char('k') | KeyCode::Down | KeyCode::Char('j') => { + state.settings.list.selected = 1 - state.settings.list.selected.min(1); + } + KeyCode::Enter | KeyCode::Char(' ') => { + let enabled = state.settings.list.selected == 0; + state.sound.enabled = enabled; + return Some(SettingsAction::SaveSound(enabled)); + } + KeyCode::Tab | KeyCode::Right | KeyCode::Char('l') => { + state.settings.section = SettingsSection::Toast; + state.settings.list.selected = usize::from(!state.toast_config.enabled); + } + KeyCode::BackTab | KeyCode::Left | KeyCode::Char('h') => { + state.settings.section = SettingsSection::Theme; + state.settings.list.selected = current_theme_index(&state.theme_name); + } + _ => match super::modal::modal_action_from_key(&key, super::modal::SETTINGS_ACTIONS) { + Some(super::modal::ModalAction::Close) => cancel_settings(state), + _ => {} + }, + }, + SettingsSection::Toast => match key.code { + KeyCode::Up | KeyCode::Char('k') | KeyCode::Down | KeyCode::Char('j') => { + state.settings.list.selected = 1 - state.settings.list.selected.min(1); + } + KeyCode::Enter | KeyCode::Char(' ') => { + let enabled = state.settings.list.selected == 0; + state.toast_config.enabled = enabled; + return Some(SettingsAction::SaveToast(enabled)); + } + KeyCode::BackTab | KeyCode::Left | KeyCode::Char('h') => { + state.settings.section = SettingsSection::Sound; + state.settings.list.selected = usize::from(!state.sound_enabled()); + } + KeyCode::Tab | KeyCode::Right | KeyCode::Char('l') => { + state.settings.section = SettingsSection::Theme; + state.settings.list.selected = current_theme_index(&state.theme_name); + } + _ => match super::modal::modal_action_from_key(&key, super::modal::SETTINGS_ACTIONS) { + Some(super::modal::ModalAction::Close) => cancel_settings(state), + _ => {} + }, + }, + } + + None +} + +pub(super) fn open_settings(state: &mut AppState) { + state.settings.original_palette = Some(state.palette.clone()); + state.settings.original_theme = Some(state.theme_name.clone()); + state.settings.section = SettingsSection::Theme; + state.settings.list.selected = current_theme_index(&state.theme_name); + state.mode = Mode::Settings; +} + +impl AppState { + fn settings_popup_rect(&self) -> Rect { + crate::ui::centered_popup_rect(self.screen_rect(), 56, 20).unwrap_or_default() + } + + fn settings_inner_rect(&self) -> Rect { + let popup = self.settings_popup_rect(); + Rect::new( + popup.x + 1, + popup.y + 1, + popup.width.saturating_sub(2), + popup.height.saturating_sub(2), + ) + } + + fn settings_tab_at(&self, col: u16, row: u16) -> Option<SettingsSection> { + let inner = self.settings_inner_rect(); + let tab_y = inner.y + 1; + if row != tab_y { + return None; + } + let mut x = inner.x; + for section in SettingsSection::ALL { + let width = section.label().len() as u16 + 2; + if col >= x && col < x + width { + return Some(*section); + } + x += width + 1; + } + None + } + + pub(crate) fn settings_content_rect(&self) -> Rect { + let inner = self.settings_inner_rect(); + crate::ui::modal_stack_areas(inner, 3, 2, 0, 1).content + } + + fn settings_list_index_at(&self, col: u16, row: u16) -> Option<usize> { + let area = self.settings_content_rect(); + if row < area.y || row >= area.y + area.height || col < area.x || col >= area.x + area.width + { + return None; + } + + match self.settings.section { + SettingsSection::Theme => { + let max_visible = area.height as usize; + let scroll = if self.settings.list.selected >= max_visible { + self.settings.list.selected - max_visible + 1 + } else { + 0 + }; + let idx = scroll + (row - area.y) as usize; + (idx < THEME_NAMES.len()).then_some(idx) + } + SettingsSection::Sound | SettingsSection::Toast => { + let list_y = area.y + 2; + if row >= list_y && row < list_y + 2 { + Some((row - list_y) as usize) + } else { + None + } + } + } + } + + pub(super) fn handle_settings_mouse(&mut self, mouse: MouseEvent) -> Option<SettingsAction> { + match mouse.kind { + MouseEventKind::Down(MouseButton::Left) => { + if let Some(section) = self.settings_tab_at(mouse.column, mouse.row) { + self.settings.section = section; + self.settings.list.select(match section { + SettingsSection::Theme => current_theme_index(&self.theme_name), + SettingsSection::Sound => usize::from(!self.sound_enabled()), + SettingsSection::Toast => usize::from(!self.toast_config.enabled), + }); + return None; + } + if let Some(idx) = self.settings_list_index_at(mouse.column, mouse.row) { + self.settings.list.select(idx); + return match self.settings.section { + SettingsSection::Theme => { + preview_selected_theme(self); + None + } + SettingsSection::Sound => { + let enabled = idx == 0; + self.sound.enabled = enabled; + Some(SettingsAction::SaveSound(enabled)) + } + SettingsSection::Toast => { + let enabled = idx == 0; + self.toast_config.enabled = enabled; + Some(SettingsAction::SaveToast(enabled)) + } + }; + } + + let inner = self.settings_inner_rect(); + let (apply, close) = crate::ui::settings_button_rects(inner); + match super::modal::modal_action_from_buttons( + mouse.column, + mouse.row, + &[ + (apply, super::modal::ModalAction::Apply), + (close, super::modal::ModalAction::Close), + ], + ) { + Some(super::modal::ModalAction::Apply) => apply_settings(self), + Some(super::modal::ModalAction::Close) => { + cancel_settings(self); + None + } + _ => { + cancel_settings(self); + None + } + } + } + _ => None, + } + } +} + +#[cfg(test)] +mod tests { + use crossterm::event::{KeyCode, KeyEvent, KeyModifiers, MouseEventKind}; + + use super::super::{app_for_mouse_test, mouse, state_with_workspaces}; + use super::*; + + #[test] + fn settings_cancel_restores_previewed_theme_from_other_sections() { + let mut state = state_with_workspaces(&["test"]); + let original_palette = state.palette.clone(); + let original_theme = state.theme_name.clone(); + + open_settings(&mut state); + update_settings_state( + &mut state, + KeyEvent::new(KeyCode::Down, KeyModifiers::empty()), + ); + assert_ne!(state.theme_name, original_theme); + + update_settings_state( + &mut state, + KeyEvent::new(KeyCode::Tab, KeyModifiers::empty()), + ); + assert_eq!( + state.settings.section, + crate::app::state::SettingsSection::Sound + ); + + update_settings_state( + &mut state, + KeyEvent::new(KeyCode::Esc, KeyModifiers::empty()), + ); + + assert_eq!(state.mode, Mode::Terminal); + assert_eq!(state.theme_name, original_theme); + assert_eq!(state.palette.accent, original_palette.accent); + assert_eq!(state.palette.panel_bg, original_palette.panel_bg); + } + + #[test] + fn settings_sound_toggle_returns_save_action() { + let mut state = state_with_workspaces(&["test"]); + open_settings(&mut state); + state.settings.section = crate::app::state::SettingsSection::Sound; + state.settings.list.selected = 0; + + let action = update_settings_state( + &mut state, + KeyEvent::new(KeyCode::Enter, KeyModifiers::empty()), + ); + + assert_eq!(action, Some(SettingsAction::SaveSound(true))); + assert!(state.sound.enabled); + assert_eq!(state.mode, Mode::Settings); + } + + #[test] + fn settings_hover_does_not_change_selection() { + let mut app = app_for_mouse_test(); + open_settings(&mut app.state); + app.state.settings.list.select(0); + + let area = app.state.settings_content_rect(); + app.handle_mouse(mouse(MouseEventKind::Moved, area.x + 2, area.y + 2)); + + assert_eq!(app.state.settings.list.selected, 0); + } +} diff --git a/src/app/input/sidebar.rs b/src/app/input/sidebar.rs new file mode 100644 index 00000000..34845861 --- /dev/null +++ b/src/app/input/sidebar.rs @@ -0,0 +1,1219 @@ +use ratatui::layout::Rect; + +use crate::app::state::{AppState, Mode}; + +use super::ScrollbarClickTarget; + +impl AppState { + pub(super) fn workspace_list_rect(&self) -> Rect { + let sidebar = self.view.sidebar_rect; + if self.sidebar_collapsed || sidebar.width <= 1 || sidebar.height == 0 { + return Rect::default(); + } + crate::ui::workspace_list_rect(sidebar, self.sidebar_section_split) + } + + pub(super) fn agent_panel_rect(&self) -> Rect { + let sidebar = self.view.sidebar_rect; + if self.sidebar_collapsed || sidebar.width <= 1 || sidebar.height == 0 { + return Rect::default(); + } + let (_, detail_area) = + crate::ui::expanded_sidebar_sections(sidebar, self.sidebar_section_split); + detail_area + } + + pub(super) fn workspace_list_scrollbar_target_at( + &self, + col: u16, + row: u16, + ) -> Option<ScrollbarClickTarget> { + let area = self.workspace_list_rect(); + let metrics = crate::ui::workspace_list_scroll_metrics(self, area); + let track = crate::ui::workspace_list_scrollbar_rect(self, area)?; + if col < track.x + || col >= track.x + track.width + || row < track.y + || row >= track.y + track.height + { + return None; + } + if let Some(grab_row_offset) = crate::ui::scrollbar_thumb_grab_offset(metrics, track, row) { + Some(ScrollbarClickTarget::Thumb { grab_row_offset }) + } else { + Some(ScrollbarClickTarget::Track { + offset_from_bottom: crate::ui::scrollbar_offset_from_row(metrics, track, row), + }) + } + } + + pub(super) fn workspace_list_offset_for_drag_row( + &self, + row: u16, + grab_row_offset: u16, + ) -> Option<usize> { + let area = self.workspace_list_rect(); + let metrics = crate::ui::workspace_list_scroll_metrics(self, area); + let track = crate::ui::workspace_list_scrollbar_rect(self, area)?; + Some(crate::ui::scrollbar_offset_from_drag_row( + metrics, + track, + row, + grab_row_offset, + )) + } + + pub(super) fn set_workspace_list_offset_from_bottom(&mut self, offset_from_bottom: usize) { + let area = self.workspace_list_rect(); + let metrics = crate::ui::workspace_list_scroll_metrics(self, area); + self.workspace_scroll = metrics + .max_offset_from_bottom + .saturating_sub(offset_from_bottom); + } + + pub(super) fn scroll_workspace_list(&mut self, delta: i16) { + if delta.is_negative() { + self.workspace_scroll = self + .workspace_scroll + .saturating_sub(delta.unsigned_abs() as usize); + return; + } + + for _ in 0..delta as usize { + let cards = crate::ui::compute_workspace_card_areas(self, self.view.sidebar_rect); + let Some(last) = cards.last() else { + break; + }; + if last.ws_idx + 1 >= self.workspaces.len() { + break; + } + self.workspace_scroll = self.workspace_scroll.saturating_add(1); + } + } + + pub(super) fn agent_panel_scrollbar_target_at( + &self, + col: u16, + row: u16, + ) -> Option<ScrollbarClickTarget> { + let area = self.agent_panel_rect(); + let metrics = crate::ui::agent_panel_scroll_metrics(self, area); + let track = crate::ui::agent_panel_scrollbar_rect(self, area)?; + if col < track.x + || col >= track.x + track.width + || row < track.y + || row >= track.y + track.height + { + return None; + } + if let Some(grab_row_offset) = crate::ui::scrollbar_thumb_grab_offset(metrics, track, row) { + Some(ScrollbarClickTarget::Thumb { grab_row_offset }) + } else { + Some(ScrollbarClickTarget::Track { + offset_from_bottom: crate::ui::scrollbar_offset_from_row(metrics, track, row), + }) + } + } + + pub(super) fn agent_panel_offset_for_drag_row( + &self, + row: u16, + grab_row_offset: u16, + ) -> Option<usize> { + let area = self.agent_panel_rect(); + let metrics = crate::ui::agent_panel_scroll_metrics(self, area); + let track = crate::ui::agent_panel_scrollbar_rect(self, area)?; + Some(crate::ui::scrollbar_offset_from_drag_row( + metrics, + track, + row, + grab_row_offset, + )) + } + + pub(super) fn set_agent_panel_offset_from_bottom(&mut self, offset_from_bottom: usize) { + let area = self.agent_panel_rect(); + let metrics = crate::ui::agent_panel_scroll_metrics(self, area); + self.agent_panel_scroll = metrics + .max_offset_from_bottom + .saturating_sub(offset_from_bottom); + } + + pub(super) fn scroll_agent_panel(&mut self, delta: i16) { + let area = self.agent_panel_rect(); + let max_scroll = crate::ui::agent_panel_scroll_metrics(self, area).max_offset_from_bottom; + if delta.is_negative() { + self.agent_panel_scroll = self + .agent_panel_scroll + .saturating_sub(delta.unsigned_abs() as usize); + } else { + self.agent_panel_scroll = self + .agent_panel_scroll + .saturating_add(delta as usize) + .min(max_scroll); + } + } + + pub(crate) fn sidebar_footer_rect(&self) -> Rect { + let ws_area = self.workspace_list_rect(); + if ws_area == Rect::default() { + return Rect::default(); + } + let y = ws_area.y + ws_area.height.saturating_sub(1); + Rect::new(ws_area.x, y, ws_area.width, 1) + } + + pub(crate) fn sidebar_new_button_rect(&self) -> Rect { + let footer = self.sidebar_footer_rect(); + let width = 5u16.min(footer.width.max(1)); + Rect::new(footer.x, footer.y, width, footer.height) + } + + pub(crate) fn global_launcher_rect(&self) -> Rect { + let footer = self.sidebar_footer_rect(); + let width = if self.update_available.is_some() { + 8 + } else { + 6 + } + .min(footer.width.max(1)); + let x = footer.x + footer.width.saturating_sub(width); + Rect::new(x, footer.y, width, footer.height) + } + + pub(crate) fn global_menu_labels(&self) -> Vec<&'static str> { + let mut labels = vec!["settings", "keybinds", "reload keybinds"]; + if self.update_available.is_some() { + labels.push("update ready"); + } else if self.latest_release_notes_available { + labels.push("what's new"); + } + labels.push(if self.quit_detaches { "detach" } else { "quit" }); + labels + } + + pub(crate) fn global_menu_rect(&self) -> Rect { + let screen = self.screen_rect(); + let launcher = self.global_launcher_rect(); + let labels = self.global_menu_labels(); + let content_width = labels + .iter() + .map(|label| { + let extra = if *label == "update ready" { 2 } else { 0 }; + label.chars().count() as u16 + extra + }) + .max() + .unwrap_or(8) + .saturating_add(2); + let menu_w = content_width.saturating_add(2).min(screen.width.max(1)); + let menu_h = (labels.len() as u16 + 2).min(screen.height.max(1)); + let max_x = screen.x + screen.width.saturating_sub(menu_w); + let desired_x = launcher.x + launcher.width.saturating_sub(menu_w); + let x = desired_x.min(max_x); + let y = launcher.y.saturating_sub(menu_h); + Rect::new(x, y, menu_w, menu_h) + } + + pub(super) fn on_sidebar_divider(&self, col: u16, row: u16) -> bool { + if self.sidebar_collapsed { + return false; + } + let sidebar = self.view.sidebar_rect; + sidebar.width > 0 + && col == sidebar.x + sidebar.width.saturating_sub(1) + && row >= sidebar.y + && row < sidebar.y + sidebar.height + } + + pub(super) fn on_collapsed_sidebar_toggle(&self, col: u16, row: u16) -> bool { + if !self.sidebar_collapsed { + return false; + } + let rect = crate::ui::collapsed_sidebar_toggle_rect(self.view.sidebar_rect); + rect.width > 0 + && col >= rect.x + && col < rect.x + rect.width + && row >= rect.y + && row < rect.y + rect.height + } + + pub(super) fn set_manual_sidebar_width(&mut self, divider_col: u16) { + let sidebar = self.view.sidebar_rect; + let width = divider_col.saturating_sub(sidebar.x).saturating_add(1); + self.sidebar_width = + width.clamp(crate::ui::MIN_SIDEBAR_WIDTH, crate::ui::MAX_SIDEBAR_WIDTH); + self.mark_session_dirty(); + } + + pub(super) fn on_sidebar_section_divider(&self, col: u16, row: u16) -> bool { + if self.sidebar_collapsed { + return false; + } + let rect = crate::ui::sidebar_section_divider_rect( + self.view.sidebar_rect, + self.sidebar_section_split, + ); + rect.width > 0 + && col >= rect.x + && col < rect.x + rect.width + && row >= rect.y + && row < rect.y + rect.height + } + + pub(super) fn set_sidebar_section_split(&mut self, row: u16) { + let sidebar = self.view.sidebar_rect; + let content_height = sidebar.height; + if content_height < 6 { + return; + } + let relative_y = row.saturating_sub(sidebar.y); + let ratio = (relative_y as f32) / (content_height as f32); + self.sidebar_section_split = ratio.clamp(0.1, 0.9); + self.mark_session_dirty(); + } + + pub(super) fn workspace_at_row(&self, row: u16) -> Option<usize> { + let footer = self.sidebar_footer_rect(); + if footer == Rect::default() { + return None; + } + + let cards = if self.view.workspace_card_areas.is_empty() { + crate::ui::compute_workspace_card_areas(self, self.view.sidebar_rect) + } else { + self.view.workspace_card_areas.clone() + }; + + cards.iter().find_map(|card| { + (row >= card.rect.y && row < card.rect.y + card.rect.height).then_some(card.ws_idx) + }) + } + + pub(super) fn collapsed_workspace_at_row(&self, row: u16) -> Option<usize> { + if !self.sidebar_collapsed { + return None; + } + + let (ws_area, _, _) = crate::ui::collapsed_sidebar_sections(self.view.sidebar_rect); + if ws_area == Rect::default() || row < ws_area.y || row >= ws_area.y + ws_area.height { + return None; + } + + let idx = (row - ws_area.y) as usize; + (idx < self.workspaces.len()).then_some(idx) + } + + fn collapsed_detail_workspace_idx(&self) -> Option<usize> { + if matches!( + self.mode, + Mode::Navigate + | Mode::RenameWorkspace + | Mode::Resize + | Mode::ConfirmClose + | Mode::ContextMenu + | Mode::Settings + | Mode::GlobalMenu + | Mode::KeybindHelp + ) { + Some(self.selected) + } else { + self.active + } + } + + pub(super) fn collapsed_agent_detail_target_at( + &self, + row: u16, + ) -> Option<(usize, usize, crate::layout::PaneId)> { + if !self.sidebar_collapsed { + return None; + } + + let (_, _, detail_area) = crate::ui::collapsed_sidebar_sections(self.view.sidebar_rect); + let detail_content_area = Rect::new( + detail_area.x, + detail_area.y, + detail_area.width, + detail_area.height.saturating_sub(1), + ); + if detail_content_area == Rect::default() + || row < detail_content_area.y + || row >= detail_content_area.y + detail_content_area.height + { + return None; + } + + let ws_idx = self.collapsed_detail_workspace_idx()?; + let ws = self.workspaces.get(ws_idx)?; + let detail_idx = (row - detail_content_area.y) as usize; + let details = ws.pane_details(); + let detail = details.get(detail_idx)?; + Some((ws_idx, detail.tab_idx, detail.pane_id)) + } + + pub(super) fn workspace_drop_index_at_row(&self, row: u16) -> Option<usize> { + let area = self.workspace_list_rect(); + let footer = self.sidebar_footer_rect(); + if area == Rect::default() || row < area.y || row >= footer.y { + return None; + } + + let cards = if self.view.workspace_card_areas.is_empty() { + crate::ui::compute_workspace_card_areas(self, self.view.sidebar_rect) + } else { + self.view.workspace_card_areas.clone() + }; + if cards.is_empty() { + return Some(0); + } + + let mut insert_indices = Vec::with_capacity(cards.len() + 1); + insert_indices.push(cards[0].ws_idx); + insert_indices.extend(cards.iter().skip(1).map(|card| card.ws_idx)); + insert_indices.push(cards.last().map(|card| card.ws_idx + 1).unwrap_or(0)); + + let mut best: Option<(usize, u16)> = None; + for insert_idx in insert_indices { + let Some(slot_row) = crate::ui::workspace_drop_indicator_row(&cards, area, insert_idx) + else { + continue; + }; + let distance = row.abs_diff(slot_row); + match best { + Some((best_idx, best_distance)) + if distance > best_distance + || (distance == best_distance && insert_idx < best_idx) => {} + _ => best = Some((insert_idx, distance)), + } + } + + best.map(|(insert_idx, _)| insert_idx) + } + + pub(super) fn on_agent_panel_scope_toggle(&self, col: u16, row: u16) -> bool { + if self.sidebar_collapsed { + return false; + } + + let (_, detail_area) = crate::ui::expanded_sidebar_sections( + self.view.sidebar_rect, + self.sidebar_section_split, + ); + let rect = crate::ui::agent_panel_toggle_rect(detail_area, self.agent_panel_scope); + rect.width > 0 + && col >= rect.x + && col < rect.x + rect.width + && row >= rect.y + && row < rect.y + rect.height + } + + pub(super) fn agent_detail_target_at( + &self, + row: u16, + ) -> Option<(usize, usize, crate::layout::PaneId)> { + if self.sidebar_collapsed { + return None; + } + + let detail_area = self.agent_panel_rect(); + let metrics = crate::ui::agent_panel_scroll_metrics(self, detail_area); + let body = crate::ui::agent_panel_body_rect( + detail_area, + crate::ui::should_show_scrollbar(metrics), + ); + if body.height < 2 || row < body.y || row >= body.y + body.height { + return None; + } + + let mut row_y = body.y; + for detail in crate::ui::agent_panel_entries(self) + .into_iter() + .skip(self.agent_panel_scroll) + { + if row_y.saturating_add(1) >= body.y + body.height { + break; + } + if row == row_y || row == row_y + 1 { + return Some((detail.ws_idx, detail.tab_idx, detail.pane_id)); + } + row_y = row_y.saturating_add(2); + if row_y < body.y + body.height { + row_y = row_y.saturating_add(1); + } + } + None + } +} + +#[cfg(test)] +mod tests { + use std::fs; + + use crossterm::event::{MouseButton, MouseEventKind}; + use ratatui::layout::Rect; + + use super::super::{app_for_mouse_test, capture_snapshot, mouse, unique_temp_path}; + use crate::{ + app::state::{AgentPanelScope, DragTarget, Mode}, + detect::Agent, + workspace::Workspace, + }; + + #[test] + fn clicking_launcher_opens_global_menu() { + let mut app = app_for_mouse_test(); + let rect = app.state.global_launcher_rect(); + + app.handle_mouse(mouse( + MouseEventKind::Down(MouseButton::Left), + rect.x + rect.width.saturating_sub(1), + rect.y, + )); + + assert_eq!(app.state.mode, Mode::GlobalMenu); + } + + #[test] + fn hovering_global_menu_updates_highlight() { + let mut app = app_for_mouse_test(); + let launcher = app.state.global_launcher_rect(); + app.handle_mouse(mouse( + MouseEventKind::Down(MouseButton::Left), + launcher.x, + launcher.y, + )); + + let menu = app.state.global_menu_rect(); + app.handle_mouse(mouse(MouseEventKind::Moved, menu.x + 2, menu.y + 2)); + + assert_eq!(app.state.global_menu.highlighted, 1); + } + + #[test] + fn clicking_keybinds_menu_item_opens_help() { + let mut app = app_for_mouse_test(); + let launcher = app.state.global_launcher_rect(); + app.handle_mouse(mouse( + MouseEventKind::Down(MouseButton::Left), + launcher.x, + launcher.y, + )); + + let menu = app.state.global_menu_rect(); + app.handle_mouse(mouse( + MouseEventKind::Down(MouseButton::Left), + menu.x + 2, + menu.y + 2, + )); + + assert_eq!(app.state.mode, Mode::KeybindHelp); + } + + #[test] + fn clicking_settings_menu_item_opens_settings() { + let mut app = app_for_mouse_test(); + let launcher = app.state.global_launcher_rect(); + app.handle_mouse(mouse( + MouseEventKind::Down(MouseButton::Left), + launcher.x, + launcher.y, + )); + + let menu = app.state.global_menu_rect(); + app.handle_mouse(mouse( + MouseEventKind::Down(MouseButton::Left), + menu.x + 2, + menu.y + 1, + )); + + assert_eq!(app.state.mode, Mode::Settings); + } + + #[test] + fn clicking_reload_keybinds_menu_item_requests_reload() { + let mut app = app_for_mouse_test(); + let launcher = app.state.global_launcher_rect(); + app.handle_mouse(mouse( + MouseEventKind::Down(MouseButton::Left), + launcher.x, + launcher.y, + )); + + let menu = app.state.global_menu_rect(); + app.handle_mouse(mouse( + MouseEventKind::Down(MouseButton::Left), + menu.x + 2, + menu.y + 3, + )); + + assert!(app.state.request_reload_keybinds); + assert_eq!(app.state.mode, Mode::Navigate); + } + + #[test] + fn update_pending_menu_surfaces_update_ready_entry() { + let mut app = app_for_mouse_test(); + app.state.update_available = Some("0.3.2".into()); + app.state.latest_release_notes_available = true; + + let launcher = app.state.global_launcher_rect(); + app.handle_mouse(mouse( + MouseEventKind::Down(MouseButton::Left), + launcher.x, + launcher.y, + )); + + assert_eq!( + app.state.global_menu_labels(), + vec![ + "settings", + "keybinds", + "reload keybinds", + "update ready", + "quit" + ] + ); + assert!(!app.state.should_quit); + } + + #[test] + fn persistence_mode_menu_surfaces_detach_action() { + let mut app = app_for_mouse_test(); + app.state.quit_detaches = true; + + let launcher = app.state.global_launcher_rect(); + app.handle_mouse(mouse( + MouseEventKind::Down(MouseButton::Left), + launcher.x, + launcher.y, + )); + + assert_eq!( + app.state.global_menu_labels(), + vec!["settings", "keybinds", "reload keybinds", "detach"] + ); + + let menu = app.state.global_menu_rect(); + app.handle_mouse(mouse( + MouseEventKind::Down(MouseButton::Left), + menu.x + 2, + menu.y + 4, + )); + + assert!(app.state.detach_requested); + assert!(!app.state.should_quit); + } + + #[test] + fn whats_new_remains_in_menu_for_latest_installed_release_notes() { + let mut app = app_for_mouse_test(); + app.state.latest_release_notes_available = true; + + assert_eq!( + app.state.global_menu_labels(), + vec![ + "settings", + "keybinds", + "reload keybinds", + "what's new", + "quit" + ] + ); + } + + #[test] + fn clicking_agent_detail_row_switches_to_correct_tab_and_pane() { + let mut app = app_for_mouse_test(); + let mut ws = Workspace::test_new("test"); + ws.tabs[0].set_custom_name("main".into()); + let first_pane = ws.tabs[0].root_pane; + ws.tabs[0] + .panes + .get_mut(&first_pane) + .unwrap() + .detected_agent = Some(Agent::Pi); + let second_tab = ws.test_add_tab(Some("logs")); + let second_pane = ws.tabs[second_tab].root_pane; + ws.tabs[second_tab] + .panes + .get_mut(&second_pane) + .unwrap() + .detected_agent = Some(Agent::Claude); + app.state.workspaces = vec![ws]; + app.state.active = Some(0); + app.state.selected = 0; + app.state.mode = Mode::Terminal; + + app.handle_mouse(mouse(MouseEventKind::Down(MouseButton::Left), 2, 16)); + + assert_eq!(app.state.workspaces[0].active_tab, 1); + assert_eq!( + app.state.workspaces[0].tabs[1].layout.focused(), + second_pane + ); + assert_eq!(app.state.mode, Mode::Terminal); + let snapshot = capture_snapshot(&app.state); + assert_eq!(snapshot.workspaces[0].active_tab, second_tab); + assert_eq!( + snapshot.workspaces[0].tabs[second_tab].focused, + Some(second_pane.raw()) + ); + } + + #[test] + fn clicking_agent_panel_toggle_switches_scope() { + let mut app = app_for_mouse_test(); + app.state.workspaces = vec![Workspace::test_new("test")]; + app.state.active = Some(0); + app.state.selected = 0; + app.state.mode = Mode::Terminal; + app.state.agent_panel_scroll = 3; + + let (_, detail_area) = crate::ui::expanded_sidebar_sections( + app.state.view.sidebar_rect, + app.state.sidebar_section_split, + ); + let toggle = crate::ui::agent_panel_toggle_rect(detail_area, app.state.agent_panel_scope); + app.handle_mouse(mouse( + MouseEventKind::Down(MouseButton::Left), + toggle.x, + toggle.y, + )); + + assert_eq!(app.state.agent_panel_scope, AgentPanelScope::AllWorkspaces); + assert_eq!(app.state.agent_panel_scroll, 0); + let snapshot = capture_snapshot(&app.state); + assert_eq!(snapshot.agent_panel_scope, AgentPanelScope::AllWorkspaces); + } + + #[test] + fn clicking_all_workspaces_agent_row_switches_to_correct_workspace() { + let mut app = app_for_mouse_test(); + let mut first = Workspace::test_new("one"); + let first_pane = first.tabs[0].root_pane; + first.tabs[0] + .panes + .get_mut(&first_pane) + .unwrap() + .detected_agent = Some(Agent::Pi); + + let mut second = Workspace::test_new("two"); + let second_pane = second.tabs[0].root_pane; + second.tabs[0] + .panes + .get_mut(&second_pane) + .unwrap() + .detected_agent = Some(Agent::Claude); + + app.state.workspaces = vec![first, second]; + app.state.active = Some(0); + app.state.selected = 0; + app.state.mode = Mode::Terminal; + app.state.agent_panel_scope = AgentPanelScope::AllWorkspaces; + + let (_, detail_area) = crate::ui::expanded_sidebar_sections( + app.state.view.sidebar_rect, + app.state.sidebar_section_split, + ); + app.handle_mouse(mouse( + MouseEventKind::Down(MouseButton::Left), + detail_area.x + 2, + detail_area.y + 6, + )); + + assert_eq!(app.state.active, Some(1)); + assert_eq!(app.state.selected, 1); + assert_eq!(app.state.workspaces[1].active_tab, 0); + assert_eq!( + app.state.workspaces[1].tabs[0].layout.focused(), + second_pane + ); + } + + #[test] + fn scrolling_agent_panel_with_wheel_updates_agent_panel_scroll() { + let mut app = app_for_mouse_test(); + let mut ws = Workspace::test_new("test"); + let first_pane = ws.tabs[0].root_pane; + ws.tabs[0] + .panes + .get_mut(&first_pane) + .unwrap() + .detected_agent = Some(Agent::Pi); + + for (tab_name, agent) in [ + ("logs", Agent::Claude), + ("review", Agent::Codex), + ("ops", Agent::Gemini), + ] { + let tab_idx = ws.test_add_tab(Some(tab_name)); + let pane_id = ws.tabs[tab_idx].root_pane; + ws.tabs[tab_idx] + .panes + .get_mut(&pane_id) + .unwrap() + .detected_agent = Some(agent); + } + + app.state.workspaces = vec![ws]; + app.state.active = Some(0); + app.state.selected = 0; + app.state.mode = Mode::Terminal; + + let detail_area = app.state.agent_panel_rect(); + assert!(crate::ui::should_show_scrollbar( + crate::ui::agent_panel_scroll_metrics(&app.state, detail_area) + )); + + app.handle_mouse(mouse( + MouseEventKind::ScrollDown, + detail_area.x + 1, + detail_area.y + 4, + )); + + assert_eq!(app.state.agent_panel_scroll, 1); + assert_eq!(app.state.selected, 0); + } + + #[test] + fn clicking_scrolled_agent_detail_row_switches_to_correct_tab_and_pane() { + let mut app = app_for_mouse_test(); + let mut ws = Workspace::test_new("test"); + let first_pane = ws.tabs[0].root_pane; + ws.tabs[0] + .panes + .get_mut(&first_pane) + .unwrap() + .detected_agent = Some(Agent::Pi); + + let second_tab = ws.test_add_tab(Some("logs")); + let second_pane = ws.tabs[second_tab].root_pane; + ws.tabs[second_tab] + .panes + .get_mut(&second_pane) + .unwrap() + .detected_agent = Some(Agent::Claude); + + for (tab_name, agent) in [("review", Agent::Codex), ("ops", Agent::Gemini)] { + let tab_idx = ws.test_add_tab(Some(tab_name)); + let pane_id = ws.tabs[tab_idx].root_pane; + ws.tabs[tab_idx] + .panes + .get_mut(&pane_id) + .unwrap() + .detected_agent = Some(agent); + } + + app.state.workspaces = vec![ws]; + app.state.active = Some(0); + app.state.selected = 0; + app.state.mode = Mode::Terminal; + app.state.agent_panel_scroll = 1; + + let detail_area = app.state.agent_panel_rect(); + let body = crate::ui::agent_panel_body_rect(detail_area, true); + app.handle_mouse(mouse( + MouseEventKind::Down(MouseButton::Left), + body.x + 1, + body.y, + )); + + assert_eq!(app.state.workspaces[0].active_tab, second_tab); + assert_eq!( + app.state.workspaces[0].tabs[second_tab].layout.focused(), + second_pane + ); + assert_eq!(app.state.mode, Mode::Terminal); + } + + #[test] + fn clicking_collapsed_agent_row_switches_to_correct_tab_and_pane() { + let mut app = app_for_mouse_test(); + let mut ws = Workspace::test_new("test"); + let first_pane = ws.tabs[0].root_pane; + ws.tabs[0] + .panes + .get_mut(&first_pane) + .unwrap() + .detected_agent = Some(Agent::Pi); + let second_tab = ws.test_add_tab(Some("logs")); + let second_pane = ws.tabs[second_tab].root_pane; + ws.tabs[second_tab] + .panes + .get_mut(&second_pane) + .unwrap() + .detected_agent = Some(Agent::Claude); + app.state.workspaces = vec![ws]; + app.state.active = Some(0); + app.state.selected = 0; + app.state.mode = Mode::Terminal; + app.state.sidebar_collapsed = true; + app.state.view.sidebar_rect = Rect::new(0, 0, 4, 20); + app.state.view.terminal_area = Rect::new(4, 0, 80, 20); + + let (_, _, detail_area) = + crate::ui::collapsed_sidebar_sections(app.state.view.sidebar_rect); + app.handle_mouse(mouse( + MouseEventKind::Down(MouseButton::Left), + detail_area.x, + detail_area.y + 1, + )); + + assert_eq!(app.state.workspaces[0].active_tab, 1); + assert_eq!( + app.state.workspaces[0].tabs[1].layout.focused(), + second_pane + ); + assert_eq!(app.state.mode, Mode::Terminal); + } + + #[test] + fn clicking_collapsed_sidebar_toggle_expands_sidebar() { + let mut app = app_for_mouse_test(); + app.state.sidebar_collapsed = true; + app.state.view.sidebar_rect = Rect::new(0, 0, 4, 20); + app.state.view.terminal_area = Rect::new(4, 0, 80, 20); + + let toggle = crate::ui::collapsed_sidebar_toggle_rect(app.state.view.sidebar_rect); + app.handle_mouse(mouse( + MouseEventKind::Down(MouseButton::Left), + toggle.x, + toggle.y, + )); + + assert!(!app.state.sidebar_collapsed); + } + + #[test] + fn clicking_workspace_switches_on_mouse_up() { + let mut app = app_for_mouse_test(); + app.state.workspaces = vec![Workspace::test_new("a"), Workspace::test_new("b")]; + app.state.active = Some(0); + app.state.selected = 0; + crate::ui::compute_view(&mut app.state, Rect::new(0, 0, 106, 20)); + let target_row = app.state.view.workspace_card_areas[1].rect.y; + + app.handle_mouse(mouse( + MouseEventKind::Down(MouseButton::Left), + 2, + target_row, + )); + assert_eq!(app.state.active, Some(0)); + assert!(app.state.workspace_press.is_some()); + + app.handle_mouse(mouse(MouseEventKind::Up(MouseButton::Left), 2, target_row)); + assert_eq!(app.state.active, Some(1)); + assert_eq!(app.state.selected, 1); + assert!(app.state.workspace_press.is_none()); + let snapshot = capture_snapshot(&app.state); + assert_eq!(snapshot.active, Some(1)); + assert_eq!(snapshot.selected, 1); + } + + #[test] + fn dragging_workspace_reorders_without_changing_identity() { + let mut app = app_for_mouse_test(); + app.state.workspaces = vec![ + Workspace::test_new("a"), + Workspace::test_new("b"), + Workspace::test_new("c"), + ]; + let active_id = app.state.workspaces[1].id.clone(); + let selected_id = app.state.workspaces[2].id.clone(); + app.state.active = Some(1); + app.state.selected = 2; + crate::ui::compute_view(&mut app.state, Rect::new(0, 0, 106, 20)); + let source_row = app.state.view.workspace_card_areas[1].rect.y; + let target_row = crate::ui::workspace_drop_indicator_row( + &app.state.view.workspace_card_areas, + app.state.workspace_list_rect(), + 0, + ) + .unwrap(); + + app.handle_mouse(mouse( + MouseEventKind::Down(MouseButton::Left), + 2, + source_row, + )); + app.handle_mouse(mouse( + MouseEventKind::Drag(MouseButton::Left), + 2, + target_row, + )); + assert!(matches!( + app.state.drag.as_ref().map(|drag| &drag.target), + Some(DragTarget::WorkspaceReorder { + source_ws_idx: 1, + insert_idx: Some(0), + }) + )); + app.handle_mouse(mouse(MouseEventKind::Up(MouseButton::Left), 2, target_row)); + + let names: Vec<_> = app + .state + .workspaces + .iter() + .map(|ws| ws.display_name()) + .collect(); + assert_eq!(names, vec!["b", "a", "c"]); + assert_eq!(app.state.active, Some(0)); + assert_eq!(app.state.selected, 2); + assert_eq!(app.state.workspaces[0].id, active_id); + assert_eq!(app.state.workspaces[2].id, selected_id); + let snapshot = capture_snapshot(&app.state); + let captured_names: Vec<_> = snapshot + .workspaces + .iter() + .map(|ws| ws.custom_name.clone().unwrap()) + .collect(); + assert_eq!(captured_names, vec!["b", "a", "c"]); + } + + #[test] + fn clicking_tab_scroll_button_reveals_hidden_tabs_without_renaming() { + let mut app = app_for_mouse_test(); + let mut ws = Workspace::test_new("test"); + ws.test_add_tab(Some("logs")); + ws.test_add_tab(Some("review")); + ws.test_add_tab(Some("ops")); + ws.test_add_tab(Some("notes")); + app.state.workspaces = vec![ws]; + app.state.active = Some(0); + app.state.selected = 0; + crate::ui::compute_view(&mut app.state, Rect::new(0, 0, 52, 20)); + + let right = app.state.view.tab_scroll_right_hit_area; + assert!(right.width > 0); + + app.handle_mouse(mouse( + MouseEventKind::Down(MouseButton::Left), + right.x + 1, + right.y, + )); + + assert_eq!(app.state.tab_scroll, 1); + assert!(!app.state.tab_scroll_follow_active); + assert_eq!(app.state.workspaces[0].active_tab, 0); + assert_eq!(app.state.view.tab_hit_areas[0].width, 0); + assert!(app.state.workspaces[0].tabs[0].custom_name.is_none()); + assert_eq!( + app.state.workspaces[0].tabs[1].custom_name.as_deref(), + Some("logs") + ); + } + + #[test] + fn clicking_last_visible_tab_at_right_edge_does_not_overscroll() { + let mut app = app_for_mouse_test(); + let mut ws = Workspace::test_new("test"); + for name in [ + "one", "two", "three", "four", "five", "six", "seven", "eight", + ] { + ws.test_add_tab(Some(name)); + } + app.state.workspaces = vec![ws]; + app.state.active = Some(0); + app.state.selected = 0; + app.state.tab_scroll = usize::MAX; + app.state.tab_scroll_follow_active = false; + crate::ui::compute_view(&mut app.state, Rect::new(0, 0, 52, 20)); + + let last_idx = app.state.workspaces[0].tabs.len() - 1; + let target = app.state.view.tab_hit_areas[last_idx]; + let clamped_scroll = app.state.tab_scroll; + assert!(target.width > 0, "last tab should already be visible"); + + app.handle_mouse(mouse( + MouseEventKind::Down(MouseButton::Left), + target.x + 1, + target.y, + )); + app.handle_mouse(mouse( + MouseEventKind::Up(MouseButton::Left), + target.x + 1, + target.y, + )); + + assert_eq!(app.state.workspaces[0].active_tab, last_idx); + assert_eq!(app.state.tab_scroll, clamped_scroll); + assert!(app.state.view.tab_hit_areas[last_idx].width > 0); + } + + #[test] + fn dragging_tab_reorders_auto_and_custom_names_without_materializing_numbers() { + let mut app = app_for_mouse_test(); + let mut ws = Workspace::test_new("test"); + ws.test_add_tab(Some("foo")); + ws.test_add_tab(None); + let moved_root = ws.tabs[0].root_pane; + app.state.workspaces = vec![ws]; + app.state.active = Some(0); + app.state.selected = 0; + crate::ui::compute_view(&mut app.state, Rect::new(0, 0, 106, 20)); + + let source = app.state.view.tab_hit_areas[0]; + let last = app.state.view.tab_hit_areas[2]; + let drop_col = last.x + last.width; + + app.handle_mouse(mouse( + MouseEventKind::Down(MouseButton::Left), + source.x + 1, + source.y, + )); + app.handle_mouse(mouse( + MouseEventKind::Drag(MouseButton::Left), + drop_col, + source.y, + )); + assert!(matches!( + app.state.drag.as_ref().map(|drag| &drag.target), + Some(DragTarget::TabReorder { + ws_idx: 0, + source_tab_idx: 0, + insert_idx: Some(3), + }) + )); + app.handle_mouse(mouse( + MouseEventKind::Up(MouseButton::Left), + drop_col, + source.y, + )); + + let labels: Vec<_> = app.state.workspaces[0] + .tabs + .iter() + .map(|tab| tab.display_name()) + .collect(); + assert_eq!(labels, vec!["foo", "2", "3"]); + assert_eq!( + app.state.workspaces[0].tabs[0].custom_name.as_deref(), + Some("foo") + ); + assert!(app.state.workspaces[0].tabs[1].custom_name.is_none()); + assert!(app.state.workspaces[0].tabs[2].custom_name.is_none()); + assert_eq!(app.state.workspaces[0].tabs[2].root_pane, moved_root); + assert_eq!(app.state.workspaces[0].active_tab, 2); + } + + fn temp_git_repo(branch: &str) -> std::path::PathBuf { + let repo = unique_temp_path("sidebar-drop-slot-repo"); + fs::create_dir_all(repo.join(".git")).unwrap(); + fs::write( + repo.join(".git/HEAD"), + format!("ref: refs/heads/{branch}\n"), + ) + .unwrap(); + repo + } + + #[test] + fn top_drop_slot_is_distinct_from_gap_below_first_workspace() { + let mut app = app_for_mouse_test(); + let first_repo = temp_git_repo("main"); + let second_repo = temp_git_repo("main"); + + let mut first = Workspace::test_new("a"); + let first_root = first.tabs[0].root_pane; + first.identity_cwd = first_repo.clone(); + first.tabs[0] + .pane_cwds + .insert(first_root, first_repo.clone()); + + let mut second = Workspace::test_new("b"); + let second_root = second.tabs[0].root_pane; + second.identity_cwd = second_repo.clone(); + second.tabs[0] + .pane_cwds + .insert(second_root, second_repo.clone()); + + app.state.workspaces = vec![first, second]; + crate::ui::compute_view(&mut app.state, Rect::new(0, 0, 106, 20)); + + assert_eq!(app.state.workspace_drop_index_at_row(0), Some(0)); + assert_eq!(app.state.workspace_drop_index_at_row(1), Some(0)); + assert_eq!(app.state.workspace_drop_index_at_row(2), Some(0)); + assert_eq!(app.state.workspace_drop_index_at_row(3), Some(1)); + + let _ = fs::remove_dir_all(first_repo); + let _ = fs::remove_dir_all(second_repo); + } + + #[test] + fn bottom_drop_slot_stays_below_last_workspace_not_footer() { + let mut app = app_for_mouse_test(); + app.state.workspaces = vec![ + Workspace::test_new("a"), + Workspace::test_new("b"), + Workspace::test_new("c"), + ]; + crate::ui::compute_view(&mut app.state, Rect::new(0, 0, 106, 20)); + + let cards = &app.state.view.workspace_card_areas; + let bottom_slot = crate::ui::workspace_drop_indicator_row( + cards, + app.state.workspace_list_rect(), + cards.len(), + ) + .unwrap(); + + let last = cards.last().unwrap().rect; + assert_eq!(bottom_slot, last.y + last.height); + assert!(bottom_slot < app.state.sidebar_footer_rect().y.saturating_sub(1)); + } + + #[test] + fn dragging_sidebar_divider_sets_manual_width() { + let mut app = app_for_mouse_test(); + + app.handle_mouse(mouse(MouseEventKind::Down(MouseButton::Left), 25, 5)); + app.handle_mouse(mouse(MouseEventKind::Drag(MouseButton::Left), 30, 5)); + + assert_eq!(app.state.sidebar_width, 31); + let snapshot = capture_snapshot(&app.state); + assert_eq!(snapshot.sidebar_width, Some(31)); + } + + #[test] + fn dragging_sidebar_section_divider_sets_split_ratio() { + let mut app = app_for_mouse_test(); + let divider = crate::ui::sidebar_section_divider_rect( + app.state.view.sidebar_rect, + app.state.sidebar_section_split, + ); + + app.handle_mouse(mouse( + MouseEventKind::Down(MouseButton::Left), + divider.x + 1, + divider.y, + )); + app.handle_mouse(mouse( + MouseEventKind::Drag(MouseButton::Left), + divider.x + 1, + divider.y + 4, + )); + + assert!(app.state.sidebar_section_split > 0.5); + let snapshot = capture_snapshot(&app.state); + assert_eq!( + snapshot.sidebar_section_split, + Some(app.state.sidebar_section_split) + ); + } + + #[test] + fn double_clicking_sidebar_divider_resets_default_width() { + let mut app = app_for_mouse_test(); + app.state.default_sidebar_width = 26; + app.state.sidebar_width = 30; + + app.handle_mouse(mouse(MouseEventKind::Down(MouseButton::Left), 25, 5)); + app.handle_mouse(mouse(MouseEventKind::Up(MouseButton::Left), 25, 5)); + app.handle_mouse(mouse(MouseEventKind::Down(MouseButton::Left), 25, 5)); + + assert_eq!(app.state.sidebar_width, 26); + assert!(app.state.drag.is_none()); + let snapshot = capture_snapshot(&app.state); + assert_eq!(snapshot.sidebar_width, Some(26)); + } +} diff --git a/src/app/input/terminal.rs b/src/app/input/terminal.rs new file mode 100644 index 00000000..910a49bd --- /dev/null +++ b/src/app/input/terminal.rs @@ -0,0 +1,440 @@ +use bytes::Bytes; +use crossterm::event::KeyCode; +use tracing::{debug, warn}; + +use crate::{ + app::{App, Mode}, + input::TerminalKey, +}; + +struct PreparedPaneInput { + ws_idx: usize, + pane_id: crate::layout::PaneId, + bytes: Bytes, +} + +fn is_modifier_only_key(code: &KeyCode) -> bool { + matches!(code, KeyCode::Modifier(_)) +} + +impl App { + pub(crate) fn handle_terminal_key_headless(&mut self, key: TerminalKey) { + let Some(input) = self.prepare_terminal_key_forward(key) else { + return; + }; + if let Some(runtime) = self.lookup_runtime_sender(input.ws_idx, input.pane_id) { + let _ = runtime.try_send_bytes(input.bytes); + } + } + + fn prepare_terminal_key_forward(&mut self, key: TerminalKey) -> Option<PreparedPaneInput> { + self.state.clear_selection(); + self.state.update_dismissed = true; + + let key_event = key.as_key_event(); + + if let Some(action) = super::terminal_direct_navigation_action(&self.state, &key_event) { + debug!( + code = ?key_event.code, + modifiers = ?key_event.modifiers, + kind = ?key_event.kind, + action = ?action, + "intercepted terminal direct navigation key before forwarding to pane" + ); + super::navigate::execute_navigate_action(&mut self.state, action); + return None; + } + + if self.state.is_prefix(&key_event) { + self.state.mode = Mode::Navigate; + return None; + } + + if is_modifier_only_key(&key_event.code) { + debug!( + code = ?key_event.code, + modifiers = ?key_event.modifiers, + kind = ?key_event.kind, + "dropping modifier-only terminal key event instead of forwarding it to pane" + ); + return None; + } + + let ws_idx = self.state.active?; + let ws = self.state.workspaces.get(ws_idx)?; + let pane_id = ws.focused_pane_id()?; + let rt = ws.runtimes.get(&pane_id)?; + rt.scroll_reset(); + let protocol = rt.keyboard_protocol(); + let bytes = rt.encode_terminal_key(key); + + if matches!(key_event.code, KeyCode::Esc) + || key_event + .modifiers + .contains(crossterm::event::KeyModifiers::ALT) + { + debug!( + code = ?key_event.code, + modifiers = ?key_event.modifiers, + kind = ?key_event.kind, + protocol = ?protocol, + encoded = ?bytes, + "forwarding potentially-ambiguous terminal key to pane" + ); + } + + if bytes.is_empty() { + if key.kind != crossterm::event::KeyEventKind::Release + && !matches!( + key.code, + KeyCode::CapsLock + | KeyCode::ScrollLock + | KeyCode::NumLock + | KeyCode::PrintScreen + | KeyCode::Pause + | KeyCode::Menu + | KeyCode::KeypadBegin + | KeyCode::Media(_) + | KeyCode::Modifier(_) + ) + { + warn!(code = ?key_event.code, mods = ?key_event.modifiers, state = ?key_event.state, "key produced empty encoding"); + } + return None; + } + + Some(PreparedPaneInput { + ws_idx, + pane_id, + bytes: Bytes::from(bytes), + }) + } + + pub(super) async fn handle_terminal_key(&mut self, key: TerminalKey) { + let Some(input) = self.prepare_terminal_key_forward(key) else { + return; + }; + if let Some(runtime) = self.lookup_runtime_sender(input.ws_idx, input.pane_id) { + let _ = runtime.send_bytes(input.bytes).await; + } + } +} + +#[cfg(test)] +mod tests { + use crossterm::event::{KeyCode, KeyModifiers, MouseButton, MouseEventKind}; + use ratatui::layout::Rect; + + use super::super::{app_for_mouse_test, mouse, numbered_lines_bytes}; + use super::*; + use crate::{config::Config, workspace::Workspace}; + + #[tokio::test] + async fn dragging_selection_above_pane_autoscrolls_and_extends_into_scrollback() { + let mut app = app_for_mouse_test(); + let mut ws = Workspace::test_new("test"); + let pane_id = ws.tabs[0].root_pane; + let pane_infos = ws.tabs[0].layout.panes(Rect::new(26, 2, 80, 18)); + let info = pane_infos[0].clone(); + ws.tabs[0].runtimes.insert( + pane_id, + crate::pane::PaneRuntime::test_with_scrollback_bytes( + info.inner_rect.width, + info.inner_rect.height, + 16 * 1024, + &numbered_lines_bytes(64), + ), + ); + + app.state.workspaces = vec![ws]; + app.state.active = Some(0); + app.state.selected = 0; + app.state.mode = Mode::Terminal; + app.state.view.pane_infos = pane_infos; + + let start_metrics = app.state.workspaces[0] + .runtime(pane_id) + .and_then(crate::pane::PaneRuntime::scroll_metrics) + .expect("initial scroll metrics"); + let start_row = info.inner_rect.y; + let start_col = info.inner_rect.x + 2; + + app.handle_mouse(mouse( + MouseEventKind::Down(MouseButton::Left), + start_col, + start_row, + )); + app.handle_mouse(mouse( + MouseEventKind::Drag(MouseButton::Left), + start_col, + info.inner_rect.y.saturating_sub(1), + )); + + let end_metrics = app.state.workspaces[0] + .runtime(pane_id) + .and_then(crate::pane::PaneRuntime::scroll_metrics) + .expect("scroll metrics after drag"); + assert_eq!( + end_metrics.offset_from_bottom, + start_metrics.offset_from_bottom + 3 + ); + + let selection = app.state.selection.as_ref().expect("selection after drag"); + assert!(selection.is_visible()); + assert_eq!( + selection.ordered_cells(), + ( + ( + (start_metrics.max_offset_from_bottom - end_metrics.offset_from_bottom) as u32, + 2, + ), + (start_metrics.max_offset_from_bottom as u32, 2), + ) + ); + } + + #[tokio::test] + async fn releasing_dragged_selection_clears_highlight_after_copy() { + let mut app = app_for_mouse_test(); + let mut ws = Workspace::test_new("test"); + let pane_id = ws.tabs[0].root_pane; + let pane_infos = ws.tabs[0].layout.panes(Rect::new(26, 2, 80, 18)); + let info = pane_infos[0].clone(); + ws.tabs[0].runtimes.insert( + pane_id, + crate::pane::PaneRuntime::test_with_scrollback_bytes( + info.inner_rect.width, + info.inner_rect.height, + 16 * 1024, + &numbered_lines_bytes(64), + ), + ); + + app.state.workspaces = vec![ws]; + app.state.active = Some(0); + app.state.selected = 0; + app.state.mode = Mode::Terminal; + app.state.view.pane_infos = pane_infos; + + let row = info.inner_rect.y; + let start_col = info.inner_rect.x + 1; + let end_col = info.inner_rect.x + 4; + + app.handle_mouse(mouse( + MouseEventKind::Down(MouseButton::Left), + start_col, + row, + )); + app.handle_mouse(mouse(MouseEventKind::Drag(MouseButton::Left), end_col, row)); + assert!(app.state.selection.is_some()); + + app.handle_mouse(mouse(MouseEventKind::Up(MouseButton::Left), end_col, row)); + + assert!(app.state.selection.is_none()); + } + + #[tokio::test] + async fn wheel_scroll_keeps_in_progress_selection_and_extends_it() { + let mut app = app_for_mouse_test(); + let mut ws = Workspace::test_new("test"); + let pane_id = ws.tabs[0].root_pane; + let pane_infos = ws.tabs[0].layout.panes(Rect::new(26, 2, 80, 18)); + let info = pane_infos[0].clone(); + ws.tabs[0].runtimes.insert( + pane_id, + crate::pane::PaneRuntime::test_with_scrollback_bytes( + info.inner_rect.width, + info.inner_rect.height, + 16 * 1024, + &numbered_lines_bytes(64), + ), + ); + + app.state.workspaces = vec![ws]; + app.state.active = Some(0); + app.state.selected = 0; + app.state.mode = Mode::Terminal; + app.state.view.pane_infos = pane_infos; + + let start_metrics = app.state.workspaces[0] + .runtime(pane_id) + .and_then(crate::pane::PaneRuntime::scroll_metrics) + .expect("initial scroll metrics"); + let top_row = info.inner_rect.y; + let col = info.inner_rect.x + 2; + + app.handle_mouse(mouse(MouseEventKind::Down(MouseButton::Left), col, top_row)); + app.handle_mouse(mouse(MouseEventKind::ScrollUp, col, top_row)); + + let end_metrics = app.state.workspaces[0] + .runtime(pane_id) + .and_then(crate::pane::PaneRuntime::scroll_metrics) + .expect("scroll metrics after wheel"); + assert_eq!( + end_metrics.offset_from_bottom, + start_metrics.offset_from_bottom + 3 + ); + + let selection = app.state.selection.as_ref().expect("selection after wheel"); + assert!(selection.is_visible()); + assert_eq!( + selection.ordered_cells(), + ( + ( + (start_metrics.max_offset_from_bottom - end_metrics.offset_from_bottom) as u32, + 2, + ), + (start_metrics.max_offset_from_bottom as u32, 2), + ) + ); + } + + #[tokio::test] + async fn clicking_unfocused_pane_with_mouse_reporting_focuses_it_via_left_button() { + let mut app = app_for_mouse_test(); + let mut ws = Workspace::test_new("test"); + let first_pane = ws.tabs[0].root_pane; + let second_pane = ws.test_split(ratatui::layout::Direction::Vertical); + + let terminal_area = Rect::new(26, 2, 80, 18); + let pane_infos = ws.tabs[0].layout.panes(terminal_area); + let first_info = pane_infos + .iter() + .find(|p| p.id == first_pane) + .unwrap() + .clone(); + let second_info = pane_infos + .iter() + .find(|p| p.id == second_pane) + .unwrap() + .clone(); + + ws.tabs[0].runtimes.insert( + first_pane, + crate::pane::PaneRuntime::test_with_screen_bytes( + first_info.inner_rect.width.max(1), + first_info.inner_rect.height.max(1), + b"", + ), + ); + ws.tabs[0].runtimes.insert( + second_pane, + crate::pane::PaneRuntime::test_with_screen_bytes( + second_info.inner_rect.width.max(1), + second_info.inner_rect.height.max(1), + b"\x1b[?1002h", + ), + ); + + ws.tabs[0].layout.focus_pane(first_pane); + + app.state.workspaces = vec![ws]; + app.state.active = Some(0); + app.state.selected = 0; + app.state.mode = Mode::Terminal; + app.state.view.pane_infos = pane_infos; + + app.handle_mouse(mouse( + MouseEventKind::Down(MouseButton::Left), + second_info.inner_rect.x + 2, + second_info.inner_rect.y + 2, + )); + + assert_eq!( + app.state.workspaces[0].tabs[0].layout.focused(), + second_pane + ); + assert_eq!(app.state.mode, Mode::Terminal); + } + + #[tokio::test] + async fn clicking_unfocused_pane_with_mouse_reporting_focuses_it_via_right_button() { + let mut app = app_for_mouse_test(); + let mut ws = Workspace::test_new("test"); + let first_pane = ws.tabs[0].root_pane; + let second_pane = ws.test_split(ratatui::layout::Direction::Vertical); + + let terminal_area = Rect::new(26, 2, 80, 18); + let pane_infos = ws.tabs[0].layout.panes(terminal_area); + let first_info = pane_infos + .iter() + .find(|p| p.id == first_pane) + .unwrap() + .clone(); + let second_info = pane_infos + .iter() + .find(|p| p.id == second_pane) + .unwrap() + .clone(); + + ws.tabs[0].runtimes.insert( + first_pane, + crate::pane::PaneRuntime::test_with_screen_bytes( + first_info.inner_rect.width.max(1), + first_info.inner_rect.height.max(1), + b"", + ), + ); + ws.tabs[0].runtimes.insert( + second_pane, + crate::pane::PaneRuntime::test_with_screen_bytes( + second_info.inner_rect.width.max(1), + second_info.inner_rect.height.max(1), + b"\x1b[?1002h", + ), + ); + + ws.tabs[0].layout.focus_pane(first_pane); + + app.state.workspaces = vec![ws]; + app.state.active = Some(0); + app.state.selected = 0; + app.state.mode = Mode::Terminal; + app.state.view.pane_infos = pane_infos; + + app.handle_mouse(mouse( + MouseEventKind::Down(MouseButton::Right), + second_info.inner_rect.x + 2, + second_info.inner_rect.y + 2, + )); + + assert_eq!( + app.state.workspaces[0].tabs[0].layout.focused(), + second_pane + ); + assert_eq!(app.state.mode, Mode::ContextMenu); + assert!(app.state.context_menu.is_some()); + } + + #[tokio::test] + async fn terminal_direct_focus_pane_shortcut_switches_focus_without_leaving_terminal_mode() { + let (_api_tx, api_rx) = tokio::sync::mpsc::unbounded_channel(); + let mut app = App::new( + &Config::default(), + true, + None, + None, + api_rx, + crate::api::EventHub::default(), + ); + app.state.workspaces = vec![Workspace::test_new("test")]; + app.state.active = Some(0); + app.state.selected = 0; + app.state.mode = Mode::Terminal; + app.state.workspaces[0].test_split(ratatui::layout::Direction::Horizontal); + app.state.view.pane_infos = app.state.workspaces[0] + .active_tab() + .unwrap() + .layout + .panes(Rect::new(0, 0, 80, 24)); + let focused_before = app.state.workspaces[0].layout.focused(); + app.state.keybinds.focus_pane_left = Some((KeyCode::Char('h'), KeyModifiers::ALT)); + app.state.keybinds.focus_pane_left_label = Some("alt+h".into()); + + app.handle_terminal_key(TerminalKey::new(KeyCode::Char('h'), KeyModifiers::ALT)) + .await; + + assert_ne!(app.state.workspaces[0].layout.focused(), focused_before); + assert_eq!(app.state.mode, Mode::Terminal); + } +} diff --git a/src/app/mod.rs b/src/app/mod.rs index 7f821da2..51a6678e 100644 --- a/src/app/mod.rs +++ b/src/app/mod.rs @@ -2,15 +2,19 @@ //! //! - `state.rs` — AppState, Mode, and pure data structs //! - `actions.rs` — state mutations (testable without PTYs/async) -//! - `api.rs` — API request handling and response building //! - `input.rs` — key/mouse → action translation -//! - `runtime_commands.rs` — custom command launching and overlay restoration -mod actions; +pub(crate) mod actions; mod api; +mod api_helpers; +mod config_io; +mod creation; +mod ids; mod input; -mod runtime_commands; +mod runtime; +mod session; pub mod state; +mod theme_sync; use std::collections::{HashMap, HashSet}; use std::future::pending; @@ -20,7 +24,7 @@ use std::sync::Arc; use std::time::{Duration, Instant}; const MIN_RENDER_INTERVAL: Duration = Duration::from_millis(16); -const ANIMATION_INTERVAL: Duration = Duration::from_millis(16); +pub(crate) const ANIMATION_INTERVAL: Duration = Duration::from_millis(16); const RESIZE_POLL_INTERVAL: Duration = Duration::from_millis(100); const GIT_REMOTE_STATUS_REFRESH_INTERVAL: Duration = Duration::from_millis(1500); const AUTO_UPDATE_CHECK_INTERVAL: Duration = Duration::from_secs(30 * 60); @@ -31,44 +35,49 @@ use crossterm::terminal; use ratatui::layout::Rect; use ratatui::DefaultTerminal; use tokio::sync::{mpsc, Notify}; -use tracing::{error, info}; +use tracing::info; use crate::config::Config; use crate::events::AppEvent; -use crate::workspace::Workspace; - -#[cfg(test)] -use self::api::api_request_changes_ui; pub use state::{AppState, Mode, ToastKind, ViewState}; /// Full application: AppState + runtime concerns (event channels, async I/O). +#[derive(Debug, Clone, Copy)] +pub(crate) struct OverlayPaneState { + ws_idx: usize, + tab_idx: usize, + previous_focus: crate::layout::PaneId, + previous_zoomed: bool, +} + pub struct App { pub state: AppState, pub event_tx: mpsc::Sender<AppEvent>, - event_rx: mpsc::Receiver<AppEvent>, - api_rx: tokio::sync::mpsc::UnboundedReceiver<crate::api::ApiRequestMessage>, - event_hub: crate::api::EventHub, - last_focus: Option<(usize, crate::layout::PaneId)>, - no_session: bool, - input_rx: Option<mpsc::Receiver<crate::raw_input::RawInputEvent>>, - last_terminal_size: Option<(u16, u16)>, - config_diagnostic_deadline: Option<Instant>, - toast_deadline: Option<Instant>, - last_git_remote_status_refresh: Instant, - last_sidebar_divider_click: Option<Instant>, - next_resize_poll: Instant, - next_animation_tick: Option<Instant>, - next_auto_update_check: Option<Instant>, - session_save_deadline: Option<Instant>, - last_render_at: Option<Instant>, - suppressed_repeat_keys: HashSet<(crossterm::event::KeyCode, crossterm::event::KeyModifiers)>, - render_notify: Arc<Notify>, - render_dirty: Arc<AtomicBool>, - overlay_panes: HashMap<crate::layout::PaneId, runtime_commands::OverlayPaneState>, + pub(crate) event_rx: mpsc::Receiver<AppEvent>, + pub(crate) api_rx: tokio::sync::mpsc::UnboundedReceiver<crate::api::ApiRequestMessage>, + pub(crate) event_hub: crate::api::EventHub, + pub(crate) last_focus: Option<(usize, crate::layout::PaneId)>, + pub(crate) no_session: bool, + pub(crate) input_rx: Option<mpsc::Receiver<crate::raw_input::RawInputEvent>>, + pub(crate) last_terminal_size: Option<(u16, u16)>, + pub(crate) config_diagnostic_deadline: Option<Instant>, + pub(crate) toast_deadline: Option<Instant>, + pub(crate) last_git_remote_status_refresh: Instant, + pub(crate) last_sidebar_divider_click: Option<Instant>, + pub(crate) next_resize_poll: Instant, + pub(crate) next_animation_tick: Option<Instant>, + pub(crate) next_auto_update_check: Option<Instant>, + pub(crate) session_save_deadline: Option<Instant>, + pub(crate) last_render_at: Option<Instant>, + pub(crate) suppressed_repeat_keys: + HashSet<(crossterm::event::KeyCode, crossterm::event::KeyModifiers)>, + pub render_notify: Arc<Notify>, + pub render_dirty: Arc<AtomicBool>, + pub(crate) overlay_panes: HashMap<crate::layout::PaneId, OverlayPaneState>, } -enum LoopEvent { +pub(crate) enum LoopEvent { Timer, Internal(AppEvent), Api(crate::api::ApiRequestMessage), @@ -99,6 +108,10 @@ fn repeat_key_identity( (key.code, key.modifiers) } +fn auto_updates_enabled(no_session: bool) -> bool { + !no_session && !cfg!(debug_assertions) +} + /// Resolve the palette from config: base theme + optional custom overrides. fn resolve_palette(config: &crate::config::Config) -> state::Palette { // Start with the named theme (default: catppuccin) @@ -228,9 +241,12 @@ impl App { selected, mode, should_quit: false, + quit_detaches: !no_session, + detach_requested: false, request_new_workspace: false, request_new_tab: false, request_reload_keybinds: false, + request_clipboard_write: None, creating_new_tab: false, requested_new_tab_name: None, request_complete_onboarding: false, @@ -307,9 +323,10 @@ impl App { ws.refresh_git_ahead_behind(); } - // Background auto-update (skipped in --no-session / test mode) - // Check once at startup, then periodically from the main loop. - if !no_session { + // Background auto-update is disabled in monolithic no-session mode + // and in debug/test builds so local development never mutates the + // running binary out from under spawned test processes. + if auto_updates_enabled(no_session) { let update_tx = event_tx.clone(); std::thread::spawn(move || crate::update::auto_update(update_tx)); } @@ -334,7 +351,7 @@ impl App { last_sidebar_divider_click: None, next_resize_poll: Instant::now() + RESIZE_POLL_INTERVAL, next_animation_tick: None, - next_auto_update_check: (!no_session) + next_auto_update_check: auto_updates_enabled(no_session) .then_some(Instant::now() + AUTO_UPDATE_CHECK_INTERVAL), session_save_deadline: None, last_render_at: None, @@ -351,42 +368,6 @@ impl App { } } - fn schedule_session_save(&mut self) { - if !self.no_session { - self.session_save_deadline = Some(Instant::now() + SESSION_SAVE_DEBOUNCE); - } - } - - fn sync_session_save_schedule(&mut self) { - if self.state.session_dirty { - self.state.session_dirty = false; - self.schedule_session_save(); - } - } - - fn save_session_now(&mut self) { - if self.no_session { - self.session_save_deadline = None; - return; - } - - if self.state.workspaces.is_empty() { - crate::persist::clear(); - } else { - let snap = crate::persist::capture( - &self.state.workspaces, - self.state.active, - self.state.selected, - self.state.agent_panel_scope, - self.state.sidebar_width, - self.state.sidebar_section_split, - ); - crate::persist::save(&snap); - } - - self.session_save_deadline = None; - } - pub async fn run(&mut self, terminal: &mut DefaultTerminal) -> io::Result<()> { if self.input_rx.is_none() { self.input_rx = Some(crate::raw_input::spawn_input_reader()); @@ -510,453 +491,6 @@ impl App { Ok(()) } - fn drain_api_requests(&mut self) -> bool { - let mut changed = false; - while let Ok(msg) = self.api_rx.try_recv() { - changed |= self.handle_api_request_message(msg); - } - changed - } - - async fn handle_raw_input_batch(&mut self, first: crate::raw_input::RawInputEvent) -> bool { - let mut changed = self.handle_raw_input_event(first).await; - - while let Some(rx) = self.input_rx.as_mut() { - match rx.try_recv() { - Ok(event) => changed |= self.handle_raw_input_event(event).await, - Err(tokio::sync::mpsc::error::TryRecvError::Empty) => break, - Err(tokio::sync::mpsc::error::TryRecvError::Disconnected) => { - self.input_rx = None; - break; - } - } - } - - changed - } - - async fn handle_raw_input_event(&mut self, event: crate::raw_input::RawInputEvent) -> bool { - match event { - crate::raw_input::RawInputEvent::Key(key) => { - let key_id = repeat_key_identity(&key); - match key.kind { - crossterm::event::KeyEventKind::Press => { - if self.state.mode == Mode::Terminal { - self.suppressed_repeat_keys.remove(&key_id); - } else { - self.suppressed_repeat_keys.insert(key_id); - } - self.handle_key(key).await; - true - } - crossterm::event::KeyEventKind::Repeat => { - if self.state.mode == Mode::Terminal - && !self.suppressed_repeat_keys.contains(&key_id) - { - self.handle_key(key).await; - true - } else { - false - } - } - crossterm::event::KeyEventKind::Release => { - self.suppressed_repeat_keys.remove(&key_id); - false - } - } - } - crate::raw_input::RawInputEvent::Paste(text) => { - self.handle_paste(text).await; - true - } - crate::raw_input::RawInputEvent::Mouse(mouse) => { - self.handle_mouse(mouse); - true - } - crate::raw_input::RawInputEvent::HostDefaultColor { kind, color } => { - let next_theme = self.state.host_terminal_theme.with_color(kind, color); - if next_theme == self.state.host_terminal_theme { - return false; - } - self.state.host_terminal_theme = next_theme; - self.apply_host_terminal_theme_to_panes(); - true - } - crate::raw_input::RawInputEvent::Unsupported => false, - } - } - - fn query_host_terminal_theme(&self) { - use std::io::Write; - - let _ = std::io::stdout() - .write_all(crate::terminal_theme::HOST_COLOR_QUERY_SEQUENCE.as_bytes()); - let _ = std::io::stdout().flush(); - } - - fn apply_host_terminal_theme_to_panes(&self) { - if self.state.host_terminal_theme.is_empty() { - return; - } - - for workspace in &self.state.workspaces { - for tab in &workspace.tabs { - for runtime in tab.runtimes.values() { - runtime.apply_host_terminal_theme(self.state.host_terminal_theme); - } - } - } - - self.render_dirty.store(true, Ordering::Release); - self.render_notify.notify_one(); - } - - fn handle_resize_poll(&mut self) -> bool { - let Ok(size) = terminal::size() else { - return false; - }; - if self.last_terminal_size != Some(size) { - self.last_terminal_size = Some(size); - return true; - } - false - } - - fn handle_scheduled_tasks(&mut self, now: Instant) -> bool { - let mut changed = false; - - self.sync_animation_timer(now); - - if now >= self.next_resize_poll { - changed |= self.handle_resize_poll(); - self.next_resize_poll = now + RESIZE_POLL_INTERVAL; - } - - if self - .config_diagnostic_deadline - .is_some_and(|deadline| now >= deadline) - { - self.config_diagnostic_deadline = None; - self.state.config_diagnostic = None; - changed = true; - } - - if self.toast_deadline.is_some_and(|deadline| now >= deadline) { - self.toast_deadline = None; - self.state.toast = None; - changed = true; - } - - if self - .next_animation_tick - .is_some_and(|deadline| now >= deadline) - { - self.state.spinner_tick = self.state.spinner_tick.wrapping_add(1); - self.next_animation_tick = Some(now + ANIMATION_INTERVAL); - changed = true; - } - - if self - .git_refresh_deadline() - .is_some_and(|deadline| now >= deadline) - { - for ws in &mut self.state.workspaces { - ws.refresh_git_ahead_behind(); - } - self.last_git_remote_status_refresh = now; - changed = true; - } - - if self - .next_auto_update_check - .is_some_and(|deadline| now >= deadline) - { - self.run_auto_update_check(); - } - - if self - .session_save_deadline - .is_some_and(|deadline| now >= deadline) - { - self.save_session_now(); - } - - self.sync_animation_timer(now); - changed - } - - fn sync_animation_timer(&mut self, now: Instant) { - if self.agent_panel_has_animation() { - self.next_animation_tick - .get_or_insert(now + ANIMATION_INTERVAL); - } else { - self.next_animation_tick = None; - } - } - - fn agent_panel_has_animation(&self) -> bool { - match self.state.agent_panel_scope { - crate::app::state::AgentPanelScope::CurrentWorkspace => self - .state - .active - .and_then(|idx| self.state.workspaces.get(idx)) - .is_some_and(Workspace::has_working_pane), - crate::app::state::AgentPanelScope::AllWorkspaces => self - .state - .workspaces - .iter() - .any(Workspace::has_working_pane), - } - } - - fn can_render_now(&self, now: Instant) -> bool { - match self.last_render_at { - Some(last_render_at) => now.duration_since(last_render_at) >= MIN_RENDER_INTERVAL, - None => true, - } - } - - fn run_auto_update_check(&mut self) { - self.next_auto_update_check = self - .state - .update_available - .is_none() - .then_some(Instant::now() + AUTO_UPDATE_CHECK_INTERVAL); - - if self.state.update_available.is_some() { - return; - } - - let update_tx = self.event_tx.clone(); - std::thread::spawn(move || crate::update::auto_update(update_tx)); - } - - fn git_refresh_deadline(&self) -> Option<Instant> { - (!self.state.workspaces.is_empty()) - .then_some(self.last_git_remote_status_refresh + GIT_REMOTE_STATUS_REFRESH_INTERVAL) - } - - fn next_loop_deadline(&self, now: Instant, needs_render: bool) -> Option<Instant> { - let render_deadline = if needs_render { - self.last_render_at - .map(|last_render_at| last_render_at + MIN_RENDER_INTERVAL) - .filter(|deadline| *deadline > now) - } else { - None - }; - - [ - Some(self.next_resize_poll), - self.config_diagnostic_deadline, - self.toast_deadline, - self.next_animation_tick, - self.git_refresh_deadline(), - self.next_auto_update_check, - self.session_save_deadline, - render_deadline, - ] - .into_iter() - .flatten() - .min() - } - - fn drain_internal_events(&mut self) -> bool { - let mut had_event = false; - while let Ok(ev) = self.event_rx.try_recv() { - had_event = true; - self.handle_internal_event(ev); - } - had_event - } - - fn handle_internal_event(&mut self, ev: AppEvent) { - if let AppEvent::ClipboardWrite { content } = ev { - crate::selection::write_osc52_bytes(&content); - return; - } - - let overlay_state = if let AppEvent::PaneDied { pane_id } = &ev { - self.overlay_panes.remove(pane_id) - } else { - None - }; - - if let AppEvent::PaneDied { pane_id } = &ev { - if let Some((ws_idx, _)) = self.find_pane(*pane_id) { - if let Some(public_pane_id) = self.public_pane_id(ws_idx, *pane_id) { - self.emit_event(crate::api::schema::EventEnvelope { - event: crate::api::schema::EventKind::PaneExited, - data: crate::api::schema::EventData::PaneExited { - pane_id: public_pane_id, - workspace_id: self.public_workspace_id(ws_idx), - }, - }); - } - } - } - - let released_agent = if let AppEvent::HookAgentReleased { - pane_id, - known_agent, - .. - } = &ev - { - known_agent.map(|agent| (*pane_id, agent)) - } else { - None - }; - - let previous_toast = self.state.toast.clone(); - let pane_updates = self.state.handle_app_event(ev); - for update in &pane_updates { - self.emit_pane_state_update(update); - } - if let Some((pane_id, agent)) = released_agent { - if pane_updates.iter().any(|update| update.pane_id == pane_id) { - if let Some((ws_idx, _)) = self.find_pane(pane_id) { - if let Some(runtime) = self.state.workspaces[ws_idx].runtimes.get(&pane_id) { - runtime.begin_graceful_release(agent); - } - } - } - } - if let Some(overlay) = overlay_state { - self.restore_overlay_after_exit(overlay); - } - self.sync_toast_deadline(previous_toast); - } - - fn emit_pane_state_update(&self, update: &crate::app::actions::PaneStateUpdate) { - let Some(pane_id) = self.public_pane_id(update.ws_idx, update.pane_id) else { - return; - }; - let workspace_id = self.public_workspace_id(update.ws_idx); - - if update.previous_agent_label != update.agent_label { - self.emit_event(crate::api::schema::EventEnvelope { - event: crate::api::schema::EventKind::PaneAgentDetected, - data: crate::api::schema::EventData::PaneAgentDetected { - pane_id: pane_id.clone(), - workspace_id: workspace_id.clone(), - agent: update.agent_label.clone(), - }, - }); - } - - if update.previous_state != update.state { - let agent_status = self - .state - .workspaces - .get(update.ws_idx) - .and_then(|ws| ws.pane_state(update.pane_id)) - .map(|pane| pane_agent_status(pane.state, pane.seen)) - .unwrap_or_else(|| pane_agent_status(update.state, true)); - self.emit_event(crate::api::schema::EventEnvelope { - event: crate::api::schema::EventKind::PaneAgentStatusChanged, - data: crate::api::schema::EventData::PaneAgentStatusChanged { - pane_id, - workspace_id, - agent_status, - }, - }); - } - } - - fn sync_toast_deadline( - &mut self, - previous_toast: Option<crate::app::state::ToastNotification>, - ) { - if self.state.toast != previous_toast { - self.toast_deadline = self.state.toast.as_ref().map(|toast| { - let duration = match toast.kind { - ToastKind::NeedsAttention => Duration::from_secs(8), - ToastKind::Finished => Duration::from_secs(5), - ToastKind::UpdateInstalled => Duration::from_secs(3), - }; - Instant::now() + duration - }); - } - } - - fn emit_event(&self, event: crate::api::schema::EventEnvelope) { - self.event_hub.push(event); - } - - fn sync_focus_events(&mut self) { - let current_focus = self.state.active.and_then(|idx| { - self.state - .workspaces - .get(idx) - .and_then(|ws| ws.focused_pane_id().map(|pane_id| (idx, pane_id))) - }); - if current_focus == self.last_focus { - return; - } - - if let Some((ws_idx, pane_id)) = self.last_focus { - self.send_pane_focus_event(ws_idx, pane_id, crate::ghostty::FocusEvent::Lost); - } - if let Some((ws_idx, pane_id)) = current_focus { - self.send_pane_focus_event(ws_idx, pane_id, crate::ghostty::FocusEvent::Gained); - self.emit_event(crate::api::schema::EventEnvelope { - event: crate::api::schema::EventKind::WorkspaceFocused, - data: crate::api::schema::EventData::WorkspaceFocused { - workspace_id: self.public_workspace_id(ws_idx), - }, - }); - if let Some(tab_id) = - self.public_tab_id(ws_idx, self.state.workspaces[ws_idx].active_tab) - { - self.emit_event(crate::api::schema::EventEnvelope { - event: crate::api::schema::EventKind::TabFocused, - data: crate::api::schema::EventData::TabFocused { - tab_id, - workspace_id: self.public_workspace_id(ws_idx), - }, - }); - } - if let Some(public_pane_id) = self.public_pane_id(ws_idx, pane_id) { - self.emit_event(crate::api::schema::EventEnvelope { - event: crate::api::schema::EventKind::PaneFocused, - data: crate::api::schema::EventData::PaneFocused { - pane_id: public_pane_id, - workspace_id: self.public_workspace_id(ws_idx), - }, - }); - } - } - - self.last_focus = current_focus; - } - - fn send_pane_focus_event( - &self, - ws_idx: usize, - pane_id: crate::layout::PaneId, - event: crate::ghostty::FocusEvent, - ) { - let Some(runtime) = self - .state - .workspaces - .get(ws_idx) - .and_then(|ws| ws.runtime(pane_id)) - else { - return; - }; - runtime.try_send_focus_event(event); - } - - fn find_pane( - &self, - pane_id: crate::layout::PaneId, - ) -> Option<(usize, &crate::pane::PaneState)> { - self.state - .workspaces - .iter() - .enumerate() - .find_map(|(ws_idx, ws)| ws.pane_state(pane_id).map(|pane| (ws_idx, pane))) - } - pub(crate) fn dismiss_release_notes(&mut self) { let preview = self .state @@ -1018,29 +552,7 @@ impl App { } } - fn update_config_file<F>(&mut self, error_context: &str, update: F) - where - F: FnOnce(&str) -> String, - { - let path = crate::config::config_path(); - if let Some(parent) = path.parent() { - if let Err(err) = std::fs::create_dir_all(parent) { - self.state.config_diagnostic = - Some(format!("failed to save {error_context}: {err}")); - self.config_diagnostic_deadline = Some(Instant::now() + Duration::from_secs(5)); - return; - } - } - - let content = std::fs::read_to_string(&path).unwrap_or_default(); - let new_content = update(&content); - if let Err(err) = std::fs::write(&path, new_content) { - self.state.config_diagnostic = Some(format!("failed to save {error_context}: {err}")); - self.config_diagnostic_deadline = Some(Instant::now() + Duration::from_secs(5)); - } - } - - fn reload_keybinds(&mut self) { + pub(crate) fn reload_keybinds(&mut self) { let previous_toast = self.state.toast.clone(); match crate::config::load_live_keybinds() { Ok(live) => { @@ -1067,216 +579,145 @@ impl App { } self.sync_toast_deadline(previous_toast); } +} - fn save_theme(&mut self, name: &str) { - self.update_config_file("theme", |content| { - crate::config::upsert_section_value(content, "theme", "name", &format!("\"{name}\"")) - }); - } - - fn save_sound(&mut self, enabled: bool) { - self.update_config_file("sound setting", |content| { - crate::config::upsert_section_bool(content, "ui.sound", "enabled", enabled) - }); - } - - fn save_toast(&mut self, enabled: bool) { - self.update_config_file("toast setting", |content| { - crate::config::upsert_section_bool(content, "ui.toast", "enabled", enabled) - }); - } - - fn seed_cwd_from_workspace(&self, ws_idx: usize) -> Option<std::path::PathBuf> { - self.state.workspaces.get(ws_idx)?.resolved_identity_cwd() - } - - fn workspace_creation_source(&self) -> Option<usize> { - if self.state.mode == Mode::Navigate - && self.state.workspaces.get(self.state.selected).is_some() - { - return Some(self.state.selected); - } - - self.state.active.or_else(|| { - self.state - .workspaces - .get(self.state.selected) - .map(|_| self.state.selected) - }) - } - - /// Create a workspace with a real PTY (needs event_tx). - fn create_workspace(&mut self) { - let initial_cwd = self - .workspace_creation_source() - .and_then(|ws_idx| self.seed_cwd_from_workspace(ws_idx)) - .or_else(|| std::env::current_dir().ok()) - .unwrap_or_else(|| std::path::PathBuf::from("/")); - if let Err(e) = self.create_workspace_with_options(initial_cwd, true) { - error!(err = %e, "failed to create workspace"); - self.state.mode = Mode::Navigate; - } - } +// --------------------------------------------------------------------------- +// Input routing for headless server mode +// --------------------------------------------------------------------------- - fn create_tab(&mut self) { - let custom_name = self.state.requested_new_tab_name.take(); - let initial_cwd = self - .state - .active - .and_then(|ws_idx| self.seed_cwd_from_workspace(ws_idx)) - .or_else(|| std::env::current_dir().ok()) - .unwrap_or_else(|| std::path::PathBuf::from("/")); - match self.create_tab_with_options(initial_cwd, true) { - Ok(tab_idx) => { - if let Some(name) = custom_name { - if let Some(ws) = self - .state - .active - .and_then(|ws_idx| self.state.workspaces.get_mut(ws_idx)) - { - if let Some(tab) = ws.tabs.get_mut(tab_idx) { - tab.set_custom_name(name); +impl App { + /// Routes raw input bytes from a client through the existing input pipeline. + /// + /// The input bytes are parsed into `RawInputEvent`s and then processed. + /// In terminal mode, keys are routed through the same semantic + /// key-handling path as monolithic herdr so they are re-encoded for the + /// focused pane's negotiated keyboard protocol instead of passing host + /// terminal escape sequences through unchanged. + #[cfg(test)] + pub(crate) fn route_client_input(&mut self, data: Vec<u8>) { + let events = crate::raw_input::parse_raw_input_bytes_sync(&data); + self.route_client_events(events, true); + } + + pub(crate) fn route_client_events( + &mut self, + events: Vec<crate::raw_input::RawInputEvent>, + apply_host_terminal_theme: bool, + ) { + for event in events { + match event { + crate::raw_input::RawInputEvent::Key(key) => { + let key_id = repeat_key_identity(&key); + match key.kind { + crossterm::event::KeyEventKind::Press => { + if self.state.mode == Mode::Terminal { + self.suppressed_repeat_keys.remove(&key_id); + self.handle_terminal_key_headless(key); + } else { + self.suppressed_repeat_keys.insert(key_id); + self.handle_non_terminal_key(key); + } + } + crossterm::event::KeyEventKind::Repeat => { + if self.state.mode == Mode::Terminal + && !self.suppressed_repeat_keys.contains(&key_id) + { + self.handle_terminal_key_headless(key); + } + // Repeats in non-terminal modes are ignored + // (same as monolithic behavior). + } + crossterm::event::KeyEventKind::Release => { + self.suppressed_repeat_keys.remove(&key_id); } - self.schedule_session_save(); } } + crate::raw_input::RawInputEvent::Mouse(mouse) => { + self.handle_mouse_event_headless(mouse); + } + crate::raw_input::RawInputEvent::Paste(text) => { + if self.state.mode == Mode::Terminal { + if let Some(ws_idx) = self.state.active { + if let Some(ws) = self.state.workspaces.get(ws_idx) { + if let Some(focused) = ws.focused_pane_id() { + if let Some(runtime) = ws.runtimes.get(&focused) { + let _ = runtime.try_send_bytes(bytes::Bytes::from( + if runtime + .input_state() + .map(|s| s.bracketed_paste) + .unwrap_or(false) + { + format!("\x1b[200~{text}\x1b[201~") + } else { + text + }, + )); + } + } + } + } + } + } + crate::raw_input::RawInputEvent::HostDefaultColor { kind, color } => { + if apply_host_terminal_theme { + self.update_host_terminal_theme(kind, color); + } + } + crate::raw_input::RawInputEvent::Unsupported => {} } - Err(e) => { - error!(err = %e, "failed to create tab"); - } - } - } - - fn create_tab_with_options( - &mut self, - initial_cwd: std::path::PathBuf, - focus: bool, - ) -> std::io::Result<usize> { - let Some(ws_idx) = self.state.active else { - return self.create_workspace_with_options(initial_cwd, focus); - }; - let (rows, cols) = self.state.estimate_pane_size(); - let ws = &mut self.state.workspaces[ws_idx]; - let idx = ws.create_tab( - rows, - cols, - initial_cwd, - self.state.pane_scrollback_limit_bytes, - self.state.host_terminal_theme, - )?; - if focus { - ws.switch_tab(idx); - self.state.mode = Mode::Terminal; } - self.schedule_session_save(); - Ok(idx) } - fn create_workspace_with_options( - &mut self, - initial_cwd: std::path::PathBuf, - focus: bool, - ) -> std::io::Result<usize> { - let (rows, cols) = self.state.estimate_pane_size(); - let mut ws = Workspace::new( - initial_cwd, - rows, - cols, - self.state.pane_scrollback_limit_bytes, - self.state.host_terminal_theme, - self.event_tx.clone(), - self.render_notify.clone(), - self.render_dirty.clone(), - )?; - ws.refresh_git_ahead_behind(); - self.state.workspaces.push(ws); - let idx = self.state.workspaces.len() - 1; - if focus || self.state.active.is_none() { - self.state.switch_workspace(idx); - self.state.mode = Mode::Terminal; + /// Handles a key event in non-terminal mode for the headless server. + /// + /// Uses the standalone handler functions that work on `&mut AppState` + /// since the server doesn't have the async context of the monolithic App. + fn handle_non_terminal_key(&mut self, key: crate::input::TerminalKey) { + let key_event = key.as_key_event(); + match self.state.mode { + Mode::Navigate => { + input::handle_navigate_key(&mut self.state, key_event); + } + Mode::RenameWorkspace | Mode::RenameTab => { + input::handle_rename_key(&mut self.state, key_event); + } + Mode::Resize => { + input::handle_resize_key(&mut self.state, key_event); + } + Mode::ConfirmClose => { + input::handle_confirm_close_key(&mut self.state, key_event); + } + Mode::ContextMenu => { + input::handle_context_menu_key(&mut self.state, key_event); + } + Mode::KeybindHelp => { + input::handle_keybind_help_key(&mut self.state, key_event); + } + Mode::GlobalMenu => { + input::handle_global_menu_key(&mut self.state, key_event); + } + Mode::Onboarding => { + self.handle_onboarding_key(key_event); + } + Mode::ReleaseNotes => { + self.handle_release_notes_key(key_event); + } + Mode::Settings => { + self.handle_settings_key(key_event); + } + Mode::Terminal => { + // Should not be called in terminal mode. + } } - self.schedule_session_save(); - Ok(idx) - } -} - -fn tab_attention_priority(state: crate::detect::AgentState, seen: bool) -> u8 { - match (state, seen) { - (crate::detect::AgentState::Blocked, _) => 4, - (crate::detect::AgentState::Idle, false) => 3, - (crate::detect::AgentState::Working, _) => 2, - (crate::detect::AgentState::Idle, true) => 1, - (crate::detect::AgentState::Unknown, _) => 0, - } -} - -fn parse_api_key(key: &str) -> Option<crossterm::event::KeyEvent> { - use crossterm::event::{KeyCode, KeyEvent, KeyModifiers}; - - let normalized = key.trim(); - match normalized { - "Enter" | "enter" => Some(KeyEvent::new(KeyCode::Enter, KeyModifiers::empty())), - "Tab" | "tab" => Some(KeyEvent::new(KeyCode::Tab, KeyModifiers::empty())), - "Esc" | "esc" => Some(KeyEvent::new(KeyCode::Esc, KeyModifiers::empty())), - "Backspace" | "backspace" => Some(KeyEvent::new(KeyCode::Backspace, KeyModifiers::empty())), - "Up" | "up" => Some(KeyEvent::new(KeyCode::Up, KeyModifiers::empty())), - "Down" | "down" => Some(KeyEvent::new(KeyCode::Down, KeyModifiers::empty())), - "Left" | "left" => Some(KeyEvent::new(KeyCode::Left, KeyModifiers::empty())), - "Right" | "right" => Some(KeyEvent::new(KeyCode::Right, KeyModifiers::empty())), - "C-c" | "c-c" | "ctrl+c" => Some(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL)), - _ if normalized.len() == 1 => normalized - .chars() - .next() - .map(|ch| KeyEvent::new(KeyCode::Char(ch), KeyModifiers::empty())), - _ => None, - } -} - -fn encode_api_text(runtime: &crate::pane::PaneRuntime, text: &str) -> Vec<u8> { - let bracketed = runtime - .input_state() - .map(|state| state.bracketed_paste) - .unwrap_or(false); - if bracketed { - format!("\x1b[200~{text}\x1b[201~").into_bytes() - } else { - text.as_bytes().to_vec() - } -} - -fn encode_api_keys( - runtime: &crate::pane::PaneRuntime, - keys: &[String], -) -> Result<Vec<Vec<u8>>, String> { - let mut encoded_keys = Vec::with_capacity(keys.len()); - for key in keys { - let Some(key_event) = parse_api_key(key) else { - return Err(key.clone()); - }; - encoded_keys.push(runtime.encode_terminal_key(key_event.into())); - } - Ok(encoded_keys) -} - -fn detect_state_from_api(state: crate::api::schema::PaneAgentState) -> crate::detect::AgentState { - match state { - crate::api::schema::PaneAgentState::Idle => crate::detect::AgentState::Idle, - crate::api::schema::PaneAgentState::Working => crate::detect::AgentState::Working, - crate::api::schema::PaneAgentState::Blocked => crate::detect::AgentState::Blocked, - crate::api::schema::PaneAgentState::Unknown => crate::detect::AgentState::Unknown, } -} -fn pane_agent_status( - state: crate::detect::AgentState, - seen: bool, -) -> crate::api::schema::AgentStatus { - match (state, seen) { - (crate::detect::AgentState::Idle, false) => crate::api::schema::AgentStatus::Done, - (crate::detect::AgentState::Idle, true) => crate::api::schema::AgentStatus::Idle, - (crate::detect::AgentState::Working, _) => crate::api::schema::AgentStatus::Working, - (crate::detect::AgentState::Blocked, _) => crate::api::schema::AgentStatus::Blocked, - (crate::detect::AgentState::Unknown, _) => crate::api::schema::AgentStatus::Unknown, + /// Handles a mouse event for the headless server. + /// + /// Delegates to the same mouse handling logic used in the monolithic + /// mode (hit-testing against the rendered UI), which works because + /// the server's AppState maintains view geometry from virtual rendering. + fn handle_mouse_event_headless(&mut self, mouse: crossterm::event::MouseEvent) { + self.handle_mouse(mouse); } } @@ -1285,6 +726,7 @@ mod tests { use super::*; use crate::config::Config; use crate::detect::{Agent, AgentState}; + use crate::pane::PaneRuntime; use crate::workspace::Workspace; use crossterm::event::{KeyCode, KeyEventKind, KeyModifiers}; use std::sync::{Mutex, OnceLock}; @@ -1541,8 +983,8 @@ mod tests { ), }; - assert!(!api_request_changes_ui(&read_only)); - assert!(api_request_changes_ui(&mutating)); + assert!(!crate::api::request_changes_ui(&read_only)); + assert!(crate::api::request_changes_ui(&mutating)); } #[test] @@ -1614,6 +1056,22 @@ mod tests { } #[test] + fn server_stop_request_sets_should_quit_flag() { + let mut app = test_app(); + + let response = app.handle_api_request(crate::api::schema::Request { + id: "req_server_stop".into(), + method: crate::api::schema::Method::ServerStop( + crate::api::schema::EmptyParams::default(), + ), + }); + let response: serde_json::Value = serde_json::from_str(&response).unwrap(); + + assert_eq!(response["result"]["type"], "ok"); + assert!(app.state.should_quit); + } + + #[test] fn pane_close_request_closes_only_the_target_tab_when_other_tabs_exist() { let mut app = test_app(); let mut workspace = Workspace::test_new("api-pane-close"); @@ -1758,4 +1216,230 @@ mod tests { "Working→Idle should still apply after temporary queue pressure" ); } + + #[test] + fn route_client_input_dispatches_navigate_mode_keybinds() { + let mut app = test_app(); + app.state.workspaces = vec![Workspace::test_new("test")]; + app.state.active = Some(0); + app.state.selected = 0; + + // Start in navigate mode. + app.state.mode = Mode::Navigate; + + // Send Ctrl+B then Esc (prefix → leave navigate mode). + // Ctrl+B is 0x02 in raw terminal input. + // After entering navigate mode and pressing Esc, we should leave navigate mode. + let esc_bytes = vec![0x1b]; // Esc + app.route_client_input(esc_bytes); + // Esc in navigate mode should leave navigate mode. + assert_eq!( + app.state.mode, + Mode::Terminal, + "Esc should leave navigate mode and return to Terminal mode" + ); + } + + #[test] + fn route_client_input_q_detaches_in_persistence_mode() { + let mut app = test_app(); + app.state.workspaces = vec![Workspace::test_new("test")]; + app.state.active = Some(0); + app.state.selected = 0; + app.state.quit_detaches = true; + + // Start in navigate mode. + app.state.mode = Mode::Navigate; + assert!(!app.state.detach_requested); + + let q_bytes = b"q".to_vec(); + app.route_client_input(q_bytes); + + assert!( + app.state.detach_requested, + "q should detach in persistence mode" + ); + assert_eq!( + app.state.mode, + Mode::Terminal, + "q should leave navigate mode" + ); + } + + #[test] + fn route_client_input_prefix_then_q_detaches_in_persistence_mode() { + let mut app = test_app(); + app.state.workspaces = vec![Workspace::test_new("test")]; + app.state.active = Some(0); + app.state.selected = 0; + app.state.quit_detaches = true; + + // Start in terminal mode (default after workspace creation). + app.state.mode = Mode::Terminal; + assert!(!app.state.detach_requested); + + // Send Ctrl+B (prefix key, raw byte 0x02). + let prefix_bytes = vec![0x02]; + app.route_client_input(prefix_bytes); + + assert_eq!( + app.state.mode, + Mode::Navigate, + "prefix key should enter navigate mode" + ); + assert!( + !app.state.detach_requested, + "prefix key should not set detach flag" + ); + + let q_bytes = b"q".to_vec(); + app.route_client_input(q_bytes); + + assert!( + app.state.detach_requested, + "q should detach in persistence mode" + ); + assert_eq!( + app.state.mode, + Mode::Terminal, + "q should leave navigate mode" + ); + } + + #[tokio::test] + async fn route_client_input_reencodes_terminal_keys_for_focused_pane_protocol() { + let mut app = test_app(); + let mut workspace = Workspace::test_new("test"); + let focused = workspace.focused_pane_id().unwrap(); + let (runtime, mut rx) = PaneRuntime::test_with_channel(80, 24); + workspace.tabs[0].runtimes.insert(focused, runtime); + app.state.workspaces = vec![workspace]; + app.state.active = Some(0); + app.state.selected = 0; + app.state.mode = Mode::Terminal; + + // Ghostty/kitty-style Ctrl-C should be normalized back to the pane's + // negotiated encoding instead of being forwarded verbatim. + app.route_client_input(b"\x1b[99;5u".to_vec()); + + assert_eq!(rx.recv().await.unwrap(), bytes::Bytes::from(vec![3])); + } + + #[tokio::test] + async fn route_client_input_splits_multi_event_payloads_before_forwarding() { + let mut app = test_app(); + let mut workspace = Workspace::test_new("test"); + let focused = workspace.focused_pane_id().unwrap(); + let (runtime, mut rx) = PaneRuntime::test_with_channel(80, 24); + workspace.tabs[0].runtimes.insert(focused, runtime); + app.state.workspaces = vec![workspace]; + app.state.active = Some(0); + app.state.selected = 0; + app.state.mode = Mode::Terminal; + + app.route_client_input(b"ab".to_vec()); + + assert_eq!(rx.recv().await.unwrap(), bytes::Bytes::from_static(b"a")); + assert_eq!(rx.recv().await.unwrap(), bytes::Bytes::from_static(b"b")); + assert!(rx.try_recv().is_err()); + } + + #[test] + fn route_client_input_handles_mouse_events() { + let mut app = test_app(); + app.state.workspaces = vec![Workspace::test_new("test")]; + app.state.active = Some(0); + app.state.selected = 0; + + // Send a mouse scroll-up event via SGR encoding. + let mouse_bytes = b"\x1b[<64;10;5M".to_vec(); + // This should not panic even though mouse handling is simplified + // in headless mode. + app.route_client_input(mouse_bytes); + // No assertions on specific behavior — just no panic. + } + + #[test] + fn route_client_input_advances_onboarding_modal() { + let mut app = test_app(); + app.state.mode = Mode::Onboarding; + app.state.onboarding_step = 0; + + app.route_client_input(b"\r".to_vec()); + + assert_eq!(app.state.onboarding_step, 1); + assert_eq!(app.state.mode, Mode::Onboarding); + } + + #[test] + fn route_client_input_closes_release_notes_modal() { + let mut app = test_app(); + app.state.workspaces = vec![Workspace::test_new("test")]; + app.state.active = Some(0); + app.state.selected = 0; + app.state.mode = Mode::ReleaseNotes; + app.state.release_notes = Some(release_notes_state()); + + app.route_client_input(b"\x1b".to_vec()); + + assert_eq!(app.state.mode, Mode::Terminal); + assert!(app.state.release_notes.is_none()); + } + + #[test] + fn route_client_input_closes_settings_modal() { + let mut app = test_app(); + app.state.workspaces = vec![Workspace::test_new("test")]; + app.state.active = Some(0); + app.state.selected = 0; + app.state.mode = Mode::Settings; + app.state.settings.original_theme = Some(app.state.theme_name.clone()); + app.state.settings.original_palette = Some(app.state.palette.clone()); + + app.route_client_input(b"\x1b".to_vec()); + + assert_eq!(app.state.mode, Mode::Terminal); + } + + #[test] + fn route_client_input_updates_host_terminal_theme_from_osc_response() { + let mut app = test_app(); + + app.route_client_input(b"\x1b]11;#123456\x07".to_vec()); + + assert_eq!( + app.state.host_terminal_theme.background, + Some(crate::terminal_theme::RgbColor { + r: 0x12, + g: 0x34, + b: 0x56, + }) + ); + } + + #[test] + fn parse_raw_input_bytes_with_ranges_tracks_offsets() { + // Verify that the range-aware parser correctly tracks byte offsets + // for events within a multi-event input buffer. + let input = b"\x1b[Aa".to_vec(); // Up arrow + 'a' + let events = crate::raw_input::parse_raw_input_bytes_with_ranges(&input); + + assert_eq!(events.len(), 2, "should parse Up arrow and 'a'"); + // Up arrow: \x1b[A = 3 bytes starting at offset 0 + assert_eq!(events[0].start, 0); + assert_eq!(events[0].len, 3); + // 'a': 1 byte starting at offset 3 + assert_eq!(events[1].start, 3); + assert_eq!(events[1].len, 1); + + // Verify the raw bytes for each event are correct. + assert_eq!( + &input[events[0].start..events[0].start + events[0].len], + b"\x1b[A" + ); + assert_eq!( + &input[events[1].start..events[1].start + events[1].len], + b"a" + ); + } } diff --git a/src/app/runtime.rs b/src/app/runtime.rs new file mode 100644 index 00000000..d82f6440 --- /dev/null +++ b/src/app/runtime.rs @@ -0,0 +1,261 @@ +use std::time::Instant; + +use crossterm::terminal; + +use super::{ + auto_updates_enabled, repeat_key_identity, App, Mode, ANIMATION_INTERVAL, + AUTO_UPDATE_CHECK_INTERVAL, GIT_REMOTE_STATUS_REFRESH_INTERVAL, MIN_RENDER_INTERVAL, + RESIZE_POLL_INTERVAL, +}; +use crate::workspace::Workspace; + +impl App { + pub(crate) fn drain_api_requests(&mut self) -> bool { + let mut changed = false; + while let Ok(msg) = self.api_rx.try_recv() { + changed |= self.handle_api_request_message(msg); + } + changed + } + + pub(super) fn handle_api_request_message( + &mut self, + msg: crate::api::ApiRequestMessage, + ) -> bool { + let changed = crate::api::request_changes_ui(&msg.request); + let response = self.handle_api_request(msg.request); + let _ = msg.respond_to.send(response); + changed + } + + pub(super) async fn handle_raw_input_batch( + &mut self, + first: crate::raw_input::RawInputEvent, + ) -> bool { + let mut changed = self.handle_raw_input_event(first).await; + + while let Some(rx) = self.input_rx.as_mut() { + match rx.try_recv() { + Ok(event) => changed |= self.handle_raw_input_event(event).await, + Err(tokio::sync::mpsc::error::TryRecvError::Empty) => break, + Err(tokio::sync::mpsc::error::TryRecvError::Disconnected) => { + self.input_rx = None; + break; + } + } + } + + changed + } + + pub(super) async fn handle_raw_input_event( + &mut self, + event: crate::raw_input::RawInputEvent, + ) -> bool { + match event { + crate::raw_input::RawInputEvent::Key(key) => { + let key_id = repeat_key_identity(&key); + match key.kind { + crossterm::event::KeyEventKind::Press => { + if self.state.mode == Mode::Terminal { + self.suppressed_repeat_keys.remove(&key_id); + } else { + self.suppressed_repeat_keys.insert(key_id); + } + self.handle_key(key).await; + true + } + crossterm::event::KeyEventKind::Repeat => { + if self.state.mode == Mode::Terminal + && !self.suppressed_repeat_keys.contains(&key_id) + { + self.handle_key(key).await; + true + } else { + false + } + } + crossterm::event::KeyEventKind::Release => { + self.suppressed_repeat_keys.remove(&key_id); + false + } + } + } + crate::raw_input::RawInputEvent::Paste(text) => { + self.handle_paste(text).await; + true + } + crate::raw_input::RawInputEvent::Mouse(mouse) => { + self.handle_mouse(mouse); + true + } + crate::raw_input::RawInputEvent::HostDefaultColor { kind, color } => { + self.update_host_terminal_theme(kind, color) + } + crate::raw_input::RawInputEvent::Unsupported => false, + } + } + + fn handle_resize_poll(&mut self) -> bool { + let Ok(size) = terminal::size() else { + return false; + }; + if self.last_terminal_size != Some(size) { + self.last_terminal_size = Some(size); + return true; + } + false + } + + pub(crate) fn handle_scheduled_tasks(&mut self, now: Instant) -> bool { + let mut changed = false; + + self.sync_animation_timer(now); + + if now >= self.next_resize_poll { + changed |= self.handle_resize_poll(); + self.next_resize_poll = now + RESIZE_POLL_INTERVAL; + } + + if self + .config_diagnostic_deadline + .is_some_and(|deadline| now >= deadline) + { + self.config_diagnostic_deadline = None; + self.state.config_diagnostic = None; + changed = true; + } + + if self.toast_deadline.is_some_and(|deadline| now >= deadline) { + self.toast_deadline = None; + self.state.toast = None; + changed = true; + } + + if self + .next_animation_tick + .is_some_and(|deadline| now >= deadline) + { + self.state.spinner_tick = self.state.spinner_tick.wrapping_add(1); + self.next_animation_tick = Some(now + ANIMATION_INTERVAL); + changed = true; + } + + if self + .git_refresh_deadline() + .is_some_and(|deadline| now >= deadline) + { + for ws in &mut self.state.workspaces { + ws.refresh_git_ahead_behind(); + } + self.last_git_remote_status_refresh = now; + changed = true; + } + + if self + .next_auto_update_check + .is_some_and(|deadline| now >= deadline) + { + self.run_auto_update_check(); + } + + if self + .session_save_deadline + .is_some_and(|deadline| now >= deadline) + { + self.save_session_now(); + } + + self.sync_animation_timer(now); + changed + } + + pub(crate) fn sync_animation_timer(&mut self, now: Instant) { + if self.agent_panel_has_animation() { + self.next_animation_tick + .get_or_insert(now + ANIMATION_INTERVAL); + } else { + self.next_animation_tick = None; + } + } + + fn agent_panel_has_animation(&self) -> bool { + match self.state.agent_panel_scope { + crate::app::state::AgentPanelScope::CurrentWorkspace => self + .state + .active + .and_then(|idx| self.state.workspaces.get(idx)) + .is_some_and(Workspace::has_working_pane), + crate::app::state::AgentPanelScope::AllWorkspaces => self + .state + .workspaces + .iter() + .any(Workspace::has_working_pane), + } + } + + pub(crate) fn can_render_now(&self, now: Instant) -> bool { + match self.last_render_at { + Some(last_render_at) => now.duration_since(last_render_at) >= MIN_RENDER_INTERVAL, + None => true, + } + } + + pub(crate) fn run_auto_update_check(&mut self) { + if !auto_updates_enabled(self.no_session) { + self.next_auto_update_check = None; + return; + } + + self.next_auto_update_check = self + .state + .update_available + .is_none() + .then_some(Instant::now() + AUTO_UPDATE_CHECK_INTERVAL); + + if self.state.update_available.is_some() { + return; + } + + let update_tx = self.event_tx.clone(); + std::thread::spawn(move || crate::update::auto_update(update_tx)); + } + + pub(crate) fn git_refresh_deadline(&self) -> Option<Instant> { + (!self.state.workspaces.is_empty()) + .then_some(self.last_git_remote_status_refresh + GIT_REMOTE_STATUS_REFRESH_INTERVAL) + } + + pub(crate) fn next_loop_deadline(&self, now: Instant, needs_render: bool) -> Option<Instant> { + let render_deadline = if needs_render { + self.last_render_at + .map(|last_render_at| last_render_at + MIN_RENDER_INTERVAL) + .filter(|deadline| *deadline > now) + } else { + None + }; + + [ + Some(self.next_resize_poll), + self.config_diagnostic_deadline, + self.toast_deadline, + self.next_animation_tick, + self.git_refresh_deadline(), + self.next_auto_update_check, + self.session_save_deadline, + render_deadline, + ] + .into_iter() + .flatten() + .min() + } + + pub(crate) fn drain_internal_events(&mut self) -> bool { + let mut had_event = false; + while let Ok(ev) = self.event_rx.try_recv() { + had_event = true; + self.handle_internal_event(ev); + } + had_event + } +} diff --git a/src/app/runtime_commands.rs b/src/app/runtime_commands.rs deleted file mode 100644 index ad9b85bc..00000000 --- a/src/app/runtime_commands.rs +++ /dev/null @@ -1,177 +0,0 @@ -//! Runtime command launching and overlay pane lifecycle helpers for [`App`]. - -use std::process::{Command, Stdio}; - -use ratatui::layout::Direction; - -use super::{App, Mode}; - -#[derive(Debug, Clone, Copy)] -pub(super) struct OverlayPaneState { - ws_idx: usize, - tab_idx: usize, - previous_focus: crate::layout::PaneId, - previous_zoomed: bool, -} - -impl App { - pub(super) fn launch_custom_command(&mut self, binding: crate::config::CustomCommandKeybind) { - let previous_toast = self.state.toast.clone(); - let result = match binding.action { - crate::config::CustomCommandAction::Shell => self.spawn_custom_command(&binding), - crate::config::CustomCommandAction::Pane => self.spawn_pane_command(&binding.command), - }; - match result { - Ok(()) => { - if self.state.active.is_some() { - self.state.mode = Mode::Terminal; - } - } - Err(err) => { - self.state.toast = Some(crate::app::state::ToastNotification { - kind: crate::app::state::ToastKind::NeedsAttention, - title: "custom command failed".to_string(), - context: err.to_string(), - }); - self.sync_toast_deadline(previous_toast); - } - } - } - - fn custom_command_env(&self) -> (Vec<(String, String)>, Option<std::path::PathBuf>) { - let mut env = vec![( - crate::api::SOCKET_PATH_ENV_VAR.to_string(), - crate::api::socket_path().display().to_string(), - )]; - if let Ok(current_exe) = std::env::current_exe() { - env.push(( - "HERDR_BIN_PATH".to_string(), - current_exe.display().to_string(), - )); - } - - let mut cwd = None; - if let Some(ws_idx) = self.state.active { - env.push(( - "HERDR_ACTIVE_WORKSPACE_ID".to_string(), - self.public_workspace_id(ws_idx), - )); - if let Some(workspace) = self.state.workspaces.get(ws_idx) { - let tab_idx = workspace.active_tab_index(); - if let Some(tab_id) = self.public_tab_id(ws_idx, tab_idx) { - env.push(("HERDR_ACTIVE_TAB_ID".to_string(), tab_id)); - } - if let Some(pane_id) = workspace.focused_pane_id() { - if let Some(public_pane_id) = self.public_pane_id(ws_idx, pane_id) { - env.push(("HERDR_ACTIVE_PANE_ID".to_string(), public_pane_id)); - } - if let Some(pane_cwd) = workspace - .active_tab() - .and_then(|tab| tab.cwd_for_pane(pane_id)) - { - env.push(( - "HERDR_ACTIVE_PANE_CWD".to_string(), - pane_cwd.display().to_string(), - )); - if pane_cwd.is_dir() { - cwd = Some(pane_cwd); - } - } - } - } - } - (env, cwd) - } - - fn spawn_custom_command( - &self, - binding: &crate::config::CustomCommandKeybind, - ) -> std::io::Result<()> { - let mut command = Command::new("/bin/sh"); - command - .arg("-lc") - .arg(&binding.command) - .stdin(Stdio::null()) - .stdout(Stdio::null()) - .stderr(Stdio::null()); - let (env, cwd) = self.custom_command_env(); - command.envs(env); - if let Some(cwd) = cwd { - command.current_dir(cwd); - } - command.spawn()?; - Ok(()) - } - - fn spawn_pane_command(&mut self, command: &str) -> std::io::Result<()> { - let Some(ws_idx) = self.state.active else { - return Err(std::io::Error::other("no active workspace")); - }; - let (rows, cols) = self.state.estimate_pane_size(); - let new_rows = rows.max(4); - let new_cols = cols.max(10); - let (env, _) = self.custom_command_env(); - - let ws = self - .state - .workspaces - .get_mut(ws_idx) - .ok_or_else(|| std::io::Error::other("active workspace disappeared"))?; - let tab_idx = ws.active_tab_index(); - let previous_focus = ws - .focused_pane_id() - .ok_or_else(|| std::io::Error::other("no focused pane"))?; - let previous_zoomed = ws.active_tab().map(|tab| tab.zoomed).unwrap_or(false); - let cwd = ws - .active_tab() - .and_then(|tab| tab.cwd_for_pane(previous_focus)); - let new_pane_id = ws.split_focused_command( - Direction::Horizontal, - new_rows, - new_cols, - cwd, - command, - &env, - self.state.pane_scrollback_limit_bytes, - self.state.host_terminal_theme, - )?; - ws.active_tab_mut() - .expect("workspace must have an active tab") - .layout - .focus_pane(new_pane_id); - ws.active_tab_mut() - .expect("workspace must have an active tab") - .zoomed = true; - self.overlay_panes.insert( - new_pane_id, - OverlayPaneState { - ws_idx, - tab_idx, - previous_focus, - previous_zoomed, - }, - ); - self.state.mode = Mode::Terminal; - Ok(()) - } - - pub(super) fn restore_overlay_after_exit(&mut self, overlay: OverlayPaneState) { - let Some(ws) = self.state.workspaces.get_mut(overlay.ws_idx) else { - return; - }; - if overlay.tab_idx >= ws.tabs.len() { - return; - } - - ws.active_tab = overlay.tab_idx; - let tab = &mut ws.tabs[overlay.tab_idx]; - if tab.panes.contains_key(&overlay.previous_focus) { - tab.layout.focus_pane(overlay.previous_focus); - } - tab.zoomed = overlay.previous_zoomed; - - if self.state.active == Some(overlay.ws_idx) { - self.state.mode = Mode::Terminal; - } - } -} diff --git a/src/app/session.rs b/src/app/session.rs new file mode 100644 index 00000000..c075fd4c --- /dev/null +++ b/src/app/session.rs @@ -0,0 +1,41 @@ +use std::time::Instant; + +use super::{App, SESSION_SAVE_DEBOUNCE}; + +impl App { + pub(super) fn schedule_session_save(&mut self) { + if !self.no_session { + self.session_save_deadline = Some(Instant::now() + SESSION_SAVE_DEBOUNCE); + } + } + + pub(crate) fn sync_session_save_schedule(&mut self) { + if self.state.session_dirty { + self.state.session_dirty = false; + self.schedule_session_save(); + } + } + + pub(crate) fn save_session_now(&mut self) { + if self.no_session { + self.session_save_deadline = None; + return; + } + + if self.state.workspaces.is_empty() { + crate::persist::clear(); + } else { + let snap = crate::persist::capture( + &self.state.workspaces, + self.state.active, + self.state.selected, + self.state.agent_panel_scope, + self.state.sidebar_width, + self.state.sidebar_section_split, + ); + crate::persist::save(&snap); + } + + self.session_save_deadline = None; + } +} diff --git a/src/app/state.rs b/src/app/state.rs index b1e69098..67f89606 100644 --- a/src/app/state.rs +++ b/src/app/state.rs @@ -586,9 +586,17 @@ pub struct AppState { pub selected: usize, pub mode: Mode, pub should_quit: bool, + /// In persistence mode, client quit actions detach instead of stopping the server. + pub quit_detaches: bool, + /// Set when the current client should detach from the persistent session. + /// The server's event loop checks this and handles client detach. + pub detach_requested: bool, pub request_new_workspace: bool, pub request_new_tab: bool, pub request_reload_keybinds: bool, + /// Set when UI interaction requested a clipboard write that must be + /// handled by the outer App/event loop instead of directly from AppState. + pub request_clipboard_write: Option<Vec<u8>>, pub creating_new_tab: bool, pub requested_new_tab_name: Option<String>, pub request_complete_onboarding: bool, @@ -657,6 +665,10 @@ impl AppState { self.sound.enabled } + pub fn is_prefix(&self, key: &crossterm::event::KeyEvent) -> bool { + key_matches(key, self.prefix_code, self.prefix_mods) + } + pub fn estimate_pane_size(&self) -> (u16, u16) { if let Some(info) = self.view.pane_infos.first() { (info.rect.height, info.rect.width) @@ -666,7 +678,6 @@ impl AppState { } } -#[cfg(test)] pub fn key_matches( key: &crossterm::event::KeyEvent, expected_code: KeyCode, @@ -700,9 +711,12 @@ impl AppState { selected: 0, mode: Mode::Navigate, should_quit: false, + quit_detaches: false, + detach_requested: false, request_new_workspace: false, request_new_tab: false, request_reload_keybinds: false, + request_clipboard_write: None, creating_new_tab: false, requested_new_tab_name: None, request_complete_onboarding: false, @@ -759,8 +773,10 @@ impl AppState { new_workspace_label: "n".into(), rename_workspace: (KeyCode::Char('n'), KeyModifiers::SHIFT), rename_workspace_label: "shift+n".into(), - close_workspace: (KeyCode::Char('d'), KeyModifiers::empty()), - close_workspace_label: "d".into(), + close_workspace: (KeyCode::Char('d'), KeyModifiers::SHIFT), + close_workspace_label: "shift+d".into(), + detach: None, + detach_label: None, previous_workspace: None, previous_workspace_label: None, next_workspace: None, diff --git a/src/app/theme_sync.rs b/src/app/theme_sync.rs new file mode 100644 index 00000000..df47f6a3 --- /dev/null +++ b/src/app/theme_sync.rs @@ -0,0 +1,51 @@ +use std::sync::atomic::Ordering; + +use super::App; + +impl App { + pub(super) fn query_host_terminal_theme(&self) { + use std::io::Write; + + let _ = std::io::stdout() + .write_all(crate::terminal_theme::HOST_COLOR_QUERY_SEQUENCE.as_bytes()); + let _ = std::io::stdout().flush(); + } + + pub(super) fn update_host_terminal_theme( + &mut self, + kind: crate::terminal_theme::DefaultColorKind, + color: crate::terminal_theme::RgbColor, + ) -> bool { + let next_theme = self.state.host_terminal_theme.with_color(kind, color); + self.set_host_terminal_theme(next_theme) + } + + pub(crate) fn set_host_terminal_theme( + &mut self, + theme: crate::terminal_theme::TerminalTheme, + ) -> bool { + if theme.is_empty() || theme == self.state.host_terminal_theme { + return false; + } + self.state.host_terminal_theme = theme; + self.apply_host_terminal_theme_to_panes(); + true + } + + fn apply_host_terminal_theme_to_panes(&self) { + if self.state.host_terminal_theme.is_empty() { + return; + } + + for workspace in &self.state.workspaces { + for tab in &workspace.tabs { + for runtime in tab.runtimes.values() { + runtime.apply_host_terminal_theme(self.state.host_terminal_theme); + } + } + } + + self.render_dirty.store(true, Ordering::Release); + self.render_notify.notify_one(); + } +} @@ -6,7 +6,8 @@ use serde::Serialize; use crate::api; use crate::api::schema::{ - AgentStatus, EmptyParams, Method, OutputMatch, PaneListParams, PaneReadParams, + AgentStatus, EmptyParams, IntegrationInstallParams, IntegrationTarget, + IntegrationUninstallParams, Method, OutputMatch, PaneListParams, PaneReadParams, PaneSendInputParams, PaneSendKeysParams, PaneSendTextParams, PaneSplitParams, PaneTarget, PaneWaitForOutputParams, ReadSource, Request, SplitDirection, Subscription, TabCreateParams, TabListParams, TabRenameParams, TabTarget, WorkspaceCreateParams, WorkspaceRenameParams, @@ -24,6 +25,12 @@ pub fn maybe_run(args: &[String]) -> std::io::Result<CommandOutcome> { }; let exit_code = match command { + "server" => { + let Some(exit_code) = run_server_command(&args[2..])? else { + return Ok(CommandOutcome::NotCli); + }; + exit_code + } "workspace" => run_workspace_command(&args[2..])?, "tab" => run_tab_command(&args[2..])?, "pane" => run_pane_command(&args[2..])?, @@ -35,6 +42,24 @@ pub fn maybe_run(args: &[String]) -> std::io::Result<CommandOutcome> { Ok(CommandOutcome::Handled(exit_code)) } +fn run_server_command(args: &[String]) -> std::io::Result<Option<i32>> { + let Some(subcommand) = args.first().map(|arg| arg.as_str()) else { + return Ok(None); + }; + + match subcommand { + "stop" => server_stop(&args[1..]).map(Some), + "help" | "--help" | "-h" => { + print_server_help(); + Ok(Some(0)) + } + _ => { + print_server_help(); + Ok(Some(2)) + } + } +} + fn run_workspace_command(args: &[String]) -> std::io::Result<i32> { let Some(subcommand) = args.first().map(|arg| arg.as_str()) else { print_workspace_help(); @@ -129,6 +154,15 @@ fn run_integration_command(args: &[String]) -> std::io::Result<i32> { } } +fn server_stop(args: &[String]) -> std::io::Result<i32> { + if !args.is_empty() { + eprintln!("usage: herdr server stop"); + return Ok(2); + } + + send_ok_request(Method::ServerStop(EmptyParams::default())) +} + fn workspace_list(args: &[String]) -> std::io::Result<i32> { if !args.is_empty() { eprintln!("usage: herdr workspace list"); @@ -625,153 +659,85 @@ fn pane_run(args: &[String]) -> std::io::Result<i32> { } fn integration_install(args: &[String]) -> std::io::Result<i32> { - let Some(target) = args.first().map(|arg| arg.as_str()) else { - eprintln!("usage: herdr integration install <pi|claude|codex|opencode>"); + let Some(target) = parse_integration_target(args, "install")? else { return Ok(2); }; - if args.len() != 1 { - eprintln!("usage: herdr integration install <pi|claude|codex|opencode>"); - return Ok(2); + + let response = send_request(&Request { + id: "cli:integration:install".into(), + method: Method::IntegrationInstall(IntegrationInstallParams { target }), + })?; + + if let Some(error) = response.get("error") { + eprintln!("{}", serde_json::to_string(error).unwrap()); + return Ok(1); } - match target { - "pi" => { - let path = crate::integration::install_pi()?; - println!("installed pi integration to {}", path.display()); - Ok(0) - } - "claude" => { - let installed = crate::integration::install_claude()?; - println!( - "installed claude integration hook to {}", - installed.hook_path.display() - ); - println!( - "ensured claude settings at {}", - installed.settings_path.display() - ); - Ok(0) - } - "codex" => { - let installed = crate::integration::install_codex()?; - println!( - "installed codex integration hook to {}", - installed.hook_path.display() - ); - println!("ensured codex hooks at {}", installed.hooks_path.display()); - println!( - "ensured codex config at {}", - installed.config_path.display() - ); - Ok(0) - } - "opencode" => { - let installed = crate::integration::install_opencode()?; - println!( - "installed opencode integration plugin to {}", - installed.plugin_path.display() - ); - Ok(0) - } - _ => { - eprintln!("unknown integration target: {target}"); - eprintln!("currently supported: pi, claude, codex, opencode"); - Ok(2) - } + let Some(messages) = response["result"]["details"]["messages"].as_array() else { + eprintln!("invalid integration install response"); + return Ok(1); + }; + + for message in messages.iter().filter_map(|entry| entry.as_str()) { + println!("{message}"); } + + Ok(0) } fn integration_uninstall(args: &[String]) -> std::io::Result<i32> { - let Some(target) = args.first().map(|arg| arg.as_str()) else { - eprintln!("usage: herdr integration uninstall <pi|claude|codex|opencode>"); + let Some(target) = parse_integration_target(args, "uninstall")? else { return Ok(2); }; + + let response = send_request(&Request { + id: "cli:integration:uninstall".into(), + method: Method::IntegrationUninstall(IntegrationUninstallParams { target }), + })?; + + if let Some(error) = response.get("error") { + eprintln!("{}", serde_json::to_string(error).unwrap()); + return Ok(1); + } + + let Some(messages) = response["result"]["details"]["messages"].as_array() else { + eprintln!("invalid integration uninstall response"); + return Ok(1); + }; + + for message in messages.iter().filter_map(|entry| entry.as_str()) { + println!("{message}"); + } + + Ok(0) +} + +fn parse_integration_target( + args: &[String], + action: &str, +) -> std::io::Result<Option<IntegrationTarget>> { + let Some(target) = args.first().map(|arg| arg.as_str()) else { + eprintln!("usage: herdr integration {action} <pi|claude|codex|opencode>"); + return Ok(None); + }; if args.len() != 1 { - eprintln!("usage: herdr integration uninstall <pi|claude|codex|opencode>"); - return Ok(2); + eprintln!("usage: herdr integration {action} <pi|claude|codex|opencode>"); + return Ok(None); } - match target { - "pi" => { - let result = crate::integration::uninstall_pi()?; - if result.removed_extension { - println!( - "removed pi integration extension at {}", - result.extension_path.display() - ); - } else { - println!( - "no pi integration extension found at {}", - result.extension_path.display() - ); - } - Ok(0) - } - "claude" => { - let result = crate::integration::uninstall_claude()?; - if result.removed_hook_file { - println!("removed claude hook at {}", result.hook_path.display()); - } else { - println!("no claude hook found at {}", result.hook_path.display()); - } - if result.updated_settings { - println!( - "removed herdr claude hook entries from {}", - result.settings_path.display() - ); - } else { - println!( - "no herdr claude hook entries found in {}", - result.settings_path.display() - ); - } - Ok(0) - } - "codex" => { - let result = crate::integration::uninstall_codex()?; - if result.removed_hook_file { - println!("removed codex hook at {}", result.hook_path.display()); - } else { - println!("no codex hook found at {}", result.hook_path.display()); - } - if result.updated_hooks { - println!( - "removed herdr codex hook entries from {}", - result.hooks_path.display() - ); - } else { - println!( - "no herdr codex hook entries found in {}", - result.hooks_path.display() - ); - } - println!( - "left codex config unchanged at {}", - result.config_path.display() - ); - Ok(0) - } - "opencode" => { - let result = crate::integration::uninstall_opencode()?; - if result.removed_plugin { - println!( - "removed opencode integration plugin at {}", - result.plugin_path.display() - ); - } else { - println!( - "no opencode integration plugin found at {}", - result.plugin_path.display() - ); - } - Ok(0) - } + let parsed = match target { + "pi" => IntegrationTarget::Pi, + "claude" => IntegrationTarget::Claude, + "codex" => IntegrationTarget::Codex, + "opencode" => IntegrationTarget::Opencode, _ => { eprintln!("unknown integration target: {target}"); eprintln!("currently supported: pi, claude, codex, opencode"); - Ok(2) + return Ok(None); } - } + }; + + Ok(Some(parsed)) } fn wait_output(args: &[String]) -> std::io::Result<i32> { @@ -1071,6 +1037,12 @@ fn parse_u64_flag(flag: &str, value: &str) -> std::io::Result<u64> { .map_err(|_| std::io::Error::other(format!("invalid value for {flag}: {value}"))) } +fn print_server_help() { + eprintln!("herdr server commands:"); + eprintln!(" herdr server run as headless server"); + eprintln!(" herdr server stop stop the running server via the api socket"); +} + fn print_workspace_help() { eprintln!("herdr workspace commands:"); eprintln!(" herdr workspace list"); diff --git a/src/client/blit.rs b/src/client/blit.rs new file mode 100644 index 00000000..aa443a7b --- /dev/null +++ b/src/client/blit.rs @@ -0,0 +1,793 @@ +//! Frame blitting — renders FrameData to the terminal using diff-based updates. +//! +//! The blitting strategy: +//! 1. On the first frame, write the entire buffer (full redraw). +//! 2. On subsequent frames, diff against the last frame and only write +//! the cells that changed. +//! 3. Before writing any cells, hide the cursor to avoid stray cursor +//! artifacts on terminals that render the hardware cursor at intermediate +//! `CUP` positions during the frame stream. +//! 4. After writing all changed cells, restore the final cursor visibility +//! and position from `frame.cursor`. +//! +//! Escape sequences used: +//! - `CSI H` (CUP) — move cursor to (row, col) +//! - `CSI m` (SGR) — set graphic rendition (colors, bold, etc.) +//! - `ESC ] 52 ; c ; <base64> BEL` — OSC 52 clipboard write +//! +//! The goal is minimal output: skip unchanged cells, batch adjacent changes, +//! and minimize cursor movement. + +use std::cmp; +use std::io::{self, Write}; + +use unicode_width::UnicodeWidthStr; + +use crate::server::protocol::{CellData, FrameData}; + +// --------------------------------------------------------------------------- +// Color → escape sequence +// --------------------------------------------------------------------------- + +/// Converts a packed u32 color to an SGR escape sequence fragment. +/// +/// Returns a string like `38;5;123` (indexed) or `38;2;255;128;64` (RGB) +/// or `39` (reset), without the leading `\x1b[` or trailing `m`. +fn color_to_sgr_fg(val: u32) -> String { + match val >> 24 { + 0x00 => match val & 0xFF { + 0x00 => "39".to_owned(), // Reset + 0x01 => "30".to_owned(), // Black + 0x02 => "31".to_owned(), // Red + 0x03 => "32".to_owned(), // Green + 0x04 => "33".to_owned(), // Yellow + 0x05 => "34".to_owned(), // Blue + 0x06 => "35".to_owned(), // Magenta + 0x07 => "36".to_owned(), // Cyan + 0x08 => "37".to_owned(), // Gray (light gray) + 0x09 => "90".to_owned(), // DarkGray + 0x0A => "91".to_owned(), // LightRed + 0x0B => "92".to_owned(), // LightGreen + 0x0C => "93".to_owned(), // LightYellow + 0x0D => "94".to_owned(), // LightBlue + 0x0E => "95".to_owned(), // LightMagenta + 0x0F => "96".to_owned(), // LightCyan + 0x10 => "97".to_owned(), // White + _ => "39".to_owned(), // Unknown → Reset + }, + 0x01 => format!("38;5;{}", val & 0xFF), // Indexed + 0x02 => { + // RGB + let r = (val >> 16) & 0xFF; + let g = (val >> 8) & 0xFF; + let b = val & 0xFF; + format!("38;2;{r};{g};{b}") + } + _ => "39".to_owned(), // Unknown → Reset + } +} + +/// Converts a packed u32 color to a background SGR fragment. +fn color_to_sgr_bg(val: u32) -> String { + match val >> 24 { + 0x00 => match val & 0xFF { + 0x00 => "49".to_owned(), // Reset + 0x01 => "40".to_owned(), // Black + 0x02 => "41".to_owned(), // Red + 0x03 => "42".to_owned(), // Green + 0x04 => "43".to_owned(), // Yellow + 0x05 => "44".to_owned(), // Blue + 0x06 => "45".to_owned(), // Magenta + 0x07 => "46".to_owned(), // Cyan + 0x08 => "47".to_owned(), // Gray (light gray) + 0x09 => "100".to_owned(), // DarkGray + 0x0A => "101".to_owned(), // LightRed + 0x0B => "102".to_owned(), // LightGreen + 0x0C => "103".to_owned(), // LightYellow + 0x0D => "104".to_owned(), // LightBlue + 0x0E => "105".to_owned(), // LightMagenta + 0x0F => "106".to_owned(), // LightCyan + 0x10 => "107".to_owned(), // White + _ => "49".to_owned(), // Unknown → Reset + }, + 0x01 => format!("48;5;{}", val & 0xFF), // Indexed + 0x02 => { + let r = (val >> 16) & 0xFF; + let g = (val >> 8) & 0xFF; + let b = val & 0xFF; + format!("48;2;{r};{g};{b}") + } + _ => "49".to_owned(), + } +} + +// --------------------------------------------------------------------------- +// Modifier → SGR +// --------------------------------------------------------------------------- + +/// Converts a u16 modifier bitmask to SGR escape sequence fragments. +/// +/// Returns a Vec of SGR parameter strings (e.g., "1" for bold, "3" for italic). +fn modifier_to_sgr_parts(val: u16) -> Vec<&'static str> { + let mut parts = Vec::new(); + + // ratatui::Modifier bits (from bitflags) + const BOLD: u16 = 1 << 0; // 0x01 + const DIM: u16 = 1 << 1; // 0x02 + const ITALIC: u16 = 1 << 2; // 0x04 + const UNDERLINED: u16 = 1 << 3; // 0x08 + const SLOW_BLINK: u16 = 1 << 4; // 0x10 + const RAPID_BLINK: u16 = 1 << 5; // 0x20 + const REVERSED: u16 = 1 << 6; // 0x40 + const HIDDEN: u16 = 1 << 7; // 0x80 + const CROSSED_OUT: u16 = 1 << 8; // 0x100 + + if val & BOLD != 0 { + parts.push("1"); + } + if val & DIM != 0 { + parts.push("2"); + } + if val & ITALIC != 0 { + parts.push("3"); + } + if val & UNDERLINED != 0 { + parts.push("4"); + } + if val & SLOW_BLINK != 0 { + parts.push("5"); + } + if val & RAPID_BLINK != 0 { + parts.push("6"); + } + if val & REVERSED != 0 { + parts.push("7"); + } + if val & HIDDEN != 0 { + parts.push("8"); + } + if val & CROSSED_OUT != 0 { + parts.push("9"); + } + + parts +} + +/// Builds a complete SGR escape sequence for a cell's style. +fn build_sgr(fg: u32, bg: u32, modifier: u16) -> String { + let mut parts = vec!["0".to_owned()]; + parts.extend( + modifier_to_sgr_parts(modifier) + .into_iter() + .map(str::to_owned), + ); + parts.push(color_to_sgr_fg(fg)); + parts.push(color_to_sgr_bg(bg)); + format!("\x1b[{}m", parts.join(";")) +} + +// --------------------------------------------------------------------------- +// Cell comparison +// --------------------------------------------------------------------------- + +/// Checks if two cells are visually identical. +#[cfg(test)] +fn cells_equal(a: &CellData, b: &CellData) -> bool { + a.symbol == b.symbol && a.fg == b.fg && a.bg == b.bg && a.modifier == b.modifier + // Skip flag is only for ratatui internal use, not visual. +} + +// --------------------------------------------------------------------------- +// Blitting +// --------------------------------------------------------------------------- + +/// Blits a frame to the terminal, diffing against the previous frame. +/// +/// On the first frame (no previous), does a full redraw. +/// On subsequent frames, only writes cells that changed. +/// After writing cells, positions the cursor. +pub fn blit_frame(frame: &FrameData, prev: Option<&FrameData>) { + let mut stdout = io::stdout(); + blit_frame_to(&mut stdout, frame, prev); +} + +/// Blits a frame to a writer, diffing against the previous frame. +fn blit_frame_to(mut writer: impl Write, frame: &FrameData, prev: Option<&FrameData>) { + // On first frame or size change, do a full redraw. + let full_redraw = + prev.is_none() || prev.is_some_and(|p| p.width != frame.width || p.height != frame.height); + + // Hide cursor before any cell writes to avoid stray cursor artifacts + // on terminals that render the hardware cursor at intermediate CUP positions. + let _ = writer.write_all(b"\x1b[?25l"); + + if full_redraw { + // Clear the screen and write all cells. + let _ = writer.write_all(b"\x1b[2J\x1b[H"); + write_all_cells(&mut writer, frame); + } else { + // Diff-based update: only write changed cells. + let prev = prev.unwrap(); + write_changed_cells(&mut writer, frame, prev); + } + + // Position the cursor and set visibility. + if let Some(cursor) = &frame.cursor { + if cursor.visible { + // Show cursor (restore visibility if it was hidden on a previous frame). + let _ = writer.write_all(b"\x1b[?25h"); + // CUP: move cursor to (row+1, col+1) — 1-based. + let _ = write!(writer, "\x1b[{};{}H", cursor.y + 1, cursor.x + 1); + } else { + // Hide cursor. + let _ = writer.write_all(b"\x1b[?25l"); + } + } else { + // No cursor info — hide cursor. + let _ = writer.write_all(b"\x1b[?25l"); + } +} + +/// Writes all cells in the frame (full redraw). +fn cell_width(cell: &CellData) -> usize { + cell.symbol.width() +} + +fn write_all_cells(writer: &mut impl Write, frame: &FrameData) { + for row in 0..frame.height { + let mut to_skip = 0usize; + for col in 0..frame.width { + if to_skip > 0 { + to_skip -= 1; + continue; + } + + let idx = (row as usize) * (frame.width as usize) + (col as usize); + let cell = &frame.cells[idx]; + + if cell.skip { + continue; + } + + // Move cursor to position (1-based). + let _ = write!(writer, "\x1b[{};{}H", row + 1, col + 1); + + // Set style. + let sgr = build_sgr(cell.fg, cell.bg, cell.modifier); + let _ = writer.write_all(sgr.as_bytes()); + + // Write the symbol. + let _ = writer.write_all(cell.symbol.as_bytes()); + to_skip = cell_width(cell).saturating_sub(1); + } + } + + // Reset style at the end. + let _ = writer.write_all(b"\x1b[0m"); +} + +fn write_cell(writer: &mut impl Write, row: u16, col: u16, cell: &CellData, last_sgr: &mut String) { + if cell.skip { + return; + } + + let _ = write!(writer, "\x1b[{};{}H", row + 1, col + 1); + + let sgr = build_sgr(cell.fg, cell.bg, cell.modifier); + if sgr != *last_sgr { + let _ = writer.write_all(sgr.as_bytes()); + *last_sgr = sgr; + } + + let _ = writer.write_all(cell.symbol.as_bytes()); +} + +/// Writes only the cells that changed between the previous and current frame. +fn write_changed_cells(writer: &mut impl Write, frame: &FrameData, prev: &FrameData) { + let mut last_sgr = String::new(); // Track last SGR to avoid redundant style changes. + + for row in 0..frame.height { + let mut invalidated = 0usize; + let mut to_skip = 0usize; + + for col in 0..frame.width { + let idx = (row as usize) * (frame.width as usize) + (col as usize); + let cell = &frame.cells[idx]; + let prev_cell = &prev.cells[idx]; + + if !cell.skip && (cell != prev_cell || invalidated > 0) && to_skip == 0 { + write_cell(writer, row, col, cell, &mut last_sgr); + } + + to_skip = cell_width(cell).saturating_sub(1); + let affected_width = cmp::max(cell_width(cell), cell_width(prev_cell)); + invalidated = cmp::max(affected_width, invalidated).saturating_sub(1); + } + } + + // Reset style if we wrote anything. + if !last_sgr.is_empty() { + let _ = writer.write_all(b"\x1b[0m"); + } +} + +// --------------------------------------------------------------------------- +// Tests +// --------------------------------------------------------------------------- + +#[cfg(test)] +mod tests { + use super::*; + use crate::server::protocol::{CellData, CursorState}; + + const WIDE_GRAPHEME: &str = "💡"; + + fn make_cell(symbol: &str, fg: u32, bg: u32, modifier: u16) -> CellData { + CellData { + symbol: symbol.to_owned(), + fg, + bg, + modifier, + skip: false, + } + } + + fn make_frame(width: u16, height: u16, cells: Vec<CellData>) -> FrameData { + FrameData { + cells, + width, + height, + cursor: None, + } + } + + #[test] + fn color_to_sgr_fg_named_colors() { + assert_eq!(color_to_sgr_fg(0x00_00_00_00), "39"); // Reset + assert_eq!(color_to_sgr_fg(0x00_00_00_01), "30"); // Black + assert_eq!(color_to_sgr_fg(0x00_00_00_02), "31"); // Red + assert_eq!(color_to_sgr_fg(0x00_00_00_10), "97"); // White + } + + #[test] + fn color_to_sgr_fg_indexed() { + assert_eq!(color_to_sgr_fg(0x01_00_00_AB), "38;5;171"); + } + + #[test] + fn color_to_sgr_fg_rgb() { + assert_eq!(color_to_sgr_fg(0x02_FF_80_40), "38;2;255;128;64"); + } + + #[test] + fn color_to_sgr_bg_named_colors() { + assert_eq!(color_to_sgr_bg(0x00_00_00_00), "49"); // Reset + assert_eq!(color_to_sgr_bg(0x00_00_00_01), "40"); // Black + assert_eq!(color_to_sgr_bg(0x00_00_00_10), "107"); // White + } + + #[test] + fn color_to_sgr_bg_rgb() { + assert_eq!(color_to_sgr_bg(0x02_FF_80_40), "48;2;255;128;64"); + } + + #[test] + fn modifier_to_sgr_parts_bold() { + let parts = modifier_to_sgr_parts(1); // BOLD + assert!(parts.contains(&"1")); + } + + #[test] + fn modifier_to_sgr_parts_italic() { + let parts = modifier_to_sgr_parts(4); // ITALIC + assert!(parts.contains(&"3")); + } + + #[test] + fn modifier_to_sgr_parts_empty() { + let parts = modifier_to_sgr_parts(0); + assert!(parts.is_empty()); + } + + #[test] + fn build_sgr_produces_valid_sequence() { + let sgr = build_sgr(0x00_00_00_02, 0x00_00_00_01, 1); // fg=Red, bg=Black, bold + assert!(sgr.starts_with("\x1b[")); + assert!(sgr.ends_with("m")); + assert!(sgr.contains("0")); // reset existing style first + assert!(sgr.contains("1")); // bold + assert!(sgr.contains("31")); // fg red + assert!(sgr.contains("40")); // bg black + } + + #[test] + fn build_sgr_resets_previous_modifiers_when_cell_is_plain() { + assert_eq!(build_sgr(0x00_00_00_00, 0x00_00_00_00, 0), "\x1b[0;39;49m"); + } + + #[test] + fn cells_equal_identical() { + let a = make_cell("A", 2, 1, 0); + let b = make_cell("A", 2, 1, 0); + assert!(cells_equal(&a, &b)); + } + + #[test] + fn cells_equal_different_symbol() { + let a = make_cell("A", 2, 1, 0); + let b = make_cell("B", 2, 1, 0); + assert!(!cells_equal(&a, &b)); + } + + #[test] + fn cells_equal_different_color() { + let a = make_cell("A", 2, 1, 0); + let b = make_cell("A", 3, 1, 0); + assert!(!cells_equal(&a, &b)); + } + + #[test] + fn blit_frame_hides_cursor_before_full_redraw_writes() { + let frame = make_frame( + 2, + 2, + vec![ + make_cell("H", 0, 0, 0), + make_cell("i", 0, 0, 0), + make_cell("!", 0, 0, 0), + make_cell(" ", 0, 0, 0), + ], + ); + + let mut output = Vec::new(); + blit_frame_to(&mut output, &frame, None); + + let output_str = String::from_utf8(output).unwrap(); + assert!( + output_str.starts_with("\x1b[?25l"), + "should hide cursor before any cell writes during full redraw" + ); + } + + #[test] + fn blit_frame_hides_cursor_before_diff_writes() { + let prev = make_frame( + 2, + 2, + vec![ + make_cell("H", 0, 0, 0), + make_cell("i", 0, 0, 0), + make_cell("!", 0, 0, 0), + make_cell(" ", 0, 0, 0), + ], + ); + + let curr = make_frame( + 2, + 2, + vec![ + make_cell("X", 0, 0, 0), // Changed + make_cell("i", 0, 0, 0), // Same + make_cell("!", 0, 0, 0), // Same + make_cell(" ", 0, 0, 0), // Same + ], + ); + + let mut output = Vec::new(); + blit_frame_to(&mut output, &curr, Some(&prev)); + + let output_str = String::from_utf8(output).unwrap(); + assert!( + output_str.starts_with("\x1b[?25l"), + "should hide cursor before any cell writes during diff" + ); + } + + #[test] + fn blit_frame_first_frame_produces_output() { + let frame = make_frame( + 2, + 2, + vec![ + make_cell("H", 0, 0, 0), + make_cell("i", 0, 0, 0), + make_cell("!", 0, 0, 0), + make_cell(" ", 0, 0, 0), + ], + ); + + let mut output = Vec::new(); + blit_frame_to(&mut output, &frame, None); + + let output_str = String::from_utf8(output).unwrap(); + // Full redraw should start with clear screen. + assert!( + output_str.contains("\x1b[2J"), + "full redraw should clear screen" + ); + assert!( + output_str.contains('H') || output_str.contains('i'), + "should contain cell content" + ); + } + + #[test] + fn blit_frame_diff_only_writes_changed_cells() { + let prev = make_frame( + 2, + 2, + vec![ + make_cell("H", 0, 0, 0), + make_cell("i", 0, 0, 0), + make_cell("!", 0, 0, 0), + make_cell(" ", 0, 0, 0), + ], + ); + + // Only the first cell changed. + let curr = make_frame( + 2, + 2, + vec![ + make_cell("X", 0, 0, 0), // Changed + make_cell("i", 0, 0, 0), // Same + make_cell("!", 0, 0, 0), // Same + make_cell(" ", 0, 0, 0), // Same + ], + ); + + let mut output = Vec::new(); + blit_frame_to(&mut output, &curr, Some(&prev)); + + let output_str = String::from_utf8(output).unwrap(); + // Diff should NOT clear the screen. + assert!( + !output_str.contains("\x1b[2J"), + "diff should not clear screen" + ); + // Should contain the changed cell content. + assert!(output_str.contains('X'), "should contain changed cell 'X'"); + } + + #[test] + fn blit_frame_size_change_triggers_full_redraw() { + let prev = make_frame(2, 2, vec![make_cell("A", 0, 0, 0); 4]); + + let curr = make_frame(3, 2, vec![make_cell("B", 0, 0, 0); 6]); + + let mut output = Vec::new(); + blit_frame_to(&mut output, &curr, Some(&prev)); + + let output_str = String::from_utf8(output).unwrap(); + assert!( + output_str.contains("\x1b[2J"), + "size change should trigger full redraw" + ); + } + + #[test] + fn blit_frame_positions_cursor() { + let frame = FrameData { + cells: vec![make_cell("A", 0, 0, 0)], + width: 1, + height: 1, + cursor: Some(CursorState { + x: 0, + y: 0, + visible: true, + }), + }; + + let mut output = Vec::new(); + blit_frame_to(&mut output, &frame, None); + + let output_str = String::from_utf8(output).unwrap(); + assert!( + output_str.contains("\x1b[1;1H"), + "should position cursor at (1,1)" + ); + } + + #[test] + fn blit_frame_hides_cursor_when_invisible() { + let frame = FrameData { + cells: vec![make_cell("A", 0, 0, 0)], + width: 1, + height: 1, + cursor: Some(CursorState { + x: 0, + y: 0, + visible: false, + }), + }; + + let mut output = Vec::new(); + blit_frame_to(&mut output, &frame, None); + + let output_str = String::from_utf8(output).unwrap(); + assert!( + output_str.contains("\x1b[?25l"), + "should hide cursor when invisible" + ); + } + + #[test] + fn blit_frame_no_cursor_hides_cursor() { + let frame = FrameData { + cells: vec![make_cell("A", 0, 0, 0)], + width: 1, + height: 1, + cursor: None, + }; + + let mut output = Vec::new(); + blit_frame_to(&mut output, &frame, None); + + let output_str = String::from_utf8(output).unwrap(); + assert!( + output_str.contains("\x1b[?25l"), + "should hide cursor when no cursor state" + ); + } + + #[test] + fn blit_frame_restores_cursor_visibility() { + // First frame: cursor hidden. + let prev = FrameData { + cells: vec![make_cell("A", 0, 0, 0)], + width: 1, + height: 1, + cursor: Some(CursorState { + x: 0, + y: 0, + visible: false, + }), + }; + + let mut output = Vec::new(); + blit_frame_to(&mut output, &prev, None); + assert!( + String::from_utf8(output).unwrap().contains("\x1b[?25l"), + "first frame should hide cursor" + ); + + // Second frame: cursor visible — should restore visibility. + let curr = FrameData { + cells: vec![make_cell("B", 0, 0, 0)], + width: 1, + height: 1, + cursor: Some(CursorState { + x: 0, + y: 0, + visible: true, + }), + }; + + let mut output = Vec::new(); + blit_frame_to(&mut output, &curr, Some(&prev)); + let output_str = String::from_utf8(output).unwrap(); + assert!( + output_str.contains("\x1b[?25h"), + "second frame should restore cursor visibility with ?25h" + ); + assert!( + output_str.contains("\x1b[1;1H"), + "should position cursor after showing it" + ); + } + + #[test] + fn blit_frame_hides_previous_visible_cursor_when_next_frame_has_none() { + let prev = FrameData { + cells: vec![make_cell("A", 0, 0, 0)], + width: 1, + height: 1, + cursor: Some(CursorState { + x: 0, + y: 0, + visible: true, + }), + }; + let curr = FrameData { + cells: vec![make_cell("B", 0, 0, 0)], + width: 1, + height: 1, + cursor: None, + }; + + let mut output = Vec::new(); + blit_frame_to(&mut output, &curr, Some(&prev)); + + assert!( + String::from_utf8(output).unwrap().contains("\x1b[?25l"), + "diff redraw should hide a previously visible cursor when the next frame has none" + ); + } + + #[test] + fn full_redraw_skips_trailing_cells_covered_by_wide_graphemes() { + let frame = FrameData { + cells: vec![ + make_cell(WIDE_GRAPHEME, 0, 0, 0), + make_cell(" ", 0, 0, 0), + make_cell("Z", 0, 0, 0), + ], + width: 3, + height: 1, + cursor: None, + }; + + let mut output = Vec::new(); + blit_frame_to(&mut output, &frame, None); + let output_str = String::from_utf8(output).unwrap(); + + assert!(output_str.contains("\x1b[1;1H")); + assert!(!output_str.contains("\x1b[1;2H")); + assert!(output_str.contains("\x1b[1;3H")); + } + + #[test] + fn diff_redraw_reveals_cells_hidden_by_previous_wide_graphemes() { + let prev = FrameData { + cells: vec![ + make_cell(WIDE_GRAPHEME, 0, 0, 0), + make_cell(" ", 0, 0, 0), + make_cell("Z", 0, 0, 0), + ], + width: 3, + height: 1, + cursor: None, + }; + let curr = FrameData { + cells: vec![ + make_cell("A", 0, 0, 0), + make_cell(" ", 0, 0, 0), + make_cell("Z", 0, 0, 0), + ], + width: 3, + height: 1, + cursor: None, + }; + + let mut output = Vec::new(); + blit_frame_to(&mut output, &curr, Some(&prev)); + let output_str = String::from_utf8(output).unwrap(); + + assert!(output_str.contains("\x1b[1;1H")); + assert!( + output_str.contains("\x1b[1;2H"), + "cells hidden by a previous wide grapheme must be redrawn when they become visible" + ); + } + + #[test] + fn diff_redraw_skips_new_trailing_cells_covered_by_wide_graphemes() { + let prev = FrameData { + cells: vec![ + make_cell("A", 0, 0, 0), + make_cell("B", 0, 0, 0), + make_cell("Z", 0, 0, 0), + ], + width: 3, + height: 1, + cursor: None, + }; + let curr = FrameData { + cells: vec![ + make_cell(WIDE_GRAPHEME, 0, 0, 0), + make_cell(" ", 0, 0, 0), + make_cell("Z", 0, 0, 0), + ], + width: 3, + height: 1, + cursor: None, + }; + + let mut output = Vec::new(); + blit_frame_to(&mut output, &curr, Some(&prev)); + let output_str = String::from_utf8(output).unwrap(); + + assert!(output_str.contains("\x1b[1;1H")); + assert!(!output_str.contains("\x1b[1;2H")); + } +} diff --git a/src/client/input.rs b/src/client/input.rs new file mode 100644 index 00000000..31e1c1e4 --- /dev/null +++ b/src/client/input.rs @@ -0,0 +1,135 @@ +//! Stdin input reading for the thin client. +//! +//! Reads raw bytes from stdin and forwards them to the main event loop. +//! Unlike the monolithic herdr, the thin client does NOT parse the input +//! into key/mouse/paste events — it just sends the raw bytes to the server +//! as `ClientMessage::Input`. The server handles parsing. +//! +//! This is simpler and more reliable because: +//! - The server has the same input parsing code +//! - We avoid duplicating parsing logic in the client +//! - Raw forwarding preserves all escape sequences faithfully + +use std::io::{self, Read}; +use std::sync::atomic::{AtomicBool, Ordering}; +use std::sync::Arc; + +#[cfg(unix)] +use std::os::fd::AsRawFd; +use tokio::sync::mpsc; + +use super::ClientLoopEvent; + +// --------------------------------------------------------------------------- +// Stdin reader thread +// --------------------------------------------------------------------------- + +/// Reads raw bytes from stdin and sends them to the main event loop. +/// +/// This runs on a dedicated thread because stdin reading is blocking. +/// The main loop receives the raw bytes and forwards them as +/// `ClientMessage::Input` to the server. +pub fn stdin_reader_loop(event_tx: mpsc::Sender<ClientLoopEvent>, should_quit: &Arc<AtomicBool>) { + let stdin = io::stdin(); + let mut reader = stdin.lock(); + let mut scratch = [0u8; 4096]; + let mut buffer = Vec::new(); + + while !should_quit.load(Ordering::Acquire) { + match reader.read(&mut scratch) { + Ok(0) => break, + Ok(n) => { + buffer.extend_from_slice(&scratch[..n]); + + for data in crate::raw_input::drain_complete_input_bytes(&mut buffer) { + if event_tx + .blocking_send(ClientLoopEvent::StdinInput(data)) + .is_err() + { + return; + } + } + + if !buffer.is_empty() && stdin_read_ready(&reader, 10) == Some(false) { + if let Some(data) = crate::raw_input::flush_incomplete_input_bytes(&mut buffer) + { + if event_tx + .blocking_send(ClientLoopEvent::StdinInput(data)) + .is_err() + { + return; + } + } + } + } + Err(err) => { + if err.kind() == io::ErrorKind::Interrupted { + continue; + } + break; + } + } + } +} + +#[cfg(unix)] +fn stdin_read_ready<R: AsRawFd>(reader: &R, timeout_ms: i32) -> Option<bool> { + poll_read_ready(reader.as_raw_fd(), timeout_ms) +} + +#[cfg(not(unix))] +fn stdin_read_ready<R>(_reader: &R, _timeout_ms: i32) -> Option<bool> { + None +} + +#[cfg(unix)] +fn poll_read_ready(fd: i32, timeout_ms: i32) -> Option<bool> { + #[repr(C)] + struct PollFd { + fd: i32, + events: i16, + revents: i16, + } + + unsafe extern "C" { + fn poll(fds: *mut PollFd, nfds: usize, timeout: i32) -> i32; + } + + const POLLIN: i16 = 0x0001; + + let mut pfd = PollFd { + fd, + events: POLLIN, + revents: 0, + }; + + let result = unsafe { poll(&mut pfd as *mut PollFd, 1, timeout_ms) }; + if result < 0 { + None + } else { + Some(result > 0) + } +} + +// --------------------------------------------------------------------------- +// Tests +// --------------------------------------------------------------------------- + +#[cfg(test)] +mod tests { + // The stdin reader thread is hard to unit test since it reads from actual stdin. + // Integration tests will verify the full client→server input flow. + // Here we test the event type construction. + + use super::*; + + #[test] + fn stdin_input_event_carries_raw_bytes() { + let data = vec![0x1b, b'[', b'A']; // Up arrow escape sequence + let event = ClientLoopEvent::StdinInput(data.clone()); + match event { + ClientLoopEvent::StdinInput(d) => assert_eq!(d, data), + _ => panic!("expected StdinInput event"), + } + } +} diff --git a/src/client/mod.rs b/src/client/mod.rs new file mode 100644 index 00000000..2476a069 --- /dev/null +++ b/src/client/mod.rs @@ -0,0 +1,741 @@ +//! Thin client mode — connects to the server's client socket. +//! +//! The client: +//! - Connects to `herdr-client.sock`, sends Hello with terminal size and protocol version +//! - Sets up the real terminal (raw mode, mouse capture, keyboard enhancements) +//! - Receives Frame messages and blits them to the terminal (diff against last frame) +//! - Reads stdin events (keystrokes, mouse, paste) and sends them as ClientMessage::Input +//! - Detects terminal resize and sends ClientMessage::Resize +//! - Restores terminal on exit (normal or error) +//! - Handles ServerShutdown gracefully (clean exit, informative message to stderr) +//! - Handles server unreachable (clear error screen, not blank/hang) +//! - Forwards OSC 52 clipboard writes from server to its own stdout +//! - Displays sound/toast notifications forwarded from server + +mod blit; +mod input; + +use std::io::{self, Write as _}; +use std::os::unix::net::UnixStream; +use std::sync::atomic::{AtomicBool, Ordering}; +use std::sync::Arc; +use std::time::Duration; + +use crossterm::event::{ + DisableBracketedPaste, DisableMouseCapture, EnableBracketedPaste, EnableMouseCapture, + KeyboardEnhancementFlags, PopKeyboardEnhancementFlags, PushKeyboardEnhancementFlags, +}; +use crossterm::execute; +use tracing::{debug, info, warn}; + +use crate::server::headless::client_socket_path; +use crate::server::protocol::{ + self, ClientMessage, FrameData, NotifyKind, ServerMessage, MAX_FRAME_SIZE, PROTOCOL_VERSION, +}; + +// --------------------------------------------------------------------------- +// Client state +// --------------------------------------------------------------------------- + +/// State tracking for the thin client. +struct ClientState { + /// The last frame we rendered, used for diff-based blitting. + last_frame: Option<FrameData>, + /// The terminal size we reported to the server in our last Hello/Resize. + reported_size: (u16, u16), +} + +// --------------------------------------------------------------------------- +// Error types +// --------------------------------------------------------------------------- + +/// Errors that can occur during client operation. +#[derive(Debug)] +pub enum ClientError { + /// Could not connect to the server's client socket. + ConnectionFailed(io::Error), + /// Server rejected our handshake. + HandshakeRejected { version: u32, error: String }, + /// Server shut down. + ServerShutdown { reason: Option<String> }, + /// Lost connection to the server. + ConnectionLost(io::Error), + /// Protocol error (framing, deserialization). + Protocol(protocol::FramingError), +} + +impl std::fmt::Display for ClientError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + ClientError::ConnectionFailed(err) => { + write!(f, "failed to connect to server: {err}")?; + let path = client_socket_path(); + write!( + f, + "\nIs herdr server running? Start it with `herdr server`." + )?; + write!(f, "\nSocket path: {}", path.display()) + } + ClientError::HandshakeRejected { version, error } => { + write!(f, "server rejected handshake (version {version}): {error}") + } + ClientError::ServerShutdown { reason } => { + match reason.as_deref() { + Some("detached") => { + write!(f, "detached from server")?; + write!(f, "\nRun `herdr` to reattach")?; + } + _ => { + write!(f, "server shut down")?; + if let Some(reason) = reason { + write!(f, ": {reason}")?; + } + } + } + Ok(()) + } + ClientError::ConnectionLost(err) => { + write!(f, "lost connection to server: {err}") + } + ClientError::Protocol(err) => { + write!(f, "protocol error: {err}") + } + } + } +} + +impl std::error::Error for ClientError { + fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { + match self { + ClientError::ConnectionFailed(err) => Some(err), + ClientError::ConnectionLost(err) => Some(err), + ClientError::Protocol(err) => Some(err), + _ => None, + } + } +} + +impl From<protocol::FramingError> for ClientError { + fn from(err: protocol::FramingError) -> Self { + ClientError::Protocol(err) + } +} + +// --------------------------------------------------------------------------- +// Terminal setup / restore +// --------------------------------------------------------------------------- + +/// Sets up the terminal for client mode (raw mode, mouse, keyboard enhancements). +/// +/// Returns a guard that restores the terminal when dropped. +fn setup_terminal() -> io::Result<TerminalGuard> { + ratatui::init(); + execute!( + io::stdout(), + EnableMouseCapture, + EnableBracketedPaste, + PushKeyboardEnhancementFlags( + KeyboardEnhancementFlags::DISAMBIGUATE_ESCAPE_CODES + | KeyboardEnhancementFlags::REPORT_EVENT_TYPES + | KeyboardEnhancementFlags::REPORT_ALTERNATE_KEYS + ) + )?; + + // tmux doesn't understand kitty keyboard protocol push. + // Enable modifyOtherKeys mode 2 for tmux. + let in_tmux = std::env::var("TMUX").is_ok(); + if in_tmux { + io::stdout().write_all(b"\x1b[>4;2m")?; + io::stdout().flush()?; + } + + Ok(TerminalGuard { in_tmux }) +} + +/// Guard that restores the terminal when dropped. +struct TerminalGuard { + in_tmux: bool, +} + +impl Drop for TerminalGuard { + fn drop(&mut self) { + // Reset modifyOtherKeys if we enabled it. + if self.in_tmux { + let _ = io::stdout().write_all(b"\x1b[>4;0m"); + let _ = io::stdout().flush(); + } + + let _ = execute!( + io::stdout(), + PopKeyboardEnhancementFlags, + DisableBracketedPaste, + DisableMouseCapture + ); + ratatui::restore(); + } +} + +// --------------------------------------------------------------------------- +// Handshake +// --------------------------------------------------------------------------- + +/// Performs the client→server handshake. +/// +/// Sends Hello with the terminal size and protocol version, reads the Welcome +/// response. Returns Ok(()) on success, or an error if the server rejects us. +fn do_handshake(stream: &mut UnixStream, cols: u16, rows: u16) -> Result<(), ClientError> { + // Send Hello. + let hello = ClientMessage::Hello { + version: PROTOCOL_VERSION, + cols, + rows, + }; + protocol::write_message(stream, &hello).map_err(|e| { + ClientError::ConnectionFailed(io::Error::new(io::ErrorKind::Other, e.to_string())) + })?; + + // Read Welcome. + stream + .set_read_timeout(Some(Duration::from_secs(5))) + .map_err(ClientError::ConnectionFailed)?; + let welcome: ServerMessage = protocol::read_message(stream, MAX_FRAME_SIZE)?; + stream + .set_read_timeout(None) + .map_err(ClientError::ConnectionFailed)?; + + match welcome { + ServerMessage::Welcome { version, error } => { + if let Some(error) = error { + return Err(ClientError::HandshakeRejected { version, error }); + } + info!(version, "handshake succeeded"); + Ok(()) + } + _ => Err(ClientError::Protocol(protocol::FramingError::Io( + io::Error::new(io::ErrorKind::InvalidData, "expected Welcome message"), + ))), + } +} + +// --------------------------------------------------------------------------- +// Client event loop +// --------------------------------------------------------------------------- + +/// Internal events for the client event loop. +enum ClientLoopEvent { + /// Raw input bytes from stdin. + StdinInput(Vec<u8>), + /// Terminal resize detected. + Resize(u16, u16), + /// Server message received. + ServerMessage(ServerMessage), + /// Server reader thread exited (connection lost). + ServerDisconnected, + /// Timer tick. + Timer, +} + +/// Runs the thin client: connects to the server, performs the handshake, +/// and enters the main event loop. +/// +/// This is the entry point called from `main.rs` when running in client mode. +pub fn run_client() -> io::Result<()> { + init_logging(); + + let loaded_config = crate::config::Config::load(); + let sound_config = loaded_config.config.ui.sound; + + let socket_path = client_socket_path(); + info!(path = %socket_path.display(), "connecting to server"); + + // Try to connect to the server. + let mut stream = match UnixStream::connect(&socket_path) { + Ok(s) => s, + Err(err) => { + // Server unreachable — show clear error and exit. + let client_err = ClientError::ConnectionFailed(err); + eprintln!("herdr: {client_err}"); + std::process::exit(1); + } + }; + + // Get the terminal size before handshake (before raw mode). + let (cols, rows) = crossterm::terminal::size().unwrap_or((80, 24)); + + // Perform handshake while the stream is still in blocking mode. + if let Err(err) = do_handshake(&mut stream, cols, rows) { + eprintln!("herdr: {err}"); + std::process::exit(1); + } + + // Now set up the terminal (raw mode, mouse, keyboard enhancements). + // This must happen AFTER the handshake succeeds, so we don't leave + // the terminal in raw mode if the server rejects us. + let _guard = setup_terminal().map_err(|err| { + eprintln!("herdr: failed to set up terminal: {err}"); + err + })?; + + // Install a panic hook to restore the terminal on panic (same as monolithic). + let in_tmux = std::env::var("TMUX").is_ok(); + let original_hook = std::panic::take_hook(); + std::panic::set_hook(Box::new(move |info| { + if in_tmux { + let _ = io::stdout().write_all(b"\x1b[>4;0m"); + } + let _ = execute!( + io::stdout(), + PopKeyboardEnhancementFlags, + DisableBracketedPaste, + DisableMouseCapture + ); + ratatui::restore(); + original_hook(info); + })); + + // Create the tokio runtime. + let rt = tokio::runtime::Builder::new_current_thread() + .enable_all() + .build() + .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?; + + let should_quit = Arc::new(AtomicBool::new(false)); + + // Install Ctrl+C handler. + let quit_flag = should_quit.clone(); + let _ = ctrlc::set_handler(move || { + quit_flag.store(true, Ordering::Release); + }); + + let result = + rt.block_on(async { run_client_loop(stream, cols, rows, should_quit, sound_config).await }); + + // Restore the terminal before printing any final status message. + drop(_guard); + + if let Err(err) = result { + eprintln!("herdr: {err}"); + rt.shutdown_timeout(Duration::from_millis(100)); + info!("herdr client exiting"); + + if matches!( + err, + ClientError::ServerShutdown { + reason: Some(reason) + } if reason == "detached" + ) { + return Ok(()); + } + + std::process::exit(1); + } + + rt.shutdown_timeout(Duration::from_millis(100)); + info!("herdr client exiting"); + Ok(()) +} + +/// The main client event loop. +/// +/// Uses a threaded architecture: +/// - stdin reader thread → sends raw input bytes to main loop +/// - resize poller thread → sends resize events to main loop +/// - server reader thread → reads ServerMessages and sends to main loop +/// - main loop: coordinates input, output, and server communication +async fn run_client_loop( + stream: UnixStream, + cols: u16, + rows: u16, + should_quit: Arc<AtomicBool>, + sound_config: crate::config::SoundConfig, +) -> Result<(), ClientError> { + let mut state = ClientState { + last_frame: None, + reported_size: (cols, rows), + }; + + // Channel for events from the stdin, resize, and server reader threads. + let (event_tx, mut event_rx) = tokio::sync::mpsc::channel::<ClientLoopEvent>(256); + + // Spawn the stdin reader thread. + let stdin_quit = should_quit.clone(); + let stdin_tx = event_tx.clone(); + std::thread::spawn(move || { + input::stdin_reader_loop(stdin_tx, &stdin_quit); + }); + + query_host_terminal_theme(); + + // Spawn the resize poller thread. + let resize_quit = should_quit.clone(); + let resize_tx = event_tx.clone(); + std::thread::spawn(move || { + resize_poll_loop(resize_tx, cols, rows, &resize_quit); + }); + + // Spawn the server reader thread (blocking reads from the socket). + // Clone the stream's file descriptor so we can read from a blocking stream. + let server_read_quit = should_quit.clone(); + let server_read_tx = event_tx.clone(); + let read_stream = stream.try_clone().map_err(ClientError::ConnectionFailed)?; + std::thread::spawn(move || { + server_reader_thread(read_stream, server_read_tx, &server_read_quit); + }); + + // Use the original stream for writing (blocking is fine since we write + // from the async loop). + let mut write_stream = stream; + write_stream + .set_nonblocking(false) + .map_err(ClientError::ConnectionFailed)?; + + // Main event loop. + while !should_quit.load(Ordering::Acquire) { + let event = tokio::select! { + ev = event_rx.recv() => ev.unwrap_or(ClientLoopEvent::Timer), + _ = tokio::time::sleep(Duration::from_millis(100)) => ClientLoopEvent::Timer, + }; + + match event { + ClientLoopEvent::StdinInput(data) => { + let msg = ClientMessage::Input { data }; + if let Err(e) = write_to_server(&mut write_stream, &msg) { + return Err(ClientError::ConnectionLost(e)); + } + } + ClientLoopEvent::Resize(new_cols, new_rows) => { + state.reported_size = (new_cols, new_rows); + let msg = ClientMessage::Resize { + cols: new_cols, + rows: new_rows, + }; + if let Err(e) = write_to_server(&mut write_stream, &msg) { + return Err(ClientError::ConnectionLost(e)); + } + } + ClientLoopEvent::ServerMessage(msg) => match msg { + ServerMessage::Frame(frame_data) => { + blit::blit_frame(&frame_data, state.last_frame.as_ref()); + state.last_frame = Some(frame_data); + let _ = io::stdout().flush(); + } + ServerMessage::ServerShutdown { reason } => { + return Err(ClientError::ServerShutdown { reason }); + } + ServerMessage::Notify { kind, message } => { + handle_notify(kind, &message, &sound_config); + } + ServerMessage::Clipboard { data } => { + forward_clipboard(&data); + let _ = io::stdout().flush(); + } + ServerMessage::Welcome { .. } => { + debug!("received unexpected Welcome in main loop"); + } + }, + ClientLoopEvent::ServerDisconnected => { + return Err(ClientError::ConnectionLost(io::Error::new( + io::ErrorKind::UnexpectedEof, + "server closed connection", + ))); + } + ClientLoopEvent::Timer => { + // Check if we should quit. + } + } + } + + // Clean exit (Ctrl+C). Send Detach before closing. + let detach = ClientMessage::Detach; + let _ = write_to_server(&mut write_stream, &detach); + let _ = io::stdout().flush(); + + Ok(()) +} + +// --------------------------------------------------------------------------- +// Server reader thread +// --------------------------------------------------------------------------- + +/// Blocking thread that reads ServerMessages from the server and sends them +/// to the main event loop. +fn server_reader_thread( + mut stream: UnixStream, + event_tx: tokio::sync::mpsc::Sender<ClientLoopEvent>, + should_quit: &Arc<AtomicBool>, +) { + // Ensure the read stream is in blocking mode to avoid WouldBlock errors + // from read_exact inside read_message. The stream should already be + // blocking after handshake, but we enforce it here as a safety measure. + if stream.set_nonblocking(false).is_err() { + // If we can't set blocking mode, the stream is likely broken. + let _ = event_tx.blocking_send(ClientLoopEvent::ServerDisconnected); + return; + } + + loop { + if should_quit.load(Ordering::Acquire) { + break; + } + + match protocol::read_message(&mut stream, MAX_FRAME_SIZE) { + Ok(msg) => { + if event_tx + .blocking_send(ClientLoopEvent::ServerMessage(msg)) + .is_err() + { + break; // Main loop gone. + } + } + Err(protocol::FramingError::UnexpectedEof) => { + // Server closed connection. + let _ = event_tx.blocking_send(ClientLoopEvent::ServerDisconnected); + break; + } + Err(protocol::FramingError::Io(err)) if err.kind() == io::ErrorKind::WouldBlock => { + // Should not happen with blocking mode, but handle gracefully + // in case the stream was set nonblocking by another clone. + std::thread::sleep(Duration::from_millis(1)); + continue; + } + Err(err) => { + warn!(err = %err, "server read error"); + let _ = event_tx.blocking_send(ClientLoopEvent::ServerDisconnected); + break; + } + } + } +} + +// --------------------------------------------------------------------------- +// Write helper +// --------------------------------------------------------------------------- + +/// Writes a message to the server stream (blocking). +fn write_to_server(stream: &mut UnixStream, msg: &ClientMessage) -> io::Result<()> { + protocol::write_message(stream, msg) + .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string())) +} + +// --------------------------------------------------------------------------- +// Notifications +// --------------------------------------------------------------------------- + +fn handle_notify(kind: NotifyKind, message: &str, sound_config: &crate::config::SoundConfig) { + match kind { + NotifyKind::Sound => { + let Some(sound) = sound_from_notify_message(message) else { + warn!( + message = message, + "received unknown sound notification from server" + ); + return; + }; + if sound_config.enabled { + crate::sound::play(sound, sound_config); + } + } + NotifyKind::Toast => { + debug!(message = message, "received toast notification from server"); + } + } +} + +fn sound_from_notify_message(message: &str) -> Option<crate::sound::Sound> { + match message { + "agent done" => Some(crate::sound::Sound::Done), + "agent attention" => Some(crate::sound::Sound::Request), + _ => None, + } +} + +// --------------------------------------------------------------------------- +// Clipboard forwarding +// --------------------------------------------------------------------------- + +/// Decode a clipboard payload forwarded by the server. +fn decode_clipboard_payload(data: &str) -> Option<Vec<u8>> { + use base64::Engine; + base64::engine::general_purpose::STANDARD.decode(data).ok() +} + +/// Forwards a clipboard write from the server to the local client clipboard. +fn forward_clipboard(data: &str) { + let Some(bytes) = decode_clipboard_payload(data) else { + warn!("received invalid clipboard payload from server"); + return; + }; + + crate::selection::write_osc52_bytes(&bytes); +} + +// --------------------------------------------------------------------------- +// Resize polling +// --------------------------------------------------------------------------- + +/// Polls the terminal size and sends resize events when it changes. +fn resize_poll_loop( + resize_tx: tokio::sync::mpsc::Sender<ClientLoopEvent>, + initial_cols: u16, + initial_rows: u16, + should_quit: &Arc<AtomicBool>, +) { + let mut last_size = (initial_cols, initial_rows); + while !should_quit.load(Ordering::Acquire) { + std::thread::sleep(Duration::from_millis(100)); + let new_size = crossterm::terminal::size().unwrap_or(last_size); + if new_size != last_size { + last_size = new_size; + if resize_tx + .blocking_send(ClientLoopEvent::Resize(new_size.0, new_size.1)) + .is_err() + { + break; // Main loop gone. + } + } + } +} + +// --------------------------------------------------------------------------- +// Logging +// --------------------------------------------------------------------------- + +/// Initialize logging for the client process. +fn query_host_terminal_theme() { + let _ = write_host_terminal_theme_query(io::stdout()); +} + +fn write_host_terminal_theme_query(mut writer: impl io::Write) -> io::Result<()> { + writer.write_all(crate::terminal_theme::HOST_COLOR_QUERY_SEQUENCE.as_bytes())?; + writer.flush() +} + +fn init_logging() { + crate::logging::init_file_logging("herdr-client.log"); +} + +// --------------------------------------------------------------------------- +// Tests +// --------------------------------------------------------------------------- + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn write_host_terminal_theme_query_emits_osc_queries() { + let mut output = Vec::new(); + write_host_terminal_theme_query(&mut output).unwrap(); + assert_eq!( + output, + crate::terminal_theme::HOST_COLOR_QUERY_SEQUENCE.as_bytes() + ); + } + + #[test] + fn client_error_display_connection_failed() { + let err = ClientError::ConnectionFailed(io::Error::new( + io::ErrorKind::ConnectionRefused, + "connection refused", + )); + let msg = err.to_string(); + assert!( + msg.contains("failed to connect to server"), + "should mention connection failure: {msg}" + ); + assert!( + msg.contains("herdr server"), + "should suggest starting server: {msg}" + ); + } + + #[test] + fn client_error_display_handshake_rejected() { + let err = ClientError::HandshakeRejected { + version: 1, + error: "incompatible".into(), + }; + let msg = err.to_string(); + assert!( + msg.contains("rejected handshake"), + "should mention rejection: {msg}" + ); + assert!(msg.contains("incompatible"), "should include error: {msg}"); + } + + #[test] + fn client_error_display_server_shutdown() { + let err = ClientError::ServerShutdown { + reason: Some("maintenance".into()), + }; + let msg = err.to_string(); + assert!( + msg.contains("server shut down"), + "should mention shutdown: {msg}" + ); + assert!(msg.contains("maintenance"), "should include reason: {msg}"); + } + + #[test] + fn client_error_display_server_shutdown_no_reason() { + let err = ClientError::ServerShutdown { reason: None }; + let msg = err.to_string(); + assert!( + msg.contains("server shut down"), + "should mention shutdown: {msg}" + ); + } + + #[test] + fn client_error_display_connection_lost() { + let err = + ClientError::ConnectionLost(io::Error::new(io::ErrorKind::BrokenPipe, "broken pipe")); + let msg = err.to_string(); + assert!( + msg.contains("lost connection to server"), + "should mention lost connection: {msg}" + ); + } + + #[test] + fn sound_from_notify_message_maps_done() { + assert_eq!( + sound_from_notify_message("agent done"), + Some(crate::sound::Sound::Done) + ); + } + + #[test] + fn sound_from_notify_message_maps_attention() { + assert_eq!( + sound_from_notify_message("agent attention"), + Some(crate::sound::Sound::Request) + ); + } + + #[test] + fn sound_from_notify_message_rejects_unknown_payloads() { + assert_eq!(sound_from_notify_message("toast"), None); + } + + #[test] + fn decode_clipboard_payload_decodes_base64() { + assert_eq!(decode_clipboard_payload("dGVzdA=="), Some(b"test".to_vec())); + } + + #[test] + fn decode_clipboard_payload_rejects_invalid_base64() { + assert_eq!(decode_clipboard_payload("not-base64!!!"), None); + } + + #[test] + fn forward_clipboard_uses_local_clipboard_path() { + unsafe { + std::env::set_var("SSH_CONNECTION", "1 2 3 4"); + } + forward_clipboard("dGVzdA=="); + unsafe { + std::env::remove_var("SSH_CONNECTION"); + } + } +} diff --git a/src/config.rs b/src/config.rs index 7a317204..4fa772d0 100644 --- a/src/config.rs +++ b/src/config.rs @@ -1,410 +1,31 @@ -use std::path::{Path, PathBuf}; - use crossterm::event::{KeyCode, KeyModifiers}; -use serde::Deserialize; + +mod io; +mod keybinds; +mod model; +mod sound; +mod theme; + +pub use self::{ + io::{ + config_dir, config_path, load_live_keybinds, save_onboarding_choices, upsert_section_bool, + upsert_section_value, + }, + keybinds::{ + format_key_combo, CommandKeybindConfig, CustomCommandAction, CustomCommandKeybind, + Keybinds, LiveKeybindConfig, + }, + model::{Config, ToastConfig}, + sound::{AgentSoundSetting, SoundConfig}, + theme::{parse_color, CustomThemeColors, ThemeConfig}, +}; pub const CONFIG_PATH_ENV_VAR: &str = "HERDR_CONFIG_PATH"; pub const DEFAULT_SCROLLBACK_LIMIT_BYTES: usize = 10_000_000; -use tracing::warn; - -pub fn app_dir_name() -> &'static str { - if cfg!(debug_assertions) { - "herdr-dev" - } else { - "herdr" - } -} - -pub fn config_dir() -> PathBuf { - if let Ok(dir) = std::env::var("XDG_CONFIG_HOME") { - PathBuf::from(dir).join(app_dir_name()) - } else if let Ok(home) = std::env::var("HOME") { - PathBuf::from(home).join(format!(".config/{}", app_dir_name())) - } else { - PathBuf::from(format!("/tmp/{}", app_dir_name())) - } -} - -use crate::detect::Agent; - -#[derive(Debug, Clone, Deserialize)] -#[serde(default)] -pub struct ToastConfig { - pub enabled: bool, -} - -#[derive(Debug, Default, Deserialize)] -#[serde(default)] -pub struct Config { - pub onboarding: Option<bool>, - pub theme: ThemeConfig, - pub keys: KeysConfig, - pub ui: UiConfig, - pub advanced: AdvancedConfig, -} - -/// Theme configuration: pick a built-in or override individual tokens. -/// -/// ```toml -/// [theme] -/// name = "tokyo-night" # built-in: catppuccin, tokyo-night, dracula, nord, etc. -/// -/// [theme.custom] # override individual tokens on top of the base -/// accent = "#f5c2e7" -/// red = "#ff6188" -/// ``` -#[derive(Debug, Default, Deserialize)] -#[serde(default)] -pub struct ThemeConfig { - /// Built-in theme name. Default: "catppuccin". - pub name: Option<String>, - /// Custom overrides — applied on top of the selected base theme. - pub custom: Option<CustomThemeColors>, -} - -/// Per-token color overrides. All fields optional — only set what you want to change. -#[derive(Debug, Default, Deserialize)] -#[serde(default)] -pub struct CustomThemeColors { - pub accent: Option<String>, - pub panel_bg: Option<String>, - pub surface0: Option<String>, - pub surface1: Option<String>, - pub surface_dim: Option<String>, - pub overlay0: Option<String>, - pub overlay1: Option<String>, - pub text: Option<String>, - pub subtext0: Option<String>, - pub mauve: Option<String>, - pub green: Option<String>, - pub yellow: Option<String>, - pub red: Option<String>, - pub blue: Option<String>, - pub teal: Option<String>, - pub peach: Option<String>, -} - -#[derive(Debug)] -pub struct LoadedConfig { - pub config: Config, - pub diagnostics: Vec<String>, -} - -#[derive(Debug)] -pub struct LiveKeybindConfig { - pub prefix: (KeyCode, KeyModifiers), - pub keybinds: Keybinds, -} - -#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Default)] -#[serde(rename_all = "snake_case")] -pub enum CommandKeybindType { - #[default] - Shell, - Pane, -} - -#[derive(Debug, Clone, Deserialize)] -#[serde(default)] -pub struct CommandKeybindConfig { - /// Navigate-mode key that runs a command after pressing the prefix key. - pub key: String, - /// Command executed either in the background shell or inside a pane. - pub command: String, - /// Command execution mode. Default: "shell". - #[serde(rename = "type")] - pub action_type: CommandKeybindType, -} - -impl Default for CommandKeybindConfig { - fn default() -> Self { - Self { - key: String::new(), - command: String::new(), - action_type: CommandKeybindType::Shell, - } - } -} - -#[derive(Debug, Deserialize)] -#[serde(default)] -pub struct KeysConfig { - /// Prefix key to toggle navigate mode (e.g. "ctrl+b", "f12", "esc"). - pub prefix: String, - /// Create a new workspace. Default: "n" - pub new_workspace: String, - /// Rename the selected workspace. Default: "shift+n" - pub rename_workspace: String, - /// Close the selected workspace. Default: "d" - pub close_workspace: String, - /// Select the previous workspace. Unset by default. - pub previous_workspace: String, - /// Select the next workspace. Unset by default. - pub next_workspace: String, - /// Create a new tab in the active workspace. Default: "c" - pub new_tab: String, - /// Rename the active tab. Unset by default. - pub rename_tab: String, - /// Select the previous tab. Unset by default. - pub previous_tab: String, - /// Select the next tab. Unset by default. - pub next_tab: String, - /// Close the active tab. Unset by default. - pub close_tab: String, - /// Focus the pane to the left in terminal mode. Unset by default. - pub focus_pane_left: String, - /// Focus the pane below in terminal mode. Unset by default. - pub focus_pane_down: String, - /// Focus the pane above in terminal mode. Unset by default. - pub focus_pane_up: String, - /// Focus the pane to the right in terminal mode. Unset by default. - pub focus_pane_right: String, - /// Split pane vertically (side by side). Default: "v" - pub split_vertical: String, - /// Split pane horizontally (stacked). Default: "-" - pub split_horizontal: String, - /// Close the focused pane. Default: "x" - pub close_pane: String, - /// Toggle fullscreen for the focused pane. Default: "f" - pub fullscreen: String, - /// Enter resize mode. Default: "r" - pub resize_mode: String, - /// Toggle sidebar collapse. Default: "b" - pub toggle_sidebar: String, - /// Prefix-mode custom command bindings. - pub command: Vec<CommandKeybindConfig>, -} - -#[derive(Debug, Deserialize)] -#[serde(default)] -pub struct UiConfig { - pub sidebar_width: u16, - /// Ask for confirmation before closing a workspace. Default: true. - pub confirm_close: bool, - /// Accent color for highlights, borders, and navigation UI. - /// Accepts hex (#89b4fa), named colors (cyan, blue), or RGB (rgb(137,180,250)). - pub accent: String, - /// Optional visual toast notifications for background workspace events. - pub toast: ToastConfig, - /// Play sounds when agents change state in background workspaces. - pub sound: SoundConfig, -} - -#[derive(Debug, Deserialize)] -#[serde(default)] -pub struct AdvancedConfig { - /// Allow launching herdr inside an existing herdr pane. Default: false. - pub allow_nested: bool, - /// Maximum scrollback buffer size in bytes retained per pane terminal. Default: 10000000. - #[serde(alias = "scrollback_lines")] - pub scrollback_limit_bytes: usize, -} - -#[derive(Debug, Clone, Deserialize)] -#[serde(default)] -pub struct SoundConfig { - pub enabled: bool, - /// Optional mp3 file path used for all notification sounds. - /// Relative paths are resolved from the config file's directory. - pub path: Option<PathBuf>, - /// Optional mp3 file path for "done" notifications. - /// Relative paths are resolved from the config file's directory. - pub done_path: Option<PathBuf>, - /// Optional mp3 file path for "request" notifications. - /// Relative paths are resolved from the config file's directory. - pub request_path: Option<PathBuf>, - pub agents: AgentSoundOverrides, -} - -#[derive(Debug, Clone, Deserialize)] -#[serde(default)] -pub struct AgentSoundOverrides { - pub pi: AgentSoundSetting, - pub claude: AgentSoundSetting, - pub codex: AgentSoundSetting, - pub gemini: AgentSoundSetting, - pub cursor: AgentSoundSetting, - pub cline: AgentSoundSetting, - pub open_code: AgentSoundSetting, - pub github_copilot: AgentSoundSetting, - pub kimi: AgentSoundSetting, - pub droid: AgentSoundSetting, - pub amp: AgentSoundSetting, -} - -#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Deserialize)] -#[serde(rename_all = "snake_case")] -pub enum AgentSoundSetting { - #[default] - Default, - On, - Off, -} - -impl SoundConfig { - pub fn allows(&self, agent: Option<Agent>) -> bool { - if !self.enabled { - return false; - } - - !matches!(self.agents.for_agent(agent), AgentSoundSetting::Off) - } - - pub fn path_for(&self, sound: crate::sound::Sound) -> Option<PathBuf> { - let path = match sound { - crate::sound::Sound::Done => self.done_path.as_ref().or(self.path.as_ref()), - crate::sound::Sound::Request => self.request_path.as_ref().or(self.path.as_ref()), - }?; - - Some(resolve_config_relative_path(path)) - } - - pub fn diagnostics(&self) -> Vec<String> { - let mut diagnostics = Vec::new(); - for (field, path) in [ - ("ui.sound.path", self.path.as_ref()), - ("ui.sound.done_path", self.done_path.as_ref()), - ("ui.sound.request_path", self.request_path.as_ref()), - ] { - let Some(path) = path else { - continue; - }; - - let resolved = resolve_config_relative_path(path); - if resolved - .extension() - .and_then(|ext| ext.to_str()) - .is_none_or(|ext| !ext.eq_ignore_ascii_case("mp3")) - { - diagnostics.push(format!( - "unsupported sound file format: {field} = {} resolves to {}; expected an mp3 file; using default sound", - path.display(), - resolved.display() - )); - continue; - } - - if !resolved.exists() { - diagnostics.push(format!( - "missing sound file: {field} = {} resolves to {}; using default sound", - path.display(), - resolved.display() - )); - } else if !resolved.is_file() { - diagnostics.push(format!( - "invalid sound file: {field} = {} resolves to {}; using default sound", - path.display(), - resolved.display() - )); - } - } - diagnostics - } -} - -impl AgentSoundOverrides { - pub fn for_agent(&self, agent: Option<Agent>) -> AgentSoundSetting { - match agent { - Some(Agent::Pi) => self.pi, - Some(Agent::Claude) => self.claude, - Some(Agent::Codex) => self.codex, - Some(Agent::Gemini) => self.gemini, - Some(Agent::Cursor) => self.cursor, - Some(Agent::Cline) => self.cline, - Some(Agent::OpenCode) => self.open_code, - Some(Agent::GithubCopilot) => self.github_copilot, - Some(Agent::Kimi) => self.kimi, - Some(Agent::Droid) => self.droid, - Some(Agent::Amp) => self.amp, - None => AgentSoundSetting::Default, - } - } -} - -impl Default for KeysConfig { - fn default() -> Self { - Self { - prefix: "ctrl+b".into(), - new_workspace: "n".into(), - rename_workspace: "shift+n".into(), - close_workspace: "d".into(), - previous_workspace: "".into(), - next_workspace: "".into(), - new_tab: "c".into(), - rename_tab: "".into(), - previous_tab: "".into(), - next_tab: "".into(), - close_tab: "".into(), - focus_pane_left: "".into(), - focus_pane_down: "".into(), - focus_pane_up: "".into(), - focus_pane_right: "".into(), - split_vertical: "v".into(), - split_horizontal: "-".into(), - close_pane: "x".into(), - fullscreen: "f".into(), - resize_mode: "r".into(), - toggle_sidebar: "b".into(), - command: Vec::new(), - } - } -} - -impl Default for UiConfig { - fn default() -> Self { - Self { - sidebar_width: 26, - confirm_close: true, - accent: "cyan".into(), - toast: ToastConfig::default(), - sound: SoundConfig::default(), - } - } -} - -impl Default for ToastConfig { - fn default() -> Self { - Self { enabled: false } - } -} - -impl Default for SoundConfig { - fn default() -> Self { - Self { - enabled: true, - path: None, - done_path: None, - request_path: None, - agents: AgentSoundOverrides::default(), - } - } -} - -impl Default for AdvancedConfig { - fn default() -> Self { - Self { - allow_nested: false, - scrollback_limit_bytes: DEFAULT_SCROLLBACK_LIMIT_BYTES, - } - } -} -impl Default for AgentSoundOverrides { - fn default() -> Self { - Self { - pi: AgentSoundSetting::Default, - claude: AgentSoundSetting::Default, - codex: AgentSoundSetting::Default, - gemini: AgentSoundSetting::Default, - cursor: AgentSoundSetting::Default, - cline: AgentSoundSetting::Default, - open_code: AgentSoundSetting::Default, - github_copilot: AgentSoundSetting::Default, - kimi: AgentSoundSetting::Default, - droid: AgentSoundSetting::Off, - amp: AgentSoundSetting::Default, - } - } +#[cfg(test)] +pub(crate) fn app_dir_name() -> &'static str { + io::app_dir_name() } impl Config { @@ -412,41 +33,6 @@ impl Config { self.onboarding.unwrap_or(true) } - pub fn load() -> LoadedConfig { - let path = config_path(); - if path.exists() { - match std::fs::read_to_string(&path) { - Ok(content) => match toml::from_str::<Config>(&content) { - Ok(config) => { - let diagnostics = config.collect_diagnostics(); - return LoadedConfig { - config, - diagnostics, - }; - } - Err(e) => { - warn!(err = %e, "config parse error, using defaults"); - return LoadedConfig { - config: Self::default(), - diagnostics: vec![format!("config parse error: {e}; using defaults")], - }; - } - }, - Err(e) => { - warn!(err = %e, "config read error, using defaults"); - return LoadedConfig { - config: Self::default(), - diagnostics: vec![format!("config read error: {e}; using defaults")], - }; - } - } - } - LoadedConfig { - config: Self::default(), - diagnostics: Vec::new(), - } - } - pub fn prefix_key(&self) -> (KeyCode, KeyModifiers) { self.validated_keybinds().1 } @@ -475,1503 +61,3 @@ impl Config { } } } - -fn resolve_config_relative_path(path: &Path) -> PathBuf { - if path.is_absolute() { - return path.to_path_buf(); - } - - config_path() - .parent() - .unwrap_or_else(|| Path::new(".")) - .join(path) -} - -impl Config { - fn validated_keybinds( - &self, - ) -> ( - Option<String>, - (KeyCode, KeyModifiers), - Vec<String>, - Keybinds, - ) { - #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] - enum BindingScope { - Navigate, - TerminalDirect, - } - - #[derive(Clone)] - struct RequiredBinding<'a> { - scope: BindingScope, - field: &'a str, - label: String, - default_label: &'a str, - value: (KeyCode, KeyModifiers), - default: (KeyCode, KeyModifiers), - } - - struct OptionalBinding { - scope: BindingScope, - field: &'static str, - value: Option<(KeyCode, KeyModifiers)>, - label: Option<String>, - } - - #[derive(Default)] - struct BindingRegistry { - seen: std::collections::HashMap<(BindingScope, KeyCode, KeyModifiers), String>, - } - - impl BindingRegistry { - fn register( - &mut self, - scope: BindingScope, - binding: (KeyCode, KeyModifiers), - field: &str, - ) -> Option<String> { - let binding = crate::input::normalize_app_key_binding(binding.0, binding.1, None); - self.seen - .insert((scope, binding.0, binding.1), field.to_string()) - } - - fn conflict( - &self, - scope: BindingScope, - binding: (KeyCode, KeyModifiers), - ) -> Option<&str> { - let binding = crate::input::normalize_app_key_binding(binding.0, binding.1, None); - self.seen - .get(&(scope, binding.0, binding.1)) - .map(String::as_str) - } - - fn reserve_if_unbound( - &mut self, - scope: BindingScope, - binding: (KeyCode, KeyModifiers), - field: &str, - ) { - let binding = crate::input::normalize_app_key_binding(binding.0, binding.1, None); - self.seen - .entry((scope, binding.0, binding.1)) - .or_insert_with(|| field.to_string()); - } - } - - fn required_binding<'a>( - scope: BindingScope, - field: &'a str, - configured_label: &'a str, - default_label: &'a str, - default: (KeyCode, KeyModifiers), - diagnostics: &mut Vec<String>, - ) -> RequiredBinding<'a> { - let (value, diag) = parse_key_combo_with_diagnostic(configured_label, field, default); - let label = if let Some(diag) = diag { - diagnostics.push(diag); - default_label.to_string() - } else { - configured_label.to_string() - }; - RequiredBinding { - scope, - field, - label, - default_label, - value, - default, - } - } - - fn optional_binding( - scope: BindingScope, - field: &'static str, - configured_label: &str, - diagnostics: &mut Vec<String>, - ) -> OptionalBinding { - if configured_label.trim().is_empty() { - return OptionalBinding { - scope, - field, - value: None, - label: None, - }; - } - match parse_key_combo(configured_label) { - Some(value) => OptionalBinding { - scope, - field, - value: Some(value), - label: Some(configured_label.to_string()), - }, - None => { - let diag = format!( - "invalid keybinding: {field} = {:?}; disabling binding", - configured_label - ); - warn!(message = %diag, "config diagnostic"); - diagnostics.push(diag); - OptionalBinding { - scope, - field, - value: None, - label: None, - } - } - } - } - - let mut diagnostics = Vec::new(); - let (prefix, prefix_diag) = parse_key_combo_with_diagnostic( - &self.keys.prefix, - "keys.prefix", - (KeyCode::Char('b'), KeyModifiers::CONTROL), - ); - if let Some(diag) = &prefix_diag { - warn!(message = %diag, "config diagnostic"); - } - - let mut bindings = vec![ - required_binding( - BindingScope::Navigate, - "keys.new_workspace", - &self.keys.new_workspace, - "n", - (KeyCode::Char('n'), KeyModifiers::empty()), - &mut diagnostics, - ), - required_binding( - BindingScope::Navigate, - "keys.rename_workspace", - &self.keys.rename_workspace, - "shift+n", - (KeyCode::Char('n'), KeyModifiers::SHIFT), - &mut diagnostics, - ), - required_binding( - BindingScope::Navigate, - "keys.close_workspace", - &self.keys.close_workspace, - "d", - (KeyCode::Char('d'), KeyModifiers::empty()), - &mut diagnostics, - ), - required_binding( - BindingScope::Navigate, - "keys.new_tab", - &self.keys.new_tab, - "c", - (KeyCode::Char('c'), KeyModifiers::empty()), - &mut diagnostics, - ), - required_binding( - BindingScope::Navigate, - "keys.split_vertical", - &self.keys.split_vertical, - "v", - (KeyCode::Char('v'), KeyModifiers::empty()), - &mut diagnostics, - ), - required_binding( - BindingScope::Navigate, - "keys.split_horizontal", - &self.keys.split_horizontal, - "-", - (KeyCode::Char('-'), KeyModifiers::empty()), - &mut diagnostics, - ), - required_binding( - BindingScope::Navigate, - "keys.close_pane", - &self.keys.close_pane, - "x", - (KeyCode::Char('x'), KeyModifiers::empty()), - &mut diagnostics, - ), - required_binding( - BindingScope::Navigate, - "keys.fullscreen", - &self.keys.fullscreen, - "f", - (KeyCode::Char('f'), KeyModifiers::empty()), - &mut diagnostics, - ), - required_binding( - BindingScope::Navigate, - "keys.resize_mode", - &self.keys.resize_mode, - "r", - (KeyCode::Char('r'), KeyModifiers::empty()), - &mut diagnostics, - ), - required_binding( - BindingScope::Navigate, - "keys.toggle_sidebar", - &self.keys.toggle_sidebar, - "b", - (KeyCode::Char('b'), KeyModifiers::empty()), - &mut diagnostics, - ), - ]; - - let mut optional_bindings = vec![ - optional_binding( - BindingScope::Navigate, - "keys.previous_workspace", - &self.keys.previous_workspace, - &mut diagnostics, - ), - optional_binding( - BindingScope::Navigate, - "keys.next_workspace", - &self.keys.next_workspace, - &mut diagnostics, - ), - optional_binding( - BindingScope::Navigate, - "keys.rename_tab", - &self.keys.rename_tab, - &mut diagnostics, - ), - optional_binding( - BindingScope::Navigate, - "keys.previous_tab", - &self.keys.previous_tab, - &mut diagnostics, - ), - optional_binding( - BindingScope::Navigate, - "keys.next_tab", - &self.keys.next_tab, - &mut diagnostics, - ), - optional_binding( - BindingScope::Navigate, - "keys.close_tab", - &self.keys.close_tab, - &mut diagnostics, - ), - optional_binding( - BindingScope::TerminalDirect, - "keys.focus_pane_left", - &self.keys.focus_pane_left, - &mut diagnostics, - ), - optional_binding( - BindingScope::TerminalDirect, - "keys.focus_pane_down", - &self.keys.focus_pane_down, - &mut diagnostics, - ), - optional_binding( - BindingScope::TerminalDirect, - "keys.focus_pane_up", - &self.keys.focus_pane_up, - &mut diagnostics, - ), - optional_binding( - BindingScope::TerminalDirect, - "keys.focus_pane_right", - &self.keys.focus_pane_right, - &mut diagnostics, - ), - ]; - - let mut registry = BindingRegistry::default(); - for binding in &mut bindings { - if let Some(first_field) = registry.conflict(binding.scope, binding.value) { - let diag = format!( - "duplicate keybinding: {} conflicts with {}; using default {}", - binding.field, first_field, binding.default_label - ); - warn!(message = %diag, "config diagnostic"); - diagnostics.push(diag); - binding.value = binding.default; - binding.label = binding.default_label.to_string(); - } - registry.register(binding.scope, binding.value, binding.field); - } - - for binding in &mut optional_bindings { - let Some(value) = binding.value else { - continue; - }; - if let Some(first_field) = registry.conflict(binding.scope, value) { - let diag = format!( - "duplicate keybinding: {} conflicts with {}; disabling binding", - binding.field, first_field - ); - warn!(message = %diag, "config diagnostic"); - diagnostics.push(diag); - binding.value = None; - binding.label = None; - continue; - } - registry.register(binding.scope, value, binding.field); - } - - registry.reserve_if_unbound(BindingScope::Navigate, prefix, "keys.prefix"); - for (field, binding) in [ - ("navigate.quit", (KeyCode::Char('q'), KeyModifiers::empty())), - ( - "navigate.open_workspace", - (KeyCode::Enter, KeyModifiers::empty()), - ), - ( - "navigate.settings", - (KeyCode::Char('s'), KeyModifiers::empty()), - ), - ( - "navigate.keybind_help", - (KeyCode::Char('?'), KeyModifiers::empty()), - ), - ( - "navigate.workspace_up", - (KeyCode::Up, KeyModifiers::empty()), - ), - ( - "navigate.workspace_down", - (KeyCode::Down, KeyModifiers::empty()), - ), - ( - "navigate.focus_left", - (KeyCode::Char('h'), KeyModifiers::empty()), - ), - ( - "navigate.focus_down", - (KeyCode::Char('j'), KeyModifiers::empty()), - ), - ( - "navigate.focus_up", - (KeyCode::Char('k'), KeyModifiers::empty()), - ), - ( - "navigate.focus_right", - (KeyCode::Char('l'), KeyModifiers::empty()), - ), - ( - "navigate.arrow_left", - (KeyCode::Left, KeyModifiers::empty()), - ), - ( - "navigate.arrow_right", - (KeyCode::Right, KeyModifiers::empty()), - ), - ("navigate.tab_next", (KeyCode::Tab, KeyModifiers::empty())), - ( - "navigate.tab_prev", - (KeyCode::BackTab, KeyModifiers::empty()), - ), - ( - "navigate.workspace_1", - (KeyCode::Char('1'), KeyModifiers::empty()), - ), - ( - "navigate.workspace_2", - (KeyCode::Char('2'), KeyModifiers::empty()), - ), - ( - "navigate.workspace_3", - (KeyCode::Char('3'), KeyModifiers::empty()), - ), - ( - "navigate.workspace_4", - (KeyCode::Char('4'), KeyModifiers::empty()), - ), - ( - "navigate.workspace_5", - (KeyCode::Char('5'), KeyModifiers::empty()), - ), - ( - "navigate.workspace_6", - (KeyCode::Char('6'), KeyModifiers::empty()), - ), - ( - "navigate.workspace_7", - (KeyCode::Char('7'), KeyModifiers::empty()), - ), - ( - "navigate.workspace_8", - (KeyCode::Char('8'), KeyModifiers::empty()), - ), - ( - "navigate.workspace_9", - (KeyCode::Char('9'), KeyModifiers::empty()), - ), - ("navigate.back", (KeyCode::Esc, KeyModifiers::empty())), - ] { - registry.reserve_if_unbound(BindingScope::Navigate, binding, field); - } - - let mut custom_commands = Vec::new(); - for (index, command) in self.keys.command.iter().enumerate() { - let key_field = format!("keys.command[{index}].key"); - let command_field = format!("keys.command[{index}].command"); - - if command.command.trim().is_empty() { - let diag = - format!("empty custom command: {command_field}; disabling custom command"); - warn!(message = %diag, "config diagnostic"); - diagnostics.push(diag); - continue; - } - - let Some(binding) = parse_key_combo(&command.key) else { - let diag = format!( - "invalid keybinding: {} = {:?}; disabling custom command", - key_field, command.key - ); - warn!(message = %diag, "config diagnostic"); - diagnostics.push(diag); - continue; - }; - - if let Some(first_field) = registry.conflict(BindingScope::Navigate, binding) { - let diag = format!( - "duplicate custom keybinding: {} conflicts with {}; disabling custom command", - key_field, first_field - ); - warn!(message = %diag, "config diagnostic"); - diagnostics.push(diag); - continue; - } - - registry.register(BindingScope::Navigate, binding, &key_field); - let action = match command.action_type { - CommandKeybindType::Shell => CustomCommandAction::Shell, - CommandKeybindType::Pane => CustomCommandAction::Pane, - }; - custom_commands.push(CustomCommandKeybind { - key: binding, - label: format_key_combo(binding), - command: command.command.clone(), - action, - }); - } - - let keybinds = Keybinds { - new_workspace: bindings[0].value, - new_workspace_label: bindings[0].label.clone(), - rename_workspace: bindings[1].value, - rename_workspace_label: bindings[1].label.clone(), - close_workspace: bindings[2].value, - close_workspace_label: bindings[2].label.clone(), - previous_workspace: optional_bindings[0].value, - previous_workspace_label: optional_bindings[0].label.clone(), - next_workspace: optional_bindings[1].value, - next_workspace_label: optional_bindings[1].label.clone(), - new_tab: bindings[3].value, - new_tab_label: bindings[3].label.clone(), - rename_tab: optional_bindings[2].value, - rename_tab_label: optional_bindings[2].label.clone(), - previous_tab: optional_bindings[3].value, - previous_tab_label: optional_bindings[3].label.clone(), - next_tab: optional_bindings[4].value, - next_tab_label: optional_bindings[4].label.clone(), - close_tab: optional_bindings[5].value, - close_tab_label: optional_bindings[5].label.clone(), - focus_pane_left: optional_bindings[6].value, - focus_pane_left_label: optional_bindings[6].label.clone(), - focus_pane_down: optional_bindings[7].value, - focus_pane_down_label: optional_bindings[7].label.clone(), - focus_pane_up: optional_bindings[8].value, - focus_pane_up_label: optional_bindings[8].label.clone(), - focus_pane_right: optional_bindings[9].value, - focus_pane_right_label: optional_bindings[9].label.clone(), - split_vertical: bindings[4].value, - split_vertical_label: bindings[4].label.clone(), - split_horizontal: bindings[5].value, - split_horizontal_label: bindings[5].label.clone(), - close_pane: bindings[6].value, - close_pane_label: bindings[6].label.clone(), - fullscreen: bindings[7].value, - fullscreen_label: bindings[7].label.clone(), - resize_mode: bindings[8].value, - resize_mode_label: bindings[8].label.clone(), - toggle_sidebar: bindings[9].value, - toggle_sidebar_label: bindings[9].label.clone(), - custom_commands, - }; - - (prefix_diag, prefix, diagnostics, keybinds) - } -} - -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -pub enum CustomCommandAction { - Shell, - Pane, -} - -#[derive(Debug, Clone)] -pub struct CustomCommandKeybind { - pub key: (KeyCode, KeyModifiers), - pub label: String, - pub command: String, - pub action: CustomCommandAction, -} - -/// Parsed keybinds for navigate mode actions. -#[derive(Debug, Clone)] -pub struct Keybinds { - pub new_workspace: (KeyCode, KeyModifiers), - pub new_workspace_label: String, - pub rename_workspace: (KeyCode, KeyModifiers), - pub rename_workspace_label: String, - pub close_workspace: (KeyCode, KeyModifiers), - pub close_workspace_label: String, - pub previous_workspace: Option<(KeyCode, KeyModifiers)>, - pub previous_workspace_label: Option<String>, - pub next_workspace: Option<(KeyCode, KeyModifiers)>, - pub next_workspace_label: Option<String>, - pub new_tab: (KeyCode, KeyModifiers), - pub new_tab_label: String, - pub rename_tab: Option<(KeyCode, KeyModifiers)>, - pub rename_tab_label: Option<String>, - pub previous_tab: Option<(KeyCode, KeyModifiers)>, - pub previous_tab_label: Option<String>, - pub next_tab: Option<(KeyCode, KeyModifiers)>, - pub next_tab_label: Option<String>, - pub close_tab: Option<(KeyCode, KeyModifiers)>, - pub close_tab_label: Option<String>, - pub focus_pane_left: Option<(KeyCode, KeyModifiers)>, - pub focus_pane_left_label: Option<String>, - pub focus_pane_down: Option<(KeyCode, KeyModifiers)>, - pub focus_pane_down_label: Option<String>, - pub focus_pane_up: Option<(KeyCode, KeyModifiers)>, - pub focus_pane_up_label: Option<String>, - pub focus_pane_right: Option<(KeyCode, KeyModifiers)>, - pub focus_pane_right_label: Option<String>, - pub split_vertical: (KeyCode, KeyModifiers), - pub split_vertical_label: String, - pub split_horizontal: (KeyCode, KeyModifiers), - pub split_horizontal_label: String, - pub close_pane: (KeyCode, KeyModifiers), - pub close_pane_label: String, - pub fullscreen: (KeyCode, KeyModifiers), - pub fullscreen_label: String, - pub resize_mode: (KeyCode, KeyModifiers), - pub resize_mode_label: String, - pub toggle_sidebar: (KeyCode, KeyModifiers), - pub toggle_sidebar_label: String, - pub custom_commands: Vec<CustomCommandKeybind>, -} - -/// Parse a color string into a ratatui Color. -/// Supports: hex (#rrggbb, #rgb), named colors, rgb(r,g,b), and reset aliases. -pub fn parse_color(s: &str) -> ratatui::style::Color { - use ratatui::style::Color; - let s = s.trim().to_lowercase(); - - match s.as_str() { - "reset" | "default" | "none" | "transparent" => return Color::Reset, - _ => {} - } - - // Hex: #rrggbb or #rgb - if let Some(hex) = s.strip_prefix('#') { - if hex.len() == 6 { - if let (Ok(r), Ok(g), Ok(b)) = ( - u8::from_str_radix(&hex[0..2], 16), - u8::from_str_radix(&hex[2..4], 16), - u8::from_str_radix(&hex[4..6], 16), - ) { - return Color::Rgb(r, g, b); - } - } else if hex.len() == 3 { - let chars: Vec<u8> = hex - .chars() - .filter_map(|c| u8::from_str_radix(&c.to_string(), 16).ok()) - .collect(); - if chars.len() == 3 { - return Color::Rgb(chars[0] * 17, chars[1] * 17, chars[2] * 17); - } - } - } - - // rgb(r, g, b) - if let Some(inner) = s.strip_prefix("rgb(").and_then(|s| s.strip_suffix(')')) { - let parts: Vec<&str> = inner.split(',').collect(); - if parts.len() == 3 { - if let (Ok(r), Ok(g), Ok(b)) = ( - parts[0].trim().parse::<u8>(), - parts[1].trim().parse::<u8>(), - parts[2].trim().parse::<u8>(), - ) { - return Color::Rgb(r, g, b); - } - } - } - - // Named colors - match s.as_str() { - "black" => Color::Black, - "red" => Color::Red, - "green" => Color::Green, - "yellow" => Color::Yellow, - "blue" => Color::Blue, - "magenta" | "purple" => Color::Magenta, - "cyan" => Color::Cyan, - "white" => Color::White, - "gray" | "grey" => Color::Gray, - "darkgray" | "darkgrey" => Color::DarkGray, - "lightred" => Color::LightRed, - "lightgreen" => Color::LightGreen, - "lightyellow" => Color::LightYellow, - "lightblue" => Color::LightBlue, - "lightmagenta" => Color::LightMagenta, - "lightcyan" => Color::LightCyan, - _ => { - warn!(color = s, "unknown color, defaulting to cyan"); - Color::Cyan - } - } -} - -pub fn save_onboarding_choices(sound_enabled: bool, toast_enabled: bool) -> std::io::Result<()> { - let path = config_path(); - if let Some(parent) = path.parent() { - std::fs::create_dir_all(parent)?; - } - - let content = std::fs::read_to_string(&path).unwrap_or_default(); - let content = upsert_top_level_bool(&content, "onboarding", false); - let content = upsert_section_bool(&content, "ui.sound", "enabled", sound_enabled); - let content = upsert_section_bool(&content, "ui.toast", "enabled", toast_enabled); - std::fs::write(path, content) -} - -pub fn config_path() -> PathBuf { - if let Ok(path) = std::env::var(CONFIG_PATH_ENV_VAR) { - return PathBuf::from(path); - } - config_dir().join("config.toml") -} - -pub fn load_live_keybinds() -> Result<LiveKeybindConfig, Vec<String>> { - let path = config_path(); - if !path.exists() { - return Config::default().live_keybinds(); - } - - let content = std::fs::read_to_string(&path).map_err(|err| { - vec![format!( - "config read error: {err}; keeping current keybinds" - )] - })?; - let config = toml::from_str::<Config>(&content).map_err(|err| { - vec![format!( - "config parse error: {err}; keeping current keybinds" - )] - })?; - config.live_keybinds() -} - -fn upsert_top_level_bool(content: &str, key: &str, value: bool) -> String { - let replacement = format!("{key} = {value}"); - let mut lines: Vec<String> = content.lines().map(|line| line.to_string()).collect(); - let mut in_section = false; - - for line in &mut lines { - let trimmed = line.trim(); - if trimmed.starts_with('[') && trimmed.ends_with(']') { - in_section = true; - continue; - } - if in_section { - continue; - } - if trimmed.starts_with(&format!("{key} ")) || trimmed.starts_with(&format!("{key}=")) { - *line = replacement.clone(); - return lines.join("\n") + "\n"; - } - } - - if lines.is_empty() { - format!("{replacement}\n") - } else { - format!("{replacement}\n{}\n", lines.join("\n").trim_end()) - } -} - -/// Write a key = value pair in a TOML section (creates section if missing). -pub fn upsert_section_value(content: &str, section: &str, key: &str, value: &str) -> String { - upsert_section_raw(content, section, key, value) -} - -pub fn upsert_section_bool(content: &str, section: &str, key: &str, value: bool) -> String { - upsert_section_raw(content, section, key, &value.to_string()) -} - -fn upsert_section_raw(content: &str, section: &str, key: &str, value: &str) -> String { - let header = format!("[{section}]"); - let assignment = format!("{key} = {value}"); - let lines: Vec<&str> = content.lines().collect(); - let mut result = Vec::new(); - let mut i = 0; - let mut found_section = false; - let mut inserted = false; - - while i < lines.len() { - let line = lines[i]; - let trimmed = line.trim(); - - if trimmed == header { - found_section = true; - result.push(line.to_string()); - i += 1; - - while i < lines.len() { - let current = lines[i]; - let current_trimmed = current.trim(); - if current_trimmed.starts_with('[') && current_trimmed.ends_with(']') { - if !inserted { - result.push(assignment.clone()); - inserted = true; - } - break; - } - - if current_trimmed.starts_with(&format!("{key} ")) - || current_trimmed.starts_with(&format!("{key}=")) - { - result.push(assignment.clone()); - inserted = true; - } else { - result.push(current.to_string()); - } - i += 1; - } - - continue; - } - - result.push(line.to_string()); - i += 1; - } - - if !found_section { - if !result.is_empty() && !result.last().is_some_and(|line| line.trim().is_empty()) { - result.push(String::new()); - } - result.push(header); - result.push(assignment); - } else if found_section && !inserted { - result.push(assignment); - } - - result.join("\n") + "\n" -} - -fn parse_key_combo(s: &str) -> Option<(KeyCode, KeyModifiers)> { - let parts: Vec<&str> = s.split('+').collect(); - let mut modifiers = KeyModifiers::empty(); - let mut key_str: Option<&str> = None; - - for part in &parts { - let trimmed = part.trim(); - match trimmed.to_lowercase().as_str() { - "ctrl" | "control" => modifiers |= KeyModifiers::CONTROL, - "shift" => modifiers |= KeyModifiers::SHIFT, - "alt" | "meta" => modifiers |= KeyModifiers::ALT, - _ if trimmed.is_empty() => return None, - _ => { - if key_str.is_some() { - return None; - } - key_str = Some(trimmed); - } - } - } - - let key_str = key_str?; - - let lower = key_str.to_lowercase(); - let code = match lower.as_str() { - "space" | " " => KeyCode::Char(' '), - "enter" | "return" => KeyCode::Enter, - "esc" | "escape" => KeyCode::Esc, - "tab" => KeyCode::Tab, - "backspace" | "bs" => KeyCode::Backspace, - "left" => KeyCode::Left, - "right" => KeyCode::Right, - "up" => KeyCode::Up, - "down" => KeyCode::Down, - s if s.len() == 1 => { - let ch = key_str.chars().next().unwrap(); - if ch.is_ascii_uppercase() { - modifiers |= KeyModifiers::SHIFT; - KeyCode::Char(ch.to_ascii_lowercase()) - } else { - KeyCode::Char(ch) - } - } - s if s.starts_with('f') => s[1..].parse::<u8>().ok().map(KeyCode::F)?, - _ => return None, - }; - - Some((code, modifiers)) -} - -pub fn format_key_combo(binding: (KeyCode, KeyModifiers)) -> String { - let (code, modifiers) = binding; - let mut parts = Vec::new(); - if modifiers.contains(KeyModifiers::CONTROL) { - parts.push("ctrl".to_string()); - } - if modifiers.contains(KeyModifiers::ALT) { - parts.push("alt".to_string()); - } - if modifiers.contains(KeyModifiers::SHIFT) { - parts.push("shift".to_string()); - } - - let key = match code { - KeyCode::Char(' ') => "space".to_string(), - KeyCode::Char(c) => c.to_string(), - KeyCode::Enter => "enter".to_string(), - KeyCode::Esc => "esc".to_string(), - KeyCode::Tab => "tab".to_string(), - KeyCode::BackTab => "shift+tab".to_string(), - KeyCode::Backspace => "backspace".to_string(), - KeyCode::Left => "left".to_string(), - KeyCode::Right => "right".to_string(), - KeyCode::Up => "up".to_string(), - KeyCode::Down => "down".to_string(), - KeyCode::F(n) => format!("f{n}"), - _ => format!("{:?}", code).to_lowercase(), - }; - - if matches!(code, KeyCode::BackTab) { - return if parts.is_empty() { - key - } else { - format!("{}+tab", parts.join("+")) - }; - } - - parts.push(key); - parts.join("+") -} - -fn parse_key_combo_with_diagnostic( - s: &str, - field: &str, - fallback: (KeyCode, KeyModifiers), -) -> ((KeyCode, KeyModifiers), Option<String>) { - match parse_key_combo(s) { - Some(binding) => (binding, None), - None => { - let diag = format!("invalid keybinding: {field} = {s:?}; using fallback"); - warn!(message = %diag, "config diagnostic"); - (fallback, Some(diag)) - } - } -} - -#[cfg(test)] -mod tests { - use super::*; - use crossterm::event::{KeyCode, KeyModifiers}; - - #[test] - fn parse_simple_char() { - assert_eq!( - parse_key_combo("v"), - Some((KeyCode::Char('v'), KeyModifiers::empty())) - ); - } - - #[test] - fn parse_ctrl_combo() { - assert_eq!( - parse_key_combo("ctrl+b"), - Some((KeyCode::Char('b'), KeyModifiers::CONTROL)) - ); - } - - #[test] - fn parse_special_key() { - assert_eq!( - parse_key_combo("enter"), - Some((KeyCode::Enter, KeyModifiers::empty())) - ); - assert_eq!( - parse_key_combo("tab"), - Some((KeyCode::Tab, KeyModifiers::empty())) - ); - assert_eq!( - parse_key_combo("esc"), - Some((KeyCode::Esc, KeyModifiers::empty())) - ); - assert_eq!( - parse_key_combo("left"), - Some((KeyCode::Left, KeyModifiers::empty())) - ); - assert_eq!( - parse_key_combo("alt+right"), - Some((KeyCode::Right, KeyModifiers::ALT)) - ); - } - - #[test] - fn parse_ctrl_shift() { - assert_eq!( - parse_key_combo("ctrl+shift+a"), - Some(( - KeyCode::Char('a'), - KeyModifiers::CONTROL | KeyModifiers::SHIFT - )) - ); - } - - #[test] - fn parse_f_key() { - assert_eq!( - parse_key_combo("f5"), - Some((KeyCode::F(5), KeyModifiers::empty())) - ); - } - - #[test] - fn parse_punctuation_key() { - assert_eq!( - parse_key_combo("ctrl+`"), - Some((KeyCode::Char('`'), KeyModifiers::CONTROL)) - ); - } - - #[test] - fn uppercase_char_implies_shift() { - assert_eq!( - parse_key_combo("D"), - Some((KeyCode::Char('d'), KeyModifiers::SHIFT)) - ); - } - - #[test] - fn explicit_shift_and_uppercase_do_not_double_apply_shift() { - assert_eq!( - parse_key_combo("shift+D"), - Some((KeyCode::Char('d'), KeyModifiers::SHIFT)) - ); - } - - #[test] - fn invalid_keybinding_is_rejected() { - assert_eq!(parse_key_combo("ctrl+foo+bar"), None); - assert_eq!(parse_key_combo("ctrl+"), None); - } - - #[test] - fn default_keybinds_parse() { - let config = Config::default(); - let kb = config.keybinds(); - assert_eq!(kb.new_workspace.0, KeyCode::Char('n')); - assert_eq!( - kb.rename_workspace, - (KeyCode::Char('n'), KeyModifiers::SHIFT) - ); - assert_eq!(kb.close_workspace.0, KeyCode::Char('d')); - assert_eq!(kb.split_vertical.0, KeyCode::Char('v')); - assert_eq!(kb.split_horizontal.0, KeyCode::Char('-')); - assert_eq!(kb.close_pane.0, KeyCode::Char('x')); - assert_eq!(kb.fullscreen.0, KeyCode::Char('f')); - assert_eq!(kb.resize_mode.0, KeyCode::Char('r')); - assert_eq!(kb.toggle_sidebar.0, KeyCode::Char('b')); - assert!(kb.custom_commands.is_empty()); - } - - #[test] - fn custom_keybinds_from_toml() { - let toml = r#" -[keys] -prefix = "ctrl+a" -new_workspace = "c" -rename_workspace = "shift+r" -close_workspace = "ctrl+d" -split_vertical = "s" -split_horizontal = "shift+s" -close_pane = "ctrl+w" -fullscreen = "z" -resize_mode = "ctrl+r" -toggle_sidebar = "tab" -focus_pane_left = "alt+h" -focus_pane_right = "alt+right" -"#; - let config: Config = toml::from_str(toml).unwrap(); - let (code, mods) = config.prefix_key(); - assert_eq!(code, KeyCode::Char('a')); - assert_eq!(mods, KeyModifiers::CONTROL); - - let kb = config.keybinds(); - assert_eq!( - kb.new_workspace, - (KeyCode::Char('c'), KeyModifiers::empty()) - ); - assert_eq!( - kb.rename_workspace, - (KeyCode::Char('r'), KeyModifiers::SHIFT) - ); - assert_eq!( - kb.close_workspace, - (KeyCode::Char('d'), KeyModifiers::CONTROL) - ); - assert_eq!(kb.split_vertical.0, KeyCode::Char('s')); - assert_eq!( - kb.split_horizontal, - (KeyCode::Char('s'), KeyModifiers::SHIFT) - ); - assert_eq!(kb.close_pane, (KeyCode::Char('w'), KeyModifiers::CONTROL)); - assert_eq!(kb.fullscreen.0, KeyCode::Char('z')); - assert_eq!(kb.resize_mode, (KeyCode::Char('r'), KeyModifiers::CONTROL)); - assert_eq!(kb.toggle_sidebar, (KeyCode::Tab, KeyModifiers::empty())); - assert_eq!( - kb.focus_pane_left, - Some((KeyCode::Char('h'), KeyModifiers::ALT)) - ); - assert_eq!( - kb.focus_pane_right, - Some((KeyCode::Right, KeyModifiers::ALT)) - ); - assert_eq!(kb.focus_pane_down, None); - assert_eq!(kb.focus_pane_up, None); - } - - #[test] - fn uppercase_keybind_from_toml_flows_into_shift_combo() { - let toml = r#" -[keys] -split_horizontal = "D" -"#; - let config: Config = toml::from_str(toml).unwrap(); - let kb = config.keybinds(); - assert_eq!( - kb.split_horizontal, - (KeyCode::Char('d'), KeyModifiers::SHIFT) - ); - } - - #[test] - fn invalid_keybinding_produces_diagnostic_and_falls_back() { - let toml = r#" -[keys] -rename_workspace = "wat" -"#; - let config: Config = toml::from_str(toml).unwrap(); - let diagnostics = config.collect_diagnostics(); - let kb = config.keybinds(); - - assert!(diagnostics - .iter() - .any(|d| d.contains("keys.rename_workspace"))); - assert_eq!( - kb.rename_workspace, - (KeyCode::Char('n'), KeyModifiers::SHIFT) - ); - assert_eq!(kb.rename_workspace_label, "shift+n"); - } - - #[test] - fn toast_config_parses() { - let toml = r#" -[ui.toast] -enabled = true -"#; - let config: Config = toml::from_str(toml).unwrap(); - assert!(config.ui.toast.enabled); - } - - #[test] - fn missing_onboarding_shows_setup() { - let config = Config::default(); - assert!(config.should_show_onboarding()); - } - - #[test] - fn onboarding_false_skips_setup() { - let config: Config = toml::from_str("onboarding = false").unwrap(); - assert!(!config.should_show_onboarding()); - } - - #[test] - fn upsert_top_level_bool_replaces_existing_value() { - let content = "onboarding = true\n[keys]\nprefix = \"ctrl+b\"\n"; - let updated = upsert_top_level_bool(content, "onboarding", false); - assert!(updated.contains("onboarding = false")); - assert!(!updated.contains("onboarding = true")); - } - - #[test] - fn upsert_section_bool_adds_missing_section() { - let updated = upsert_section_bool("", "ui.toast", "enabled", true); - assert!(updated.contains("[ui.toast]")); - assert!(updated.contains("enabled = true")); - } - - #[test] - fn duplicate_keybinding_produces_diagnostic_and_falls_back_later_binding() { - let toml = r#" -[keys] -new_workspace = "g" -rename_workspace = "g" -"#; - let config: Config = toml::from_str(toml).unwrap(); - let diagnostics = config.collect_diagnostics(); - let kb = config.keybinds(); - - assert!(diagnostics - .iter() - .any(|d| d.contains("duplicate keybinding"))); - assert_eq!( - kb.new_workspace, - (KeyCode::Char('g'), KeyModifiers::empty()) - ); - assert_eq!( - kb.rename_workspace, - (KeyCode::Char('n'), KeyModifiers::SHIFT) - ); - assert_eq!(kb.rename_workspace_label, "shift+n"); - } - - #[test] - fn duplicate_optional_keybinding_is_disabled_with_diagnostic() { - let toml = r#" -[keys] -new_workspace = "g" -rename_tab = "g" -"#; - let config: Config = toml::from_str(toml).unwrap(); - let diagnostics = config.collect_diagnostics(); - let kb = config.keybinds(); - - assert!(diagnostics - .iter() - .any(|d| d.contains("keys.rename_tab") && d.contains("disabling binding"))); - assert_eq!( - kb.new_workspace, - (KeyCode::Char('g'), KeyModifiers::empty()) - ); - assert_eq!(kb.rename_tab, None); - } - - #[test] - fn duplicate_shifted_symbol_binding_is_rejected_after_normalization() { - let toml = r#" -[keys] -new_workspace = "?" -rename_workspace = "shift+/" -"#; - let config: Config = toml::from_str(toml).unwrap(); - let diagnostics = config.collect_diagnostics(); - let kb = config.keybinds(); - - assert!(diagnostics.iter().any(|d| { - d.contains("duplicate keybinding") - && d.contains("keys.rename_workspace") - && d.contains("keys.new_workspace") - })); - assert_eq!( - kb.new_workspace, - (KeyCode::Char('?'), KeyModifiers::empty()) - ); - assert_eq!( - kb.rename_workspace, - (KeyCode::Char('n'), KeyModifiers::SHIFT) - ); - assert_eq!(kb.rename_workspace_label, "shift+n"); - } - - #[test] - fn custom_command_conflicting_with_shifted_symbol_reserved_key_is_disabled() { - let toml = r#" -[[keys.command]] -key = "shift+/" -command = "echo hi" -"#; - let config: Config = toml::from_str(toml).unwrap(); - let diagnostics = config.collect_diagnostics(); - let kb = config.keybinds(); - - assert!(diagnostics.iter().any(|d| { - d.contains("duplicate custom keybinding") - && d.contains("keys.command[0].key") - && d.contains("navigate.keybind_help") - })); - assert!(kb.custom_commands.is_empty()); - } - - #[test] - fn custom_command_keybinds_parse_from_toml() { - let toml = r#" -[[keys.command]] -key = "g" -command = "echo hi" -"#; - let config: Config = toml::from_str(toml).unwrap(); - let kb = config.keybinds(); - - assert_eq!(kb.custom_commands.len(), 1); - assert_eq!( - kb.custom_commands[0].key, - (KeyCode::Char('g'), KeyModifiers::empty()) - ); - assert_eq!(kb.custom_commands[0].label, "g"); - assert_eq!(kb.custom_commands[0].command, "echo hi"); - assert_eq!(kb.custom_commands[0].action, CustomCommandAction::Shell); - } - - #[test] - fn pane_custom_command_keybinds_parse_from_toml() { - let toml = r#" -[[keys.command]] -key = "g" -type = "pane" -command = "lazygit" -"#; - let config: Config = toml::from_str(toml).unwrap(); - let kb = config.keybinds(); - - assert_eq!(kb.custom_commands.len(), 1); - assert_eq!(kb.custom_commands[0].action, CustomCommandAction::Pane); - } - - #[test] - fn custom_command_conflicting_with_builtin_is_disabled_with_diagnostic() { - let toml = r#" -[keys] -new_workspace = "g" - -[[keys.command]] -key = "g" -command = "echo hi" -"#; - let config: Config = toml::from_str(toml).unwrap(); - let diagnostics = config.collect_diagnostics(); - let kb = config.keybinds(); - - assert!(diagnostics.iter().any(|d| { - d.contains("duplicate custom keybinding") - && d.contains("keys.command[0].key") - && d.contains("keys.new_workspace") - })); - assert!(kb.custom_commands.is_empty()); - } - - #[test] - fn custom_command_conflicting_with_reserved_navigate_key_is_disabled_with_diagnostic() { - let toml = r#" -[[keys.command]] -key = "q" -command = "echo hi" -"#; - let config: Config = toml::from_str(toml).unwrap(); - let diagnostics = config.collect_diagnostics(); - let kb = config.keybinds(); - - assert!(diagnostics.iter().any(|d| { - d.contains("duplicate custom keybinding") - && d.contains("keys.command[0].key") - && d.contains("navigate.quit") - })); - assert!(kb.custom_commands.is_empty()); - } - - #[test] - fn live_keybinds_reject_invalid_keybinding() { - let config: Config = toml::from_str( - r#" -[keys] -rename_workspace = "wat" -"#, - ) - .unwrap(); - - let diagnostics = config.live_keybinds().unwrap_err(); - assert!(diagnostics - .iter() - .any(|d| d.contains("keys.rename_workspace"))); - } - - #[test] - fn live_keybinds_ignore_non_key_diagnostics() { - let config: Config = toml::from_str( - r#" -[keys] -new_workspace = "g" - -[ui.sound] -done_path = "sounds/missing.mp3" -"#, - ) - .unwrap(); - - let live = config.live_keybinds().unwrap(); - assert_eq!( - live.keybinds.new_workspace, - (KeyCode::Char('g'), KeyModifiers::empty()) - ); - } - - #[test] - fn sound_table_config_parses() { - let toml = r#" -[ui.sound] -enabled = true -path = "sounds/all.mp3" -done_path = "sounds/done.mp3" -request_path = "/tmp/request.mp3" - -[ui.sound.agents] -droid = "off" -claude = "on" -"#; - let config: Config = toml::from_str(toml).unwrap(); - assert!(config.ui.sound.enabled); - assert_eq!(config.ui.sound.path, Some(PathBuf::from("sounds/all.mp3"))); - assert_eq!( - config.ui.sound.done_path, - Some(PathBuf::from("sounds/done.mp3")) - ); - assert_eq!( - config.ui.sound.request_path, - Some(PathBuf::from("/tmp/request.mp3")) - ); - assert_eq!(config.ui.sound.agents.droid, AgentSoundSetting::Off); - assert_eq!(config.ui.sound.agents.claude, AgentSoundSetting::On); - assert_eq!(config.ui.sound.agents.pi, AgentSoundSetting::Default); - } - - #[test] - fn sound_path_resolution_prefers_specific_over_global() { - let config: Config = toml::from_str( - r#" -[ui.sound] -path = "sounds/all.mp3" -done_path = "sounds/done.mp3" -"#, - ) - .unwrap(); - - let config_root = config_path().parent().unwrap().to_path_buf(); - assert_eq!( - config.ui.sound.path_for(crate::sound::Sound::Done), - Some(config_root.join("sounds/done.mp3")) - ); - assert_eq!( - config.ui.sound.path_for(crate::sound::Sound::Request), - Some(config_root.join("sounds/all.mp3")) - ); - } - - #[test] - fn missing_sound_file_produces_diagnostic() { - let config: Config = toml::from_str( - r#" -[ui.sound] -done_path = "sounds/missing.mp3" -"#, - ) - .unwrap(); - - let diagnostics = config.collect_diagnostics(); - assert!(diagnostics.iter().any( - |diag| diag.contains("ui.sound.done_path") && diag.contains("using default sound") - )); - } - - #[test] - fn non_mp3_sound_file_produces_diagnostic() { - let config: Config = toml::from_str( - r#" -[ui.sound] -path = "sounds/notification.wav" -"#, - ) - .unwrap(); - - let diagnostics = config.collect_diagnostics(); - assert!(diagnostics.iter().any(|diag| { - diag.contains("ui.sound.path") && diag.contains("expected an mp3 file") - })); - } - - #[test] - fn advanced_defaults_include_scrollback_limit_bytes() { - let config = Config::default(); - assert_eq!( - config.advanced.scrollback_limit_bytes, - DEFAULT_SCROLLBACK_LIMIT_BYTES - ); - } - - #[test] - fn advanced_config_parses() { - let toml = r#" -[advanced] -allow_nested = true -scrollback_limit_bytes = 12345 -"#; - let config: Config = toml::from_str(toml).unwrap(); - assert!(config.advanced.allow_nested); - assert_eq!(config.advanced.scrollback_limit_bytes, 12345); - } - - #[test] - fn advanced_legacy_scrollback_lines_alias_parses() { - let toml = r#" -[advanced] -scrollback_lines = 12345 -"#; - let config: Config = toml::from_str(toml).unwrap(); - assert_eq!(config.advanced.scrollback_limit_bytes, 12345); - } - - #[test] - fn theme_name_parses() { - let toml = r#" -[theme] -name = "dracula" -"#; - let config: Config = toml::from_str(toml).unwrap(); - assert_eq!(config.theme.name.as_deref(), Some("dracula")); - } - - #[test] - fn parse_color_accepts_reset_aliases() { - use ratatui::style::Color; - - for value in ["reset", "default", "none", "transparent"] { - assert_eq!(parse_color(value), Color::Reset, "value: {value}"); - } - } - - #[test] - fn theme_custom_overrides_parse() { - let toml = r##" -[theme] -name = "nord" - -[theme.custom] -panel_bg = "#1e1e2e" -accent = "#ff79c6" -red = "rgb(255, 85, 85)" -"##; - let config: Config = toml::from_str(toml).unwrap(); - assert_eq!(config.theme.name.as_deref(), Some("nord")); - let custom = config.theme.custom.as_ref().unwrap(); - assert_eq!(custom.panel_bg.as_deref(), Some("#1e1e2e")); - assert_eq!(custom.accent.as_deref(), Some("#ff79c6")); - assert_eq!(custom.red.as_deref(), Some("rgb(255, 85, 85)")); - assert!(custom.green.is_none()); - } - - #[test] - fn theme_defaults_when_missing() { - let config: Config = toml::from_str("").unwrap(); - assert!(config.theme.name.is_none()); - assert!(config.theme.custom.is_none()); - } -} diff --git a/src/config/io.rs b/src/config/io.rs new file mode 100644 index 00000000..3bc18c4b --- /dev/null +++ b/src/config/io.rs @@ -0,0 +1,226 @@ +use std::path::{Path, PathBuf}; + +use tracing::warn; + +use super::{model::LoadedConfig, Config, LiveKeybindConfig, CONFIG_PATH_ENV_VAR}; + +pub fn app_dir_name() -> &'static str { + if cfg!(debug_assertions) { + "herdr-dev" + } else { + "herdr" + } +} + +pub fn config_dir() -> PathBuf { + if let Ok(dir) = std::env::var("XDG_CONFIG_HOME") { + PathBuf::from(dir).join(app_dir_name()) + } else if let Ok(home) = std::env::var("HOME") { + PathBuf::from(home).join(format!(".config/{}", app_dir_name())) + } else { + PathBuf::from(format!("/tmp/{}", app_dir_name())) + } +} + +impl Config { + pub fn load() -> LoadedConfig { + let path = config_path(); + if path.exists() { + match std::fs::read_to_string(&path) { + Ok(content) => match toml::from_str::<Config>(&content) { + Ok(config) => { + let diagnostics = config.collect_diagnostics(); + return LoadedConfig { + config, + diagnostics, + }; + } + Err(err) => { + warn!(err = %err, "config parse error, using defaults"); + return LoadedConfig { + config: Self::default(), + diagnostics: vec![format!("config parse error: {err}; using defaults")], + }; + } + }, + Err(err) => { + warn!(err = %err, "config read error, using defaults"); + return LoadedConfig { + config: Self::default(), + diagnostics: vec![format!("config read error: {err}; using defaults")], + }; + } + } + } + LoadedConfig { + config: Self::default(), + diagnostics: Vec::new(), + } + } +} + +pub(super) fn resolve_config_relative_path(path: &Path) -> PathBuf { + if path.is_absolute() { + return path.to_path_buf(); + } + + config_path() + .parent() + .unwrap_or_else(|| Path::new(".")) + .join(path) +} + +pub fn save_onboarding_choices(sound_enabled: bool, toast_enabled: bool) -> std::io::Result<()> { + let path = config_path(); + if let Some(parent) = path.parent() { + std::fs::create_dir_all(parent)?; + } + + let content = std::fs::read_to_string(&path).unwrap_or_default(); + let content = upsert_top_level_bool(&content, "onboarding", false); + let content = upsert_section_bool(&content, "ui.sound", "enabled", sound_enabled); + let content = upsert_section_bool(&content, "ui.toast", "enabled", toast_enabled); + std::fs::write(path, content) +} + +pub fn config_path() -> PathBuf { + if let Ok(path) = std::env::var(CONFIG_PATH_ENV_VAR) { + return PathBuf::from(path); + } + config_dir().join("config.toml") +} + +pub fn load_live_keybinds() -> Result<LiveKeybindConfig, Vec<String>> { + let path = config_path(); + if !path.exists() { + return Config::default().live_keybinds(); + } + + let content = std::fs::read_to_string(&path).map_err(|err| { + vec![format!( + "config read error: {err}; keeping current keybinds" + )] + })?; + let config = toml::from_str::<Config>(&content).map_err(|err| { + vec![format!( + "config parse error: {err}; keeping current keybinds" + )] + })?; + config.live_keybinds() +} + +pub(super) fn upsert_top_level_bool(content: &str, key: &str, value: bool) -> String { + let replacement = format!("{key} = {value}"); + let mut lines: Vec<String> = content.lines().map(|line| line.to_string()).collect(); + let mut in_section = false; + + for line in &mut lines { + let trimmed = line.trim(); + if trimmed.starts_with('[') && trimmed.ends_with(']') { + in_section = true; + continue; + } + if in_section { + continue; + } + if trimmed.starts_with(&format!("{key} ")) || trimmed.starts_with(&format!("{key}=")) { + *line = replacement.clone(); + return lines.join("\n") + "\n"; + } + } + + if lines.is_empty() { + format!("{replacement}\n") + } else { + format!("{replacement}\n{}\n", lines.join("\n").trim_end()) + } +} + +/// Write a key = value pair in a TOML section (creates section if missing). +pub fn upsert_section_value(content: &str, section: &str, key: &str, value: &str) -> String { + upsert_section_raw(content, section, key, value) +} + +pub fn upsert_section_bool(content: &str, section: &str, key: &str, value: bool) -> String { + upsert_section_raw(content, section, key, &value.to_string()) +} + +fn upsert_section_raw(content: &str, section: &str, key: &str, value: &str) -> String { + let header = format!("[{section}]"); + let assignment = format!("{key} = {value}"); + let lines: Vec<&str> = content.lines().collect(); + let mut result = Vec::new(); + let mut i = 0; + let mut found_section = false; + let mut inserted = false; + + while i < lines.len() { + let line = lines[i]; + let trimmed = line.trim(); + + if trimmed == header { + found_section = true; + result.push(line.to_string()); + i += 1; + + while i < lines.len() { + let current = lines[i]; + let current_trimmed = current.trim(); + if current_trimmed.starts_with('[') && current_trimmed.ends_with(']') { + if !inserted { + result.push(assignment.clone()); + inserted = true; + } + break; + } + + if current_trimmed.starts_with(&format!("{key} ")) + || current_trimmed.starts_with(&format!("{key}=")) + { + result.push(assignment.clone()); + inserted = true; + } else { + result.push(current.to_string()); + } + i += 1; + } + + continue; + } + + result.push(line.to_string()); + i += 1; + } + + if !found_section { + if !result.is_empty() && !result.last().is_some_and(|line| line.trim().is_empty()) { + result.push(String::new()); + } + result.push(header); + result.push(assignment); + } else if !inserted { + result.push(assignment); + } + + result.join("\n") + "\n" +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn upsert_top_level_bool_replaces_existing_value() { + let content = "onboarding = true\n[keys]\nprefix = \"ctrl+b\"\n"; + let updated = upsert_top_level_bool(content, "onboarding", false); + assert!(updated.contains("onboarding = false")); + assert!(!updated.contains("onboarding = true")); + } + + #[test] + fn upsert_section_bool_adds_missing_section() { + let updated = upsert_section_bool("", "ui.toast", "enabled", true); + assert!(updated.contains("[ui.toast]")); + assert!(updated.contains("enabled = true")); + } +} diff --git a/src/config/keybinds.rs b/src/config/keybinds.rs new file mode 100644 index 00000000..07c682ba --- /dev/null +++ b/src/config/keybinds.rs @@ -0,0 +1,1089 @@ +use crossterm::event::{KeyCode, KeyModifiers}; +use serde::Deserialize; +use tracing::warn; + +use super::Config; + +#[derive(Debug)] +pub struct LiveKeybindConfig { + pub prefix: (KeyCode, KeyModifiers), + pub keybinds: Keybinds, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Default)] +#[serde(rename_all = "snake_case")] +pub enum CommandKeybindType { + #[default] + Shell, + Pane, +} + +#[derive(Debug, Clone, Deserialize)] +#[serde(default)] +pub struct CommandKeybindConfig { + /// Navigate-mode key that runs a command after pressing the prefix key. + pub key: String, + /// Command executed either in the background shell or inside a pane. + pub command: String, + /// Command execution mode. Default: "shell". + #[serde(rename = "type")] + pub action_type: CommandKeybindType, +} + +impl Default for CommandKeybindConfig { + fn default() -> Self { + Self { + key: String::new(), + command: String::new(), + action_type: CommandKeybindType::Shell, + } + } +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum CustomCommandAction { + Shell, + Pane, +} + +#[derive(Debug, Clone)] +pub struct CustomCommandKeybind { + pub key: (KeyCode, KeyModifiers), + pub label: String, + pub command: String, + pub action: CustomCommandAction, +} + +/// Parsed keybinds for navigate mode actions. +#[derive(Debug, Clone)] +pub struct Keybinds { + pub new_workspace: (KeyCode, KeyModifiers), + pub new_workspace_label: String, + pub rename_workspace: (KeyCode, KeyModifiers), + pub rename_workspace_label: String, + pub close_workspace: (KeyCode, KeyModifiers), + pub close_workspace_label: String, + pub detach: Option<(KeyCode, KeyModifiers)>, + pub detach_label: Option<String>, + pub previous_workspace: Option<(KeyCode, KeyModifiers)>, + pub previous_workspace_label: Option<String>, + pub next_workspace: Option<(KeyCode, KeyModifiers)>, + pub next_workspace_label: Option<String>, + pub new_tab: (KeyCode, KeyModifiers), + pub new_tab_label: String, + pub rename_tab: Option<(KeyCode, KeyModifiers)>, + pub rename_tab_label: Option<String>, + pub previous_tab: Option<(KeyCode, KeyModifiers)>, + pub previous_tab_label: Option<String>, + pub next_tab: Option<(KeyCode, KeyModifiers)>, + pub next_tab_label: Option<String>, + pub close_tab: Option<(KeyCode, KeyModifiers)>, + pub close_tab_label: Option<String>, + pub focus_pane_left: Option<(KeyCode, KeyModifiers)>, + pub focus_pane_left_label: Option<String>, + pub focus_pane_down: Option<(KeyCode, KeyModifiers)>, + pub focus_pane_down_label: Option<String>, + pub focus_pane_up: Option<(KeyCode, KeyModifiers)>, + pub focus_pane_up_label: Option<String>, + pub focus_pane_right: Option<(KeyCode, KeyModifiers)>, + pub focus_pane_right_label: Option<String>, + pub split_vertical: (KeyCode, KeyModifiers), + pub split_vertical_label: String, + pub split_horizontal: (KeyCode, KeyModifiers), + pub split_horizontal_label: String, + pub close_pane: (KeyCode, KeyModifiers), + pub close_pane_label: String, + pub fullscreen: (KeyCode, KeyModifiers), + pub fullscreen_label: String, + pub resize_mode: (KeyCode, KeyModifiers), + pub resize_mode_label: String, + pub toggle_sidebar: (KeyCode, KeyModifiers), + pub toggle_sidebar_label: String, + pub custom_commands: Vec<CustomCommandKeybind>, +} + +impl Config { + pub(super) fn validated_keybinds( + &self, + ) -> ( + Option<String>, + (KeyCode, KeyModifiers), + Vec<String>, + Keybinds, + ) { + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] + enum BindingScope { + Navigate, + TerminalDirect, + } + + #[derive(Clone)] + struct RequiredBinding<'a> { + scope: BindingScope, + field: &'a str, + label: String, + default_label: &'a str, + value: (KeyCode, KeyModifiers), + default: (KeyCode, KeyModifiers), + } + + struct OptionalBinding { + scope: BindingScope, + field: &'static str, + value: Option<(KeyCode, KeyModifiers)>, + label: Option<String>, + } + + #[derive(Default)] + struct BindingRegistry { + seen: std::collections::HashMap<(BindingScope, KeyCode, KeyModifiers), String>, + } + + impl BindingRegistry { + fn register( + &mut self, + scope: BindingScope, + binding: (KeyCode, KeyModifiers), + field: &str, + ) -> Option<String> { + self.seen + .insert((scope, binding.0, binding.1), field.to_string()) + } + + fn conflict( + &self, + scope: BindingScope, + binding: (KeyCode, KeyModifiers), + ) -> Option<&str> { + self.seen + .get(&(scope, binding.0, binding.1)) + .map(String::as_str) + } + + fn reserve_if_unbound( + &mut self, + scope: BindingScope, + binding: (KeyCode, KeyModifiers), + field: &str, + ) { + self.seen + .entry((scope, binding.0, binding.1)) + .or_insert_with(|| field.to_string()); + } + } + + fn required_binding<'a>( + scope: BindingScope, + field: &'a str, + configured_label: &'a str, + default_label: &'a str, + default: (KeyCode, KeyModifiers), + diagnostics: &mut Vec<String>, + ) -> RequiredBinding<'a> { + let (value, diag) = parse_key_combo_with_diagnostic(configured_label, field, default); + let label = if let Some(diag) = diag { + diagnostics.push(diag); + default_label.to_string() + } else { + configured_label.to_string() + }; + RequiredBinding { + scope, + field, + label, + default_label, + value, + default, + } + } + + fn optional_binding( + scope: BindingScope, + field: &'static str, + configured_label: &str, + diagnostics: &mut Vec<String>, + ) -> OptionalBinding { + if configured_label.trim().is_empty() { + return OptionalBinding { + scope, + field, + value: None, + label: None, + }; + } + match parse_key_combo(configured_label) { + Some(value) => OptionalBinding { + scope, + field, + value: Some(value), + label: Some(configured_label.to_string()), + }, + None => { + let diag = format!( + "invalid keybinding: {field} = {:?}; disabling binding", + configured_label + ); + warn!(message = %diag, "config diagnostic"); + diagnostics.push(diag); + OptionalBinding { + scope, + field, + value: None, + label: None, + } + } + } + } + + let mut diagnostics = Vec::new(); + let (prefix, prefix_diag) = parse_key_combo_with_diagnostic( + &self.keys.prefix, + "keys.prefix", + (KeyCode::Char('b'), KeyModifiers::CONTROL), + ); + if let Some(diag) = &prefix_diag { + warn!(message = %diag, "config diagnostic"); + } + + let mut bindings = vec![ + required_binding( + BindingScope::Navigate, + "keys.new_workspace", + &self.keys.new_workspace, + "n", + (KeyCode::Char('n'), KeyModifiers::empty()), + &mut diagnostics, + ), + required_binding( + BindingScope::Navigate, + "keys.rename_workspace", + &self.keys.rename_workspace, + "shift+n", + (KeyCode::Char('n'), KeyModifiers::SHIFT), + &mut diagnostics, + ), + required_binding( + BindingScope::Navigate, + "keys.close_workspace", + &self.keys.close_workspace, + "shift+d", + (KeyCode::Char('d'), KeyModifiers::SHIFT), + &mut diagnostics, + ), + required_binding( + BindingScope::Navigate, + "keys.new_tab", + &self.keys.new_tab, + "c", + (KeyCode::Char('c'), KeyModifiers::empty()), + &mut diagnostics, + ), + required_binding( + BindingScope::Navigate, + "keys.split_vertical", + &self.keys.split_vertical, + "v", + (KeyCode::Char('v'), KeyModifiers::empty()), + &mut diagnostics, + ), + required_binding( + BindingScope::Navigate, + "keys.split_horizontal", + &self.keys.split_horizontal, + "-", + (KeyCode::Char('-'), KeyModifiers::empty()), + &mut diagnostics, + ), + required_binding( + BindingScope::Navigate, + "keys.close_pane", + &self.keys.close_pane, + "x", + (KeyCode::Char('x'), KeyModifiers::empty()), + &mut diagnostics, + ), + required_binding( + BindingScope::Navigate, + "keys.fullscreen", + &self.keys.fullscreen, + "f", + (KeyCode::Char('f'), KeyModifiers::empty()), + &mut diagnostics, + ), + required_binding( + BindingScope::Navigate, + "keys.resize_mode", + &self.keys.resize_mode, + "r", + (KeyCode::Char('r'), KeyModifiers::empty()), + &mut diagnostics, + ), + required_binding( + BindingScope::Navigate, + "keys.toggle_sidebar", + &self.keys.toggle_sidebar, + "b", + (KeyCode::Char('b'), KeyModifiers::empty()), + &mut diagnostics, + ), + ]; + + let mut optional_bindings = vec![ + optional_binding( + BindingScope::Navigate, + "keys.detach", + &self.keys.detach, + &mut diagnostics, + ), + optional_binding( + BindingScope::Navigate, + "keys.previous_workspace", + &self.keys.previous_workspace, + &mut diagnostics, + ), + optional_binding( + BindingScope::Navigate, + "keys.next_workspace", + &self.keys.next_workspace, + &mut diagnostics, + ), + optional_binding( + BindingScope::Navigate, + "keys.rename_tab", + &self.keys.rename_tab, + &mut diagnostics, + ), + optional_binding( + BindingScope::Navigate, + "keys.previous_tab", + &self.keys.previous_tab, + &mut diagnostics, + ), + optional_binding( + BindingScope::Navigate, + "keys.next_tab", + &self.keys.next_tab, + &mut diagnostics, + ), + optional_binding( + BindingScope::Navigate, + "keys.close_tab", + &self.keys.close_tab, + &mut diagnostics, + ), + optional_binding( + BindingScope::TerminalDirect, + "keys.focus_pane_left", + &self.keys.focus_pane_left, + &mut diagnostics, + ), + optional_binding( + BindingScope::TerminalDirect, + "keys.focus_pane_down", + &self.keys.focus_pane_down, + &mut diagnostics, + ), + optional_binding( + BindingScope::TerminalDirect, + "keys.focus_pane_up", + &self.keys.focus_pane_up, + &mut diagnostics, + ), + optional_binding( + BindingScope::TerminalDirect, + "keys.focus_pane_right", + &self.keys.focus_pane_right, + &mut diagnostics, + ), + ]; + + let mut registry = BindingRegistry::default(); + for binding in &mut bindings { + if let Some(first_field) = registry.conflict(binding.scope, binding.value) { + let diag = format!( + "duplicate keybinding: {} conflicts with {}; using default {}", + binding.field, first_field, binding.default_label + ); + warn!(message = %diag, "config diagnostic"); + diagnostics.push(diag); + binding.value = binding.default; + binding.label = binding.default_label.to_string(); + } + registry.register(binding.scope, binding.value, binding.field); + } + + for binding in &mut optional_bindings { + let Some(value) = binding.value else { + continue; + }; + if let Some(first_field) = registry.conflict(binding.scope, value) { + let diag = format!( + "duplicate keybinding: {} conflicts with {}; disabling binding", + binding.field, first_field + ); + warn!(message = %diag, "config diagnostic"); + diagnostics.push(diag); + binding.value = None; + binding.label = None; + continue; + } + registry.register(binding.scope, value, binding.field); + } + + registry.reserve_if_unbound(BindingScope::Navigate, prefix, "keys.prefix"); + for (field, binding) in [ + ("navigate.quit", (KeyCode::Char('q'), KeyModifiers::empty())), + ( + "navigate.open_workspace", + (KeyCode::Enter, KeyModifiers::empty()), + ), + ( + "navigate.settings", + (KeyCode::Char('s'), KeyModifiers::empty()), + ), + ( + "navigate.keybind_help", + (KeyCode::Char('?'), KeyModifiers::empty()), + ), + ( + "navigate.workspace_up", + (KeyCode::Up, KeyModifiers::empty()), + ), + ( + "navigate.workspace_down", + (KeyCode::Down, KeyModifiers::empty()), + ), + ( + "navigate.focus_left", + (KeyCode::Char('h'), KeyModifiers::empty()), + ), + ( + "navigate.focus_down", + (KeyCode::Char('j'), KeyModifiers::empty()), + ), + ( + "navigate.focus_up", + (KeyCode::Char('k'), KeyModifiers::empty()), + ), + ( + "navigate.focus_right", + (KeyCode::Char('l'), KeyModifiers::empty()), + ), + ( + "navigate.arrow_left", + (KeyCode::Left, KeyModifiers::empty()), + ), + ( + "navigate.arrow_right", + (KeyCode::Right, KeyModifiers::empty()), + ), + ("navigate.tab_next", (KeyCode::Tab, KeyModifiers::empty())), + ( + "navigate.tab_prev", + (KeyCode::BackTab, KeyModifiers::empty()), + ), + ( + "navigate.workspace_1", + (KeyCode::Char('1'), KeyModifiers::empty()), + ), + ( + "navigate.workspace_2", + (KeyCode::Char('2'), KeyModifiers::empty()), + ), + ( + "navigate.workspace_3", + (KeyCode::Char('3'), KeyModifiers::empty()), + ), + ( + "navigate.workspace_4", + (KeyCode::Char('4'), KeyModifiers::empty()), + ), + ( + "navigate.workspace_5", + (KeyCode::Char('5'), KeyModifiers::empty()), + ), + ( + "navigate.workspace_6", + (KeyCode::Char('6'), KeyModifiers::empty()), + ), + ( + "navigate.workspace_7", + (KeyCode::Char('7'), KeyModifiers::empty()), + ), + ( + "navigate.workspace_8", + (KeyCode::Char('8'), KeyModifiers::empty()), + ), + ( + "navigate.workspace_9", + (KeyCode::Char('9'), KeyModifiers::empty()), + ), + ("navigate.back", (KeyCode::Esc, KeyModifiers::empty())), + ] { + registry.reserve_if_unbound(BindingScope::Navigate, binding, field); + } + + let mut custom_commands = Vec::new(); + for (index, command) in self.keys.command.iter().enumerate() { + let key_field = format!("keys.command[{index}].key"); + let command_field = format!("keys.command[{index}].command"); + + if command.command.trim().is_empty() { + let diag = + format!("empty custom command: {command_field}; disabling custom command"); + warn!(message = %diag, "config diagnostic"); + diagnostics.push(diag); + continue; + } + + let Some(binding) = parse_key_combo(&command.key) else { + let diag = format!( + "invalid keybinding: {} = {:?}; disabling custom command", + key_field, command.key + ); + warn!(message = %diag, "config diagnostic"); + diagnostics.push(diag); + continue; + }; + + if let Some(first_field) = registry.conflict(BindingScope::Navigate, binding) { + let diag = format!( + "duplicate custom keybinding: {} conflicts with {}; disabling custom command", + key_field, first_field + ); + warn!(message = %diag, "config diagnostic"); + diagnostics.push(diag); + continue; + } + + registry.register(BindingScope::Navigate, binding, &key_field); + let action = match command.action_type { + CommandKeybindType::Shell => CustomCommandAction::Shell, + CommandKeybindType::Pane => CustomCommandAction::Pane, + }; + custom_commands.push(CustomCommandKeybind { + key: binding, + label: format_key_combo(binding), + command: command.command.clone(), + action, + }); + } + + let keybinds = Keybinds { + new_workspace: bindings[0].value, + new_workspace_label: bindings[0].label.clone(), + rename_workspace: bindings[1].value, + rename_workspace_label: bindings[1].label.clone(), + close_workspace: bindings[2].value, + close_workspace_label: bindings[2].label.clone(), + detach: optional_bindings[0].value, + detach_label: optional_bindings[0].label.clone(), + previous_workspace: optional_bindings[1].value, + previous_workspace_label: optional_bindings[1].label.clone(), + next_workspace: optional_bindings[2].value, + next_workspace_label: optional_bindings[2].label.clone(), + new_tab: bindings[3].value, + new_tab_label: bindings[3].label.clone(), + rename_tab: optional_bindings[3].value, + rename_tab_label: optional_bindings[3].label.clone(), + previous_tab: optional_bindings[4].value, + previous_tab_label: optional_bindings[4].label.clone(), + next_tab: optional_bindings[5].value, + next_tab_label: optional_bindings[5].label.clone(), + close_tab: optional_bindings[6].value, + close_tab_label: optional_bindings[6].label.clone(), + focus_pane_left: optional_bindings[7].value, + focus_pane_left_label: optional_bindings[7].label.clone(), + focus_pane_down: optional_bindings[8].value, + focus_pane_down_label: optional_bindings[8].label.clone(), + focus_pane_up: optional_bindings[9].value, + focus_pane_up_label: optional_bindings[9].label.clone(), + focus_pane_right: optional_bindings[10].value, + focus_pane_right_label: optional_bindings[10].label.clone(), + split_vertical: bindings[4].value, + split_vertical_label: bindings[4].label.clone(), + split_horizontal: bindings[5].value, + split_horizontal_label: bindings[5].label.clone(), + close_pane: bindings[6].value, + close_pane_label: bindings[6].label.clone(), + fullscreen: bindings[7].value, + fullscreen_label: bindings[7].label.clone(), + resize_mode: bindings[8].value, + resize_mode_label: bindings[8].label.clone(), + toggle_sidebar: bindings[9].value, + toggle_sidebar_label: bindings[9].label.clone(), + custom_commands, + }; + + (prefix_diag, prefix, diagnostics, keybinds) + } +} + +pub fn format_key_combo(binding: (KeyCode, KeyModifiers)) -> String { + let (code, modifiers) = binding; + let mut parts = Vec::new(); + if modifiers.contains(KeyModifiers::CONTROL) { + parts.push("ctrl".to_string()); + } + if modifiers.contains(KeyModifiers::ALT) { + parts.push("alt".to_string()); + } + if modifiers.contains(KeyModifiers::SHIFT) { + parts.push("shift".to_string()); + } + + let key = match code { + KeyCode::Char(' ') => "space".to_string(), + KeyCode::Char(c) => c.to_string(), + KeyCode::Enter => "enter".to_string(), + KeyCode::Esc => "esc".to_string(), + KeyCode::Tab => "tab".to_string(), + KeyCode::BackTab => "shift+tab".to_string(), + KeyCode::Backspace => "backspace".to_string(), + KeyCode::Left => "left".to_string(), + KeyCode::Right => "right".to_string(), + KeyCode::Up => "up".to_string(), + KeyCode::Down => "down".to_string(), + KeyCode::F(n) => format!("f{n}"), + _ => format!("{:?}", code).to_lowercase(), + }; + + if matches!(code, KeyCode::BackTab) { + return if parts.is_empty() { + key + } else { + format!("{}+tab", parts.join("+")) + }; + } + + parts.push(key); + parts.join("+") +} + +pub(super) fn parse_key_combo(s: &str) -> Option<(KeyCode, KeyModifiers)> { + let parts: Vec<&str> = s.split('+').collect(); + let mut modifiers = KeyModifiers::empty(); + let mut key_str: Option<&str> = None; + + for part in &parts { + let trimmed = part.trim(); + match trimmed.to_lowercase().as_str() { + "ctrl" | "control" => modifiers |= KeyModifiers::CONTROL, + "shift" => modifiers |= KeyModifiers::SHIFT, + "alt" | "meta" => modifiers |= KeyModifiers::ALT, + _ if trimmed.is_empty() => return None, + _ => { + if key_str.is_some() { + return None; + } + key_str = Some(trimmed); + } + } + } + + let key_str = key_str?; + + let lower = key_str.to_lowercase(); + let code = match lower.as_str() { + "space" | " " => KeyCode::Char(' '), + "enter" | "return" => KeyCode::Enter, + "esc" | "escape" => KeyCode::Esc, + "tab" => KeyCode::Tab, + "backspace" | "bs" => KeyCode::Backspace, + "left" => KeyCode::Left, + "right" => KeyCode::Right, + "up" => KeyCode::Up, + "down" => KeyCode::Down, + s if s.len() == 1 => { + let ch = key_str.chars().next().unwrap(); + if ch.is_ascii_uppercase() { + modifiers |= KeyModifiers::SHIFT; + KeyCode::Char(ch.to_ascii_lowercase()) + } else { + KeyCode::Char(ch) + } + } + s if s.starts_with('f') => s[1..].parse::<u8>().ok().map(KeyCode::F)?, + _ => return None, + }; + + Some((code, modifiers)) +} + +fn parse_key_combo_with_diagnostic( + s: &str, + field: &str, + fallback: (KeyCode, KeyModifiers), +) -> ((KeyCode, KeyModifiers), Option<String>) { + match parse_key_combo(s) { + Some(binding) => (binding, None), + None => { + let diag = format!("invalid keybinding: {field} = {s:?}; using fallback"); + warn!(message = %diag, "config diagnostic"); + (fallback, Some(diag)) + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::config::Config; + + #[test] + fn parse_simple_char() { + assert_eq!( + parse_key_combo("v"), + Some((KeyCode::Char('v'), KeyModifiers::empty())) + ); + } + + #[test] + fn parse_ctrl_combo() { + assert_eq!( + parse_key_combo("ctrl+b"), + Some((KeyCode::Char('b'), KeyModifiers::CONTROL)) + ); + } + + #[test] + fn parse_special_key() { + assert_eq!( + parse_key_combo("enter"), + Some((KeyCode::Enter, KeyModifiers::empty())) + ); + assert_eq!( + parse_key_combo("tab"), + Some((KeyCode::Tab, KeyModifiers::empty())) + ); + assert_eq!( + parse_key_combo("esc"), + Some((KeyCode::Esc, KeyModifiers::empty())) + ); + assert_eq!( + parse_key_combo("left"), + Some((KeyCode::Left, KeyModifiers::empty())) + ); + assert_eq!( + parse_key_combo("alt+right"), + Some((KeyCode::Right, KeyModifiers::ALT)) + ); + } + + #[test] + fn parse_ctrl_shift() { + assert_eq!( + parse_key_combo("ctrl+shift+a"), + Some(( + KeyCode::Char('a'), + KeyModifiers::CONTROL | KeyModifiers::SHIFT + )) + ); + } + + #[test] + fn parse_f_key() { + assert_eq!( + parse_key_combo("f5"), + Some((KeyCode::F(5), KeyModifiers::empty())) + ); + } + + #[test] + fn parse_punctuation_key() { + assert_eq!( + parse_key_combo("ctrl+`"), + Some((KeyCode::Char('`'), KeyModifiers::CONTROL)) + ); + } + + #[test] + fn uppercase_char_implies_shift() { + assert_eq!( + parse_key_combo("D"), + Some((KeyCode::Char('d'), KeyModifiers::SHIFT)) + ); + } + + #[test] + fn explicit_shift_and_uppercase_do_not_double_apply_shift() { + assert_eq!( + parse_key_combo("shift+D"), + Some((KeyCode::Char('d'), KeyModifiers::SHIFT)) + ); + } + + #[test] + fn invalid_keybinding_is_rejected() { + assert_eq!(parse_key_combo("ctrl+foo+bar"), None); + assert_eq!(parse_key_combo("ctrl+"), None); + } + + #[test] + fn default_keybinds_parse() { + let config = Config::default(); + let kb = config.keybinds(); + assert_eq!(kb.new_workspace.0, KeyCode::Char('n')); + assert_eq!( + kb.rename_workspace, + (KeyCode::Char('n'), KeyModifiers::SHIFT) + ); + assert_eq!( + kb.close_workspace, + (KeyCode::Char('d'), KeyModifiers::SHIFT) + ); + assert_eq!(kb.detach, None); + assert_eq!(kb.split_vertical.0, KeyCode::Char('v')); + assert_eq!(kb.split_horizontal.0, KeyCode::Char('-')); + assert_eq!(kb.close_pane.0, KeyCode::Char('x')); + assert_eq!(kb.fullscreen.0, KeyCode::Char('f')); + assert_eq!(kb.resize_mode.0, KeyCode::Char('r')); + assert_eq!(kb.toggle_sidebar.0, KeyCode::Char('b')); + assert!(kb.custom_commands.is_empty()); + } + + #[test] + fn custom_keybinds_from_toml() { + let toml = r#" +[keys] +prefix = "ctrl+a" +new_workspace = "c" +rename_workspace = "shift+r" +close_workspace = "ctrl+d" +split_vertical = "s" +split_horizontal = "shift+s" +close_pane = "ctrl+w" +fullscreen = "z" +resize_mode = "ctrl+r" +toggle_sidebar = "tab" +focus_pane_left = "alt+h" +focus_pane_right = "alt+right" +"#; + let config: Config = toml::from_str(toml).unwrap(); + let (code, mods) = config.prefix_key(); + assert_eq!(code, KeyCode::Char('a')); + assert_eq!(mods, KeyModifiers::CONTROL); + + let kb = config.keybinds(); + assert_eq!( + kb.new_workspace, + (KeyCode::Char('c'), KeyModifiers::empty()) + ); + assert_eq!( + kb.rename_workspace, + (KeyCode::Char('r'), KeyModifiers::SHIFT) + ); + assert_eq!( + kb.close_workspace, + (KeyCode::Char('d'), KeyModifiers::CONTROL) + ); + assert_eq!(kb.split_vertical.0, KeyCode::Char('s')); + assert_eq!( + kb.split_horizontal, + (KeyCode::Char('s'), KeyModifiers::SHIFT) + ); + assert_eq!(kb.close_pane, (KeyCode::Char('w'), KeyModifiers::CONTROL)); + assert_eq!(kb.fullscreen.0, KeyCode::Char('z')); + assert_eq!(kb.resize_mode, (KeyCode::Char('r'), KeyModifiers::CONTROL)); + assert_eq!(kb.toggle_sidebar, (KeyCode::Tab, KeyModifiers::empty())); + assert_eq!( + kb.focus_pane_left, + Some((KeyCode::Char('h'), KeyModifiers::ALT)) + ); + assert_eq!( + kb.focus_pane_right, + Some((KeyCode::Right, KeyModifiers::ALT)) + ); + assert_eq!(kb.focus_pane_down, None); + assert_eq!(kb.focus_pane_up, None); + } + + #[test] + fn uppercase_keybind_from_toml_flows_into_shift_combo() { + let toml = r#" +[keys] +close_pane = "X" +"#; + let config: Config = toml::from_str(toml).unwrap(); + let kb = config.keybinds(); + assert_eq!(kb.close_pane, (KeyCode::Char('x'), KeyModifiers::SHIFT)); + } + + #[test] + fn invalid_keybinding_produces_diagnostic_and_falls_back() { + let toml = r#" +[keys] +rename_workspace = "wat" +"#; + let config: Config = toml::from_str(toml).unwrap(); + let diagnostics = config.collect_diagnostics(); + let kb = config.keybinds(); + + assert!(diagnostics + .iter() + .any(|d| d.contains("keys.rename_workspace"))); + assert_eq!( + kb.rename_workspace, + (KeyCode::Char('n'), KeyModifiers::SHIFT) + ); + assert_eq!(kb.rename_workspace_label, "shift+n"); + } + + #[test] + fn duplicate_keybinding_produces_diagnostic_and_falls_back_later_binding() { + let toml = r#" +[keys] +new_workspace = "g" +rename_workspace = "g" +"#; + let config: Config = toml::from_str(toml).unwrap(); + let diagnostics = config.collect_diagnostics(); + let kb = config.keybinds(); + + assert!(diagnostics + .iter() + .any(|d| d.contains("duplicate keybinding"))); + assert_eq!( + kb.new_workspace, + (KeyCode::Char('g'), KeyModifiers::empty()) + ); + assert_eq!( + kb.rename_workspace, + (KeyCode::Char('n'), KeyModifiers::SHIFT) + ); + assert_eq!(kb.rename_workspace_label, "shift+n"); + } + + #[test] + fn duplicate_optional_keybinding_is_disabled_with_diagnostic() { + let toml = r#" +[keys] +new_workspace = "g" +rename_tab = "g" +"#; + let config: Config = toml::from_str(toml).unwrap(); + let diagnostics = config.collect_diagnostics(); + let kb = config.keybinds(); + + assert!(diagnostics + .iter() + .any(|d| d.contains("keys.rename_tab") && d.contains("disabling binding"))); + assert_eq!( + kb.new_workspace, + (KeyCode::Char('g'), KeyModifiers::empty()) + ); + assert_eq!(kb.rename_tab, None); + } + + #[test] + fn custom_command_keybinds_parse_from_toml() { + let toml = r#" +[[keys.command]] +key = "g" +command = "echo hi" +"#; + let config: Config = toml::from_str(toml).unwrap(); + let kb = config.keybinds(); + + assert_eq!(kb.custom_commands.len(), 1); + assert_eq!( + kb.custom_commands[0].key, + (KeyCode::Char('g'), KeyModifiers::empty()) + ); + assert_eq!(kb.custom_commands[0].label, "g"); + assert_eq!(kb.custom_commands[0].command, "echo hi"); + assert_eq!(kb.custom_commands[0].action, CustomCommandAction::Shell); + } + + #[test] + fn pane_custom_command_keybinds_parse_from_toml() { + let toml = r#" +[[keys.command]] +key = "g" +type = "pane" +command = "lazygit" +"#; + let config: Config = toml::from_str(toml).unwrap(); + let kb = config.keybinds(); + + assert_eq!(kb.custom_commands.len(), 1); + assert_eq!(kb.custom_commands[0].action, CustomCommandAction::Pane); + } + + #[test] + fn custom_command_conflicting_with_builtin_is_disabled_with_diagnostic() { + let toml = r#" +[keys] +new_workspace = "g" + +[[keys.command]] +key = "g" +command = "echo hi" +"#; + let config: Config = toml::from_str(toml).unwrap(); + let diagnostics = config.collect_diagnostics(); + let kb = config.keybinds(); + + assert!(diagnostics.iter().any(|d| { + d.contains("duplicate custom keybinding") + && d.contains("keys.command[0].key") + && d.contains("keys.new_workspace") + })); + assert!(kb.custom_commands.is_empty()); + } + + #[test] + fn custom_command_conflicting_with_reserved_navigate_key_is_disabled_with_diagnostic() { + let toml = r#" +[[keys.command]] +key = "q" +command = "echo hi" +"#; + let config: Config = toml::from_str(toml).unwrap(); + let diagnostics = config.collect_diagnostics(); + let kb = config.keybinds(); + + assert!(diagnostics.iter().any(|d| { + d.contains("duplicate custom keybinding") + && d.contains("keys.command[0].key") + && d.contains("navigate.quit") + })); + assert!(kb.custom_commands.is_empty()); + } + + #[test] + fn live_keybinds_reject_invalid_keybinding() { + let config: Config = toml::from_str( + r#" +[keys] +rename_workspace = "wat" +"#, + ) + .unwrap(); + + let diagnostics = config.live_keybinds().unwrap_err(); + assert!(diagnostics + .iter() + .any(|d| d.contains("keys.rename_workspace"))); + } + + #[test] + fn live_keybinds_ignore_non_key_diagnostics() { + let config: Config = toml::from_str( + r#" +[keys] +new_workspace = "g" + +[ui.sound] +done_path = "sounds/missing.mp3" +"#, + ) + .unwrap(); + + let live = config.live_keybinds().unwrap(); + assert_eq!( + live.keybinds.new_workspace, + (KeyCode::Char('g'), KeyModifiers::empty()) + ); + } +} diff --git a/src/config/model.rs b/src/config/model.rs new file mode 100644 index 00000000..70eede5a --- /dev/null +++ b/src/config/model.rs @@ -0,0 +1,216 @@ +use serde::Deserialize; + +use super::{CommandKeybindConfig, SoundConfig, ThemeConfig, DEFAULT_SCROLLBACK_LIMIT_BYTES}; + +#[derive(Debug, Clone, Deserialize)] +#[serde(default)] +pub struct ToastConfig { + pub enabled: bool, +} + +#[derive(Debug, Default, Deserialize)] +#[serde(default)] +pub struct Config { + pub onboarding: Option<bool>, + pub theme: ThemeConfig, + pub keys: KeysConfig, + pub ui: UiConfig, + pub advanced: AdvancedConfig, +} + +#[derive(Debug)] +pub struct LoadedConfig { + pub config: Config, + pub diagnostics: Vec<String>, +} + +#[derive(Debug, Deserialize)] +#[serde(default)] +pub struct KeysConfig { + /// Prefix key to toggle navigate mode (e.g. "ctrl+b", "f12", "esc"). + pub prefix: String, + /// Create a new workspace. Default: "n" + pub new_workspace: String, + /// Rename the selected workspace. Default: "shift+n" + pub rename_workspace: String, + /// Close the selected workspace. Default: "shift+d" + pub close_workspace: String, + /// Optional explicit detach shortcut in server/client mode. Unset by default. + pub detach: String, + /// Select the previous workspace. Unset by default. + pub previous_workspace: String, + /// Select the next workspace. Unset by default. + pub next_workspace: String, + /// Create a new tab in the active workspace. Default: "c" + pub new_tab: String, + /// Rename the active tab. Unset by default. + pub rename_tab: String, + /// Select the previous tab. Unset by default. + pub previous_tab: String, + /// Select the next tab. Unset by default. + pub next_tab: String, + /// Close the active tab. Unset by default. + pub close_tab: String, + /// Focus the pane to the left in terminal mode. Unset by default. + pub focus_pane_left: String, + /// Focus the pane below in terminal mode. Unset by default. + pub focus_pane_down: String, + /// Focus the pane above in terminal mode. Unset by default. + pub focus_pane_up: String, + /// Focus the pane to the right in terminal mode. Unset by default. + pub focus_pane_right: String, + /// Split pane vertically (side by side). Default: "v" + pub split_vertical: String, + /// Split pane horizontally (stacked). Default: "-" + pub split_horizontal: String, + /// Close the focused pane. Default: "x" + pub close_pane: String, + /// Toggle fullscreen for the focused pane. Default: "f" + pub fullscreen: String, + /// Enter resize mode. Default: "r" + pub resize_mode: String, + /// Toggle sidebar collapse. Default: "b" + pub toggle_sidebar: String, + /// Prefix-mode custom command bindings. + pub command: Vec<CommandKeybindConfig>, +} + +#[derive(Debug, Deserialize)] +#[serde(default)] +pub struct UiConfig { + pub sidebar_width: u16, + /// Ask for confirmation before closing a workspace. Default: true. + pub confirm_close: bool, + /// Accent color for highlights, borders, and navigation UI. + /// Accepts hex (#89b4fa), named colors (cyan, blue), or RGB (rgb(137,180,250)). + pub accent: String, + /// Optional visual toast notifications for background workspace events. + pub toast: ToastConfig, + /// Play sounds when agents change state in background workspaces. + pub sound: SoundConfig, +} + +#[derive(Debug, Deserialize)] +#[serde(default)] +pub struct AdvancedConfig { + /// Allow launching herdr inside an existing herdr pane. Default: false. + pub allow_nested: bool, + /// Maximum scrollback buffer size in bytes retained per pane terminal. Default: 10000000. + #[serde(alias = "scrollback_lines")] + pub scrollback_limit_bytes: usize, +} + +impl Default for KeysConfig { + fn default() -> Self { + Self { + prefix: "ctrl+b".into(), + new_workspace: "n".into(), + rename_workspace: "shift+n".into(), + close_workspace: "shift+d".into(), + detach: "".into(), + previous_workspace: "".into(), + next_workspace: "".into(), + new_tab: "c".into(), + rename_tab: "".into(), + previous_tab: "".into(), + next_tab: "".into(), + close_tab: "".into(), + focus_pane_left: "".into(), + focus_pane_down: "".into(), + focus_pane_up: "".into(), + focus_pane_right: "".into(), + split_vertical: "v".into(), + split_horizontal: "-".into(), + close_pane: "x".into(), + fullscreen: "f".into(), + resize_mode: "r".into(), + toggle_sidebar: "b".into(), + command: Vec::new(), + } + } +} + +impl Default for UiConfig { + fn default() -> Self { + Self { + sidebar_width: 26, + confirm_close: true, + accent: "cyan".into(), + toast: ToastConfig::default(), + sound: SoundConfig::default(), + } + } +} + +impl Default for ToastConfig { + fn default() -> Self { + Self { enabled: false } + } +} + +impl Default for AdvancedConfig { + fn default() -> Self { + Self { + allow_nested: false, + scrollback_limit_bytes: DEFAULT_SCROLLBACK_LIMIT_BYTES, + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn toast_config_parses() { + let toml = r#" +[ui.toast] +enabled = true +"#; + let config: Config = toml::from_str(toml).unwrap(); + assert!(config.ui.toast.enabled); + } + + #[test] + fn missing_onboarding_shows_setup() { + let config = Config::default(); + assert!(config.should_show_onboarding()); + } + + #[test] + fn onboarding_false_skips_setup() { + let config: Config = toml::from_str("onboarding = false").unwrap(); + assert!(!config.should_show_onboarding()); + } + + #[test] + fn advanced_defaults_include_scrollback_limit_bytes() { + let config = Config::default(); + assert_eq!( + config.advanced.scrollback_limit_bytes, + DEFAULT_SCROLLBACK_LIMIT_BYTES + ); + } + + #[test] + fn advanced_config_parses() { + let toml = r#" +[advanced] +allow_nested = true +scrollback_limit_bytes = 12345 +"#; + let config: Config = toml::from_str(toml).unwrap(); + assert!(config.advanced.allow_nested); + assert_eq!(config.advanced.scrollback_limit_bytes, 12345); + } + + #[test] + fn advanced_legacy_scrollback_lines_alias_parses() { + let toml = r#" +[advanced] +scrollback_lines = 12345 +"#; + let config: Config = toml::from_str(toml).unwrap(); + assert_eq!(config.advanced.scrollback_limit_bytes, 12345); + } +} diff --git a/src/config/sound.rs b/src/config/sound.rs new file mode 100644 index 00000000..063a521b --- /dev/null +++ b/src/config/sound.rs @@ -0,0 +1,249 @@ +use std::path::PathBuf; + +use serde::Deserialize; + +use crate::detect::Agent; + +use super::io::resolve_config_relative_path; + +#[derive(Debug, Clone, Deserialize)] +#[serde(default)] +pub struct SoundConfig { + pub enabled: bool, + /// Optional mp3 file path used for all notification sounds. + /// Relative paths are resolved from the config file's directory. + pub path: Option<PathBuf>, + /// Optional mp3 file path for "done" notifications. + /// Relative paths are resolved from the config file's directory. + pub done_path: Option<PathBuf>, + /// Optional mp3 file path for "request" notifications. + /// Relative paths are resolved from the config file's directory. + pub request_path: Option<PathBuf>, + pub agents: AgentSoundOverrides, +} + +#[derive(Debug, Clone, Deserialize)] +#[serde(default)] +pub struct AgentSoundOverrides { + pub pi: AgentSoundSetting, + pub claude: AgentSoundSetting, + pub codex: AgentSoundSetting, + pub gemini: AgentSoundSetting, + pub cursor: AgentSoundSetting, + pub cline: AgentSoundSetting, + pub open_code: AgentSoundSetting, + pub github_copilot: AgentSoundSetting, + pub kimi: AgentSoundSetting, + pub droid: AgentSoundSetting, + pub amp: AgentSoundSetting, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum AgentSoundSetting { + #[default] + Default, + On, + Off, +} + +impl SoundConfig { + pub fn allows(&self, agent: Option<Agent>) -> bool { + if !self.enabled { + return false; + } + + !matches!(self.agents.for_agent(agent), AgentSoundSetting::Off) + } + + pub fn path_for(&self, sound: crate::sound::Sound) -> Option<PathBuf> { + let path = match sound { + crate::sound::Sound::Done => self.done_path.as_ref().or(self.path.as_ref()), + crate::sound::Sound::Request => self.request_path.as_ref().or(self.path.as_ref()), + }?; + + Some(resolve_config_relative_path(path)) + } + + pub fn diagnostics(&self) -> Vec<String> { + let mut diagnostics = Vec::new(); + for (field, path) in [ + ("ui.sound.path", self.path.as_ref()), + ("ui.sound.done_path", self.done_path.as_ref()), + ("ui.sound.request_path", self.request_path.as_ref()), + ] { + let Some(path) = path else { + continue; + }; + + let resolved = resolve_config_relative_path(path); + if resolved + .extension() + .and_then(|ext| ext.to_str()) + .is_none_or(|ext: &str| !ext.eq_ignore_ascii_case("mp3")) + { + diagnostics.push(format!( + "unsupported sound file format: {field} = {} resolves to {}; expected an mp3 file; using default sound", + path.display(), + resolved.display() + )); + continue; + } + + if !resolved.exists() { + diagnostics.push(format!( + "missing sound file: {field} = {} resolves to {}; using default sound", + path.display(), + resolved.display() + )); + } else if !resolved.is_file() { + diagnostics.push(format!( + "invalid sound file: {field} = {} resolves to {}; using default sound", + path.display(), + resolved.display() + )); + } + } + diagnostics + } +} + +impl AgentSoundOverrides { + pub fn for_agent(&self, agent: Option<Agent>) -> AgentSoundSetting { + match agent { + Some(Agent::Pi) => self.pi, + Some(Agent::Claude) => self.claude, + Some(Agent::Codex) => self.codex, + Some(Agent::Gemini) => self.gemini, + Some(Agent::Cursor) => self.cursor, + Some(Agent::Cline) => self.cline, + Some(Agent::OpenCode) => self.open_code, + Some(Agent::GithubCopilot) => self.github_copilot, + Some(Agent::Kimi) => self.kimi, + Some(Agent::Droid) => self.droid, + Some(Agent::Amp) => self.amp, + None => AgentSoundSetting::Default, + } + } +} + +impl Default for SoundConfig { + fn default() -> Self { + Self { + enabled: true, + path: None, + done_path: None, + request_path: None, + agents: AgentSoundOverrides::default(), + } + } +} + +impl Default for AgentSoundOverrides { + fn default() -> Self { + Self { + pi: AgentSoundSetting::Default, + claude: AgentSoundSetting::Default, + codex: AgentSoundSetting::Default, + gemini: AgentSoundSetting::Default, + cursor: AgentSoundSetting::Default, + cline: AgentSoundSetting::Default, + open_code: AgentSoundSetting::Default, + github_copilot: AgentSoundSetting::Default, + kimi: AgentSoundSetting::Default, + droid: AgentSoundSetting::Off, + amp: AgentSoundSetting::Default, + } + } +} + +#[cfg(test)] +mod tests { + use std::path::PathBuf; + + use super::*; + use crate::config::{config_path, Config}; + + #[test] + fn sound_table_config_parses() { + let toml = r#" +[ui.sound] +enabled = true +path = "sounds/all.mp3" +done_path = "sounds/done.mp3" +request_path = "/tmp/request.mp3" + +[ui.sound.agents] +droid = "off" +claude = "on" +"#; + let config: Config = toml::from_str(toml).unwrap(); + assert!(config.ui.sound.enabled); + assert_eq!(config.ui.sound.path, Some(PathBuf::from("sounds/all.mp3"))); + assert_eq!( + config.ui.sound.done_path, + Some(PathBuf::from("sounds/done.mp3")) + ); + assert_eq!( + config.ui.sound.request_path, + Some(PathBuf::from("/tmp/request.mp3")) + ); + assert_eq!(config.ui.sound.agents.droid, AgentSoundSetting::Off); + assert_eq!(config.ui.sound.agents.claude, AgentSoundSetting::On); + assert_eq!(config.ui.sound.agents.pi, AgentSoundSetting::Default); + } + + #[test] + fn sound_path_resolution_prefers_specific_over_global() { + let config: Config = toml::from_str( + r#" +[ui.sound] +path = "sounds/all.mp3" +done_path = "sounds/done.mp3" +"#, + ) + .unwrap(); + + let config_root = config_path().parent().unwrap().to_path_buf(); + assert_eq!( + config.ui.sound.path_for(crate::sound::Sound::Done), + Some(config_root.join("sounds/done.mp3")) + ); + assert_eq!( + config.ui.sound.path_for(crate::sound::Sound::Request), + Some(config_root.join("sounds/all.mp3")) + ); + } + + #[test] + fn missing_sound_file_produces_diagnostic() { + let config: Config = toml::from_str( + r#" +[ui.sound] +done_path = "sounds/missing.mp3" +"#, + ) + .unwrap(); + + let diagnostics = config.collect_diagnostics(); + assert!(diagnostics.iter().any( + |diag| diag.contains("ui.sound.done_path") && diag.contains("using default sound") + )); + } + + #[test] + fn non_mp3_sound_file_produces_diagnostic() { + let config: Config = toml::from_str( + r#" +[ui.sound] +path = "sounds/notification.wav" +"#, + ) + .unwrap(); + + let diagnostics = config.collect_diagnostics(); + assert!(diagnostics.iter().any(|diag| { + diag.contains("ui.sound.path") && diag.contains("expected an mp3 file") + })); + } +} diff --git a/src/config/theme.rs b/src/config/theme.rs new file mode 100644 index 00000000..9d641862 --- /dev/null +++ b/src/config/theme.rs @@ -0,0 +1,163 @@ +use serde::Deserialize; +use tracing::warn; + +/// Theme configuration: pick a built-in or override individual tokens. +/// +/// ```toml +/// [theme] +/// name = "tokyo-night" # built-in: catppuccin, tokyo-night, dracula, nord, etc. +/// +/// [theme.custom] # override individual tokens on top of the base +/// accent = "#f5c2e7" +/// red = "#ff6188" +/// ``` +#[derive(Debug, Default, Deserialize)] +#[serde(default)] +pub struct ThemeConfig { + /// Built-in theme name. Default: "catppuccin". + pub name: Option<String>, + /// Custom overrides — applied on top of the selected base theme. + pub custom: Option<CustomThemeColors>, +} + +/// Per-token color overrides. All fields optional — only set what you want to change. +#[derive(Debug, Default, Deserialize)] +#[serde(default)] +pub struct CustomThemeColors { + pub accent: Option<String>, + pub panel_bg: Option<String>, + pub surface0: Option<String>, + pub surface1: Option<String>, + pub surface_dim: Option<String>, + pub overlay0: Option<String>, + pub overlay1: Option<String>, + pub text: Option<String>, + pub subtext0: Option<String>, + pub mauve: Option<String>, + pub green: Option<String>, + pub yellow: Option<String>, + pub red: Option<String>, + pub blue: Option<String>, + pub teal: Option<String>, + pub peach: Option<String>, +} + +/// Parse a color string into a ratatui Color. +/// Supports: hex (#rrggbb, #rgb), named colors, rgb(r,g,b), and reset aliases. +pub fn parse_color(s: &str) -> ratatui::style::Color { + use ratatui::style::Color; + let s = s.trim().to_lowercase(); + + match s.as_str() { + "reset" | "default" | "none" | "transparent" => return Color::Reset, + _ => {} + } + + if let Some(hex) = s.strip_prefix('#') { + if hex.len() == 6 { + if let (Ok(r), Ok(g), Ok(b)) = ( + u8::from_str_radix(&hex[0..2], 16), + u8::from_str_radix(&hex[2..4], 16), + u8::from_str_radix(&hex[4..6], 16), + ) { + return Color::Rgb(r, g, b); + } + } else if hex.len() == 3 { + let chars: Vec<u8> = hex + .chars() + .filter_map(|c| u8::from_str_radix(&c.to_string(), 16).ok()) + .collect(); + if chars.len() == 3 { + return Color::Rgb(chars[0] * 17, chars[1] * 17, chars[2] * 17); + } + } + } + + if let Some(inner) = s.strip_prefix("rgb(").and_then(|s| s.strip_suffix(')')) { + let parts: Vec<&str> = inner.split(',').collect(); + if parts.len() == 3 { + if let (Ok(r), Ok(g), Ok(b)) = ( + parts[0].trim().parse::<u8>(), + parts[1].trim().parse::<u8>(), + parts[2].trim().parse::<u8>(), + ) { + return Color::Rgb(r, g, b); + } + } + } + + match s.as_str() { + "black" => Color::Black, + "red" => Color::Red, + "green" => Color::Green, + "yellow" => Color::Yellow, + "blue" => Color::Blue, + "magenta" | "purple" => Color::Magenta, + "cyan" => Color::Cyan, + "white" => Color::White, + "gray" | "grey" => Color::Gray, + "darkgray" | "darkgrey" => Color::DarkGray, + "lightred" => Color::LightRed, + "lightgreen" => Color::LightGreen, + "lightyellow" => Color::LightYellow, + "lightblue" => Color::LightBlue, + "lightmagenta" => Color::LightMagenta, + "lightcyan" => Color::LightCyan, + _ => { + warn!(color = s, "unknown color, defaulting to cyan"); + Color::Cyan + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::config::Config; + + #[test] + fn theme_name_parses() { + let toml = r#" +[theme] +name = "dracula" +"#; + let config: Config = toml::from_str(toml).unwrap(); + assert_eq!(config.theme.name.as_deref(), Some("dracula")); + } + + #[test] + fn parse_color_accepts_reset_aliases() { + use ratatui::style::Color; + + for value in ["reset", "default", "none", "transparent"] { + assert_eq!(parse_color(value), Color::Reset, "value: {value}"); + } + } + + #[test] + fn theme_custom_overrides_parse() { + let toml = r##" +[theme] +name = "nord" + +[theme.custom] +panel_bg = "#1e1e2e" +accent = "#ff79c6" +red = "rgb(255, 85, 85)" +"##; + let config: Config = toml::from_str(toml).unwrap(); + assert_eq!(config.theme.name.as_deref(), Some("nord")); + let custom = config.theme.custom.as_ref().unwrap(); + assert_eq!(custom.panel_bg.as_deref(), Some("#1e1e2e")); + assert_eq!(custom.accent.as_deref(), Some("#ff79c6")); + assert_eq!(custom.red.as_deref(), Some("rgb(255, 85, 85)")); + assert!(custom.green.is_none()); + } + + #[test] + fn theme_defaults_when_missing() { + let config: Config = toml::from_str("").unwrap(); + assert!(config.theme.name.is_none()); + assert!(config.theme.custom.is_none()); + } +} diff --git a/src/detect.rs b/src/detect.rs index df5bbae4..55a7b2a5 100644 --- a/src/detect.rs +++ b/src/detect.rs @@ -352,10 +352,6 @@ fn detect_kimi(content: &str) -> AgentState { fn detect_droid(content: &str) -> AgentState { let lower = content.to_lowercase(); - if is_droid_mission_control(content, &lower) { - return AgentState::Idle; - } - // Blocked: EXECUTE approval prompt with selection UI chrome // Primary (AND): structural keyword + chrome text = certain let has_execute = content.contains("EXECUTE"); @@ -385,20 +381,6 @@ fn detect_droid(content: &str) -> AgentState { AgentState::Idle } -fn is_droid_mission_control(content: &str, lower_content: &str) -> bool { - let has_header = lower_content.contains("mission control"); - let has_active_feature = lower_content.contains("active feature"); - let has_feature_summary = lower_content.contains("features "); - let has_mission_metrics = lower_content.contains("time ") - && lower_content.contains("input ") - && lower_content.contains("output "); - - content.contains("⛬") - && has_header - && has_active_feature - && (has_feature_summary || has_mission_metrics) -} - /// Amp (Sourcegraph) detection. /// /// Blocked approval prompts use a shared footer with options like @@ -1133,24 +1115,6 @@ mod tests { } #[test] - fn droid_mission_control_is_idle_even_with_stop_chrome() { - let screen = concat!( - "⛬ Mission Control ~/Projects/herdr-worktrees/persistence TIME 22h 40m · Input 12.6M · Cached 129.7M · Output 471.5K\n", - "● RUNNING\n", - "Active Feature fix-scrutiny-misc-followups\n", - "Features 25/28\n", - "(Press ESC to stop)\n", - ); - assert_eq!(detect_droid(screen), AgentState::Idle); - } - - #[test] - fn droid_leaves_mission_control_and_returns_to_working() { - let screen = "> how u doin\n\n⠴ Thinking... (Press ESC to stop)\n\nAuto (Off)"; - assert_eq!(detect_droid(screen), AgentState::Working); - } - - #[test] fn droid_braille_spinner_detected() { assert!(has_braille_spinner("⠴ Thinking...")); assert!(has_braille_spinner(" ⠧ Loading...")); diff --git a/src/events.rs b/src/events.rs index dd433d55..1d90ac32 100644 --- a/src/events.rs +++ b/src/events.rs @@ -37,7 +37,7 @@ pub enum AppEvent { agent_label: String, known_agent: Option<Agent>, }, - /// A new version was downloaded and installed. Restart to use it. + /// A new version is available and ready to install explicitly. UpdateReady { version: String }, /// A pane child emitted a valid OSC 52 clipboard write. The main loop /// re-emits it through herdr's own clipboard writer. diff --git a/src/input/encode.rs b/src/input/encode.rs index 6599b3ba..81454ddc 100644 --- a/src/input/encode.rs +++ b/src/input/encode.rs @@ -442,3 +442,366 @@ fn encode_f_key(n: u8) -> Vec<u8> { _ => vec![], } } + +#[cfg(test)] +mod tests { + use crossterm::event::{KeyCode, KeyEvent, KeyModifiers}; + + use super::*; + use crate::input::parse_terminal_key_sequence; + + fn assert_terminal_key_eq( + actual: TerminalKey, + code: KeyCode, + modifiers: KeyModifiers, + kind: crossterm::event::KeyEventKind, + shifted_codepoint: Option<u32>, + ) { + assert_eq!(actual.code, code); + assert_eq!(actual.modifiers, modifiers); + assert_eq!(actual.kind, kind); + assert_eq!(actual.shifted_codepoint, shifted_codepoint); + } + + #[test] + fn legacy_enter() { + let key = KeyEvent::new(KeyCode::Enter, KeyModifiers::empty()); + assert_eq!(encode_key(key, KeyboardProtocol::Legacy), vec![b'\r']); + } + + #[test] + fn legacy_ctrl_c() { + let key = KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL); + assert_eq!(encode_key(key, KeyboardProtocol::Legacy), vec![3]); + } + + #[test] + fn legacy_shift_enter_is_just_cr() { + let key = KeyEvent::new(KeyCode::Enter, KeyModifiers::SHIFT); + assert_eq!(encode_key(key, KeyboardProtocol::Legacy), vec![b'\r']); + } + + #[test] + fn legacy_alt_up() { + let key = KeyEvent::new(KeyCode::Up, KeyModifiers::ALT); + assert_eq!(encode_key(key, KeyboardProtocol::Legacy), b"\x1b[1;3A"); + } + + #[test] + fn legacy_shift_right() { + let key = KeyEvent::new(KeyCode::Right, KeyModifiers::SHIFT); + assert_eq!(encode_key(key, KeyboardProtocol::Legacy), b"\x1b[1;2C"); + } + + #[test] + fn legacy_ctrl_left() { + let key = KeyEvent::new(KeyCode::Left, KeyModifiers::CONTROL); + assert_eq!(encode_key(key, KeyboardProtocol::Legacy), b"\x1b[1;5D"); + } + + #[test] + fn legacy_ctrl_shift_end() { + let key = KeyEvent::new(KeyCode::End, KeyModifiers::CONTROL | KeyModifiers::SHIFT); + assert_eq!(encode_key(key, KeyboardProtocol::Legacy), b"\x1b[1;6F"); + } + + #[test] + fn legacy_alt_delete() { + let key = KeyEvent::new(KeyCode::Delete, KeyModifiers::ALT); + assert_eq!(encode_key(key, KeyboardProtocol::Legacy), b"\x1b[3;3~"); + } + + #[test] + fn legacy_shift_f5() { + let key = KeyEvent::new(KeyCode::F(5), KeyModifiers::SHIFT); + assert_eq!(encode_key(key, KeyboardProtocol::Legacy), b"\x1b[15;2~"); + } + + #[test] + fn legacy_alt_char_still_esc_prefix() { + let key = KeyEvent::new(KeyCode::Char('a'), KeyModifiers::ALT); + assert_eq!(encode_key(key, KeyboardProtocol::Legacy), b"\x1ba"); + } + + #[test] + fn application_cursor_keys_use_ss3_sequences() { + assert_eq!(encode_cursor_key(KeyCode::Up, true), b"\x1bOA"); + assert_eq!(encode_cursor_key(KeyCode::Down, true), b"\x1bOB"); + } + + #[test] + fn normal_cursor_keys_use_csi_sequences() { + assert_eq!(encode_cursor_key(KeyCode::Up, false), b"\x1b[A"); + assert_eq!(encode_cursor_key(KeyCode::Down, false), b"\x1b[B"); + } + + #[test] + fn sgr_mouse_scroll_encodes_wheel_button_and_coordinates() { + let encoded = encode_mouse_scroll( + crossterm::event::MouseEventKind::ScrollDown, + 4, + 6, + KeyModifiers::SHIFT, + MouseProtocolEncoding::Sgr, + ) + .expect("mouse scroll should encode"); + + assert_eq!(encoded, b"\x1b[<69;5;7M"); + } + + #[test] + fn sgr_mouse_release_keeps_button_code() { + let encoded = encode_mouse_button( + crossterm::event::MouseEventKind::Up(crossterm::event::MouseButton::Left), + 11, + 9, + KeyModifiers::empty(), + MouseProtocolEncoding::Sgr, + ) + .expect("mouse release should encode"); + + assert_eq!(encoded, b"\x1b[<0;12;10m"); + } + + #[test] + fn kitty_shift_enter() { + let key = KeyEvent::new(KeyCode::Enter, KeyModifiers::SHIFT); + assert_eq!( + encode_key(key, KeyboardProtocol::Kitty { flags: 1 }), + b"\x1b[13;2u" + ); + } + + #[test] + fn kitty_ctrl_shift_a() { + let key = KeyEvent::new( + KeyCode::Char('a'), + KeyModifiers::CONTROL | KeyModifiers::SHIFT, + ); + assert_eq!( + encode_key(key, KeyboardProtocol::Kitty { flags: 1 }), + b"\x1b[97;6u" + ); + } + + #[test] + fn kitty_shift_uppercase_letter_sends_text() { + let key = KeyEvent::new(KeyCode::Char('L'), KeyModifiers::SHIFT); + assert_eq!(encode_key(key, KeyboardProtocol::Kitty { flags: 1 }), b"L"); + } + + #[test] + fn kitty_shift_uppercase_letter_ignores_alternate_key_reporting_for_text() { + let key = KeyEvent::new(KeyCode::Char('L'), KeyModifiers::SHIFT); + assert_eq!(encode_key(key, KeyboardProtocol::Kitty { flags: 7 }), b"L"); + } + + #[test] + fn kitty_shift_lowercase_letter_sends_uppercase_text() { + let key = KeyEvent::new(KeyCode::Char('l'), KeyModifiers::SHIFT); + assert_eq!(encode_key(key, KeyboardProtocol::Kitty { flags: 1 }), b"L"); + } + + #[test] + fn kitty_alt_shift_uppercase_letter_uses_base_codepoint() { + let key = KeyEvent::new(KeyCode::Char('L'), KeyModifiers::ALT | KeyModifiers::SHIFT); + assert_eq!( + encode_key(key, KeyboardProtocol::Kitty { flags: 1 }), + b"\x1b[108;4u" + ); + } + + #[test] + fn kitty_ctrl_shift_uppercase_letter_uses_base_codepoint() { + let key = KeyEvent::new( + KeyCode::Char('L'), + KeyModifiers::CONTROL | KeyModifiers::SHIFT, + ); + assert_eq!( + encode_key(key, KeyboardProtocol::Kitty { flags: 1 }), + b"\x1b[108;6u" + ); + } + + #[test] + fn legacy_shift_uppercase_letter_stays_uppercase() { + let key = KeyEvent::new(KeyCode::Char('L'), KeyModifiers::SHIFT); + assert_eq!(encode_key(key, KeyboardProtocol::Legacy), b"L"); + } + + #[test] + fn kitty_alt_enter() { + let key = KeyEvent::new(KeyCode::Enter, KeyModifiers::ALT); + assert_eq!( + encode_key(key, KeyboardProtocol::Kitty { flags: 1 }), + b"\x1b[13;3u" + ); + } + + #[test] + fn kitty_plain_ctrl_c_uses_csi_u() { + let key = KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL); + assert_eq!( + encode_key(key, KeyboardProtocol::Kitty { flags: 1 }), + b"\x1b[99;5u" + ); + } + + #[test] + fn kitty_plain_ctrl_c_includes_press_event_when_requested() { + let key = KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL); + assert_eq!( + encode_key(key, KeyboardProtocol::Kitty { flags: 3 }), + b"\x1b[99;5:1u" + ); + } + + #[test] + fn kitty_unmodified_uses_legacy() { + let key = KeyEvent::new(KeyCode::Char('a'), KeyModifiers::empty()); + assert_eq!(encode_key(key, KeyboardProtocol::Kitty { flags: 1 }), b"a"); + } + + #[test] + fn kitty_shift_tab() { + let key = KeyEvent::new(KeyCode::Tab, KeyModifiers::SHIFT); + assert_eq!( + encode_key(key, KeyboardProtocol::Kitty { flags: 1 }), + b"\x1b[9;2u" + ); + } + + #[test] + fn kitty_ctrl_shift_enter() { + let key = KeyEvent::new(KeyCode::Enter, KeyModifiers::CONTROL | KeyModifiers::SHIFT); + assert_eq!( + encode_key(key, KeyboardProtocol::Kitty { flags: 1 }), + b"\x1b[13;6u" + ); + } + + #[test] + fn kitty_repeat_event_type_is_encoded_when_requested() { + let key = KeyEvent::new_with_kind( + KeyCode::Enter, + KeyModifiers::SHIFT, + crossterm::event::KeyEventKind::Repeat, + ); + assert_eq!( + encode_key(key, KeyboardProtocol::Kitty { flags: 3 }), + b"\x1b[13;2:2u" + ); + } + + #[test] + fn kitty_shift_letter_release_does_not_emit_text() { + let key = KeyEvent::new_with_kind( + KeyCode::Char('L'), + KeyModifiers::SHIFT, + crossterm::event::KeyEventKind::Release, + ); + assert_eq!(encode_key(key, KeyboardProtocol::Kitty { flags: 7 }), b""); + } + + #[test] + fn kitty_shifted_symbol_sends_text() { + let key = TerminalKey::new(KeyCode::Char('1'), KeyModifiers::SHIFT) + .with_shifted_codepoint('!' as u32); + assert_eq!( + encode_terminal_key(key, KeyboardProtocol::Kitty { flags: 7 }), + b"!" + ); + } + + #[test] + fn legacy_modified_special_roundtrip_matrix() { + let cases = [ + KeyEvent::new(KeyCode::Up, KeyModifiers::ALT), + KeyEvent::new(KeyCode::Down, KeyModifiers::ALT), + KeyEvent::new(KeyCode::Right, KeyModifiers::SHIFT), + KeyEvent::new(KeyCode::Left, KeyModifiers::CONTROL), + KeyEvent::new(KeyCode::Home, KeyModifiers::CONTROL), + KeyEvent::new(KeyCode::End, KeyModifiers::CONTROL | KeyModifiers::SHIFT), + KeyEvent::new(KeyCode::PageUp, KeyModifiers::ALT), + KeyEvent::new(KeyCode::PageDown, KeyModifiers::CONTROL), + KeyEvent::new(KeyCode::Insert, KeyModifiers::SHIFT), + KeyEvent::new(KeyCode::Delete, KeyModifiers::ALT), + ]; + + for key in cases { + let encoded = encode_key(key, KeyboardProtocol::Legacy); + let parsed = + parse_terminal_key_sequence(std::str::from_utf8(&encoded).unwrap()).unwrap(); + assert_terminal_key_eq(parsed, key.code, key.modifiers, key.kind, None); + } + } + + #[test] + fn kitty_shifted_symbol_prefers_text_over_roundtrip_key_identity() { + let key = TerminalKey::new(KeyCode::Char('1'), KeyModifiers::SHIFT) + .with_shifted_codepoint('!' as u32); + let encoded = encode_terminal_key(key, KeyboardProtocol::Kitty { flags: 7 }); + assert_eq!(encoded, b"!"); + } + + #[test] + fn legacy_basic_special_roundtrip_matrix() { + let cases = [ + KeyEvent::new(KeyCode::Enter, KeyModifiers::empty()), + KeyEvent::new(KeyCode::Tab, KeyModifiers::empty()), + KeyEvent::new(KeyCode::Backspace, KeyModifiers::empty()), + KeyEvent::new(KeyCode::Esc, KeyModifiers::empty()), + KeyEvent::new(KeyCode::Up, KeyModifiers::empty()), + KeyEvent::new(KeyCode::Down, KeyModifiers::empty()), + KeyEvent::new(KeyCode::Left, KeyModifiers::empty()), + KeyEvent::new(KeyCode::Right, KeyModifiers::empty()), + KeyEvent::new(KeyCode::Home, KeyModifiers::empty()), + KeyEvent::new(KeyCode::End, KeyModifiers::empty()), + KeyEvent::new(KeyCode::PageUp, KeyModifiers::empty()), + KeyEvent::new(KeyCode::PageDown, KeyModifiers::empty()), + KeyEvent::new(KeyCode::Insert, KeyModifiers::empty()), + KeyEvent::new(KeyCode::Delete, KeyModifiers::empty()), + ]; + + for key in cases { + let encoded = encode_key(key, KeyboardProtocol::Legacy); + let parsed = + parse_terminal_key_sequence(std::str::from_utf8(&encoded).unwrap()).unwrap(); + assert_terminal_key_eq(parsed, key.code, key.modifiers, key.kind, None); + } + } + + #[test] + fn kitty_shifted_symbol_pair_matrix_is_encoded_as_text() { + let cases = [('1', '!'), ('/', '?'), ('[', '{')]; + + for (base, shifted) in cases { + let key = TerminalKey::new(KeyCode::Char(base), KeyModifiers::SHIFT) + .with_shifted_codepoint(shifted as u32); + let encoded = encode_terminal_key(key, KeyboardProtocol::Kitty { flags: 7 }); + assert_eq!(encoded, shifted.to_string().into_bytes(), "base={base}"); + } + } + + #[test] + fn chinese_char_encodes_as_utf8() { + let key = TerminalKey::new(KeyCode::Char('中'), KeyModifiers::empty()); + let encoded = encode_terminal_key(key, KeyboardProtocol::Legacy); + assert_eq!(encoded, "中".as_bytes()); + } + + #[test] + fn chinese_char_with_kitty_protocol_encodes_as_utf8() { + let key = TerminalKey::new(KeyCode::Char('文'), KeyModifiers::empty()); + let encoded = encode_terminal_key(key, KeyboardProtocol::Kitty { flags: 7 }); + assert_eq!(encoded, "文".as_bytes()); + } + + #[test] + fn chinese_char_with_modifiers_falls_back_to_kitty_encoding() { + let key = TerminalKey::new(KeyCode::Char('测'), KeyModifiers::ALT); + let encoded = encode_terminal_key(key, KeyboardProtocol::Kitty { flags: 7 }); + assert!(!encoded.is_empty()); + assert_ne!(encoded, "测".as_bytes()); + } +} diff --git a/src/input/mod.rs b/src/input/mod.rs index 67e8a14d..2536dfe2 100644 --- a/src/input/mod.rs +++ b/src/input/mod.rs @@ -8,11 +8,5 @@ pub use encode::encode_key; pub use encode::{ encode_cursor_key, encode_mouse_button, encode_mouse_scroll, encode_terminal_key, }; -pub use model::{ - normalize_app_key_binding, KeyboardProtocol, MouseProtocolEncoding, MouseProtocolMode, - TerminalKey, -}; +pub use model::{KeyboardProtocol, MouseProtocolEncoding, MouseProtocolMode, TerminalKey}; pub use parse::parse_terminal_key_sequence; - -#[cfg(test)] -mod tests; diff --git a/src/input/model.rs b/src/input/model.rs index 5721f82b..181ba7b3 100644 --- a/src/input/model.rs +++ b/src/input/model.rs @@ -1,57 +1,5 @@ use crossterm::event::{KeyCode, KeyEvent, KeyModifiers}; -pub fn normalize_app_key_binding( - code: KeyCode, - modifiers: KeyModifiers, - shifted_codepoint: Option<u32>, -) -> (KeyCode, KeyModifiers) { - let KeyCode::Char(raw_char) = code else { - return (code, modifiers); - }; - - let shifted_char = shifted_codepoint - .and_then(char::from_u32) - .or_else(|| modifiers.contains(KeyModifiers::SHIFT).then_some(raw_char)) - .and_then(shifted_printable_char); - - let normalized_char = shifted_char.unwrap_or(raw_char); - let mut normalized_modifiers = modifiers; - if shifted_char.is_some() { - normalized_modifiers.remove(KeyModifiers::SHIFT); - } - - (KeyCode::Char(normalized_char), normalized_modifiers) -} - -fn shifted_printable_char(ch: char) -> Option<char> { - match ch { - 'a'..='z' => Some(ch.to_ascii_uppercase()), - 'A'..='Z' => Some(ch), - '`' | '~' => Some('~'), - '1' | '!' => Some('!'), - '2' | '@' => Some('@'), - '3' | '#' => Some('#'), - '4' | '$' => Some('$'), - '5' | '%' => Some('%'), - '6' | '^' => Some('^'), - '7' | '&' => Some('&'), - '8' | '*' => Some('*'), - '9' | '(' => Some('('), - '0' | ')' => Some(')'), - '-' | '_' => Some('_'), - '=' | '+' => Some('+'), - '[' | '{' => Some('{'), - ']' | '}' => Some('}'), - '\\' | '|' => Some('|'), - ';' | ':' => Some(':'), - '\'' | '"' => Some('"'), - ',' | '<' => Some('<'), - '.' | '>' => Some('>'), - '/' | '?' => Some('?'), - _ => None, - } -} - #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub struct TerminalKey { pub code: KeyCode, @@ -129,3 +77,24 @@ pub enum MouseProtocolEncoding { Utf8, Sgr, } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn protocol_from_zero_flags_is_legacy() { + assert_eq!( + KeyboardProtocol::from_kitty_flags(0), + KeyboardProtocol::Legacy + ); + } + + #[test] + fn protocol_from_nonzero_flags_is_kitty() { + assert_eq!( + KeyboardProtocol::from_kitty_flags(7), + KeyboardProtocol::Kitty { flags: 7 } + ); + } +} diff --git a/src/input/parse.rs b/src/input/parse.rs index b7b449ae..79f11e23 100644 --- a/src/input/parse.rs +++ b/src/input/parse.rs @@ -301,3 +301,394 @@ fn key_modifiers_from_u8(modifier: u8) -> KeyModifiers { } mods } + +#[cfg(test)] +mod tests { + use crossterm::event::{KeyCode, KeyModifiers, ModifierKeyCode}; + + use super::*; + use crate::input::{encode_terminal_key, KeyboardProtocol}; + + fn assert_terminal_key_eq( + actual: TerminalKey, + code: KeyCode, + modifiers: KeyModifiers, + kind: crossterm::event::KeyEventKind, + shifted_codepoint: Option<u32>, + ) { + assert_eq!(actual.code, code); + assert_eq!(actual.modifiers, modifiers); + assert_eq!(actual.kind, kind); + assert_eq!(actual.shifted_codepoint, shifted_codepoint); + } + + fn decode_hex(hex: &str) -> Vec<u8> { + let hex = hex.trim(); + assert_eq!(hex.len() % 2, 0, "hex string must have even length"); + (0..hex.len()) + .step_by(2) + .map(|idx| u8::from_str_radix(&hex[idx..idx + 2], 16).unwrap()) + .collect() + } + + fn parse_fixture_key_code(value: &str) -> KeyCode { + match value { + "enter" => KeyCode::Enter, + "tab" => KeyCode::Tab, + "backspace" => KeyCode::Backspace, + "esc" => KeyCode::Esc, + "up" => KeyCode::Up, + "down" => KeyCode::Down, + "left" => KeyCode::Left, + "right" => KeyCode::Right, + "home" => KeyCode::Home, + "end" => KeyCode::End, + "pageup" => KeyCode::PageUp, + "pagedown" => KeyCode::PageDown, + "insert" => KeyCode::Insert, + "delete" => KeyCode::Delete, + value if value.starts_with("char:") => { + KeyCode::Char(value.trim_start_matches("char:").chars().next().unwrap()) + } + other => panic!("unsupported fixture key code: {other}"), + } + } + + fn parse_fixture_modifiers(value: &str) -> KeyModifiers { + if value == "-" || value.is_empty() { + return KeyModifiers::empty(); + } + + let mut modifiers = KeyModifiers::empty(); + for part in value.split('+') { + match part { + "shift" => modifiers |= KeyModifiers::SHIFT, + "alt" => modifiers |= KeyModifiers::ALT, + "control" => modifiers |= KeyModifiers::CONTROL, + "super" => modifiers |= KeyModifiers::SUPER, + "hyper" => modifiers |= KeyModifiers::HYPER, + "meta" => modifiers |= KeyModifiers::META, + other => panic!("unsupported fixture modifier: {other}"), + } + } + modifiers + } + + fn parse_fixture_kind(value: &str) -> crossterm::event::KeyEventKind { + match value { + "press" => crossterm::event::KeyEventKind::Press, + "repeat" => crossterm::event::KeyEventKind::Repeat, + "release" => crossterm::event::KeyEventKind::Release, + other => panic!("unsupported fixture kind: {other}"), + } + } + + #[test] + fn parse_legacy_f_keys() { + assert_terminal_key_eq( + parse_terminal_key_sequence("\x1bOP").expect("f1 should parse"), + KeyCode::F(1), + KeyModifiers::empty(), + crossterm::event::KeyEventKind::Press, + None, + ); + assert_terminal_key_eq( + parse_terminal_key_sequence("\x1b[15~").expect("f5 should parse"), + KeyCode::F(5), + KeyModifiers::empty(), + crossterm::event::KeyEventKind::Press, + None, + ); + } + + #[test] + fn parse_modified_f_keys() { + assert_terminal_key_eq( + parse_terminal_key_sequence("\x1b[1;2P").expect("shift+f1 should parse"), + KeyCode::F(1), + KeyModifiers::SHIFT, + crossterm::event::KeyEventKind::Press, + None, + ); + assert_terminal_key_eq( + parse_terminal_key_sequence("\x1b[15;2~").expect("shift+f5 should parse"), + KeyCode::F(5), + KeyModifiers::SHIFT, + crossterm::event::KeyEventKind::Press, + None, + ); + } + + #[test] + fn parse_kitty_sequence_preserves_shifted_symbol_pair() { + let key = parse_terminal_key_sequence("\x1b[49:33;2:1u").unwrap(); + assert_eq!(key.code, KeyCode::Char('1')); + assert_eq!(key.modifiers, KeyModifiers::SHIFT); + assert_eq!(key.kind, crossterm::event::KeyEventKind::Press); + assert_eq!(key.shifted_codepoint, Some('!' as u32)); + } + + #[test] + fn parse_kitty_sequence_preserves_shifted_letter_pair_and_release() { + let key = parse_terminal_key_sequence("\x1b[108:76;2:3u").unwrap(); + assert_eq!(key.code, KeyCode::Char('l')); + assert_eq!(key.modifiers, KeyModifiers::SHIFT); + assert_eq!(key.kind, crossterm::event::KeyEventKind::Release); + assert_eq!(key.shifted_codepoint, Some('L' as u32)); + } + + #[test] + fn parse_modify_other_keys_sequence() { + let key = parse_terminal_key_sequence("\x1b[27;6;108~").unwrap(); + assert_eq!(key.code, KeyCode::Char('l')); + assert_eq!(key.modifiers, KeyModifiers::CONTROL | KeyModifiers::SHIFT); + assert_eq!(key.kind, crossterm::event::KeyEventKind::Press); + assert_eq!(key.shifted_codepoint, None); + } + + #[test] + fn parse_legacy_uppercase_letter_as_shifted_char() { + let key = parse_terminal_key_sequence("L").unwrap(); + assert_eq!(key.code, KeyCode::Char('L')); + assert_eq!(key.modifiers, KeyModifiers::SHIFT); + } + + #[test] + fn parse_legacy_up_arrow_sequence() { + let key = parse_terminal_key_sequence("\x1b[A").unwrap(); + assert_eq!(key.code, KeyCode::Up); + assert_eq!(key.modifiers, KeyModifiers::empty()); + } + + #[test] + fn parse_kitty_modifier_sequence() { + let key = parse_terminal_key_sequence("\x1b[57441;2:1u").unwrap(); + assert_eq!(key.code, KeyCode::Modifier(ModifierKeyCode::LeftShift)); + assert_eq!(key.modifiers, KeyModifiers::SHIFT); + assert_eq!(key.kind, crossterm::event::KeyEventKind::Press); + } + + #[test] + fn parse_ghostty_enhanced_up_arrow_press_sequence() { + let key = parse_terminal_key_sequence("\x1b[1;1:1A").unwrap(); + assert_eq!(key.code, KeyCode::Up); + assert_eq!(key.modifiers, KeyModifiers::empty()); + assert_eq!(key.kind, crossterm::event::KeyEventKind::Press); + } + + #[test] + fn parse_ghostty_enhanced_up_arrow_release_sequence() { + let key = parse_terminal_key_sequence("\x1b[1;1:3A").unwrap(); + assert_eq!(key.code, KeyCode::Up); + assert_eq!(key.modifiers, KeyModifiers::empty()); + assert_eq!(key.kind, crossterm::event::KeyEventKind::Release); + } + + #[test] + fn parse_xterm_alt_up_arrow_sequence() { + let key = parse_terminal_key_sequence("\x1b[1;3A").unwrap(); + assert_eq!(key.code, KeyCode::Up); + assert_eq!(key.modifiers, KeyModifiers::ALT); + } + + #[test] + fn parse_xterm_alt_down_arrow_sequence() { + let key = parse_terminal_key_sequence("\x1b[1;3B").unwrap(); + assert_eq!(key.code, KeyCode::Down); + assert_eq!(key.modifiers, KeyModifiers::ALT); + } + + #[test] + fn parse_kitty_functional_up_arrow_sequence() { + let key = parse_terminal_key_sequence("\x1b[57419;1u").unwrap(); + assert_eq!(key.code, KeyCode::Up); + assert_eq!(key.modifiers, KeyModifiers::empty()); + } + + #[test] + fn parse_legacy_ctrl_b_sequence() { + let key = parse_terminal_key_sequence("\x02").unwrap(); + assert_eq!(key.code, KeyCode::Char('b')); + assert_eq!(key.modifiers, KeyModifiers::CONTROL); + } + + #[test] + fn parse_legacy_ctrl_c_sequence() { + let key = parse_terminal_key_sequence("\x03").unwrap(); + assert_eq!(key.code, KeyCode::Char('c')); + assert_eq!(key.modifiers, KeyModifiers::CONTROL); + } + + #[test] + fn parse_legacy_lf_sequence_as_ctrl_j() { + let key = parse_terminal_key_sequence("\n").unwrap(); + assert_eq!(key.code, KeyCode::Char('j')); + assert_eq!(key.modifiers, KeyModifiers::CONTROL); + } + + #[test] + fn legacy_lf_roundtrips_as_lf() { + let key = parse_terminal_key_sequence("\n").unwrap(); + assert_eq!(encode_terminal_key(key, KeyboardProtocol::Legacy), b"\n"); + } + + #[test] + fn legacy_ctrl_byte_matrix_is_covered() { + for (byte, expected) in [ + (b'\x01', 'a'), + (b'\x02', 'b'), + (b'\x03', 'c'), + (b'\x1a', 'z'), + ] { + let key = parse_terminal_key_sequence(std::str::from_utf8(&[byte]).unwrap()).unwrap(); + assert_terminal_key_eq( + key, + KeyCode::Char(expected), + KeyModifiers::CONTROL, + crossterm::event::KeyEventKind::Press, + None, + ); + } + + for (byte, expected) in [ + (b'\x1c', '\\'), + (b'\x1d', ']'), + (b'\x1e', '^'), + (b'\x1f', '-'), + ] { + let key = parse_terminal_key_sequence(std::str::from_utf8(&[byte]).unwrap()).unwrap(); + assert_terminal_key_eq( + key, + KeyCode::Char(expected), + KeyModifiers::CONTROL, + crossterm::event::KeyEventKind::Press, + None, + ); + } + } + + #[test] + fn kitty_functional_key_matrix_is_covered() { + let cases = [ + ("\x1b[57417;1u", KeyCode::Left), + ("\x1b[57418;1u", KeyCode::Right), + ("\x1b[57419;1u", KeyCode::Up), + ("\x1b[57420;1u", KeyCode::Down), + ("\x1b[57421;1u", KeyCode::PageUp), + ("\x1b[57422;1u", KeyCode::PageDown), + ("\x1b[57423;1u", KeyCode::Home), + ("\x1b[57424;1u", KeyCode::End), + ("\x1b[57425;1u", KeyCode::Insert), + ("\x1b[57426;1u", KeyCode::Delete), + ]; + + for (sequence, code) in cases { + let parsed = parse_terminal_key_sequence(sequence).unwrap(); + assert_terminal_key_eq( + parsed, + code, + KeyModifiers::empty(), + crossterm::event::KeyEventKind::Press, + None, + ); + } + } + + fn assert_fixture_corpus_parses(corpus: &str) { + for line in corpus.lines() { + let line = line.trim(); + if line.is_empty() || line.starts_with('#') { + continue; + } + + let mut columns: Vec<_> = line.split('\t').collect(); + if columns.len() == 5 { + columns.push(""); + } + + let (family, bytes_hex, code, modifiers, kind, shifted) = match columns.len() { + 6 => { + if columns[1].chars().all(|ch| ch.is_ascii_hexdigit()) { + ( + columns[0], columns[1], columns[2], columns[3], columns[4], columns[5], + ) + } else { + ( + columns[0], columns[2], columns[3], columns[4], columns[5], "", + ) + } + } + 7 => ( + columns[0], columns[2], columns[3], columns[4], columns[5], columns[6], + ), + _ => panic!("fixture row must have 6 or 7 columns: {line}"), + }; + + assert!( + bytes_hex.chars().all(|ch| ch.is_ascii_hexdigit()), + "non-hex fixture bytes for {family}: {bytes_hex}" + ); + let bytes = decode_hex(bytes_hex); + let text = std::str::from_utf8(&bytes).unwrap(); + let parsed = parse_terminal_key_sequence(text) + .unwrap_or_else(|| panic!("fixture failed to parse: {family}")); + + assert_terminal_key_eq( + parsed, + parse_fixture_key_code(code), + parse_fixture_modifiers(modifiers), + parse_fixture_kind(kind), + if shifted.is_empty() { + None + } else { + Some(shifted.parse::<u32>().unwrap()) + }, + ); + } + } + + #[test] + fn keyboard_protocol_corpus_fixture_parses() { + let corpus = include_str!("../../tests/fixtures/keyboard_protocol_corpus.tsv"); + assert_fixture_corpus_parses(corpus); + } + + #[test] + fn macos_terminal_variants_fixture_parses() { + let corpus = include_str!("../../tests/fixtures/macos_terminal_variants.tsv"); + for line in corpus.lines() { + let line = line.trim(); + if line.is_empty() || line.starts_with('#') { + continue; + } + + let mut columns: Vec<_> = line.split('\t').collect(); + if columns.len() == 6 { + columns.push(""); + } + assert_eq!( + columns.len(), + 7, + "macOS fixture row must have 7 columns: {line}" + ); + + let source = format!("{}:{}", columns[0], columns[1]); + let transformed = [ + source.as_str(), + columns[2], + columns[3], + columns[4], + columns[5], + columns[6], + ] + .join("\t"); + assert_fixture_corpus_parses(&transformed); + } + } + + #[test] + fn linux_terminal_variants_fixture_parses() { + let corpus = include_str!("../../tests/fixtures/linux_terminal_variants.tsv"); + assert_fixture_corpus_parses(corpus); + } +} diff --git a/src/input/tests.rs b/src/input/tests.rs deleted file mode 100644 index 6e196ad7..00000000 --- a/src/input/tests.rs +++ /dev/null @@ -1,752 +0,0 @@ -use crossterm::event::{KeyCode, KeyEvent, KeyModifiers, ModifierKeyCode}; - -use super::{ - encode_cursor_key, encode_key, encode_mouse_button, encode_mouse_scroll, encode_terminal_key, - parse_terminal_key_sequence, KeyboardProtocol, MouseProtocolEncoding, TerminalKey, -}; - -fn assert_terminal_key_eq( - actual: TerminalKey, - code: KeyCode, - modifiers: KeyModifiers, - kind: crossterm::event::KeyEventKind, - shifted_codepoint: Option<u32>, -) { - assert_eq!(actual.code, code); - assert_eq!(actual.modifiers, modifiers); - assert_eq!(actual.kind, kind); - assert_eq!(actual.shifted_codepoint, shifted_codepoint); -} - -fn decode_hex(hex: &str) -> Vec<u8> { - let hex = hex.trim(); - assert_eq!(hex.len() % 2, 0, "hex string must have even length"); - (0..hex.len()) - .step_by(2) - .map(|idx| u8::from_str_radix(&hex[idx..idx + 2], 16).unwrap()) - .collect() -} - -fn parse_fixture_key_code(value: &str) -> KeyCode { - match value { - "enter" => KeyCode::Enter, - "tab" => KeyCode::Tab, - "backspace" => KeyCode::Backspace, - "esc" => KeyCode::Esc, - "up" => KeyCode::Up, - "down" => KeyCode::Down, - "left" => KeyCode::Left, - "right" => KeyCode::Right, - "home" => KeyCode::Home, - "end" => KeyCode::End, - "pageup" => KeyCode::PageUp, - "pagedown" => KeyCode::PageDown, - "insert" => KeyCode::Insert, - "delete" => KeyCode::Delete, - value if value.starts_with("char:") => { - KeyCode::Char(value.trim_start_matches("char:").chars().next().unwrap()) - } - other => panic!("unsupported fixture key code: {other}"), - } -} - -fn parse_fixture_modifiers(value: &str) -> KeyModifiers { - if value == "-" || value.is_empty() { - return KeyModifiers::empty(); - } - - let mut modifiers = KeyModifiers::empty(); - for part in value.split('+') { - match part { - "shift" => modifiers |= KeyModifiers::SHIFT, - "alt" => modifiers |= KeyModifiers::ALT, - "control" => modifiers |= KeyModifiers::CONTROL, - "super" => modifiers |= KeyModifiers::SUPER, - "hyper" => modifiers |= KeyModifiers::HYPER, - "meta" => modifiers |= KeyModifiers::META, - other => panic!("unsupported fixture modifier: {other}"), - } - } - modifiers -} - -fn parse_fixture_kind(value: &str) -> crossterm::event::KeyEventKind { - match value { - "press" => crossterm::event::KeyEventKind::Press, - "repeat" => crossterm::event::KeyEventKind::Repeat, - "release" => crossterm::event::KeyEventKind::Release, - other => panic!("unsupported fixture kind: {other}"), - } -} - -#[test] -fn legacy_enter() { - let key = KeyEvent::new(KeyCode::Enter, KeyModifiers::empty()); - assert_eq!(encode_key(key, KeyboardProtocol::Legacy), vec![b'\r']); -} - -#[test] -fn legacy_ctrl_c() { - let key = KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL); - assert_eq!(encode_key(key, KeyboardProtocol::Legacy), vec![3]); -} - -#[test] -fn legacy_shift_enter_is_just_cr() { - let key = KeyEvent::new(KeyCode::Enter, KeyModifiers::SHIFT); - // Enter/Tab/Backspace/Esc aren't special keys with xterm modifier encoding, - // so Shift+Enter falls through to legacy which just sends CR - assert_eq!(encode_key(key, KeyboardProtocol::Legacy), vec![b'\r']); -} - -#[test] -fn legacy_alt_up() { - let key = KeyEvent::new(KeyCode::Up, KeyModifiers::ALT); - // xterm modified key format: CSI 1;3A (3 = 1 + Alt) - assert_eq!(encode_key(key, KeyboardProtocol::Legacy), b"\x1b[1;3A"); -} - -#[test] -fn legacy_shift_right() { - let key = KeyEvent::new(KeyCode::Right, KeyModifiers::SHIFT); - assert_eq!(encode_key(key, KeyboardProtocol::Legacy), b"\x1b[1;2C"); -} - -#[test] -fn legacy_ctrl_left() { - let key = KeyEvent::new(KeyCode::Left, KeyModifiers::CONTROL); - assert_eq!(encode_key(key, KeyboardProtocol::Legacy), b"\x1b[1;5D"); -} - -#[test] -fn legacy_ctrl_shift_end() { - let key = KeyEvent::new(KeyCode::End, KeyModifiers::CONTROL | KeyModifiers::SHIFT); - assert_eq!(encode_key(key, KeyboardProtocol::Legacy), b"\x1b[1;6F"); -} - -#[test] -fn legacy_alt_delete() { - let key = KeyEvent::new(KeyCode::Delete, KeyModifiers::ALT); - assert_eq!(encode_key(key, KeyboardProtocol::Legacy), b"\x1b[3;3~"); -} - -#[test] -fn legacy_shift_f5() { - let key = KeyEvent::new(KeyCode::F(5), KeyModifiers::SHIFT); - assert_eq!(encode_key(key, KeyboardProtocol::Legacy), b"\x1b[15;2~"); -} - -#[test] -fn parse_legacy_f_keys() { - assert_terminal_key_eq( - parse_terminal_key_sequence("\x1bOP").expect("f1 should parse"), - KeyCode::F(1), - KeyModifiers::empty(), - crossterm::event::KeyEventKind::Press, - None, - ); - assert_terminal_key_eq( - parse_terminal_key_sequence("\x1b[15~").expect("f5 should parse"), - KeyCode::F(5), - KeyModifiers::empty(), - crossterm::event::KeyEventKind::Press, - None, - ); -} - -#[test] -fn parse_modified_f_keys() { - assert_terminal_key_eq( - parse_terminal_key_sequence("\x1b[1;2P").expect("shift+f1 should parse"), - KeyCode::F(1), - KeyModifiers::SHIFT, - crossterm::event::KeyEventKind::Press, - None, - ); - assert_terminal_key_eq( - parse_terminal_key_sequence("\x1b[15;2~").expect("shift+f5 should parse"), - KeyCode::F(5), - KeyModifiers::SHIFT, - crossterm::event::KeyEventKind::Press, - None, - ); -} - -#[test] -fn legacy_alt_char_still_esc_prefix() { - // Alt+a on character keys still uses ESC prefix (not xterm modified) - let key = KeyEvent::new(KeyCode::Char('a'), KeyModifiers::ALT); - assert_eq!(encode_key(key, KeyboardProtocol::Legacy), b"\x1ba"); -} - -#[test] -fn application_cursor_keys_use_ss3_sequences() { - assert_eq!(encode_cursor_key(KeyCode::Up, true), b"\x1bOA"); - assert_eq!(encode_cursor_key(KeyCode::Down, true), b"\x1bOB"); -} - -#[test] -fn normal_cursor_keys_use_csi_sequences() { - assert_eq!(encode_cursor_key(KeyCode::Up, false), b"\x1b[A"); - assert_eq!(encode_cursor_key(KeyCode::Down, false), b"\x1b[B"); -} - -#[test] -fn sgr_mouse_scroll_encodes_wheel_button_and_coordinates() { - let encoded = encode_mouse_scroll( - crossterm::event::MouseEventKind::ScrollDown, - 4, - 6, - KeyModifiers::SHIFT, - MouseProtocolEncoding::Sgr, - ) - .expect("mouse scroll should encode"); - - assert_eq!(encoded, b"\x1b[<69;5;7M"); -} - -#[test] -fn sgr_mouse_release_keeps_button_code() { - let encoded = encode_mouse_button( - crossterm::event::MouseEventKind::Up(crossterm::event::MouseButton::Left), - 11, - 9, - KeyModifiers::empty(), - MouseProtocolEncoding::Sgr, - ) - .expect("mouse release should encode"); - - assert_eq!(encoded, b"\x1b[<0;12;10m"); -} - -#[test] -fn kitty_shift_enter() { - let key = KeyEvent::new(KeyCode::Enter, KeyModifiers::SHIFT); - assert_eq!( - encode_key(key, KeyboardProtocol::Kitty { flags: 1 }), - b"\x1b[13;2u" - ); -} - -#[test] -fn kitty_ctrl_shift_a() { - let key = KeyEvent::new( - KeyCode::Char('a'), - KeyModifiers::CONTROL | KeyModifiers::SHIFT, - ); - assert_eq!( - encode_key(key, KeyboardProtocol::Kitty { flags: 1 }), - b"\x1b[97;6u" - ); -} - -#[test] -fn kitty_shift_uppercase_letter_sends_text() { - let key = KeyEvent::new(KeyCode::Char('L'), KeyModifiers::SHIFT); - assert_eq!(encode_key(key, KeyboardProtocol::Kitty { flags: 1 }), b"L"); -} - -#[test] -fn kitty_shift_uppercase_letter_ignores_alternate_key_reporting_for_text() { - let key = KeyEvent::new(KeyCode::Char('L'), KeyModifiers::SHIFT); - assert_eq!(encode_key(key, KeyboardProtocol::Kitty { flags: 7 }), b"L"); -} - -#[test] -fn kitty_shift_lowercase_letter_sends_uppercase_text() { - let key = KeyEvent::new(KeyCode::Char('l'), KeyModifiers::SHIFT); - assert_eq!(encode_key(key, KeyboardProtocol::Kitty { flags: 1 }), b"L"); -} - -#[test] -fn kitty_alt_shift_uppercase_letter_uses_base_codepoint() { - let key = KeyEvent::new(KeyCode::Char('L'), KeyModifiers::ALT | KeyModifiers::SHIFT); - assert_eq!( - encode_key(key, KeyboardProtocol::Kitty { flags: 1 }), - b"\x1b[108;4u" - ); -} - -#[test] -fn kitty_ctrl_shift_uppercase_letter_uses_base_codepoint() { - let key = KeyEvent::new( - KeyCode::Char('L'), - KeyModifiers::CONTROL | KeyModifiers::SHIFT, - ); - assert_eq!( - encode_key(key, KeyboardProtocol::Kitty { flags: 1 }), - b"\x1b[108;6u" - ); -} - -#[test] -fn legacy_shift_uppercase_letter_stays_uppercase() { - let key = KeyEvent::new(KeyCode::Char('L'), KeyModifiers::SHIFT); - assert_eq!(encode_key(key, KeyboardProtocol::Legacy), b"L"); -} - -#[test] -fn kitty_alt_enter() { - let key = KeyEvent::new(KeyCode::Enter, KeyModifiers::ALT); - assert_eq!( - encode_key(key, KeyboardProtocol::Kitty { flags: 1 }), - b"\x1b[13;3u" - ); -} - -#[test] -fn kitty_plain_ctrl_c_uses_csi_u() { - let key = KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL); - assert_eq!( - encode_key(key, KeyboardProtocol::Kitty { flags: 1 }), - b"\x1b[99;5u" - ); -} - -#[test] -fn kitty_plain_ctrl_c_includes_press_event_when_requested() { - let key = KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL); - assert_eq!( - encode_key(key, KeyboardProtocol::Kitty { flags: 3 }), - b"\x1b[99;5:1u" - ); -} - -#[test] -fn kitty_unmodified_uses_legacy() { - let key = KeyEvent::new(KeyCode::Char('a'), KeyModifiers::empty()); - assert_eq!(encode_key(key, KeyboardProtocol::Kitty { flags: 1 }), b"a"); -} - -#[test] -fn kitty_shift_tab() { - let key = KeyEvent::new(KeyCode::Tab, KeyModifiers::SHIFT); - assert_eq!( - encode_key(key, KeyboardProtocol::Kitty { flags: 1 }), - b"\x1b[9;2u" - ); -} - -#[test] -fn kitty_ctrl_shift_enter() { - let key = KeyEvent::new(KeyCode::Enter, KeyModifiers::CONTROL | KeyModifiers::SHIFT); - assert_eq!( - encode_key(key, KeyboardProtocol::Kitty { flags: 1 }), - b"\x1b[13;6u" - ); -} - -#[test] -fn kitty_repeat_event_type_is_encoded_when_requested() { - let key = KeyEvent::new_with_kind( - KeyCode::Enter, - KeyModifiers::SHIFT, - crossterm::event::KeyEventKind::Repeat, - ); - assert_eq!( - encode_key(key, KeyboardProtocol::Kitty { flags: 3 }), - b"\x1b[13;2:2u" - ); -} - -#[test] -fn kitty_shift_letter_release_does_not_emit_text() { - let key = KeyEvent::new_with_kind( - KeyCode::Char('L'), - KeyModifiers::SHIFT, - crossterm::event::KeyEventKind::Release, - ); - assert_eq!(encode_key(key, KeyboardProtocol::Kitty { flags: 7 }), b""); -} - -#[test] -fn kitty_shifted_symbol_sends_text() { - let key = TerminalKey::new(KeyCode::Char('1'), KeyModifiers::SHIFT) - .with_shifted_codepoint('!' as u32); - assert_eq!( - encode_terminal_key(key, KeyboardProtocol::Kitty { flags: 7 }), - b"!" - ); -} - -#[test] -fn parse_kitty_sequence_preserves_shifted_symbol_pair() { - let key = parse_terminal_key_sequence("\x1b[49:33;2:1u").unwrap(); - assert_eq!(key.code, KeyCode::Char('1')); - assert_eq!(key.modifiers, KeyModifiers::SHIFT); - assert_eq!(key.kind, crossterm::event::KeyEventKind::Press); - assert_eq!(key.shifted_codepoint, Some('!' as u32)); -} - -#[test] -fn parse_kitty_sequence_preserves_shifted_letter_pair_and_release() { - let key = parse_terminal_key_sequence("\x1b[108:76;2:3u").unwrap(); - assert_eq!(key.code, KeyCode::Char('l')); - assert_eq!(key.modifiers, KeyModifiers::SHIFT); - assert_eq!(key.kind, crossterm::event::KeyEventKind::Release); - assert_eq!(key.shifted_codepoint, Some('L' as u32)); -} - -#[test] -fn parse_modify_other_keys_sequence() { - let key = parse_terminal_key_sequence("\x1b[27;6;108~").unwrap(); - assert_eq!(key.code, KeyCode::Char('l')); - assert_eq!(key.modifiers, KeyModifiers::CONTROL | KeyModifiers::SHIFT); - assert_eq!(key.kind, crossterm::event::KeyEventKind::Press); - assert_eq!(key.shifted_codepoint, None); -} - -#[test] -fn parse_legacy_uppercase_letter_as_shifted_char() { - let key = parse_terminal_key_sequence("L").unwrap(); - assert_eq!(key.code, KeyCode::Char('L')); - assert_eq!(key.modifiers, KeyModifiers::SHIFT); -} - -#[test] -fn parse_legacy_up_arrow_sequence() { - let key = parse_terminal_key_sequence("\x1b[A").unwrap(); - assert_eq!(key.code, KeyCode::Up); - assert_eq!(key.modifiers, KeyModifiers::empty()); -} - -#[test] -fn parse_kitty_modifier_sequence() { - let key = parse_terminal_key_sequence("\x1b[57441;2:1u").unwrap(); - assert_eq!(key.code, KeyCode::Modifier(ModifierKeyCode::LeftShift)); - assert_eq!(key.modifiers, KeyModifiers::SHIFT); - assert_eq!(key.kind, crossterm::event::KeyEventKind::Press); -} - -#[test] -fn parse_ghostty_enhanced_up_arrow_press_sequence() { - let key = parse_terminal_key_sequence("\x1b[1;1:1A").unwrap(); - assert_eq!(key.code, KeyCode::Up); - assert_eq!(key.modifiers, KeyModifiers::empty()); - assert_eq!(key.kind, crossterm::event::KeyEventKind::Press); -} - -#[test] -fn parse_ghostty_enhanced_up_arrow_release_sequence() { - let key = parse_terminal_key_sequence("\x1b[1;1:3A").unwrap(); - assert_eq!(key.code, KeyCode::Up); - assert_eq!(key.modifiers, KeyModifiers::empty()); - assert_eq!(key.kind, crossterm::event::KeyEventKind::Release); -} - -#[test] -fn parse_xterm_alt_up_arrow_sequence() { - let key = parse_terminal_key_sequence("\x1b[1;3A").unwrap(); - assert_eq!(key.code, KeyCode::Up); - assert_eq!(key.modifiers, KeyModifiers::ALT); -} - -#[test] -fn parse_xterm_alt_down_arrow_sequence() { - let key = parse_terminal_key_sequence("\x1b[1;3B").unwrap(); - assert_eq!(key.code, KeyCode::Down); - assert_eq!(key.modifiers, KeyModifiers::ALT); -} - -#[test] -fn parse_kitty_functional_up_arrow_sequence() { - let key = parse_terminal_key_sequence("\x1b[57419;1u").unwrap(); - assert_eq!(key.code, KeyCode::Up); - assert_eq!(key.modifiers, KeyModifiers::empty()); -} - -#[test] -fn parse_legacy_ctrl_b_sequence() { - let key = parse_terminal_key_sequence("\x02").unwrap(); - assert_eq!(key.code, KeyCode::Char('b')); - assert_eq!(key.modifiers, KeyModifiers::CONTROL); -} - -#[test] -fn parse_legacy_ctrl_c_sequence() { - let key = parse_terminal_key_sequence("\x03").unwrap(); - assert_eq!(key.code, KeyCode::Char('c')); - assert_eq!(key.modifiers, KeyModifiers::CONTROL); -} - -#[test] -fn parse_legacy_lf_sequence_as_ctrl_j() { - let key = parse_terminal_key_sequence("\n").unwrap(); - assert_eq!(key.code, KeyCode::Char('j')); - assert_eq!(key.modifiers, KeyModifiers::CONTROL); -} - -#[test] -fn legacy_lf_roundtrips_as_lf() { - let key = parse_terminal_key_sequence("\n").unwrap(); - assert_eq!(encode_terminal_key(key, KeyboardProtocol::Legacy), b"\n"); -} - -#[test] -fn legacy_ctrl_byte_matrix_is_covered() { - for (byte, expected) in [ - (b'\x01', 'a'), - (b'\x02', 'b'), - (b'\x03', 'c'), - (b'\x1a', 'z'), - ] { - let key = parse_terminal_key_sequence(std::str::from_utf8(&[byte]).unwrap()).unwrap(); - assert_terminal_key_eq( - key, - KeyCode::Char(expected), - KeyModifiers::CONTROL, - crossterm::event::KeyEventKind::Press, - None, - ); - } - - // Ctrl+[ is byte-identical to Escape in legacy terminals, so the parser - // intentionally treats 0x1b as Escape and only disambiguates the other - // legacy control-symbol bytes here. - for (byte, expected) in [ - (b'\x1c', '\\'), - (b'\x1d', ']'), - (b'\x1e', '^'), - (b'\x1f', '-'), - ] { - let key = parse_terminal_key_sequence(std::str::from_utf8(&[byte]).unwrap()).unwrap(); - assert_terminal_key_eq( - key, - KeyCode::Char(expected), - KeyModifiers::CONTROL, - crossterm::event::KeyEventKind::Press, - None, - ); - } -} - -#[test] -fn legacy_modified_special_roundtrip_matrix() { - let cases = [ - KeyEvent::new(KeyCode::Up, KeyModifiers::ALT), - KeyEvent::new(KeyCode::Down, KeyModifiers::ALT), - KeyEvent::new(KeyCode::Right, KeyModifiers::SHIFT), - KeyEvent::new(KeyCode::Left, KeyModifiers::CONTROL), - KeyEvent::new(KeyCode::Home, KeyModifiers::CONTROL), - KeyEvent::new(KeyCode::End, KeyModifiers::CONTROL | KeyModifiers::SHIFT), - KeyEvent::new(KeyCode::PageUp, KeyModifiers::ALT), - KeyEvent::new(KeyCode::PageDown, KeyModifiers::CONTROL), - KeyEvent::new(KeyCode::Insert, KeyModifiers::SHIFT), - KeyEvent::new(KeyCode::Delete, KeyModifiers::ALT), - ]; - - for key in cases { - let encoded = encode_key(key, KeyboardProtocol::Legacy); - let parsed = parse_terminal_key_sequence(std::str::from_utf8(&encoded).unwrap()).unwrap(); - assert_terminal_key_eq(parsed, key.code, key.modifiers, key.kind, None); - } -} - -#[test] -fn kitty_shifted_symbol_prefers_text_over_roundtrip_key_identity() { - let key = TerminalKey::new(KeyCode::Char('1'), KeyModifiers::SHIFT) - .with_shifted_codepoint('!' as u32); - let encoded = encode_terminal_key(key, KeyboardProtocol::Kitty { flags: 7 }); - assert_eq!(encoded, b"!"); -} - -#[test] -fn legacy_basic_special_roundtrip_matrix() { - let cases = [ - KeyEvent::new(KeyCode::Enter, KeyModifiers::empty()), - KeyEvent::new(KeyCode::Tab, KeyModifiers::empty()), - KeyEvent::new(KeyCode::Backspace, KeyModifiers::empty()), - KeyEvent::new(KeyCode::Esc, KeyModifiers::empty()), - KeyEvent::new(KeyCode::Up, KeyModifiers::empty()), - KeyEvent::new(KeyCode::Down, KeyModifiers::empty()), - KeyEvent::new(KeyCode::Left, KeyModifiers::empty()), - KeyEvent::new(KeyCode::Right, KeyModifiers::empty()), - KeyEvent::new(KeyCode::Home, KeyModifiers::empty()), - KeyEvent::new(KeyCode::End, KeyModifiers::empty()), - KeyEvent::new(KeyCode::PageUp, KeyModifiers::empty()), - KeyEvent::new(KeyCode::PageDown, KeyModifiers::empty()), - KeyEvent::new(KeyCode::Insert, KeyModifiers::empty()), - KeyEvent::new(KeyCode::Delete, KeyModifiers::empty()), - ]; - - for key in cases { - let encoded = encode_key(key, KeyboardProtocol::Legacy); - let parsed = parse_terminal_key_sequence(std::str::from_utf8(&encoded).unwrap()).unwrap(); - assert_terminal_key_eq(parsed, key.code, key.modifiers, key.kind, None); - } -} - -#[test] -fn kitty_functional_key_matrix_is_covered() { - let cases = [ - ("\x1b[57417;1u", KeyCode::Left), - ("\x1b[57418;1u", KeyCode::Right), - ("\x1b[57419;1u", KeyCode::Up), - ("\x1b[57420;1u", KeyCode::Down), - ("\x1b[57421;1u", KeyCode::PageUp), - ("\x1b[57422;1u", KeyCode::PageDown), - ("\x1b[57423;1u", KeyCode::Home), - ("\x1b[57424;1u", KeyCode::End), - ("\x1b[57425;1u", KeyCode::Insert), - ("\x1b[57426;1u", KeyCode::Delete), - ]; - - for (sequence, code) in cases { - let parsed = parse_terminal_key_sequence(sequence).unwrap(); - assert_terminal_key_eq( - parsed, - code, - KeyModifiers::empty(), - crossterm::event::KeyEventKind::Press, - None, - ); - } -} - -#[test] -fn kitty_shifted_symbol_pair_matrix_is_encoded_as_text() { - let cases = [('1', '!'), ('/', '?'), ('[', '{')]; - - for (base, shifted) in cases { - let key = TerminalKey::new(KeyCode::Char(base), KeyModifiers::SHIFT) - .with_shifted_codepoint(shifted as u32); - let encoded = encode_terminal_key(key, KeyboardProtocol::Kitty { flags: 7 }); - assert_eq!(encoded, shifted.to_string().into_bytes(), "base={base}"); - } -} - -fn assert_fixture_corpus_parses(corpus: &str) { - for line in corpus.lines() { - let line = line.trim(); - if line.is_empty() || line.starts_with('#') { - continue; - } - - let mut columns: Vec<_> = line.split('\t').collect(); - if columns.len() == 5 { - columns.push(""); - } - - let (family, bytes_hex, code, modifiers, kind, shifted) = match columns.len() { - 6 => { - if columns[1].chars().all(|ch| ch.is_ascii_hexdigit()) { - ( - columns[0], columns[1], columns[2], columns[3], columns[4], columns[5], - ) - } else { - ( - columns[0], columns[2], columns[3], columns[4], columns[5], "", - ) - } - } - 7 => ( - columns[0], columns[2], columns[3], columns[4], columns[5], columns[6], - ), - _ => panic!("fixture row must have 6 or 7 columns: {line}"), - }; - - assert!( - bytes_hex.chars().all(|ch| ch.is_ascii_hexdigit()), - "non-hex fixture bytes for {family}: {bytes_hex}" - ); - let bytes = decode_hex(bytes_hex); - let text = std::str::from_utf8(&bytes).unwrap(); - let parsed = parse_terminal_key_sequence(text) - .unwrap_or_else(|| panic!("fixture failed to parse: {family}")); - - assert_terminal_key_eq( - parsed, - parse_fixture_key_code(code), - parse_fixture_modifiers(modifiers), - parse_fixture_kind(kind), - if shifted.is_empty() { - None - } else { - Some(shifted.parse::<u32>().unwrap()) - }, - ); - } -} - -#[test] -fn keyboard_protocol_corpus_fixture_parses() { - let corpus = include_str!("../../tests/fixtures/keyboard_protocol_corpus.tsv"); - assert_fixture_corpus_parses(corpus); -} - -#[test] -fn macos_terminal_variants_fixture_parses() { - let corpus = include_str!("../../tests/fixtures/macos_terminal_variants.tsv"); - for line in corpus.lines() { - let line = line.trim(); - if line.is_empty() || line.starts_with('#') { - continue; - } - - let mut columns: Vec<_> = line.split('\t').collect(); - if columns.len() == 6 { - columns.push(""); - } - assert_eq!( - columns.len(), - 7, - "macOS fixture row must have 7 columns: {line}" - ); - - let source = format!("{}:{}", columns[0], columns[1]); - let transformed = [ - source.as_str(), - columns[2], - columns[3], - columns[4], - columns[5], - columns[6], - ] - .join("\t"); - assert_fixture_corpus_parses(&transformed); - } -} - -#[test] -fn linux_terminal_variants_fixture_parses() { - let corpus = include_str!("../../tests/fixtures/linux_terminal_variants.tsv"); - assert_fixture_corpus_parses(corpus); -} - -#[test] -fn protocol_from_zero_flags_is_legacy() { - assert_eq!( - KeyboardProtocol::from_kitty_flags(0), - KeyboardProtocol::Legacy - ); -} - -#[test] -fn protocol_from_nonzero_flags_is_kitty() { - assert_eq!( - KeyboardProtocol::from_kitty_flags(7), - KeyboardProtocol::Kitty { flags: 7 } - ); -} - -#[test] -fn chinese_char_encodes_as_utf8() { - let key = TerminalKey::new(KeyCode::Char('中'), KeyModifiers::empty()); - let encoded = encode_terminal_key(key, KeyboardProtocol::Legacy); - assert_eq!(encoded, "中".as_bytes()); -} - -#[test] -fn chinese_char_with_kitty_protocol_encodes_as_utf8() { - let key = TerminalKey::new(KeyCode::Char('文'), KeyModifiers::empty()); - let encoded = encode_terminal_key(key, KeyboardProtocol::Kitty { flags: 7 }); - assert_eq!(encoded, "文".as_bytes()); -} - -#[test] -fn chinese_char_with_modifiers_falls_back_to_kitty_encoding() { - let key = TerminalKey::new(KeyCode::Char('测'), KeyModifiers::ALT); - let encoded = encode_terminal_key(key, KeyboardProtocol::Kitty { flags: 7 }); - assert!(!encoded.is_empty()); - assert_ne!(encoded, "测".as_bytes()); -} diff --git a/src/ipc.rs b/src/ipc.rs new file mode 100644 index 00000000..aa0148a1 --- /dev/null +++ b/src/ipc.rs @@ -0,0 +1,46 @@ +use std::fs; +use std::io; +use std::os::unix::fs::PermissionsExt; +use std::os::unix::net::UnixStream; +use std::path::Path; + +pub(crate) fn prepare_socket_path( + path: &Path, + busy_message: impl FnOnce(&Path) -> String, +) -> io::Result<()> { + if let Some(parent) = path.parent() { + fs::create_dir_all(parent)?; + } + + if !path.exists() { + return Ok(()); + } + + match UnixStream::connect(path) { + Ok(_) => { + return Err(io::Error::new(io::ErrorKind::AddrInUse, busy_message(path))); + } + Err(err) + if matches!( + err.kind(), + io::ErrorKind::ConnectionRefused + | io::ErrorKind::NotFound + | io::ErrorKind::TimedOut + ) => {} + Err(err) => return Err(err), + } + + if let Err(err) = fs::remove_file(path) { + if err.kind() != io::ErrorKind::NotFound { + return Err(err); + } + } + + Ok(()) +} + +pub(crate) fn restrict_socket_permissions(path: &Path, mode: u32) -> io::Result<()> { + let mut permissions = fs::metadata(path)?.permissions(); + permissions.set_mode(mode); + fs::set_permissions(path, permissions) +} diff --git a/src/logging.rs b/src/logging.rs new file mode 100644 index 00000000..899a9588 --- /dev/null +++ b/src/logging.rs @@ -0,0 +1,29 @@ +pub(crate) fn init_file_logging(file_name: &str) { + use std::fs::{self, OpenOptions}; + use tracing_subscriber::EnvFilter; + + let log_dir = crate::config::config_dir(); + let _ = fs::create_dir_all(&log_dir); + let log_path = log_dir.join(file_name); + + if let Ok(meta) = fs::metadata(&log_path) { + if meta.len() > 5 * 1024 * 1024 { + let _ = fs::remove_file(&log_path); + } + } + + let file = match OpenOptions::new().create(true).append(true).open(&log_path) { + Ok(file) => file, + Err(_) => return, + }; + + let filter = + EnvFilter::try_from_env("HERDR_LOG").unwrap_or_else(|_| EnvFilter::new("herdr=info")); + + let _ = tracing_subscriber::fmt() + .with_env_filter(filter) + .with_writer(file) + .with_ansi(false) + .with_target(false) + .try_init(); +} diff --git a/src/main.rs b/src/main.rs index c990f793..2637668e 100644 --- a/src/main.rs +++ b/src/main.rs @@ -21,19 +21,23 @@ const NESTED_HERDR_MESSAGES: [&str; 6] = [ mod api; mod app; mod cli; +mod client; mod config; mod detect; mod events; mod ghostty; mod input; mod integration; +mod ipc; mod layout; +mod logging; mod pane; mod persist; mod platform; mod raw_input; mod release_notes; mod selection; +mod server; mod sound; mod terminal_theme; mod ui; @@ -41,34 +45,7 @@ mod update; mod workspace; fn init_logging() { - use std::fs::{self, OpenOptions}; - use tracing_subscriber::EnvFilter; - - let log_dir = crate::config::config_dir(); - let _ = fs::create_dir_all(&log_dir); - let log_path = log_dir.join("herdr.log"); - - // Rotate: truncate if over 5MB - if let Ok(meta) = fs::metadata(&log_path) { - if meta.len() > 5 * 1024 * 1024 { - let _ = fs::remove_file(&log_path); - } - } - - let file = match OpenOptions::new().create(true).append(true).open(&log_path) { - Ok(f) => f, - Err(_) => return, // can't open log file, proceed without logging - }; - - let filter = - EnvFilter::try_from_env("HERDR_LOG").unwrap_or_else(|_| EnvFilter::new("herdr=info")); - - tracing_subscriber::fmt() - .with_env_filter(filter) - .with_writer(file) - .with_ansi(false) - .with_target(false) - .init(); + crate::logging::init_file_logging("herdr.log"); } const DEFAULT_CONFIG: &str = r##"# herdr configuration @@ -102,9 +79,10 @@ const DEFAULT_CONFIG: &str = r##"# herdr configuration # Navigate-mode actions # new_workspace = "n" # rename_workspace = "shift+n" -# close_workspace = "d" +# close_workspace = "shift+d" # previous_workspace = "" # optional, unset by default # next_workspace = "" # optional, unset by default +# detach = "" # optional explicit detach shortcut in server/client mode # new_tab = "c" # rename_tab = "" # optional, unset by default # previous_tab = "" # optional, unset by default @@ -184,6 +162,15 @@ fn main() -> io::Result<()> { } // Subcommands and flags (no TUI, no logging needed) + if args.get(1).map(|s| s.as_str()) == Some("server") { + return server::headless::run_server(); + } + + // Client mode: connect to an existing server's client socket. + if args.get(1).map(|s| s.as_str()) == Some("client") { + return client::run_client(); + } + if args.get(1).map(|s| s.as_str()) == Some("update") { match update::self_update() { Ok(_) => return Ok(()), @@ -199,6 +186,7 @@ fn main() -> io::Result<()> { println!(); println!("Usage: herdr [options]"); println!(" herdr update"); + println!(" herdr server stop"); println!(" herdr workspace <subcommand> ..."); println!(" herdr tab <subcommand> ..."); println!(" herdr pane <subcommand> ..."); @@ -206,7 +194,12 @@ fn main() -> io::Result<()> { println!(" herdr integration <subcommand> ..."); println!(); println!("Commands:"); - println!(" update Download and install the latest version"); + println!(" server Run as headless server (no terminal, persists after client disconnect)"); + println!(" server stop Stop the running server via the API socket"); + println!(" client Connect to a running server as a thin client"); + println!( + " update Download and install the latest version (run outside herdr)" + ); println!(" workspace workspace helpers over the socket api"); println!(" tab tab helpers over the socket api"); println!(" pane pane control helpers over the socket api"); @@ -214,7 +207,7 @@ fn main() -> io::Result<()> { println!(" integration manage built-in agent integrations"); println!(); println!("Options:"); - println!(" --no-session Don't restore or save sessions"); + println!(" --no-session Run monolithically (no server/client, escape hatch)"); println!(" --default-config Print default configuration and exit"); println!(" --version, -V Print version and exit"); println!(" --show-changelog Preview the current version's release notes"); @@ -257,7 +250,16 @@ fn main() -> io::Result<()> { std::process::exit(1); } if !arg.starts_with('-') - && !["update", "workspace", "pane", "wait", "integration"].contains(&arg.as_str()) + && ![ + "server", + "client", + "update", + "workspace", + "pane", + "wait", + "integration", + ] + .contains(&arg.as_str()) { eprintln!("unknown command: {arg}"); eprintln!("run 'herdr --help' for usage"); @@ -274,6 +276,18 @@ fn main() -> io::Result<()> { std::process::exit(1); } + let no_session = args.iter().any(|a| a == "--no-session"); + + // Auto-detect launch: when --no-session is NOT set, use server/client mode. + // Check if a server is running, spawn one if needed, then attach as client. + if !no_session { + init_logging(); + return server::autodetect::auto_detect_launch(); + } + + // --- Monolithic mode (--no-session escape hatch) --- + // This is the pre-mission single-process behavior. + init_logging(); let (api_tx, api_rx) = tokio::sync::mpsc::unbounded_channel(); @@ -288,8 +302,7 @@ fn main() -> io::Result<()> { Err(err) => return Err(err), }; - let no_session = std::env::args().any(|a| a == "--no-session"); - let show_changelog = std::env::args().any(|a| a == "--show-changelog"); + let show_changelog = args.iter().any(|a| a == "--show-changelog"); let in_tmux = std::env::var("TMUX").is_ok(); let original_hook = std::panic::take_hook(); @@ -321,7 +334,7 @@ fn main() -> io::Result<()> { loaded_config.diagnostics.len() - 1 )) }; - info!("herdr starting, pid={}", std::process::id()); + info!("herdr starting (monolithic), pid={}", std::process::id()); // Background update check (non-blocking, best-effort) // Only checks for newer versions and notifies the TUI. @@ -362,7 +375,7 @@ fn main() -> io::Result<()> { let mut app = app::App::new( config, - no_session, + true, // no_session — monolithic mode never saves/restores sessions config_diagnostic, startup_release_notes, api_rx, diff --git a/src/pane.rs b/src/pane.rs index fb34b6ab..eb37d0c1 100644 --- a/src/pane.rs +++ b/src/pane.rs @@ -1,4 +1,3 @@ -use std::borrow::Cow; use std::cell::Cell; use std::io::{BufWriter, Read, Write}; use std::sync::{ @@ -8,19 +7,29 @@ use std::sync::{ use bytes::Bytes; use portable_pty::{native_pty_system, CommandBuilder, PtySize}; -use ratatui::style::{Color, Modifier, Style}; use ratatui::{layout::Rect, Frame}; use tokio::sync::{mpsc, Notify}; use tracing::{debug, error, info, warn}; -use unicode_width::UnicodeWidthStr; use crate::detect::{Agent, AgentState}; use crate::events::AppEvent; use crate::layout::PaneId; -const CLAUDE_WORKING_HOLD: std::time::Duration = std::time::Duration::from_millis(1200); +mod input; +mod osc; +mod state; +mod terminal; + +use self::{ + state::stabilize_agent_state, + terminal::{GhosttyPaneTerminal, PaneTerminal}, +}; +pub use self::{ + state::{EffectiveStateChange, PaneState}, + terminal::{InputState, ScrollMetrics}, +}; + const RELEASE_REACQUIRE_SUPPRESSION: std::time::Duration = std::time::Duration::from_secs(1); -const DEFAULT_DETECTION_ROWS: usize = 24; #[derive(Debug, Clone, Copy)] struct PendingAgentRelease { @@ -68,196 +77,50 @@ async fn publish_state_changed_event( } } -fn stabilize_agent_state( - agent: Option<Agent>, - previous: AgentState, - raw: AgentState, - now: std::time::Instant, - last_claude_working_at: &mut Option<std::time::Instant>, -) -> AgentState { - if agent != Some(Agent::Claude) { - return raw; - } - - match raw { - AgentState::Working => { - *last_claude_working_at = Some(now); - AgentState::Working - } - AgentState::Blocked => AgentState::Blocked, - AgentState::Idle if previous == AgentState::Working => { - if last_claude_working_at - .is_some_and(|last_working| now.duration_since(last_working) < CLAUDE_WORKING_HOLD) - { - AgentState::Working - } else { - AgentState::Idle - } - } - _ => raw, - } -} +const AGENT_MISS_CONFIRMATION_ATTEMPTS: u8 = 6; -// --------------------------------------------------------------------------- -// PaneState — pure data, constructable without PTYs, testable -// --------------------------------------------------------------------------- - -#[derive(Debug, Clone, PartialEq, Eq)] -pub struct HookAuthority { - pub source: String, - pub agent_label: String, - pub state: AgentState, - pub message: Option<String>, -} - -#[derive(Debug, Clone, PartialEq, Eq)] -pub struct EffectiveStateChange { - pub previous_agent_label: Option<String>, - pub previous_known_agent: Option<Agent>, - pub previous_state: AgentState, - pub agent_label: Option<String>, - pub known_agent: Option<Agent>, - pub state: AgentState, -} - -/// Observable state for a single pane. -/// This is the only part of a pane that workspace logic and tests need. -pub struct PaneState { - pub detected_agent: Option<Agent>, - pub fallback_state: AgentState, - pub hook_authority: Option<HookAuthority>, - pub state: AgentState, - /// Whether the user has seen this pane since its last state change to Idle. - /// False = "Done" (agent finished while user was in another workspace). - pub seen: bool, +#[derive(Debug, Clone, Copy)] +struct AgentDetectionPresence { + current_agent: Option<Agent>, + consecutive_misses: u8, } -impl PaneState { - pub fn new() -> Self { +impl AgentDetectionPresence { + fn from_agent(current_agent: Option<Agent>) -> Self { Self { - detected_agent: None, - fallback_state: AgentState::Unknown, - hook_authority: None, - state: AgentState::Unknown, - seen: true, + current_agent, + consecutive_misses: 0, } } - pub fn set_detected_state( - &mut self, - agent: Option<Agent>, - fallback_state: AgentState, - ) -> Option<EffectiveStateChange> { - let previous_agent_label = self.effective_agent_label().map(str::to_string); - let previous_known_agent = self.effective_known_agent(); - let previous_state = self.state; - self.detected_agent = agent; - self.fallback_state = fallback_state; - self.recompute_effective_state(previous_agent_label, previous_known_agent, previous_state) - } - - pub fn set_hook_authority( - &mut self, - source: String, - agent_label: String, - state: AgentState, - message: Option<String>, - ) -> Option<EffectiveStateChange> { - let previous_agent_label = self.effective_agent_label().map(str::to_string); - let previous_known_agent = self.effective_known_agent(); - let previous_state = self.state; - self.hook_authority = Some(HookAuthority { - source, - agent_label, - state, - message, - }); - self.recompute_effective_state(previous_agent_label, previous_known_agent, previous_state) + fn current_agent(&self) -> Option<Agent> { + self.current_agent } - pub fn clear_hook_authority(&mut self, source: Option<&str>) -> Option<EffectiveStateChange> { - let previous_agent_label = self.effective_agent_label().map(str::to_string); - let previous_known_agent = self.effective_known_agent(); - let previous_state = self.state; - let should_clear = self - .hook_authority - .as_ref() - .is_some_and(|authority| source.is_none_or(|source| authority.source == source)); - if !should_clear { - return None; - } - self.hook_authority = None; - self.recompute_effective_state(previous_agent_label, previous_known_agent, previous_state) - } - - pub fn release_agent( - &mut self, - source: &str, - agent_label: &str, - ) -> Option<EffectiveStateChange> { - let Some(current_agent_label) = self.effective_agent_label() else { - return None; - }; - if current_agent_label != agent_label { - return None; - } - - if self.hook_authority.as_ref().is_some_and(|authority| { - authority.agent_label != agent_label || authority.source != source - }) { - return None; - } - - let previous_agent_label = self.effective_agent_label().map(str::to_string); - let previous_known_agent = self.effective_known_agent(); - let previous_state = self.state; - self.detected_agent = None; - self.fallback_state = AgentState::Unknown; - self.hook_authority = None; - self.recompute_effective_state(previous_agent_label, previous_known_agent, previous_state) - } - - pub fn effective_agent_label(&self) -> Option<&str> { - self.hook_authority - .as_ref() - .map(|authority| authority.agent_label.as_str()) - .or_else(|| self.detected_agent.map(crate::detect::agent_label)) - } - - pub fn effective_known_agent(&self) -> Option<Agent> { - if let Some(authority) = &self.hook_authority { - return crate::detect::parse_agent_label(&authority.agent_label); + fn observe_process_probe(&mut self, identified_agent: Option<Agent>) -> bool { + match identified_agent { + Some(agent) => { + self.consecutive_misses = 0; + if Some(agent) == self.current_agent { + return false; + } + self.current_agent = Some(agent); + true + } + None => { + if self.current_agent.is_none() { + self.consecutive_misses = 0; + return false; + } + self.consecutive_misses = self.consecutive_misses.saturating_add(1); + if self.consecutive_misses < AGENT_MISS_CONFIRMATION_ATTEMPTS { + return false; + } + self.current_agent = None; + self.consecutive_misses = 0; + true + } } - self.detected_agent - } - - fn recompute_effective_state( - &mut self, - previous_agent_label: Option<String>, - previous_known_agent: Option<Agent>, - previous_state: AgentState, - ) -> Option<EffectiveStateChange> { - let state = self - .hook_authority - .as_ref() - .map(|authority| authority.state) - .unwrap_or(self.fallback_state); - let agent_label = self.effective_agent_label().map(str::to_string); - let known_agent = self.effective_known_agent(); - - if previous_agent_label == agent_label && previous_state == state { - return None; - } - - self.state = state; - Some(EffectiveStateChange { - previous_agent_label, - previous_known_agent, - previous_state, - agent_label, - known_agent, - state, - }) } } @@ -281,1461 +144,6 @@ pub struct PaneRuntime { } #[derive(Debug, Clone, Copy, PartialEq, Eq)] -pub struct ScrollMetrics { - pub offset_from_bottom: usize, - pub max_offset_from_bottom: usize, - pub viewport_rows: usize, -} - -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -pub struct InputState { - pub alternate_screen: bool, - pub application_cursor: bool, - pub bracketed_paste: bool, - pub focus_reporting: bool, - pub mouse_protocol_mode: crate::input::MouseProtocolMode, - pub mouse_protocol_encoding: crate::input::MouseProtocolEncoding, - pub mouse_alternate_scroll: bool, -} - -impl InputState { - pub fn mouse_reporting_enabled(self) -> bool { - self.mouse_protocol_mode.reporting_enabled() - } -} - -#[derive(Debug, Clone, PartialEq, Eq)] -struct ProcessBytesResult { - request_render: bool, - clipboard_writes: Vec<Vec<u8>>, -} - -struct GhosttyPaneTerminal { - core: Mutex<GhosttyPaneCore>, - key_encoder: Mutex<crate::ghostty::KeyEncoder>, -} - -struct GhosttyPaneCore { - terminal: crate::ghostty::Terminal, - render_state: crate::ghostty::RenderState, - host_terminal_theme: crate::terminal_theme::TerminalTheme, - transient_default_color_owner_pgid: Option<u32>, - default_color_tracker: DefaultColorOscTracker, - osc52_forwarder: Osc52Forwarder, -} - -#[derive(Debug, Default)] -struct DefaultColorOscTracker { - state: DefaultColorOscTrackerState, - body: Vec<u8>, -} - -#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] -enum DefaultColorOscTrackerState { - #[default] - Ground, - Escape, - OscBody, - OscEscape, -} - -impl DefaultColorOscTracker { - fn observe(&mut self, bytes: &[u8]) -> bool { - let mut saw_default_color_set = false; - - for &byte in bytes { - match self.state { - DefaultColorOscTrackerState::Ground => { - if byte == 0x1b { - self.state = DefaultColorOscTrackerState::Escape; - } - } - DefaultColorOscTrackerState::Escape => { - if byte == b']' { - self.body.clear(); - self.state = DefaultColorOscTrackerState::OscBody; - } else if byte == 0x1b { - self.state = DefaultColorOscTrackerState::Escape; - } else { - self.state = DefaultColorOscTrackerState::Ground; - } - } - DefaultColorOscTrackerState::OscBody => match byte { - 0x07 => { - saw_default_color_set |= is_default_color_set_osc(&self.body); - self.body.clear(); - self.state = DefaultColorOscTrackerState::Ground; - } - 0x1b => self.state = DefaultColorOscTrackerState::OscEscape, - _ => self.body.push(byte), - }, - DefaultColorOscTrackerState::OscEscape => { - if byte == b'\\' { - saw_default_color_set |= is_default_color_set_osc(&self.body); - self.body.clear(); - self.state = DefaultColorOscTrackerState::Ground; - } else { - self.body.push(0x1b); - self.body.push(byte); - self.state = DefaultColorOscTrackerState::OscBody; - } - } - } - - if self.body.len() > 1024 { - self.body.clear(); - self.state = DefaultColorOscTrackerState::Ground; - } - } - - saw_default_color_set - } -} - -fn is_default_color_set_osc(body: &[u8]) -> bool { - let Some(separator) = body.iter().position(|byte| *byte == b';') else { - return false; - }; - let command = &body[..separator]; - let value = &body[separator + 1..]; - matches!(command, b"10" | b"11") && !value.is_empty() && value != b"?" -} - -/// 256 KiB of base64 ≈ 192 KiB of text — enough for real source-file copies -/// while still bounding memory against stream garbage. -const OSC52_MAX_PAYLOAD_BYTES: usize = 256 * 1024; - -#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] -enum Osc52ForwarderState { - #[default] - Ground, - Escape, - OscBody, - OscEscape, -} - -/// Reconstructs OSC 52 clipboard-write sequences from raw PTY bytes so the -/// main loop can re-emit them. `libghostty-vt` drops `.clipboard_contents`, -/// so child clipboard writes never reach the host terminal unless we forward -/// them ourselves. -#[derive(Debug, Default)] -struct Osc52Forwarder { - state: Osc52ForwarderState, - body: Vec<u8>, - pending: Vec<Vec<u8>>, -} - -impl Osc52Forwarder { - fn observe(&mut self, bytes: &[u8]) { - for &byte in bytes { - match self.state { - Osc52ForwarderState::Ground => { - if byte == 0x1b { - self.state = Osc52ForwarderState::Escape; - } - } - Osc52ForwarderState::Escape => { - if byte == b']' { - self.body.clear(); - self.state = Osc52ForwarderState::OscBody; - } else if byte == 0x1b { - self.state = Osc52ForwarderState::Escape; - } else { - self.state = Osc52ForwarderState::Ground; - } - } - Osc52ForwarderState::OscBody => match byte { - 0x07 => { - self.finalize(); - self.state = Osc52ForwarderState::Ground; - } - 0x1b => self.state = Osc52ForwarderState::OscEscape, - _ => self.body.push(byte), - }, - Osc52ForwarderState::OscEscape => { - if byte == b'\\' { - self.finalize(); - self.state = Osc52ForwarderState::Ground; - } else { - self.body.push(0x1b); - self.body.push(byte); - self.state = Osc52ForwarderState::OscBody; - } - } - } - - if self.body.len() > OSC52_MAX_PAYLOAD_BYTES { - self.body.clear(); - self.state = Osc52ForwarderState::Ground; - } - } - } - - fn finalize(&mut self) { - if let Some(content) = parse_osc52_clipboard_write(&self.body) { - self.pending.push(content); - } - self.body.clear(); - } - - fn drain_pending(&mut self) -> Vec<Vec<u8>> { - std::mem::take(&mut self.pending) - } -} - -/// Accepts `52;c;<base64>` and `52;;<base64>`. -/// Queries (`?`) are rejected because herdr has no reply path. -/// The payload must decode as base64 before it is forwarded. -fn parse_osc52_clipboard_write(body: &[u8]) -> Option<Vec<u8>> { - use base64::Engine; - - let rest = body.strip_prefix(b"52;")?; - let sep = rest.iter().position(|b| *b == b';')?; - let selector = &rest[..sep]; - let data = &rest[sep + 1..]; - if !(selector.is_empty() || selector == b"c") || data == b"?" { - return None; - } - base64::engine::general_purpose::STANDARD.decode(data).ok() -} - -fn foreground_job_is_shell(job: &crate::platform::ForegroundJob, shell_pid: u32) -> bool { - job.processes.iter().any(|process| process.pid == shell_pid) -} - -fn current_transient_default_color_owner(shell_pid: u32) -> Option<u32> { - let job = crate::detect::foreground_job(shell_pid)?; - (!foreground_job_is_shell(&job, shell_pid)).then_some(job.process_group_id) -} - -fn foreground_job_uses_droid_scrollback_compat(job: &crate::platform::ForegroundJob) -> bool { - job.processes.iter().any(|process| { - process.name.eq_ignore_ascii_case("droid") - || process - .argv0 - .as_deref() - .is_some_and(|argv0| argv0.eq_ignore_ascii_case("droid")) - || process.cmdline.as_deref().is_some_and(|cmdline| { - cmdline.eq_ignore_ascii_case("droid") - || cmdline.starts_with("droid ") - || cmdline.to_ascii_lowercase().contains("/droid") - }) - }) -} - -fn contains_scrollback_clear_sequence(bytes: &[u8]) -> bool { - bytes.windows(4).any(|window| window == b"\x1b[3J") - || bytes.windows(5).any(|window| window == b"\x1b[?3J") -} - -fn strip_scrollback_clear_sequences<'a>(bytes: &'a [u8]) -> Cow<'a, [u8]> { - if !contains_scrollback_clear_sequence(bytes) { - return Cow::Borrowed(bytes); - } - - let mut filtered = Vec::with_capacity(bytes.len()); - let mut index = 0; - while index < bytes.len() { - let remaining = &bytes[index..]; - if remaining.starts_with(b"\x1b[3J") { - index += 4; - continue; - } - if remaining.starts_with(b"\x1b[?3J") { - index += 5; - continue; - } - filtered.push(bytes[index]); - index += 1; - } - - Cow::Owned(filtered) -} - -fn maybe_filter_primary_screen_scrollback_clear<'a>( - bytes: &'a [u8], - alternate_screen: bool, - foreground_job: Option<&crate::platform::ForegroundJob>, -) -> Cow<'a, [u8]> { - // Droid redraws its primary-screen TUI with CSI 3 J, which erases pane - // scrollback inside herdr. Keep the hack scoped to Droid on the primary - // screen so normal terminal clear-history behavior still works elsewhere. - if alternate_screen - || !contains_scrollback_clear_sequence(bytes) - || !foreground_job.is_some_and(foreground_job_uses_droid_scrollback_compat) - { - return Cow::Borrowed(bytes); - } - - strip_scrollback_clear_sequences(bytes) -} - -#[cfg(target_os = "macos")] -fn should_restore_host_terminal_theme( - owner_pgid: u32, - shell_pid: u32, - alternate_screen: bool, - foreground_job: Option<&crate::platform::ForegroundJob>, -) -> bool { - if alternate_screen { - return false; - } - - let Some(foreground_job) = foreground_job else { - return false; - }; - - let _ = owner_pgid; - foreground_job_is_shell(foreground_job, shell_pid) -} - -#[cfg(not(target_os = "macos"))] -fn should_restore_host_terminal_theme( - owner_pgid: u32, - shell_pid: u32, - alternate_screen: bool, - foreground_job: Option<&crate::platform::ForegroundJob>, -) -> bool { - if alternate_screen { - return false; - } - - let Some(foreground_job) = foreground_job else { - return false; - }; - - foreground_job.process_group_id != owner_pgid - && foreground_job_is_shell(foreground_job, shell_pid) -} - -fn write_host_terminal_theme( - terminal: &mut crate::ghostty::Terminal, - theme: crate::terminal_theme::TerminalTheme, -) { - if let Some(color) = theme.foreground { - let sequence = crate::terminal_theme::osc_set_default_color_sequence( - crate::terminal_theme::DefaultColorKind::Foreground, - color, - ); - terminal.write(sequence.as_bytes()); - } - if let Some(color) = theme.background { - let sequence = crate::terminal_theme::osc_set_default_color_sequence( - crate::terminal_theme::DefaultColorKind::Background, - color, - ); - terminal.write(sequence.as_bytes()); - } -} - -fn restore_host_terminal_theme_if_needed( - core: &mut GhosttyPaneCore, - pane_id: PaneId, - shell_pid: u32, - alternate_screen: bool, - foreground_job: Option<&crate::platform::ForegroundJob>, -) -> bool { - let Some(owner_pgid) = core.transient_default_color_owner_pgid else { - return false; - }; - if core.host_terminal_theme.is_empty() { - return false; - } - if !should_restore_host_terminal_theme(owner_pgid, shell_pid, alternate_screen, foreground_job) - { - return false; - } - - core.transient_default_color_owner_pgid = None; - write_host_terminal_theme(&mut core.terminal, core.host_terminal_theme); - info!( - pane = pane_id.raw(), - owner_pgid, "restored host terminal default colors after transient override" - ); - true -} - -struct PaneTerminal { - ghostty: GhosttyPaneTerminal, -} - -impl PaneTerminal { - fn process_pty_bytes( - &self, - pane_id: PaneId, - shell_pid: u32, - bytes: &[u8], - response_writer: &mpsc::Sender<Bytes>, - ) -> ProcessBytesResult { - self.ghostty - .process_pty_bytes(pane_id, shell_pid, bytes, response_writer) - } - - fn resize(&self, rows: u16, cols: u16) { - self.ghostty.resize(rows, cols); - } - - fn scroll_up(&self, lines: usize) { - self.ghostty.scroll_up(lines); - } - - fn scroll_down(&self, lines: usize) { - self.ghostty.scroll_down(lines); - } - - fn scroll_reset(&self) { - self.ghostty.scroll_reset(); - } - - fn set_scroll_offset_from_bottom(&self, lines: usize) { - self.ghostty.set_scroll_offset_from_bottom(lines); - } - - fn scroll_metrics(&self) -> Option<ScrollMetrics> { - self.ghostty.scroll_metrics() - } - - fn input_state(&self) -> Option<InputState> { - self.ghostty.input_state() - } - - fn visible_text(&self) -> String { - self.ghostty.visible_text() - } - - fn detection_text(&self) -> String { - self.ghostty.detection_text() - } - - fn recent_text(&self, lines: usize) -> String { - self.ghostty.recent_text(lines) - } - - fn recent_unwrapped_text(&self, lines: usize) -> String { - self.ghostty.recent_unwrapped_text(lines) - } - - fn extract_selection(&self, selection: &crate::selection::Selection) -> Option<String> { - self.ghostty.extract_selection(selection) - } - - fn render(&self, frame: &mut Frame, area: Rect, show_cursor: bool) { - self.ghostty.render(frame, area, show_cursor); - } - - fn apply_host_terminal_theme(&self, theme: crate::terminal_theme::TerminalTheme) { - self.ghostty.apply_host_terminal_theme(theme); - } - - fn has_transient_default_color_override(&self) -> bool { - self.ghostty.has_transient_default_color_override() - } - - fn maybe_restore_host_terminal_theme(&self, pane_id: PaneId, shell_pid: u32) -> bool { - self.ghostty - .maybe_restore_host_terminal_theme(pane_id, shell_pid) - } - - fn keyboard_protocol( - &self, - fallback: crate::input::KeyboardProtocol, - ) -> crate::input::KeyboardProtocol { - self.ghostty.keyboard_protocol().unwrap_or(fallback) - } - - fn encode_terminal_key( - &self, - key: crate::input::TerminalKey, - protocol: crate::input::KeyboardProtocol, - ) -> Vec<u8> { - self.ghostty.encode_terminal_key(key, protocol) - } - - fn encode_mouse_button( - &self, - kind: crossterm::event::MouseEventKind, - column: u16, - row: u16, - modifiers: crossterm::event::KeyModifiers, - ) -> Option<Vec<u8>> { - self.ghostty - .encode_mouse_button(kind, column, row, modifiers) - } - - fn encode_mouse_wheel( - &self, - kind: crossterm::event::MouseEventKind, - column: u16, - row: u16, - modifiers: crossterm::event::KeyModifiers, - ) -> Option<Vec<u8>> { - self.ghostty - .encode_mouse_wheel(kind, column, row, modifiers) - } -} - -impl GhosttyPaneTerminal { - fn new( - mut terminal: crate::ghostty::Terminal, - response_writer: mpsc::Sender<Bytes>, - ) -> std::io::Result<Self> { - terminal - .set_write_pty_callback(move |bytes| { - let _ = response_writer.try_send(Bytes::copy_from_slice(bytes)); - }) - .map_err(|e| std::io::Error::other(e.to_string()))?; - - let render_state = - crate::ghostty::RenderState::new().map_err(|e| std::io::Error::other(e.to_string()))?; - let mut key_encoder = - crate::ghostty::KeyEncoder::new().map_err(|e| std::io::Error::other(e.to_string()))?; - key_encoder.set_from_terminal(&terminal); - Ok(Self { - core: Mutex::new(GhosttyPaneCore { - terminal, - render_state, - host_terminal_theme: crate::terminal_theme::TerminalTheme::default(), - transient_default_color_owner_pgid: None, - default_color_tracker: DefaultColorOscTracker::default(), - osc52_forwarder: Osc52Forwarder::default(), - }), - key_encoder: Mutex::new(key_encoder), - }) - } - - fn apply_host_terminal_theme(&self, theme: crate::terminal_theme::TerminalTheme) { - if let Ok(mut core) = self.core.lock() { - core.host_terminal_theme = theme; - core.transient_default_color_owner_pgid = None; - write_host_terminal_theme(&mut core.terminal, theme); - } - } - - fn has_transient_default_color_override(&self) -> bool { - self.core - .lock() - .map(|core| core.transient_default_color_owner_pgid.is_some()) - .unwrap_or(false) - } - - fn maybe_restore_host_terminal_theme(&self, pane_id: PaneId, shell_pid: u32) -> bool { - let foreground_job = crate::detect::foreground_job(shell_pid); - let Ok(mut core) = self.core.lock() else { - return false; - }; - - let alternate_screen = core - .terminal - .active_screen() - .map(|screen| screen == crate::ghostty::ActiveScreen::Alternate) - .unwrap_or(false); - restore_host_terminal_theme_if_needed( - &mut core, - pane_id, - shell_pid, - alternate_screen, - foreground_job.as_ref(), - ) - } - - fn process_pty_bytes( - &self, - pane_id: PaneId, - shell_pid: u32, - bytes: &[u8], - response_writer: &mpsc::Sender<Bytes>, - ) -> ProcessBytesResult { - let Ok(mut core) = self.core.lock() else { - error!(pane = pane_id.raw(), "ghostty core lock poisoned in reader"); - return ProcessBytesResult { - request_render: false, - clipboard_writes: Vec::new(), - }; - }; - - if shell_pid > 0 && core.default_color_tracker.observe(bytes) { - if let Some(owner_pgid) = current_transient_default_color_owner(shell_pid) { - core.transient_default_color_owner_pgid = Some(owner_pgid); - debug!( - pane = pane_id.raw(), - owner_pgid, "tracked transient default color override" - ); - } - } - - core.osc52_forwarder.observe(bytes); - let clipboard_writes = core.osc52_forwarder.drain_pending(); - - let alternate_screen = core - .terminal - .active_screen() - .map(|screen| screen == crate::ghostty::ActiveScreen::Alternate) - .unwrap_or(false); - let filtered_bytes = if shell_pid > 0 { - let foreground_job = (!alternate_screen && contains_scrollback_clear_sequence(bytes)) - .then(|| crate::detect::foreground_job(shell_pid)) - .flatten(); - maybe_filter_primary_screen_scrollback_clear( - bytes, - alternate_screen, - foreground_job.as_ref(), - ) - } else { - Cow::Borrowed(bytes) - }; - if filtered_bytes.len() != bytes.len() { - debug!( - pane = pane_id.raw(), - shell_pid, "ignored scrollback clear sequence for droid compatibility" - ); - } - - core.terminal.write(filtered_bytes.as_ref()); - if let Ok(mut key_encoder) = self.key_encoder.lock() { - key_encoder.set_from_terminal(&core.terminal); - } - let synchronized_output = core - .terminal - .mode_get(crate::ghostty::MODE_SYNCHRONIZED_OUTPUT) - .unwrap_or(false); - let _ = response_writer; - ProcessBytesResult { - request_render: !synchronized_output, - clipboard_writes, - } - } - - fn resize(&self, rows: u16, cols: u16) { - if let Ok(mut core) = self.core.lock() { - let _ = core.terminal.resize(cols, rows); - } - } - - fn scroll_up(&self, lines: usize) { - if let Ok(mut core) = self.core.lock() { - core.terminal.scroll_viewport_delta(-(lines as isize)); - } - } - - fn scroll_down(&self, lines: usize) { - if let Ok(mut core) = self.core.lock() { - core.terminal.scroll_viewport_delta(lines as isize); - } - } - - fn scroll_reset(&self) { - if let Ok(mut core) = self.core.lock() { - core.terminal.scroll_viewport_bottom(); - } - } - - fn set_scroll_offset_from_bottom(&self, lines: usize) { - if let Ok(mut core) = self.core.lock() { - core.terminal.scroll_viewport_bottom(); - if lines > 0 { - core.terminal.scroll_viewport_delta(-(lines as isize)); - } - } - } - - fn scroll_metrics(&self) -> Option<ScrollMetrics> { - let Ok(core) = self.core.lock() else { - return None; - }; - let scrollbar = core.terminal.scrollbar().ok()?; - Some(ScrollMetrics { - offset_from_bottom: scrollbar - .total - .saturating_sub(scrollbar.offset + scrollbar.len), - max_offset_from_bottom: scrollbar.total.saturating_sub(scrollbar.len), - viewport_rows: scrollbar.len, - }) - } - - fn keyboard_protocol(&self) -> Option<crate::input::KeyboardProtocol> { - let Ok(core) = self.core.lock() else { - return None; - }; - Some(crate::input::KeyboardProtocol::from_kitty_flags( - core.terminal.kitty_keyboard_flags().ok()? as u16, - )) - } - - fn input_state(&self) -> Option<InputState> { - let Ok(core) = self.core.lock() else { - return None; - }; - let alternate_screen = - core.terminal.active_screen().ok()? == crate::ghostty::ActiveScreen::Alternate; - let application_cursor = core - .terminal - .mode_get(crate::ghostty::MODE_APPLICATION_CURSOR_KEYS) - .ok()?; - let bracketed_paste = core - .terminal - .mode_get(crate::ghostty::MODE_BRACKETED_PASTE) - .ok()?; - let focus_reporting = core - .terminal - .mode_get(crate::ghostty::MODE_FOCUS_EVENT) - .ok()?; - let mouse_sgr = core - .terminal - .mode_get(crate::ghostty::MODE_MOUSE_SGR) - .ok()?; - let mouse_utf8 = core - .terminal - .mode_get(crate::ghostty::MODE_MOUSE_UTF8) - .ok()?; - let mouse_alternate_scroll = core - .terminal - .mode_get(crate::ghostty::MODE_MOUSE_ALTERNATE_SCROLL) - .ok()?; - let mouse_protocol_mode = if core.terminal.mode_get(1003).ok()? { - crate::input::MouseProtocolMode::AnyMotion - } else if core.terminal.mode_get(1002).ok()? { - crate::input::MouseProtocolMode::ButtonMotion - } else if core.terminal.mode_get(1000).ok()? { - crate::input::MouseProtocolMode::PressRelease - } else if core.terminal.mode_get(9).ok()? { - crate::input::MouseProtocolMode::Press - } else { - crate::input::MouseProtocolMode::None - }; - let mouse_protocol_encoding = if mouse_sgr { - crate::input::MouseProtocolEncoding::Sgr - } else if mouse_utf8 { - crate::input::MouseProtocolEncoding::Utf8 - } else { - crate::input::MouseProtocolEncoding::Default - }; - Some(InputState { - alternate_screen, - application_cursor, - bracketed_paste, - focus_reporting, - mouse_protocol_mode, - mouse_protocol_encoding, - mouse_alternate_scroll, - }) - } - - fn encode_terminal_key( - &self, - key: crate::input::TerminalKey, - protocol: crate::input::KeyboardProtocol, - ) -> Vec<u8> { - if ghostty_prefers_herdr_text_encoding(key) { - return crate::input::encode_terminal_key(key, protocol); - } - - let Some(event) = ghostty_key_event_from_terminal_key(key) else { - return crate::input::encode_terminal_key(key, protocol); - }; - - let Ok(mut encoder) = self.key_encoder.lock() else { - return crate::input::encode_terminal_key(key, protocol); - }; - match encoder.encode(&event) { - Ok(bytes) if !bytes.is_empty() => bytes, - Ok(_) | Err(_) => crate::input::encode_terminal_key(key, protocol), - } - } - - fn encode_mouse_button( - &self, - kind: crossterm::event::MouseEventKind, - column: u16, - row: u16, - modifiers: crossterm::event::KeyModifiers, - ) -> Option<Vec<u8>> { - let Ok(core) = self.core.lock() else { - return None; - }; - let mut encoder = ghostty_mouse_encoder_for_terminal(&core.terminal)?; - let event = ghostty_mouse_event_from_button_kind(kind, column, row, modifiers)?; - encoder.encode(&event).ok() - } - - fn encode_mouse_wheel( - &self, - kind: crossterm::event::MouseEventKind, - column: u16, - row: u16, - modifiers: crossterm::event::KeyModifiers, - ) -> Option<Vec<u8>> { - let Ok(core) = self.core.lock() else { - return None; - }; - let mut encoder = ghostty_mouse_encoder_for_terminal(&core.terminal)?; - let event = ghostty_mouse_event_from_wheel_kind(kind, column, row, modifiers)?; - encoder.encode(&event).ok() - } - - fn visible_text(&self) -> String { - self.core - .lock() - .ok() - .and_then(|mut core| ghostty_visible_text(&mut core).ok()) - .unwrap_or_default() - } - - fn detection_text(&self) -> String { - self.core - .lock() - .ok() - .and_then(|core| ghostty_detection_text(&core).ok()) - .unwrap_or_default() - } - - fn recent_text(&self, lines: usize) -> String { - self.core - .lock() - .ok() - .and_then(|core| ghostty_recent_text(&core, lines).ok()) - .unwrap_or_default() - } - - fn recent_unwrapped_text(&self, lines: usize) -> String { - self.core - .lock() - .ok() - .and_then(|core| ghostty_recent_text_unwrapped(&core, lines).ok()) - .unwrap_or_default() - } - - fn extract_selection(&self, selection: &crate::selection::Selection) -> Option<String> { - self.core - .lock() - .ok() - .and_then(|mut core| ghostty_extract_selection(&mut core, selection).ok()) - } - - fn render(&self, frame: &mut Frame, area: Rect, show_cursor: bool) { - let Ok(mut core) = self.core.lock() else { - return; - }; - let host_theme = core.host_terminal_theme; - let GhosttyPaneCore { - terminal, - render_state, - .. - } = &mut *core; - if render_state.update(terminal).is_err() { - return; - } - let colors = render_state.colors().ok(); - let default_bg = colors.and_then(|c| ghostty_default_bg(c.background, host_theme)); - let default_fg = colors.map(|c| ghostty_color(c.foreground)); - - let mut row_iterator = match crate::ghostty::RowIterator::new() { - Ok(iterator) => iterator, - Err(_) => return, - }; - let mut row_cells = match crate::ghostty::RowCells::new() { - Ok(cells) => cells, - Err(_) => return, - }; - { - let buf = frame.buffer_mut(); - let mut rows = match render_state.populate_row_iterator(&mut row_iterator) { - Ok(rows) => rows, - Err(_) => return, - }; - let mut y = 0u16; - while y < area.height && rows.next() { - let mut cells = match rows.populate_cells(&mut row_cells) { - Ok(cells) => cells, - Err(_) => break, - }; - let mut x = 0u16; - while x < area.width && cells.next() { - let wide = cells.wide().unwrap_or(crate::ghostty::CellWide::Narrow); - let style = ghostty_cell_style(&cells, default_fg, default_bg); - let symbol = ghostty_buffer_symbol(&cells, wide) - .unwrap_or_else(|_| ghostty_blank_symbol_for_width(wide).to_string()); - let cell = &mut buf[(area.x + x, area.y + y)]; - cell.reset(); - cell.set_symbol(&symbol); - cell.set_style(style); - x += 1; - } - while x < area.width { - let cell = &mut buf[(area.x + x, area.y + y)]; - ghostty_reset_cell(cell, default_fg, default_bg); - x += 1; - } - y += 1; - } - while y < area.height { - for x in 0..area.width { - let cell = &mut buf[(area.x + x, area.y + y)]; - ghostty_reset_cell(cell, default_fg, default_bg); - } - y += 1; - } - } - - if show_cursor && render_state.cursor_visible().ok() == Some(true) { - if let Ok(Some(cursor)) = render_state.cursor_viewport() { - if cursor.x < area.width && cursor.y < area.height { - frame.set_cursor_position((area.x + cursor.x, area.y + cursor.y)); - } - } - } - } -} - -fn ghostty_key_event_from_terminal_key( - key: crate::input::TerminalKey, -) -> Option<crate::ghostty::KeyEvent> { - let mut event = crate::ghostty::KeyEvent::new().ok()?; - event.set_action(match key.kind { - crossterm::event::KeyEventKind::Press => { - crate::ghostty::ffi::GhosttyKeyAction_GHOSTTY_KEY_ACTION_PRESS - } - crossterm::event::KeyEventKind::Release => { - crate::ghostty::ffi::GhosttyKeyAction_GHOSTTY_KEY_ACTION_RELEASE - } - crossterm::event::KeyEventKind::Repeat => { - crate::ghostty::ffi::GhosttyKeyAction_GHOSTTY_KEY_ACTION_REPEAT - } - }); - event.set_mods(ghostty_mods_from_key_modifiers(key.modifiers)); - event.set_key(ghostty_key_from_crossterm_key_code( - key.code, - key.shifted_codepoint, - )?); - - if let Some(text) = ghostty_key_text(key) { - event.set_utf8(&text); - } else { - event.set_utf8(""); - } - - if let Some(codepoint) = ghostty_unshifted_codepoint(key) { - event.set_unshifted_codepoint(codepoint); - } - - Some(event) -} - -fn ghostty_prefers_herdr_text_encoding(key: crate::input::TerminalKey) -> bool { - matches!(key.code, crossterm::event::KeyCode::Char(_)) -} - -fn ghostty_mods_from_key_modifiers(modifiers: crossterm::event::KeyModifiers) -> u16 { - let mut ghostty_mods = 0u16; - if modifiers.contains(crossterm::event::KeyModifiers::SHIFT) { - ghostty_mods |= crate::ghostty::MOD_SHIFT; - } - if modifiers.contains(crossterm::event::KeyModifiers::CONTROL) { - ghostty_mods |= crate::ghostty::MOD_CTRL; - } - if modifiers.contains(crossterm::event::KeyModifiers::ALT) { - ghostty_mods |= crate::ghostty::MOD_ALT; - } - if modifiers.contains(crossterm::event::KeyModifiers::SUPER) { - ghostty_mods |= crate::ghostty::MOD_SUPER; - } - ghostty_mods -} - -fn ghostty_mouse_encoder_for_terminal( - terminal: &crate::ghostty::Terminal, -) -> Option<crate::ghostty::MouseEncoder> { - let mut encoder = crate::ghostty::MouseEncoder::new().ok()?; - encoder.set_from_terminal(terminal); - let cols = terminal.cols().ok()? as u32; - let rows = terminal.rows().ok()? as u32; - encoder.set_size(cols, rows, 1, 1); - Some(encoder) -} - -fn ghostty_mouse_event_from_button_kind( - kind: crossterm::event::MouseEventKind, - column: u16, - row: u16, - modifiers: crossterm::event::KeyModifiers, -) -> Option<crate::ghostty::MouseEvent> { - let mut event = crate::ghostty::MouseEvent::new().ok()?; - let (action, button) = match kind { - crossterm::event::MouseEventKind::Down(crossterm::event::MouseButton::Left) => ( - crate::ghostty::MOUSE_ACTION_PRESS, - Some(crate::ghostty::MOUSE_BUTTON_LEFT), - ), - crossterm::event::MouseEventKind::Down(crossterm::event::MouseButton::Middle) => ( - crate::ghostty::MOUSE_ACTION_PRESS, - Some(crate::ghostty::MOUSE_BUTTON_MIDDLE), - ), - crossterm::event::MouseEventKind::Down(crossterm::event::MouseButton::Right) => ( - crate::ghostty::MOUSE_ACTION_PRESS, - Some(crate::ghostty::MOUSE_BUTTON_RIGHT), - ), - crossterm::event::MouseEventKind::Up(crossterm::event::MouseButton::Left) => ( - crate::ghostty::MOUSE_ACTION_RELEASE, - Some(crate::ghostty::MOUSE_BUTTON_LEFT), - ), - crossterm::event::MouseEventKind::Up(crossterm::event::MouseButton::Middle) => ( - crate::ghostty::MOUSE_ACTION_RELEASE, - Some(crate::ghostty::MOUSE_BUTTON_MIDDLE), - ), - crossterm::event::MouseEventKind::Up(crossterm::event::MouseButton::Right) => ( - crate::ghostty::MOUSE_ACTION_RELEASE, - Some(crate::ghostty::MOUSE_BUTTON_RIGHT), - ), - crossterm::event::MouseEventKind::Drag(crossterm::event::MouseButton::Left) => ( - crate::ghostty::MOUSE_ACTION_MOTION, - Some(crate::ghostty::MOUSE_BUTTON_LEFT), - ), - crossterm::event::MouseEventKind::Drag(crossterm::event::MouseButton::Middle) => ( - crate::ghostty::MOUSE_ACTION_MOTION, - Some(crate::ghostty::MOUSE_BUTTON_MIDDLE), - ), - crossterm::event::MouseEventKind::Drag(crossterm::event::MouseButton::Right) => ( - crate::ghostty::MOUSE_ACTION_MOTION, - Some(crate::ghostty::MOUSE_BUTTON_RIGHT), - ), - _ => return None, - }; - event.set_action(action); - if let Some(button) = button { - event.set_button(button); - } else { - event.clear_button(); - } - event.set_mods(ghostty_mods_from_key_modifiers(modifiers)); - event.set_position(column as f32, row as f32); - Some(event) -} - -fn ghostty_mouse_event_from_wheel_kind( - kind: crossterm::event::MouseEventKind, - column: u16, - row: u16, - modifiers: crossterm::event::KeyModifiers, -) -> Option<crate::ghostty::MouseEvent> { - let mut event = crate::ghostty::MouseEvent::new().ok()?; - event.set_action(crate::ghostty::MOUSE_ACTION_PRESS); - let button = match kind { - crossterm::event::MouseEventKind::ScrollUp => crate::ghostty::MOUSE_BUTTON_WHEEL_UP, - crossterm::event::MouseEventKind::ScrollDown => crate::ghostty::MOUSE_BUTTON_WHEEL_DOWN, - crossterm::event::MouseEventKind::ScrollLeft => crate::ghostty::MOUSE_BUTTON_WHEEL_LEFT, - crossterm::event::MouseEventKind::ScrollRight => crate::ghostty::MOUSE_BUTTON_WHEEL_RIGHT, - _ => return None, - }; - event.set_button(button); - event.set_mods(ghostty_mods_from_key_modifiers(modifiers)); - event.set_position(column as f32, row as f32); - Some(event) -} - -fn ghostty_key_text(key: crate::input::TerminalKey) -> Option<String> { - match key.code { - crossterm::event::KeyCode::Char(c) => Some( - key.shifted_codepoint - .and_then(char::from_u32) - .unwrap_or(c) - .to_string(), - ), - _ => None, - } -} - -fn ghostty_unshifted_codepoint(key: crate::input::TerminalKey) -> Option<u32> { - match key.code { - crossterm::event::KeyCode::Char(c) => Some(c as u32), - _ => None, - } -} - -fn ghostty_key_from_crossterm_key_code( - code: crossterm::event::KeyCode, - shifted_codepoint: Option<u32>, -) -> Option<u32> { - use crate::ghostty::ffi; - use crossterm::event::KeyCode; - - match code { - KeyCode::Backspace => Some(ffi::GhosttyKey_GHOSTTY_KEY_BACKSPACE), - KeyCode::Enter => Some(ffi::GhosttyKey_GHOSTTY_KEY_ENTER), - KeyCode::Left => Some(ffi::GhosttyKey_GHOSTTY_KEY_ARROW_LEFT), - KeyCode::Right => Some(ffi::GhosttyKey_GHOSTTY_KEY_ARROW_RIGHT), - KeyCode::Up => Some(ffi::GhosttyKey_GHOSTTY_KEY_ARROW_UP), - KeyCode::Down => Some(ffi::GhosttyKey_GHOSTTY_KEY_ARROW_DOWN), - KeyCode::Home => Some(ffi::GhosttyKey_GHOSTTY_KEY_HOME), - KeyCode::End => Some(ffi::GhosttyKey_GHOSTTY_KEY_END), - KeyCode::PageUp => Some(ffi::GhosttyKey_GHOSTTY_KEY_PAGE_UP), - KeyCode::PageDown => Some(ffi::GhosttyKey_GHOSTTY_KEY_PAGE_DOWN), - KeyCode::Tab | KeyCode::BackTab => Some(ffi::GhosttyKey_GHOSTTY_KEY_TAB), - KeyCode::Delete => Some(ffi::GhosttyKey_GHOSTTY_KEY_DELETE), - KeyCode::Insert => Some(ffi::GhosttyKey_GHOSTTY_KEY_INSERT), - KeyCode::Esc => Some(ffi::GhosttyKey_GHOSTTY_KEY_ESCAPE), - KeyCode::F(n) => Some(match n { - 1 => ffi::GhosttyKey_GHOSTTY_KEY_F1, - 2 => ffi::GhosttyKey_GHOSTTY_KEY_F2, - 3 => ffi::GhosttyKey_GHOSTTY_KEY_F3, - 4 => ffi::GhosttyKey_GHOSTTY_KEY_F4, - 5 => ffi::GhosttyKey_GHOSTTY_KEY_F5, - 6 => ffi::GhosttyKey_GHOSTTY_KEY_F6, - 7 => ffi::GhosttyKey_GHOSTTY_KEY_F7, - 8 => ffi::GhosttyKey_GHOSTTY_KEY_F8, - 9 => ffi::GhosttyKey_GHOSTTY_KEY_F9, - 10 => ffi::GhosttyKey_GHOSTTY_KEY_F10, - 11 => ffi::GhosttyKey_GHOSTTY_KEY_F11, - 12 => ffi::GhosttyKey_GHOSTTY_KEY_F12, - _ => return None, - }), - KeyCode::Char(c) => ghostty_key_from_char(c, shifted_codepoint), - _ => None, - } -} - -fn ghostty_key_from_char(c: char, shifted_codepoint: Option<u32>) -> Option<u32> { - use crate::ghostty::ffi; - - let base = if let Some(shifted) = shifted_codepoint.and_then(char::from_u32) { - ghostty_unshifted_ascii_pair(shifted).unwrap_or(c) - } else { - c - }; - - match base.to_ascii_lowercase() { - 'a' => Some(ffi::GhosttyKey_GHOSTTY_KEY_A), - 'b' => Some(ffi::GhosttyKey_GHOSTTY_KEY_B), - 'c' => Some(ffi::GhosttyKey_GHOSTTY_KEY_C), - 'd' => Some(ffi::GhosttyKey_GHOSTTY_KEY_D), - 'e' => Some(ffi::GhosttyKey_GHOSTTY_KEY_E), - 'f' => Some(ffi::GhosttyKey_GHOSTTY_KEY_F), - 'g' => Some(ffi::GhosttyKey_GHOSTTY_KEY_G), - 'h' => Some(ffi::GhosttyKey_GHOSTTY_KEY_H), - 'i' => Some(ffi::GhosttyKey_GHOSTTY_KEY_I), - 'j' => Some(ffi::GhosttyKey_GHOSTTY_KEY_J), - 'k' => Some(ffi::GhosttyKey_GHOSTTY_KEY_K), - 'l' => Some(ffi::GhosttyKey_GHOSTTY_KEY_L), - 'm' => Some(ffi::GhosttyKey_GHOSTTY_KEY_M), - 'n' => Some(ffi::GhosttyKey_GHOSTTY_KEY_N), - 'o' => Some(ffi::GhosttyKey_GHOSTTY_KEY_O), - 'p' => Some(ffi::GhosttyKey_GHOSTTY_KEY_P), - 'q' => Some(ffi::GhosttyKey_GHOSTTY_KEY_Q), - 'r' => Some(ffi::GhosttyKey_GHOSTTY_KEY_R), - 's' => Some(ffi::GhosttyKey_GHOSTTY_KEY_S), - 't' => Some(ffi::GhosttyKey_GHOSTTY_KEY_T), - 'u' => Some(ffi::GhosttyKey_GHOSTTY_KEY_U), - 'v' => Some(ffi::GhosttyKey_GHOSTTY_KEY_V), - 'w' => Some(ffi::GhosttyKey_GHOSTTY_KEY_W), - 'x' => Some(ffi::GhosttyKey_GHOSTTY_KEY_X), - 'y' => Some(ffi::GhosttyKey_GHOSTTY_KEY_Y), - 'z' => Some(ffi::GhosttyKey_GHOSTTY_KEY_Z), - '0' => Some(ffi::GhosttyKey_GHOSTTY_KEY_DIGIT_0), - '1' => Some(ffi::GhosttyKey_GHOSTTY_KEY_DIGIT_1), - '2' => Some(ffi::GhosttyKey_GHOSTTY_KEY_DIGIT_2), - '3' => Some(ffi::GhosttyKey_GHOSTTY_KEY_DIGIT_3), - '4' => Some(ffi::GhosttyKey_GHOSTTY_KEY_DIGIT_4), - '5' => Some(ffi::GhosttyKey_GHOSTTY_KEY_DIGIT_5), - '6' => Some(ffi::GhosttyKey_GHOSTTY_KEY_DIGIT_6), - '7' => Some(ffi::GhosttyKey_GHOSTTY_KEY_DIGIT_7), - '8' => Some(ffi::GhosttyKey_GHOSTTY_KEY_DIGIT_8), - '9' => Some(ffi::GhosttyKey_GHOSTTY_KEY_DIGIT_9), - '`' => Some(ffi::GhosttyKey_GHOSTTY_KEY_BACKQUOTE), - '\\' => Some(ffi::GhosttyKey_GHOSTTY_KEY_BACKSLASH), - '[' => Some(ffi::GhosttyKey_GHOSTTY_KEY_BRACKET_LEFT), - ']' => Some(ffi::GhosttyKey_GHOSTTY_KEY_BRACKET_RIGHT), - ',' => Some(ffi::GhosttyKey_GHOSTTY_KEY_COMMA), - '=' => Some(ffi::GhosttyKey_GHOSTTY_KEY_EQUAL), - '-' => Some(ffi::GhosttyKey_GHOSTTY_KEY_MINUS), - '.' => Some(ffi::GhosttyKey_GHOSTTY_KEY_PERIOD), - '\'' => Some(ffi::GhosttyKey_GHOSTTY_KEY_QUOTE), - ';' => Some(ffi::GhosttyKey_GHOSTTY_KEY_SEMICOLON), - '/' => Some(ffi::GhosttyKey_GHOSTTY_KEY_SLASH), - ' ' => Some(ffi::GhosttyKey_GHOSTTY_KEY_SPACE), - _ => None, - } -} - -fn ghostty_unshifted_ascii_pair(c: char) -> Option<char> { - Some(match c { - '!' => '1', - '@' => '2', - '#' => '3', - '$' => '4', - '%' => '5', - '^' => '6', - '&' => '7', - '*' => '8', - '(' => '9', - ')' => '0', - '_' => '-', - '+' => '=', - '{' => '[', - '}' => ']', - '|' => '\\', - ':' => ';', - '"' => '\'', - '<' => ',', - '>' => '.', - '?' => '/', - '~' => '`', - _ => return None, - }) -} - -fn ghostty_visible_text(core: &mut GhosttyPaneCore) -> Result<String, crate::ghostty::Error> { - let GhosttyPaneCore { - terminal, - render_state, - .. - } = core; - render_state.update(terminal)?; - let mut row_iterator = crate::ghostty::RowIterator::new()?; - let mut row_cells = crate::ghostty::RowCells::new()?; - let mut rows = render_state.populate_row_iterator(&mut row_iterator)?; - let mut lines = Vec::new(); - while rows.next() { - let mut cells = rows.populate_cells(&mut row_cells)?; - lines.push(ghostty_line_from_cells(&mut cells)?); - } - trim_trailing_blank_rows(&mut lines); - Ok(lines_to_text(lines)) -} - -fn ghostty_detection_text(core: &GhosttyPaneCore) -> Result<String, crate::ghostty::Error> { - let lines = core - .terminal - .rows() - .ok() - .map(|rows| usize::from(rows).max(1)) - .unwrap_or(DEFAULT_DETECTION_ROWS); - ghostty_recent_text(core, lines) -} - -fn ghostty_recent_text( - core: &GhosttyPaneCore, - lines: usize, -) -> Result<String, crate::ghostty::Error> { - let total_rows = core.terminal.total_rows()?; - let cols = core.terminal.cols()?; - let start = total_rows.saturating_sub(lines); - let mut rows = Vec::with_capacity(total_rows.saturating_sub(start)); - for y in start..total_rows { - rows.push(ghostty_screen_row(core, cols, y as u32)?); - } - trim_trailing_blank_rows(&mut rows); - Ok(recent_text_from_rows(&rows, lines)) -} - -fn ghostty_recent_text_unwrapped( - core: &GhosttyPaneCore, - lines: usize, -) -> Result<String, crate::ghostty::Error> { - let total_rows = core.terminal.total_rows()?; - let cols = core.terminal.cols()?; - if total_rows == 0 || cols == 0 { - return Ok(String::new()); - } - let start = total_rows.saturating_sub(lines) as u32; - let end = (total_rows.saturating_sub(1)) as u32; - core.terminal - .read_text_screen((0, start), (cols.saturating_sub(1), end), false) -} - -fn ghostty_extract_selection( - core: &mut GhosttyPaneCore, - selection: &crate::selection::Selection, -) -> Result<String, crate::ghostty::Error> { - let ((start_row, start_col), (end_row, end_col)) = selection.ordered_cells(); - core.terminal - .read_text_screen((start_col, start_row), (end_col, end_row), false) -} - -fn ghostty_screen_row( - core: &GhosttyPaneCore, - cols: u16, - y: u32, -) -> Result<String, crate::ghostty::Error> { - let mut line = String::new(); - for x in 0..cols { - let graphemes = core.terminal.screen_graphemes(x, y)?; - if graphemes.is_empty() { - line.push(' '); - } else { - for codepoint in graphemes { - if let Some(ch) = char::from_u32(codepoint) { - line.push(ch); - } - } - } - } - Ok(line.trim_end().to_string()) -} - -fn ghostty_line_from_cells( - cells: &mut crate::ghostty::RowCellIter<'_>, -) -> Result<String, crate::ghostty::Error> { - let mut line = String::new(); - while cells.next() { - line.push_str(&ghostty_cell_symbol(cells)?); - } - Ok(line.trim_end().to_string()) -} - -fn ghostty_cell_symbol( - cells: &crate::ghostty::RowCellIter<'_>, -) -> Result<String, crate::ghostty::Error> { - let graphemes = cells.graphemes()?; - if graphemes.is_empty() { - return Ok(" ".to_string()); - } - let mut text = String::new(); - for codepoint in graphemes { - if let Some(ch) = char::from_u32(codepoint) { - text.push(ch); - } - } - if text.is_empty() { - text.push(' '); - } - Ok(text) -} - -fn ghostty_blank_symbol_for_width(wide: crate::ghostty::CellWide) -> &'static str { - match wide { - crate::ghostty::CellWide::Wide => " ", - crate::ghostty::CellWide::SpacerTail => "", - crate::ghostty::CellWide::Narrow | crate::ghostty::CellWide::SpacerHead => " ", - } -} - -fn ghostty_normalize_buffer_symbol(symbol: &str, wide: crate::ghostty::CellWide) -> String { - let expected_width = match wide { - crate::ghostty::CellWide::Wide => 2, - crate::ghostty::CellWide::Narrow | crate::ghostty::CellWide::SpacerHead => 1, - crate::ghostty::CellWide::SpacerTail => 0, - }; - let actual_width = symbol.width(); - if actual_width == expected_width { - return symbol.to_string(); - } - ghostty_blank_symbol_for_width(wide).to_string() -} - -fn ghostty_buffer_symbol( - cells: &crate::ghostty::RowCellIter<'_>, - wide: crate::ghostty::CellWide, -) -> Result<String, crate::ghostty::Error> { - let symbol = match wide { - crate::ghostty::CellWide::SpacerTail => String::new(), - crate::ghostty::CellWide::SpacerHead => " ".to_string(), - crate::ghostty::CellWide::Narrow | crate::ghostty::CellWide::Wide => { - ghostty_cell_symbol(cells)? - } - }; - Ok(ghostty_normalize_buffer_symbol(&symbol, wide)) -} - -fn ghostty_reset_cell( - cell: &mut ratatui::buffer::Cell, - default_fg: Option<Color>, - default_bg: Option<Color>, -) { - cell.reset(); - cell.set_symbol(" "); - if let Some(bg) = default_bg { - cell.set_bg(bg); - } - if let Some(fg) = default_fg { - cell.set_fg(fg); - } -} - -fn ghostty_cell_style( - cells: &crate::ghostty::RowCellIter<'_>, - default_fg: Option<Color>, - default_bg: Option<Color>, -) -> Style { - let style_data = cells.style().unwrap_or_default(); - let mut fg = cells - .fg_color() - .ok() - .flatten() - .map(ghostty_color) - .or(default_fg); - let mut bg = cells - .bg_color() - .ok() - .flatten() - .map(ghostty_color) - .or(default_bg); - if style_data.invisible { - fg = bg.or(default_bg); - } - if style_data.inverse { - std::mem::swap(&mut fg, &mut bg); - } - - let mut style = Style::default(); - if let Some(fg) = fg { - style = style.fg(fg); - } - if let Some(bg) = bg { - style = style.bg(bg); - } - - let mut modifiers = Modifier::empty(); - if style_data.bold { - modifiers |= Modifier::BOLD; - } - if style_data.italic { - modifiers |= Modifier::ITALIC; - } - if style_data.faint { - modifiers |= Modifier::DIM; - } - if style_data.blink { - modifiers |= Modifier::SLOW_BLINK; - } - if style_data.underlined { - modifiers |= Modifier::UNDERLINED; - } - if style_data.strikethrough { - modifiers |= Modifier::CROSSED_OUT; - } - style.add_modifier(modifiers) -} - -fn ghostty_default_bg( - color: crate::ghostty::RgbColor, - host_theme: crate::terminal_theme::TerminalTheme, -) -> Option<Color> { - if host_theme.background == Some(terminal_theme_color(color)) { - None - } else { - Some(ghostty_color(color)) - } -} - -fn terminal_theme_color(color: crate::ghostty::RgbColor) -> crate::terminal_theme::RgbColor { - crate::terminal_theme::RgbColor { - r: color.r, - g: color.g, - b: color.b, - } -} - -fn ghostty_color(color: crate::ghostty::RgbColor) -> Color { - Color::Rgb(color.r, color.g, color.b) -} - -fn lines_to_text(lines: Vec<String>) -> String { - let text = lines.join("\n"); - if text.is_empty() { - text - } else { - format!("{text}\n") - } -} - -#[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum WheelRouting { HostScroll, MouseReport, @@ -1751,22 +159,6 @@ impl Drop for PaneRuntime { } } -fn trim_trailing_blank_rows(rows: &mut Vec<String>) { - while rows.last().is_some_and(|row| row.trim().is_empty()) { - rows.pop(); - } -} - -fn recent_text_from_rows(rows: &[String], lines: usize) -> String { - let start = rows.len().saturating_sub(lines); - let text = rows[start..].join("\n"); - if text.is_empty() { - text - } else { - format!("{text}\n") - } -} - fn wait_for_processes_to_exit(pids: &[u32], timeout: std::time::Duration) -> bool { let deadline = std::time::Instant::now() + timeout; loop { @@ -1939,9 +331,7 @@ impl PaneRuntime { .map_err(|e| std::io::Error::other(e.to_string()))?; let pane_terminal = GhosttyPaneTerminal::new(terminal, input_tx.clone())?; pane_terminal.apply_host_terminal_theme(host_terminal_theme); - let terminal = Arc::new(PaneTerminal { - ghostty: pane_terminal, - }); + let terminal = Arc::new(PaneTerminal::new(pane_terminal)); let kitty_keyboard_flags = Arc::new(AtomicU16::new(0)); let reader = pair @@ -2050,7 +440,7 @@ impl PaneRuntime { let pending_release_for_task = pending_release.clone(); let handle = tokio::spawn(async move { - let mut agent: Option<Agent> = None; + let mut agent_presence = AgentDetectionPresence::from_agent(None); let mut state = AgentState::Unknown; let mut last_process_check = Instant::now(); let mut last_claude_working_at = None; @@ -2063,7 +453,7 @@ impl PaneRuntime { || terminal.has_transient_default_color_override() { TICK_PENDING_RELEASE - } else if agent.is_none() { + } else if agent_presence.current_agent().is_none() { TICK_UNIDENTIFIED } else { TICK_IDENTIFIED @@ -2071,7 +461,7 @@ impl PaneRuntime { tokio::select! { _ = tokio::time::sleep(tick) => {} _ = detect_reset.notified() => { - agent = None; + agent_presence = AgentDetectionPresence::from_agent(None); state = AgentState::Unknown; last_claude_working_at = None; } @@ -2080,48 +470,60 @@ impl PaneRuntime { let now = Instant::now(); let suppressed_agent = active_pending_release(&pending_release_for_task, now); let should_check_process = suppressed_agent.is_some() - || agent.is_none() + || agent_presence.current_agent().is_none() || now.duration_since(last_process_check) >= PROCESS_RECHECK; let mut agent_changed = false; + let mut agent = agent_presence.current_agent(); if should_check_process { last_process_check = now; let pid = child_pid.load(Ordering::Acquire); if pid > 0 { + let mut process_name = None; + let mut process_group_id = None; + let mut new_agent = None; + if let Some(job) = detect::foreground_job(pid) { + process_group_id = Some(job.process_group_id); let identified = detect::identify_agent_in_job(&job); - let mut new_agent = identified.as_ref().map(|(agent, _)| *agent); - - if let Some(suppressed_agent) = suppressed_agent { - if new_agent == Some(suppressed_agent) { - new_agent = None; - } else if let Ok(mut pending_release) = - pending_release_for_task.lock() - { - *pending_release = None; - } + process_name = identified + .as_ref() + .map(|(_, process_name)| process_name.clone()); + new_agent = identified.as_ref().map(|(agent, _)| *agent); + } + + if let Some(suppressed_agent) = suppressed_agent { + if new_agent == Some(suppressed_agent) { + new_agent = None; + } else if let Ok(mut pending_release) = + pending_release_for_task.lock() + { + *pending_release = None; } + } - if new_agent != agent { - if let Some((_, process_name)) = identified { - info!( - pane = pane_id.raw(), - ?new_agent, - process = %process_name, - pgid = job.process_group_id, - "agent changed" - ); - } else { - info!( - pane = pane_id.raw(), - ?new_agent, - pgid = job.process_group_id, - "agent changed" - ); - } - agent = new_agent; - agent_changed = true; + let previous_agent = agent_presence.current_agent(); + if agent_presence.observe_process_probe(new_agent) { + agent = agent_presence.current_agent(); + if let Some(process_name) = process_name { + info!( + pane = pane_id.raw(), + previous_agent = ?previous_agent, + ?agent, + process = %process_name, + pgid = ?process_group_id, + "agent changed" + ); + } else { + info!( + pane = pane_id.raw(), + previous_agent = ?previous_agent, + ?agent, + pgid = ?process_group_id, + "agent changed" + ); } + agent_changed = true; } } } @@ -2405,16 +807,12 @@ impl PaneRuntime { #[cfg(test)] impl PaneRuntime { - pub(crate) fn test_with_screen_bytes(cols: u16, rows: u16, bytes: &[u8]) -> Self { - Self::test_with_scrollback_bytes(cols, rows, 0, bytes) + pub(crate) fn test_with_channel(cols: u16, rows: u16) -> (Self, mpsc::Receiver<Bytes>) { + Self::test_with_channel_and_scrollback_bytes(cols, rows, 0, &[]) } - pub(crate) fn test_with_screen_bytes_and_receiver( - cols: u16, - rows: u16, - bytes: &[u8], - ) -> (Self, mpsc::Receiver<Bytes>) { - Self::test_with_scrollback_bytes_and_receiver(cols, rows, 0, bytes) + pub(crate) fn test_with_screen_bytes(cols: u16, rows: u16, bytes: &[u8]) -> Self { + Self::test_with_scrollback_bytes(cols, rows, 0, bytes) } pub(crate) fn test_with_scrollback_bytes( @@ -2423,10 +821,10 @@ impl PaneRuntime { scrollback_limit_bytes: usize, bytes: &[u8], ) -> Self { - Self::test_with_scrollback_bytes_and_receiver(cols, rows, scrollback_limit_bytes, bytes).0 + Self::test_with_channel_and_scrollback_bytes(cols, rows, scrollback_limit_bytes, bytes).0 } - fn test_with_scrollback_bytes_and_receiver( + fn test_with_channel_and_scrollback_bytes( cols: u16, rows: u16, scrollback_limit_bytes: usize, @@ -2440,9 +838,9 @@ impl PaneRuntime { ( Self { - terminal: Arc::new(PaneTerminal { - ghostty: GhosttyPaneTerminal::new(terminal, tx.clone()).unwrap(), - }), + terminal: Arc::new(PaneTerminal::new( + GhosttyPaneTerminal::new(terminal, tx.clone()).unwrap(), + )), sender: tx, resize_tx, current_size: Cell::new((rows, cols)), @@ -2461,761 +859,6 @@ impl PaneRuntime { mod tests { use super::*; - fn write_numbered_lines(terminal: &mut crate::ghostty::Terminal, count: usize) { - for i in 0..count { - terminal.write(format!("{i:06}\r\n").as_bytes()); - } - } - - fn pane_default_theme(pane: &GhosttyPaneTerminal) -> crate::terminal_theme::TerminalTheme { - let mut core = pane.core.lock().unwrap(); - let GhosttyPaneCore { - terminal, - render_state, - .. - } = &mut *core; - render_state.update(terminal).unwrap(); - let colors = render_state.colors().unwrap(); - crate::terminal_theme::TerminalTheme { - foreground: Some(crate::terminal_theme::RgbColor { - r: colors.foreground.r, - g: colors.foreground.g, - b: colors.foreground.b, - }), - background: Some(crate::terminal_theme::RgbColor { - r: colors.background.r, - g: colors.background.g, - b: colors.background.b, - }), - } - } - - fn shell_job(shell_pid: u32) -> crate::platform::ForegroundJob { - crate::platform::ForegroundJob { - process_group_id: shell_pid, - processes: vec![crate::platform::ForegroundProcess { - pid: shell_pid, - name: "zsh".to_string(), - argv0: Some("zsh".to_string()), - cmdline: Some("zsh".to_string()), - }], - } - } - - #[test] - fn ghostty_render_can_suppress_cursor_position() { - let (tx, _rx) = mpsc::channel(4); - let mut first_terminal = crate::ghostty::Terminal::new(20, 5, 0).unwrap(); - first_terminal.write(b"left"); - let first = GhosttyPaneTerminal::new(first_terminal, tx.clone()).unwrap(); - - let mut second_terminal = crate::ghostty::Terminal::new(20, 5, 0).unwrap(); - second_terminal.write(b"r\r\nb"); - let second = GhosttyPaneTerminal::new(second_terminal, tx).unwrap(); - - let backend = ratatui::backend::TestBackend::new(40, 5); - let mut terminal = ratatui::Terminal::new(backend).unwrap(); - terminal - .draw(|frame| { - first.render(frame, Rect::new(0, 0, 20, 5), true); - second.render(frame, Rect::new(20, 0, 20, 5), false); - }) - .unwrap(); - - terminal.backend_mut().assert_cursor_position((4, 0)); - } - - #[test] - fn ghostty_keyboard_protocol_tracks_live_terminal_flags() { - let (tx, _rx) = mpsc::channel(4); - let mut terminal = crate::ghostty::Terminal::new(80, 24, 0).unwrap(); - terminal.write(b"\x1b[>3u"); - let pane = GhosttyPaneTerminal::new(terminal, tx).unwrap(); - - assert_eq!( - pane.keyboard_protocol(), - Some(crate::input::KeyboardProtocol::Kitty { flags: 3 }) - ); - } - - #[test] - fn ghostty_plain_text_chars_still_encode_as_text() { - let (tx, _rx) = mpsc::channel(4); - let terminal = crate::ghostty::Terminal::new(80, 24, 0).unwrap(); - let pane = GhosttyPaneTerminal::new(terminal, tx).unwrap(); - - let encoded = pane.encode_terminal_key( - crate::input::TerminalKey::new( - crossterm::event::KeyCode::Char('a'), - crossterm::event::KeyModifiers::empty(), - ), - crate::input::KeyboardProtocol::Legacy, - ); - - assert_eq!(encoded, b"a"); - } - - #[test] - fn ghostty_char_keys_still_use_herdr_encoding() { - let (tx, _rx) = mpsc::channel(4); - let mut terminal = crate::ghostty::Terminal::new(80, 24, 0).unwrap(); - terminal.write(b"\x1b[>1u"); - let pane = GhosttyPaneTerminal::new(terminal, tx).unwrap(); - - let encoded = pane.encode_terminal_key( - crate::input::TerminalKey::new( - crossterm::event::KeyCode::Char('a'), - crossterm::event::KeyModifiers::CONTROL | crossterm::event::KeyModifiers::SHIFT, - ), - crate::input::KeyboardProtocol::Legacy, - ); - - assert_eq!(encoded, vec![1]); - } - - #[test] - fn ghostty_key_encoding_honors_application_cursor_mode() { - let (tx, _rx) = mpsc::channel(4); - let mut terminal = crate::ghostty::Terminal::new(80, 24, 0).unwrap(); - terminal - .mode_set(crate::ghostty::MODE_APPLICATION_CURSOR_KEYS, true) - .unwrap(); - let pane = GhosttyPaneTerminal::new(terminal, tx).unwrap(); - - let encoded = pane.encode_terminal_key( - crate::input::TerminalKey::new( - crossterm::event::KeyCode::Up, - crossterm::event::KeyModifiers::empty(), - ), - crate::input::KeyboardProtocol::Legacy, - ); - - assert_eq!(encoded, b"\x1bOA"); - } - - #[test] - fn ghostty_key_encoder_updates_after_terminal_mode_changes() { - let (tx, _rx) = mpsc::channel(4); - let terminal = crate::ghostty::Terminal::new(80, 24, 0).unwrap(); - let pane = GhosttyPaneTerminal::new(terminal, tx.clone()).unwrap(); - let pane_id = PaneId::from_raw(1); - - let before = pane.encode_terminal_key( - crate::input::TerminalKey::new( - crossterm::event::KeyCode::Up, - crossterm::event::KeyModifiers::empty(), - ), - crate::input::KeyboardProtocol::Legacy, - ); - assert_eq!(before, b"\x1b[A"); - - pane.process_pty_bytes(pane_id, 0, b"\x1b[?1h", &tx); - - let after = pane.encode_terminal_key( - crate::input::TerminalKey::new( - crossterm::event::KeyCode::Up, - crossterm::event::KeyModifiers::empty(), - ), - crate::input::KeyboardProtocol::Legacy, - ); - assert_eq!(after, b"\x1bOA"); - } - - #[test] - fn ghostty_key_encoder_updates_after_kitty_flag_changes() { - let (tx, _rx) = mpsc::channel(4); - let terminal = crate::ghostty::Terminal::new(80, 24, 0).unwrap(); - let pane = GhosttyPaneTerminal::new(terminal, tx.clone()).unwrap(); - let pane_id = PaneId::from_raw(1); - let key = crate::input::TerminalKey::new( - crossterm::event::KeyCode::Enter, - crossterm::event::KeyModifiers::CONTROL | crossterm::event::KeyModifiers::SHIFT, - ); - - let before = pane.encode_terminal_key(key, crate::input::KeyboardProtocol::Legacy); - pane.process_pty_bytes(pane_id, 0, b"\x1b[>1u", &tx); - let after = pane.encode_terminal_key(key, crate::input::KeyboardProtocol::Legacy); - - assert_ne!(before, after); - assert_eq!(after, b"\x1b[13;6u"); - } - - #[test] - fn ghostty_key_encoders_are_isolated_per_pane() { - let (tx, _rx) = mpsc::channel(4); - let first = GhosttyPaneTerminal::new( - crate::ghostty::Terminal::new(80, 24, 0).unwrap(), - tx.clone(), - ) - .unwrap(); - let second = GhosttyPaneTerminal::new( - crate::ghostty::Terminal::new(80, 24, 0).unwrap(), - tx.clone(), - ) - .unwrap(); - - first.process_pty_bytes(PaneId::from_raw(1), 0, b"\x1b[?1h", &tx); - - let first_encoded = first.encode_terminal_key( - crate::input::TerminalKey::new( - crossterm::event::KeyCode::Up, - crossterm::event::KeyModifiers::empty(), - ), - crate::input::KeyboardProtocol::Legacy, - ); - let second_encoded = second.encode_terminal_key( - crate::input::TerminalKey::new( - crossterm::event::KeyCode::Up, - crossterm::event::KeyModifiers::empty(), - ), - crate::input::KeyboardProtocol::Legacy, - ); - - assert_eq!(first_encoded, b"\x1bOA"); - assert_eq!(second_encoded, b"\x1b[A"); - } - - #[test] - fn ghostty_mouse_button_encoding_uses_live_terminal_state() { - let (tx, _rx) = mpsc::channel(4); - let mut terminal = crate::ghostty::Terminal::new(80, 24, 0).unwrap(); - terminal.write(b"\x1b[?1000h\x1b[?1006h"); - let pane = GhosttyPaneTerminal::new(terminal, tx).unwrap(); - - let encoded = pane.encode_mouse_button( - crossterm::event::MouseEventKind::Up(crossterm::event::MouseButton::Left), - 11, - 9, - crossterm::event::KeyModifiers::empty(), - ); - - assert_eq!(encoded.as_deref(), Some(&b"\x1b[<0;12;10m"[..])); - } - - #[test] - fn ghostty_mouse_drag_encoding_uses_motion_reporting_state() { - let (tx, _rx) = mpsc::channel(4); - let mut terminal = crate::ghostty::Terminal::new(80, 24, 0).unwrap(); - terminal.write(b"\x1b[?1002h\x1b[?1006h"); - let pane = GhosttyPaneTerminal::new(terminal, tx).unwrap(); - - let encoded = pane.encode_mouse_button( - crossterm::event::MouseEventKind::Drag(crossterm::event::MouseButton::Left), - 4, - 6, - crossterm::event::KeyModifiers::SHIFT, - ); - - assert_eq!(encoded.as_deref(), Some(&b"\x1b[<36;5;7M"[..])); - } - - #[test] - fn ghostty_normalize_buffer_symbol_uses_ratatui_width_contract() { - assert_eq!( - ghostty_normalize_buffer_symbol("🙂", crate::ghostty::CellWide::Wide), - "🙂" - ); - assert_eq!( - ghostty_normalize_buffer_symbol("a", crate::ghostty::CellWide::Wide), - " " - ); - assert_eq!( - ghostty_normalize_buffer_symbol("⌨️", crate::ghostty::CellWide::Narrow), - " " - ); - assert_eq!( - ghostty_normalize_buffer_symbol(" ", crate::ghostty::CellWide::SpacerTail), - "" - ); - assert_eq!( - ghostty_normalize_buffer_symbol("xx", crate::ghostty::CellWide::SpacerHead), - " " - ); - } - - #[test] - fn pane_scrollback_controls_reach_top_without_ui_interference() { - let (tx, _rx) = mpsc::channel(4); - let mut terminal = crate::ghostty::Terminal::new(80, 3, 100).unwrap(); - write_numbered_lines(&mut terminal, 1000); - let pane = GhosttyPaneTerminal::new(terminal, tx).unwrap(); - - let before = pane.scroll_metrics().expect("scroll metrics before scroll"); - assert!(before.max_offset_from_bottom > 0); - assert_eq!(before.offset_from_bottom, 0); - - pane.set_scroll_offset_from_bottom(before.max_offset_from_bottom); - - let after = pane.scroll_metrics().expect("scroll metrics after scroll"); - assert_eq!(after.offset_from_bottom, after.max_offset_from_bottom); - assert!(pane.visible_text().contains("000000")); - } - - #[test] - fn detection_text_stays_at_bottom_when_viewport_is_scrolled() { - let (tx, _rx) = mpsc::channel(4); - let mut terminal = crate::ghostty::Terminal::new(80, 3, 100).unwrap(); - write_numbered_lines(&mut terminal, 10); - let pane = GhosttyPaneTerminal::new(terminal, tx).unwrap(); - - let bottom_snapshot = pane.detection_text(); - assert_eq!(bottom_snapshot, pane.recent_text(3)); - assert!(bottom_snapshot.contains("000009")); - - let before = pane.scroll_metrics().expect("scroll metrics before scroll"); - pane.set_scroll_offset_from_bottom(before.max_offset_from_bottom); - - assert!(pane.visible_text().contains("000000")); - assert_eq!(pane.detection_text(), bottom_snapshot); - } - - #[test] - fn extract_selection_reads_screen_rows_not_current_viewport() { - let (tx, _rx) = mpsc::channel(4); - let mut terminal = crate::ghostty::Terminal::new(8, 3, 1024).unwrap(); - write_numbered_lines(&mut terminal, 8); - let pane = GhosttyPaneTerminal::new(terminal, tx).unwrap(); - - pane.set_scroll_offset_from_bottom(3); - let metrics = pane - .scroll_metrics() - .expect("scroll metrics after initial scroll"); - let mut selection = - crate::selection::Selection::anchor(PaneId::from_raw(1), 0, 0, Some(metrics)); - selection.drag(5, 2, Rect::new(0, 0, 8, 3), Some(metrics)); - - pane.scroll_reset(); - - let text = pane - .extract_selection(&selection) - .expect("selection should extract text"); - assert_eq!(text, "000003\n000004\n000005"); - } - - #[test] - fn recent_unwrapped_text_ignores_soft_wraps() { - let (tx, _rx) = mpsc::channel(4); - let mut terminal = crate::ghostty::Terminal::new(5, 3, 100).unwrap(); - terminal.write(b"ABCDEFGHIJ"); - let pane = GhosttyPaneTerminal::new(terminal, tx).unwrap(); - - assert_eq!(pane.recent_text(3), "ABCDE\nFGHIJ\n"); - assert_eq!(pane.recent_unwrapped_text(3), "ABCDEFGHIJ"); - } - - #[test] - fn synchronized_output_suppresses_intermediate_render_requests_until_batch_ends() { - let (tx, _rx) = mpsc::channel(4); - let terminal = crate::ghostty::Terminal::new(80, 24, 0).unwrap(); - let pane_terminal = GhosttyPaneTerminal::new(terminal, tx.clone()).unwrap(); - let pane_id = PaneId::from_raw(1); - - let begin = pane_terminal.process_pty_bytes(pane_id, 0, b"\x1b[?2026h", &tx); - assert!(!begin.request_render); - - let body = pane_terminal.process_pty_bytes(pane_id, 0, b"hello", &tx); - assert!(!body.request_render); - - let end = pane_terminal.process_pty_bytes(pane_id, 0, b"\x1b[?2026l", &tx); - assert!(end.request_render); - } - - #[test] - fn default_color_tracker_detects_split_osc_11_sequences() { - let mut tracker = DefaultColorOscTracker::default(); - - assert!(!tracker.observe(b"\x1b]11;rgb:11/22")); - assert!(tracker.observe(b"/33\x1b\\")); - } - - #[test] - fn default_color_tracker_ignores_osc_queries() { - let mut tracker = DefaultColorOscTracker::default(); - - assert!(!tracker.observe(b"\x1b]10;?\x1b\\")); - assert!(!tracker.observe(b"\x1b]11;?\x07")); - } - - #[test] - fn osc52_forwarder_detects_write_with_bel() { - let mut fw = Osc52Forwarder::default(); - fw.observe(b"\x1b]52;c;aGVsbG8=\x07"); - let pending = fw.drain_pending(); - assert_eq!(pending, vec![b"hello".to_vec()]); - } - - #[test] - fn osc52_forwarder_detects_write_with_st() { - let mut fw = Osc52Forwarder::default(); - fw.observe(b"\x1b]52;c;aGVsbG8=\x1b\\"); - let pending = fw.drain_pending(); - assert_eq!(pending, vec![b"hello".to_vec()]); - } - - #[test] - fn osc52_forwarder_detects_empty_selector_form() { - let mut fw = Osc52Forwarder::default(); - fw.observe(b"\x1b]52;;aGVsbG8=\x07"); - let pending = fw.drain_pending(); - assert_eq!(pending, vec![b"hello".to_vec()]); - } - - #[test] - fn osc52_forwarder_accepts_clear_clipboard() { - let mut fw = Osc52Forwarder::default(); - fw.observe(b"\x1b]52;c;\x07"); - let pending = fw.drain_pending(); - assert_eq!(pending, vec![Vec::<u8>::new()]); - } - - #[test] - fn osc52_forwarder_ignores_query() { - let mut fw = Osc52Forwarder::default(); - fw.observe(b"\x1b]52;c;?\x07"); - assert!(fw.drain_pending().is_empty()); - } - - #[test] - fn osc52_forwarder_ignores_empty_selector_query() { - let mut fw = Osc52Forwarder::default(); - fw.observe(b"\x1b]52;;?\x07"); - assert!(fw.drain_pending().is_empty()); - } - - #[test] - fn osc52_forwarder_ignores_other_kinds() { - let mut fw = Osc52Forwarder::default(); - fw.observe(b"\x1b]52;p;aGk=\x07"); - fw.observe(b"\x1b]52;s;aGk=\x07"); - fw.observe(b"\x1b]52;q;aGk=\x07"); - fw.observe(b"\x1b]52;0;aGk=\x07"); - fw.observe(b"\x1b]52;7;aGk=\x07"); - assert!(fw.drain_pending().is_empty()); - } - - #[test] - fn osc52_forwarder_ignores_invalid_base64() { - let mut fw = Osc52Forwarder::default(); - fw.observe(b"\x1b]52;c;%%%\x07"); - fw.observe(b"\x1b]52;c;aGVs\x1b[bG8=\x07"); - assert!(fw.drain_pending().is_empty()); - } - - #[test] - fn osc52_forwarder_ignores_non_osc52() { - let mut fw = Osc52Forwarder::default(); - fw.observe(b"\x1b]11;?\x07"); - fw.observe(b"\x1b]0;title\x07"); - fw.observe(b"\x1b]8;;https://example.com\x1b\\"); - assert!(fw.drain_pending().is_empty()); - } - - #[test] - fn osc52_forwarder_handles_split_sequence_mid_payload() { - let mut fw = Osc52Forwarder::default(); - fw.observe(b"\x1b]52;c;aGVs"); - assert!(fw.drain_pending().is_empty()); - fw.observe(b"bG8gd29y"); - assert!(fw.drain_pending().is_empty()); - fw.observe(b"bGQ=\x07"); - let pending = fw.drain_pending(); - assert_eq!(pending, vec![b"hello world".to_vec()]); - } - - #[test] - fn osc52_forwarder_handles_split_before_bel() { - let mut fw = Osc52Forwarder::default(); - fw.observe(b"\x1b]52;c;aGk="); - assert!(fw.drain_pending().is_empty()); - fw.observe(b"\x07"); - let pending = fw.drain_pending(); - assert_eq!(pending, vec![b"hi".to_vec()]); - } - - #[test] - fn osc52_forwarder_handles_split_between_esc_and_backslash() { - let mut fw = Osc52Forwarder::default(); - fw.observe(b"\x1b]52;c;aGk=\x1b"); - assert!(fw.drain_pending().is_empty()); - fw.observe(b"\\"); - let pending = fw.drain_pending(); - assert_eq!(pending, vec![b"hi".to_vec()]); - } - - #[test] - fn osc52_forwarder_payload_size_limit() { - let mut fw = Osc52Forwarder::default(); - let mut huge = Vec::with_capacity(OSC52_MAX_PAYLOAD_BYTES + 32); - huge.extend_from_slice(b"\x1b]52;c;"); - huge.extend(std::iter::repeat_n(b'A', OSC52_MAX_PAYLOAD_BYTES + 16)); - huge.push(0x07); - fw.observe(&huge); - assert!(fw.drain_pending().is_empty()); - - fw.observe(b"\x1b]52;c;aGk=\x07"); - let pending = fw.drain_pending(); - assert_eq!(pending, vec![b"hi".to_vec()]); - } - - #[test] - fn osc52_forwarder_recovers_after_garbage() { - let mut fw = Osc52Forwarder::default(); - fw.observe(b"\x01\x02random\x7fbytes\x1b]52;c;aGk=\x07tail"); - let pending = fw.drain_pending(); - assert_eq!(pending, vec![b"hi".to_vec()]); - } - - #[test] - fn osc52_forwarder_multiple_in_one_chunk() { - let mut fw = Osc52Forwarder::default(); - fw.observe(b"\x1b]52;c;aGk=\x07\x1b]52;c;Ynll\x07"); - let pending = fw.drain_pending(); - assert_eq!(pending, vec![b"hi".to_vec(), b"bye".to_vec()]); - } - - #[test] - fn osc52_forwarder_drain_clears_pending() { - let mut fw = Osc52Forwarder::default(); - fw.observe(b"\x1b]52;c;aGk=\x07"); - assert_eq!(fw.drain_pending(), vec![b"hi".to_vec()]); - assert!(fw.drain_pending().is_empty()); - } - - #[test] - fn droid_scrollback_compat_matches_process_name_and_cmdline() { - let name_only = crate::platform::ForegroundJob { - process_group_id: 42, - processes: vec![crate::platform::ForegroundProcess { - pid: 42, - name: "droid".to_string(), - argv0: None, - cmdline: Some("/opt/factory/droid --resume".to_string()), - }], - }; - assert!(foreground_job_uses_droid_scrollback_compat(&name_only)); - - let cmdline_only = crate::platform::ForegroundJob { - process_group_id: 42, - processes: vec![crate::platform::ForegroundProcess { - pid: 42, - name: "bun".to_string(), - argv0: Some("bun".to_string()), - cmdline: Some("/home/can/.local/bin/droid --resume".to_string()), - }], - }; - assert!(foreground_job_uses_droid_scrollback_compat(&cmdline_only)); - - let shell = shell_job(7); - assert!(!foreground_job_uses_droid_scrollback_compat(&shell)); - } - - #[test] - fn strip_scrollback_clear_sequences_removes_ed3_only() { - let filtered = strip_scrollback_clear_sequences(b"a\x1b[3Jb\x1b[?3Jc\x1b[2Jd"); - assert_eq!(filtered.as_ref(), b"abc\x1b[2Jd"); - } - - #[test] - fn primary_screen_droid_compat_ignores_scrollback_clear_only_for_droid() { - let droid_job = crate::platform::ForegroundJob { - process_group_id: 42, - processes: vec![crate::platform::ForegroundProcess { - pid: 42, - name: "droid".to_string(), - argv0: Some("droid".to_string()), - cmdline: Some("droid".to_string()), - }], - }; - - let filtered = maybe_filter_primary_screen_scrollback_clear( - b"\x1b[3J\x1b[2J", - false, - Some(&droid_job), - ); - assert_eq!(filtered.as_ref(), b"\x1b[2J"); - - let shell = maybe_filter_primary_screen_scrollback_clear( - b"\x1b[3J\x1b[2J", - false, - Some(&shell_job(7)), - ); - assert_eq!(shell.as_ref(), b"\x1b[3J\x1b[2J"); - - let alternate = - maybe_filter_primary_screen_scrollback_clear(b"\x1b[3J\x1b[2J", true, Some(&droid_job)); - assert_eq!(alternate.as_ref(), b"\x1b[3J\x1b[2J"); - } - - #[test] - fn host_theme_restore_waits_for_shell_and_non_alternate_screen() { - assert!(!should_restore_host_terminal_theme( - 42, - 7, - true, - Some(&shell_job(7)), - )); - assert!(!should_restore_host_terminal_theme(42, 7, false, None)); - assert!(!should_restore_host_terminal_theme( - 42, - 7, - false, - Some(&crate::platform::ForegroundJob { - process_group_id: 42, - processes: vec![crate::platform::ForegroundProcess { - pid: 42, - name: "droid".to_string(), - argv0: Some("droid".to_string()), - cmdline: Some("droid".to_string()), - }], - }), - )); - assert!(should_restore_host_terminal_theme( - 42, - 7, - false, - Some(&shell_job(7)), - )); - - #[cfg(target_os = "macos")] - assert!(should_restore_host_terminal_theme( - 7, - 7, - false, - Some(&shell_job(7)), - )); - - #[cfg(not(target_os = "macos"))] - assert!(!should_restore_host_terminal_theme( - 7, - 7, - false, - Some(&shell_job(7)), - )); - } - - #[test] - fn restore_host_terminal_theme_reapplies_cached_colors() { - let (tx, _rx) = mpsc::channel(4); - let terminal = crate::ghostty::Terminal::new(80, 24, 0).unwrap(); - let pane = GhosttyPaneTerminal::new(terminal, tx).unwrap(); - let pane_id = PaneId::from_raw(1); - let shell_pid = 7; - let host_theme = crate::terminal_theme::TerminalTheme { - foreground: Some(crate::terminal_theme::RgbColor { - r: 0xaa, - g: 0xbb, - b: 0xcc, - }), - background: Some(crate::terminal_theme::RgbColor { - r: 0x11, - g: 0x22, - b: 0x33, - }), - }; - - pane.apply_host_terminal_theme(host_theme); - { - let mut core = pane.core.lock().unwrap(); - core.transient_default_color_owner_pgid = Some(42); - core.terminal.write(b"\x1b]11;rgb:dd/ee/ff\x1b\\"); - } - assert_eq!( - pane_default_theme(&pane).background, - Some(crate::terminal_theme::RgbColor { - r: 0xdd, - g: 0xee, - b: 0xff, - }) - ); - - { - let mut core = pane.core.lock().unwrap(); - assert!(restore_host_terminal_theme_if_needed( - &mut core, - pane_id, - shell_pid, - false, - Some(&shell_job(shell_pid)), - )); - } - - assert_eq!(pane_default_theme(&pane).background, host_theme.background); - assert_eq!(pane_default_theme(&pane).foreground, host_theme.foreground); - } - - #[test] - fn render_leaves_host_default_background_transparent() { - let (tx, _rx) = mpsc::channel(4); - let terminal = crate::ghostty::Terminal::new(20, 5, 0).unwrap(); - let pane = GhosttyPaneTerminal::new(terminal, tx).unwrap(); - let host_theme = crate::terminal_theme::TerminalTheme { - foreground: Some(crate::terminal_theme::RgbColor { - r: 0xaa, - g: 0xbb, - b: 0xcc, - }), - background: Some(crate::terminal_theme::RgbColor { - r: 0x11, - g: 0x22, - b: 0x33, - }), - }; - pane.apply_host_terminal_theme(host_theme); - { - let mut core = pane.core.lock().unwrap(); - core.terminal.write(b"hi"); - } - - let backend = ratatui::backend::TestBackend::new(20, 5); - let mut terminal = ratatui::Terminal::new(backend).unwrap(); - terminal - .draw(|frame| pane.render(frame, Rect::new(0, 0, 20, 5), false)) - .unwrap(); - - let buffer = terminal.backend().buffer(); - assert_eq!(buffer[(0, 0)].symbol(), "h"); - assert_eq!(buffer[(0, 0)].style().bg, Some(Color::Reset)); - assert_eq!(buffer[(2, 0)].symbol(), " "); - assert_eq!(buffer[(2, 0)].style().bg, Some(Color::Reset)); - } - - #[test] - fn render_keeps_explicit_default_background_when_it_differs_from_host() { - let (tx, _rx) = mpsc::channel(4); - let terminal = crate::ghostty::Terminal::new(20, 5, 0).unwrap(); - let pane = GhosttyPaneTerminal::new(terminal, tx).unwrap(); - let host_theme = crate::terminal_theme::TerminalTheme { - foreground: Some(crate::terminal_theme::RgbColor { - r: 0xaa, - g: 0xbb, - b: 0xcc, - }), - background: Some(crate::terminal_theme::RgbColor { - r: 0x11, - g: 0x22, - b: 0x33, - }), - }; - pane.apply_host_terminal_theme(host_theme); - { - let mut core = pane.core.lock().unwrap(); - core.terminal.write(b"\x1b]11;rgb:44/55/66\x1b\\hi"); - } - - let backend = ratatui::backend::TestBackend::new(20, 5); - let mut terminal = ratatui::Terminal::new(backend).unwrap(); - terminal - .draw(|frame| pane.render(frame, Rect::new(0, 0, 20, 5), false)) - .unwrap(); - - let buffer = terminal.backend().buffer(); - let expected_bg = Some(Color::Rgb(0x44, 0x55, 0x66)); - assert_eq!(buffer[(0, 0)].symbol(), "h"); - assert_eq!(buffer[(0, 0)].style().bg, expected_bg); - assert_eq!(buffer[(2, 0)].symbol(), " "); - assert_eq!(buffer[(2, 0)].style().bg, expected_bg); - } - #[tokio::test] async fn focus_events_are_forwarded_when_enabled() { let (tx, mut rx) = mpsc::channel(4); @@ -3225,9 +868,9 @@ mod tests { .mode_set(crate::ghostty::MODE_FOCUS_EVENT, true) .unwrap(); let runtime = PaneRuntime { - terminal: Arc::new(PaneTerminal { - ghostty: GhosttyPaneTerminal::new(terminal, tx.clone()).unwrap(), - }), + terminal: Arc::new(PaneTerminal::new( + GhosttyPaneTerminal::new(terminal, tx.clone()).unwrap(), + )), sender: tx, resize_tx, current_size: Cell::new((80, 24)), @@ -3248,9 +891,9 @@ mod tests { let (resize_tx, _resize_rx) = mpsc::channel(1); let terminal = crate::ghostty::Terminal::new(80, 24, 0).unwrap(); let runtime = PaneRuntime { - terminal: Arc::new(PaneTerminal { - ghostty: GhosttyPaneTerminal::new(terminal, tx.clone()).unwrap(), - }), + terminal: Arc::new(PaneTerminal::new( + GhosttyPaneTerminal::new(terminal, tx.clone()).unwrap(), + )), sender: tx, resize_tx, current_size: Cell::new((80, 24)), @@ -3270,126 +913,31 @@ mod tests { } #[test] - fn trim_trailing_blank_rows_drops_empty_viewport_tail() { - let mut rows = vec!["hello".to_string(), "".to_string(), " ".to_string()]; - trim_trailing_blank_rows(&mut rows); - assert_eq!(rows, vec!["hello".to_string()]); - } - - #[test] - fn claude_working_is_sticky_for_short_gap() { - let now = std::time::Instant::now(); - let mut last_working = None; - - let working = stabilize_agent_state( - Some(Agent::Claude), - AgentState::Idle, - AgentState::Working, - now, - &mut last_working, - ); - assert_eq!(working, AgentState::Working); - - let still_working = stabilize_agent_state( - Some(Agent::Claude), - AgentState::Working, - AgentState::Idle, - now + std::time::Duration::from_millis(400), - &mut last_working, - ); - assert_eq!(still_working, AgentState::Working); - } - - #[test] - fn claude_transitions_to_idle_after_hold_expires() { - let now = std::time::Instant::now(); - let mut last_working = Some(now); - - let state = stabilize_agent_state( - Some(Agent::Claude), - AgentState::Working, - AgentState::Idle, - now + CLAUDE_WORKING_HOLD + std::time::Duration::from_millis(1), - &mut last_working, - ); - assert_eq!(state, AgentState::Idle); - } - - #[test] - fn non_claude_states_are_unchanged() { - let now = std::time::Instant::now(); - let mut last_working = None; - - let state = stabilize_agent_state( - Some(Agent::Codex), - AgentState::Working, - AgentState::Idle, - now, - &mut last_working, - ); - assert_eq!(state, AgentState::Idle); - } - - #[test] - fn hook_authority_overrides_fallback_for_same_agent() { - let mut pane = PaneState::new(); - pane.set_detected_state(Some(Agent::Pi), AgentState::Idle); - pane.set_hook_authority("herdr:pi".into(), "pi".into(), AgentState::Working, None); - - assert_eq!(pane.detected_agent, Some(Agent::Pi)); - assert_eq!(pane.fallback_state, AgentState::Idle); - assert_eq!(pane.effective_agent_label(), Some("pi")); - assert_eq!(pane.state, AgentState::Working); - } - - #[test] - fn hook_authority_can_override_with_unknown_agent_label() { - let mut pane = PaneState::new(); - pane.set_detected_state(Some(Agent::Pi), AgentState::Idle); - pane.set_hook_authority( - "herdr:custom".into(), - "hermes".into(), - AgentState::Working, - None, - ); - - assert_eq!(pane.detected_agent, Some(Agent::Pi)); - assert_eq!(pane.effective_agent_label(), Some("hermes")); - assert_eq!(pane.effective_known_agent(), None); - assert_eq!(pane.state, AgentState::Working); - } - - #[test] - fn hook_authority_survives_detected_agent_changes() { - let mut pane = PaneState::new(); - pane.set_detected_state(Some(Agent::Pi), AgentState::Idle); - pane.set_hook_authority( - "herdr:custom".into(), - "hermes".into(), - AgentState::Working, - None, - ); + fn transient_process_miss_keeps_current_agent_detected() { + let mut presence = AgentDetectionPresence::from_agent(Some(Agent::Pi)); - pane.set_detected_state(None, AgentState::Unknown); + let changed = presence.observe_process_probe(None); - assert!(pane.hook_authority.is_some()); - assert_eq!(pane.detected_agent, None); - assert_eq!(pane.effective_agent_label(), Some("hermes")); - assert_eq!(pane.state, AgentState::Working); + assert!(!changed, "one miss should not clear the detected agent"); + assert_eq!(presence.current_agent(), Some(Agent::Pi)); } #[test] - fn release_agent_clears_identity_immediately() { - let mut pane = PaneState::new(); - pane.set_detected_state(Some(Agent::Pi), AgentState::Idle); - pane.set_hook_authority("herdr:pi".into(), "pi".into(), AgentState::Working, None); + fn agent_only_clears_after_confirmation_misses() { + let mut presence = AgentDetectionPresence::from_agent(Some(Agent::Pi)); - pane.release_agent("herdr:pi", "pi"); + for attempt in 1..AGENT_MISS_CONFIRMATION_ATTEMPTS { + let changed = presence.observe_process_probe(None); + assert!( + !changed, + "miss {attempt} should stay in the confirmation window" + ); + assert_eq!(presence.current_agent(), Some(Agent::Pi)); + } - assert!(pane.hook_authority.is_none()); - assert_eq!(pane.detected_agent, None); - assert_eq!(pane.fallback_state, AgentState::Unknown); - assert_eq!(pane.state, AgentState::Unknown); + let changed = presence.observe_process_probe(None); + assert!(changed, "last confirmation miss should clear the agent"); + assert_eq!(presence.current_agent(), None); } #[tokio::test] diff --git a/src/pane/input.rs b/src/pane/input.rs new file mode 100644 index 00000000..262e036d --- /dev/null +++ b/src/pane/input.rs @@ -0,0 +1,293 @@ +pub(super) fn ghostty_key_event_from_terminal_key( + key: crate::input::TerminalKey, +) -> Option<crate::ghostty::KeyEvent> { + let mut event = crate::ghostty::KeyEvent::new().ok()?; + event.set_action(match key.kind { + crossterm::event::KeyEventKind::Press => { + crate::ghostty::ffi::GhosttyKeyAction_GHOSTTY_KEY_ACTION_PRESS + } + crossterm::event::KeyEventKind::Release => { + crate::ghostty::ffi::GhosttyKeyAction_GHOSTTY_KEY_ACTION_RELEASE + } + crossterm::event::KeyEventKind::Repeat => { + crate::ghostty::ffi::GhosttyKeyAction_GHOSTTY_KEY_ACTION_REPEAT + } + }); + event.set_mods(ghostty_mods_from_key_modifiers(key.modifiers)); + event.set_key(ghostty_key_from_crossterm_key_code( + key.code, + key.shifted_codepoint, + )?); + + if let Some(text) = ghostty_key_text(key) { + event.set_utf8(&text); + } else { + event.set_utf8(""); + } + + if let Some(codepoint) = ghostty_unshifted_codepoint(key) { + event.set_unshifted_codepoint(codepoint); + } + + Some(event) +} + +pub(super) fn ghostty_prefers_herdr_text_encoding(key: crate::input::TerminalKey) -> bool { + matches!(key.code, crossterm::event::KeyCode::Char(_)) +} + +pub(super) fn ghostty_mods_from_key_modifiers(modifiers: crossterm::event::KeyModifiers) -> u16 { + let mut ghostty_mods = 0u16; + if modifiers.contains(crossterm::event::KeyModifiers::SHIFT) { + ghostty_mods |= crate::ghostty::MOD_SHIFT; + } + if modifiers.contains(crossterm::event::KeyModifiers::CONTROL) { + ghostty_mods |= crate::ghostty::MOD_CTRL; + } + if modifiers.contains(crossterm::event::KeyModifiers::ALT) { + ghostty_mods |= crate::ghostty::MOD_ALT; + } + if modifiers.contains(crossterm::event::KeyModifiers::SUPER) { + ghostty_mods |= crate::ghostty::MOD_SUPER; + } + ghostty_mods +} + +pub(super) fn ghostty_mouse_encoder_for_terminal( + terminal: &crate::ghostty::Terminal, +) -> Option<crate::ghostty::MouseEncoder> { + let mut encoder = crate::ghostty::MouseEncoder::new().ok()?; + encoder.set_from_terminal(terminal); + let cols = terminal.cols().ok()? as u32; + let rows = terminal.rows().ok()? as u32; + encoder.set_size(cols, rows, 1, 1); + Some(encoder) +} + +pub(super) fn ghostty_mouse_event_from_button_kind( + kind: crossterm::event::MouseEventKind, + column: u16, + row: u16, + modifiers: crossterm::event::KeyModifiers, +) -> Option<crate::ghostty::MouseEvent> { + let mut event = crate::ghostty::MouseEvent::new().ok()?; + let (action, button) = match kind { + crossterm::event::MouseEventKind::Down(crossterm::event::MouseButton::Left) => ( + crate::ghostty::MOUSE_ACTION_PRESS, + Some(crate::ghostty::MOUSE_BUTTON_LEFT), + ), + crossterm::event::MouseEventKind::Down(crossterm::event::MouseButton::Middle) => ( + crate::ghostty::MOUSE_ACTION_PRESS, + Some(crate::ghostty::MOUSE_BUTTON_MIDDLE), + ), + crossterm::event::MouseEventKind::Down(crossterm::event::MouseButton::Right) => ( + crate::ghostty::MOUSE_ACTION_PRESS, + Some(crate::ghostty::MOUSE_BUTTON_RIGHT), + ), + crossterm::event::MouseEventKind::Up(crossterm::event::MouseButton::Left) => ( + crate::ghostty::MOUSE_ACTION_RELEASE, + Some(crate::ghostty::MOUSE_BUTTON_LEFT), + ), + crossterm::event::MouseEventKind::Up(crossterm::event::MouseButton::Middle) => ( + crate::ghostty::MOUSE_ACTION_RELEASE, + Some(crate::ghostty::MOUSE_BUTTON_MIDDLE), + ), + crossterm::event::MouseEventKind::Up(crossterm::event::MouseButton::Right) => ( + crate::ghostty::MOUSE_ACTION_RELEASE, + Some(crate::ghostty::MOUSE_BUTTON_RIGHT), + ), + crossterm::event::MouseEventKind::Drag(crossterm::event::MouseButton::Left) => ( + crate::ghostty::MOUSE_ACTION_MOTION, + Some(crate::ghostty::MOUSE_BUTTON_LEFT), + ), + crossterm::event::MouseEventKind::Drag(crossterm::event::MouseButton::Middle) => ( + crate::ghostty::MOUSE_ACTION_MOTION, + Some(crate::ghostty::MOUSE_BUTTON_MIDDLE), + ), + crossterm::event::MouseEventKind::Drag(crossterm::event::MouseButton::Right) => ( + crate::ghostty::MOUSE_ACTION_MOTION, + Some(crate::ghostty::MOUSE_BUTTON_RIGHT), + ), + _ => return None, + }; + event.set_action(action); + if let Some(button) = button { + event.set_button(button); + } else { + event.clear_button(); + } + event.set_mods(ghostty_mods_from_key_modifiers(modifiers)); + event.set_position(column as f32, row as f32); + Some(event) +} + +pub(super) fn ghostty_mouse_event_from_wheel_kind( + kind: crossterm::event::MouseEventKind, + column: u16, + row: u16, + modifiers: crossterm::event::KeyModifiers, +) -> Option<crate::ghostty::MouseEvent> { + let mut event = crate::ghostty::MouseEvent::new().ok()?; + event.set_action(crate::ghostty::MOUSE_ACTION_PRESS); + let button = match kind { + crossterm::event::MouseEventKind::ScrollUp => crate::ghostty::MOUSE_BUTTON_WHEEL_UP, + crossterm::event::MouseEventKind::ScrollDown => crate::ghostty::MOUSE_BUTTON_WHEEL_DOWN, + crossterm::event::MouseEventKind::ScrollLeft => crate::ghostty::MOUSE_BUTTON_WHEEL_LEFT, + crossterm::event::MouseEventKind::ScrollRight => crate::ghostty::MOUSE_BUTTON_WHEEL_RIGHT, + _ => return None, + }; + event.set_button(button); + event.set_mods(ghostty_mods_from_key_modifiers(modifiers)); + event.set_position(column as f32, row as f32); + Some(event) +} + +fn ghostty_key_text(key: crate::input::TerminalKey) -> Option<String> { + match key.code { + crossterm::event::KeyCode::Char(c) => Some( + key.shifted_codepoint + .and_then(char::from_u32) + .unwrap_or(c) + .to_string(), + ), + _ => None, + } +} + +fn ghostty_unshifted_codepoint(key: crate::input::TerminalKey) -> Option<u32> { + match key.code { + crossterm::event::KeyCode::Char(c) => Some(c as u32), + _ => None, + } +} + +fn ghostty_key_from_crossterm_key_code( + code: crossterm::event::KeyCode, + shifted_codepoint: Option<u32>, +) -> Option<u32> { + use crate::ghostty::ffi; + use crossterm::event::KeyCode; + + match code { + KeyCode::Backspace => Some(ffi::GhosttyKey_GHOSTTY_KEY_BACKSPACE), + KeyCode::Enter => Some(ffi::GhosttyKey_GHOSTTY_KEY_ENTER), + KeyCode::Left => Some(ffi::GhosttyKey_GHOSTTY_KEY_ARROW_LEFT), + KeyCode::Right => Some(ffi::GhosttyKey_GHOSTTY_KEY_ARROW_RIGHT), + KeyCode::Up => Some(ffi::GhosttyKey_GHOSTTY_KEY_ARROW_UP), + KeyCode::Down => Some(ffi::GhosttyKey_GHOSTTY_KEY_ARROW_DOWN), + KeyCode::Home => Some(ffi::GhosttyKey_GHOSTTY_KEY_HOME), + KeyCode::End => Some(ffi::GhosttyKey_GHOSTTY_KEY_END), + KeyCode::PageUp => Some(ffi::GhosttyKey_GHOSTTY_KEY_PAGE_UP), + KeyCode::PageDown => Some(ffi::GhosttyKey_GHOSTTY_KEY_PAGE_DOWN), + KeyCode::Tab | KeyCode::BackTab => Some(ffi::GhosttyKey_GHOSTTY_KEY_TAB), + KeyCode::Delete => Some(ffi::GhosttyKey_GHOSTTY_KEY_DELETE), + KeyCode::Insert => Some(ffi::GhosttyKey_GHOSTTY_KEY_INSERT), + KeyCode::Esc => Some(ffi::GhosttyKey_GHOSTTY_KEY_ESCAPE), + KeyCode::F(n) => Some(match n { + 1 => ffi::GhosttyKey_GHOSTTY_KEY_F1, + 2 => ffi::GhosttyKey_GHOSTTY_KEY_F2, + 3 => ffi::GhosttyKey_GHOSTTY_KEY_F3, + 4 => ffi::GhosttyKey_GHOSTTY_KEY_F4, + 5 => ffi::GhosttyKey_GHOSTTY_KEY_F5, + 6 => ffi::GhosttyKey_GHOSTTY_KEY_F6, + 7 => ffi::GhosttyKey_GHOSTTY_KEY_F7, + 8 => ffi::GhosttyKey_GHOSTTY_KEY_F8, + 9 => ffi::GhosttyKey_GHOSTTY_KEY_F9, + 10 => ffi::GhosttyKey_GHOSTTY_KEY_F10, + 11 => ffi::GhosttyKey_GHOSTTY_KEY_F11, + 12 => ffi::GhosttyKey_GHOSTTY_KEY_F12, + _ => return None, + }), + KeyCode::Char(c) => ghostty_key_from_char(c, shifted_codepoint), + _ => None, + } +} + +fn ghostty_key_from_char(c: char, shifted_codepoint: Option<u32>) -> Option<u32> { + use crate::ghostty::ffi; + + let base = if let Some(shifted) = shifted_codepoint.and_then(char::from_u32) { + ghostty_unshifted_ascii_pair(shifted).unwrap_or(c) + } else { + c + }; + + match base.to_ascii_lowercase() { + 'a' => Some(ffi::GhosttyKey_GHOSTTY_KEY_A), + 'b' => Some(ffi::GhosttyKey_GHOSTTY_KEY_B), + 'c' => Some(ffi::GhosttyKey_GHOSTTY_KEY_C), + 'd' => Some(ffi::GhosttyKey_GHOSTTY_KEY_D), + 'e' => Some(ffi::GhosttyKey_GHOSTTY_KEY_E), + 'f' => Some(ffi::GhosttyKey_GHOSTTY_KEY_F), + 'g' => Some(ffi::GhosttyKey_GHOSTTY_KEY_G), + 'h' => Some(ffi::GhosttyKey_GHOSTTY_KEY_H), + 'i' => Some(ffi::GhosttyKey_GHOSTTY_KEY_I), + 'j' => Some(ffi::GhosttyKey_GHOSTTY_KEY_J), + 'k' => Some(ffi::GhosttyKey_GHOSTTY_KEY_K), + 'l' => Some(ffi::GhosttyKey_GHOSTTY_KEY_L), + 'm' => Some(ffi::GhosttyKey_GHOSTTY_KEY_M), + 'n' => Some(ffi::GhosttyKey_GHOSTTY_KEY_N), + 'o' => Some(ffi::GhosttyKey_GHOSTTY_KEY_O), + 'p' => Some(ffi::GhosttyKey_GHOSTTY_KEY_P), + 'q' => Some(ffi::GhosttyKey_GHOSTTY_KEY_Q), + 'r' => Some(ffi::GhosttyKey_GHOSTTY_KEY_R), + 's' => Some(ffi::GhosttyKey_GHOSTTY_KEY_S), + 't' => Some(ffi::GhosttyKey_GHOSTTY_KEY_T), + 'u' => Some(ffi::GhosttyKey_GHOSTTY_KEY_U), + 'v' => Some(ffi::GhosttyKey_GHOSTTY_KEY_V), + 'w' => Some(ffi::GhosttyKey_GHOSTTY_KEY_W), + 'x' => Some(ffi::GhosttyKey_GHOSTTY_KEY_X), + 'y' => Some(ffi::GhosttyKey_GHOSTTY_KEY_Y), + 'z' => Some(ffi::GhosttyKey_GHOSTTY_KEY_Z), + '0' => Some(ffi::GhosttyKey_GHOSTTY_KEY_DIGIT_0), + '1' => Some(ffi::GhosttyKey_GHOSTTY_KEY_DIGIT_1), + '2' => Some(ffi::GhosttyKey_GHOSTTY_KEY_DIGIT_2), + '3' => Some(ffi::GhosttyKey_GHOSTTY_KEY_DIGIT_3), + '4' => Some(ffi::GhosttyKey_GHOSTTY_KEY_DIGIT_4), + '5' => Some(ffi::GhosttyKey_GHOSTTY_KEY_DIGIT_5), + '6' => Some(ffi::GhosttyKey_GHOSTTY_KEY_DIGIT_6), + '7' => Some(ffi::GhosttyKey_GHOSTTY_KEY_DIGIT_7), + '8' => Some(ffi::GhosttyKey_GHOSTTY_KEY_DIGIT_8), + '9' => Some(ffi::GhosttyKey_GHOSTTY_KEY_DIGIT_9), + '`' => Some(ffi::GhosttyKey_GHOSTTY_KEY_BACKQUOTE), + '\\' => Some(ffi::GhosttyKey_GHOSTTY_KEY_BACKSLASH), + '[' => Some(ffi::GhosttyKey_GHOSTTY_KEY_BRACKET_LEFT), + ']' => Some(ffi::GhosttyKey_GHOSTTY_KEY_BRACKET_RIGHT), + ',' => Some(ffi::GhosttyKey_GHOSTTY_KEY_COMMA), + '=' => Some(ffi::GhosttyKey_GHOSTTY_KEY_EQUAL), + '-' => Some(ffi::GhosttyKey_GHOSTTY_KEY_MINUS), + '.' => Some(ffi::GhosttyKey_GHOSTTY_KEY_PERIOD), + '\'' => Some(ffi::GhosttyKey_GHOSTTY_KEY_QUOTE), + ';' => Some(ffi::GhosttyKey_GHOSTTY_KEY_SEMICOLON), + '/' => Some(ffi::GhosttyKey_GHOSTTY_KEY_SLASH), + ' ' => Some(ffi::GhosttyKey_GHOSTTY_KEY_SPACE), + _ => None, + } +} + +fn ghostty_unshifted_ascii_pair(c: char) -> Option<char> { + Some(match c { + '!' => '1', + '@' => '2', + '#' => '3', + '$' => '4', + '%' => '5', + '^' => '6', + '&' => '7', + '*' => '8', + '(' => '9', + ')' => '0', + '_' => '-', + '+' => '=', + '{' => '[', + '}' => ']', + '|' => '\\', + ':' => ';', + '"' => '\'', + '<' => ',', + '>' => '.', + '?' => '/', + '~' => '`', + _ => return None, + }) +} diff --git a/src/pane/osc.rs b/src/pane/osc.rs new file mode 100644 index 00000000..b5278125 --- /dev/null +++ b/src/pane/osc.rs @@ -0,0 +1,706 @@ +use std::borrow::Cow; + +use tracing::info; + +use crate::layout::PaneId; + +use super::terminal::GhosttyPaneCore; + +#[derive(Debug, Default)] +pub(super) struct DefaultColorOscTracker { + state: DefaultColorOscTrackerState, + body: Vec<u8>, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] +enum DefaultColorOscTrackerState { + #[default] + Ground, + Escape, + OscBody, + OscEscape, +} + +impl DefaultColorOscTracker { + pub(super) fn observe(&mut self, bytes: &[u8]) -> bool { + let mut saw_default_color_set = false; + + for &byte in bytes { + match self.state { + DefaultColorOscTrackerState::Ground => { + if byte == 0x1b { + self.state = DefaultColorOscTrackerState::Escape; + } + } + DefaultColorOscTrackerState::Escape => { + if byte == b']' { + self.body.clear(); + self.state = DefaultColorOscTrackerState::OscBody; + } else if byte == 0x1b { + self.state = DefaultColorOscTrackerState::Escape; + } else { + self.state = DefaultColorOscTrackerState::Ground; + } + } + DefaultColorOscTrackerState::OscBody => match byte { + 0x07 => { + saw_default_color_set |= is_default_color_set_osc(&self.body); + self.body.clear(); + self.state = DefaultColorOscTrackerState::Ground; + } + 0x1b => self.state = DefaultColorOscTrackerState::OscEscape, + _ => self.body.push(byte), + }, + DefaultColorOscTrackerState::OscEscape => { + if byte == b'\\' { + saw_default_color_set |= is_default_color_set_osc(&self.body); + self.body.clear(); + self.state = DefaultColorOscTrackerState::Ground; + } else { + self.body.push(0x1b); + self.body.push(byte); + self.state = DefaultColorOscTrackerState::OscBody; + } + } + } + + if self.body.len() > 1024 { + self.body.clear(); + self.state = DefaultColorOscTrackerState::Ground; + } + } + + saw_default_color_set + } +} + +fn is_default_color_set_osc(body: &[u8]) -> bool { + let Some(separator) = body.iter().position(|byte| *byte == b';') else { + return false; + }; + let command = &body[..separator]; + let value = &body[separator + 1..]; + matches!(command, b"10" | b"11") && !value.is_empty() && value != b"?" +} + +/// 256 KiB of base64 ≈ 192 KiB of text — enough for real source-file copies +/// while still bounding memory against stream garbage. +const OSC52_MAX_PAYLOAD_BYTES: usize = 256 * 1024; + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] +enum Osc52ForwarderState { + #[default] + Ground, + Escape, + OscBody, + OscEscape, +} + +/// Reconstructs OSC 52 clipboard-write sequences from raw PTY bytes so the +/// main loop can re-emit them. `libghostty-vt` drops `.clipboard_contents`, +/// so child clipboard writes never reach the host terminal unless we forward +/// them ourselves. +#[derive(Debug, Default)] +pub(super) struct Osc52Forwarder { + state: Osc52ForwarderState, + body: Vec<u8>, + pending: Vec<Vec<u8>>, +} + +impl Osc52Forwarder { + pub(super) fn observe(&mut self, bytes: &[u8]) { + for &byte in bytes { + match self.state { + Osc52ForwarderState::Ground => { + if byte == 0x1b { + self.state = Osc52ForwarderState::Escape; + } + } + Osc52ForwarderState::Escape => { + if byte == b']' { + self.body.clear(); + self.state = Osc52ForwarderState::OscBody; + } else if byte == 0x1b { + self.state = Osc52ForwarderState::Escape; + } else { + self.state = Osc52ForwarderState::Ground; + } + } + Osc52ForwarderState::OscBody => match byte { + 0x07 => { + self.finalize(); + self.state = Osc52ForwarderState::Ground; + } + 0x1b => self.state = Osc52ForwarderState::OscEscape, + _ => self.body.push(byte), + }, + Osc52ForwarderState::OscEscape => { + if byte == b'\\' { + self.finalize(); + self.state = Osc52ForwarderState::Ground; + } else { + self.body.push(0x1b); + self.body.push(byte); + self.state = Osc52ForwarderState::OscBody; + } + } + } + + if self.body.len() > OSC52_MAX_PAYLOAD_BYTES { + self.body.clear(); + self.state = Osc52ForwarderState::Ground; + } + } + } + + fn finalize(&mut self) { + if let Some(content) = parse_osc52_clipboard_write(&self.body) { + self.pending.push(content); + } + self.body.clear(); + } + + pub(super) fn drain_pending(&mut self) -> Vec<Vec<u8>> { + std::mem::take(&mut self.pending) + } +} + +/// Accepts `52;c;<base64>` and `52;;<base64>`. +/// Queries (`?`) are rejected because herdr has no reply path. +/// The payload must decode as base64 before it is forwarded. +fn parse_osc52_clipboard_write(body: &[u8]) -> Option<Vec<u8>> { + use base64::Engine; + + let rest = body.strip_prefix(b"52;")?; + let sep = rest.iter().position(|b| *b == b';')?; + let selector = &rest[..sep]; + let data = &rest[sep + 1..]; + if !(selector.is_empty() || selector == b"c") || data == b"?" { + return None; + } + base64::engine::general_purpose::STANDARD.decode(data).ok() +} + +fn foreground_job_is_shell(job: &crate::platform::ForegroundJob, shell_pid: u32) -> bool { + job.processes.iter().any(|process| process.pid == shell_pid) +} + +pub(super) fn current_transient_default_color_owner(shell_pid: u32) -> Option<u32> { + let job = crate::detect::foreground_job(shell_pid)?; + (!foreground_job_is_shell(&job, shell_pid)).then_some(job.process_group_id) +} + +fn foreground_job_uses_droid_scrollback_compat(job: &crate::platform::ForegroundJob) -> bool { + job.processes.iter().any(|process| { + process.name.eq_ignore_ascii_case("droid") + || process + .argv0 + .as_deref() + .is_some_and(|argv0| argv0.eq_ignore_ascii_case("droid")) + || process.cmdline.as_deref().is_some_and(|cmdline| { + cmdline.eq_ignore_ascii_case("droid") + || cmdline.starts_with("droid ") + || cmdline.to_ascii_lowercase().contains("/droid") + }) + }) +} + +pub(super) fn contains_scrollback_clear_sequence(bytes: &[u8]) -> bool { + bytes.windows(4).any(|window| window == b"\x1b[3J") + || bytes.windows(5).any(|window| window == b"\x1b[?3J") +} + +fn strip_scrollback_clear_sequences<'a>(bytes: &'a [u8]) -> Cow<'a, [u8]> { + if !contains_scrollback_clear_sequence(bytes) { + return Cow::Borrowed(bytes); + } + + let mut filtered = Vec::with_capacity(bytes.len()); + let mut index = 0; + while index < bytes.len() { + let remaining = &bytes[index..]; + if remaining.starts_with(b"\x1b[3J") { + index += 4; + continue; + } + if remaining.starts_with(b"\x1b[?3J") { + index += 5; + continue; + } + filtered.push(bytes[index]); + index += 1; + } + + Cow::Owned(filtered) +} + +pub(super) fn maybe_filter_primary_screen_scrollback_clear<'a>( + bytes: &'a [u8], + alternate_screen: bool, + foreground_job: Option<&crate::platform::ForegroundJob>, +) -> Cow<'a, [u8]> { + // Droid redraws its primary-screen TUI with CSI 3 J, which erases pane + // scrollback inside herdr. Keep the hack scoped to Droid on the primary + // screen so normal terminal clear-history behavior still works elsewhere. + if alternate_screen + || !contains_scrollback_clear_sequence(bytes) + || !foreground_job.is_some_and(foreground_job_uses_droid_scrollback_compat) + { + return Cow::Borrowed(bytes); + } + + strip_scrollback_clear_sequences(bytes) +} + +#[cfg(target_os = "macos")] +pub(super) fn should_restore_host_terminal_theme( + owner_pgid: u32, + shell_pid: u32, + alternate_screen: bool, + foreground_job: Option<&crate::platform::ForegroundJob>, +) -> bool { + if alternate_screen { + return false; + } + + let Some(foreground_job) = foreground_job else { + return false; + }; + + let _ = owner_pgid; + foreground_job_is_shell(foreground_job, shell_pid) +} + +#[cfg(not(target_os = "macos"))] +pub(super) fn should_restore_host_terminal_theme( + owner_pgid: u32, + shell_pid: u32, + alternate_screen: bool, + foreground_job: Option<&crate::platform::ForegroundJob>, +) -> bool { + if alternate_screen { + return false; + } + + let Some(foreground_job) = foreground_job else { + return false; + }; + + foreground_job.process_group_id != owner_pgid + && foreground_job_is_shell(foreground_job, shell_pid) +} + +pub(super) fn write_host_terminal_theme( + terminal: &mut crate::ghostty::Terminal, + theme: crate::terminal_theme::TerminalTheme, +) { + if let Some(color) = theme.foreground { + let sequence = crate::terminal_theme::osc_set_default_color_sequence( + crate::terminal_theme::DefaultColorKind::Foreground, + color, + ); + terminal.write(sequence.as_bytes()); + } + if let Some(color) = theme.background { + let sequence = crate::terminal_theme::osc_set_default_color_sequence( + crate::terminal_theme::DefaultColorKind::Background, + color, + ); + terminal.write(sequence.as_bytes()); + } +} + +pub(super) fn restore_host_terminal_theme_if_needed( + core: &mut GhosttyPaneCore, + pane_id: PaneId, + shell_pid: u32, + alternate_screen: bool, + foreground_job: Option<&crate::platform::ForegroundJob>, +) -> bool { + let Some(owner_pgid) = core.transient_default_color_owner_pgid else { + return false; + }; + if core.host_terminal_theme.is_empty() { + return false; + } + if !should_restore_host_terminal_theme(owner_pgid, shell_pid, alternate_screen, foreground_job) + { + return false; + } + + core.transient_default_color_owner_pgid = None; + write_host_terminal_theme(&mut core.terminal, core.host_terminal_theme); + info!( + pane = pane_id.raw(), + owner_pgid, "restored host terminal default colors after transient override" + ); + true +} + +#[cfg(test)] +mod tests { + use tokio::sync::mpsc; + + use super::*; + use crate::layout::PaneId; + + fn pane_default_theme( + pane: &super::super::GhosttyPaneTerminal, + ) -> crate::terminal_theme::TerminalTheme { + let mut core = pane.core.lock().unwrap(); + let super::super::terminal::GhosttyPaneCore { + terminal, + render_state, + .. + } = &mut *core; + render_state.update(terminal).unwrap(); + let colors = render_state.colors().unwrap(); + crate::terminal_theme::TerminalTheme { + foreground: Some(crate::terminal_theme::RgbColor { + r: colors.foreground.r, + g: colors.foreground.g, + b: colors.foreground.b, + }), + background: Some(crate::terminal_theme::RgbColor { + r: colors.background.r, + g: colors.background.g, + b: colors.background.b, + }), + } + } + + fn shell_job(shell_pid: u32) -> crate::platform::ForegroundJob { + crate::platform::ForegroundJob { + process_group_id: shell_pid, + processes: vec![crate::platform::ForegroundProcess { + pid: shell_pid, + name: "zsh".to_string(), + argv0: Some("zsh".to_string()), + cmdline: Some("zsh".to_string()), + }], + } + } + + #[test] + fn default_color_tracker_detects_split_osc_11_sequences() { + let mut tracker = DefaultColorOscTracker::default(); + + assert!(!tracker.observe(b"\x1b]11;rgb:11/22")); + assert!(tracker.observe(b"/33\x1b\\")); + } + + #[test] + fn default_color_tracker_ignores_osc_queries() { + let mut tracker = DefaultColorOscTracker::default(); + + assert!(!tracker.observe(b"\x1b]10;?\x1b\\")); + assert!(!tracker.observe(b"\x1b]11;?\x07")); + } + + #[test] + fn osc52_forwarder_detects_write_with_bel() { + let mut fw = Osc52Forwarder::default(); + fw.observe(b"\x1b]52;c;aGVsbG8=\x07"); + let pending = fw.drain_pending(); + assert_eq!(pending, vec![b"hello".to_vec()]); + } + + #[test] + fn osc52_forwarder_detects_write_with_st() { + let mut fw = Osc52Forwarder::default(); + fw.observe(b"\x1b]52;c;aGVsbG8=\x1b\\"); + let pending = fw.drain_pending(); + assert_eq!(pending, vec![b"hello".to_vec()]); + } + + #[test] + fn osc52_forwarder_detects_empty_selector_form() { + let mut fw = Osc52Forwarder::default(); + fw.observe(b"\x1b]52;;aGVsbG8=\x07"); + let pending = fw.drain_pending(); + assert_eq!(pending, vec![b"hello".to_vec()]); + } + + #[test] + fn osc52_forwarder_accepts_clear_clipboard() { + let mut fw = Osc52Forwarder::default(); + fw.observe(b"\x1b]52;c;\x07"); + let pending = fw.drain_pending(); + assert_eq!(pending, vec![Vec::<u8>::new()]); + } + + #[test] + fn osc52_forwarder_ignores_query() { + let mut fw = Osc52Forwarder::default(); + fw.observe(b"\x1b]52;c;?\x07"); + assert!(fw.drain_pending().is_empty()); + } + + #[test] + fn osc52_forwarder_ignores_empty_selector_query() { + let mut fw = Osc52Forwarder::default(); + fw.observe(b"\x1b]52;;?\x07"); + assert!(fw.drain_pending().is_empty()); + } + + #[test] + fn osc52_forwarder_ignores_other_kinds() { + let mut fw = Osc52Forwarder::default(); + fw.observe(b"\x1b]52;p;aGk=\x07"); + fw.observe(b"\x1b]52;s;aGk=\x07"); + fw.observe(b"\x1b]52;q;aGk=\x07"); + fw.observe(b"\x1b]52;0;aGk=\x07"); + fw.observe(b"\x1b]52;7;aGk=\x07"); + assert!(fw.drain_pending().is_empty()); + } + + #[test] + fn osc52_forwarder_ignores_invalid_base64() { + let mut fw = Osc52Forwarder::default(); + fw.observe(b"\x1b]52;c;%%%\x07"); + fw.observe(b"\x1b]52;c;aGVs\x1b[bG8=\x07"); + assert!(fw.drain_pending().is_empty()); + } + + #[test] + fn osc52_forwarder_ignores_non_osc52() { + let mut fw = Osc52Forwarder::default(); + fw.observe(b"\x1b]11;?\x07"); + fw.observe(b"\x1b]0;title\x07"); + fw.observe(b"\x1b]8;;https://example.com\x1b\\"); + assert!(fw.drain_pending().is_empty()); + } + + #[test] + fn osc52_forwarder_handles_split_sequence_mid_payload() { + let mut fw = Osc52Forwarder::default(); + fw.observe(b"\x1b]52;c;aGVs"); + assert!(fw.drain_pending().is_empty()); + fw.observe(b"bG8gd29y"); + assert!(fw.drain_pending().is_empty()); + fw.observe(b"bGQ=\x07"); + let pending = fw.drain_pending(); + assert_eq!(pending, vec![b"hello world".to_vec()]); + } + + #[test] + fn osc52_forwarder_handles_split_before_bel() { + let mut fw = Osc52Forwarder::default(); + fw.observe(b"\x1b]52;c;aGk="); + assert!(fw.drain_pending().is_empty()); + fw.observe(b"\x07"); + let pending = fw.drain_pending(); + assert_eq!(pending, vec![b"hi".to_vec()]); + } + + #[test] + fn osc52_forwarder_handles_split_between_esc_and_backslash() { + let mut fw = Osc52Forwarder::default(); + fw.observe(b"\x1b]52;c;aGk=\x1b"); + assert!(fw.drain_pending().is_empty()); + fw.observe(b"\\"); + let pending = fw.drain_pending(); + assert_eq!(pending, vec![b"hi".to_vec()]); + } + + #[test] + fn osc52_forwarder_payload_size_limit() { + let mut fw = Osc52Forwarder::default(); + let mut huge = Vec::with_capacity(OSC52_MAX_PAYLOAD_BYTES + 32); + huge.extend_from_slice(b"\x1b]52;c;"); + huge.extend(std::iter::repeat_n(b'A', OSC52_MAX_PAYLOAD_BYTES + 16)); + huge.push(0x07); + fw.observe(&huge); + assert!(fw.drain_pending().is_empty()); + + fw.observe(b"\x1b]52;c;aGk=\x07"); + let pending = fw.drain_pending(); + assert_eq!(pending, vec![b"hi".to_vec()]); + } + + #[test] + fn osc52_forwarder_recovers_after_garbage() { + let mut fw = Osc52Forwarder::default(); + fw.observe(b"\x01\x02random\x7fbytes\x1b]52;c;aGk=\x07tail"); + let pending = fw.drain_pending(); + assert_eq!(pending, vec![b"hi".to_vec()]); + } + + #[test] + fn osc52_forwarder_multiple_in_one_chunk() { + let mut fw = Osc52Forwarder::default(); + fw.observe(b"\x1b]52;c;aGk=\x07\x1b]52;c;Ynll\x07"); + let pending = fw.drain_pending(); + assert_eq!(pending, vec![b"hi".to_vec(), b"bye".to_vec()]); + } + + #[test] + fn osc52_forwarder_drain_clears_pending() { + let mut fw = Osc52Forwarder::default(); + fw.observe(b"\x1b]52;c;aGk=\x07"); + assert_eq!(fw.drain_pending(), vec![b"hi".to_vec()]); + assert!(fw.drain_pending().is_empty()); + } + + #[test] + fn droid_scrollback_compat_matches_process_name_and_cmdline() { + let name_only = crate::platform::ForegroundJob { + process_group_id: 42, + processes: vec![crate::platform::ForegroundProcess { + pid: 42, + name: "droid".to_string(), + argv0: None, + cmdline: Some("/opt/factory/droid --resume".to_string()), + }], + }; + assert!(foreground_job_uses_droid_scrollback_compat(&name_only)); + + let cmdline_only = crate::platform::ForegroundJob { + process_group_id: 42, + processes: vec![crate::platform::ForegroundProcess { + pid: 42, + name: "bun".to_string(), + argv0: Some("bun".to_string()), + cmdline: Some("/home/can/.local/bin/droid --resume".to_string()), + }], + }; + assert!(foreground_job_uses_droid_scrollback_compat(&cmdline_only)); + + let shell = shell_job(7); + assert!(!foreground_job_uses_droid_scrollback_compat(&shell)); + } + + #[test] + fn strip_scrollback_clear_sequences_removes_ed3_only() { + let filtered = strip_scrollback_clear_sequences(b"a\x1b[3Jb\x1b[?3Jc\x1b[2Jd"); + assert_eq!(filtered.as_ref(), b"abc\x1b[2Jd"); + } + + #[test] + fn primary_screen_droid_compat_ignores_scrollback_clear_only_for_droid() { + let droid_job = crate::platform::ForegroundJob { + process_group_id: 42, + processes: vec![crate::platform::ForegroundProcess { + pid: 42, + name: "droid".to_string(), + argv0: Some("droid".to_string()), + cmdline: Some("droid".to_string()), + }], + }; + + let filtered = maybe_filter_primary_screen_scrollback_clear( + b"\x1b[3J\x1b[2J", + false, + Some(&droid_job), + ); + assert_eq!(filtered.as_ref(), b"\x1b[2J"); + + let shell = maybe_filter_primary_screen_scrollback_clear( + b"\x1b[3J\x1b[2J", + false, + Some(&shell_job(7)), + ); + assert_eq!(shell.as_ref(), b"\x1b[3J\x1b[2J"); + + let alternate = + maybe_filter_primary_screen_scrollback_clear(b"\x1b[3J\x1b[2J", true, Some(&droid_job)); + assert_eq!(alternate.as_ref(), b"\x1b[3J\x1b[2J"); + } + + #[test] + fn host_theme_restore_waits_for_shell_and_non_alternate_screen() { + assert!(!should_restore_host_terminal_theme( + 42, + 7, + true, + Some(&shell_job(7)), + )); + assert!(!should_restore_host_terminal_theme(42, 7, false, None)); + assert!(!should_restore_host_terminal_theme( + 42, + 7, + false, + Some(&crate::platform::ForegroundJob { + process_group_id: 42, + processes: vec![crate::platform::ForegroundProcess { + pid: 42, + name: "droid".to_string(), + argv0: Some("droid".to_string()), + cmdline: Some("droid".to_string()), + }], + }), + )); + assert!(should_restore_host_terminal_theme( + 42, + 7, + false, + Some(&shell_job(7)), + )); + + #[cfg(target_os = "macos")] + assert!(should_restore_host_terminal_theme( + 7, + 7, + false, + Some(&shell_job(7)), + )); + + #[cfg(not(target_os = "macos"))] + assert!(!should_restore_host_terminal_theme( + 7, + 7, + false, + Some(&shell_job(7)), + )); + } + + #[test] + fn restore_host_terminal_theme_reapplies_cached_colors() { + let (tx, _rx) = mpsc::channel(4); + let terminal = crate::ghostty::Terminal::new(80, 24, 0).unwrap(); + let pane = super::super::GhosttyPaneTerminal::new(terminal, tx).unwrap(); + let pane_id = PaneId::from_raw(1); + let shell_pid = 7; + let host_theme = crate::terminal_theme::TerminalTheme { + foreground: Some(crate::terminal_theme::RgbColor { + r: 0xaa, + g: 0xbb, + b: 0xcc, + }), + background: Some(crate::terminal_theme::RgbColor { + r: 0x11, + g: 0x22, + b: 0x33, + }), + }; + + pane.apply_host_terminal_theme(host_theme); + { + let mut core = pane.core.lock().unwrap(); + core.transient_default_color_owner_pgid = Some(42); + core.terminal.write(b"\x1b]11;rgb:dd/ee/ff\x1b\\"); + } + assert_eq!( + pane_default_theme(&pane).background, + Some(crate::terminal_theme::RgbColor { + r: 0xdd, + g: 0xee, + b: 0xff, + }) + ); + + { + let mut core = pane.core.lock().unwrap(); + assert!(restore_host_terminal_theme_if_needed( + &mut core, + pane_id, + shell_pid, + false, + Some(&shell_job(shell_pid)), + )); + } + + assert_eq!(pane_default_theme(&pane).background, host_theme.background); + assert_eq!(pane_default_theme(&pane).foreground, host_theme.foreground); + } +} diff --git a/src/pane/state.rs b/src/pane/state.rs new file mode 100644 index 00000000..973f660a --- /dev/null +++ b/src/pane/state.rs @@ -0,0 +1,313 @@ +use crate::detect::{Agent, AgentState}; + +const CLAUDE_WORKING_HOLD: std::time::Duration = std::time::Duration::from_millis(1200); + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct HookAuthority { + pub source: String, + pub agent_label: String, + pub state: AgentState, + pub message: Option<String>, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct EffectiveStateChange { + pub previous_agent_label: Option<String>, + pub previous_known_agent: Option<Agent>, + pub previous_state: AgentState, + pub agent_label: Option<String>, + pub known_agent: Option<Agent>, + pub state: AgentState, +} + +/// Observable state for a single pane. +/// This is the only part of a pane that workspace logic and tests need. +pub struct PaneState { + pub detected_agent: Option<Agent>, + pub fallback_state: AgentState, + pub hook_authority: Option<HookAuthority>, + pub state: AgentState, + /// Whether the user has seen this pane since its last state change to Idle. + /// False = "Done" (agent finished while user was in another workspace). + pub seen: bool, +} + +impl PaneState { + pub fn new() -> Self { + Self { + detected_agent: None, + fallback_state: AgentState::Unknown, + hook_authority: None, + state: AgentState::Unknown, + seen: true, + } + } + + pub fn set_detected_state( + &mut self, + agent: Option<Agent>, + fallback_state: AgentState, + ) -> Option<EffectiveStateChange> { + let previous_agent_label = self.effective_agent_label().map(str::to_string); + let previous_known_agent = self.effective_known_agent(); + let previous_state = self.state; + self.detected_agent = agent; + self.fallback_state = fallback_state; + self.recompute_effective_state(previous_agent_label, previous_known_agent, previous_state) + } + + pub fn set_hook_authority( + &mut self, + source: String, + agent_label: String, + state: AgentState, + message: Option<String>, + ) -> Option<EffectiveStateChange> { + let previous_agent_label = self.effective_agent_label().map(str::to_string); + let previous_known_agent = self.effective_known_agent(); + let previous_state = self.state; + self.hook_authority = Some(HookAuthority { + source, + agent_label, + state, + message, + }); + self.recompute_effective_state(previous_agent_label, previous_known_agent, previous_state) + } + + pub fn clear_hook_authority(&mut self, source: Option<&str>) -> Option<EffectiveStateChange> { + let previous_agent_label = self.effective_agent_label().map(str::to_string); + let previous_known_agent = self.effective_known_agent(); + let previous_state = self.state; + let should_clear = self + .hook_authority + .as_ref() + .is_some_and(|authority| source.is_none_or(|source| authority.source == source)); + if !should_clear { + return None; + } + self.hook_authority = None; + self.recompute_effective_state(previous_agent_label, previous_known_agent, previous_state) + } + + pub fn release_agent( + &mut self, + source: &str, + agent_label: &str, + ) -> Option<EffectiveStateChange> { + let Some(current_agent_label) = self.effective_agent_label() else { + return None; + }; + if current_agent_label != agent_label { + return None; + } + + if self.hook_authority.as_ref().is_some_and(|authority| { + authority.agent_label != agent_label || authority.source != source + }) { + return None; + } + + let previous_agent_label = self.effective_agent_label().map(str::to_string); + let previous_known_agent = self.effective_known_agent(); + let previous_state = self.state; + self.detected_agent = None; + self.fallback_state = AgentState::Unknown; + self.hook_authority = None; + self.recompute_effective_state(previous_agent_label, previous_known_agent, previous_state) + } + + pub fn effective_agent_label(&self) -> Option<&str> { + self.hook_authority + .as_ref() + .map(|authority| authority.agent_label.as_str()) + .or_else(|| self.detected_agent.map(crate::detect::agent_label)) + } + + pub fn effective_known_agent(&self) -> Option<Agent> { + if let Some(authority) = &self.hook_authority { + return crate::detect::parse_agent_label(&authority.agent_label); + } + self.detected_agent + } + + fn recompute_effective_state( + &mut self, + previous_agent_label: Option<String>, + previous_known_agent: Option<Agent>, + previous_state: AgentState, + ) -> Option<EffectiveStateChange> { + let state = self + .hook_authority + .as_ref() + .map(|authority| authority.state) + .unwrap_or(self.fallback_state); + let agent_label = self.effective_agent_label().map(str::to_string); + let known_agent = self.effective_known_agent(); + + if previous_agent_label == agent_label && previous_state == state { + return None; + } + + self.state = state; + Some(EffectiveStateChange { + previous_agent_label, + previous_known_agent, + previous_state, + agent_label, + known_agent, + state, + }) + } +} + +pub(crate) fn stabilize_agent_state( + agent: Option<Agent>, + previous: AgentState, + raw: AgentState, + now: std::time::Instant, + last_claude_working_at: &mut Option<std::time::Instant>, +) -> AgentState { + if agent != Some(Agent::Claude) { + return raw; + } + + match raw { + AgentState::Working => { + *last_claude_working_at = Some(now); + AgentState::Working + } + AgentState::Blocked => AgentState::Blocked, + AgentState::Idle if previous == AgentState::Working => { + if last_claude_working_at + .is_some_and(|last_working| now.duration_since(last_working) < CLAUDE_WORKING_HOLD) + { + AgentState::Working + } else { + AgentState::Idle + } + } + _ => raw, + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn claude_working_is_sticky_for_short_gap() { + let now = std::time::Instant::now(); + let mut last_working = None; + + let working = stabilize_agent_state( + Some(Agent::Claude), + AgentState::Idle, + AgentState::Working, + now, + &mut last_working, + ); + assert_eq!(working, AgentState::Working); + + let still_working = stabilize_agent_state( + Some(Agent::Claude), + AgentState::Working, + AgentState::Idle, + now + std::time::Duration::from_millis(400), + &mut last_working, + ); + assert_eq!(still_working, AgentState::Working); + } + + #[test] + fn claude_transitions_to_idle_after_hold_expires() { + let now = std::time::Instant::now(); + let mut last_working = Some(now); + + let state = stabilize_agent_state( + Some(Agent::Claude), + AgentState::Working, + AgentState::Idle, + now + CLAUDE_WORKING_HOLD + std::time::Duration::from_millis(1), + &mut last_working, + ); + assert_eq!(state, AgentState::Idle); + } + + #[test] + fn non_claude_states_are_unchanged() { + let now = std::time::Instant::now(); + let mut last_working = None; + + let state = stabilize_agent_state( + Some(Agent::Codex), + AgentState::Working, + AgentState::Idle, + now, + &mut last_working, + ); + assert_eq!(state, AgentState::Idle); + } + + #[test] + fn hook_authority_overrides_fallback_for_same_agent() { + let mut pane = PaneState::new(); + pane.set_detected_state(Some(Agent::Pi), AgentState::Idle); + pane.set_hook_authority("herdr:pi".into(), "pi".into(), AgentState::Working, None); + + assert_eq!(pane.detected_agent, Some(Agent::Pi)); + assert_eq!(pane.fallback_state, AgentState::Idle); + assert_eq!(pane.effective_agent_label(), Some("pi")); + assert_eq!(pane.state, AgentState::Working); + } + + #[test] + fn hook_authority_can_override_with_unknown_agent_label() { + let mut pane = PaneState::new(); + pane.set_detected_state(Some(Agent::Pi), AgentState::Idle); + pane.set_hook_authority( + "herdr:custom".into(), + "hermes".into(), + AgentState::Working, + None, + ); + + assert_eq!(pane.detected_agent, Some(Agent::Pi)); + assert_eq!(pane.effective_agent_label(), Some("hermes")); + assert_eq!(pane.effective_known_agent(), None); + assert_eq!(pane.state, AgentState::Working); + } + + #[test] + fn hook_authority_survives_detected_agent_changes() { + let mut pane = PaneState::new(); + pane.set_detected_state(Some(Agent::Pi), AgentState::Idle); + pane.set_hook_authority( + "herdr:custom".into(), + "hermes".into(), + AgentState::Working, + None, + ); + + pane.set_detected_state(None, AgentState::Unknown); + + assert!(pane.hook_authority.is_some()); + assert_eq!(pane.detected_agent, None); + assert_eq!(pane.effective_agent_label(), Some("hermes")); + assert_eq!(pane.state, AgentState::Working); + } + + #[test] + fn release_agent_clears_identity_immediately() { + let mut pane = PaneState::new(); + pane.set_detected_state(Some(Agent::Pi), AgentState::Idle); + pane.set_hook_authority("herdr:pi".into(), "pi".into(), AgentState::Working, None); + + pane.release_agent("herdr:pi", "pi"); + + assert!(pane.hook_authority.is_none()); + assert_eq!(pane.detected_agent, None); + assert_eq!(pane.fallback_state, AgentState::Unknown); + assert_eq!(pane.state, AgentState::Unknown); + } +} diff --git a/src/pane/terminal.rs b/src/pane/terminal.rs new file mode 100644 index 00000000..796220b9 --- /dev/null +++ b/src/pane/terminal.rs @@ -0,0 +1,1307 @@ +use std::borrow::Cow; +use std::sync::Mutex; + +use bytes::Bytes; +use ratatui::style::{Color, Modifier, Style}; +use ratatui::{layout::Rect, Frame}; +use tokio::sync::mpsc; +use tracing::{debug, error}; +use unicode_width::UnicodeWidthStr; + +use crate::layout::PaneId; + +use super::{ + input::{ + ghostty_key_event_from_terminal_key, ghostty_mouse_encoder_for_terminal, + ghostty_mouse_event_from_button_kind, ghostty_mouse_event_from_wheel_kind, + ghostty_prefers_herdr_text_encoding, + }, + osc::{ + contains_scrollback_clear_sequence, current_transient_default_color_owner, + maybe_filter_primary_screen_scrollback_clear, restore_host_terminal_theme_if_needed, + write_host_terminal_theme, DefaultColorOscTracker, Osc52Forwarder, + }, +}; + +const DEFAULT_DETECTION_ROWS: usize = 24; + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ScrollMetrics { + pub offset_from_bottom: usize, + pub max_offset_from_bottom: usize, + pub viewport_rows: usize, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct InputState { + pub alternate_screen: bool, + pub application_cursor: bool, + pub bracketed_paste: bool, + pub focus_reporting: bool, + pub mouse_protocol_mode: crate::input::MouseProtocolMode, + pub mouse_protocol_encoding: crate::input::MouseProtocolEncoding, + pub mouse_alternate_scroll: bool, +} + +impl InputState { + pub fn mouse_reporting_enabled(self) -> bool { + self.mouse_protocol_mode.reporting_enabled() + } +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub(crate) struct ProcessBytesResult { + pub request_render: bool, + pub clipboard_writes: Vec<Vec<u8>>, +} + +pub(crate) struct GhosttyPaneTerminal { + pub core: Mutex<GhosttyPaneCore>, + key_encoder: Mutex<crate::ghostty::KeyEncoder>, +} + +pub(crate) struct GhosttyPaneCore { + pub terminal: crate::ghostty::Terminal, + pub render_state: crate::ghostty::RenderState, + pub host_terminal_theme: crate::terminal_theme::TerminalTheme, + pub transient_default_color_owner_pgid: Option<u32>, + pub default_color_tracker: DefaultColorOscTracker, + pub osc52_forwarder: Osc52Forwarder, +} + +pub(crate) struct PaneTerminal { + pub(crate) ghostty: GhosttyPaneTerminal, +} + +impl PaneTerminal { + pub(crate) fn new(ghostty: GhosttyPaneTerminal) -> Self { + Self { ghostty } + } + + pub fn process_pty_bytes( + &self, + pane_id: PaneId, + shell_pid: u32, + bytes: &[u8], + response_writer: &mpsc::Sender<Bytes>, + ) -> ProcessBytesResult { + self.ghostty + .process_pty_bytes(pane_id, shell_pid, bytes, response_writer) + } + + pub fn resize(&self, rows: u16, cols: u16) { + self.ghostty.resize(rows, cols); + } + + pub fn scroll_up(&self, lines: usize) { + self.ghostty.scroll_up(lines); + } + + pub fn scroll_down(&self, lines: usize) { + self.ghostty.scroll_down(lines); + } + + pub fn scroll_reset(&self) { + self.ghostty.scroll_reset(); + } + + pub fn set_scroll_offset_from_bottom(&self, lines: usize) { + self.ghostty.set_scroll_offset_from_bottom(lines); + } + + pub fn scroll_metrics(&self) -> Option<ScrollMetrics> { + self.ghostty.scroll_metrics() + } + + pub fn input_state(&self) -> Option<InputState> { + self.ghostty.input_state() + } + + pub fn visible_text(&self) -> String { + self.ghostty.visible_text() + } + + pub fn detection_text(&self) -> String { + self.ghostty.detection_text() + } + + pub fn recent_text(&self, lines: usize) -> String { + self.ghostty.recent_text(lines) + } + + pub fn recent_unwrapped_text(&self, lines: usize) -> String { + self.ghostty.recent_unwrapped_text(lines) + } + + pub fn extract_selection(&self, selection: &crate::selection::Selection) -> Option<String> { + self.ghostty.extract_selection(selection) + } + + pub fn render(&self, frame: &mut Frame, area: Rect, show_cursor: bool) { + self.ghostty.render(frame, area, show_cursor); + } + + pub fn apply_host_terminal_theme(&self, theme: crate::terminal_theme::TerminalTheme) { + self.ghostty.apply_host_terminal_theme(theme); + } + + pub fn has_transient_default_color_override(&self) -> bool { + self.ghostty.has_transient_default_color_override() + } + + pub fn maybe_restore_host_terminal_theme(&self, pane_id: PaneId, shell_pid: u32) -> bool { + self.ghostty + .maybe_restore_host_terminal_theme(pane_id, shell_pid) + } + + pub fn keyboard_protocol( + &self, + fallback: crate::input::KeyboardProtocol, + ) -> crate::input::KeyboardProtocol { + self.ghostty.keyboard_protocol().unwrap_or(fallback) + } + + pub fn encode_terminal_key( + &self, + key: crate::input::TerminalKey, + protocol: crate::input::KeyboardProtocol, + ) -> Vec<u8> { + self.ghostty.encode_terminal_key(key, protocol) + } + + pub fn encode_mouse_button( + &self, + kind: crossterm::event::MouseEventKind, + column: u16, + row: u16, + modifiers: crossterm::event::KeyModifiers, + ) -> Option<Vec<u8>> { + self.ghostty + .encode_mouse_button(kind, column, row, modifiers) + } + + pub fn encode_mouse_wheel( + &self, + kind: crossterm::event::MouseEventKind, + column: u16, + row: u16, + modifiers: crossterm::event::KeyModifiers, + ) -> Option<Vec<u8>> { + self.ghostty + .encode_mouse_wheel(kind, column, row, modifiers) + } +} + +impl GhosttyPaneTerminal { + pub fn new( + mut terminal: crate::ghostty::Terminal, + response_writer: mpsc::Sender<Bytes>, + ) -> std::io::Result<Self> { + terminal + .set_write_pty_callback(move |bytes| { + let _ = response_writer.try_send(Bytes::copy_from_slice(bytes)); + }) + .map_err(|e| std::io::Error::other(e.to_string()))?; + + let render_state = + crate::ghostty::RenderState::new().map_err(|e| std::io::Error::other(e.to_string()))?; + let mut key_encoder = + crate::ghostty::KeyEncoder::new().map_err(|e| std::io::Error::other(e.to_string()))?; + key_encoder.set_from_terminal(&terminal); + Ok(Self { + core: Mutex::new(GhosttyPaneCore { + terminal, + render_state, + host_terminal_theme: crate::terminal_theme::TerminalTheme::default(), + transient_default_color_owner_pgid: None, + default_color_tracker: DefaultColorOscTracker::default(), + osc52_forwarder: Osc52Forwarder::default(), + }), + key_encoder: Mutex::new(key_encoder), + }) + } + + pub fn apply_host_terminal_theme(&self, theme: crate::terminal_theme::TerminalTheme) { + if let Ok(mut core) = self.core.lock() { + core.host_terminal_theme = theme; + core.transient_default_color_owner_pgid = None; + write_host_terminal_theme(&mut core.terminal, theme); + } + } + + pub fn has_transient_default_color_override(&self) -> bool { + self.core + .lock() + .map(|core| core.transient_default_color_owner_pgid.is_some()) + .unwrap_or(false) + } + + pub fn maybe_restore_host_terminal_theme(&self, pane_id: PaneId, shell_pid: u32) -> bool { + let foreground_job = crate::detect::foreground_job(shell_pid); + let Ok(mut core) = self.core.lock() else { + return false; + }; + + let alternate_screen = core + .terminal + .active_screen() + .map(|screen| screen == crate::ghostty::ActiveScreen::Alternate) + .unwrap_or(false); + restore_host_terminal_theme_if_needed( + &mut core, + pane_id, + shell_pid, + alternate_screen, + foreground_job.as_ref(), + ) + } + + pub fn process_pty_bytes( + &self, + pane_id: PaneId, + shell_pid: u32, + bytes: &[u8], + response_writer: &mpsc::Sender<Bytes>, + ) -> ProcessBytesResult { + let Ok(mut core) = self.core.lock() else { + error!(pane = pane_id.raw(), "ghostty core lock poisoned in reader"); + return ProcessBytesResult { + request_render: false, + clipboard_writes: Vec::new(), + }; + }; + + if shell_pid > 0 && core.default_color_tracker.observe(bytes) { + if let Some(owner_pgid) = current_transient_default_color_owner(shell_pid) { + core.transient_default_color_owner_pgid = Some(owner_pgid); + debug!( + pane = pane_id.raw(), + owner_pgid, "tracked transient default color override" + ); + } + } + + core.osc52_forwarder.observe(bytes); + let clipboard_writes = core.osc52_forwarder.drain_pending(); + + let alternate_screen = core + .terminal + .active_screen() + .map(|screen| screen == crate::ghostty::ActiveScreen::Alternate) + .unwrap_or(false); + let filtered_bytes = if shell_pid > 0 { + let foreground_job = (!alternate_screen && contains_scrollback_clear_sequence(bytes)) + .then(|| crate::detect::foreground_job(shell_pid)) + .flatten(); + maybe_filter_primary_screen_scrollback_clear( + bytes, + alternate_screen, + foreground_job.as_ref(), + ) + } else { + Cow::Borrowed(bytes) + }; + if filtered_bytes.len() != bytes.len() { + debug!( + pane = pane_id.raw(), + shell_pid, "ignored scrollback clear sequence for droid compatibility" + ); + } + + core.terminal.write(filtered_bytes.as_ref()); + if let Ok(mut key_encoder) = self.key_encoder.lock() { + key_encoder.set_from_terminal(&core.terminal); + } + let synchronized_output = core + .terminal + .mode_get(crate::ghostty::MODE_SYNCHRONIZED_OUTPUT) + .unwrap_or(false); + let _ = response_writer; + ProcessBytesResult { + request_render: !synchronized_output, + clipboard_writes, + } + } + + pub fn resize(&self, rows: u16, cols: u16) { + if let Ok(mut core) = self.core.lock() { + let _ = core.terminal.resize(cols, rows); + } + } + + pub fn scroll_up(&self, lines: usize) { + if let Ok(mut core) = self.core.lock() { + core.terminal.scroll_viewport_delta(-(lines as isize)); + } + } + + pub fn scroll_down(&self, lines: usize) { + if let Ok(mut core) = self.core.lock() { + core.terminal.scroll_viewport_delta(lines as isize); + } + } + + pub fn scroll_reset(&self) { + if let Ok(mut core) = self.core.lock() { + core.terminal.scroll_viewport_bottom(); + } + } + + pub fn set_scroll_offset_from_bottom(&self, lines: usize) { + if let Ok(mut core) = self.core.lock() { + core.terminal.scroll_viewport_bottom(); + if lines > 0 { + core.terminal.scroll_viewport_delta(-(lines as isize)); + } + } + } + + pub fn scroll_metrics(&self) -> Option<ScrollMetrics> { + let Ok(core) = self.core.lock() else { + return None; + }; + let scrollbar = core.terminal.scrollbar().ok()?; + Some(ScrollMetrics { + offset_from_bottom: scrollbar + .total + .saturating_sub(scrollbar.offset + scrollbar.len), + max_offset_from_bottom: scrollbar.total.saturating_sub(scrollbar.len), + viewport_rows: scrollbar.len, + }) + } + + pub fn keyboard_protocol(&self) -> Option<crate::input::KeyboardProtocol> { + let Ok(core) = self.core.lock() else { + return None; + }; + Some(crate::input::KeyboardProtocol::from_kitty_flags( + core.terminal.kitty_keyboard_flags().ok()? as u16, + )) + } + + pub fn input_state(&self) -> Option<InputState> { + let Ok(core) = self.core.lock() else { + return None; + }; + let alternate_screen = + core.terminal.active_screen().ok()? == crate::ghostty::ActiveScreen::Alternate; + let application_cursor = core + .terminal + .mode_get(crate::ghostty::MODE_APPLICATION_CURSOR_KEYS) + .ok()?; + let bracketed_paste = core + .terminal + .mode_get(crate::ghostty::MODE_BRACKETED_PASTE) + .ok()?; + let focus_reporting = core + .terminal + .mode_get(crate::ghostty::MODE_FOCUS_EVENT) + .ok()?; + let mouse_sgr = core + .terminal + .mode_get(crate::ghostty::MODE_MOUSE_SGR) + .ok()?; + let mouse_utf8 = core + .terminal + .mode_get(crate::ghostty::MODE_MOUSE_UTF8) + .ok()?; + let mouse_alternate_scroll = core + .terminal + .mode_get(crate::ghostty::MODE_MOUSE_ALTERNATE_SCROLL) + .ok()?; + let mouse_protocol_mode = if core.terminal.mode_get(1003).ok()? { + crate::input::MouseProtocolMode::AnyMotion + } else if core.terminal.mode_get(1002).ok()? { + crate::input::MouseProtocolMode::ButtonMotion + } else if core.terminal.mode_get(1000).ok()? { + crate::input::MouseProtocolMode::PressRelease + } else if core.terminal.mode_get(9).ok()? { + crate::input::MouseProtocolMode::Press + } else { + crate::input::MouseProtocolMode::None + }; + let mouse_protocol_encoding = if mouse_sgr { + crate::input::MouseProtocolEncoding::Sgr + } else if mouse_utf8 { + crate::input::MouseProtocolEncoding::Utf8 + } else { + crate::input::MouseProtocolEncoding::Default + }; + Some(InputState { + alternate_screen, + application_cursor, + bracketed_paste, + focus_reporting, + mouse_protocol_mode, + mouse_protocol_encoding, + mouse_alternate_scroll, + }) + } + + pub fn encode_terminal_key( + &self, + key: crate::input::TerminalKey, + protocol: crate::input::KeyboardProtocol, + ) -> Vec<u8> { + if ghostty_prefers_herdr_text_encoding(key) { + return crate::input::encode_terminal_key(key, protocol); + } + + let Some(event) = ghostty_key_event_from_terminal_key(key) else { + return crate::input::encode_terminal_key(key, protocol); + }; + + let Ok(mut encoder) = self.key_encoder.lock() else { + return crate::input::encode_terminal_key(key, protocol); + }; + match encoder.encode(&event) { + Ok(bytes) if !bytes.is_empty() => bytes, + Ok(_) | Err(_) => crate::input::encode_terminal_key(key, protocol), + } + } + + pub fn encode_mouse_button( + &self, + kind: crossterm::event::MouseEventKind, + column: u16, + row: u16, + modifiers: crossterm::event::KeyModifiers, + ) -> Option<Vec<u8>> { + let Ok(core) = self.core.lock() else { + return None; + }; + let mut encoder = ghostty_mouse_encoder_for_terminal(&core.terminal)?; + let event = ghostty_mouse_event_from_button_kind(kind, column, row, modifiers)?; + encoder.encode(&event).ok() + } + + pub fn encode_mouse_wheel( + &self, + kind: crossterm::event::MouseEventKind, + column: u16, + row: u16, + modifiers: crossterm::event::KeyModifiers, + ) -> Option<Vec<u8>> { + let Ok(core) = self.core.lock() else { + return None; + }; + let mut encoder = ghostty_mouse_encoder_for_terminal(&core.terminal)?; + let event = ghostty_mouse_event_from_wheel_kind(kind, column, row, modifiers)?; + encoder.encode(&event).ok() + } + + pub fn visible_text(&self) -> String { + self.core + .lock() + .ok() + .and_then(|mut core| ghostty_visible_text(&mut core).ok()) + .unwrap_or_default() + } + + pub fn detection_text(&self) -> String { + self.core + .lock() + .ok() + .and_then(|core| ghostty_detection_text(&core).ok()) + .unwrap_or_default() + } + + pub fn recent_text(&self, lines: usize) -> String { + self.core + .lock() + .ok() + .and_then(|core| ghostty_recent_text(&core, lines).ok()) + .unwrap_or_default() + } + + pub fn recent_unwrapped_text(&self, lines: usize) -> String { + self.core + .lock() + .ok() + .and_then(|core| ghostty_recent_text_unwrapped(&core, lines).ok()) + .unwrap_or_default() + } + + pub fn extract_selection(&self, selection: &crate::selection::Selection) -> Option<String> { + self.core + .lock() + .ok() + .and_then(|mut core| ghostty_extract_selection(&mut core, selection).ok()) + } + + pub fn render(&self, frame: &mut Frame, area: Rect, show_cursor: bool) { + let Ok(mut core) = self.core.lock() else { + return; + }; + let host_theme = core.host_terminal_theme; + let GhosttyPaneCore { + terminal, + render_state, + .. + } = &mut *core; + if render_state.update(terminal).is_err() { + return; + } + let colors = render_state.colors().ok(); + let default_bg = colors.and_then(|c| ghostty_default_bg(c.background, host_theme)); + let default_fg = colors.map(|c| ghostty_color(c.foreground)); + + let mut row_iterator = match crate::ghostty::RowIterator::new() { + Ok(iterator) => iterator, + Err(_) => return, + }; + let mut row_cells = match crate::ghostty::RowCells::new() { + Ok(cells) => cells, + Err(_) => return, + }; + { + let buf = frame.buffer_mut(); + let mut rows = match render_state.populate_row_iterator(&mut row_iterator) { + Ok(rows) => rows, + Err(_) => return, + }; + let mut y = 0u16; + while y < area.height && rows.next() { + let mut cells = match rows.populate_cells(&mut row_cells) { + Ok(cells) => cells, + Err(_) => break, + }; + let mut x = 0u16; + while x < area.width && cells.next() { + let wide = cells.wide().unwrap_or(crate::ghostty::CellWide::Narrow); + let style = ghostty_cell_style(&cells, default_fg, default_bg); + let symbol = ghostty_buffer_symbol(&cells, wide) + .unwrap_or_else(|_| ghostty_blank_symbol_for_width(wide).to_string()); + let cell = &mut buf[(area.x + x, area.y + y)]; + cell.reset(); + cell.set_symbol(&symbol); + cell.set_style(style); + x += 1; + } + while x < area.width { + let cell = &mut buf[(area.x + x, area.y + y)]; + ghostty_reset_cell(cell, default_fg, default_bg); + x += 1; + } + y += 1; + } + while y < area.height { + for x in 0..area.width { + let cell = &mut buf[(area.x + x, area.y + y)]; + ghostty_reset_cell(cell, default_fg, default_bg); + } + y += 1; + } + } + + if show_cursor && render_state.cursor_visible().ok() == Some(true) { + if let Ok(Some(cursor)) = render_state.cursor_viewport() { + if cursor.x < area.width && cursor.y < area.height { + frame.set_cursor_position((area.x + cursor.x, area.y + cursor.y)); + } + } + } + } +} + +fn ghostty_visible_text(core: &mut GhosttyPaneCore) -> Result<String, crate::ghostty::Error> { + let GhosttyPaneCore { + terminal, + render_state, + .. + } = core; + render_state.update(terminal)?; + let mut row_iterator = crate::ghostty::RowIterator::new()?; + let mut row_cells = crate::ghostty::RowCells::new()?; + let mut rows = render_state.populate_row_iterator(&mut row_iterator)?; + let mut lines = Vec::new(); + while rows.next() { + let mut cells = rows.populate_cells(&mut row_cells)?; + lines.push(ghostty_line_from_cells(&mut cells)?); + } + trim_trailing_blank_rows(&mut lines); + Ok(lines_to_text(lines)) +} + +fn ghostty_detection_text(core: &GhosttyPaneCore) -> Result<String, crate::ghostty::Error> { + let lines = core + .terminal + .rows() + .ok() + .map(|rows| usize::from(rows).max(1)) + .unwrap_or(DEFAULT_DETECTION_ROWS); + ghostty_recent_text(core, lines) +} + +fn ghostty_recent_text( + core: &GhosttyPaneCore, + lines: usize, +) -> Result<String, crate::ghostty::Error> { + let total_rows = core.terminal.total_rows()?; + let cols = core.terminal.cols()?; + let start = total_rows.saturating_sub(lines); + let mut rows = Vec::with_capacity(total_rows.saturating_sub(start)); + for y in start..total_rows { + rows.push(ghostty_screen_row(core, cols, y as u32)?); + } + trim_trailing_blank_rows(&mut rows); + Ok(recent_text_from_rows(&rows, lines)) +} + +fn ghostty_recent_text_unwrapped( + core: &GhosttyPaneCore, + lines: usize, +) -> Result<String, crate::ghostty::Error> { + let total_rows = core.terminal.total_rows()?; + let cols = core.terminal.cols()?; + if total_rows == 0 || cols == 0 { + return Ok(String::new()); + } + let start = total_rows.saturating_sub(lines) as u32; + let end = (total_rows.saturating_sub(1)) as u32; + core.terminal + .read_text_screen((0, start), (cols.saturating_sub(1), end), false) +} + +fn ghostty_extract_selection( + core: &mut GhosttyPaneCore, + selection: &crate::selection::Selection, +) -> Result<String, crate::ghostty::Error> { + let ((start_row, start_col), (end_row, end_col)) = selection.ordered_cells(); + core.terminal + .read_text_screen((start_col, start_row), (end_col, end_row), false) +} + +fn ghostty_screen_row( + core: &GhosttyPaneCore, + cols: u16, + y: u32, +) -> Result<String, crate::ghostty::Error> { + let mut line = String::new(); + for x in 0..cols { + let graphemes = core.terminal.screen_graphemes(x, y)?; + if graphemes.is_empty() { + line.push(' '); + } else { + for codepoint in graphemes { + if let Some(ch) = char::from_u32(codepoint) { + line.push(ch); + } + } + } + } + Ok(line.trim_end().to_string()) +} + +fn ghostty_line_from_cells( + cells: &mut crate::ghostty::RowCellIter<'_>, +) -> Result<String, crate::ghostty::Error> { + let mut line = String::new(); + while cells.next() { + line.push_str(&ghostty_cell_symbol(cells)?); + } + Ok(line.trim_end().to_string()) +} + +fn ghostty_cell_symbol( + cells: &crate::ghostty::RowCellIter<'_>, +) -> Result<String, crate::ghostty::Error> { + let graphemes = cells.graphemes()?; + if graphemes.is_empty() { + return Ok(" ".to_string()); + } + let mut text = String::new(); + for codepoint in graphemes { + if let Some(ch) = char::from_u32(codepoint) { + text.push(ch); + } + } + if text.is_empty() { + text.push(' '); + } + Ok(text) +} + +pub(super) fn ghostty_blank_symbol_for_width(wide: crate::ghostty::CellWide) -> &'static str { + match wide { + crate::ghostty::CellWide::Wide => " ", + crate::ghostty::CellWide::SpacerTail => "", + crate::ghostty::CellWide::Narrow | crate::ghostty::CellWide::SpacerHead => " ", + } +} + +pub(super) fn ghostty_normalize_buffer_symbol( + symbol: &str, + wide: crate::ghostty::CellWide, +) -> String { + let expected_width = match wide { + crate::ghostty::CellWide::Wide => 2, + crate::ghostty::CellWide::Narrow | crate::ghostty::CellWide::SpacerHead => 1, + crate::ghostty::CellWide::SpacerTail => 0, + }; + let actual_width = symbol.width(); + if actual_width == expected_width { + return symbol.to_string(); + } + + if wide == crate::ghostty::CellWide::Narrow && actual_width == 2 { + return symbol.to_string(); + } + + ghostty_blank_symbol_for_width(wide).to_string() +} + +fn ghostty_buffer_symbol( + cells: &crate::ghostty::RowCellIter<'_>, + wide: crate::ghostty::CellWide, +) -> Result<String, crate::ghostty::Error> { + let symbol = match wide { + crate::ghostty::CellWide::SpacerTail => String::new(), + crate::ghostty::CellWide::SpacerHead => " ".to_string(), + crate::ghostty::CellWide::Narrow | crate::ghostty::CellWide::Wide => { + ghostty_cell_symbol(cells)? + } + }; + Ok(ghostty_normalize_buffer_symbol(&symbol, wide)) +} + +fn ghostty_reset_cell( + cell: &mut ratatui::buffer::Cell, + default_fg: Option<Color>, + default_bg: Option<Color>, +) { + cell.reset(); + cell.set_symbol(" "); + if let Some(bg) = default_bg { + cell.set_bg(bg); + } + if let Some(fg) = default_fg { + cell.set_fg(fg); + } +} + +fn ghostty_cell_style( + cells: &crate::ghostty::RowCellIter<'_>, + default_fg: Option<Color>, + default_bg: Option<Color>, +) -> Style { + let style_data = cells.style().unwrap_or_default(); + let mut fg = cells + .fg_color() + .ok() + .flatten() + .map(ghostty_color) + .or(default_fg); + let mut bg = cells + .bg_color() + .ok() + .flatten() + .map(ghostty_color) + .or(default_bg); + if style_data.invisible { + fg = bg.or(default_bg); + } + if style_data.inverse { + std::mem::swap(&mut fg, &mut bg); + } + + let mut style = Style::default(); + if let Some(fg) = fg { + style = style.fg(fg); + } + if let Some(bg) = bg { + style = style.bg(bg); + } + + let mut modifiers = Modifier::empty(); + if style_data.bold { + modifiers |= Modifier::BOLD; + } + if style_data.italic { + modifiers |= Modifier::ITALIC; + } + if style_data.faint { + modifiers |= Modifier::DIM; + } + if style_data.blink { + modifiers |= Modifier::SLOW_BLINK; + } + if style_data.underlined { + modifiers |= Modifier::UNDERLINED; + } + if style_data.strikethrough { + modifiers |= Modifier::CROSSED_OUT; + } + style.add_modifier(modifiers) +} + +fn ghostty_default_bg( + color: crate::ghostty::RgbColor, + host_theme: crate::terminal_theme::TerminalTheme, +) -> Option<Color> { + if host_theme.background == Some(terminal_theme_color(color)) { + None + } else { + Some(ghostty_color(color)) + } +} + +fn terminal_theme_color(color: crate::ghostty::RgbColor) -> crate::terminal_theme::RgbColor { + crate::terminal_theme::RgbColor { + r: color.r, + g: color.g, + b: color.b, + } +} + +fn ghostty_color(color: crate::ghostty::RgbColor) -> Color { + Color::Rgb(color.r, color.g, color.b) +} + +fn lines_to_text(lines: Vec<String>) -> String { + let text = lines.join("\n"); + if text.is_empty() { + text + } else { + format!("{text}\n") + } +} + +pub(super) fn trim_trailing_blank_rows(rows: &mut Vec<String>) { + while rows.last().is_some_and(|row| row.trim().is_empty()) { + rows.pop(); + } +} + +fn recent_text_from_rows(rows: &[String], lines: usize) -> String { + let start = rows.len().saturating_sub(lines); + let text = rows[start..].join("\n"); + if text.is_empty() { + text + } else { + format!("{text}\n") + } +} + +#[cfg(test)] +mod tests { + use super::*; + use ratatui::{layout::Rect, style::Color}; + use tokio::sync::mpsc; + + fn write_numbered_lines(terminal: &mut crate::ghostty::Terminal, count: usize) { + for i in 0..count { + terminal.write(format!("{i:06}\r\n").as_bytes()); + } + } + + #[test] + fn ghostty_render_can_suppress_cursor_position() { + let (tx, _rx) = mpsc::channel(4); + let mut first_terminal = crate::ghostty::Terminal::new(20, 5, 0).unwrap(); + first_terminal.write(b"left"); + let first = GhosttyPaneTerminal::new(first_terminal, tx.clone()).unwrap(); + + let mut second_terminal = crate::ghostty::Terminal::new(20, 5, 0).unwrap(); + second_terminal.write(b"r\r\nb"); + let second = GhosttyPaneTerminal::new(second_terminal, tx).unwrap(); + + let backend = ratatui::backend::TestBackend::new(40, 5); + let mut terminal = ratatui::Terminal::new(backend).unwrap(); + terminal + .draw(|frame| { + first.render(frame, Rect::new(0, 0, 20, 5), true); + second.render(frame, Rect::new(20, 0, 20, 5), false); + }) + .unwrap(); + + terminal.backend_mut().assert_cursor_position((4, 0)); + } + + #[test] + fn ghostty_keyboard_protocol_tracks_live_terminal_flags() { + let (tx, _rx) = mpsc::channel(4); + let mut terminal = crate::ghostty::Terminal::new(80, 24, 0).unwrap(); + terminal.write(b"\x1b[>3u"); + let pane = GhosttyPaneTerminal::new(terminal, tx).unwrap(); + + assert_eq!( + pane.keyboard_protocol(), + Some(crate::input::KeyboardProtocol::Kitty { flags: 3 }) + ); + } + + #[test] + fn ghostty_plain_text_chars_still_encode_as_text() { + let (tx, _rx) = mpsc::channel(4); + let terminal = crate::ghostty::Terminal::new(80, 24, 0).unwrap(); + let pane = GhosttyPaneTerminal::new(terminal, tx).unwrap(); + + let encoded = pane.encode_terminal_key( + crate::input::TerminalKey::new( + crossterm::event::KeyCode::Char('a'), + crossterm::event::KeyModifiers::empty(), + ), + crate::input::KeyboardProtocol::Legacy, + ); + + assert_eq!(encoded, b"a"); + } + + #[test] + fn ghostty_char_keys_still_use_herdr_encoding() { + let (tx, _rx) = mpsc::channel(4); + let mut terminal = crate::ghostty::Terminal::new(80, 24, 0).unwrap(); + terminal.write(b"\x1b[>1u"); + let pane = GhosttyPaneTerminal::new(terminal, tx).unwrap(); + + let encoded = pane.encode_terminal_key( + crate::input::TerminalKey::new( + crossterm::event::KeyCode::Char('a'), + crossterm::event::KeyModifiers::CONTROL | crossterm::event::KeyModifiers::SHIFT, + ), + crate::input::KeyboardProtocol::Legacy, + ); + + assert_eq!(encoded, vec![1]); + } + + #[test] + fn ghostty_key_encoding_honors_application_cursor_mode() { + let (tx, _rx) = mpsc::channel(4); + let mut terminal = crate::ghostty::Terminal::new(80, 24, 0).unwrap(); + terminal + .mode_set(crate::ghostty::MODE_APPLICATION_CURSOR_KEYS, true) + .unwrap(); + let pane = GhosttyPaneTerminal::new(terminal, tx).unwrap(); + + let encoded = pane.encode_terminal_key( + crate::input::TerminalKey::new( + crossterm::event::KeyCode::Up, + crossterm::event::KeyModifiers::empty(), + ), + crate::input::KeyboardProtocol::Legacy, + ); + + assert_eq!(encoded, b"\x1bOA"); + } + + #[test] + fn ghostty_key_encoder_updates_after_terminal_mode_changes() { + let (tx, _rx) = mpsc::channel(4); + let terminal = crate::ghostty::Terminal::new(80, 24, 0).unwrap(); + let pane = GhosttyPaneTerminal::new(terminal, tx.clone()).unwrap(); + let pane_id = PaneId::from_raw(1); + + let before = pane.encode_terminal_key( + crate::input::TerminalKey::new( + crossterm::event::KeyCode::Up, + crossterm::event::KeyModifiers::empty(), + ), + crate::input::KeyboardProtocol::Legacy, + ); + assert_eq!(before, b"\x1b[A"); + + pane.process_pty_bytes(pane_id, 0, b"\x1b[?1h", &tx); + + let after = pane.encode_terminal_key( + crate::input::TerminalKey::new( + crossterm::event::KeyCode::Up, + crossterm::event::KeyModifiers::empty(), + ), + crate::input::KeyboardProtocol::Legacy, + ); + assert_eq!(after, b"\x1bOA"); + } + + #[test] + fn ghostty_key_encoder_updates_after_kitty_flag_changes() { + let (tx, _rx) = mpsc::channel(4); + let terminal = crate::ghostty::Terminal::new(80, 24, 0).unwrap(); + let pane = GhosttyPaneTerminal::new(terminal, tx.clone()).unwrap(); + let pane_id = PaneId::from_raw(1); + let key = crate::input::TerminalKey::new( + crossterm::event::KeyCode::Enter, + crossterm::event::KeyModifiers::CONTROL | crossterm::event::KeyModifiers::SHIFT, + ); + + let before = pane.encode_terminal_key(key, crate::input::KeyboardProtocol::Legacy); + pane.process_pty_bytes(pane_id, 0, b"\x1b[>1u", &tx); + let after = pane.encode_terminal_key(key, crate::input::KeyboardProtocol::Legacy); + + assert_ne!(before, after); + assert_eq!(after, b"\x1b[13;6u"); + } + + #[test] + fn ghostty_key_encoders_are_isolated_per_pane() { + let (tx, _rx) = mpsc::channel(4); + let first = GhosttyPaneTerminal::new( + crate::ghostty::Terminal::new(80, 24, 0).unwrap(), + tx.clone(), + ) + .unwrap(); + let second = GhosttyPaneTerminal::new( + crate::ghostty::Terminal::new(80, 24, 0).unwrap(), + tx.clone(), + ) + .unwrap(); + + first.process_pty_bytes(PaneId::from_raw(1), 0, b"\x1b[?1h", &tx); + + let first_encoded = first.encode_terminal_key( + crate::input::TerminalKey::new( + crossterm::event::KeyCode::Up, + crossterm::event::KeyModifiers::empty(), + ), + crate::input::KeyboardProtocol::Legacy, + ); + let second_encoded = second.encode_terminal_key( + crate::input::TerminalKey::new( + crossterm::event::KeyCode::Up, + crossterm::event::KeyModifiers::empty(), + ), + crate::input::KeyboardProtocol::Legacy, + ); + + assert_eq!(first_encoded, b"\x1bOA"); + assert_eq!(second_encoded, b"\x1b[A"); + } + + #[test] + fn ghostty_mouse_button_encoding_uses_live_terminal_state() { + let (tx, _rx) = mpsc::channel(4); + let mut terminal = crate::ghostty::Terminal::new(80, 24, 0).unwrap(); + terminal.write(b"\x1b[?1000h\x1b[?1006h"); + let pane = GhosttyPaneTerminal::new(terminal, tx).unwrap(); + + let encoded = pane.encode_mouse_button( + crossterm::event::MouseEventKind::Up(crossterm::event::MouseButton::Left), + 11, + 9, + crossterm::event::KeyModifiers::empty(), + ); + + assert_eq!(encoded.as_deref(), Some(&b"\x1b[<0;12;10m"[..])); + } + + #[test] + fn ghostty_mouse_drag_encoding_uses_motion_reporting_state() { + let (tx, _rx) = mpsc::channel(4); + let mut terminal = crate::ghostty::Terminal::new(80, 24, 0).unwrap(); + terminal.write(b"\x1b[?1002h\x1b[?1006h"); + let pane = GhosttyPaneTerminal::new(terminal, tx).unwrap(); + + let encoded = pane.encode_mouse_button( + crossterm::event::MouseEventKind::Drag(crossterm::event::MouseButton::Left), + 4, + 6, + crossterm::event::KeyModifiers::SHIFT, + ); + + assert_eq!(encoded.as_deref(), Some(&b"\x1b[<36;5;7M"[..])); + } + + #[test] + fn ghostty_normalize_buffer_symbol_prefers_grapheme_width_when_metadata_disagrees() { + const WIDE_GRAPHEME: &str = "🙂"; + const VS16_GRAPHEME: &str = "⚠️"; + const EMOJI_GRAPHEME: &str = "💳"; + + assert_eq!( + ghostty_normalize_buffer_symbol(WIDE_GRAPHEME, crate::ghostty::CellWide::Wide), + WIDE_GRAPHEME + ); + assert_eq!( + ghostty_normalize_buffer_symbol("a", crate::ghostty::CellWide::Wide), + " " + ); + assert_eq!( + ghostty_normalize_buffer_symbol("⌨️", crate::ghostty::CellWide::Narrow), + "⌨️" + ); + assert_eq!( + ghostty_normalize_buffer_symbol(VS16_GRAPHEME, crate::ghostty::CellWide::Narrow), + VS16_GRAPHEME + ); + assert_eq!( + ghostty_normalize_buffer_symbol(EMOJI_GRAPHEME, crate::ghostty::CellWide::Narrow), + EMOJI_GRAPHEME + ); + assert_eq!( + ghostty_normalize_buffer_symbol(" ", crate::ghostty::CellWide::SpacerTail), + "" + ); + assert_eq!( + ghostty_normalize_buffer_symbol("xx", crate::ghostty::CellWide::SpacerHead), + " " + ); + } + + #[test] + fn pane_scrollback_controls_reach_top_without_ui_interference() { + let (tx, _rx) = mpsc::channel(4); + let mut terminal = crate::ghostty::Terminal::new(80, 3, 100).unwrap(); + write_numbered_lines(&mut terminal, 1000); + let pane = GhosttyPaneTerminal::new(terminal, tx).unwrap(); + + let before = pane.scroll_metrics().expect("scroll metrics before scroll"); + assert!(before.max_offset_from_bottom > 0); + assert_eq!(before.offset_from_bottom, 0); + + pane.set_scroll_offset_from_bottom(before.max_offset_from_bottom); + + let after = pane.scroll_metrics().expect("scroll metrics after scroll"); + assert_eq!(after.offset_from_bottom, after.max_offset_from_bottom); + assert!(pane.visible_text().contains("000000")); + } + + #[test] + fn detection_text_stays_at_bottom_when_viewport_is_scrolled() { + let (tx, _rx) = mpsc::channel(4); + let mut terminal = crate::ghostty::Terminal::new(80, 3, 100).unwrap(); + write_numbered_lines(&mut terminal, 10); + let pane = GhosttyPaneTerminal::new(terminal, tx).unwrap(); + + let bottom_snapshot = pane.detection_text(); + assert_eq!(bottom_snapshot, pane.recent_text(3)); + assert!(bottom_snapshot.contains("000009")); + + let before = pane.scroll_metrics().expect("scroll metrics before scroll"); + pane.set_scroll_offset_from_bottom(before.max_offset_from_bottom); + + assert!(pane.visible_text().contains("000000")); + assert_eq!(pane.detection_text(), bottom_snapshot); + } + + #[test] + fn extract_selection_reads_screen_rows_not_current_viewport() { + let (tx, _rx) = mpsc::channel(4); + let mut terminal = crate::ghostty::Terminal::new(8, 3, 1024).unwrap(); + write_numbered_lines(&mut terminal, 8); + let pane = GhosttyPaneTerminal::new(terminal, tx).unwrap(); + + pane.set_scroll_offset_from_bottom(3); + let metrics = pane + .scroll_metrics() + .expect("scroll metrics after initial scroll"); + let mut selection = + crate::selection::Selection::anchor(PaneId::from_raw(1), 0, 0, Some(metrics)); + selection.drag(5, 2, Rect::new(0, 0, 8, 3), Some(metrics)); + + pane.scroll_reset(); + + let text = pane + .extract_selection(&selection) + .expect("selection should extract text"); + assert_eq!(text, "000003\n000004\n000005"); + } + + #[test] + fn recent_unwrapped_text_ignores_soft_wraps() { + let (tx, _rx) = mpsc::channel(4); + let mut terminal = crate::ghostty::Terminal::new(5, 3, 100).unwrap(); + terminal.write(b"ABCDEFGHIJ"); + let pane = GhosttyPaneTerminal::new(terminal, tx).unwrap(); + + assert_eq!(pane.recent_text(3), "ABCDE\nFGHIJ\n"); + assert_eq!(pane.recent_unwrapped_text(3), "ABCDEFGHIJ"); + } + + #[test] + fn synchronized_output_suppresses_intermediate_render_requests_until_batch_ends() { + let (tx, _rx) = mpsc::channel(4); + let terminal = crate::ghostty::Terminal::new(80, 24, 0).unwrap(); + let pane_terminal = GhosttyPaneTerminal::new(terminal, tx.clone()).unwrap(); + let pane_id = PaneId::from_raw(1); + + let begin = pane_terminal.process_pty_bytes(pane_id, 0, b"\x1b[?2026h", &tx); + assert!(!begin.request_render); + + let body = pane_terminal.process_pty_bytes(pane_id, 0, b"hello", &tx); + assert!(!body.request_render); + + let end = pane_terminal.process_pty_bytes(pane_id, 0, b"\x1b[?2026l", &tx); + assert!(end.request_render); + } + + #[test] + fn render_leaves_host_default_background_transparent() { + let (tx, _rx) = mpsc::channel(4); + let terminal = crate::ghostty::Terminal::new(20, 5, 0).unwrap(); + let pane = GhosttyPaneTerminal::new(terminal, tx).unwrap(); + let host_theme = crate::terminal_theme::TerminalTheme { + foreground: Some(crate::terminal_theme::RgbColor { + r: 0xaa, + g: 0xbb, + b: 0xcc, + }), + background: Some(crate::terminal_theme::RgbColor { + r: 0x11, + g: 0x22, + b: 0x33, + }), + }; + pane.apply_host_terminal_theme(host_theme); + { + let mut core = pane.core.lock().unwrap(); + core.terminal.write(b"hi"); + } + + let backend = ratatui::backend::TestBackend::new(20, 5); + let mut terminal = ratatui::Terminal::new(backend).unwrap(); + terminal + .draw(|frame| pane.render(frame, Rect::new(0, 0, 20, 5), false)) + .unwrap(); + + let buffer = terminal.backend().buffer(); + assert_eq!(buffer[(0, 0)].symbol(), "h"); + assert_eq!(buffer[(0, 0)].style().bg, Some(Color::Reset)); + assert_eq!(buffer[(2, 0)].symbol(), " "); + assert_eq!(buffer[(2, 0)].style().bg, Some(Color::Reset)); + } + + #[test] + fn render_keeps_explicit_default_background_when_it_differs_from_host() { + let (tx, _rx) = mpsc::channel(4); + let terminal = crate::ghostty::Terminal::new(20, 5, 0).unwrap(); + let pane = GhosttyPaneTerminal::new(terminal, tx).unwrap(); + let host_theme = crate::terminal_theme::TerminalTheme { + foreground: Some(crate::terminal_theme::RgbColor { + r: 0xaa, + g: 0xbb, + b: 0xcc, + }), + background: Some(crate::terminal_theme::RgbColor { + r: 0x11, + g: 0x22, + b: 0x33, + }), + }; + pane.apply_host_terminal_theme(host_theme); + { + let mut core = pane.core.lock().unwrap(); + core.terminal.write(b"\x1b]11;rgb:44/55/66\x1b\\hi"); + } + + let backend = ratatui::backend::TestBackend::new(20, 5); + let mut terminal = ratatui::Terminal::new(backend).unwrap(); + terminal + .draw(|frame| pane.render(frame, Rect::new(0, 0, 20, 5), false)) + .unwrap(); + + let buffer = terminal.backend().buffer(); + let expected_bg = Some(Color::Rgb(0x44, 0x55, 0x66)); + assert_eq!(buffer[(0, 0)].symbol(), "h"); + assert_eq!(buffer[(0, 0)].style().bg, expected_bg); + assert_eq!(buffer[(2, 0)].symbol(), " "); + assert_eq!(buffer[(2, 0)].style().bg, expected_bg); + } + + #[test] + fn trim_trailing_blank_rows_drops_empty_viewport_tail() { + let mut rows = vec!["hello".to_string(), "".to_string(), " ".to_string()]; + trim_trailing_blank_rows(&mut rows); + assert_eq!(rows, vec!["hello".to_string()]); + } +} diff --git a/src/persist.rs b/src/persist.rs index 6704dd17..1753d679 100644 --- a/src/persist.rs +++ b/src/persist.rs @@ -2,1054 +2,12 @@ //! //! Stored at `~/.config/herdr/session.json`. -use std::collections::HashMap; -use std::path::PathBuf; -use std::sync::atomic::AtomicBool; -use std::sync::Arc; - -use ratatui::layout::Direction; -use serde::{Deserialize, Serialize}; -use tracing::{error, info, warn}; - -use tokio::sync::{mpsc, Notify}; - -use crate::events::AppEvent; -use crate::layout::{Node, PaneId, TileLayout}; -use crate::pane::{PaneRuntime, PaneState}; -use crate::workspace::Workspace; - -/// Current snapshot format version. -const SNAPSHOT_VERSION: u32 = 3; - -/// Serializable snapshot of the entire herdr session. -#[derive(Serialize, Deserialize)] -pub struct SessionSnapshot { - /// Format version — used to detect incompatible changes. - #[serde(default)] - pub version: u32, - pub workspaces: Vec<WorkspaceSnapshot>, - pub active: Option<usize>, - pub selected: usize, - #[serde(default)] - pub agent_panel_scope: crate::app::state::AgentPanelScope, - #[serde(default)] - pub sidebar_width: Option<u16>, - #[serde(default)] - pub sidebar_section_split: Option<f32>, -} - -#[derive(Serialize, Deserialize)] -pub struct WorkspaceSnapshot { - #[serde(default)] - pub id: Option<String>, - #[serde(default)] - pub custom_name: Option<String>, - pub identity_cwd: PathBuf, - pub tabs: Vec<TabSnapshot>, - #[serde(default)] - pub active_tab: usize, -} - -#[derive(Deserialize)] -struct LegacyWorkspaceSnapshot { - #[serde(default)] - custom_name: Option<String>, - layout: LayoutSnapshot, - panes: HashMap<u32, PaneSnapshot>, - zoomed: bool, - #[serde(default)] - focused: Option<u32>, - #[serde(default)] - root_pane: Option<u32>, -} - -#[derive(Serialize, Deserialize)] -pub struct TabSnapshot { - #[serde(default)] - pub custom_name: Option<String>, - pub layout: LayoutSnapshot, - pub panes: HashMap<u32, PaneSnapshot>, - pub zoomed: bool, - #[serde(default)] - pub focused: Option<u32>, - #[serde(default)] - pub root_pane: Option<u32>, -} - -#[derive(Serialize, Deserialize)] -pub struct PaneSnapshot { - pub cwd: PathBuf, -} - -/// Serializable BSP tree. -#[derive(Serialize, Deserialize)] -pub enum LayoutSnapshot { - Pane(u32), - Split { - direction: DirectionSnapshot, - ratio: f32, - first: Box<LayoutSnapshot>, - second: Box<LayoutSnapshot>, - }, -} - -#[derive(Serialize, Deserialize)] -pub enum DirectionSnapshot { - Horizontal, - Vertical, -} - -impl From<LegacyWorkspaceSnapshot> for WorkspaceSnapshot { - fn from(snap: LegacyWorkspaceSnapshot) -> Self { - let identity_cwd = legacy_identity_cwd(&snap); - let tab = TabSnapshot { - custom_name: None, - layout: snap.layout, - panes: snap.panes, - zoomed: snap.zoomed, - focused: snap.focused, - root_pane: snap.root_pane, - }; - - Self { - id: None, - custom_name: snap.custom_name, - identity_cwd, - tabs: vec![tab], - active_tab: 0, - } - } -} - -#[derive(Deserialize)] -struct RawSessionSnapshot { - #[serde(default)] - version: u32, - #[serde(default)] - workspaces: Vec<serde_json::Value>, - #[serde(default)] - active: Option<usize>, - #[serde(default)] - selected: usize, - #[serde(default)] - agent_panel_scope: crate::app::state::AgentPanelScope, - #[serde(default)] - sidebar_width: Option<u16>, - #[serde(default)] - sidebar_section_split: Option<f32>, -} - -fn migrate_snapshot(raw: RawSessionSnapshot) -> Result<SessionSnapshot, String> { - Ok(SessionSnapshot { - version: raw.version, - workspaces: raw - .workspaces - .into_iter() - .map(migrate_workspace) - .collect::<Result<Vec<_>, _>>()?, - active: raw.active, - selected: raw.selected, - agent_panel_scope: raw.agent_panel_scope, - sidebar_width: raw.sidebar_width, - sidebar_section_split: raw.sidebar_section_split, - }) -} - -fn migrate_workspace(raw: serde_json::Value) -> Result<WorkspaceSnapshot, String> { - if raw.get("identity_cwd").is_some() { - return serde_json::from_value(raw).map_err(|e| e.to_string()); - } - - if raw.get("layout").is_some() { - let legacy = - serde_json::from_value::<LegacyWorkspaceSnapshot>(raw).map_err(|e| e.to_string())?; - return Ok(legacy.into()); - } - - Err("workspace snapshot is neither current nor legacy format".to_string()) -} - -fn legacy_identity_cwd(snap: &LegacyWorkspaceSnapshot) -> PathBuf { - let root_pane = snap - .root_pane - .or_else(|| first_pane_id_in_layout(&snap.layout)); - - root_pane - .and_then(|pane_id| snap.panes.get(&pane_id)) - .map(|pane| pane.cwd.clone()) - .or_else(|| { - first_pane_id_in_layout(&snap.layout) - .and_then(|pane_id| snap.panes.get(&pane_id)) - .map(|pane| pane.cwd.clone()) - }) - .or_else(|| { - snap.panes - .keys() - .min() - .and_then(|pane_id| snap.panes.get(pane_id)) - .map(|pane| pane.cwd.clone()) - }) - .unwrap_or_else(|| std::env::current_dir().unwrap_or_else(|_| "/".into())) -} - -fn first_pane_id_in_layout(layout: &LayoutSnapshot) -> Option<u32> { - match layout { - LayoutSnapshot::Pane(id) => Some(*id), - LayoutSnapshot::Split { first, second, .. } => { - first_pane_id_in_layout(first).or_else(|| first_pane_id_in_layout(second)) - } - } -} - -// --- Capture --- - -/// Capture the current app state into a serializable snapshot. -pub fn capture( - workspaces: &[Workspace], - active: Option<usize>, - selected: usize, - agent_panel_scope: crate::app::state::AgentPanelScope, - sidebar_width: u16, - sidebar_section_split: f32, -) -> SessionSnapshot { - SessionSnapshot { - version: SNAPSHOT_VERSION, - workspaces: workspaces.iter().map(capture_workspace).collect(), - active, - selected, - agent_panel_scope, - sidebar_width: Some(sidebar_width), - sidebar_section_split: Some(sidebar_section_split), - } -} - -fn capture_workspace(ws: &Workspace) -> WorkspaceSnapshot { - WorkspaceSnapshot { - id: Some(ws.id.clone()), - custom_name: ws.custom_name.clone(), - identity_cwd: ws - .resolved_identity_cwd() - .unwrap_or_else(|| ws.identity_cwd.clone()), - tabs: ws.tabs.iter().map(capture_tab).collect(), - active_tab: ws.active_tab, - } -} - -fn capture_tab(tab: &crate::workspace::Tab) -> TabSnapshot { - let mut panes = HashMap::new(); - for id in tab.panes.keys() { - let cwd = tab - .cwd_for_pane(*id) - .unwrap_or_else(|| std::env::current_dir().unwrap_or_else(|_| "/".into())); - panes.insert(id.raw(), PaneSnapshot { cwd }); - } - TabSnapshot { - custom_name: tab.custom_name.clone(), - layout: capture_node(tab.layout.root()), - panes, - zoomed: tab.zoomed, - focused: Some(tab.layout.focused().raw()), - root_pane: Some(tab.root_pane.raw()), - } -} - -fn capture_node(node: &Node) -> LayoutSnapshot { - match node { - Node::Pane(id) => LayoutSnapshot::Pane(id.raw()), - Node::Split { - direction, - ratio, - first, - second, - } => LayoutSnapshot::Split { - direction: match direction { - Direction::Horizontal => DirectionSnapshot::Horizontal, - Direction::Vertical => DirectionSnapshot::Vertical, - }, - ratio: *ratio, - first: Box::new(capture_node(first)), - second: Box::new(capture_node(second)), - }, - } -} - -// --- Restore --- - -/// Restore workspaces from a snapshot. Each pane gets a fresh shell in its saved cwd. -pub fn restore( - snapshot: &SessionSnapshot, - rows: u16, - cols: u16, - scrollback_limit_bytes: usize, - events: mpsc::Sender<AppEvent>, - render_notify: Arc<Notify>, - render_dirty: Arc<AtomicBool>, -) -> Vec<Workspace> { - snapshot - .workspaces - .iter() - .filter_map(|ws_snap| { - restore_workspace( - ws_snap, - rows, - cols, - scrollback_limit_bytes, - events.clone(), - render_notify.clone(), - render_dirty.clone(), - ) - }) - .collect() -} - -fn restore_workspace( - snap: &WorkspaceSnapshot, - rows: u16, - cols: u16, - scrollback_limit_bytes: usize, - events: mpsc::Sender<AppEvent>, - render_notify: Arc<Notify>, - render_dirty: Arc<AtomicBool>, -) -> Option<Workspace> { - let mut tabs = Vec::new(); - let mut public_pane_numbers = HashMap::new(); - let mut next_public_pane_number = 1; - - for (idx, tab_snap) in snap.tabs.iter().enumerate() { - let tab = restore_tab( - tab_snap, - idx + 1, - rows, - cols, - scrollback_limit_bytes, - events.clone(), - render_notify.clone(), - render_dirty.clone(), - )?; - for pane_id in tab.layout.pane_ids() { - public_pane_numbers.insert(pane_id, next_public_pane_number); - next_public_pane_number += 1; - } - tabs.push(tab); - } - - if tabs.is_empty() { - return None; - } - - Some(Workspace { - id: snap - .id - .clone() - .unwrap_or_else(crate::workspace::generate_workspace_id), - custom_name: snap.custom_name.clone(), - identity_cwd: snap.identity_cwd.clone(), - cached_git_ahead_behind: None, - public_pane_numbers, - next_public_pane_number, - active_tab: snap.active_tab.min(tabs.len().saturating_sub(1)), - tabs, - }) -} - -fn restore_tab( - snap: &TabSnapshot, - number: usize, - rows: u16, - cols: u16, - scrollback_limit_bytes: usize, - events: mpsc::Sender<AppEvent>, - render_notify: Arc<Notify>, - render_dirty: Arc<AtomicBool>, -) -> Option<crate::workspace::Tab> { - let (node, id_map) = restore_node_remapped(&snap.layout); - let pane_ids = collect_pane_ids(&node); - let focus = snap - .focused - .and_then(|old_raw| id_map.get(&old_raw).copied()) - .or_else(|| pane_ids.first().copied()) - .unwrap_or(PaneId::from_raw(0)); - let layout = TileLayout::from_saved(node, focus); - - let mut panes = HashMap::new(); - let mut pane_cwds = HashMap::new(); - let mut runtimes = HashMap::new(); - for id in &pane_ids { - let old_id = id_map - .iter() - .find(|(_, new)| **new == *id) - .map(|(old, _)| old); - let cwd = old_id - .and_then(|old| snap.panes.get(old)) - .map(|p| p.cwd.clone()) - .unwrap_or_else(|| std::env::current_dir().unwrap_or_else(|_| "/".into())); - - match PaneRuntime::spawn( - *id, - rows, - cols, - cwd.clone(), - scrollback_limit_bytes, - crate::terminal_theme::TerminalTheme::default(), - events.clone(), - render_notify.clone(), - render_dirty.clone(), - ) { - Ok(runtime) => { - panes.insert(*id, PaneState::new()); - pane_cwds.insert(*id, cwd.clone()); - runtimes.insert(*id, runtime); - } - Err(e) => { - error!(tab = ?snap.custom_name, err = %e, "failed to restore pane"); - return None; - } - } - } - - let root_pane = snap - .root_pane - .and_then(|old_raw| id_map.get(&old_raw).copied()) - .or_else(|| pane_ids.first().copied()) - .unwrap_or(PaneId::from_raw(0)); - - Some(crate::workspace::Tab { - custom_name: snap.custom_name.clone(), - number, - root_pane, - layout, - panes, - pane_cwds, - runtimes, - zoomed: snap.zoomed, - events, - render_notify, - render_dirty, - }) -} - -/// Restore a layout tree, remapping every pane ID to a fresh globally unique one. -/// Returns the new tree and a map of old_raw_id → new PaneId. -fn restore_node_remapped(snap: &LayoutSnapshot) -> (Node, HashMap<u32, PaneId>) { - let mut id_map = HashMap::new(); - let node = remap_inner(snap, &mut id_map); - (node, id_map) -} - -fn remap_inner(snap: &LayoutSnapshot, id_map: &mut HashMap<u32, PaneId>) -> Node { - match snap { - LayoutSnapshot::Pane(old_id) => { - let new_id = PaneId::alloc(); - id_map.insert(*old_id, new_id); - Node::Pane(new_id) - } - LayoutSnapshot::Split { - direction, - ratio, - first, - second, - } => { - let first_node = remap_inner(first, id_map); - let second_node = remap_inner(second, id_map); - let dir = match direction { - DirectionSnapshot::Horizontal => Direction::Horizontal, - DirectionSnapshot::Vertical => Direction::Vertical, - }; - Node::Split { - direction: dir, - ratio: *ratio, - first: Box::new(first_node), - second: Box::new(second_node), - } - } - } -} - -fn collect_pane_ids(node: &Node) -> Vec<PaneId> { - let mut ids = Vec::new(); - collect_ids_inner(node, &mut ids); - ids -} - -fn collect_ids_inner(node: &Node, ids: &mut Vec<PaneId>) { - match node { - Node::Pane(id) => ids.push(*id), - Node::Split { first, second, .. } => { - collect_ids_inner(first, ids); - collect_ids_inner(second, ids); - } - } -} - -// --- File I/O --- - -fn session_path() -> PathBuf { - crate::config::config_dir().join("session.json") -} - -fn save_to_path(path: &std::path::Path, snapshot: &SessionSnapshot) -> std::io::Result<()> { - if let Some(parent) = path.parent() { - std::fs::create_dir_all(parent)?; - } - let json = serde_json::to_string_pretty(snapshot)?; - let tmp_path = path.with_extension("json.tmp"); - std::fs::write(&tmp_path, &json)?; - if let Err(err) = std::fs::rename(&tmp_path, path) { - let _ = std::fs::remove_file(&tmp_path); - return Err(err); - } - Ok(()) -} - -fn clear_path(path: &std::path::Path) -> std::io::Result<()> { - match std::fs::remove_file(path) { - Ok(()) => Ok(()), - Err(err) if err.kind() == std::io::ErrorKind::NotFound => Ok(()), - Err(err) => Err(err), - } -} - -pub fn save(snapshot: &SessionSnapshot) { - let path = session_path(); - if let Err(err) = save_to_path(&path, snapshot) { - error!(err = %err, path = %path.display(), "failed to save session"); - return; - } - info!(workspaces = snapshot.workspaces.len(), "session saved"); -} - -pub fn clear() { - let path = session_path(); - if let Err(err) = clear_path(&path) { - error!(err = %err, path = %path.display(), "failed to clear session"); - return; - } - info!(path = %path.display(), "session cleared"); -} - -fn parse_snapshot(content: &str) -> Result<SessionSnapshot, String> { - let raw = serde_json::from_str::<RawSessionSnapshot>(content).map_err(|e| e.to_string())?; - if raw.version > SNAPSHOT_VERSION { - return Err(format!( - "snapshot version {} is newer than supported {}", - raw.version, SNAPSHOT_VERSION - )); - } - migrate_snapshot(raw) -} - -pub fn load() -> Option<SessionSnapshot> { - let path = session_path(); - if !path.exists() { - return None; - } - let content = match std::fs::read_to_string(&path) { - Ok(c) => c, - Err(e) => { - warn!(err = %e, "failed to read session file"); - return None; - } - }; - match parse_snapshot(&content) { - Ok(snap) => Some(snap), - Err(e) => { - if let Ok(raw) = serde_json::from_str::<RawSessionSnapshot>(&content) { - if raw.version > SNAPSHOT_VERSION { - warn!( - file_version = raw.version, - supported = SNAPSHOT_VERSION, - "session file is from a newer herdr version, ignoring" - ); - return None; - } - } - warn!(err = %e, "failed to parse session file, ignoring"); - None - } - } -} - -// --- Tests --- - -#[cfg(test)] -mod tests { - use super::*; - use ratatui::layout::Rect; - - use crate::app::{state::AgentPanelScope, AppState, Mode}; - use crate::layout::NavDirection; - use crate::workspace::Workspace; - - fn session_fixture(name: &str) -> &'static str { - match name { - "current-herdr" => include_str!("../tests/fixtures/session/current-herdr-session.json"), - "current-herdr-dev" => { - include_str!("../tests/fixtures/session/current-herdr-dev-session.json") - } - "legacy-pre-tabs-v2" => { - include_str!("../tests/fixtures/session/legacy-pre-tabs-v2.json") - } - other => panic!("unknown session fixture: {other}"), - } - } - - fn temp_session_path(name: &str) -> PathBuf { - let unique = format!( - "herdr-session-tests-{}-{}-{}", - name, - std::process::id(), - std::time::SystemTime::now() - .duration_since(std::time::UNIX_EPOCH) - .unwrap() - .as_nanos() - ); - std::env::temp_dir().join(unique).join("session.json") - } - - #[test] - fn round_trip_empty_session() { - let snap = SessionSnapshot { - version: SNAPSHOT_VERSION, - workspaces: vec![], - active: None, - selected: 0, - agent_panel_scope: crate::app::state::AgentPanelScope::CurrentWorkspace, - sidebar_width: Some(26), - sidebar_section_split: Some(0.5), - }; - let json = serde_json::to_string(&snap).unwrap(); - let restored = parse_snapshot(&json).unwrap(); - assert!(restored.workspaces.is_empty()); - assert_eq!(restored.active, None); - assert_eq!(restored.sidebar_width, Some(26)); - assert_eq!(restored.sidebar_section_split, Some(0.5)); - } - - #[test] - fn clear_path_removes_existing_session_file() { - let path = temp_session_path("clear-existing"); - save_to_path( - &path, - &SessionSnapshot { - version: SNAPSHOT_VERSION, - workspaces: vec![], - active: None, - selected: 0, - agent_panel_scope: AgentPanelScope::CurrentWorkspace, - sidebar_width: Some(26), - sidebar_section_split: Some(0.5), - }, - ) - .unwrap(); - - clear_path(&path).unwrap(); - - assert!(!path.exists()); - } - - #[test] - fn clear_path_ignores_missing_session_file() { - let path = temp_session_path("clear-missing"); - - clear_path(&path).unwrap(); - - assert!(!path.exists()); - } - - #[test] - fn round_trip_layout_snapshot() { - let layout = LayoutSnapshot::Split { - direction: DirectionSnapshot::Horizontal, - ratio: 0.6, - first: Box::new(LayoutSnapshot::Pane(0)), - second: Box::new(LayoutSnapshot::Split { - direction: DirectionSnapshot::Vertical, - ratio: 0.5, - first: Box::new(LayoutSnapshot::Pane(1)), - second: Box::new(LayoutSnapshot::Pane(2)), - }), - }; - let json = serde_json::to_string(&layout).unwrap(); - let restored: LayoutSnapshot = serde_json::from_str(&json).unwrap(); - - // Verify structure - match restored { - LayoutSnapshot::Split { ratio, .. } => assert!((ratio - 0.6).abs() < 0.01), - _ => panic!("expected split"), - } - } - - #[test] - fn round_trip_full_workspace_snapshot() { - let mut panes = HashMap::new(); - panes.insert( - 0, - PaneSnapshot { - cwd: PathBuf::from("/home/can/Projects/herdr"), - }, - ); - panes.insert( - 1, - PaneSnapshot { - cwd: PathBuf::from("/home/can/Projects/website"), - }, - ); - - let snap = SessionSnapshot { - workspaces: vec![WorkspaceSnapshot { - id: Some("wproj".to_string()), - custom_name: Some("pi-mono".to_string()), - identity_cwd: PathBuf::from("/home/can/Projects/herdr"), - tabs: vec![TabSnapshot { - custom_name: Some("api".to_string()), - layout: LayoutSnapshot::Split { - direction: DirectionSnapshot::Horizontal, - ratio: 0.5, - first: Box::new(LayoutSnapshot::Pane(0)), - second: Box::new(LayoutSnapshot::Pane(1)), - }, - panes, - zoomed: false, - focused: Some(0), - root_pane: Some(0), - }], - active_tab: 0, - }], - active: Some(0), - selected: 0, - agent_panel_scope: crate::app::state::AgentPanelScope::CurrentWorkspace, - sidebar_width: Some(26), - sidebar_section_split: Some(0.5), - version: SNAPSHOT_VERSION, - }; - - let json = serde_json::to_string_pretty(&snap).unwrap(); - let restored = parse_snapshot(&json).unwrap(); - - assert_eq!(restored.workspaces.len(), 1); - assert_eq!(restored.workspaces[0].id.as_deref(), Some("wproj")); - assert_eq!( - restored.workspaces[0].custom_name.as_deref(), - Some("pi-mono") - ); - assert_eq!(restored.workspaces[0].tabs.len(), 1); - assert_eq!(restored.workspaces[0].tabs[0].panes.len(), 2); - assert_eq!( - restored.workspaces[0].tabs[0].panes[&0].cwd, - PathBuf::from("/home/can/Projects/herdr") - ); - assert_eq!( - restored.agent_panel_scope, - crate::app::state::AgentPanelScope::CurrentWorkspace - ); - assert_eq!(restored.sidebar_width, Some(26)); - assert_eq!(restored.sidebar_section_split, Some(0.5)); - } - - #[test] - fn current_session_fixture_parses() { - let snap = parse_snapshot(session_fixture("current-herdr")).unwrap(); - - assert_eq!(snap.version, 3); - assert_eq!(snap.workspaces.len(), 2); - assert_eq!(snap.active, Some(0)); - assert_eq!(snap.selected, 0); - assert_eq!( - snap.agent_panel_scope, - crate::app::state::AgentPanelScope::CurrentWorkspace - ); - assert_eq!(snap.sidebar_width, None); - assert_eq!(snap.sidebar_section_split, None); - assert_eq!(snap.workspaces[0].tabs.len(), 2); - assert_eq!( - snap.workspaces[1].identity_cwd, - PathBuf::from("/home/test/projects/project-b") - ); - } - - #[test] - fn current_dev_session_fixture_parses_additive_fields() { - let snap = parse_snapshot(session_fixture("current-herdr-dev")).unwrap(); - - assert_eq!(snap.version, 3); - assert_eq!(snap.workspaces.len(), 2); - assert_eq!( - snap.agent_panel_scope, - crate::app::state::AgentPanelScope::CurrentWorkspace - ); - assert_eq!(snap.sidebar_section_split, Some(0.4)); - assert_eq!(snap.workspaces[0].active_tab, 1); - assert_eq!(snap.workspaces[1].tabs[0].panes.len(), 2); - } - - #[test] - fn old_snapshot_defaults_agent_panel_scope() { - let json = serde_json::json!({ - "version": SNAPSHOT_VERSION, - "workspaces": [], - "active": null, - "selected": 0 - }) - .to_string(); - - let restored = parse_snapshot(&json).unwrap(); - - assert_eq!( - restored.agent_panel_scope, - crate::app::state::AgentPanelScope::CurrentWorkspace - ); - assert_eq!(restored.sidebar_width, None); - assert_eq!(restored.sidebar_section_split, None); - } - - #[test] - fn legacy_workspace_snapshot_migrates_to_single_tab() { - let snap = parse_snapshot(session_fixture("legacy-pre-tabs-v2")).unwrap(); - let ws = &snap.workspaces[0]; - - assert_eq!(snap.version, 2); - assert_eq!(snap.workspaces.len(), 1); - assert_eq!(ws.custom_name.as_deref(), Some("legacy")); - assert_eq!(ws.identity_cwd, PathBuf::from("/tmp/pion")); - assert_eq!(ws.active_tab, 0); - assert_eq!(ws.tabs.len(), 1); - assert_eq!(ws.tabs[0].focused, Some(1)); - assert_eq!(ws.tabs[0].root_pane, Some(0)); - assert_eq!(ws.tabs[0].panes[&0].cwd, PathBuf::from("/tmp/pion")); - assert_eq!(ws.tabs[0].panes[&1].cwd, PathBuf::from("/tmp/herdr")); - } - - #[test] - fn capture_and_restore_node_round_trip() { - // Create a tree: Split(H, 0.5, Pane(0), Split(V, 0.3, Pane(1), Pane(2))) - let node = Node::Split { - direction: Direction::Horizontal, - ratio: 0.5, - first: Box::new(Node::Pane(PaneId::from_raw(0))), - second: Box::new(Node::Split { - direction: Direction::Vertical, - ratio: 0.3, - first: Box::new(Node::Pane(PaneId::from_raw(1))), - second: Box::new(Node::Pane(PaneId::from_raw(2))), - }), - }; - - let snap = capture_node(&node); - let (restored, id_map) = restore_node_remapped(&snap); - - assert_eq!(id_map.len(), 3); - let ids = collect_pane_ids(&restored); - assert_eq!(ids.len(), 3); - let unique: std::collections::HashSet<u32> = ids.iter().map(|id| id.raw()).collect(); - assert_eq!(unique.len(), 3); - } - - fn state_with_workspaces(names: &[&str]) -> AppState { - let mut state = AppState::test_new(); - state.workspaces = names.iter().map(|name| Workspace::test_new(name)).collect(); - if !state.workspaces.is_empty() { - state.active = Some(0); - state.selected = 0; - state.mode = Mode::Terminal; - } - state - } - - fn capture_from_state(state: &AppState) -> SessionSnapshot { - capture( - &state.workspaces, - state.active, - state.selected, - state.agent_panel_scope, - state.sidebar_width, - state.sidebar_section_split, - ) - } - - fn root_split_ratio(tab: &TabSnapshot) -> Option<f32> { - match &tab.layout { - LayoutSnapshot::Split { ratio, .. } => Some(*ratio), - LayoutSnapshot::Pane(_) => None, - } - } - - #[test] - fn capture_contract_tracks_workspace_order_active_and_selected() { - let mut state = state_with_workspaces(&["a", "b", "c"]); - state.active = Some(1); - state.selected = 2; - - state.move_workspace(1, 0); - - let snapshot = capture_from_state(&state); - let ids: Vec<_> = state.workspaces.iter().map(|ws| ws.id.clone()).collect(); - let captured_ids: Vec<_> = snapshot - .workspaces - .iter() - .map(|ws| ws.id.clone().unwrap()) - .collect(); - assert_eq!(captured_ids, ids); - assert_eq!(snapshot.active, state.active); - assert_eq!(snapshot.selected, state.selected); - } - - #[test] - fn capture_contract_tracks_workspace_and_tab_names_and_active_tab() { - let mut state = state_with_workspaces(&["one"]); - state.workspaces[0].set_custom_name("renamed-workspace".into()); - let second_tab = state.workspaces[0].test_add_tab(Some("logs")); - state.workspaces[0].switch_tab(second_tab); - state.workspaces[0].tabs[0].set_custom_name("main".into()); - - let snapshot = capture_from_state(&state); - let workspace = &snapshot.workspaces[0]; - assert_eq!(workspace.custom_name.as_deref(), Some("renamed-workspace")); - assert_eq!(workspace.active_tab, second_tab); - assert_eq!(workspace.tabs[0].custom_name.as_deref(), Some("main")); - assert_eq!(workspace.tabs[1].custom_name.as_deref(), Some("logs")); - } - - #[test] - fn capture_contract_tracks_workspace_closure() { - let mut state = state_with_workspaces(&["one", "two"]); - state.selected = 1; - state.active = Some(1); - - state.close_selected_workspace(); - - let snapshot = capture_from_state(&state); - assert_eq!(snapshot.workspaces.len(), 1); - assert_eq!(snapshot.workspaces[0].custom_name.as_deref(), Some("one")); - assert_eq!(snapshot.active, Some(0)); - assert_eq!(snapshot.selected, 0); - } - - #[test] - fn capture_contract_tracks_sidebar_state() { - let mut state = state_with_workspaces(&["one"]); - state.sidebar_width = 31; - state.sidebar_section_split = 0.4; - state.agent_panel_scope = AgentPanelScope::AllWorkspaces; - - let snapshot = capture_from_state(&state); - assert_eq!(snapshot.sidebar_width, Some(31)); - assert_eq!(snapshot.sidebar_section_split, Some(0.4)); - assert_eq!(snapshot.agent_panel_scope, AgentPanelScope::AllWorkspaces); - } - - #[test] - fn capture_contract_tracks_layout_focus_zoom_and_root_pane() { - let mut state = state_with_workspaces(&["one"]); - let root = state.workspaces[0].tabs[0].root_pane; - let second = state.workspaces[0].test_split(Direction::Horizontal); - state.workspaces[0].tabs[0].layout.focus_pane(second); - state.toggle_fullscreen(); - - let snapshot = capture_from_state(&state); - let tab = &snapshot.workspaces[0].tabs[0]; - assert!(matches!(tab.layout, LayoutSnapshot::Split { .. })); - assert_eq!(tab.focused, Some(second.raw())); - assert_eq!(tab.root_pane, Some(root.raw())); - assert!(tab.zoomed); - assert_eq!(tab.panes.len(), 2); - } - - #[test] - fn capture_contract_tracks_focus_navigation() { - let mut state = state_with_workspaces(&["one"]); - let root = state.workspaces[0].tabs[0].root_pane; - let second = state.workspaces[0].test_split(Direction::Horizontal); - crate::ui::compute_view(&mut state, Rect::new(0, 0, 106, 20)); - - state.navigate_pane(NavDirection::Right); - - let snapshot = capture_from_state(&state); - assert_eq!(snapshot.workspaces[0].tabs[0].focused, Some(second.raw())); - assert_ne!(snapshot.workspaces[0].tabs[0].focused, Some(root.raw())); - } - - #[test] - fn capture_contract_tracks_resize_ratio_changes() { - let mut state = state_with_workspaces(&["one"]); - state.workspaces[0].test_split(Direction::Horizontal); - crate::ui::compute_view(&mut state, Rect::new(0, 0, 106, 20)); - let before = capture_from_state(&state); - - state.resize_pane(NavDirection::Right); - - let after = capture_from_state(&state); - let before_ratio = root_split_ratio(&before.workspaces[0].tabs[0]).unwrap(); - let after_ratio = root_split_ratio(&after.workspaces[0].tabs[0]).unwrap(); - assert_ne!(before_ratio, after_ratio); - } - - #[test] - fn capture_contract_tracks_tab_closure() { - let mut state = state_with_workspaces(&["one"]); - let second_tab = state.workspaces[0].test_add_tab(Some("logs")); - state.switch_tab(second_tab); - - state.close_tab(); - - let snapshot = capture_from_state(&state); - let workspace = &snapshot.workspaces[0]; - assert_eq!(workspace.tabs.len(), 1); - assert_eq!(workspace.active_tab, 0); - assert!(workspace.tabs[0].custom_name.is_none()); - } - - #[test] - fn capture_contract_tracks_pane_closure() { - let mut state = state_with_workspaces(&["one"]); - state.workspaces[0].test_split(Direction::Horizontal); - - state.close_pane(); - - let snapshot = capture_from_state(&state); - let tab = &snapshot.workspaces[0].tabs[0]; - assert_eq!(tab.panes.len(), 1); - assert!(matches!(tab.layout, LayoutSnapshot::Pane(_))); - assert!(!tab.zoomed); - } - - #[test] - fn capture_contract_tracks_workspace_identity_and_pane_cwds() { - let mut state = state_with_workspaces(&["one"]); - let root = state.workspaces[0].tabs[0].root_pane; - state.workspaces[0].tabs[0] - .pane_cwds - .insert(root, PathBuf::from("/tmp/pion")); - let second = state.workspaces[0].test_split(Direction::Horizontal); - state.workspaces[0].tabs[0] - .pane_cwds - .insert(second, PathBuf::from("/tmp/herdr")); - - let snapshot = capture_from_state(&state); - let workspace = &snapshot.workspaces[0]; - let tab = &workspace.tabs[0]; - assert_eq!(workspace.identity_cwd, PathBuf::from("/tmp/pion")); - assert_eq!(tab.panes[&root.raw()].cwd, PathBuf::from("/tmp/pion")); - assert_eq!(tab.panes[&second.raw()].cwd, PathBuf::from("/tmp/herdr")); - } - - #[test] - fn old_unversioned_snapshot_loads_as_version_0() { - // Simulate a snapshot from before versioning was added - let json = r#"{"workspaces":[],"active":null,"selected":0}"#; - let snap = parse_snapshot(json).unwrap(); - assert_eq!(snap.version, 0); - } - - #[test] - fn future_version_is_rejected() { - let json = r#"{"version":999,"workspaces":[],"active":null,"selected":0}"#; - assert!(parse_snapshot(json).is_err()); - } - - #[test] - fn active_tab_default_is_zero() { - let json = r#"{"custom_name":"test","identity_cwd":"/tmp","tabs":[]}"#; - let ws: WorkspaceSnapshot = serde_json::from_str(json).unwrap(); - assert_eq!(ws.active_tab, 0); - } -} +mod io; +mod restore; +mod snapshot; + +pub use self::io::{clear, load, save}; +pub use self::restore::restore; +pub use self::snapshot::{ + capture, DirectionSnapshot, LayoutSnapshot, SessionSnapshot, TabSnapshot, WorkspaceSnapshot, +}; diff --git a/src/persist/io.rs b/src/persist/io.rs new file mode 100644 index 00000000..26e6fd4e --- /dev/null +++ b/src/persist/io.rs @@ -0,0 +1,130 @@ +use std::path::{Path, PathBuf}; + +use tracing::{error, info, warn}; + +use super::snapshot::{parse_snapshot, snapshot_file_version, SessionSnapshot, SNAPSHOT_VERSION}; + +fn session_path() -> PathBuf { + crate::config::config_dir().join("session.json") +} + +pub(super) fn save_to_path(path: &Path, snapshot: &SessionSnapshot) -> std::io::Result<()> { + if let Some(parent) = path.parent() { + std::fs::create_dir_all(parent)?; + } + let json = serde_json::to_string_pretty(snapshot)?; + let tmp_path = path.with_extension("json.tmp"); + std::fs::write(&tmp_path, &json)?; + if let Err(err) = std::fs::rename(&tmp_path, path) { + let _ = std::fs::remove_file(&tmp_path); + return Err(err); + } + Ok(()) +} + +pub(super) fn clear_path(path: &Path) -> std::io::Result<()> { + match std::fs::remove_file(path) { + Ok(()) => Ok(()), + Err(err) if err.kind() == std::io::ErrorKind::NotFound => Ok(()), + Err(err) => Err(err), + } +} + +pub fn save(snapshot: &SessionSnapshot) { + let path = session_path(); + if let Err(err) = save_to_path(&path, snapshot) { + error!(err = %err, path = %path.display(), "failed to save session"); + return; + } + info!(workspaces = snapshot.workspaces.len(), "session saved"); +} + +pub fn clear() { + let path = session_path(); + if let Err(err) = clear_path(&path) { + error!(err = %err, path = %path.display(), "failed to clear session"); + return; + } + info!(path = %path.display(), "session cleared"); +} + +pub fn load() -> Option<SessionSnapshot> { + let path = session_path(); + if !path.exists() { + return None; + } + let content = match std::fs::read_to_string(&path) { + Ok(content) => content, + Err(err) => { + warn!(err = %err, "failed to read session file"); + return None; + } + }; + match parse_snapshot(&content) { + Ok(snapshot) => Some(snapshot), + Err(err) => { + if let Some(version) = snapshot_file_version(&content) { + if version > SNAPSHOT_VERSION { + warn!( + file_version = version, + supported = SNAPSHOT_VERSION, + "session file is from a newer herdr version, ignoring" + ); + return None; + } + } + warn!(err = %err, "failed to parse session file, ignoring"); + None + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::app::state::AgentPanelScope; + + fn temp_session_path(name: &str) -> PathBuf { + let unique = format!( + "herdr-session-tests-{}-{}-{}", + name, + std::process::id(), + std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .unwrap() + .as_nanos() + ); + std::env::temp_dir().join(unique).join("session.json") + } + + fn empty_snapshot() -> SessionSnapshot { + SessionSnapshot { + version: SNAPSHOT_VERSION, + workspaces: vec![], + active: None, + selected: 0, + agent_panel_scope: AgentPanelScope::CurrentWorkspace, + sidebar_width: Some(26), + sidebar_section_split: Some(0.5), + } + } + + #[test] + fn clear_path_removes_existing_session_file() { + let path = temp_session_path("clear-existing"); + save_to_path(&path, &empty_snapshot()).unwrap(); + + clear_path(&path).unwrap(); + + assert!(!path.exists()); + } + + #[test] + fn clear_path_ignores_missing_session_file() { + let path = temp_session_path("clear-missing"); + + clear_path(&path).unwrap(); + + assert!(!path.exists()); + } +} diff --git a/src/persist/restore.rs b/src/persist/restore.rs new file mode 100644 index 00000000..eeef0af1 --- /dev/null +++ b/src/persist/restore.rs @@ -0,0 +1,353 @@ +use std::collections::{HashMap, HashSet}; +use std::path::PathBuf; +use std::sync::atomic::AtomicBool; +use std::sync::Arc; + +use ratatui::layout::Direction; +use tokio::sync::{mpsc, Notify}; +use tracing::{error, warn}; + +use crate::events::AppEvent; +use crate::layout::{Node, PaneId, TileLayout}; +use crate::pane::{PaneRuntime, PaneState}; +use crate::workspace::Workspace; + +use super::{DirectionSnapshot, LayoutSnapshot, SessionSnapshot, TabSnapshot, WorkspaceSnapshot}; + +/// Restore workspaces from a snapshot. Each pane gets a fresh shell in its saved cwd. +pub fn restore( + snapshot: &SessionSnapshot, + rows: u16, + cols: u16, + scrollback_limit_bytes: usize, + events: mpsc::Sender<AppEvent>, + render_notify: Arc<Notify>, + render_dirty: Arc<AtomicBool>, +) -> Vec<Workspace> { + snapshot + .workspaces + .iter() + .filter_map(|ws_snap| { + restore_workspace( + ws_snap, + rows, + cols, + scrollback_limit_bytes, + events.clone(), + render_notify.clone(), + render_dirty.clone(), + ) + }) + .collect() +} + +fn restore_workspace( + snap: &WorkspaceSnapshot, + rows: u16, + cols: u16, + scrollback_limit_bytes: usize, + events: mpsc::Sender<AppEvent>, + render_notify: Arc<Notify>, + render_dirty: Arc<AtomicBool>, +) -> Option<Workspace> { + let mut tabs = Vec::new(); + let mut public_pane_numbers = HashMap::new(); + let mut next_public_pane_number = 1; + + for (idx, tab_snap) in snap.tabs.iter().enumerate() { + let tab = restore_tab( + tab_snap, + idx + 1, + rows, + cols, + scrollback_limit_bytes, + events.clone(), + render_notify.clone(), + render_dirty.clone(), + )?; + for pane_id in tab.layout.pane_ids() { + public_pane_numbers.insert(pane_id, next_public_pane_number); + next_public_pane_number += 1; + } + tabs.push(tab); + } + + if tabs.is_empty() { + return None; + } + + Some(Workspace { + id: snap + .id + .clone() + .unwrap_or_else(crate::workspace::generate_workspace_id), + custom_name: snap.custom_name.clone(), + identity_cwd: snap.identity_cwd.clone(), + cached_git_ahead_behind: None, + public_pane_numbers, + next_public_pane_number, + active_tab: snap.active_tab.min(tabs.len().saturating_sub(1)), + tabs, + }) +} + +fn restore_tab( + snap: &TabSnapshot, + number: usize, + rows: u16, + cols: u16, + scrollback_limit_bytes: usize, + events: mpsc::Sender<AppEvent>, + render_notify: Arc<Notify>, + render_dirty: Arc<AtomicBool>, +) -> Option<crate::workspace::Tab> { + let (node, id_map) = restore_node_remapped(&snap.layout); + let reverse_id_map: HashMap<PaneId, u32> = id_map + .iter() + .map(|(&old_id, &new_id)| (new_id, old_id)) + .collect(); + let pane_ids = collect_pane_ids(&node); + + let mut panes = HashMap::new(); + let mut pane_cwds = HashMap::new(); + let mut runtimes = HashMap::new(); + for id in &pane_ids { + let saved_cwd = reverse_id_map + .get(id) + .and_then(|old_id| snap.panes.get(old_id)) + .map(|p| p.cwd.clone()) + .unwrap_or_else(|| std::env::current_dir().unwrap_or_else(|_| "/".into())); + + let cwd = if saved_cwd.exists() { + saved_cwd + } else { + warn!( + cwd = %saved_cwd.display(), + "saved pane cwd does not exist, falling back to HOME" + ); + let home = std::env::var("HOME") + .map(PathBuf::from) + .unwrap_or_else(|_| PathBuf::from("/")); + if home.exists() { + home + } else { + PathBuf::from("/") + } + }; + + match PaneRuntime::spawn( + *id, + rows, + cols, + cwd.clone(), + scrollback_limit_bytes, + crate::terminal_theme::TerminalTheme::default(), + events.clone(), + render_notify.clone(), + render_dirty.clone(), + ) { + Ok(runtime) => { + panes.insert(*id, PaneState::new()); + pane_cwds.insert(*id, cwd.clone()); + runtimes.insert(*id, runtime); + } + Err(e) => { + error!( + tab = ?snap.custom_name, + pane_id = id.raw(), + err = %e, + "failed to restore pane, skipping" + ); + } + } + } + + if panes.is_empty() { + warn!( + tab = ?snap.custom_name, + "no panes could be restored for tab, dropping it" + ); + return None; + } + + let surviving: HashSet<PaneId> = panes.keys().copied().collect(); + let Some(node) = prune_restored_node(node, &surviving) else { + warn!( + tab = ?snap.custom_name, + "restored tab lost all panes after pruning missing layout nodes" + ); + return None; + }; + let pane_ids = collect_pane_ids(&node); + let focus = resolve_restored_pane(snap.focused, &id_map, &surviving, &pane_ids)?; + let root_pane = resolve_restored_pane(snap.root_pane, &id_map, &surviving, &pane_ids)?; + let layout = TileLayout::from_saved(node, focus); + + Some(crate::workspace::Tab { + custom_name: snap.custom_name.clone(), + number, + root_pane, + layout, + panes, + pane_cwds, + runtimes, + zoomed: snap.zoomed, + events, + render_notify, + render_dirty, + }) +} + +pub(super) fn prune_restored_node(node: Node, surviving: &HashSet<PaneId>) -> Option<Node> { + match node { + Node::Pane(id) => surviving.contains(&id).then_some(Node::Pane(id)), + Node::Split { + direction, + ratio, + first, + second, + } => { + let first = prune_restored_node(*first, surviving); + let second = prune_restored_node(*second, surviving); + match (first, second) { + (Some(first), Some(second)) => Some(Node::Split { + direction, + ratio, + first: Box::new(first), + second: Box::new(second), + }), + (Some(remaining), None) | (None, Some(remaining)) => Some(remaining), + (None, None) => None, + } + } + } +} + +pub(super) fn resolve_restored_pane( + saved_old_id: Option<u32>, + id_map: &HashMap<u32, PaneId>, + surviving: &HashSet<PaneId>, + pane_ids: &[PaneId], +) -> Option<PaneId> { + saved_old_id + .and_then(|old_id| id_map.get(&old_id).copied()) + .filter(|pane_id| surviving.contains(pane_id)) + .or_else(|| pane_ids.first().copied()) +} + +/// Restore a layout tree, remapping every pane ID to a fresh globally unique one. +/// Returns the new tree and a map of old_raw_id → new PaneId. +pub(super) fn restore_node_remapped(snap: &LayoutSnapshot) -> (Node, HashMap<u32, PaneId>) { + let mut id_map = HashMap::new(); + let node = remap_inner(snap, &mut id_map); + (node, id_map) +} + +fn remap_inner(snap: &LayoutSnapshot, id_map: &mut HashMap<u32, PaneId>) -> Node { + match snap { + LayoutSnapshot::Pane(old_id) => { + let new_id = PaneId::alloc(); + id_map.insert(*old_id, new_id); + Node::Pane(new_id) + } + LayoutSnapshot::Split { + direction, + ratio, + first, + second, + } => { + let first_node = remap_inner(first, id_map); + let second_node = remap_inner(second, id_map); + let dir = match direction { + DirectionSnapshot::Horizontal => Direction::Horizontal, + DirectionSnapshot::Vertical => Direction::Vertical, + }; + Node::Split { + direction: dir, + ratio: *ratio, + first: Box::new(first_node), + second: Box::new(second_node), + } + } + } +} + +pub(super) fn collect_pane_ids(node: &Node) -> Vec<PaneId> { + let mut ids = Vec::new(); + collect_ids_inner(node, &mut ids); + ids +} + +fn collect_ids_inner(node: &Node, ids: &mut Vec<PaneId>) { + match node { + Node::Pane(id) => ids.push(*id), + Node::Split { first, second, .. } => { + collect_ids_inner(first, ids); + collect_ids_inner(second, ids); + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn capture_and_restore_node_round_trip() { + let node = Node::Split { + direction: Direction::Horizontal, + ratio: 0.5, + first: Box::new(Node::Pane(PaneId::from_raw(0))), + second: Box::new(Node::Split { + direction: Direction::Vertical, + ratio: 0.3, + first: Box::new(Node::Pane(PaneId::from_raw(1))), + second: Box::new(Node::Pane(PaneId::from_raw(2))), + }), + }; + + let snap = super::super::snapshot::capture_node(&node); + let (restored, id_map) = restore_node_remapped(&snap); + + assert_eq!(id_map.len(), 3); + let ids = collect_pane_ids(&restored); + assert_eq!(ids.len(), 3); + let unique: std::collections::HashSet<u32> = ids.iter().map(|id| id.raw()).collect(); + assert_eq!(unique.len(), 3); + } + + #[test] + fn prune_restored_node_collapses_missing_branch() { + let keep = PaneId::from_raw(11); + let missing = PaneId::from_raw(12); + let node = Node::Split { + direction: Direction::Horizontal, + ratio: 0.5, + first: Box::new(Node::Pane(keep)), + second: Box::new(Node::Pane(missing)), + }; + let surviving = std::collections::HashSet::from([keep]); + + let pruned = prune_restored_node(node, &surviving).expect("remaining pane should survive"); + + assert!(matches!(pruned, Node::Pane(id) if id == keep)); + } + + #[test] + fn resolve_restored_pane_prefers_surviving_saved_id_and_falls_back_to_first_remaining() { + let first = PaneId::from_raw(21); + let second = PaneId::from_raw(22); + let id_map = HashMap::from([(0_u32, first), (1_u32, second)]); + let surviving = std::collections::HashSet::from([first]); + let pane_ids = vec![first]; + + assert_eq!( + resolve_restored_pane(Some(0), &id_map, &surviving, &pane_ids), + Some(first) + ); + assert_eq!( + resolve_restored_pane(Some(1), &id_map, &surviving, &pane_ids), + Some(first) + ); + } +} diff --git a/src/persist/snapshot.rs b/src/persist/snapshot.rs new file mode 100644 index 00000000..1438cd6d --- /dev/null +++ b/src/persist/snapshot.rs @@ -0,0 +1,744 @@ +use std::collections::HashMap; +use std::path::PathBuf; + +use ratatui::layout::Direction; +use serde::{Deserialize, Serialize}; + +use crate::layout::Node; +use crate::workspace::Workspace; + +/// Current snapshot format version. +pub(super) const SNAPSHOT_VERSION: u32 = 3; + +/// Serializable snapshot of the entire herdr session. +#[derive(Serialize, Deserialize)] +pub struct SessionSnapshot { + /// Format version — used to detect incompatible changes. + #[serde(default)] + pub version: u32, + pub workspaces: Vec<WorkspaceSnapshot>, + pub active: Option<usize>, + pub selected: usize, + #[serde(default)] + pub agent_panel_scope: crate::app::state::AgentPanelScope, + #[serde(default)] + pub sidebar_width: Option<u16>, + #[serde(default)] + pub sidebar_section_split: Option<f32>, +} + +#[derive(Serialize, Deserialize)] +pub struct WorkspaceSnapshot { + #[serde(default)] + pub id: Option<String>, + #[serde(default)] + pub custom_name: Option<String>, + pub identity_cwd: PathBuf, + pub tabs: Vec<TabSnapshot>, + #[serde(default)] + pub active_tab: usize, +} + +#[derive(Deserialize)] +struct LegacyWorkspaceSnapshot { + #[serde(default)] + custom_name: Option<String>, + layout: LayoutSnapshot, + panes: HashMap<u32, PaneSnapshot>, + zoomed: bool, + #[serde(default)] + focused: Option<u32>, + #[serde(default)] + root_pane: Option<u32>, +} + +#[derive(Serialize, Deserialize)] +pub struct TabSnapshot { + #[serde(default)] + pub custom_name: Option<String>, + pub layout: LayoutSnapshot, + pub panes: HashMap<u32, PaneSnapshot>, + pub zoomed: bool, + #[serde(default)] + pub focused: Option<u32>, + #[serde(default)] + pub root_pane: Option<u32>, +} + +#[derive(Serialize, Deserialize)] +pub struct PaneSnapshot { + pub cwd: PathBuf, +} + +/// Serializable BSP tree. +#[derive(Serialize, Deserialize)] +pub enum LayoutSnapshot { + Pane(u32), + Split { + direction: DirectionSnapshot, + ratio: f32, + first: Box<LayoutSnapshot>, + second: Box<LayoutSnapshot>, + }, +} + +#[derive(Serialize, Deserialize)] +pub enum DirectionSnapshot { + Horizontal, + Vertical, +} + +impl From<LegacyWorkspaceSnapshot> for WorkspaceSnapshot { + fn from(snap: LegacyWorkspaceSnapshot) -> Self { + let identity_cwd = legacy_identity_cwd(&snap); + let tab = TabSnapshot { + custom_name: None, + layout: snap.layout, + panes: snap.panes, + zoomed: snap.zoomed, + focused: snap.focused, + root_pane: snap.root_pane, + }; + + Self { + id: None, + custom_name: snap.custom_name, + identity_cwd, + tabs: vec![tab], + active_tab: 0, + } + } +} + +#[derive(Deserialize)] +struct RawSessionSnapshot { + #[serde(default)] + version: u32, + #[serde(default)] + workspaces: Vec<serde_json::Value>, + #[serde(default)] + active: Option<usize>, + #[serde(default)] + selected: usize, + #[serde(default)] + agent_panel_scope: crate::app::state::AgentPanelScope, + #[serde(default)] + sidebar_width: Option<u16>, + #[serde(default)] + sidebar_section_split: Option<f32>, +} + +fn migrate_snapshot(raw: RawSessionSnapshot) -> Result<SessionSnapshot, String> { + Ok(SessionSnapshot { + version: raw.version, + workspaces: raw + .workspaces + .into_iter() + .map(migrate_workspace) + .collect::<Result<Vec<_>, _>>()?, + active: raw.active, + selected: raw.selected, + agent_panel_scope: raw.agent_panel_scope, + sidebar_width: raw.sidebar_width, + sidebar_section_split: raw.sidebar_section_split, + }) +} + +fn migrate_workspace(raw: serde_json::Value) -> Result<WorkspaceSnapshot, String> { + if raw.get("identity_cwd").is_some() { + return serde_json::from_value(raw).map_err(|e| e.to_string()); + } + + if raw.get("layout").is_some() { + let legacy = + serde_json::from_value::<LegacyWorkspaceSnapshot>(raw).map_err(|e| e.to_string())?; + return Ok(legacy.into()); + } + + Err("workspace snapshot is neither current nor legacy format".to_string()) +} + +fn legacy_identity_cwd(snap: &LegacyWorkspaceSnapshot) -> PathBuf { + let root_pane = snap + .root_pane + .or_else(|| first_pane_id_in_layout(&snap.layout)); + + root_pane + .and_then(|pane_id| snap.panes.get(&pane_id)) + .map(|pane| pane.cwd.clone()) + .or_else(|| { + first_pane_id_in_layout(&snap.layout) + .and_then(|pane_id| snap.panes.get(&pane_id)) + .map(|pane| pane.cwd.clone()) + }) + .or_else(|| { + snap.panes + .keys() + .min() + .and_then(|pane_id| snap.panes.get(pane_id)) + .map(|pane| pane.cwd.clone()) + }) + .unwrap_or_else(|| std::env::current_dir().unwrap_or_else(|_| "/".into())) +} + +fn first_pane_id_in_layout(layout: &LayoutSnapshot) -> Option<u32> { + match layout { + LayoutSnapshot::Pane(id) => Some(*id), + LayoutSnapshot::Split { first, second, .. } => { + first_pane_id_in_layout(first).or_else(|| first_pane_id_in_layout(second)) + } + } +} + +/// Capture the current app state into a serializable snapshot. +pub fn capture( + workspaces: &[Workspace], + active: Option<usize>, + selected: usize, + agent_panel_scope: crate::app::state::AgentPanelScope, + sidebar_width: u16, + sidebar_section_split: f32, +) -> SessionSnapshot { + SessionSnapshot { + version: SNAPSHOT_VERSION, + workspaces: workspaces.iter().map(capture_workspace).collect(), + active, + selected, + agent_panel_scope, + sidebar_width: Some(sidebar_width), + sidebar_section_split: Some(sidebar_section_split), + } +} + +fn capture_workspace(ws: &Workspace) -> WorkspaceSnapshot { + WorkspaceSnapshot { + id: Some(ws.id.clone()), + custom_name: ws.custom_name.clone(), + identity_cwd: ws + .resolved_identity_cwd() + .unwrap_or_else(|| ws.identity_cwd.clone()), + tabs: ws.tabs.iter().map(capture_tab).collect(), + active_tab: ws.active_tab, + } +} + +fn capture_tab(tab: &crate::workspace::Tab) -> TabSnapshot { + let mut panes = HashMap::new(); + for id in tab.panes.keys() { + let cwd = tab + .cwd_for_pane(*id) + .unwrap_or_else(|| std::env::current_dir().unwrap_or_else(|_| "/".into())); + panes.insert(id.raw(), PaneSnapshot { cwd }); + } + TabSnapshot { + custom_name: tab.custom_name.clone(), + layout: capture_node(tab.layout.root()), + panes, + zoomed: tab.zoomed, + focused: Some(tab.layout.focused().raw()), + root_pane: Some(tab.root_pane.raw()), + } +} + +pub(super) fn capture_node(node: &Node) -> LayoutSnapshot { + match node { + Node::Pane(id) => LayoutSnapshot::Pane(id.raw()), + Node::Split { + direction, + ratio, + first, + second, + } => LayoutSnapshot::Split { + direction: match direction { + Direction::Horizontal => DirectionSnapshot::Horizontal, + Direction::Vertical => DirectionSnapshot::Vertical, + }, + ratio: *ratio, + first: Box::new(capture_node(first)), + second: Box::new(capture_node(second)), + }, + } +} + +pub(super) fn parse_snapshot(content: &str) -> Result<SessionSnapshot, String> { + let raw = serde_json::from_str::<RawSessionSnapshot>(content).map_err(|e| e.to_string())?; + if raw.version > SNAPSHOT_VERSION { + return Err(format!( + "snapshot version {} is newer than supported {}", + raw.version, SNAPSHOT_VERSION + )); + } + migrate_snapshot(raw) +} + +pub(super) fn snapshot_file_version(content: &str) -> Option<u32> { + serde_json::from_str::<RawSessionSnapshot>(content) + .ok() + .map(|raw| raw.version) +} + +#[cfg(test)] +mod tests { + use std::collections::HashMap; + use std::path::PathBuf; + + use ratatui::layout::{Direction, Rect}; + + use super::*; + use crate::app::{state::AgentPanelScope, AppState, Mode}; + use crate::layout::{NavDirection, Node, PaneId}; + use crate::workspace::Workspace; + + fn session_fixture(name: &str) -> &'static str { + match name { + "current-herdr" => { + include_str!("../../tests/fixtures/session/current-herdr-session.json") + } + "current-herdr-dev" => { + include_str!("../../tests/fixtures/session/current-herdr-dev-session.json") + } + "legacy-pre-tabs-v2" => { + include_str!("../../tests/fixtures/session/legacy-pre-tabs-v2.json") + } + other => panic!("unknown session fixture: {other}"), + } + } + + fn state_with_workspaces(names: &[&str]) -> AppState { + let mut state = AppState::test_new(); + state.workspaces = names.iter().map(|name| Workspace::test_new(name)).collect(); + if !state.workspaces.is_empty() { + state.active = Some(0); + state.selected = 0; + state.mode = Mode::Terminal; + } + state + } + + fn capture_from_state(state: &AppState) -> SessionSnapshot { + capture( + &state.workspaces, + state.active, + state.selected, + state.agent_panel_scope, + state.sidebar_width, + state.sidebar_section_split, + ) + } + + fn root_split_ratio(tab: &TabSnapshot) -> Option<f32> { + match &tab.layout { + LayoutSnapshot::Split { ratio, .. } => Some(*ratio), + LayoutSnapshot::Pane(_) => None, + } + } + + #[test] + fn round_trip_empty_session() { + let snap = SessionSnapshot { + version: SNAPSHOT_VERSION, + workspaces: vec![], + active: None, + selected: 0, + agent_panel_scope: AgentPanelScope::CurrentWorkspace, + sidebar_width: Some(26), + sidebar_section_split: Some(0.5), + }; + let json = serde_json::to_string(&snap).unwrap(); + let restored = parse_snapshot(&json).unwrap(); + assert!(restored.workspaces.is_empty()); + assert_eq!(restored.active, None); + assert_eq!(restored.sidebar_width, Some(26)); + assert_eq!(restored.sidebar_section_split, Some(0.5)); + } + + #[test] + fn round_trip_layout_snapshot() { + let layout = LayoutSnapshot::Split { + direction: DirectionSnapshot::Horizontal, + ratio: 0.6, + first: Box::new(LayoutSnapshot::Pane(0)), + second: Box::new(LayoutSnapshot::Split { + direction: DirectionSnapshot::Vertical, + ratio: 0.5, + first: Box::new(LayoutSnapshot::Pane(1)), + second: Box::new(LayoutSnapshot::Pane(2)), + }), + }; + let json = serde_json::to_string(&layout).unwrap(); + let restored: LayoutSnapshot = serde_json::from_str(&json).unwrap(); + + match restored { + LayoutSnapshot::Split { ratio, .. } => assert!((ratio - 0.6).abs() < 0.01), + _ => panic!("expected split"), + } + } + + #[test] + fn round_trip_full_workspace_snapshot() { + let mut panes = HashMap::new(); + panes.insert( + 0, + PaneSnapshot { + cwd: PathBuf::from("/home/can/Projects/herdr"), + }, + ); + panes.insert( + 1, + PaneSnapshot { + cwd: PathBuf::from("/home/can/Projects/website"), + }, + ); + + let snap = SessionSnapshot { + workspaces: vec![WorkspaceSnapshot { + id: Some("wproj".to_string()), + custom_name: Some("pi-mono".to_string()), + identity_cwd: PathBuf::from("/home/can/Projects/herdr"), + tabs: vec![TabSnapshot { + custom_name: Some("api".to_string()), + layout: LayoutSnapshot::Split { + direction: DirectionSnapshot::Horizontal, + ratio: 0.5, + first: Box::new(LayoutSnapshot::Pane(0)), + second: Box::new(LayoutSnapshot::Pane(1)), + }, + panes, + zoomed: false, + focused: Some(0), + root_pane: Some(0), + }], + active_tab: 0, + }], + active: Some(0), + selected: 0, + agent_panel_scope: AgentPanelScope::CurrentWorkspace, + sidebar_width: Some(26), + sidebar_section_split: Some(0.5), + version: SNAPSHOT_VERSION, + }; + + let json = serde_json::to_string_pretty(&snap).unwrap(); + let restored = parse_snapshot(&json).unwrap(); + + assert_eq!(restored.workspaces.len(), 1); + assert_eq!(restored.workspaces[0].id.as_deref(), Some("wproj")); + assert_eq!( + restored.workspaces[0].custom_name.as_deref(), + Some("pi-mono") + ); + assert_eq!(restored.workspaces[0].tabs.len(), 1); + assert_eq!(restored.workspaces[0].tabs[0].panes.len(), 2); + assert_eq!( + restored.workspaces[0].tabs[0].panes[&0].cwd, + PathBuf::from("/home/can/Projects/herdr") + ); + assert_eq!( + restored.agent_panel_scope, + AgentPanelScope::CurrentWorkspace + ); + assert_eq!(restored.sidebar_width, Some(26)); + assert_eq!(restored.sidebar_section_split, Some(0.5)); + } + + #[test] + fn current_session_fixture_parses() { + let snap = parse_snapshot(session_fixture("current-herdr")).unwrap(); + + assert_eq!(snap.version, 3); + assert_eq!(snap.workspaces.len(), 2); + assert_eq!(snap.active, Some(0)); + assert_eq!(snap.selected, 0); + assert_eq!(snap.agent_panel_scope, AgentPanelScope::CurrentWorkspace); + assert_eq!(snap.sidebar_width, None); + assert_eq!(snap.sidebar_section_split, None); + assert_eq!(snap.workspaces[0].tabs.len(), 2); + assert_eq!( + snap.workspaces[1].identity_cwd, + PathBuf::from("/home/test/projects/project-b") + ); + } + + #[test] + fn current_dev_session_fixture_parses_additive_fields() { + let snap = parse_snapshot(session_fixture("current-herdr-dev")).unwrap(); + + assert_eq!(snap.version, 3); + assert_eq!(snap.workspaces.len(), 2); + assert_eq!(snap.agent_panel_scope, AgentPanelScope::CurrentWorkspace); + assert_eq!(snap.sidebar_section_split, Some(0.4)); + assert_eq!(snap.workspaces[0].active_tab, 1); + assert_eq!(snap.workspaces[1].tabs[0].panes.len(), 2); + } + + #[test] + fn old_snapshot_defaults_agent_panel_scope() { + let json = serde_json::json!({ + "version": SNAPSHOT_VERSION, + "workspaces": [], + "active": null, + "selected": 0 + }) + .to_string(); + + let restored = parse_snapshot(&json).unwrap(); + + assert_eq!( + restored.agent_panel_scope, + AgentPanelScope::CurrentWorkspace + ); + assert_eq!(restored.sidebar_width, None); + assert_eq!(restored.sidebar_section_split, None); + } + + #[test] + fn legacy_workspace_snapshot_migrates_to_single_tab() { + let snap = parse_snapshot(session_fixture("legacy-pre-tabs-v2")).unwrap(); + let ws = &snap.workspaces[0]; + + assert_eq!(snap.version, 2); + assert_eq!(snap.workspaces.len(), 1); + assert_eq!(ws.custom_name.as_deref(), Some("legacy")); + assert_eq!(ws.identity_cwd, PathBuf::from("/tmp/pion")); + assert_eq!(ws.active_tab, 0); + assert_eq!(ws.tabs.len(), 1); + assert_eq!(ws.tabs[0].focused, Some(1)); + assert_eq!(ws.tabs[0].root_pane, Some(0)); + assert_eq!(ws.tabs[0].panes[&0].cwd, PathBuf::from("/tmp/pion")); + assert_eq!(ws.tabs[0].panes[&1].cwd, PathBuf::from("/tmp/herdr")); + } + + #[test] + fn capture_contract_tracks_workspace_order_active_and_selected() { + let mut state = state_with_workspaces(&["a", "b", "c"]); + state.active = Some(1); + state.selected = 2; + + state.move_workspace(1, 0); + + let snapshot = capture_from_state(&state); + let ids: Vec<_> = state.workspaces.iter().map(|ws| ws.id.clone()).collect(); + let captured_ids: Vec<_> = snapshot + .workspaces + .iter() + .map(|ws| ws.id.clone().unwrap()) + .collect(); + assert_eq!(captured_ids, ids); + assert_eq!(snapshot.active, state.active); + assert_eq!(snapshot.selected, state.selected); + } + + #[test] + fn capture_contract_tracks_workspace_and_tab_names_and_active_tab() { + let mut state = state_with_workspaces(&["one"]); + state.workspaces[0].set_custom_name("renamed-workspace".into()); + let second_tab = state.workspaces[0].test_add_tab(Some("logs")); + state.workspaces[0].switch_tab(second_tab); + state.workspaces[0].tabs[0].set_custom_name("main".into()); + + let snapshot = capture_from_state(&state); + let workspace = &snapshot.workspaces[0]; + assert_eq!(workspace.custom_name.as_deref(), Some("renamed-workspace")); + assert_eq!(workspace.active_tab, second_tab); + assert_eq!(workspace.tabs[0].custom_name.as_deref(), Some("main")); + assert_eq!(workspace.tabs[1].custom_name.as_deref(), Some("logs")); + } + + #[test] + fn capture_contract_tracks_workspace_closure() { + let mut state = state_with_workspaces(&["one", "two"]); + state.selected = 1; + state.active = Some(1); + + state.close_selected_workspace(); + + let snapshot = capture_from_state(&state); + assert_eq!(snapshot.workspaces.len(), 1); + assert_eq!(snapshot.workspaces[0].custom_name.as_deref(), Some("one")); + assert_eq!(snapshot.active, Some(0)); + assert_eq!(snapshot.selected, 0); + } + + #[test] + fn capture_contract_tracks_sidebar_state() { + let mut state = state_with_workspaces(&["one"]); + state.sidebar_width = 31; + state.sidebar_section_split = 0.4; + state.agent_panel_scope = AgentPanelScope::AllWorkspaces; + + let snapshot = capture_from_state(&state); + assert_eq!(snapshot.sidebar_width, Some(31)); + assert_eq!(snapshot.sidebar_section_split, Some(0.4)); + assert_eq!(snapshot.agent_panel_scope, AgentPanelScope::AllWorkspaces); + } + + #[test] + fn capture_contract_tracks_layout_focus_zoom_and_root_pane() { + let mut state = state_with_workspaces(&["one"]); + let root = state.workspaces[0].tabs[0].root_pane; + let second = state.workspaces[0].test_split(Direction::Horizontal); + state.workspaces[0].tabs[0].layout.focus_pane(second); + state.toggle_fullscreen(); + + let snapshot = capture_from_state(&state); + let tab = &snapshot.workspaces[0].tabs[0]; + assert!(matches!(tab.layout, LayoutSnapshot::Split { .. })); + assert_eq!(tab.focused, Some(second.raw())); + assert_eq!(tab.root_pane, Some(root.raw())); + assert!(tab.zoomed); + assert_eq!(tab.panes.len(), 2); + } + + #[test] + fn capture_contract_tracks_focus_navigation() { + let mut state = state_with_workspaces(&["one"]); + let root = state.workspaces[0].tabs[0].root_pane; + let second = state.workspaces[0].test_split(Direction::Horizontal); + crate::ui::compute_view(&mut state, Rect::new(0, 0, 106, 20)); + + state.navigate_pane(NavDirection::Right); + + let snapshot = capture_from_state(&state); + assert_eq!(snapshot.workspaces[0].tabs[0].focused, Some(second.raw())); + assert_ne!(snapshot.workspaces[0].tabs[0].focused, Some(root.raw())); + } + + #[test] + fn capture_contract_tracks_resize_ratio_changes() { + let mut state = state_with_workspaces(&["one"]); + state.workspaces[0].test_split(Direction::Horizontal); + crate::ui::compute_view(&mut state, Rect::new(0, 0, 106, 20)); + let before = capture_from_state(&state); + + state.resize_pane(NavDirection::Right); + + let after = capture_from_state(&state); + let before_ratio = root_split_ratio(&before.workspaces[0].tabs[0]).unwrap(); + let after_ratio = root_split_ratio(&after.workspaces[0].tabs[0]).unwrap(); + assert_ne!(before_ratio, after_ratio); + } + + #[test] + fn capture_contract_tracks_tab_closure() { + let mut state = state_with_workspaces(&["one"]); + let second_tab = state.workspaces[0].test_add_tab(Some("logs")); + state.switch_tab(second_tab); + + state.close_tab(); + + let snapshot = capture_from_state(&state); + let workspace = &snapshot.workspaces[0]; + assert_eq!(workspace.tabs.len(), 1); + assert_eq!(workspace.active_tab, 0); + assert!(workspace.tabs[0].custom_name.is_none()); + } + + #[test] + fn capture_contract_tracks_pane_closure() { + let mut state = state_with_workspaces(&["one"]); + state.workspaces[0].test_split(Direction::Horizontal); + + state.close_pane(); + + let snapshot = capture_from_state(&state); + let tab = &snapshot.workspaces[0].tabs[0]; + assert_eq!(tab.panes.len(), 1); + assert!(matches!(tab.layout, LayoutSnapshot::Pane(_))); + assert!(!tab.zoomed); + } + + #[test] + fn capture_contract_tracks_workspace_identity_and_pane_cwds() { + let mut state = state_with_workspaces(&["one"]); + let root = state.workspaces[0].tabs[0].root_pane; + state.workspaces[0].tabs[0] + .pane_cwds + .insert(root, PathBuf::from("/tmp/pion")); + let second = state.workspaces[0].test_split(Direction::Horizontal); + state.workspaces[0].tabs[0] + .pane_cwds + .insert(second, PathBuf::from("/tmp/herdr")); + + let snapshot = capture_from_state(&state); + let workspace = &snapshot.workspaces[0]; + let tab = &workspace.tabs[0]; + assert_eq!(workspace.identity_cwd, PathBuf::from("/tmp/pion")); + assert_eq!(tab.panes[&root.raw()].cwd, PathBuf::from("/tmp/pion")); + assert_eq!(tab.panes[&second.raw()].cwd, PathBuf::from("/tmp/herdr")); + } + + #[test] + fn old_unversioned_snapshot_loads_as_version_0() { + let json = r#"{"workspaces":[],"active":null,"selected":0}"#; + let snap = parse_snapshot(json).unwrap(); + assert_eq!(snap.version, 0); + } + + #[test] + fn future_version_is_rejected() { + let json = r#"{"version":999,"workspaces":[],"active":null,"selected":0}"#; + assert!(parse_snapshot(json).is_err()); + } + + #[test] + fn active_tab_default_is_zero() { + let json = r#"{"custom_name":"test","identity_cwd":"/tmp","tabs":[]}"#; + let ws: WorkspaceSnapshot = serde_json::from_str(json).unwrap(); + assert_eq!(ws.active_tab, 0); + } + + #[test] + fn restore_falls_back_to_home_when_cwd_missing() { + let mut panes = HashMap::new(); + panes.insert( + 0, + PaneSnapshot { + cwd: PathBuf::from("/tmp/this-directory-does-not-exist-for-herdr-test"), + }, + ); + panes.insert( + 1, + PaneSnapshot { + cwd: std::env::var("HOME") + .map(PathBuf::from) + .unwrap_or_else(|_| PathBuf::from("/tmp")), + }, + ); + + let snap = SessionSnapshot { + version: SNAPSHOT_VERSION, + workspaces: vec![WorkspaceSnapshot { + id: Some("test-ws".to_string()), + custom_name: Some("fallback test".to_string()), + identity_cwd: PathBuf::from("/tmp"), + tabs: vec![TabSnapshot { + custom_name: None, + layout: LayoutSnapshot::Split { + direction: DirectionSnapshot::Horizontal, + ratio: 0.5, + first: Box::new(LayoutSnapshot::Pane(0)), + second: Box::new(LayoutSnapshot::Pane(1)), + }, + panes, + zoomed: false, + focused: Some(0), + root_pane: Some(0), + }], + active_tab: 0, + }], + active: Some(0), + selected: 0, + agent_panel_scope: AgentPanelScope::CurrentWorkspace, + sidebar_width: Some(26), + sidebar_section_split: Some(0.5), + }; + + let json = serde_json::to_string(&snap).unwrap(); + let restored = parse_snapshot(&json).unwrap(); + assert_eq!(restored.workspaces.len(), 1); + assert_eq!( + restored.workspaces[0].tabs[0].panes[&0].cwd, + PathBuf::from("/tmp/this-directory-does-not-exist-for-herdr-test") + ); + } +} diff --git a/src/platform/linux.rs b/src/platform/linux.rs index f95c7418..dc944cd9 100644 --- a/src/platform/linux.rs +++ b/src/platform/linux.rs @@ -217,9 +217,16 @@ fn process_session_id(pid: u32) -> Option<i32> { #[cfg(test)] mod tests { use super::*; + use std::sync::{Mutex, OnceLock}; + + fn env_lock() -> &'static Mutex<()> { + static LOCK: OnceLock<Mutex<()>> = OnceLock::new(); + LOCK.get_or_init(|| Mutex::new(())) + } #[test] fn clipboard_commands_prefer_wayland_when_available() { + let _guard = env_lock().lock().unwrap(); unsafe { std::env::set_var("WAYLAND_DISPLAY", "wayland-0"); std::env::remove_var("DISPLAY"); @@ -231,6 +238,7 @@ mod tests { #[test] fn clipboard_commands_include_x11_fallbacks() { + let _guard = env_lock().lock().unwrap(); unsafe { std::env::remove_var("WAYLAND_DISPLAY"); std::env::set_var("DISPLAY", ":0"); diff --git a/src/raw_input.rs b/src/raw_input.rs index 262721c8..a98cf25d 100644 --- a/src/raw_input.rs +++ b/src/raw_input.rs @@ -2,6 +2,113 @@ use std::io::Read; use crossterm::event::{KeyModifiers, MouseButton, MouseEvent, MouseEventKind}; +/// Parse raw terminal input bytes into a list of `RawInputEvent`s. +/// +/// This is used by the headless server to route client input through the +/// same parsing pipeline that the monolithic binary uses for stdin. +/// Incomplete sequences at the end of the buffer are flushed as best-effort +/// (same logic as the live input reader). +#[allow(dead_code)] +pub fn parse_raw_input_bytes(data: &[u8]) -> Vec<RawInputEvent> { + // Delegate to the sync version which actually works. + parse_raw_input_bytes_sync(data) +} + +/// A raw input event paired with the byte range it consumed from the original buffer. +#[cfg(test)] +#[derive(Debug)] +pub struct RawInputEventWithRange { + /// The parsed event. + pub event: RawInputEvent, + /// Byte offset where this event starts in the original buffer. + pub start: usize, + /// Number of bytes this event consumed from the original buffer. + /// For events generated from flushed incomplete bytes, `len` may be 0 + /// (synthetic events that don't map to original bytes). + pub len: usize, +} + +/// Parse raw terminal input bytes into a list of `RawInputEventWithRange`s (synchronous version). +/// +/// Unlike `parse_raw_input_bytes_sync`, this preserves the byte offset for each +/// event, allowing callers to write only the specific bytes for each event +/// instead of the entire input buffer. +#[cfg(test)] +pub fn parse_raw_input_bytes_with_ranges(data: &[u8]) -> Vec<RawInputEventWithRange> { + let mut buffer = data.to_vec(); + let mut events = Vec::new(); + let mut offset = 0usize; + + loop { + let Some((event, consumed)) = extract_one_event(&buffer) else { + break; + }; + buffer.drain(..consumed); + events.push(RawInputEventWithRange { + event, + start: offset, + len: consumed, + }); + offset += consumed; + } + + // Flush remaining incomplete bytes. + if !buffer.is_empty() { + if buffer.as_slice() == [ESC] { + events.push(RawInputEventWithRange { + event: RawInputEvent::Key(TerminalKey::new( + crossterm::event::KeyCode::Esc, + KeyModifiers::empty(), + )), + start: offset, + len: 1, + }); + } else if let Ok(text) = std::str::from_utf8(&buffer) { + if let Some(key) = parse_terminal_key_sequence(text) { + events.push(RawInputEventWithRange { + event: RawInputEvent::Key(key), + start: offset, + len: buffer.len(), + }); + } + } + } + + events +} + +/// Parse raw terminal input bytes into a list of `RawInputEvent`s (synchronous version). +/// +/// Unlike `parse_raw_input_bytes`, this directly extracts events without +/// going through a channel, making it suitable for synchronous use. +pub fn parse_raw_input_bytes_sync(data: &[u8]) -> Vec<RawInputEvent> { + let mut buffer = data.to_vec(); + let mut events = Vec::new(); + + loop { + let Some((event, consumed)) = extract_one_event(&buffer) else { + break; + }; + buffer.drain(..consumed); + events.push(event); + } + + if !buffer.is_empty() { + if buffer.as_slice() == [ESC] { + events.push(RawInputEvent::Key(TerminalKey::new( + crossterm::event::KeyCode::Esc, + KeyModifiers::empty(), + ))); + } else if let Ok(text) = std::str::from_utf8(&buffer) { + if let Some(key) = parse_terminal_key_sequence(text) { + events.push(RawInputEvent::Key(key)); + } + } + } + + events +} + #[cfg(unix)] use std::os::fd::AsRawFd; use tokio::sync::mpsc; @@ -54,30 +161,56 @@ pub fn spawn_input_reader() -> mpsc::Receiver<RawInputEvent> { } fn drain_buffer(buffer: &mut Vec<u8>, tx: &mpsc::Sender<RawInputEvent>) { + for bytes in drain_complete_input_bytes(buffer) { + let Some((event, _consumed)) = extract_one_event(&bytes) else { + continue; + }; + tracing::debug!(raw_bytes = ?bytes, event = ?event, "raw input event parsed"); + let _ = tx.blocking_send(event); + } +} + +pub(crate) fn drain_complete_input_bytes(buffer: &mut Vec<u8>) -> Vec<Vec<u8>> { + let mut chunks = Vec::new(); + loop { - let Some((event, consumed)) = extract_one_event(buffer) else { + let Some((_event, consumed)) = extract_one_event(buffer) else { break; }; - tracing::debug!( - raw_bytes = ?&buffer[..consumed], - event = ?event, - "raw input event parsed" - ); + chunks.push(buffer[..consumed].to_vec()); buffer.drain(..consumed); - let _ = tx.blocking_send(event); } + + chunks } fn flush_incomplete_buffer(buffer: &mut Vec<u8>, tx: &mpsc::Sender<RawInputEvent>) { + if let Some(bytes) = flush_incomplete_input_bytes(buffer) { + if bytes.as_slice() == [ESC] { + let _ = tx.blocking_send(RawInputEvent::Key(TerminalKey::new( + crossterm::event::KeyCode::Esc, + KeyModifiers::empty(), + ))); + return; + } + + let Some((event, _consumed)) = extract_one_event(&bytes) else { + return; + }; + let _ = tx.blocking_send(event); + } +} + +pub(crate) fn flush_incomplete_input_bytes(buffer: &mut Vec<u8>) -> Option<Vec<u8>> { if buffer.is_empty() { - return; + return None; } if buffer.starts_with(BRACKETED_PASTE_START) && find_subsequence(buffer, BRACKETED_PASTE_END).is_none() { tracing::trace!(len = buffer.len(), "waiting for bracketed paste terminator"); - return; + return None; } if buffer.as_slice() == [ESC] { @@ -85,24 +218,18 @@ fn flush_incomplete_buffer(buffer: &mut Vec<u8>, tx: &mpsc::Sender<RawInputEvent bytes = ?buffer, "flushing lone escape after input timeout; if this follows an alt chord or focus switch it may reach the pane as plain esc" ); - let _ = tx.blocking_send(RawInputEvent::Key(TerminalKey::new( - crossterm::event::KeyCode::Esc, - KeyModifiers::empty(), - ))); - buffer.clear(); - return; + return Some(std::mem::take(buffer)); } if let Ok(text) = std::str::from_utf8(buffer) { - if let Some(key) = parse_terminal_key_sequence(text) { - let _ = tx.blocking_send(RawInputEvent::Key(key)); - buffer.clear(); - return; + if parse_terminal_key_sequence(text).is_some() { + return Some(std::mem::take(buffer)); } } tracing::debug!(bytes = ?buffer, "dropping incomplete raw input buffer after timeout"); buffer.clear(); + None } #[cfg(unix)] @@ -790,4 +917,78 @@ mod tests { KeyModifiers::empty(), ); } + + #[test] + fn parse_with_ranges_tracks_byte_offsets() { + use super::parse_raw_input_bytes_with_ranges; + + // Input: Up arrow (3 bytes) + 'a' (1 byte) + Down arrow (3 bytes) + let input = b"\x1b[Aa\x1b[B".to_vec(); + let ranges = parse_raw_input_bytes_with_ranges(&input); + + assert_eq!(ranges.len(), 3, "should parse three events"); + + // Up arrow: \x1b[A at offset 0, length 3 + assert_eq!(ranges[0].start, 0); + assert_eq!(ranges[0].len, 3); + assert!(matches!( + &ranges[0].event, + RawInputEvent::Key(k) if k.code == KeyCode::Up + )); + + // 'a' at offset 3, length 1 + assert_eq!(ranges[1].start, 3); + assert_eq!(ranges[1].len, 1); + assert!(matches!( + &ranges[1].event, + RawInputEvent::Key(k) if k.code == KeyCode::Char('a') + )); + + // Down arrow: \x1b[B at offset 4, length 3 + assert_eq!(ranges[2].start, 4); + assert_eq!(ranges[2].len, 3); + assert!(matches!( + &ranges[2].event, + RawInputEvent::Key(k) if k.code == KeyCode::Down + )); + + // Verify the raw bytes for each event slice correctly. + assert_eq!( + &input[ranges[0].start..ranges[0].start + ranges[0].len], + b"\x1b[A" + ); + assert_eq!( + &input[ranges[1].start..ranges[1].start + ranges[1].len], + b"a" + ); + assert_eq!( + &input[ranges[2].start..ranges[2].start + ranges[2].len], + b"\x1b[B" + ); + } + + #[test] + fn parse_with_ranges_handles_single_event() { + use super::parse_raw_input_bytes_with_ranges; + + let input = b"a".to_vec(); + let ranges = parse_raw_input_bytes_with_ranges(&input); + + assert_eq!(ranges.len(), 1); + assert_eq!(ranges[0].start, 0); + assert_eq!(ranges[0].len, 1); + } + + #[test] + fn parse_with_ranges_handles_mouse_event() { + use super::parse_raw_input_bytes_with_ranges; + + let input = b"\x1b[<0;20;10M".to_vec(); + let ranges = parse_raw_input_bytes_with_ranges(&input); + + assert_eq!(ranges.len(), 1); + assert_eq!(ranges[0].start, 0); + assert_eq!(ranges[0].len, input.len()); + assert!(matches!(&ranges[0].event, RawInputEvent::Mouse(_))); + } } diff --git a/src/selection.rs b/src/selection.rs index 9d29b08e..6b2fc093 100644 --- a/src/selection.rs +++ b/src/selection.rs @@ -11,7 +11,7 @@ //! coordinates. That keeps selection stable while the pane scrolls. use ratatui::layout::Rect; -use std::io::Write; +use std::{ffi::OsStr, io::Write}; use crate::{layout::PaneId, pane::ScrollMetrics}; @@ -171,6 +171,17 @@ fn osc52_sequence(bytes: &[u8]) -> String { format!("\x1b]52;c;{encoded}\x07") } +fn should_prefer_osc52_for_env(ssh_connection: Option<&OsStr>, ssh_tty: Option<&OsStr>) -> bool { + ssh_connection.is_some() || ssh_tty.is_some() +} + +fn should_prefer_osc52() -> bool { + should_prefer_osc52_for_env( + std::env::var_os("SSH_CONNECTION").as_deref(), + std::env::var_os("SSH_TTY").as_deref(), + ) +} + /// Write clipboard bytes to the system clipboard via OSC 52. /// /// OSC 52 format: `ESC ] 52 ; c ; <base64> BEL` @@ -178,7 +189,7 @@ fn osc52_sequence(bytes: &[u8]) -> String { /// Some terminals still only honor BEL-terminated OSC 52 writes, so herdr /// emits BEL here even though ST works in newer emulators. pub fn write_osc52_bytes(bytes: &[u8]) { - if crate::platform::write_clipboard(bytes) { + if !should_prefer_osc52() && crate::platform::write_clipboard(bytes) { return; } @@ -187,11 +198,6 @@ pub fn write_osc52_bytes(bytes: &[u8]) { let _ = std::io::stdout().flush(); } -/// Write text to the system clipboard via OSC 52. -pub fn write_osc52(text: &str) { - write_osc52_bytes(text.as_bytes()); -} - #[cfg(test)] mod tests { use super::*; @@ -210,6 +216,19 @@ mod tests { } #[test] + fn ssh_sessions_prefer_osc52() { + assert!(should_prefer_osc52_for_env( + Some(OsStr::new("1 2 3 4")), + None + )); + assert!(should_prefer_osc52_for_env( + None, + Some(OsStr::new("/dev/ttys001")) + )); + assert!(!should_prefer_osc52_for_env(None, None)); + } + + #[test] fn ordering_forward() { let sel = make_sel(2, 5, 4, 10); assert_eq!(sel.ordered(), ((2, 5), (4, 10))); diff --git a/src/server/autodetect.rs b/src/server/autodetect.rs new file mode 100644 index 00000000..b0ca2a2e --- /dev/null +++ b/src/server/autodetect.rs @@ -0,0 +1,296 @@ +//! Auto-detect launch behavior for the `herdr` command. +//! +//! When the user runs `herdr` with no subcommand: +//! 1. Check if a server is already listening on the client socket +//! 2. If no server → spawn one as a background daemon → wait for socket readiness (up to 5s) +//! 3. Attach as a thin client to the server +//! +//! The `--no-session` flag bypasses server/client entirely and runs monolithically +//! (escape hatch for users who want the traditional single-process behavior). + +use std::io; +use std::os::unix::net::UnixStream; +use std::os::unix::process::CommandExt; +use std::path::Path; +use std::process::Command; +use std::time::Duration; + +use tracing::{info, warn}; + +use super::headless::client_socket_path; + +/// Maximum time to wait for the server's client socket to become ready +/// after spawning the server process. +const SERVER_READY_TIMEOUT: Duration = Duration::from_secs(5); + +/// Poll interval when waiting for the server socket to appear. +const SOCKET_POLL_INTERVAL: Duration = Duration::from_millis(50); + +// --------------------------------------------------------------------------- +// Server detection +// --------------------------------------------------------------------------- + +/// Checks whether a herdr server is currently listening on the client socket. +/// +/// This works by attempting to connect to the client socket. If the connection +/// succeeds, a server is running. If the socket file doesn't exist or the +/// connection is refused, no server is running. Stale sockets (from a crashed +/// server) are detected because `UnixStream::connect` returns `ConnectionRefused` +/// when nobody is listening. +#[allow(dead_code)] // Public API for external use and testing +pub fn is_server_listening() -> bool { + is_server_listening_at(&client_socket_path()) +} + +/// Checks whether a herdr server is listening at a specific socket path. +fn is_server_listening_at(socket_path: &Path) -> bool { + if !socket_path.exists() { + return false; + } + + match UnixStream::connect(socket_path) { + Ok(_) => { + // Server is listening. Close the test connection immediately. + // The server's handshake handler will time out on this connection + // since we don't send Hello, which is fine. + true + } + Err(err) + if matches!( + err.kind(), + io::ErrorKind::ConnectionRefused | io::ErrorKind::TimedOut + ) => + { + // Socket file exists but nobody is listening — stale socket. + false + } + Err(err) if err.kind() == io::ErrorKind::NotFound => { + // Socket file disappeared between exists() and connect(). + false + } + Err(err) => { + // Other errors (permission denied, etc.) — assume not listening. + warn!(err = %err, "unexpected error checking server socket"); + false + } + } +} + +// --------------------------------------------------------------------------- +// Server spawning +// --------------------------------------------------------------------------- + +/// Spawns the herdr server as a background daemon process. +/// +/// The server process is fully detached: +/// - Runs in its own session (setsid) so it survives the client exiting +/// - Stdin/stdout/stderr are redirected to /dev/null +/// - Inherits all relevant environment variables +/// (`HERDR_SOCKET_PATH`, `HERDR_CLIENT_SOCKET_PATH`, `XDG_CONFIG_HOME`, etc.) +/// +/// Returns the PID of the spawned server process. +pub fn spawn_server_daemon() -> io::Result<u32> { + let exe = std::env::current_exe().map_err(|err| { + io::Error::new( + err.kind(), + format!("failed to determine herdr executable path: {err}"), + ) + })?; + + info!(exe = %exe.display(), "spawning server daemon"); + + let child = Command::new(&exe) + .arg("server") + // Create a new process group so the server survives the parent's exit + // and doesn't receive SIGHUP when the client's terminal closes. + .process_group(0) + // Redirect stdio to /dev/null + .stdin(std::process::Stdio::null()) + .stdout(std::process::Stdio::null()) + .stderr(std::process::Stdio::null()) + .spawn() + .map_err(|err: io::Error| { + io::Error::new(err.kind(), format!("failed to spawn herdr server: {err}")) + })?; + + let pid = child.id(); + info!(pid, "server daemon spawned"); + + Ok(pid) +} + +// --------------------------------------------------------------------------- +// Socket readiness +// --------------------------------------------------------------------------- + +/// Waits for the server's client socket to become ready for connections. +/// +/// Polls the socket path at regular intervals until a connection succeeds +/// or the timeout elapses. Returns an error if the server doesn't become +/// ready within the timeout. +pub fn wait_for_server_socket(socket_path: &Path, timeout: Duration) -> io::Result<()> { + let deadline = std::time::Instant::now() + timeout; + + while std::time::Instant::now() < deadline { + if is_server_listening_at(socket_path) { + info!(path = %socket_path.display(), "server socket ready"); + return Ok(()); + } + std::thread::sleep(SOCKET_POLL_INTERVAL); + } + + Err(io::Error::new( + io::ErrorKind::TimedOut, + format!( + "server did not become ready within {}s (socket: {})", + timeout.as_secs(), + socket_path.display() + ), + )) +} + +// --------------------------------------------------------------------------- +// Auto-detect launch +// --------------------------------------------------------------------------- + +/// Performs auto-detect launch: check for server, spawn if needed, then +/// attach as a thin client. +/// +/// This is the entry point called from `main.rs` when the user runs `herdr` +/// without `--no-session` and without a subcommand. +/// +/// Flow: +/// 1. Check if a server is listening on the client socket +/// 2. If no server → spawn server daemon → wait for socket readiness +/// 3. Run the thin client (which connects to the server) +pub fn auto_detect_launch() -> io::Result<()> { + let socket_path = client_socket_path(); + info!(path = %socket_path.display(), "auto-detect launch starting"); + + if is_server_listening_at(&socket_path) { + info!("server already running, attaching as client"); + } else { + info!("no server running, spawning server daemon"); + spawn_server_daemon()?; + wait_for_server_socket(&socket_path, SERVER_READY_TIMEOUT)?; + info!("server ready, attaching as client"); + } + + // Now attach as a thin client. + crate::client::run_client() +} + +// --------------------------------------------------------------------------- +// Tests +// --------------------------------------------------------------------------- + +#[cfg(test)] +mod tests { + use super::*; + use std::os::unix::net::UnixListener; + + fn temp_socket_path(name: &str) -> std::path::PathBuf { + let unique = format!( + "herdr-autodetect-test-{}-{}-{}", + name, + std::process::id(), + std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .unwrap() + .as_nanos() + ); + std::env::temp_dir().join(unique).join("test.sock") + } + + #[test] + fn is_server_listening_returns_false_for_nonexistent_path() { + let path = temp_socket_path("nonexistent"); + assert!(!is_server_listening_at(&path)); + } + + #[test] + fn is_server_listening_returns_true_for_live_socket() { + let dir = temp_socket_path("live"); + std::fs::create_dir_all(&dir).unwrap(); + let path = dir.join("test.sock"); + + let _listener = UnixListener::bind(&path).unwrap(); + assert!(is_server_listening_at(&path)); + } + + #[test] + fn is_server_listening_returns_false_for_stale_socket() { + let dir = temp_socket_path("stale"); + std::fs::create_dir_all(&dir).unwrap(); + let path = dir.join("test.sock"); + + // Create a socket and immediately drop the listener. + // This leaves a stale socket file with nobody listening. + { + let _listener = UnixListener::bind(&path).unwrap(); + } + + // The socket file exists but nobody is listening. + assert!(!is_server_listening_at(&path)); + } + + #[test] + fn is_server_listening_returns_false_when_listener_dropped() { + let dir = temp_socket_path("dropped"); + std::fs::create_dir_all(&dir).unwrap(); + let path = dir.join("test.sock"); + + // Bind and immediately drop the listener. + drop(UnixListener::bind(&path).unwrap()); + + // Socket is stale — should return false. + assert!(!is_server_listening_at(&path)); + + let _ = std::fs::remove_dir_all(dir); + } + + #[test] + fn wait_for_server_socket_succeeds_immediately() { + let dir = temp_socket_path("wait-ok"); + std::fs::create_dir_all(&dir).unwrap(); + let path = dir.join("test.sock"); + + let _listener = UnixListener::bind(&path).unwrap(); + + // Should succeed immediately (socket is already ready). + let result = wait_for_server_socket(&path, Duration::from_millis(100)); + assert!(result.is_ok()); + } + + #[test] + fn wait_for_server_socket_times_out() { + let dir = temp_socket_path("wait-timeout"); + std::fs::create_dir_all(&dir).unwrap(); + let path = dir.join("test.sock"); + + // No listener — should time out. + let result = wait_for_server_socket(&path, Duration::from_millis(50)); + assert!(result.is_err()); + assert_eq!(result.unwrap_err().kind(), io::ErrorKind::TimedOut); + } + + #[test] + fn wait_for_server_socket_succeeds_after_delay() { + let dir = temp_socket_path("wait-delay"); + std::fs::create_dir_all(&dir).unwrap(); + let path = dir.join("test.sock"); + + // Spawn a thread that will create the listener after a short delay. + let path_clone = path.clone(); + std::thread::spawn(move || { + std::thread::sleep(Duration::from_millis(50)); + let _listener = UnixListener::bind(&path_clone).unwrap(); + // Keep the listener alive for a bit. + std::thread::sleep(Duration::from_secs(1)); + }); + + // Wait with a generous timeout — should succeed. + let result = wait_for_server_socket(&path, Duration::from_secs(2)); + assert!(result.is_ok()); + } +} diff --git a/src/server/headless.rs b/src/server/headless.rs new file mode 100644 index 00000000..ba6098df --- /dev/null +++ b/src/server/headless.rs @@ -0,0 +1,2272 @@ +//! Headless server mode — runs the herdr event loop without a real terminal. +//! +//! The server: +//! - Does not enter raw mode or read stdin +//! - Creates and listens on both `herdr.sock` (existing JSON API) and +//! `herdr-client.sock` (new binary protocol) +//! - Initializes AppState and all PTYs from session restore or fresh state +//! - Runs the main event loop (drain events, drain API requests, scheduled tasks) +//! - Renders to a virtual ratatui Buffer in memory +//! - Accepts client connections on the client socket +//! - Streams frames to connected clients after each render +//! - Routes client input events through the existing input pipeline +//! - Continues running after client disconnect +//! - Handles stale socket cleanup, explicit server stop, minimum terminal size, +//! and pane spawn failure during restore + +use std::collections::HashMap; +use std::fs; +use std::io::{self, Write}; +use std::os::unix::net::{UnixListener, UnixStream}; +use std::path::{Path, PathBuf}; +use std::sync::atomic::{AtomicBool, Ordering}; +use std::sync::Arc; +use std::time::{Duration, Instant}; + +use ratatui::backend::{Backend, ClearType, TestBackend, WindowSize}; +use ratatui::layout::{Position, Rect, Size}; +use tokio::sync::mpsc; +use tracing::{debug, error, info, warn}; + +use base64::Engine; + +use crate::api; +use crate::app; +use crate::app::state::AppState; +use crate::config; +use crate::events::AppEvent; +use crate::server::protocol::{ + self, ClientMessage, CursorState, FrameData, ServerMessage, MAX_FRAME_SIZE, PROTOCOL_VERSION, +}; + +// --------------------------------------------------------------------------- +// Loop event enum for the headless server event loop +// --------------------------------------------------------------------------- + +/// Events that the headless server event loop can process. +enum LoopEvent { + Timer, + Internal(AppEvent), + Api(api::ApiRequestMessage), + ServerEvent(ServerEvent), + RenderRequested, +} + +// --------------------------------------------------------------------------- +// Constants +// --------------------------------------------------------------------------- + +/// Default shared runtime size (columns, rows) when no clients are attached. +const MIN_COLS: u16 = 80; +const MIN_ROWS: u16 = 24; + +/// Minimum accepted attached client size. +/// +/// Narrow observers must be allowed to drive narrow renders, otherwise the +/// server wraps pane content against a wider width and the client sees the +/// right edge clipped. +const MIN_CLIENT_COLS: u16 = 1; +const MIN_CLIENT_ROWS: u16 = 1; + +/// Legacy environment variable for overriding the client socket path. +/// +/// Contractual override behavior for auto-detect uses `HERDR_SOCKET_PATH`. +/// This variable is kept as a fallback for callers that explicitly need a +/// client-only override when `HERDR_SOCKET_PATH` is not set. +const CLIENT_SOCKET_PATH_ENV_VAR: &str = "HERDR_CLIENT_SOCKET_PATH"; + +/// Socket permission mode (owner read/write only). +const SOCKET_PERMISSION_MODE: u32 = 0o600; + +/// Timeout for in-flight API requests during shutdown. +#[allow(dead_code)] +const SHUTDOWN_API_TIMEOUT: Duration = Duration::from_secs(5); + +/// How long to wait for a client handshake before closing the connection. +/// Set to 4 seconds (rather than 5) to guarantee the connection is closed +/// within the 5-second deadline, even with +/// OS timer slack, thread scheduling, and cleanup overhead. +const HANDSHAKE_TIMEOUT: Duration = Duration::from_secs(4); + +/// Maximum input payload size (bytes) for a single `ClientMessage::Input`. +const MAX_INPUT_PAYLOAD: usize = 1024 * 1024; // 1 MB + +// --------------------------------------------------------------------------- +// Socket path helpers +// --------------------------------------------------------------------------- + +/// Returns the path for the client protocol socket. +/// +/// Contract-aligned override behavior: +/// 1. If `HERDR_SOCKET_PATH` is set, derive the client socket path from it by +/// inserting `-client` before `.sock` (e.g. `herdr.sock` -> `herdr-client.sock`). +/// This keeps JSON API and client socket overrides consistent. +/// 2. Otherwise, honor `HERDR_CLIENT_SOCKET_PATH` (legacy/testing fallback). +/// 3. Otherwise, use the app config directory. +pub fn client_socket_path() -> PathBuf { + client_socket_path_from_overrides( + std::env::var(api::SOCKET_PATH_ENV_VAR).ok().as_deref(), + std::env::var(CLIENT_SOCKET_PATH_ENV_VAR).ok().as_deref(), + ) +} + +fn client_socket_path_from_overrides( + api_socket_override: Option<&str>, + client_socket_override: Option<&str>, +) -> PathBuf { + if let Some(api_socket_override) = api_socket_override { + return derive_client_socket_from_api_socket(Path::new(api_socket_override)); + } + + if let Some(client_socket_override) = client_socket_override { + return PathBuf::from(client_socket_override); + } + + config::config_dir().join("herdr-client.sock") +} + +fn derive_client_socket_from_api_socket(api_socket_path: &Path) -> PathBuf { + let stem = api_socket_path + .file_stem() + .and_then(|s| s.to_str()) + .unwrap_or("herdr"); + let parent = api_socket_path.parent().unwrap_or_else(|| Path::new("")); + + if api_socket_path + .extension() + .and_then(|ext| ext.to_str()) + .is_some_and(|ext| ext == "sock") + { + return parent.join(format!("{stem}-client.sock")); + } + + parent.join(format!("{stem}-client.sock")) +} + +/// Clamp client-reported terminal dimensions to a minimum viable size. +pub fn clamp_terminal_size(cols: u16, rows: u16) -> (u16, u16) { + let clamped_cols = cols.max(MIN_CLIENT_COLS); + let clamped_rows = rows.max(MIN_CLIENT_ROWS); + (clamped_cols, clamped_rows) +} + +// --------------------------------------------------------------------------- +// Connected client state +// --------------------------------------------------------------------------- + +/// A connected client tracked by the server. +struct ClientConnection { + /// The client's terminal size (after clamping). + terminal_size: (u16, u16), + /// Last known host terminal default colors for this client. + host_terminal_theme: crate::terminal_theme::TerminalTheme, + /// Monotonic activity stamp used to choose the fallback foreground client. + last_activity: u64, + /// Channel for sending framed ServerMessage data to the client writer thread. + writer: Option<std::sync::mpsc::Sender<Vec<u8>>>, +} + +// --------------------------------------------------------------------------- +// Stale socket cleanup +// --------------------------------------------------------------------------- + +/// Prepares a socket path for binding: creates parent directories, +/// removes stale socket files (where no server is listening), and +/// returns an error if a live server is already bound. +fn prepare_socket_path(path: &Path) -> io::Result<()> { + crate::ipc::prepare_socket_path(path, |path| { + format!( + "herdr server is already running (socket busy at {})", + path.display() + ) + }) +} + +/// Restricts socket file permissions to owner-only (0o600). +fn restrict_socket_permissions(path: &Path) -> io::Result<()> { + crate::ipc::restrict_socket_permissions(path, SOCKET_PERMISSION_MODE) +} + +// --------------------------------------------------------------------------- +// Virtual rendering +// --------------------------------------------------------------------------- + +struct CursorTrackingBackend { + inner: TestBackend, + rendered_cursor: Option<Position>, +} + +impl CursorTrackingBackend { + fn new(width: u16, height: u16) -> Self { + Self { + inner: TestBackend::new(width, height), + rendered_cursor: None, + } + } + + fn buffer(&self) -> &ratatui::buffer::Buffer { + self.inner.buffer() + } + + fn rendered_cursor(&self) -> Option<CursorState> { + self.rendered_cursor.map(|pos| CursorState { + x: pos.x, + y: pos.y, + visible: true, + }) + } +} + +impl Backend for CursorTrackingBackend { + type Error = std::convert::Infallible; + + fn draw<'a, I>(&mut self, content: I) -> Result<(), Self::Error> + where + I: Iterator<Item = (u16, u16, &'a ratatui::buffer::Cell)>, + { + self.inner.draw(content) + } + + fn append_lines(&mut self, n: u16) -> Result<(), Self::Error> { + self.inner.append_lines(n) + } + + fn hide_cursor(&mut self) -> Result<(), Self::Error> { + self.inner.hide_cursor()?; + self.rendered_cursor = None; + Ok(()) + } + + fn show_cursor(&mut self) -> Result<(), Self::Error> { + self.inner.show_cursor() + } + + fn get_cursor_position(&mut self) -> Result<Position, Self::Error> { + self.inner.get_cursor_position() + } + + fn set_cursor_position<P: Into<Position>>(&mut self, position: P) -> Result<(), Self::Error> { + let position = position.into(); + self.inner.set_cursor_position(position)?; + self.rendered_cursor = Some(position); + Ok(()) + } + + fn clear(&mut self) -> Result<(), Self::Error> { + self.inner.clear() + } + + fn clear_region(&mut self, clear_type: ClearType) -> Result<(), Self::Error> { + self.inner.clear_region(clear_type) + } + + fn size(&self) -> Result<Size, Self::Error> { + self.inner.size() + } + + fn window_size(&mut self) -> Result<WindowSize, Self::Error> { + self.inner.window_size() + } + + fn flush(&mut self) -> Result<(), Self::Error> { + self.inner.flush() + } +} + +/// Renders the AppState to an in-memory ratatui Buffer. +/// +/// This produces the same output as the monolithic binary's terminal draw, +/// but writes to a `Buffer` instead of stdout. Cursor visibility is captured +/// from explicit frame cursor intent rather than incidental backend state. +fn render_virtual( + app_state: &mut AppState, + area: Rect, + resize_panes: bool, +) -> (ratatui::buffer::Buffer, Option<CursorState>) { + if resize_panes { + crate::ui::compute_view(app_state, area); + } else { + crate::ui::compute_view_without_resizing_panes(app_state, area); + } + + let backend = CursorTrackingBackend::new(area.width, area.height); + let mut terminal = ratatui::Terminal::new(backend).expect("TestBackend::new should never fail"); + + terminal + .draw(|frame| { + crate::ui::render(app_state, frame); + }) + .expect("render to TestBackend should never fail"); + + let buffer = terminal.backend().buffer().clone(); + let cursor = terminal.backend().rendered_cursor(); + + (buffer, cursor) +} + +// --------------------------------------------------------------------------- +// Headless server +// --------------------------------------------------------------------------- + +/// The headless server — runs the herdr event loop without a real terminal. +pub struct HeadlessServer { + app: app::App, + client_listener: UnixListener, + client_socket_path: PathBuf, + clients: HashMap<u64, ClientConnection>, + next_client_id: u64, + /// The client currently driving the shared pane runtime size and theme. + foreground_client_id: Option<u64>, + /// Monotonic activity counter used to pick the most recently active client. + next_activity_stamp: u64, + /// Shared pane runtime size derived from the foreground client, + /// or MIN_COLS × MIN_ROWS when no clients are connected. + effective_size: (u16, u16), + /// Flag set when shutdown is initiated. + shutting_down: bool, + /// Flag set by Ctrl+C or `server stop` signal. + should_quit: Arc<AtomicBool>, + /// Channel for receiving server events from client connection threads. + server_event_rx: mpsc::Receiver<ServerEvent>, + /// Sender for server events (cloned for each client thread). + server_event_tx: mpsc::Sender<ServerEvent>, +} + +impl HeadlessServer { + /// Creates and starts the headless server. + /// + /// This: + /// 1. Prepares the client socket path (cleans up stale sockets) + /// 2. Binds the client socket listener + /// 3. Returns the server ready to run + pub fn new(app: app::App) -> io::Result<Self> { + let client_path = client_socket_path(); + prepare_socket_path(&client_path)?; + + let listener = UnixListener::bind(&client_path)?; + restrict_socket_permissions(&client_path)?; + info!(path = %client_path.display(), "client protocol socket listening"); + + // Set non-blocking on the listener so we can poll it from the event loop. + listener.set_nonblocking(true)?; + + let should_quit = Arc::new(AtomicBool::new(false)); + + // Channel for server events from client threads. + let (server_event_tx, server_event_rx) = mpsc::channel(64); + + Ok(Self { + app, + client_listener: listener, + client_socket_path: client_path, + clients: HashMap::new(), + next_client_id: 1, + foreground_client_id: None, + next_activity_stamp: 1, + effective_size: (MIN_COLS, MIN_ROWS), + shutting_down: false, + should_quit, + server_event_rx, + server_event_tx, + }) + } + + /// Runs the headless server event loop until shutdown. + /// + /// This is the server's main loop — analogous to `App::run()` but without + /// a real terminal. It: + /// - Drains internal events (pane death, state changes) + /// - Drains API requests (from the JSON socket) + /// - Accepts new client connections + /// - Reads client messages and routes input + /// - Handles scheduled tasks (resize poll, animation, session save, etc.) + /// - Renders virtually and streams frames to clients + pub async fn run(&mut self) -> io::Result<()> { + info!("headless server starting"); + + // Register SIGINT handler for graceful shutdown. + let should_quit = self.should_quit.clone(); + let quit_notify = self.server_event_tx.clone(); + ctrlc_handler(should_quit, quit_notify); + + // No input_rx needed — server doesn't read stdin. + // We use None for input_rx so the event loop doesn't try to read from stdin. + self.app.input_rx = None; + + let mut needs_render = true; + + loop { + // If shutdown has been initiated, complete it and exit. + if self.shutting_down { + self.complete_shutdown()?; + break; + } + + // Check if we should start shutting down. + if self.app.state.should_quit || self.should_quit.load(Ordering::Acquire) { + self.initiate_shutdown(); + continue; + } + + // 1. Check render_dirty flag from PTY reader tasks. + if self.app.render_dirty.load(Ordering::Acquire) { + needs_render = true; + } + + // 2. Drain internal events. + if self.drain_internal_events_with_forwarding() { + needs_render = true; + } + + // 3. Drain API requests. + if self.drain_api_requests_with_shutdown_check() { + needs_render = true; + } + + self.app.sync_focus_events(); + self.app.sync_session_save_schedule(); + + // 4. Accept new client connections. + self.accept_client_connections()?; + + // 5. Drain server events from client threads. + if self.drain_server_events() { + needs_render = true; + } + + // 6. Handle scheduled tasks. + let now = Instant::now(); + if self.handle_scheduled_tasks_headless(now) { + needs_render = true; + } + + // Handle deferred requests. + if self.app.state.request_complete_onboarding { + self.app.state.request_complete_onboarding = false; + self.app.complete_onboarding(); + needs_render = true; + } + + if self.app.state.request_new_workspace { + self.app.state.request_new_workspace = false; + self.app.create_workspace(); + needs_render = true; + } + + if self.app.state.request_new_tab { + self.app.state.request_new_tab = false; + self.app.create_tab(); + needs_render = true; + } + + if self.app.state.request_reload_keybinds { + self.app.state.request_reload_keybinds = false; + self.app.reload_keybinds(); + needs_render = true; + } + + self.app.sync_animation_timer(now); + + // 7. Render virtually and stream frames. + if needs_render && self.app.can_render_now(now) { + self.app.render_dirty.swap(false, Ordering::AcqRel); + self.render_and_stream(); + self.app.last_render_at = Some(now); + needs_render = false; + continue; + } + + // 8. Wait for next event. + let next_deadline = self.app.next_loop_deadline(now, needs_render); + let event = { + tokio::select! { + maybe_api = self.app.api_rx.recv() => match maybe_api { + Some(msg) => LoopEvent::Api(msg), + None => LoopEvent::Timer, + }, + maybe_ev = self.app.event_rx.recv() => match maybe_ev { + Some(ev) => LoopEvent::Internal(ev), + None => LoopEvent::Timer, + }, + maybe_server_ev = self.server_event_rx.recv() => match maybe_server_ev { + Some(ev) => LoopEvent::ServerEvent(ev), + None => LoopEvent::Timer, + }, + _ = sleep_until_or_pending(next_deadline) => LoopEvent::Timer, + _ = self.app.render_notify.notified() => LoopEvent::RenderRequested, + } + }; + + match event { + LoopEvent::Timer => {} + LoopEvent::Internal(ev) => { + if self.handle_internal_event_with_forwarding(ev) { + needs_render = true; + } + } + LoopEvent::Api(msg) => { + if self.handle_api_request_with_shutdown_check(msg) { + needs_render = true; + } + } + LoopEvent::ServerEvent(ev) => { + if self.handle_server_event(ev) { + needs_render = true; + } + } + LoopEvent::RenderRequested => { + if self.app.render_dirty.load(Ordering::Acquire) { + needs_render = true; + } + } + } + } + + // Save session on exit. + if !self.app.no_session { + self.app.save_session_now(); + } + + info!("headless server exiting"); + Ok(()) + } + + fn allocate_activity_stamp(&mut self) -> u64 { + let stamp = self.next_activity_stamp; + self.next_activity_stamp = self.next_activity_stamp.saturating_add(1); + stamp + } + + fn resize_shared_runtime_to_effective_size(&mut self) { + if self.foreground_client_id.is_none() { + return; + } + let (cols, rows) = self.effective_size; + let area = Rect::new(0, 0, cols, rows); + crate::ui::compute_view(&mut self.app.state, area); + } + + fn sync_foreground_client_state(&mut self) { + let Some(client_id) = self.foreground_client_id else { + self.effective_size = (MIN_COLS, MIN_ROWS); + return; + }; + let Some(client) = self.clients.get(&client_id) else { + self.foreground_client_id = None; + self.effective_size = (MIN_COLS, MIN_ROWS); + return; + }; + + self.effective_size = client.terminal_size; + if !client.host_terminal_theme.is_empty() { + self.app.set_host_terminal_theme(client.host_terminal_theme); + } + } + + fn promote_client_to_foreground(&mut self, client_id: u64) -> bool { + let stamp = self.allocate_activity_stamp(); + let Some(client) = self.clients.get_mut(&client_id) else { + return false; + }; + client.last_activity = stamp; + + let changed = self.foreground_client_id != Some(client_id); + self.foreground_client_id = Some(client_id); + self.sync_foreground_client_state(); + changed + } + + fn promote_latest_remaining_client(&mut self) -> bool { + let next_foreground = self + .clients + .iter() + .max_by_key(|(_, client)| client.last_activity) + .map(|(&client_id, _)| client_id); + let changed = next_foreground != self.foreground_client_id; + self.foreground_client_id = next_foreground; + self.sync_foreground_client_state(); + changed + } + + fn remove_client(&mut self, client_id: u64) -> bool { + let was_foreground = self.foreground_client_id == Some(client_id); + self.clients.remove(&client_id); + if was_foreground { + self.promote_latest_remaining_client() + } else { + false + } + } + + fn update_client_host_theme_from_events( + &mut self, + client_id: u64, + events: &[crate::raw_input::RawInputEvent], + ) -> bool { + let Some(client) = self.clients.get_mut(&client_id) else { + return false; + }; + + let mut next_theme = client.host_terminal_theme; + for event in events { + if let crate::raw_input::RawInputEvent::HostDefaultColor { kind, color } = event { + next_theme = next_theme.with_color(*kind, *color); + } + } + + if next_theme == client.host_terminal_theme { + return false; + } + + client.host_terminal_theme = next_theme; + if self.foreground_client_id == Some(client_id) { + self.app.set_host_terminal_theme(next_theme) + } else { + false + } + } + + fn events_include_interaction(events: &[crate::raw_input::RawInputEvent]) -> bool { + events.iter().any(|event| { + matches!( + event, + crate::raw_input::RawInputEvent::Key(_) + | crate::raw_input::RawInputEvent::Mouse(_) + | crate::raw_input::RawInputEvent::Paste(_) + ) + }) + } + + /// Accepts pending client connections from the non-blocking listener. + fn accept_client_connections(&mut self) -> io::Result<()> { + loop { + match self.client_listener.accept() { + Ok((stream, _addr)) => { + let client_id = self.next_client_id; + self.next_client_id += 1; + + if let Err(err) = stream.set_nonblocking(true) { + warn!(err = %err, "failed to set client stream nonblocking"); + continue; + } + + // Spawn a thread for the handshake and read loop. + let should_quit = self.should_quit.clone(); + let server_event_tx = self.server_event_tx.clone(); + std::thread::spawn(move || { + if let Err(err) = handle_client_handshake( + stream, + client_id, + &server_event_tx, + &should_quit, + ) { + debug!(client_id, err = %err, "client handshake failed"); + } + }); + } + Err(ref err) if err.kind() == io::ErrorKind::WouldBlock => { + // No more pending connections. + break; + } + Err(err) => { + error!(err = %err, "client listener accept failed"); + break; + } + } + } + Ok(()) + } + + /// Drains server events from the dedicated channel. + /// + /// Returns true if any input was processed (requiring a re-render). + fn drain_server_events(&mut self) -> bool { + let mut changed = false; + while let Ok(ev) = self.server_event_rx.try_recv() { + changed |= self.handle_server_event(ev); + } + changed + } + + /// Handles a single internal event with forwarding logic for clipboard, + /// sound, and toast notifications to connected clients. + /// + /// ALL internal events MUST be routed through this method to ensure + /// clipboard/notify forwarding is never bypassed. Do not call + /// `self.app.handle_internal_event()` directly for any internal event + /// in the headless server — use this method instead. + /// + /// Returns true if the event changed visual state (requiring a re-render). + fn handle_internal_event_with_forwarding(&mut self, ev: AppEvent) -> bool { + match &ev { + AppEvent::ClipboardWrite { content } => { + // Clipboard writes are client-local side effects. Forward them only to + // the foreground client instead of broadcasting to every attached client. + if let Some(client_id) = self.foreground_client_id { + let data = base64::engine::general_purpose::STANDARD.encode(content.as_slice()); + self.send_to_client(client_id, ServerMessage::Clipboard { data }); + } + // ClipboardWrite doesn't change visual state — no render needed. + false + } + AppEvent::StateChanged { + pane_id, + agent, + state, + } => { + // Capture toast before handling. + let toast_before = self.app.state.toast.clone(); + let pane_id_val = *pane_id; + let agent_val = *agent; + let state_val = *state; + + // Find the previous state of this pane before the event + // is processed. We need this to determine if a sound + // notification would be triggered. + let prev_state = self + .app + .state + .workspaces + .iter() + .find_map(|ws| { + ws.tabs + .iter() + .find_map(|tab| tab.panes.get(&pane_id_val).map(|p| p.state)) + }) + .unwrap_or(crate::detect::AgentState::Unknown); + + // Handle the state change (updates pane state, sets toast on AppState). + // Note: apply_pane_state_change inside handle_internal_event will try + // to play sounds, but sound.enabled=false in the headless server, so + // sound::play is never called. Toast may still be set on AppState if + // toast_config.enabled is true. + self.app.handle_internal_event(ev); + + // Forward sound notification to clients. + // We check the agent-specific sound setting but NOT sound.enabled, + // because the server sets enabled=false to prevent local playback — + // clients should still receive sound notifications and decide + // locally whether to play them based on their own config. + let is_active_tab = self + .app + .state + .active + .and_then(|ws_idx| self.app.state.workspaces.get(ws_idx)) + .is_some_and(|ws| { + ws.find_tab_index_for_pane(pane_id_val) + .is_some_and(|tab_idx| ws.active_tab_index() == tab_idx) + }); + + if !matches!( + self.app.state.sound.agents.for_agent(agent_val), + crate::config::AgentSoundSetting::Off + ) { + if let Some(sound) = crate::app::actions::notification_sound_for_state_change( + is_active_tab, + prev_state, + state_val, + ) { + let msg = match sound { + crate::sound::Sound::Done => "agent done", + crate::sound::Sound::Request => "agent attention", + }; + self.send_to_all_clients(ServerMessage::Notify { + kind: protocol::NotifyKind::Sound, + message: msg.to_owned(), + }); + } + } + + // Forward any new toast as a notification. + if self.app.state.toast.is_some() && self.app.state.toast != toast_before { + if let Some(toast) = &self.app.state.toast { + let msg = format!("{}: {}", toast.title, toast.context); + self.send_to_all_clients(ServerMessage::Notify { + kind: protocol::NotifyKind::Toast, + message: msg, + }); + } + } + + true + } + AppEvent::HookStateReported { + pane_id, + agent_label, + state, + .. + } => { + // The hook authority may not change the effective pane state if + // the detected agent doesn't match. We forward based on the + // hook-reported state transition regardless. + let toast_before = self.app.state.toast.clone(); + let pane_id_val = *pane_id; + let agent_val = crate::detect::parse_agent_label(agent_label); + let hook_state_val = *state; + + // Capture the previous hook authority state for this pane. + // If no hook authority exists, use the effective state. + let prev_hook_state = self + .app + .state + .workspaces + .iter() + .find_map(|ws| { + ws.tabs.iter().find_map(|tab| { + tab.panes.get(&pane_id_val).map(|p| { + p.hook_authority + .as_ref() + .map(|h| h.state) + .unwrap_or(p.state) + }) + }) + }) + .unwrap_or(crate::detect::AgentState::Unknown); + + self.app.handle_internal_event(ev); + + // Forward sound notification based on hook state transition. + // This ensures API-reported state changes (pane.report_agent) + // produce notifications even before fallback detection confirms. + let is_active_tab = self + .app + .state + .active + .and_then(|ws_idx| self.app.state.workspaces.get(ws_idx)) + .is_some_and(|ws| { + ws.find_tab_index_for_pane(pane_id_val) + .is_some_and(|tab_idx| ws.active_tab_index() == tab_idx) + }); + + if !matches!( + self.app.state.sound.agents.for_agent(agent_val), + crate::config::AgentSoundSetting::Off + ) { + if let Some(sound) = crate::app::actions::notification_sound_for_state_change( + is_active_tab, + prev_hook_state, + hook_state_val, + ) { + let msg = match sound { + crate::sound::Sound::Done => "agent done", + crate::sound::Sound::Request => "agent attention", + }; + self.send_to_all_clients(ServerMessage::Notify { + kind: protocol::NotifyKind::Sound, + message: msg.to_owned(), + }); + } + } + + // Forward any new toast as a notification. + if self.app.state.toast.is_some() && self.app.state.toast != toast_before { + if let Some(toast) = &self.app.state.toast { + let msg = format!("{}: {}", toast.title, toast.context); + self.send_to_all_clients(ServerMessage::Notify { + kind: protocol::NotifyKind::Toast, + message: msg, + }); + } + } + + true + } + AppEvent::UpdateReady { version: _ } => { + let toast_before = self.app.state.toast.clone(); + + self.app.handle_internal_event(ev); + + // Forward the update toast notification. + if self.app.state.toast.is_some() && self.app.state.toast != toast_before { + if let Some(toast) = &self.app.state.toast { + let msg = format!("{}: {}", toast.title, toast.context); + self.send_to_all_clients(ServerMessage::Notify { + kind: protocol::NotifyKind::Toast, + message: msg, + }); + } + } + + true + } + _ => { + self.app.handle_internal_event(ev); + true + } + } + } + + /// Drains internal events, forwarding clipboard, sound, and toast + /// notifications to connected clients instead of processing them locally. + /// + /// In the monolithic mode: + /// - `ClipboardWrite` events are written to stdout via `write_osc52_bytes`. + /// - Sound notifications are played locally via `sound::play`. + /// - Toast notifications are set on AppState and rendered into the frame. + /// + /// In the headless server, there is no stdout terminal or audio subsystem, + /// so we: + /// - Forward `ClipboardWrite` as `ServerMessage::Clipboard` to the + /// foreground client only. + /// - Detect when a sound would be played and forward as + /// `ServerMessage::Notify { kind: Sound }` to all clients. + /// - Detect when a toast is set on AppState and forward as + /// `ServerMessage::Notify { kind: Toast }` to all clients. + fn drain_internal_events_with_forwarding(&mut self) -> bool { + let mut changed = false; + while let Ok(ev) = self.app.event_rx.try_recv() { + changed |= self.handle_internal_event_with_forwarding(ev); + } + changed + } + + /// Encodes a server message into a length-prefixed frame. + fn frame_server_message(msg: &ServerMessage) -> Result<Vec<u8>, protocol::FramingError> { + let mut framed = Vec::new(); + protocol::write_message(&mut framed, msg)?; + Ok(framed) + } + + /// Sends a message to all connected clients. + /// Broken connections are tracked and cleaned up. + fn send_to_all_clients(&mut self, msg: ServerMessage) { + let serialized = match Self::frame_server_message(&msg) { + Ok(framed) => framed, + Err(err) => { + warn!(err = %err, "failed to serialize message for clients"); + return; + } + }; + + let mut broken_clients: Vec<u64> = Vec::new(); + for (&client_id, client) in &mut self.clients { + if let Some(writer) = &client.writer { + if writer.send(serialized.clone()).is_err() { + debug!(client_id, "client writer channel closed during broadcast"); + broken_clients.push(client_id); + } + } + } + + // Remove broken clients. + for client_id in broken_clients { + let foreground_changed = self.remove_client(client_id); + if foreground_changed { + self.resize_shared_runtime_to_effective_size(); + } + } + } + + /// Sends a message to a specific client. Returns false if the client + /// was not found or the send failed (client removed). + fn send_to_client(&mut self, client_id: u64, msg: ServerMessage) -> bool { + let serialized = match Self::frame_server_message(&msg) { + Ok(framed) => framed, + Err(err) => { + warn!(client_id, err = %err, "failed to serialize message for client"); + return false; + } + }; + + if let Some(client) = self.clients.get(&client_id) { + if let Some(writer) = &client.writer { + if writer.send(serialized).is_err() { + debug!( + client_id, + "client writer channel closed during targeted send" + ); + let foreground_changed = self.remove_client(client_id); + if foreground_changed { + self.resize_shared_runtime_to_effective_size(); + } + return false; + } + } + true + } else { + false + } + } + + /// Handles a server event. Returns true if the event requires a re-render. + fn handle_server_event(&mut self, ev: ServerEvent) -> bool { + match ev { + ServerEvent::ClientConnected { + client_id, + cols, + rows, + writer, + } => { + info!(client_id, cols, rows, "client connected"); + let last_activity = self.allocate_activity_stamp(); + self.clients.insert( + client_id, + ClientConnection { + terminal_size: (cols, rows), + host_terminal_theme: crate::terminal_theme::TerminalTheme::default(), + last_activity, + writer: Some(writer), + }, + ); + self.foreground_client_id = Some(client_id); + self.sync_foreground_client_state(); + self.resize_shared_runtime_to_effective_size(); + true + } + ServerEvent::ClientInput { client_id, data } => { + debug!(client_id, len = data.len(), "client input received"); + let events = crate::raw_input::parse_raw_input_bytes_sync(&data); + let interaction = Self::events_include_interaction(&events); + let foreground_changed = if interaction { + self.promote_client_to_foreground(client_id) + } else { + false + }; + if foreground_changed { + self.resize_shared_runtime_to_effective_size(); + } + let theme_changed = self.update_client_host_theme_from_events(client_id, &events); + self.app + .route_client_events(events, self.foreground_client_id == Some(client_id)); + + // Check if the detach keybind was triggered during input processing. + if self.app.state.detach_requested { + self.app.state.detach_requested = false; + info!(client_id, "client detach requested via keybind"); + + // Send a ServerShutdown with "detached" reason to this client + // so it exits cleanly (not with a connection-lost error). + // The client will close its connection after receiving this, + // which triggers a ClientDisconnected event that removes it. + self.send_to_client( + client_id, + ServerMessage::ServerShutdown { + reason: Some("detached".to_owned()), + }, + ); + + // Don't remove the client here — let the client disconnect + // naturally after receiving the ServerShutdown. The client's + // read loop will see EOF and the server will get a + // ClientDisconnected event which handles cleanup. + // + // However, we do need to stop sending frames to this client + // since it's detaching. Drop the writer channel so no more + // frames are queued for this client. + if let Some(client) = self.clients.get_mut(&client_id) { + client.writer = None; + } + + // No re-render needed for remaining clients. + false + } else { + foreground_changed || theme_changed || interaction + } + } + ServerEvent::ClientResize { + client_id, + cols, + rows, + } => { + info!(client_id, cols, rows, "client resize"); + if let Some(client) = self.clients.get_mut(&client_id) { + client.terminal_size = (cols, rows); + } + self.promote_client_to_foreground(client_id); + self.resize_shared_runtime_to_effective_size(); + true + } + ServerEvent::ClientDetach { client_id } => { + info!(client_id, "client detached"); + let foreground_changed = self.remove_client(client_id); + if foreground_changed { + self.resize_shared_runtime_to_effective_size(); + } + true + } + ServerEvent::ClientDisconnected { client_id } => { + info!(client_id, "client disconnected"); + let foreground_changed = self.remove_client(client_id); + if foreground_changed { + self.resize_shared_runtime_to_effective_size(); + } + true + } + ServerEvent::QuitSignal => { + // The quit check at the top of the loop handles this. + // No render needed — the next iteration will initiate shutdown. + false + } + } + } + + /// Drains API requests with shutdown awareness. + /// + /// During shutdown, remaining requests get a `server_unavailable` error. + fn drain_api_requests_with_shutdown_check(&mut self) -> bool { + let mut changed = false; + while let Ok(msg) = self.app.api_rx.try_recv() { + changed |= self.handle_api_request_with_shutdown_check(msg); + } + changed + } + + /// Handles a single API request with shutdown awareness. + /// + /// Also forwards any toast/sound notifications that result from the API + /// request to connected clients. API methods like `pane.report_agent` + /// trigger internal events that may set toast state or would normally + /// play sounds — in headless mode we forward these to clients instead. + fn handle_api_request_with_shutdown_check(&mut self, msg: api::ApiRequestMessage) -> bool { + if self.shutting_down { + // During shutdown, respond with server_unavailable. + let response = serde_json::to_string(&api::schema::ErrorResponse { + id: msg.request.id, + error: api::schema::ErrorBody { + code: "server_unavailable".into(), + message: "server is shutting down".into(), + }, + }) + .unwrap_or_else(|_| { + r#"{"id":"","error":{"code":"server_unavailable","message":"server is shutting down"}}"# + .to_string() + }); + let _ = msg.respond_to.send(response); + return false; + } + + let changed = api::request_changes_ui(&msg.request); + + // Capture toast and pane agent states before the API call so we can + // forward any resulting notifications to connected clients. + // API requests like pane.report_agent trigger handle_internal_event + // internally, which bypasses drain_internal_events_with_forwarding. + // Since sound.enabled=false in the headless server, sounds would be + // silently dropped; toasts may be set but not forwarded. + // + // Note: pane.report_agent sets hook_authority on the pane, but the + // effective state may not change until the fallback detector confirms + // the agent (detected_agent must match). So we capture both the + // effective state AND the hook authority state for comparison. + let toast_before = self.app.state.toast.clone(); + let pane_states_before: Vec<( + usize, + crate::layout::PaneId, + crate::detect::AgentState, + Option<crate::detect::AgentState>, + )> = self + .app + .state + .workspaces + .iter() + .enumerate() + .flat_map(|(ws_idx, ws)| { + ws.tabs.iter().flat_map(move |tab| { + tab.panes.iter().map(move |(&pane_id, pane)| { + ( + ws_idx, + pane_id, + pane.state, + pane.hook_authority.as_ref().map(|h| h.state), + ) + }) + }) + }) + .collect(); + + let response = self.app.handle_api_request(msg.request); + let _ = msg.respond_to.send(response); + + // Forward any new toast as a notification to clients. + let toast_after = self.app.state.toast.clone(); + if toast_after.is_some() && toast_after != toast_before { + if let Some(toast) = &toast_after { + let msg_text = format!("{}: {}", toast.title, toast.context); + debug!(msg = %msg_text, "forwarding toast notification from API request"); + self.send_to_all_clients(ServerMessage::Notify { + kind: protocol::NotifyKind::Toast, + message: msg_text, + }); + } + } + + // Forward sound notifications for any pane state changes that occurred + // during the API request. Compare before/after pane states (including + // hook authority state) to find transitions that would trigger a sound. + // + // pane.report_agent sets hook_authority on the pane, but the effective + // state may not change until the fallback detector confirms the agent + // (detected_agent must match hook_authority.agent). We check BOTH the + // effective state AND the hook authority state so that API-reported + // state changes trigger notifications even before fallback confirmation. + for (ws_idx, pane_id, prev_effective_state, prev_hook_state) in &pane_states_before { + let pane_after = self + .app + .state + .workspaces + .get(*ws_idx) + .and_then(|ws| ws.tabs.iter().find_map(|tab| tab.panes.get(pane_id))); + + let Some(pane_after) = pane_after else { + continue; + }; + + let new_effective_state = pane_after.state; + let new_hook_state = pane_after.hook_authority.as_ref().map(|h| h.state); + + // Check effective state change first. + let effective_changed = new_effective_state != *prev_effective_state; + // Check hook authority state change — this catches API-reported + // state changes that haven't been confirmed by fallback detection. + let hook_changed = new_hook_state != *prev_hook_state; + + if effective_changed || hook_changed { + // Use the hook state if available (it reflects the API-reported + // state), otherwise use the effective state. + let prev_state = prev_hook_state.unwrap_or(*prev_effective_state); + let new_state = new_hook_state.unwrap_or(new_effective_state); + + // Skip if the derived transition is a no-op. + if prev_state == new_state { + continue; + } + + let is_active_tab = self.app.state.pane_is_in_active_tab(*ws_idx, *pane_id); + + // Get the known agent for sound settings. Unknown custom labels + // fall back to None so clients use the generic sound behavior. + let agent = pane_after.effective_known_agent(); + + debug!( + ws_idx, + pane_id = pane_id.raw(), + prev_state = ?prev_state, + new_state = ?new_state, + agent = ?agent, + effective_changed, + hook_changed, + "pane state changed during API request, checking sound notification" + ); + + // Check agent-specific sound setting but NOT sound.enabled, + // because the server sets enabled=false to prevent local playback. + // Clients decide locally whether to play sounds. + if !matches!( + self.app.state.sound.agents.for_agent(agent), + crate::config::AgentSoundSetting::Off + ) { + if let Some(sound) = crate::app::actions::notification_sound_for_state_change( + is_active_tab, + prev_state, + new_state, + ) { + let msg_text = match sound { + crate::sound::Sound::Done => "agent done", + crate::sound::Sound::Request => "agent attention", + }; + debug!(sound = ?sound, "forwarding sound notification from API request"); + self.send_to_all_clients(ServerMessage::Notify { + kind: protocol::NotifyKind::Sound, + message: msg_text.to_owned(), + }); + } + } + } + } + + changed + } + + /// Renders the current state to client-sized virtual buffers and streams + /// frames to all connected clients. + fn render_and_stream(&mut self) { + let foreground_client_id = self.foreground_client_id; + let mut render_targets: Vec<(u64, (u16, u16), std::sync::mpsc::Sender<Vec<u8>>, bool)> = + self.clients + .iter() + .filter_map(|(&client_id, client)| { + client.writer.as_ref().map(|writer| { + ( + client_id, + client.terminal_size, + writer.clone(), + foreground_client_id == Some(client_id), + ) + }) + }) + .collect(); + + render_targets.sort_by_key(|(client_id, _, _, is_foreground)| (*is_foreground, *client_id)); + + if render_targets.is_empty() { + let (cols, rows) = self.effective_size; + let area = Rect::new(0, 0, cols, rows); + let _ = render_virtual(&mut self.app.state, area, true); + debug!( + cols, + rows, "rendered virtual frame with no attached clients" + ); + return; + } + + let mut broken_clients: Vec<u64> = Vec::new(); + for (client_id, (cols, rows), writer, is_foreground) in render_targets { + let area = Rect::new(0, 0, cols, rows); + let (buffer, cursor) = render_virtual(&mut self.app.state, area, is_foreground); + let message = ServerMessage::Frame(FrameData::from_ratatui_buffer(&buffer, cursor)); + let serialized = match Self::frame_server_message(&message) { + Ok(framed) => framed, + Err(err) => { + warn!(client_id, err = %err, "failed to serialize frame for client"); + broken_clients.push(client_id); + continue; + } + }; + + if writer.send(serialized).is_err() { + debug!(client_id, "client writer channel closed, marking as broken"); + broken_clients.push(client_id); + } + } + + if !broken_clients.is_empty() { + for client_id in broken_clients { + let foreground_changed = self.remove_client(client_id); + if foreground_changed { + self.resize_shared_runtime_to_effective_size(); + } + } + } + + let (cols, rows) = self.effective_size; + debug!(cols, rows, foreground_client_id = ?self.foreground_client_id, "rendered virtual frame(s)"); + } + + /// Handle scheduled tasks for the headless server. + /// + /// Similar to `App::handle_scheduled_tasks` but without resize polling + /// (the server doesn't have a terminal to resize). + fn handle_scheduled_tasks_headless(&mut self, now: Instant) -> bool { + let mut changed = false; + + self.app.sync_animation_timer(now); + + // No resize polling needed — server has no terminal. + // Client resize messages drive size changes instead. + + if self + .app + .config_diagnostic_deadline + .is_some_and(|deadline| now >= deadline) + { + self.app.config_diagnostic_deadline = None; + self.app.state.config_diagnostic = None; + changed = true; + } + + if self + .app + .toast_deadline + .is_some_and(|deadline| now >= deadline) + { + self.app.toast_deadline = None; + self.app.state.toast = None; + changed = true; + } + + if self + .app + .next_animation_tick + .is_some_and(|deadline| now >= deadline) + { + self.app.state.spinner_tick = self.app.state.spinner_tick.wrapping_add(1); + self.app.next_animation_tick = Some(now + app::ANIMATION_INTERVAL); + changed = true; + } + + if self + .app + .git_refresh_deadline() + .is_some_and(|deadline| now >= deadline) + { + for ws in &mut self.app.state.workspaces { + ws.refresh_git_ahead_behind(); + } + self.app.last_git_remote_status_refresh = now; + changed = true; + } + + if self + .app + .next_auto_update_check + .is_some_and(|deadline| now >= deadline) + { + self.app.run_auto_update_check(); + } + + if self + .app + .session_save_deadline + .is_some_and(|deadline| now >= deadline) + { + self.app.save_session_now(); + } + + self.app.sync_animation_timer(now); + changed + } + + /// Initiates graceful shutdown. + fn initiate_shutdown(&mut self) { + if self.shutting_down { + return; + } + info!("server shutdown initiated"); + self.shutting_down = true; + + // Send ServerShutdown to all connected clients. + let shutdown_msg = ServerMessage::ServerShutdown { + reason: Some("server is shutting down".to_owned()), + }; + self.send_to_all_clients(shutdown_msg); + + // Give client writer threads a moment to flush the shutdown message. + // A short sleep ensures the message is written to the socket before + // we close the connections. + std::thread::sleep(Duration::from_millis(50)); + + // Signal the main loop to exit. + self.should_quit.store(true, Ordering::Release); + self.app.state.should_quit = true; + } + + /// Completes the shutdown sequence: send ServerShutdown to clients, + /// close client connections, remove socket files, and clean up. + fn complete_shutdown(&mut self) -> io::Result<()> { + info!("completing server shutdown"); + + // Send ServerShutdown to all remaining clients. + if !self.clients.is_empty() { + let shutdown_msg = ServerMessage::ServerShutdown { + reason: Some("server is shutting down".to_owned()), + }; + self.send_to_all_clients(shutdown_msg); + + // Give writer threads a moment to flush before closing. + std::thread::sleep(Duration::from_millis(50)); + } + + // Drain remaining API requests with server_unavailable. + self.drain_api_requests_with_shutdown_check(); + + // Close all client connections. + self.clients.clear(); + + // Remove socket files. + self.cleanup_sockets()?; + + Ok(()) + } + + /// Removes socket files created by the server. + fn cleanup_sockets(&self) -> io::Result<()> { + if let Err(err) = fs::remove_file(&self.client_socket_path) { + if err.kind() != io::ErrorKind::NotFound { + warn!( + path = %self.client_socket_path.display(), + err = %err, + "failed to remove client socket on shutdown" + ); + } + } + Ok(()) + } +} + +impl Drop for HeadlessServer { + fn drop(&mut self) { + let _ = self.cleanup_sockets(); + } +} + +// --------------------------------------------------------------------------- +// Client handshake +// --------------------------------------------------------------------------- + +/// Internal event sent from the handshake thread to the main event loop. +#[derive(Debug)] +pub enum ServerEvent { + /// A new client completed the handshake. + ClientConnected { + client_id: u64, + cols: u16, + rows: u16, + writer: std::sync::mpsc::Sender<Vec<u8>>, + }, + /// A client sent an input message. + ClientInput { client_id: u64, data: Vec<u8> }, + /// A client sent a resize message. + ClientResize { + client_id: u64, + cols: u16, + rows: u16, + }, + /// A client detached gracefully. + ClientDetach { client_id: u64 }, + /// A client connection was lost. + ClientDisconnected { client_id: u64 }, + /// Ctrl+C or external shutdown signal received. + QuitSignal, +} + +/// Handles the client handshake on a blocking thread. +/// +/// Reads the `Hello` message, validates the version, sends `Welcome`, +/// and then enters a read loop forwarding messages to the server event channel. +fn handle_client_handshake( + mut stream: UnixStream, + client_id: u64, + server_event_tx: &mpsc::Sender<ServerEvent>, + should_quit: &Arc<AtomicBool>, +) -> io::Result<()> { + // Reset to blocking mode — the accept loop sets nonblocking but + // the handshake thread needs blocking I/O for read_message/write_message. + stream.set_nonblocking(false)?; + + // Set a read timeout for the handshake. + stream.set_read_timeout(Some(HANDSHAKE_TIMEOUT))?; + + // Read the Hello message. + let hello: ClientMessage = match protocol::read_message(&mut stream, MAX_FRAME_SIZE) { + Ok(msg) => msg, + Err(protocol::FramingError::UnexpectedEof) => { + debug!(client_id, "client disconnected before handshake"); + return Ok(()); + } + Err(protocol::FramingError::Oversized { claimed, max }) => { + warn!(client_id, claimed, max, "oversized handshake from client"); + return Ok(()); + } + Err(err) => { + debug!(client_id, err = %err, "failed to read client hello"); + return Ok(()); + } + }; + + let (client_cols, client_rows) = match hello { + ClientMessage::Hello { + version, + cols, + rows, + } => { + // Version check. + match protocol::check_client_version(version) { + protocol::VersionCheck::Compatible => {} + protocol::VersionCheck::Incompatible(reason) => { + // Send rejection Welcome. + let welcome = ServerMessage::Welcome { + version: PROTOCOL_VERSION, + error: Some(reason), + }; + let _ = protocol::write_message(&mut stream, &welcome); + return Ok(()); + } + } + + // Clamp size. + let (clamped_cols, clamped_rows) = clamp_terminal_size(cols, rows); + (clamped_cols, clamped_rows) + } + _ => { + // First message must be Hello. + debug!(client_id, "first message was not Hello, closing"); + let welcome = ServerMessage::Welcome { + version: PROTOCOL_VERSION, + error: Some("expected Hello as first message".to_owned()), + }; + let _ = protocol::write_message(&mut stream, &welcome); + return Ok(()); + } + }; + + // Send Welcome. + let welcome = ServerMessage::Welcome { + version: PROTOCOL_VERSION, + error: None, + }; + protocol::write_message(&mut stream, &welcome) + .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?; + + // Clear read timeout for normal operation. + stream.set_read_timeout(None)?; + + // Create a channel for writing frames back to the client. + let (frame_tx, frame_rx) = std::sync::mpsc::channel::<Vec<u8>>(); + + // Notify the main loop about the new client. + let _ = server_event_tx.blocking_send(ServerEvent::ClientConnected { + client_id, + cols: client_cols, + rows: client_rows, + writer: frame_tx, + }); + + // Spawn a writer thread that forwards frames from the channel to the stream. + let write_stream = stream.try_clone()?; + let write_quit = should_quit.clone(); + std::thread::spawn(move || { + client_writer_loop(write_stream, frame_rx, &write_quit); + }); + + // Enter read loop — read client messages and forward to main loop. + client_read_loop(stream, client_id, server_event_tx, should_quit) +} + +/// The client writer loop — sends frames from the channel to the client stream. +fn client_writer_loop( + mut stream: UnixStream, + frame_rx: std::sync::mpsc::Receiver<Vec<u8>>, + should_quit: &Arc<AtomicBool>, +) { + while !should_quit.load(Ordering::Acquire) { + match frame_rx.recv_timeout(Duration::from_millis(100)) { + Ok(data) => { + if let Err(err) = stream.write_all(&data) { + debug!(err = %err, "client write failed, closing writer"); + break; + } + if let Err(err) = stream.flush() { + debug!(err = %err, "client flush failed, closing writer"); + break; + } + } + Err(std::sync::mpsc::RecvTimeoutError::Timeout) => continue, + Err(std::sync::mpsc::RecvTimeoutError::Disconnected) => break, + } + } + debug!("client writer thread exiting"); +} + +/// The client read loop — reads messages from the client and forwards to the server event channel. +fn client_read_loop( + mut stream: UnixStream, + client_id: u64, + server_event_tx: &mpsc::Sender<ServerEvent>, + should_quit: &Arc<AtomicBool>, +) -> io::Result<()> { + while !should_quit.load(Ordering::Acquire) { + let msg: ClientMessage = match protocol::read_message(&mut stream, MAX_FRAME_SIZE) { + Ok(msg) => msg, + Err(protocol::FramingError::UnexpectedEof) => { + // Client disconnected. + let _ = + server_event_tx.blocking_send(ServerEvent::ClientDisconnected { client_id }); + break; + } + Err(protocol::FramingError::Oversized { claimed, max }) => { + warn!( + client_id, + claimed, max, "oversized message from client, closing" + ); + let _ = + server_event_tx.blocking_send(ServerEvent::ClientDisconnected { client_id }); + break; + } + Err(err) => { + debug!(client_id, err = %err, "client read error, closing"); + let _ = + server_event_tx.blocking_send(ServerEvent::ClientDisconnected { client_id }); + break; + } + }; + + let event = match msg { + ClientMessage::Input { data } => { + // Validate input size. + if data.len() > MAX_INPUT_PAYLOAD { + warn!( + client_id, + size = data.len(), + "oversized input from client, closing" + ); + ServerEvent::ClientDisconnected { client_id } + } else { + ServerEvent::ClientInput { client_id, data } + } + } + ClientMessage::Resize { cols, rows } => { + let (clamped_cols, clamped_rows) = clamp_terminal_size(cols, rows); + ServerEvent::ClientResize { + client_id, + cols: clamped_cols, + rows: clamped_rows, + } + } + ClientMessage::Detach => ServerEvent::ClientDetach { client_id }, + ClientMessage::Hello { .. } => { + // Duplicate Hello — ignore. + continue; + } + }; + + if server_event_tx.blocking_send(event).is_err() { + break; // Main loop gone. + } + } + + debug!(client_id, "client read thread exiting"); + Ok(()) +} + +// --------------------------------------------------------------------------- +// Helpers +// --------------------------------------------------------------------------- + +/// Installs a Ctrl+C handler that sets the should_quit flag and wakes up +/// the event loop by sending a QuitSignal on the server event channel. +fn ctrlc_handler(should_quit: Arc<AtomicBool>, server_event_tx: mpsc::Sender<ServerEvent>) { + let _ = ctrlc::set_handler(move || { + should_quit.store(true, Ordering::Release); + // Wake up the event loop so the quit flag is checked promptly. + let _ = server_event_tx.try_send(ServerEvent::QuitSignal); + }); +} + +/// Sleep until a deadline, or return pending if none. +async fn sleep_until_or_pending(deadline: Option<Instant>) { + match deadline { + Some(deadline) => tokio::time::sleep_until(tokio::time::Instant::from_std(deadline)).await, + None => std::future::pending().await, + } +} + +// --------------------------------------------------------------------------- +// Entry point +// --------------------------------------------------------------------------- + +/// Run the headless server. This is the entry point called from main.rs. +pub fn run_server() -> io::Result<()> { + init_logging(); + + let loaded_config = config::Config::load(); + let (api_tx, api_rx) = tokio::sync::mpsc::unbounded_channel(); + let event_hub = api::EventHub::default(); + + // Start the JSON API socket server. + let _api_server = match api::start_server(api_tx, event_hub.clone()) { + Ok(server) => server, + Err(err) if err.kind() == io::ErrorKind::AddrInUse => { + eprintln!("error: herdr server is already running"); + eprintln!("api socket: {}", api::socket_path().display()); + std::process::exit(1); + } + Err(err) => return Err(err), + }; + + let no_session = false; // Server always does session persistence. + let _show_changelog = false; + + let rt = tokio::runtime::Builder::new_multi_thread() + .enable_all() + .build() + .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?; + + let result = rt.block_on(async { + // Create the App (with AppState, event channels, etc.). + let mut app = app::App::new( + &loaded_config.config, + no_session, + None, // config_diagnostic + None, // startup_release_notes + api_rx, + event_hub, + ); + + // The server runs headless — disable local sound playback. + // Sound notifications are forwarded to connected clients as + // ServerMessage::Notify instead of played locally. + app.state.sound.enabled = false; + + // Create the headless server. + let mut server = match HeadlessServer::new(app) { + Ok(server) => server, + Err(err) if err.kind() == io::ErrorKind::AddrInUse => { + eprintln!("error: herdr server is already running"); + eprintln!("client socket: {}", client_socket_path().display()); + std::process::exit(1); + } + Err(err) => return Err(err), + }; + + info!( + api_socket = %api::socket_path().display(), + client_socket = %client_socket_path().display(), + "herdr server started" + ); + + server.run().await + }); + + rt.shutdown_timeout(Duration::from_millis(100)); + result +} + +/// Initialize logging for the server process. +fn init_logging() { + crate::logging::init_file_logging("herdr-server.log"); +} + +// --------------------------------------------------------------------------- +// Tests +// --------------------------------------------------------------------------- + +#[cfg(test)] +mod tests { + use super::*; + + use crate::server::protocol::CursorState; + + fn test_headless_server() -> HeadlessServer { + let config = crate::config::Config::default(); + let (_api_tx, api_rx) = tokio::sync::mpsc::unbounded_channel(); + let app = crate::app::App::new(&config, true, None, None, api_rx, api::EventHub::default()); + + let dir = std::env::temp_dir().join(format!( + "herdr-headless-test-{}-{}", + std::process::id(), + std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .map(|d| d.as_nanos()) + .unwrap_or(0) + )); + let _ = fs::create_dir_all(&dir); + let socket_path = dir.join("client.sock"); + let listener = UnixListener::bind(&socket_path).expect("bind test listener"); + listener + .set_nonblocking(true) + .expect("set listener nonblocking"); + let (server_event_tx, server_event_rx) = mpsc::channel(64); + + HeadlessServer { + app, + client_listener: listener, + client_socket_path: socket_path, + clients: HashMap::new(), + next_client_id: 1, + foreground_client_id: None, + next_activity_stamp: 1, + effective_size: (MIN_COLS, MIN_ROWS), + shutting_down: false, + should_quit: Arc::new(AtomicBool::new(false)), + server_event_rx, + server_event_tx, + } + } + + fn read_server_message(bytes: Vec<u8>) -> ServerMessage { + let mut cursor = std::io::Cursor::new(bytes); + protocol::read_message(&mut cursor, MAX_FRAME_SIZE).expect("decode server message") + } + + fn read_server_frame(bytes: Vec<u8>) -> FrameData { + match read_server_message(bytes) { + ServerMessage::Frame(frame) => frame, + other => panic!("expected frame, got {other:?}"), + } + } + + #[test] + fn clamp_terminal_size_zero_zero() { + assert_eq!( + clamp_terminal_size(0, 0), + (MIN_CLIENT_COLS, MIN_CLIENT_ROWS) + ); + } + + #[test] + fn clamp_terminal_size_one_one() { + assert_eq!(clamp_terminal_size(1, 1), (1, 1)); + } + + #[test] + fn clamp_terminal_size_preserves_narrow_client_size() { + assert_eq!(clamp_terminal_size(40, 12), (40, 12)); + } + + #[test] + fn clamp_terminal_size_valid() { + assert_eq!(clamp_terminal_size(120, 40), (120, 40)); + } + + #[test] + fn clamp_terminal_size_exact_minimum() { + assert_eq!( + clamp_terminal_size(MIN_CLIENT_COLS, MIN_CLIENT_ROWS), + (MIN_CLIENT_COLS, MIN_CLIENT_ROWS) + ); + } + + #[test] + fn client_socket_path_derived_from_api_socket_override() { + let path = client_socket_path_from_overrides(Some("/tmp/test-herdr.sock"), None); + assert_eq!(path, PathBuf::from("/tmp/test-herdr-client.sock")); + } + + #[test] + fn client_socket_path_api_override_takes_precedence_over_legacy_client_override() { + let path = client_socket_path_from_overrides( + Some("/tmp/test-herdr.sock"), + Some("/tmp/legacy-client.sock"), + ); + assert_eq!(path, PathBuf::from("/tmp/test-herdr-client.sock")); + } + + #[test] + fn client_socket_path_respects_legacy_client_override_without_api_override() { + let path = client_socket_path_from_overrides(None, Some("/tmp/test-herdr-client.sock")); + assert_eq!(path, PathBuf::from("/tmp/test-herdr-client.sock")); + } + + #[test] + fn client_socket_path_defaults_to_config_dir() { + let path = client_socket_path_from_overrides(None, None); + assert_eq!(path, config::config_dir().join("herdr-client.sock")); + } + + #[test] + fn derive_client_socket_from_api_socket_without_sock_extension() { + let derived = derive_client_socket_from_api_socket(Path::new("/tmp/custom-api")); + assert_eq!(derived, PathBuf::from("/tmp/custom-api-client.sock")); + } + + #[test] + fn prepare_socket_path_removes_stale_socket() { + let dir = std::env::temp_dir().join(format!( + "herdr-test-stale-{}-{}", + std::process::id(), + std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .map(|d| d.as_nanos()) + .unwrap_or(0) + )); + let _ = fs::create_dir_all(&dir); + let socket_path = dir.join("stale.sock"); + + // Create a socket file that nobody is listening on. + let _ = UnixListener::bind(&socket_path); + // The listener goes out of scope, so the socket becomes stale. + + // prepare_socket_path should remove it without error. + let result = prepare_socket_path(&socket_path); + assert!(result.is_ok(), "should remove stale socket: {result:?}"); + + // Socket file should be gone. + assert!(!socket_path.exists()); + + let _ = fs::remove_dir_all(&dir); + } + + #[test] + fn prepare_socket_path_rejects_live_socket() { + let dir = std::env::temp_dir().join(format!( + "herdr-test-live-{}-{}", + std::process::id(), + std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .map(|d| d.as_nanos()) + .unwrap_or(0) + )); + let _ = fs::create_dir_all(&dir); + let socket_path = dir.join("live.sock"); + + // Bind a live listener. + let _listener = UnixListener::bind(&socket_path).expect("bind"); + + let result = prepare_socket_path(&socket_path); + assert!(result.is_err()); + assert_eq!(result.unwrap_err().kind(), io::ErrorKind::AddrInUse); + + let _ = fs::remove_dir_all(&dir); + } + + #[test] + fn virtual_render_produces_nonempty_buffer() { + let mut state = AppState::test_new(); + let area = Rect::new(0, 0, 80, 24); + let (buffer, _cursor) = render_virtual(&mut state, area, true); + assert_eq!(buffer.area.width, 80); + assert_eq!(buffer.area.height, 24); + } + + #[test] + fn virtual_render_without_frame_cursor_keeps_cursor_hidden() { + let mut state = AppState::test_new(); + let area = Rect::new(0, 0, 80, 24); + let (_buffer, cursor) = render_virtual(&mut state, area, true); + + assert_eq!(cursor, None); + } + + #[tokio::test] + async fn virtual_render_preserves_explicit_frame_cursor_position() { + let mut state = AppState::test_new(); + let mut ws = crate::workspace::Workspace::test_new("test"); + let pane_id = ws.tabs[0].root_pane; + ws.tabs[0].runtimes.insert( + pane_id, + crate::pane::PaneRuntime::test_with_screen_bytes(20, 5, b"left"), + ); + + state.workspaces = vec![ws]; + state.active = Some(0); + state.selected = 0; + state.mode = crate::app::Mode::Terminal; + + let area = Rect::new(0, 0, 80, 24); + let (_buffer, cursor) = render_virtual(&mut state, area, true); + let pane = state + .view + .pane_infos + .iter() + .find(|info| info.id == pane_id) + .expect("focused pane info"); + + assert_eq!( + cursor, + Some(CursorState { + x: pane.inner_rect.x + 4, + y: pane.inner_rect.y, + visible: true, + }) + ); + } + + #[test] + fn latest_active_client_drives_shared_size_theme_and_fallback() { + let mut server = test_headless_server(); + + server.clients.insert( + 1, + ClientConnection { + terminal_size: (160, 45), + host_terminal_theme: crate::terminal_theme::TerminalTheme { + foreground: Some(crate::terminal_theme::RgbColor { + r: 0xaa, + g: 0xbb, + b: 0xcc, + }), + background: Some(crate::terminal_theme::RgbColor { + r: 0x11, + g: 0x22, + b: 0x33, + }), + }, + last_activity: 1, + writer: None, + }, + ); + server.clients.insert( + 2, + ClientConnection { + terminal_size: (80, 24), + host_terminal_theme: crate::terminal_theme::TerminalTheme { + foreground: Some(crate::terminal_theme::RgbColor { + r: 0x10, + g: 0x20, + b: 0x30, + }), + background: Some(crate::terminal_theme::RgbColor { + r: 0xdd, + g: 0xee, + b: 0xff, + }), + }, + last_activity: 2, + writer: None, + }, + ); + + assert!(server.promote_client_to_foreground(1)); + assert_eq!(server.foreground_client_id, Some(1)); + assert_eq!(server.effective_size, (160, 45)); + assert_eq!( + server.app.state.host_terminal_theme, + server.clients[&1].host_terminal_theme + ); + + assert!(server.promote_client_to_foreground(2)); + assert_eq!(server.foreground_client_id, Some(2)); + assert_eq!(server.effective_size, (80, 24)); + assert_eq!( + server.app.state.host_terminal_theme, + server.clients[&2].host_terminal_theme + ); + + assert!(server.remove_client(2)); + assert_eq!(server.foreground_client_id, Some(1)); + assert_eq!(server.effective_size, (160, 45)); + assert_eq!( + server.app.state.host_terminal_theme, + server.clients[&1].host_terminal_theme + ); + } + + #[test] + fn render_and_stream_uses_each_client_terminal_size() { + let mut server = test_headless_server(); + server.app.state.workspaces = vec![crate::workspace::Workspace::test_new("test")]; + server.app.state.active = Some(0); + server.app.state.selected = 0; + server.app.state.mode = crate::app::Mode::Terminal; + + let (desktop_tx, desktop_rx) = std::sync::mpsc::channel(); + let (phone_tx, phone_rx) = std::sync::mpsc::channel(); + + server.clients.insert( + 1, + ClientConnection { + terminal_size: (120, 40), + host_terminal_theme: crate::terminal_theme::TerminalTheme::default(), + last_activity: 1, + writer: Some(desktop_tx), + }, + ); + server.clients.insert( + 2, + ClientConnection { + terminal_size: (80, 24), + host_terminal_theme: crate::terminal_theme::TerminalTheme::default(), + last_activity: 2, + writer: Some(phone_tx), + }, + ); + server.foreground_client_id = Some(1); + server.sync_foreground_client_state(); + server.resize_shared_runtime_to_effective_size(); + + server.render_and_stream(); + + let desktop_frame = read_server_frame(desktop_rx.recv().expect("desktop frame")); + let phone_frame = read_server_frame(phone_rx.recv().expect("phone frame")); + + assert_eq!((desktop_frame.width, desktop_frame.height), (120, 40)); + assert_eq!((phone_frame.width, phone_frame.height), (80, 24)); + } + + #[test] + fn clipboard_write_targets_foreground_client_only() { + let mut server = test_headless_server(); + let (background_tx, background_rx) = std::sync::mpsc::channel(); + let (foreground_tx, foreground_rx) = std::sync::mpsc::channel(); + + server.clients.insert( + 1, + ClientConnection { + terminal_size: (120, 40), + host_terminal_theme: crate::terminal_theme::TerminalTheme::default(), + last_activity: 1, + writer: Some(background_tx), + }, + ); + server.clients.insert( + 2, + ClientConnection { + terminal_size: (80, 24), + host_terminal_theme: crate::terminal_theme::TerminalTheme::default(), + last_activity: 2, + writer: Some(foreground_tx), + }, + ); + server.foreground_client_id = Some(2); + server.sync_foreground_client_state(); + + let changed = server.handle_internal_event_with_forwarding(AppEvent::ClipboardWrite { + content: b"test".to_vec(), + }); + + assert!(!changed); + match read_server_message( + foreground_rx + .recv_timeout(Duration::from_millis(100)) + .expect("foreground clipboard message"), + ) { + ServerMessage::Clipboard { data } => assert_eq!(data, "dGVzdA=="), + other => panic!("expected clipboard message, got {other:?}"), + } + assert!( + background_rx + .recv_timeout(Duration::from_millis(50)) + .is_err(), + "background client should not receive clipboard writes" + ); + } + + #[test] + fn handshake_timeout_is_within_five_second_deadline() { + // The handshake timeout must be short enough that + // the connection is guaranteed to close within 5 seconds even with + // OS overhead (thread scheduling, timer slack, cleanup). + assert!( + HANDSHAKE_TIMEOUT < Duration::from_secs(5), + "HANDSHAKE_TIMEOUT ({:?}) must be less than 5 seconds to guarantee \ + connection close within the 5-second deadline", + HANDSHAKE_TIMEOUT + ); + } + + /// Verify that no direct calls to `self.app.handle_internal_event` + /// exist outside of `handle_internal_event_with_forwarding` in this + /// module. This ensures the forwarding bypass cannot be reintroduced. + /// + /// The search pattern looks for `handle_internal_event` calls that + /// are NOT inside the `handle_internal_event_with_forwarding` method. + #[test] + fn no_handle_internal_event_bypass_in_module() { + let source = include_str!("headless.rs"); + + // Find all lines containing handle_internal_event + let mut bypass_lines: Vec<String> = Vec::new(); + let mut inside_forwarding_method = false; + let mut forwarding_method_brace_depth = 0u32; + + for (i, line) in source.lines().enumerate() { + let line_num = i + 1; + + // Track when we're inside handle_internal_event_with_forwarding + if line.contains("fn handle_internal_event_with_forwarding") { + inside_forwarding_method = true; + forwarding_method_brace_depth = 0; + } + + if inside_forwarding_method { + // Count braces to track when we exit the method + for ch in line.chars() { + match ch { + '{' => forwarding_method_brace_depth += 1, + '}' => { + forwarding_method_brace_depth = + forwarding_method_brace_depth.saturating_sub(1); + if forwarding_method_brace_depth == 0 { + inside_forwarding_method = false; + } + } + _ => {} + } + } + } else if line.contains("self.app.handle_internal_event(") + && !line.trim().starts_with("///") + && !line.contains("contains(") + { + // Direct call to handle_internal_event outside the forwarding method + bypass_lines.push(format!("line {}: {}", line_num, line.trim())); + } + } + + assert!( + bypass_lines.is_empty(), + "Found direct calls to self.app.handle_internal_event outside \ + handle_internal_event_with_forwarding (bypass risk):\n {}", + bypass_lines.join("\n ") + ); + } +} diff --git a/src/server/mod.rs b/src/server/mod.rs new file mode 100644 index 00000000..5b5f1d4e --- /dev/null +++ b/src/server/mod.rs @@ -0,0 +1,3 @@ +pub mod autodetect; +pub mod headless; +pub mod protocol; diff --git a/src/server/protocol.rs b/src/server/protocol.rs new file mode 100644 index 00000000..f3784a5e --- /dev/null +++ b/src/server/protocol.rs @@ -0,0 +1,1212 @@ +//! Wire protocol for herdr server/client communication. +//! +//! Defines the message types, framing, version negotiation, and safety +//! constraints for the binary protocol over Unix domain sockets. + +use std::io::{self, Read, Write}; + +use serde::{Deserialize, Serialize}; + +// --------------------------------------------------------------------------- +// Protocol constants +// --------------------------------------------------------------------------- + +/// Current protocol version. Bumped when wire format changes incompatibly. +pub const PROTOCOL_VERSION: u32 = 1; + +/// Maximum allowed frame payload size (2 MB). Frames larger than this are +/// rejected to prevent denial-of-service via oversized length prefixes. +pub const MAX_FRAME_SIZE: usize = 2 * 1024 * 1024; + +/// Length of the u32 little-endian length prefix in bytes. +const LENGTH_PREFIX_BYTES: usize = 4; + +// --------------------------------------------------------------------------- +// Client → Server messages +// --------------------------------------------------------------------------- + +/// Messages sent from the client to the server over the client protocol socket. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub enum ClientMessage { + /// Handshake: client announces its protocol version and terminal dimensions. + Hello { + /// Protocol version the client speaks. + version: u32, + /// Terminal width in columns. + cols: u16, + /// Terminal height in rows. + rows: u16, + }, + + /// Raw input bytes read from the client's stdin. + Input { + /// Raw terminal input (possibly multi-byte escape sequences). + data: Vec<u8>, + }, + + /// Terminal resize notification from the client. + Resize { + /// New terminal width in columns. + cols: u16, + /// New terminal height in rows. + rows: u16, + }, + + /// Graceful disconnect request. + Detach, +} + +// --------------------------------------------------------------------------- +// Server → Client messages +// --------------------------------------------------------------------------- + +/// A single cell in a rendered frame, serialized independently from ratatui's +/// `Cell` type to keep the wire protocol stable. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct CellData { + /// Grapheme cluster displayed in this cell (usually 1–2 chars). + pub symbol: String, + /// Foreground color as a packed u32 (0xAARRGGBB or ratatui Color index). + pub fg: u32, + /// Background color as a packed u32. + pub bg: u32, + /// Bitmask of style modifiers (bold, italic, etc.). + pub modifier: u16, + /// Whether this cell should be skipped during diff-based rendering. + pub skip: bool, +} + +/// Cursor position within a rendered frame. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct CursorState { + /// Column offset (0-based) of the cursor. + pub x: u16, + /// Row offset (0-based) of the cursor. + pub y: u16, + /// Whether the cursor is visible. + pub visible: bool, +} + +/// A rendered frame to be displayed by the client. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct FrameData { + /// Cells in row-major order. Length must equal `width * height`. + pub cells: Vec<CellData>, + /// Frame width in columns. + pub width: u16, + /// Frame height in rows. + pub height: u16, + /// Cursor state for this frame, if applicable. + pub cursor: Option<CursorState>, +} + +impl FrameData { + /// Creates a `FrameData` from a ratatui `Buffer` and optional cursor. + /// + /// This converts ratatui's internal cell representation into the + /// wire-protocol cell format. The conversion is lossless for all + /// commonly used cell attributes. + pub fn from_ratatui_buffer( + buffer: &ratatui::buffer::Buffer, + cursor: Option<CursorState>, + ) -> Self { + let area = buffer.area; + let width = area.width; + let height = area.height; + + let mut cells = Vec::with_capacity((width as usize) * (height as usize)); + for row in 0..height { + for col in 0..width { + let cell = buffer.cell((col, row)).expect("cell within bounds"); + cells.push(CellData { + symbol: cell.symbol().to_owned(), + fg: color_to_u32(cell.fg), + bg: color_to_u32(cell.bg), + modifier: modifier_to_u16(cell.modifier), + skip: cell.skip, + }); + } + } + + FrameData { + cells, + width, + height, + cursor, + } + } + + /// Reconstructs a ratatui `Buffer` from this frame data. + /// + /// Returns `None` if the cells vector length doesn't match `width * height`. + #[cfg(test)] + pub fn to_ratatui_buffer(&self) -> Option<ratatui::buffer::Buffer> { + let expected = (self.width as usize) * (self.height as usize); + if self.cells.len() != expected { + return None; + } + + let area = ratatui::layout::Rect::new(0, 0, self.width, self.height); + let mut buffer = ratatui::buffer::Buffer::filled(area, ratatui::buffer::Cell::new(" ")); + + for row in 0..self.height { + for col in 0..self.width { + let idx = (row as usize) * (self.width as usize) + (col as usize); + let cell_data = &self.cells[idx]; + let cell = buffer.cell_mut((col, row)).expect("cell within bounds"); + cell.set_symbol(&cell_data.symbol); + cell.fg = u32_to_color(cell_data.fg); + cell.bg = u32_to_color(cell_data.bg); + cell.modifier = u16_to_modifier(cell_data.modifier); + cell.skip = cell_data.skip; + } + } + + Some(buffer) + } +} + +/// Notification kind forwarded from server to client. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub enum NotifyKind { + /// Play a sound (bell/agent-done, etc.). + Sound, + /// Display a toast message. + Toast, +} + +/// Messages sent from the server to the client over the client protocol socket. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub enum ServerMessage { + /// Handshake response: server acknowledges (or rejects) the client. + Welcome { + /// Protocol version the server speaks. + version: u32, + /// If present, the handshake failed and this describes why. + /// The client should exit with a clear error message. + error: Option<String>, + }, + + /// A rendered frame to be displayed by the client. + Frame(FrameData), + + /// Server is shutting down. Clients should exit gracefully. + ServerShutdown { + /// Optional reason for the shutdown. + reason: Option<String>, + }, + + /// A notification event (sound/toast) to be rendered locally by the client. + Notify { + /// What kind of notification. + kind: NotifyKind, + /// Human-readable message. + message: String, + }, + + /// OSC 52 clipboard data forwarded from a PTY through the server. + Clipboard { + /// Base64-encoded clipboard data. + data: String, + }, +} + +// --------------------------------------------------------------------------- +// Color / Modifier conversion helpers +// --------------------------------------------------------------------------- + +/// Converts a ratatui `Color` to a packed u32 for wire transport. +/// +/// Encoding: +/// - Named colors (Reset, Black, …, White) → `0x00_00_00_XX` where XX is 0..=16 +/// - Indexed palette → `0x01_00_00_XX` where XX is the palette index +/// - RGB → `0x02_RR_GG_BB` with components in the lower 3 bytes +fn color_to_u32(color: ratatui::style::Color) -> u32 { + match color { + ratatui::style::Color::Reset => 0x00_00_00_00, + ratatui::style::Color::Black => 0x00_00_00_01, + ratatui::style::Color::Red => 0x00_00_00_02, + ratatui::style::Color::Green => 0x00_00_00_03, + ratatui::style::Color::Yellow => 0x00_00_00_04, + ratatui::style::Color::Blue => 0x00_00_00_05, + ratatui::style::Color::Magenta => 0x00_00_00_06, + ratatui::style::Color::Cyan => 0x00_00_00_07, + ratatui::style::Color::Gray => 0x00_00_00_08, + ratatui::style::Color::DarkGray => 0x00_00_00_09, + ratatui::style::Color::LightRed => 0x00_00_00_0A, + ratatui::style::Color::LightGreen => 0x00_00_00_0B, + ratatui::style::Color::LightYellow => 0x00_00_00_0C, + ratatui::style::Color::LightBlue => 0x00_00_00_0D, + ratatui::style::Color::LightMagenta => 0x00_00_00_0E, + ratatui::style::Color::LightCyan => 0x00_00_00_0F, + ratatui::style::Color::White => 0x00_00_00_10, + ratatui::style::Color::Indexed(i) => 0x01_00_00_00 | (i as u32), + ratatui::style::Color::Rgb(r, g, b) => { + 0x02_00_00_00 | ((r as u32) << 16) | ((g as u32) << 8) | (b as u32) + } + } +} + +/// Converts a packed u32 back to a ratatui `Color`. +#[cfg(test)] +fn u32_to_color(val: u32) -> ratatui::style::Color { + match val >> 24 { + 0x00 => match val & 0xFF { + 0x00 => ratatui::style::Color::Reset, + 0x01 => ratatui::style::Color::Black, + 0x02 => ratatui::style::Color::Red, + 0x03 => ratatui::style::Color::Green, + 0x04 => ratatui::style::Color::Yellow, + 0x05 => ratatui::style::Color::Blue, + 0x06 => ratatui::style::Color::Magenta, + 0x07 => ratatui::style::Color::Cyan, + 0x08 => ratatui::style::Color::Gray, + 0x09 => ratatui::style::Color::DarkGray, + 0x0A => ratatui::style::Color::LightRed, + 0x0B => ratatui::style::Color::LightGreen, + 0x0C => ratatui::style::Color::LightYellow, + 0x0D => ratatui::style::Color::LightBlue, + 0x0E => ratatui::style::Color::LightMagenta, + 0x0F => ratatui::style::Color::LightCyan, + 0x10 => ratatui::style::Color::White, + _ => ratatui::style::Color::Reset, // unknown named → Reset + }, + 0x01 => ratatui::style::Color::Indexed((val & 0xFF) as u8), + 0x02 => { + let r = ((val >> 16) & 0xFF) as u8; + let g = ((val >> 8) & 0xFF) as u8; + let b = (val & 0xFF) as u8; + ratatui::style::Color::Rgb(r, g, b) + } + _ => ratatui::style::Color::Reset, // unknown tag → Reset + } +} + +/// Converts a ratatui `Modifier` bitmask to a u16 for wire transport. +fn modifier_to_u16(modifier: ratatui::style::Modifier) -> u16 { + modifier.bits() +} + +/// Converts a u16 back to a ratatui `Modifier`. +#[cfg(test)] +fn u16_to_modifier(val: u16) -> ratatui::style::Modifier { + ratatui::style::Modifier::from_bits_truncate(val) +} + +// --------------------------------------------------------------------------- +// Framing: length-prefixed binary messages +// --------------------------------------------------------------------------- + +/// Errors that can occur during framing operations. +#[derive(Debug)] +pub enum FramingError { + /// The decoded payload length exceeds the configured maximum frame size. + Oversized { claimed: usize, max: usize }, + /// An I/O error occurred while reading or writing. + Io(io::Error), + /// Bincode serialization or deserialization failed. + Bincode(String), + /// The connection was closed before a complete frame could be read. + UnexpectedEof, +} + +impl std::fmt::Display for FramingError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + FramingError::Oversized { claimed, max } => { + write!(f, "frame size {claimed} exceeds maximum {max}") + } + FramingError::Io(e) => write!(f, "I/O error: {e}"), + FramingError::Bincode(e) => write!(f, "bincode error: {e}"), + FramingError::UnexpectedEof => write!(f, "unexpected end of stream"), + } + } +} + +impl std::error::Error for FramingError { + fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { + match self { + FramingError::Io(e) => Some(e), + _ => None, + } + } +} + +impl From<io::Error> for FramingError { + fn from(e: io::Error) -> Self { + FramingError::Io(e) + } +} + +/// Serializes a message and writes it as a length-prefixed frame: +/// `[u32LE length][bincode payload]`. +/// +/// This is a blocking/synchronous write suitable for use with `std::os::unix::net::UnixStream` +/// in blocking mode, or with any `Write` implementor. +/// +/// # Errors +/// +/// Returns `FramingError::Bincode` if the payload length exceeds `u32::MAX` +/// (would be truncated by the length prefix cast). +pub fn write_message<W: Write, M: Serialize>(writer: &mut W, msg: &M) -> Result<(), FramingError> { + let payload = bincode::serde::encode_to_vec(msg, bincode::config::standard()) + .map_err(|e| FramingError::Bincode(e.to_string()))?; + + let len = payload.len(); + if len > u32::MAX as usize { + return Err(FramingError::Bincode(format!( + "payload length {len} exceeds u32::MAX ({}), would be truncated by length prefix", + u32::MAX + ))); + } + + writer.write_all(&(len as u32).to_le_bytes())?; + writer.write_all(&payload)?; + writer.flush()?; + Ok(()) +} + +/// Reads and deserializes a length-prefixed frame from a reader. +/// +/// Reassembles partial reads correctly. Rejects frames whose declared +/// length exceeds `max_frame_size` without panicking or allocating +/// oversized buffers. +pub fn read_message<R: Read, M: for<'de> Deserialize<'de>>( + reader: &mut R, + max_frame_size: usize, +) -> Result<M, FramingError> { + // Read the 4-byte length prefix, reassembling partial reads. + let mut len_buf = [0u8; LENGTH_PREFIX_BYTES]; + read_exact_or_eof(reader, &mut len_buf)?; + let claimed_len = u32::from_le_bytes(len_buf) as usize; + + if claimed_len > max_frame_size { + return Err(FramingError::Oversized { + claimed: claimed_len, + max: max_frame_size, + }); + } + + // Read the payload, reassembling partial reads. + let mut payload = vec![0u8; claimed_len]; + read_exact_or_eof(reader, &mut payload)?; + + let (msg, consumed) = bincode::serde::decode_from_slice(&payload, bincode::config::standard()) + .map_err(|e| FramingError::Bincode(e.to_string()))?; + + // Enforce that the decoder consumed the full payload. + // Trailing bytes after the decoded message indicate a protocol violation + // (e.g., a corrupted length prefix or concatenated payloads). + if consumed != claimed_len { + return Err(FramingError::Bincode(format!( + "decoded {} bytes but payload length was {claimed_len}; trailing bytes are not allowed", + consumed + ))); + } + + Ok(msg) +} + +/// Like `Read::read_exact`, but returns `FramingError::UnexpectedEof` +/// when the reader hits end-of-stream before filling the buffer, instead +/// of the generic `io::ErrorKind::UnexpectedEof`. +fn read_exact_or_eof<R: Read>(reader: &mut R, buf: &mut [u8]) -> Result<(), FramingError> { + reader.read_exact(buf).map_err(|e| { + if e.kind() == io::ErrorKind::UnexpectedEof { + FramingError::UnexpectedEof + } else { + FramingError::Io(e) + } + }) +} + +// --------------------------------------------------------------------------- +// Version negotiation +// --------------------------------------------------------------------------- + +/// Result of checking a client's protocol version against the server's. +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum VersionCheck { + /// Versions are compatible. The server should reply `Welcome { version, error: None }`. + Compatible, + /// Versions are incompatible. The server should reply + /// `Welcome { version, error: Some(reason) }` and close the connection. + Incompatible(String), +} + +/// Checks whether a client's protocol version is compatible with this server. +/// +/// Current rules: +/// - Version 0 (pre-persistence client) is always rejected. +/// - Matching major versions are accepted. +/// - A client with a newer version than the server is rejected. +/// - A client with an older version than the server is rejected +/// (backward compatibility is not yet supported). +pub fn check_client_version(client_version: u32) -> VersionCheck { + if client_version == 0 { + return VersionCheck::Incompatible( + "pre-persistence client (version 0) is not supported".to_owned(), + ); + } + + if client_version == PROTOCOL_VERSION { + VersionCheck::Compatible + } else if client_version < PROTOCOL_VERSION { + VersionCheck::Incompatible(format!( + "client version {client_version} is older than server version {PROTOCOL_VERSION}; please upgrade your herdr client" + )) + } else { + VersionCheck::Incompatible(format!( + "client version {client_version} is newer than server version {PROTOCOL_VERSION}; please upgrade the herdr server" + )) + } +} + +// --------------------------------------------------------------------------- +// Tests +// --------------------------------------------------------------------------- + +#[cfg(test)] +mod tests { + use super::*; + use ratatui::style::{Color, Modifier}; + + // ---- Round-trip: ClientMessage ---- + + #[test] + fn client_hello_roundtrip() { + let msg = ClientMessage::Hello { + version: 1, + cols: 80, + rows: 24, + }; + let encoded = bincode::serde::encode_to_vec(&msg, bincode::config::standard()).unwrap(); + let (decoded, _): (ClientMessage, _) = + bincode::serde::decode_from_slice(&encoded, bincode::config::standard()).unwrap(); + assert_eq!(msg, decoded); + } + + #[test] + fn client_input_roundtrip() { + let msg = ClientMessage::Input { + data: vec![0x1b, 0x5b, 0x41], // ESC [ A (up arrow) + }; + let encoded = bincode::serde::encode_to_vec(&msg, bincode::config::standard()).unwrap(); + let (decoded, _): (ClientMessage, _) = + bincode::serde::decode_from_slice(&encoded, bincode::config::standard()).unwrap(); + assert_eq!(msg, decoded); + } + + #[test] + fn client_resize_roundtrip() { + let msg = ClientMessage::Resize { cols: 80, rows: 24 }; + let encoded = bincode::serde::encode_to_vec(&msg, bincode::config::standard()).unwrap(); + let (decoded, _): (ClientMessage, _) = + bincode::serde::decode_from_slice(&encoded, bincode::config::standard()).unwrap(); + assert_eq!(msg, decoded); + } + + #[test] + fn client_detach_roundtrip() { + let msg = ClientMessage::Detach; + let encoded = bincode::serde::encode_to_vec(&msg, bincode::config::standard()).unwrap(); + let (decoded, _): (ClientMessage, _) = + bincode::serde::decode_from_slice(&encoded, bincode::config::standard()).unwrap(); + assert_eq!(msg, decoded); + } + + // ---- Round-trip: ServerMessage ---- + + #[test] + fn server_welcome_roundtrip() { + let msg = ServerMessage::Welcome { + version: 1, + error: None, + }; + let encoded = bincode::serde::encode_to_vec(&msg, bincode::config::standard()).unwrap(); + let (decoded, _): (ServerMessage, _) = + bincode::serde::decode_from_slice(&encoded, bincode::config::standard()).unwrap(); + assert_eq!(msg, decoded); + } + + #[test] + fn server_welcome_with_error_roundtrip() { + let msg = ServerMessage::Welcome { + version: 1, + error: Some("incompatible version".to_owned()), + }; + let encoded = bincode::serde::encode_to_vec(&msg, bincode::config::standard()).unwrap(); + let (decoded, _): (ServerMessage, _) = + bincode::serde::decode_from_slice(&encoded, bincode::config::standard()).unwrap(); + assert_eq!(msg, decoded); + } + + #[test] + fn server_frame_roundtrip_nontrivial() { + // Build a 3×2 frame with varied styles (≥2×2). + let frame = FrameData { + cells: vec![ + CellData { + symbol: "H".into(), + fg: color_to_u32(Color::Red), + bg: color_to_u32(Color::Black), + modifier: Modifier::BOLD.bits(), + skip: false, + }, + CellData { + symbol: "i".into(), + fg: color_to_u32(Color::Green), + bg: color_to_u32(Color::Reset), + modifier: Modifier::ITALIC.bits(), + skip: false, + }, + CellData { + symbol: "!".into(), + fg: color_to_u32(Color::Rgb(255, 128, 0)), + bg: color_to_u32(Color::Indexed(220)), + modifier: (Modifier::BOLD | Modifier::UNDERLINED).bits(), + skip: false, + }, + CellData { + symbol: " ".into(), + fg: color_to_u32(Color::Reset), + bg: color_to_u32(Color::Reset), + modifier: Modifier::empty().bits(), + skip: true, + }, + CellData { + symbol: "→".into(), // multi-byte grapheme + fg: color_to_u32(Color::Cyan), + bg: color_to_u32(Color::Blue), + modifier: Modifier::REVERSED.bits(), + skip: false, + }, + CellData { + symbol: "🦀".into(), // emoji, wide grapheme cluster + fg: color_to_u32(Color::Yellow), + bg: color_to_u32(Color::Magenta), + modifier: Modifier::empty().bits(), + skip: false, + }, + ], + width: 3, + height: 2, + cursor: Some(CursorState { + x: 0, + y: 0, + visible: true, + }), + }; + let msg = ServerMessage::Frame(frame.clone()); + let encoded = bincode::serde::encode_to_vec(&msg, bincode::config::standard()).unwrap(); + let (decoded, _): (ServerMessage, _) = + bincode::serde::decode_from_slice(&encoded, bincode::config::standard()).unwrap(); + assert_eq!(msg, decoded); + } + + #[test] + fn server_shutdown_roundtrip() { + let msg = ServerMessage::ServerShutdown { + reason: Some("updating".to_owned()), + }; + let encoded = bincode::serde::encode_to_vec(&msg, bincode::config::standard()).unwrap(); + let (decoded, _): (ServerMessage, _) = + bincode::serde::decode_from_slice(&encoded, bincode::config::standard()).unwrap(); + assert_eq!(msg, decoded); + } + + #[test] + fn server_notify_roundtrip() { + let msg = ServerMessage::Notify { + kind: NotifyKind::Sound, + message: "agent done".to_owned(), + }; + let encoded = bincode::serde::encode_to_vec(&msg, bincode::config::standard()).unwrap(); + let (decoded, _): (ServerMessage, _) = + bincode::serde::decode_from_slice(&encoded, bincode::config::standard()).unwrap(); + assert_eq!(msg, decoded); + } + + #[test] + fn server_clipboard_roundtrip() { + let msg = ServerMessage::Clipboard { + data: "dGVzdA==".to_owned(), // base64 "test" + }; + let encoded = bincode::serde::encode_to_vec(&msg, bincode::config::standard()).unwrap(); + let (decoded, _): (ServerMessage, _) = + bincode::serde::decode_from_slice(&encoded, bincode::config::standard()).unwrap(); + assert_eq!(msg, decoded); + } + + // ---- Framing ---- + + #[test] + fn framing_small_message_roundtrip() { + let msg = ClientMessage::Hello { + version: 1, + cols: 80, + rows: 24, + }; + let mut buf = Vec::new(); + write_message(&mut buf, &msg).unwrap(); + let decoded: ClientMessage = read_message(&mut buf.as_slice(), MAX_FRAME_SIZE).unwrap(); + assert_eq!(msg, decoded); + } + + #[test] + fn framing_large_payload_roundtrip() { + // Create a Frame message that is ≥128 KB. + // Use a large frame with verbose cell data to exceed 128 KB after bincode encoding. + // 200×50 = 10000 cells. With varied symbols and styles, this should easily exceed 128 KB. + let width: u16 = 200; + let height: u16 = 50; + let cells: Vec<CellData> = (0..(width as usize) * (height as usize)) + .map(|i| CellData { + symbol: if i % 256 < 32 { + " ".to_owned() + } else { + format!("{:03}", i % 1000) + }, + fg: color_to_u32(Color::Rgb((i % 256) as u8, ((i / 256) % 256) as u8, 128)), + bg: color_to_u32(Color::Indexed((i % 256) as u8)), + modifier: ((i % 16) as u16), + skip: i % 100 == 0, + }) + .collect(); + + let frame = FrameData { + cells, + width, + height, + cursor: Some(CursorState { + x: 10, + y: 5, + visible: true, + }), + }; + let msg = ServerMessage::Frame(frame); + + let mut buf = Vec::new(); + write_message(&mut buf, &msg).unwrap(); + // Verify the payload is at least 128 KB + assert!( + buf.len() >= 128 * 1024, + "framed payload should be >= 128 KB, got {} bytes", + buf.len() + ); + + let decoded: ServerMessage = read_message(&mut buf.as_slice(), MAX_FRAME_SIZE).unwrap(); + assert_eq!(msg, decoded); + } + + #[test] + fn framing_multiple_messages_sequential() { + // Write 100+ messages of varying types and read them back. + let mut buf = Vec::new(); + let mut expected = Vec::new(); + + for i in 0..150u32 { + let msg = match i % 4 { + 0 => ClientMessage::Hello { + version: 1, + cols: (80 + (i % 40) as u16), + rows: (24 + (i % 20) as u16), + }, + 1 => ClientMessage::Input { + data: vec![(i % 256) as u8; (i as usize % 50) + 1], + }, + 2 => ClientMessage::Resize { + cols: (100 + (i % 30) as u16), + rows: (30 + (i % 10) as u16), + }, + 3 => ClientMessage::Detach, + _ => unreachable!(), + }; + write_message(&mut buf, &msg).unwrap(); + expected.push(msg); + } + + let mut cursor = buf.as_slice(); + for expected_msg in &expected { + let decoded: ClientMessage = read_message(&mut cursor, MAX_FRAME_SIZE).unwrap(); + assert_eq!(*expected_msg, decoded); + } + } + + #[test] + fn framing_oversized_rejected_without_panic() { + // Craft a frame with a huge length prefix (4 GB claim). + let mut buf: Vec<u8> = (u32::MAX).to_le_bytes().to_vec(); + // Add a few garbage bytes after the length prefix. + buf.extend_from_slice(&[0xDE, 0xAD, 0xBE, 0xEF]); + + let result: Result<ClientMessage, FramingError> = + read_message(&mut buf.as_slice(), MAX_FRAME_SIZE); + match result { + Err(FramingError::Oversized { claimed, max }) => { + assert_eq!(claimed, u32::MAX as usize); + assert_eq!(max, MAX_FRAME_SIZE); + } + other => panic!("expected Oversized error, got: {other:?}"), + } + } + + #[test] + fn framing_malformed_payload_rejected_without_panic() { + // Valid length prefix pointing to garbage data. + let payload = vec![0xDE, 0xAD, 0xBE, 0xEF, 0x01, 0x02]; + let mut buf = (payload.len() as u32).to_le_bytes().to_vec(); + buf.extend_from_slice(&payload); + + let result: Result<ClientMessage, FramingError> = + read_message(&mut buf.as_slice(), MAX_FRAME_SIZE); + assert!(result.is_err(), "malformed payload should be rejected"); + match result { + Err(FramingError::Bincode(_)) => {} // expected + other => panic!("expected Bincode error, got: {other:?}"), + } + } + + #[test] + fn framing_truncated_stream_returns_unexpected_eof() { + // Write a length prefix claiming 100 bytes, but only provide 4. + let mut buf: Vec<u8> = 100u32.to_le_bytes().to_vec(); + buf.extend_from_slice(&[0xAA, 0xBB, 0xCC, 0xDD]); + + let result: Result<ClientMessage, FramingError> = + read_message(&mut buf.as_slice(), MAX_FRAME_SIZE); + match result { + Err(FramingError::UnexpectedEof) => {} + other => panic!("expected UnexpectedEof, got: {other:?}"), + } + } + + #[test] + fn framing_zero_length_message() { + // A 1-byte message (smallest possible valid bincode payload). + // Actually, let's test with the smallest real message: Detach. + let msg = ClientMessage::Detach; + let mut buf = Vec::new(); + write_message(&mut buf, &msg).unwrap(); + + // Verify the length prefix is correct + let len = u32::from_le_bytes(buf[..4].try_into().unwrap()) as usize; + assert_eq!( + len, + buf.len() - 4, + "length prefix should match payload size" + ); + + let decoded: ClientMessage = read_message(&mut buf.as_slice(), MAX_FRAME_SIZE).unwrap(); + assert_eq!(msg, decoded); + } + + #[test] + fn framing_partial_read_reassembly() { + // Simulate partial reads by using a reader that yields small chunks. + let msg = ClientMessage::Input { + data: vec![42; 500], // 500-byte input payload + }; + let mut full_buf = Vec::new(); + write_message(&mut full_buf, &msg).unwrap(); + + // Wrap in a chunked reader that only yields 7 bytes at a time. + let mut chunked = ChunkedReader::new(full_buf, 7); + let decoded: ClientMessage = read_message(&mut chunked, MAX_FRAME_SIZE).unwrap(); + assert_eq!(msg, decoded); + } + + // ---- Version negotiation ---- + + #[test] + fn version_compatible() { + assert_eq!(check_client_version(1), VersionCheck::Compatible); + } + + #[test] + fn version_older_client_rejected() { + match check_client_version(1) { + VersionCheck::Compatible => {} // current version + _ => panic!("current version should be compatible"), + } + // If we imagine a future server version 2, a v1 client would be rejected. + // We test this by checking the logic directly. + let result = check_client_version(0); + assert!( + matches!(result, VersionCheck::Incompatible(_)), + "version 0 should be incompatible" + ); + } + + #[test] + fn version_newer_client_rejected() { + let result = check_client_version(PROTOCOL_VERSION + 1); + assert!(matches!(result, VersionCheck::Incompatible(_))); + if let VersionCheck::Incompatible(msg) = result { + assert!(msg.contains("newer"), "error should mention newer version"); + } + } + + // ---- Pre-persistence client rejection ---- + + #[test] + fn prepersistence_version_zero_rejected() { + let result = check_client_version(0); + match result { + VersionCheck::Incompatible(msg) => { + assert!( + msg.contains("pre-persistence"), + "error should mention pre-persistence: {msg}" + ); + } + _ => panic!("version 0 should be rejected as incompatible"), + } + } + + #[test] + fn prepersistence_version_zero_welcome_has_error() { + // Simulating what the server would send to a v0 client. + let check = check_client_version(0); + let response = match check { + VersionCheck::Compatible => ServerMessage::Welcome { + version: PROTOCOL_VERSION, + error: None, + }, + VersionCheck::Incompatible(reason) => ServerMessage::Welcome { + version: PROTOCOL_VERSION, + error: Some(reason), + }, + }; + + match response { + ServerMessage::Welcome { error: Some(_), .. } => {} + other => panic!("expected Welcome with error, got: {other:?}"), + } + } + + // ---- Malformed/oversized input ---- + + #[test] + fn oversized_frame_does_not_panic() { + // Claim 4GB payload — should return Oversized error, not panic. + let mut buf: Vec<u8> = 0xFFC00000u32.to_le_bytes().to_vec(); // ~4 GB claim + buf.extend_from_slice(&[0; 8]); + + let result: Result<ClientMessage, FramingError> = + read_message(&mut buf.as_slice(), MAX_FRAME_SIZE); + assert!(result.is_err()); + // Did not panic — test passing is proof. + } + + #[test] + fn malformed_frame_does_not_panic() { + // Random garbage bytes after a valid-ish length prefix. + let garbage: Vec<u8> = (0..200).map(|i| (i ^ 0xAA) as u8).collect(); + let mut buf = (garbage.len() as u32).to_le_bytes().to_vec(); + buf.extend_from_slice(&garbage); + + let result: Result<ClientMessage, FramingError> = + read_message(&mut buf.as_slice(), MAX_FRAME_SIZE); + assert!(result.is_err()); + // Did not panic. + } + + #[test] + fn oversized_input_rejected_custom_max() { + // Verify a custom (small) max_frame_size is enforced. + let msg = ClientMessage::Input { + data: vec![0x41; 1000], + }; + let mut buf = Vec::new(); + write_message(&mut buf, &msg).unwrap(); + + let result: Result<ClientMessage, FramingError> = read_message(&mut buf.as_slice(), 64); + // The actual bincode payload for 1000 bytes of input will be > 64 bytes. + assert!( + matches!(result, Err(FramingError::Oversized { .. })), + "expected Oversized with small max_frame_size" + ); + } + + // ---- FrameData ↔ ratatui Buffer conversion ---- + + #[test] + fn frame_data_roundtrip_through_ratatui_buffer() { + let area = ratatui::layout::Rect::new(0, 0, 5, 3); + let mut buffer = ratatui::buffer::Buffer::filled(area, ratatui::buffer::Cell::new(" ")); + + // Write some styled content. + buffer.cell_mut((0, 0)).unwrap().set_symbol("H"); + buffer.cell_mut((0, 0)).unwrap().fg = Color::Red; + buffer.cell_mut((0, 0)).unwrap().modifier = Modifier::BOLD; + + buffer.cell_mut((1, 0)).unwrap().set_symbol("i"); + buffer.cell_mut((1, 0)).unwrap().fg = Color::Green; + buffer.cell_mut((1, 0)).unwrap().modifier = Modifier::ITALIC; + + buffer.cell_mut((2, 0)).unwrap().set_symbol("!"); + buffer.cell_mut((2, 0)).unwrap().fg = Color::Rgb(255, 128, 0); + buffer.cell_mut((2, 0)).unwrap().bg = Color::Indexed(220); + + let cursor = CursorState { + x: 1, + y: 0, + visible: true, + }; + let frame = FrameData::from_ratatui_buffer(&buffer, Some(cursor.clone())); + + // Verify frame dimensions. + assert_eq!(frame.width, 5); + assert_eq!(frame.height, 3); + assert_eq!(frame.cells.len(), 15); + assert_eq!(frame.cursor, Some(cursor)); + + // Verify specific cells survived the conversion. + assert_eq!(frame.cells[0].symbol, "H"); + assert_eq!(frame.cells[0].fg, color_to_u32(Color::Red)); + assert_eq!(frame.cells[0].modifier, Modifier::BOLD.bits()); + + assert_eq!(frame.cells[1].symbol, "i"); + assert_eq!(frame.cells[1].fg, color_to_u32(Color::Green)); + assert_eq!(frame.cells[1].modifier, Modifier::ITALIC.bits()); + + assert_eq!(frame.cells[2].symbol, "!"); + assert_eq!(frame.cells[2].fg, color_to_u32(Color::Rgb(255, 128, 0))); + assert_eq!(frame.cells[2].bg, color_to_u32(Color::Indexed(220))); + + // Convert back to ratatui buffer and compare. + let restored = frame.to_ratatui_buffer().expect("should reconstruct"); + assert_eq!(restored.area, area); + assert_eq!(restored.cell((0, 0)).unwrap().symbol(), "H"); + assert_eq!(restored.cell((0, 0)).unwrap().fg, Color::Red); + assert_eq!(restored.cell((0, 0)).unwrap().modifier, Modifier::BOLD); + assert_eq!(restored.cell((1, 0)).unwrap().symbol(), "i"); + assert_eq!(restored.cell((2, 0)).unwrap().symbol(), "!"); + assert_eq!(restored.cell((2, 0)).unwrap().fg, Color::Rgb(255, 128, 0)); + } + + #[test] + fn frame_data_rejects_mismatched_cell_count() { + let frame = FrameData { + cells: vec![ + CellData { + symbol: "X".into(), + fg: 0, + bg: 0, + modifier: 0, + skip: false, + }; + 5 + ], // 5 cells but 3×2 = 6 expected + width: 3, + height: 2, + cursor: None, + }; + assert!(frame.to_ratatui_buffer().is_none()); + } + + // ---- Color conversion coverage ---- + + #[test] + fn color_roundtrip_all_named_colors() { + let named = [ + Color::Reset, + Color::Black, + Color::Red, + Color::Green, + Color::Yellow, + Color::Blue, + Color::Magenta, + Color::Cyan, + Color::Gray, + Color::DarkGray, + Color::LightRed, + Color::LightGreen, + Color::LightYellow, + Color::LightBlue, + Color::LightMagenta, + Color::LightCyan, + Color::White, + ]; + for c in named { + assert_eq!( + u32_to_color(color_to_u32(c)), + c, + "roundtrip failed for {c:?}" + ); + } + } + + #[test] + fn color_roundtrip_indexed() { + for i in 0..=255u8 { + let c = Color::Indexed(i); + assert_eq!( + u32_to_color(color_to_u32(c)), + c, + "roundtrip failed for Indexed({i})" + ); + } + } + + #[test] + fn color_roundtrip_rgb() { + let c = Color::Rgb(0xAB, 0xCD, 0xEF); + assert_eq!(u32_to_color(color_to_u32(c)), c); + + let c = Color::Rgb(0, 0, 0); + assert_eq!(u32_to_color(color_to_u32(c)), c); + + let c = Color::Rgb(255, 255, 255); + assert_eq!(u32_to_color(color_to_u32(c)), c); + } + + // ---- Modifier conversion ---- + + #[test] + fn modifier_roundtrip() { + let all_mods = [ + Modifier::BOLD, + Modifier::ITALIC, + Modifier::REVERSED, + Modifier::UNDERLINED, + Modifier::DIM, + Modifier::SLOW_BLINK, + Modifier::CROSSED_OUT, + Modifier::BOLD | Modifier::ITALIC, + Modifier::BOLD | Modifier::UNDERLINED | Modifier::REVERSED, + Modifier::empty(), + ]; + for m in all_mods { + assert_eq!( + u16_to_modifier(modifier_to_u16(m)), + m, + "roundtrip failed for {m:?}" + ); + } + } + + #[test] + fn read_message_rejects_trailing_bytes() { + // Encode a valid message, then append an extra byte after it. + let msg = ClientMessage::Detach; + let mut payload = bincode::serde::encode_to_vec(&msg, bincode::config::standard()).unwrap(); + let original_len = payload.len(); + payload.push(0xDE); // trailing garbage + + // Frame it with the inflated length (original + 1). + let mut buf = (payload.len() as u32).to_le_bytes().to_vec(); + buf.extend_from_slice(&payload); + + let result: Result<ClientMessage, FramingError> = + read_message(&mut buf.as_slice(), MAX_FRAME_SIZE); + match result { + Err(FramingError::Bincode(msg)) => { + assert!( + msg.contains("trailing bytes"), + "error should mention trailing bytes: {msg}" + ); + assert!( + msg.contains(&format!("decoded {original_len}")), + "error should mention decoded byte count: {msg}" + ); + } + other => panic!("expected Bincode error about trailing bytes, got: {other:?}"), + } + } + + #[test] + fn read_message_accepts_exact_payload() { + // A normally-framed message should decode without error. + let msg = ClientMessage::Hello { + version: 1, + cols: 80, + rows: 24, + }; + let mut buf = Vec::new(); + write_message(&mut buf, &msg).unwrap(); + let decoded: ClientMessage = read_message(&mut buf.as_slice(), MAX_FRAME_SIZE).unwrap(); + assert_eq!(msg, decoded); + } + + #[test] + fn write_message_rejects_oversized_payload() { + // We can't easily create a message that exceeds u32::MAX in a test, + // but we can verify the check exists by testing that normal messages + // have lengths well within the limit and the function doesn't fail. + let msg = ClientMessage::Detach; + let mut buf = Vec::new(); + assert!(write_message(&mut buf, &msg).is_ok()); + } + + // ---- Unix socketpair integration test ---- + + #[test] + fn framing_over_unix_socketpair() { + use std::os::unix::net::UnixStream; + + let (mut a, mut b) = UnixStream::pair().expect("socketpair"); + + let messages = vec![ + ClientMessage::Hello { + version: 1, + cols: 200, + rows: 60, + }, + ClientMessage::Input { + data: b"hello world".to_vec(), + }, + ClientMessage::Resize { + cols: 100, + rows: 30, + }, + ClientMessage::Detach, + ]; + + // Set non-blocking so we can write and read in the same test. + a.set_nonblocking(false).unwrap(); + b.set_nonblocking(false).unwrap(); + + for msg in &messages { + write_message(&mut a, msg).unwrap(); + } + + for expected in &messages { + let decoded: ClientMessage = read_message(&mut b, MAX_FRAME_SIZE).unwrap(); + assert_eq!(*expected, decoded); + } + } + + // ---- Helper: chunked reader for simulating partial reads ---- + + /// A `Read` wrapper that yields at most `chunk_size` bytes per `read()` call, + /// simulating partial reads on a real socket. + struct ChunkedReader { + data: Vec<u8>, + pos: usize, + chunk_size: usize, + } + + impl ChunkedReader { + fn new(data: Vec<u8>, chunk_size: usize) -> Self { + Self { + data, + pos: 0, + chunk_size, + } + } + } + + impl Read for ChunkedReader { + fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { + if self.pos >= self.data.len() { + return Ok(0); + } + let remaining = self.data.len() - self.pos; + let to_read = buf.len().min(remaining).min(self.chunk_size); + buf[..to_read].copy_from_slice(&self.data[self.pos..self.pos + to_read]); + self.pos += to_read; + Ok(to_read) + } + } +} @@ -1,15 +1,64 @@ use ratatui::{ - layout::{Alignment, Constraint, Layout, Rect}, - style::{Color, Modifier, Style}, - text::{Line, Span}, - widgets::{Block, Borders, Clear, List, ListItem, ListState, Paragraph, Tabs, Wrap}, + layout::{Constraint, Layout, Rect}, + style::{Modifier, Style}, + text::Span, Frame, }; -use crate::app::state::{AgentPanelScope, ToastKind, ToastNotification}; +mod dialogs; +mod keybind_help; +mod menus; +mod onboarding; +mod panes; +mod release_notes; +mod scrollbar; +mod settings; +mod sidebar; +mod status; +mod tabs; +mod widgets; + +use self::dialogs::{render_confirm_close_overlay, render_rename_overlay}; +use self::keybind_help::render_keybind_help_overlay; +use self::menus::{ + render_context_menu, render_global_launcher_menu, render_navigate_overlay, + render_resize_overlay, +}; +use self::onboarding::render_onboarding_overlay; +pub(crate) use self::onboarding::{ + onboarding_notification_button_rects, onboarding_welcome_continue_rect, +}; +use self::panes::{compute_pane_infos, render_panes}; +use self::release_notes::render_release_notes_overlay; +pub(crate) use self::release_notes::{ + release_notes_close_button_rect, release_notes_display_lines, release_notes_sections, + RELEASE_NOTES_MODAL_SIZE, +}; +pub(crate) use self::scrollbar::{ + pane_scrollbar_rect, release_notes_scrollbar_rect, scrollbar_offset_from_drag_row, + scrollbar_offset_from_row, scrollbar_thumb_grab_offset, should_show_scrollbar, +}; +use self::settings::render_settings_overlay; +use self::sidebar::{render_sidebar, render_sidebar_collapsed}; +use self::status::{render_config_diagnostic, render_toast_notification}; +use self::tabs::render_tab_bar; +pub(crate) use self::{ + dialogs::{confirm_close_button_rects, confirm_close_popup_rect, rename_button_rects}, + settings::settings_button_rects, + sidebar::{ + agent_panel_body_rect, agent_panel_entries, agent_panel_scroll_metrics, + agent_panel_scrollbar_rect, agent_panel_toggle_rect, collapsed_sidebar_sections, + collapsed_sidebar_toggle_rect, compute_workspace_card_areas, expanded_sidebar_sections, + sidebar_section_divider_rect, workspace_drop_indicator_row, workspace_list_rect, + workspace_list_scroll_metrics, workspace_list_scrollbar_rect, + }, +}; +pub(crate) use self::{ + keybind_help::keybind_help_lines, + tabs::compute_tab_bar_view, + widgets::{centered_popup_rect, modal_stack_areas}, +}; use crate::app::{AppState, Mode}; -use crate::detect::AgentState; -use crate::layout::PaneInfo; const COLLAPSED_WIDTH: u16 = 4; // num + space + dot + separator pub(crate) const MIN_SIDEBAR_WIDTH: u16 = 18; @@ -20,211 +69,26 @@ const SPINNERS: &[&str] = &["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", " /// Map spinner_tick (incremented every frame at ~60fps) to a spinner frame. /// We want ~8 updates/sec so divide by 8. -fn spinner_frame(tick: u32) -> &'static str { +pub(super) fn spinner_frame(tick: u32) -> &'static str { SPINNERS[(tick as usize / 8) % SPINNERS.len()] } -use crate::app::state::Palette; - -pub(crate) struct AgentPanelEntry { - pub ws_idx: usize, - pub tab_idx: usize, - pub pane_id: crate::layout::PaneId, - pub primary_label: String, - pub primary_tab_label: Option<String>, - pub agent_label: Option<String>, - pub state: AgentState, - pub seen: bool, -} - -fn sidebar_section_heights(total_h: u16, split_ratio: f32) -> (u16, u16) { - if total_h == 0 { - return (0, 0); - } - - if total_h < 6 { - let ws_h = (total_h + 1) / 2; - return (ws_h, total_h.saturating_sub(ws_h)); - } - - let ratio = split_ratio.clamp(0.1, 0.9); - let ws_h = ((total_h as f32) * ratio).round() as u16; - let ws_h = ws_h.clamp(3, total_h.saturating_sub(3)); - let detail_h = total_h.saturating_sub(ws_h); - (ws_h, detail_h) -} - -pub(crate) fn expanded_sidebar_sections(area: Rect, split_ratio: f32) -> (Rect, Rect) { - let content = Rect::new(area.x, area.y, area.width.saturating_sub(1), area.height); - if content.width == 0 || content.height == 0 { - return (Rect::default(), Rect::default()); - } - - let (ws_h, detail_h) = sidebar_section_heights(content.height, split_ratio); - let ws_area = Rect::new(content.x, content.y, content.width, ws_h); - let detail_area = Rect::new(content.x, content.y + ws_h, content.width, detail_h); - (ws_area, detail_area) -} - -pub(crate) fn sidebar_section_divider_rect(area: Rect, split_ratio: f32) -> Rect { - let content = Rect::new(area.x, area.y, area.width.saturating_sub(1), area.height); - if content.width == 0 || content.height < 6 { - return Rect::default(); - } - - let (ws_h, _) = sidebar_section_heights(content.height, split_ratio); - Rect::new(content.x, content.y + ws_h, content.width, 1) -} - -fn agent_panel_current_workspace_idx(app: &AppState) -> Option<usize> { - if matches!( - app.mode, - Mode::Navigate - | Mode::RenameWorkspace - | Mode::Resize - | Mode::ConfirmClose - | Mode::ContextMenu - | Mode::Settings - | Mode::GlobalMenu - | Mode::KeybindHelp - ) { - Some(app.selected) - } else { - app.active - } -} - -fn agent_panel_toggle_label(scope: AgentPanelScope) -> &'static str { - match scope { - AgentPanelScope::CurrentWorkspace => "current", - AgentPanelScope::AllWorkspaces => "all", - } -} - -pub(crate) fn agent_panel_toggle_rect(area: Rect, scope: AgentPanelScope) -> Rect { - if area.width == 0 || area.height < 2 { - return Rect::default(); - } - - let label = agent_panel_toggle_label(scope); - let width = label.chars().count() as u16; - Rect::new( - area.x + area.width.saturating_sub(width), - area.y + 1, - width, - 1, - ) -} - -pub(crate) fn agent_panel_entries(app: &AppState) -> Vec<AgentPanelEntry> { - match app.agent_panel_scope { - AgentPanelScope::CurrentWorkspace => { - let Some(ws_idx) = agent_panel_current_workspace_idx(app) else { - return Vec::new(); - }; - let Some(ws) = app.workspaces.get(ws_idx) else { - return Vec::new(); - }; - ws.pane_details() - .into_iter() - .map(|detail| AgentPanelEntry { - ws_idx, - tab_idx: detail.tab_idx, - pane_id: detail.pane_id, - primary_label: detail.label, - primary_tab_label: None, - agent_label: None, - state: detail.state, - seen: detail.seen, - }) - .collect() - } - AgentPanelScope::AllWorkspaces => app - .workspaces - .iter() - .enumerate() - .flat_map(|(ws_idx, ws)| { - let multi_tab = ws.tabs.len() > 1; - let workspace_label = ws.display_name(); - ws.pane_details() - .into_iter() - .map(move |detail| AgentPanelEntry { - ws_idx, - tab_idx: detail.tab_idx, - pane_id: detail.pane_id, - primary_label: workspace_label.clone(), - primary_tab_label: multi_tab.then_some(detail.tab_label), - agent_label: Some(detail.agent_label), - state: detail.state, - seen: detail.seen, - }) - }) - .collect(), - } -} - -fn truncate_text(text: &str, max_width: usize) -> String { - let len = text.chars().count(); - if len <= max_width { - return text.to_string(); - } - if max_width == 0 { - return String::new(); - } - if max_width == 1 { - return "…".to_string(); - } - let prefix: String = text.chars().take(max_width.saturating_sub(1)).collect(); - format!("{prefix}…") +/// Compute view geometry and reconcile pane sizes. +/// Called before render to separate mutation from drawing. +pub fn compute_view(app: &mut AppState, area: Rect) { + compute_view_internal(app, area, true); } -fn format_agent_panel_primary_label(entry: &AgentPanelEntry, max_width: usize) -> String { - let Some(tab_label) = entry.primary_tab_label.as_deref() else { - return truncate_text(&entry.primary_label, max_width); - }; - - let separator = " · "; - let separator_width = separator.chars().count(); - if max_width <= separator_width + 2 { - return truncate_text( - &format!("{}{}{}", entry.primary_label, separator, tab_label), - max_width, - ); - } - - let available = max_width.saturating_sub(separator_width); - let min_tab = 4.min(available.saturating_sub(1)).max(1); - let preferred_workspace = ((available * 2) / 3).max(1); - let mut workspace_budget = preferred_workspace - .min(available.saturating_sub(min_tab)) - .max(1); - let mut tab_budget = available.saturating_sub(workspace_budget); - - let workspace_len = entry.primary_label.chars().count(); - let tab_len = tab_label.chars().count(); - - if workspace_len < workspace_budget { - let spare = workspace_budget - workspace_len; - workspace_budget = workspace_len; - tab_budget = (tab_budget + spare).min(available.saturating_sub(workspace_budget)); - } - if tab_len < tab_budget { - let spare = tab_budget - tab_len; - tab_budget = tab_len; - workspace_budget = (workspace_budget + spare).min(available.saturating_sub(tab_budget)); - } - - format!( - "{}{}{}", - truncate_text(&entry.primary_label, workspace_budget), - separator, - truncate_text(tab_label, tab_budget) - ) +/// Compute view geometry for a client-sized render without resizing pane runtimes. +/// +/// This is used by the headless server when a non-foreground client needs its +/// own frame size while the shared pane runtimes stay pinned to the foreground +/// client. +pub(crate) fn compute_view_without_resizing_panes(app: &mut AppState, area: Rect) { + compute_view_internal(app, area, false); } -/// Compute view geometry and reconcile pane sizes. -/// Called before render to separate mutation from drawing. -pub fn compute_view(app: &mut AppState, area: Rect) { +fn compute_view_internal(app: &mut AppState, area: Rect, resize_panes: bool) { let sidebar_w = if app.sidebar_collapsed { COLLAPSED_WIDTH } else { @@ -281,7 +145,7 @@ pub fn compute_view(app: &mut AppState, area: Rect) { .map(|ws| ws.layout.splits(terminal_area)) .unwrap_or_default(); - let pane_infos = compute_pane_infos(app, terminal_area); + let pane_infos = compute_pane_infos(app, terminal_area, resize_panes); app.view = crate::app::ViewState { sidebar_rect: sidebar_area, @@ -343,1454 +207,6 @@ pub fn render(app: &AppState, frame: &mut Frame) { } } -const MIN_TAB_WIDTH: u16 = 8; -const NEW_TAB_WIDTH: u16 = 3; -const TAB_SCROLL_BUTTON_WIDTH: u16 = 3; -const WORKSPACE_SECTION_HEADER_ROWS: u16 = 2; -const AGENT_PANEL_HEADER_ROWS: u16 = 3; - -#[derive(Default)] -pub(crate) struct TabBarView { - pub scroll: usize, - pub tab_hit_areas: Vec<Rect>, - pub scroll_left_hit_area: Rect, - pub scroll_right_hit_area: Rect, - pub new_tab_hit_area: Rect, -} - -fn workspace_row_height(ws: &crate::workspace::Workspace) -> u16 { - if ws.branch().is_some() { - 2 - } else { - 1 - } -} - -pub(crate) fn workspace_list_rect(area: Rect, split_ratio: f32) -> Rect { - let (ws_area, _) = expanded_sidebar_sections(area, split_ratio); - ws_area -} - -pub(crate) fn workspace_list_body_rect(area: Rect, has_scrollbar: bool) -> Rect { - if area.width == 0 || area.height <= WORKSPACE_SECTION_HEADER_ROWS { - return Rect::default(); - } - - let body_y = area.y.saturating_add(WORKSPACE_SECTION_HEADER_ROWS); - let footer_y = area.y + area.height.saturating_sub(1); - let body_height = footer_y.saturating_sub(body_y); - let body_width = area.width.saturating_sub(u16::from(has_scrollbar)); - Rect::new(area.x, body_y, body_width, body_height) -} - -fn workspace_list_visible_count(app: &AppState, area: Rect, scroll: usize) -> usize { - let body = workspace_list_body_rect(area, false); - if body.width == 0 || body.height == 0 { - return 0; - } - - let mut used_rows = 0u16; - let mut visible = 0usize; - for ws in app.workspaces.iter().skip(scroll) { - let needed = workspace_row_height(ws).saturating_add(1); - if used_rows.saturating_add(needed) > body.height { - break; - } - used_rows = used_rows.saturating_add(needed); - visible += 1; - } - visible -} - -pub(crate) fn workspace_list_scroll_metrics( - app: &AppState, - area: Rect, -) -> crate::pane::ScrollMetrics { - let viewport_rows = workspace_list_visible_count(app, area, app.workspace_scroll); - let total_rows = app.workspaces.len(); - let max_offset_from_bottom = total_rows.saturating_sub(viewport_rows); - let offset_from_bottom = total_rows - .saturating_sub(app.workspace_scroll) - .saturating_sub(viewport_rows); - - crate::pane::ScrollMetrics { - offset_from_bottom, - max_offset_from_bottom, - viewport_rows, - } -} - -pub(crate) fn workspace_list_scrollbar_rect(app: &AppState, area: Rect) -> Option<Rect> { - let metrics = workspace_list_scroll_metrics(app, area); - let body = workspace_list_body_rect(area, true); - (should_show_scrollbar(metrics) && body.width > 0 && body.height > 0).then_some(Rect::new( - area.x + area.width.saturating_sub(1), - body.y, - 1, - body.height, - )) -} - -pub(crate) fn agent_panel_body_rect(area: Rect, has_scrollbar: bool) -> Rect { - if area.width == 0 || area.height <= AGENT_PANEL_HEADER_ROWS { - return Rect::default(); - } - - let body_y = area.y.saturating_add(AGENT_PANEL_HEADER_ROWS); - let body_height = (area.y + area.height).saturating_sub(body_y); - let body_width = area.width.saturating_sub(u16::from(has_scrollbar)); - Rect::new(area.x, body_y, body_width, body_height) -} - -fn agent_panel_visible_count(area: Rect) -> usize { - let body = agent_panel_body_rect(area, false); - if body.width == 0 || body.height < 2 { - return 0; - } - - let mut used_rows = 0u16; - let mut visible = 0usize; - while used_rows.saturating_add(2) <= body.height { - used_rows = used_rows.saturating_add(2); - visible += 1; - if used_rows < body.height { - used_rows = used_rows.saturating_add(1); - } - } - visible -} - -pub(crate) fn agent_panel_scroll_metrics(app: &AppState, area: Rect) -> crate::pane::ScrollMetrics { - let viewport_rows = agent_panel_visible_count(area); - let total_rows = agent_panel_entries(app).len(); - let max_offset_from_bottom = total_rows.saturating_sub(viewport_rows); - let offset_from_bottom = total_rows - .saturating_sub(app.agent_panel_scroll) - .saturating_sub(viewport_rows); - - crate::pane::ScrollMetrics { - offset_from_bottom, - max_offset_from_bottom, - viewport_rows, - } -} - -pub(crate) fn agent_panel_scrollbar_rect(app: &AppState, area: Rect) -> Option<Rect> { - let metrics = agent_panel_scroll_metrics(app, area); - let body = agent_panel_body_rect(area, true); - (should_show_scrollbar(metrics) && body.width > 0 && body.height > 0).then_some(Rect::new( - area.x + area.width.saturating_sub(1), - body.y, - 1, - body.height, - )) -} - -pub(crate) fn compute_workspace_card_areas( - app: &AppState, - area: Rect, -) -> Vec<crate::app::state::WorkspaceCardArea> { - let ws_area = workspace_list_rect(area, app.sidebar_section_split); - if ws_area == Rect::default() { - return Vec::new(); - } - - let metrics = workspace_list_scroll_metrics(app, ws_area); - let body = workspace_list_body_rect(ws_area, should_show_scrollbar(metrics)); - if body.width == 0 || body.height == 0 { - return Vec::new(); - } - - let mut row_y = body.y; - let body_bottom = body.y + body.height; - let mut cards = Vec::new(); - - for (ws_idx, ws) in app.workspaces.iter().enumerate().skip(app.workspace_scroll) { - let row_height = workspace_row_height(ws); - if row_y.saturating_add(row_height).saturating_add(1) > body_bottom { - break; - } - cards.push(crate::app::state::WorkspaceCardArea { - ws_idx, - rect: Rect::new(body.x, row_y, body.width, row_height), - }); - row_y = row_y.saturating_add(row_height + 1); - } - - cards -} - -fn tab_width(tab: &crate::workspace::Tab) -> u16 { - (tab.display_name().chars().count() as u16 + 4).max(MIN_TAB_WIDTH) -} - -fn layout_tab_hit_areas(ws: &crate::workspace::Workspace, area: Rect, scroll: usize) -> Vec<Rect> { - let mut rects = vec![Rect::default(); ws.tabs.len()]; - if area.width == 0 || area.height == 0 { - return rects; - } - - let mut x = area.x; - let right = area.x + area.width; - for idx in scroll..ws.tabs.len() { - if x >= right { - break; - } - let desired = tab_width(&ws.tabs[idx]); - let remaining = right.saturating_sub(x); - let width = desired.min(remaining).max(1); - rects[idx] = Rect::new(x, area.y, width, 1); - x = x.saturating_add(width + 1); - } - rects -} - -fn centered_tab_scroll(ws: &crate::workspace::Workspace, area: Rect) -> usize { - let mut best_scroll = ws.active_tab; - let mut best_distance = u16::MAX; - let viewport_center = area.x.saturating_mul(2).saturating_add(area.width); - - for scroll in 0..=ws.active_tab { - let rects = layout_tab_hit_areas(ws, area, scroll); - let Some(active_rect) = rects.get(ws.active_tab).copied() else { - continue; - }; - if active_rect.width == 0 { - continue; - } - - let active_center = active_rect - .x - .saturating_mul(2) - .saturating_add(active_rect.width); - let distance = active_center.abs_diff(viewport_center); - if distance <= best_distance { - best_distance = distance; - best_scroll = scroll; - } - } - - best_scroll -} - -fn trailing_tab_controls_x(tab_hit_areas: &[Rect], fallback_x: u16) -> u16 { - tab_hit_areas - .iter() - .rev() - .find(|rect| rect.width > 0) - .map(|rect| rect.x + rect.width) - .unwrap_or(fallback_x) -} - -fn max_tab_scroll(ws: &crate::workspace::Workspace, area: Rect) -> usize { - (0..ws.tabs.len()) - .find(|&scroll| { - layout_tab_hit_areas(ws, area, scroll) - .last() - .is_some_and(|rect| rect.width > 0) - }) - .unwrap_or(0) -} - -pub(crate) fn compute_tab_bar_view( - ws: &crate::workspace::Workspace, - area: Rect, - current_scroll: usize, - follow_active: bool, -) -> TabBarView { - if area.width == 0 || area.height == 0 { - return TabBarView::default(); - } - - let area_right = area.x + area.width; - let all_tabs_area = Rect::new( - area.x, - area.y, - area.width.saturating_sub(NEW_TAB_WIDTH), - area.height, - ); - let all_tabs = layout_tab_hit_areas(ws, all_tabs_area, 0); - let overflow = all_tabs.iter().any(|rect| rect.width == 0); - if !overflow { - let new_tab_x = trailing_tab_controls_x(&all_tabs, area.x); - let new_tab_hit_area = Rect::new( - new_tab_x, - area.y, - area_right.saturating_sub(new_tab_x).min(NEW_TAB_WIDTH), - 1, - ); - return TabBarView { - scroll: 0, - tab_hit_areas: all_tabs, - scroll_left_hit_area: Rect::default(), - scroll_right_hit_area: Rect::default(), - new_tab_hit_area, - }; - } - - let left_hit_area = Rect::new(area.x, area.y, TAB_SCROLL_BUTTON_WIDTH.min(area.width), 1); - let tab_area_x = left_hit_area.x + left_hit_area.width; - let reserved_trailing_width = NEW_TAB_WIDTH.saturating_add(TAB_SCROLL_BUTTON_WIDTH); - let tab_area_right = area_right.saturating_sub(reserved_trailing_width); - let tab_area = Rect::new( - tab_area_x, - area.y, - tab_area_right.saturating_sub(tab_area_x), - area.height, - ); - - let max_scroll = max_tab_scroll(ws, tab_area); - let scroll = if follow_active { - centered_tab_scroll(ws, tab_area).min(max_scroll) - } else { - current_scroll.min(max_scroll) - }; - let tab_hit_areas = layout_tab_hit_areas(ws, tab_area, scroll); - let trailing_x = trailing_tab_controls_x(&tab_hit_areas, tab_area_x).min(tab_area_right); - let right_hit_area = Rect::new( - trailing_x, - area.y, - area_right - .saturating_sub(trailing_x) - .min(TAB_SCROLL_BUTTON_WIDTH), - 1, - ); - let new_tab_x = right_hit_area.x + right_hit_area.width; - let new_tab_hit_area = Rect::new( - new_tab_x, - area.y, - area_right.saturating_sub(new_tab_x).min(NEW_TAB_WIDTH), - 1, - ); - - TabBarView { - scroll, - tab_hit_areas, - scroll_left_hit_area: left_hit_area, - scroll_right_hit_area: right_hit_area, - new_tab_hit_area, - } -} - -fn tab_drop_indicator_x( - app: &AppState, - ws: &crate::workspace::Workspace, - insert_idx: usize, -) -> Option<u16> { - let visible_tabs = app - .view - .tab_hit_areas - .iter() - .enumerate() - .filter(|(_, rect)| rect.width > 0); - let first_visible = visible_tabs.clone().next()?; - let last_visible = visible_tabs.last().unwrap_or(first_visible); - - if insert_idx == 0 { - return Some(if first_visible.0 == 0 { - first_visible.1.x - } else { - app.view.tab_scroll_left_hit_area.x + app.view.tab_scroll_left_hit_area.width - }); - } - - if let Some((_, rect)) = app - .view - .tab_hit_areas - .iter() - .enumerate() - .find(|(idx, rect)| *idx == insert_idx && rect.width > 0) - { - return Some(rect.x.saturating_sub(1)); - } - - if insert_idx >= ws.tabs.len() { - return Some(if last_visible.0 + 1 >= ws.tabs.len() { - last_visible.1.x + last_visible.1.width - } else { - app.view.tab_scroll_right_hit_area.x.saturating_sub(1) - }); - } - - None -} - -fn render_tab_bar(app: &AppState, frame: &mut Frame, area: Rect) { - if area.width == 0 || area.height == 0 { - return; - } - let Some(active_ws_idx) = app.active else { - return; - }; - let Some(ws) = app.workspaces.get(active_ws_idx) else { - return; - }; - - let p = &app.palette; - - frame.render_widget( - Paragraph::new(" ".repeat(area.width as usize)).style(Style::default().bg(p.panel_bg)), - area, - ); - - let first_visible_idx = app - .view - .tab_hit_areas - .iter() - .enumerate() - .find(|(_, rect)| rect.width > 0) - .map(|(idx, _)| idx); - let last_visible_idx = app - .view - .tab_hit_areas - .iter() - .enumerate() - .rev() - .find(|(_, rect)| rect.width > 0) - .map(|(idx, _)| idx); - let can_scroll_left = app.view.tab_scroll_left_hit_area.width > 0 && app.tab_scroll > 0; - let can_scroll_right = app.view.tab_scroll_right_hit_area.width > 0 - && last_visible_idx.is_some_and(|idx| idx + 1 < ws.tabs.len()); - - if app.view.tab_scroll_left_hit_area.width > 0 { - let style = if can_scroll_left { - Style::default().fg(p.overlay1).bg(p.surface0) - } else { - Style::default() - .fg(p.overlay0) - .bg(p.surface0) - .add_modifier(Modifier::DIM) - }; - frame.render_widget( - Paragraph::new(" < ").style(style), - app.view.tab_scroll_left_hit_area, - ); - } - - if app.view.tab_scroll_right_hit_area.width > 0 { - let style = if can_scroll_right { - Style::default().fg(p.overlay1).bg(p.surface0) - } else { - Style::default() - .fg(p.overlay0) - .bg(p.surface0) - .add_modifier(Modifier::DIM) - }; - frame.render_widget( - Paragraph::new(" > ").style(style), - app.view.tab_scroll_right_hit_area, - ); - } - - for (idx, tab) in ws.tabs.iter().enumerate() { - let Some(rect) = app.view.tab_hit_areas.get(idx).copied() else { - break; - }; - if rect.width == 0 { - continue; - } - let active = idx == ws.active_tab; - let style = if active { - let base = Style::default().fg(panel_contrast_fg(p)).bg(p.accent); - if tab.is_auto_named() { - base.add_modifier(Modifier::DIM) - } else { - base.add_modifier(Modifier::BOLD) - } - } else if tab.is_auto_named() { - Style::default() - .fg(p.overlay0) - .bg(p.surface0) - .add_modifier(Modifier::DIM) - } else { - Style::default().fg(p.overlay1).bg(p.surface0) - }; - let width = rect.width as usize; - let name = tab.display_name(); - let text = format!(" {:width$}", name, width = width.saturating_sub(1)); - frame.render_widget(Paragraph::new(text).style(style), rect); - } - - if let Some(crate::app::state::DragState { - target: - crate::app::state::DragTarget::TabReorder { - ws_idx, - insert_idx: Some(insert_idx), - .. - }, - }) = &app.drag - { - if *ws_idx == active_ws_idx { - if let Some(x) = tab_drop_indicator_x(app, ws, *insert_idx) { - frame.buffer_mut()[(x.min(area.x + area.width.saturating_sub(1)), area.y)] - .set_symbol("│") - .set_style(Style::default().fg(p.accent)); - } - } - } - - if app.view.new_tab_hit_area.width > 0 { - frame.render_widget( - Paragraph::new(" + ").style(Style::default().fg(p.overlay1)), - app.view.new_tab_hit_area, - ); - } - - if first_visible_idx.is_some_and(|idx| idx > 0) { - let x = app.view.tab_scroll_left_hit_area.x + app.view.tab_scroll_left_hit_area.width; - if x < area.x + area.width { - frame.buffer_mut()[(x, area.y)] - .set_symbol("…") - .set_style(Style::default().fg(p.overlay0)); - } - } - if last_visible_idx.is_some_and(|idx| idx + 1 < ws.tabs.len()) { - let x = app.view.tab_scroll_right_hit_area.x.saturating_sub(1); - if x >= area.x && x < area.x + area.width { - frame.buffer_mut()[(x, area.y)] - .set_symbol("…") - .set_style(Style::default().fg(p.overlay0)); - } - } -} - -/// Compute pane layout info and resize pane runtimes to match. -fn compute_pane_infos(app: &AppState, area: Rect) -> Vec<PaneInfo> { - let Some(ws_idx) = app.active else { - return Vec::new(); - }; - let Some(ws) = app.workspaces.get(ws_idx) else { - return Vec::new(); - }; - - let multi_pane = ws.layout.pane_count() > 1; - let terminal_active = app.mode == Mode::Terminal; - - if ws.zoomed { - let focused_id = ws.layout.focused(); - let mut inner_rect = area; - let mut scrollbar_rect = None; - if let Some(rt) = ws.runtimes.get(&focused_id) { - if rt - .scroll_metrics() - .is_some_and(|metrics| should_show_scrollbar(metrics) && area.width > 1) - { - inner_rect.width = inner_rect.width.saturating_sub(1); - scrollbar_rect = Some(Rect::new( - area.x + area.width.saturating_sub(1), - area.y, - 1, - area.height, - )); - } - rt.resize(inner_rect.height, inner_rect.width); - } - return vec![PaneInfo { - id: focused_id, - rect: area, - inner_rect, - scrollbar_rect, - is_focused: true, - }]; - } - - let mut pane_infos = ws.layout.panes(area); - - for info in &mut pane_infos { - let pane_inner = if multi_pane { - let border_set = if info.is_focused && terminal_active { - ratatui::symbols::border::THICK - } else { - ratatui::symbols::border::PLAIN - }; - let block = Block::default() - .borders(Borders::ALL) - .border_set(border_set); - block.inner(info.rect) - } else { - area - }; - - let mut inner_rect = pane_inner; - let mut scrollbar_rect = None; - if let Some(rt) = ws.runtimes.get(&info.id) { - if rt - .scroll_metrics() - .is_some_and(|metrics| should_show_scrollbar(metrics) && pane_inner.width > 1) - { - inner_rect.width = inner_rect.width.saturating_sub(1); - scrollbar_rect = Some(Rect::new( - pane_inner.x + pane_inner.width.saturating_sub(1), - pane_inner.y, - 1, - pane_inner.height, - )); - } - rt.resize(inner_rect.height, inner_rect.width); - } - - info.inner_rect = inner_rect; - info.scrollbar_rect = scrollbar_rect; - } - - pane_infos -} - -/// Auto-scale sidebar width based on workspace identity + agent summary. -pub(crate) fn collapsed_sidebar_sections(area: Rect) -> (Rect, Option<u16>, Rect) { - let content = Rect::new(area.x, area.y, area.width.saturating_sub(1), area.height); - if content.width == 0 || content.height == 0 { - return (Rect::default(), None, Rect::default()); - } - - if content.height < 7 { - return (content, None, Rect::default()); - } - - let total_h = content.height as usize; - let ws_h = (total_h + 1) / 2; - let detail_h = total_h.saturating_sub(ws_h + 1); - if ws_h == 0 || detail_h == 0 { - return (content, None, Rect::default()); - } - - let divider_y = content.y + ws_h as u16; - let ws_area = Rect::new(content.x, content.y, content.width, ws_h as u16); - let detail_area = Rect::new(content.x, divider_y + 1, content.width, detail_h as u16); - (ws_area, Some(divider_y), detail_area) -} - -/// Collapsed sidebar: workspace glance on top, compact agent list below. -fn render_sidebar_collapsed(app: &AppState, frame: &mut Frame, area: Rect) { - let is_navigating = matches!(app.mode, Mode::Navigate); - - let p = &app.palette; - let sep_style = if is_navigating { - Style::default().fg(p.accent) - } else { - Style::default().fg(p.surface_dim) - }; - let sep_x = area.x + area.width.saturating_sub(1); - let buf = frame.buffer_mut(); - for y in area.y..area.y + area.height { - buf[(sep_x, y)].set_symbol("│"); - buf[(sep_x, y)].set_style(sep_style); - } - - let (ws_area, divider_y, detail_area) = collapsed_sidebar_sections(area); - if ws_area == Rect::default() { - render_sidebar_toggle(app, frame, area, true, p); - return; - } - - for (visible_idx, ws) in app.workspaces.iter().enumerate() { - let y = ws_area.y + visible_idx as u16; - if y >= ws_area.y + ws_area.height { - break; - } - let (agg_state, agg_seen) = ws.aggregate_state(); - let (icon, icon_style) = state_dot(agg_state, agg_seen, p); - let is_selected = visible_idx == app.selected && is_navigating; - let is_active = Some(visible_idx) == app.active; - let row_style = if is_selected { - Style::default().bg(p.surface0) - } else if is_active { - Style::default().bg(p.surface_dim) - } else { - Style::default() - }; - let num_style = if is_selected { - Style::default().fg(p.overlay1).bg(p.surface0) - } else if is_active { - Style::default().fg(p.text).bg(p.surface_dim) - } else { - Style::default().fg(p.overlay0) - }; - - if is_selected || is_active { - let buf = frame.buffer_mut(); - for x in ws_area.x..ws_area.x + ws_area.width { - buf[(x, y)].set_style(row_style); - } - } - - frame.render_widget( - Paragraph::new(Line::from(vec![ - Span::styled(format!("{}", visible_idx + 1), num_style), - Span::styled(" ", row_style), - Span::styled(icon, icon_style), - ])), - Rect::new(ws_area.x, y, ws_area.width, 1), - ); - } - - if let Some(divider_y) = divider_y { - let buf = frame.buffer_mut(); - for x in ws_area.x..ws_area.x + ws_area.width { - buf[(x, divider_y)].set_symbol("─"); - buf[(x, divider_y)].set_style(Style::default().fg(p.surface_dim)); - } - } - - let detail_ws_idx = if is_navigating { - Some(app.selected) - } else { - app.active - }; - let detail_content_area = Rect::new( - detail_area.x, - detail_area.y, - detail_area.width, - detail_area.height.saturating_sub(1), - ); - if detail_content_area != Rect::default() { - if let Some(ws_idx) = detail_ws_idx { - if let Some(ws) = app.workspaces.get(ws_idx) { - for (detail_idx, detail) in ws.pane_details().iter().enumerate() { - let y = detail_content_area.y + detail_idx as u16; - if y >= detail_content_area.y + detail_content_area.height { - break; - } - let pane_num = ws - .public_pane_number(detail.pane_id) - .unwrap_or(detail_idx + 1); - let pane_style = Style::default().fg(p.overlay0); - let (icon, icon_style) = - agent_icon(detail.state, detail.seen, app.spinner_tick, p); - frame.render_widget( - Paragraph::new(Line::from(vec![ - Span::styled(format!("{pane_num}"), pane_style), - Span::styled(" ", pane_style), - Span::styled(icon, icon_style), - ])), - Rect::new(detail_content_area.x, y, detail_content_area.width, 1), - ); - } - } - } - } - - render_sidebar_toggle(app, frame, area, true, p); -} - -pub(crate) fn workspace_drop_indicator_row( - cards: &[crate::app::state::WorkspaceCardArea], - area: Rect, - insert_idx: usize, -) -> Option<u16> { - if area.height == 0 { - return None; - } - let list_bottom = area.y + area.height.saturating_sub(1); - - let first = cards.first()?; - if insert_idx == first.ws_idx { - return first.rect.y.checked_sub(1).filter(|y| *y < list_bottom); - } - - if let Some(card) = cards.iter().find(|card| card.ws_idx == insert_idx) { - return card.rect.y.checked_sub(1).filter(|y| *y < list_bottom); - } - - cards - .last() - .filter(|card| insert_idx == card.ws_idx.saturating_add(1)) - .map(|card| card.rect.y.saturating_add(card.rect.height)) - .filter(|y| *y < list_bottom) -} - -fn render_sidebar(app: &AppState, frame: &mut Frame, area: Rect) { - let p = &app.palette; - let is_navigating = matches!(app.mode, Mode::Navigate); - let sep_style = if is_navigating { - Style::default().fg(p.accent) - } else { - Style::default().fg(p.surface_dim) - }; - - // Right border - let sep_x = area.x + area.width.saturating_sub(1); - let buf = frame.buffer_mut(); - for y in area.y..area.y + area.height { - buf[(sep_x, y)].set_symbol("│"); - buf[(sep_x, y)].set_style(sep_style); - } - - let (ws_area, detail_area) = expanded_sidebar_sections(area, app.sidebar_section_split); - - // --- Top section: Workspaces --- - render_workspace_list(app, frame, ws_area, is_navigating); - - // --- Bottom section: Agent detail --- - render_agent_detail(app, frame, detail_area); - - render_sidebar_toggle(app, frame, area, false, p); -} - -/// Render the workspace list in the top section of the sidebar. -fn render_workspace_list(app: &AppState, frame: &mut Frame, area: Rect, is_navigating: bool) { - let p = &app.palette; - let dragged_ws_idx = match app.drag.as_ref().map(|drag| &drag.target) { - Some(crate::app::state::DragTarget::WorkspaceReorder { source_ws_idx, .. }) => { - Some(*source_ws_idx) - } - _ => None, - }; - let insertion_row = match app.drag.as_ref().map(|drag| &drag.target) { - Some(crate::app::state::DragTarget::WorkspaceReorder { - insert_idx: Some(insert_idx), - .. - }) => workspace_drop_indicator_row(&app.view.workspace_card_areas, area, *insert_idx), - _ => None, - }; - - // Section header + reserve last row for "new" button - let list_bottom = area.y + area.height.saturating_sub(1); - if area.height > 0 { - frame.render_widget( - Paragraph::new(Line::from(vec![Span::styled( - " spaces", - Style::default().fg(p.overlay0).add_modifier(Modifier::BOLD), - )])), - Rect::new(area.x, area.y, area.width, 1), - ); - } - - let metrics = workspace_list_scroll_metrics(app, area); - let scrollbar_rect = workspace_list_scrollbar_rect(app, area); - let cards = &app.view.workspace_card_areas; - - for card in cards { - let i = card.ws_idx; - let ws = &app.workspaces[i]; - let row_y = card.rect.y; - let row_height = card.rect.height; - let selected = i == app.selected && is_navigating; - let is_active = Some(i) == app.active; - let is_dragged = dragged_ws_idx == Some(i); - let highlighted = selected || is_active || is_dragged; - let (agg_state, agg_seen) = ws.aggregate_state(); - - if highlighted { - let bg = if selected { - p.surface0 - } else if is_dragged { - p.surface1 - } else { - p.surface_dim - }; - let buf = frame.buffer_mut(); - for y in row_y..row_y + row_height { - if y >= list_bottom { - break; - } - for x in card.rect.x..card.rect.x + card.rect.width { - buf[(x, y)].set_style(Style::default().bg(bg)); - } - } - } - - if is_active { - let buf = frame.buffer_mut(); - for y in row_y..row_y + row_height { - if y >= list_bottom { - break; - } - buf[(card.rect.x, y)].set_symbol("▌"); - buf[(card.rect.x, y)].set_style(Style::default().fg(p.accent)); - } - } - - let name_style = if selected || is_active || is_dragged { - Style::default().fg(p.text).add_modifier(Modifier::BOLD) - } else { - Style::default().fg(p.subtext0) - }; - let num_style = if selected || is_active { - Style::default().fg(p.overlay1) - } else { - Style::default().fg(p.overlay0) - }; - - let mut line1 = vec![ - Span::styled(" ", Style::default()), - Span::styled(format!("{} ", i + 1), num_style), - Span::styled(ws.display_name(), name_style), - Span::styled(" ", Style::default()), - ]; - let (icon, icon_style) = state_dot(agg_state, agg_seen, p); - line1.push(Span::styled(icon, icon_style)); - - frame.render_widget( - Paragraph::new(Line::from(line1)), - Rect::new(card.rect.x, row_y, card.rect.width, 1), - ); - - if row_height > 1 && row_y + 1 < list_bottom { - if let Some(branch) = ws.branch() { - let upstream_label = ws.git_ahead_behind().and_then(|(ahead, behind)| { - let mut parts = Vec::new(); - if ahead > 0 { - parts.push((format!("↑{}", ahead), p.green)); - } - if behind > 0 { - parts.push((format!("↓{}", behind), p.red)); - } - (!parts.is_empty()).then_some(parts) - }); - let reserved = upstream_label - .as_ref() - .map(|parts| { - parts.iter().map(|(label, _)| label.len()).sum::<usize>() + parts.len() - }) - .unwrap_or(0); - let max_branch_len = (card.rect.width as usize).saturating_sub(5 + reserved); - let branch_display = if branch.len() > max_branch_len { - format!("{}…", &branch[..max_branch_len.saturating_sub(1)]) - } else { - branch - }; - let branch_color = if selected || is_active { - p.mauve - } else { - p.overlay0 - }; - let mut spans = vec![ - Span::styled(" ", Style::default()), - Span::styled(branch_display, Style::default().fg(branch_color)), - ]; - if let Some(parts) = upstream_label { - spans.push(Span::styled(" ", Style::default())); - for (idx, (label, color)) in parts.into_iter().enumerate() { - if idx > 0 { - spans.push(Span::styled(" ", Style::default())); - } - spans.push(Span::styled(label, Style::default().fg(color))); - } - } - frame.render_widget( - Paragraph::new(Line::from(spans)), - Rect::new(card.rect.x, row_y + 1, card.rect.width, 1), - ); - } - } - } - - if let Some(y) = insertion_row.filter(|y| *y < list_bottom) { - let indicator_right = scrollbar_rect - .map(|rect| rect.x) - .unwrap_or(area.x + area.width); - let buf = frame.buffer_mut(); - for x in area.x..indicator_right { - buf[(x, y)].set_symbol("─"); - buf[(x, y)].set_style(Style::default().fg(p.accent)); - } - } - - if let Some(track) = scrollbar_rect { - render_scrollbar(frame, metrics, track, p.surface_dim, p.overlay0, "▕"); - } - - // Footer actions for workspace section - if list_bottom > area.y { - let new_rect = app.sidebar_new_button_rect(); - frame.render_widget( - Paragraph::new(Span::styled("new", Style::default().fg(p.overlay0))), - new_rect, - ); - - let menu_rect = app.global_launcher_rect(); - let menu_line = if app.update_available.is_some() { - Line::from(vec![ - Span::styled("menu", Style::default().fg(p.overlay0)), - Span::styled( - " ●", - Style::default().fg(p.accent).add_modifier(Modifier::BOLD), - ), - ]) - } else { - Line::from(vec![Span::styled("menu", Style::default().fg(p.overlay0))]) - }; - frame.render_widget( - Paragraph::new(menu_line).alignment(Alignment::Right), - menu_rect, - ); - } -} - -/// Render the agent detail panel in the bottom section of the sidebar. -fn render_agent_detail(app: &AppState, frame: &mut Frame, area: Rect) { - let p = &app.palette; - - if area.height < 3 { - return; - } - - let sep_line = "─".repeat(area.width as usize); - frame.render_widget( - Paragraph::new(Span::styled(&sep_line, Style::default().fg(p.surface_dim))), - Rect::new(area.x, area.y, area.width, 1), - ); - - frame.render_widget( - Paragraph::new(Line::from(vec![Span::styled( - " agents", - Style::default().fg(p.overlay0).add_modifier(Modifier::BOLD), - )])), - Rect::new(area.x, area.y + 1, area.width, 1), - ); - let toggle_rect = agent_panel_toggle_rect(area, app.agent_panel_scope); - if toggle_rect != Rect::default() { - frame.render_widget( - Paragraph::new(Span::styled( - agent_panel_toggle_label(app.agent_panel_scope), - Style::default().fg(p.overlay0).add_modifier(Modifier::BOLD), - )) - .alignment(Alignment::Right), - toggle_rect, - ); - } - - let details = agent_panel_entries(app); - let metrics = agent_panel_scroll_metrics(app, area); - let scrollbar_rect = agent_panel_scrollbar_rect(app, area); - let body = agent_panel_body_rect(area, should_show_scrollbar(metrics)); - if body == Rect::default() { - return; - } - - let mut row_y = body.y; - let body_bottom = body.y + body.height; - for detail in details.iter().skip(app.agent_panel_scroll) { - if row_y.saturating_add(1) >= body_bottom { - break; - } - - let (icon, icon_style) = agent_icon(detail.state, detail.seen, app.spinner_tick, p); - let label_color = state_label_color(detail.state, detail.seen, p); - let label = state_label(detail.state, detail.seen); - - let name_style = Style::default().fg(p.subtext0).add_modifier(Modifier::BOLD); - let status_style = Style::default().fg(label_color).add_modifier(Modifier::DIM); - let agent_style = Style::default().fg(p.overlay0).add_modifier(Modifier::DIM); - - let primary_label = - format_agent_panel_primary_label(detail, body.width.saturating_sub(3) as usize); - let name_line = Line::from(vec![ - Span::styled(" ", Style::default()), - Span::styled(icon, icon_style), - Span::styled(" ", Style::default()), - Span::styled(primary_label, name_style), - ]); - frame.render_widget( - Paragraph::new(name_line), - Rect::new(body.x, row_y, body.width, 1), - ); - row_y += 1; - - let mut status_spans = vec![ - Span::styled(" ", Style::default()), - Span::styled(label, status_style), - ]; - if let Some(agent_label) = &detail.agent_label { - status_spans.push(Span::styled(" · ", agent_style)); - status_spans.push(Span::styled(agent_label, agent_style)); - } - frame.render_widget( - Paragraph::new(Line::from(status_spans)), - Rect::new(body.x, row_y, body.width, 1), - ); - row_y += 1; - - if row_y < body_bottom { - row_y += 1; - } - } - - if let Some(track) = scrollbar_rect { - render_scrollbar(frame, metrics, track, p.surface_dim, p.overlay0, "▕"); - } -} - -pub(crate) fn collapsed_sidebar_toggle_rect(area: Rect) -> Rect { - let bottom_y = area.y + area.height.saturating_sub(1); - let content_w = area.width.saturating_sub(1); - if content_w == 0 || area.height == 0 { - return Rect::default(); - } - let x = area.x + content_w / 2; - Rect::new(x, bottom_y, 1, 1) -} - -fn render_sidebar_toggle( - app: &AppState, - frame: &mut Frame, - area: Rect, - collapsed: bool, - p: &Palette, -) { - // Toggle button not needed when sidebar has content — skip for now - // to avoid conflicting with the agent detail panel at the bottom. - if !collapsed { - return; - } - let toggle_area = collapsed_sidebar_toggle_rect(area); - if toggle_area == Rect::default() { - return; - } - let icon_style = if app.update_available.is_some() { - Style::default().fg(p.accent).add_modifier(Modifier::BOLD) - } else { - Style::default().fg(p.overlay0) - }; - frame.render_widget(Paragraph::new(Span::styled("»", icon_style)), toggle_area); -} - -fn render_panes(app: &AppState, frame: &mut Frame, area: Rect) { - let Some(ws_idx) = app.active else { - render_empty(app, frame, area); - return; - }; - let Some(ws) = app.workspaces.get(ws_idx) else { - render_empty(app, frame, area); - return; - }; - - let multi_pane = ws.layout.pane_count() > 1; - let terminal_active = app.mode == Mode::Terminal; - - for info in &app.view.pane_infos { - if let Some(rt) = ws.runtimes.get(&info.id) { - // Draw borders for multi-pane layouts - if multi_pane { - let (border_style, border_set) = if info.is_focused && terminal_active { - ( - Style::default().fg(app.palette.accent), - ratatui::symbols::border::THICK, - ) - } else if info.is_focused { - ( - Style::default().fg(app.palette.accent), - ratatui::symbols::border::PLAIN, - ) - } else { - ( - Style::default().fg(app.palette.overlay0), - ratatui::symbols::border::PLAIN, - ) - }; - - let block = Block::default() - .borders(Borders::ALL) - .border_style(border_style) - .border_set(border_set); - frame.render_widget(block, info.rect); - } - - // Draw terminal content. Only the focused pane should own the cursor. - rt.render(frame, info.inner_rect, info.is_focused && terminal_active); - render_pane_scrollbar(app, frame, info, rt); - - // Dim unfocused panes only in navigate mode - let should_dim = !info.is_focused && multi_pane && !terminal_active; - if should_dim { - let inner = info.inner_rect; - let buf = frame.buffer_mut(); - for y in inner.y..inner.y + inner.height { - for x in inner.x..inner.x + inner.width { - let cell = &mut buf[(x, y)]; - let style = cell.style(); - let fg = style.fg.unwrap_or(Color::White); - let dimmed_fg = dim_color(fg); - cell.set_style(style.fg(dimmed_fg)); - } - } - } - - // Selection highlight - render_selection_highlight( - &app.selection, - frame, - info.id, - info.inner_rect, - rt.scroll_metrics(), - &app.palette, - ); - } - } -} - -/// Render selection highlight for a pane by inverting fg/bg colors. -/// Reduce a color's brightness by blending it toward black. -fn dim_color(color: Color) -> Color { - match color { - Color::Rgb(r, g, b) => Color::Rgb(r / 3, g / 3, b / 3), - Color::White => Color::DarkGray, - Color::Gray => Color::DarkGray, - Color::DarkGray => Color::Rgb(30, 30, 30), - Color::Red => Color::Rgb(60, 0, 0), - Color::Green => Color::Rgb(0, 60, 0), - Color::Yellow => Color::Rgb(60, 60, 0), - Color::Blue => Color::Rgb(0, 0, 60), - Color::Magenta => Color::Rgb(60, 0, 60), - Color::Cyan => Color::Rgb(0, 60, 60), - Color::LightRed => Color::Rgb(80, 30, 30), - Color::LightGreen => Color::Rgb(30, 80, 30), - Color::LightYellow => Color::Rgb(80, 80, 30), - Color::LightBlue => Color::Rgb(30, 30, 80), - Color::LightMagenta => Color::Rgb(80, 30, 80), - Color::LightCyan => Color::Rgb(30, 80, 80), - // Indexed colors and others: just use DIM modifier as fallback - _ => Color::DarkGray, - } -} - -pub(crate) fn pane_scrollbar_rect(info: &PaneInfo) -> Option<Rect> { - info.scrollbar_rect -} - -pub(crate) fn release_notes_scrollbar_rect( - body: Rect, - metrics: crate::pane::ScrollMetrics, -) -> Option<Rect> { - (should_show_scrollbar(metrics) && body.width > 1).then_some(Rect::new( - body.x + body.width - 1, - body.y, - 1, - body.height, - )) -} - -pub(crate) fn should_show_scrollbar(metrics: crate::pane::ScrollMetrics) -> bool { - metrics.max_offset_from_bottom > 0 -} - -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -pub(crate) struct ScrollbarThumb { - pub top: u16, - pub len: u16, -} - -pub(crate) fn scrollbar_thumb( - metrics: crate::pane::ScrollMetrics, - track: Rect, -) -> Option<ScrollbarThumb> { - if metrics.max_offset_from_bottom == 0 || track.height == 0 { - return None; - } - - let track_height = track.height as usize; - let total_rows = metrics.max_offset_from_bottom + metrics.viewport_rows; - if total_rows == 0 { - return None; - } - - let thumb_len = ((metrics.viewport_rows * track_height) as f32 / total_rows as f32) - .round() - .max(1.0) - .min(track_height as f32) as usize; - let max_thumb_top = track_height.saturating_sub(thumb_len); - let scrolled_from_top = metrics - .max_offset_from_bottom - .saturating_sub(metrics.offset_from_bottom); - let thumb_top = if max_thumb_top == 0 || metrics.max_offset_from_bottom == 0 { - 0 - } else { - ((scrolled_from_top * max_thumb_top) as f32 / metrics.max_offset_from_bottom as f32) - .round() - .clamp(0.0, max_thumb_top as f32) as usize - }; - - Some(ScrollbarThumb { - top: track.y + thumb_top as u16, - len: thumb_len as u16, - }) -} - -pub(crate) fn scrollbar_thumb_grab_offset( - metrics: crate::pane::ScrollMetrics, - track: Rect, - row: u16, -) -> Option<u16> { - let thumb = scrollbar_thumb(metrics, track)?; - (row >= thumb.top && row < thumb.top + thumb.len).then_some(row - thumb.top) -} - -fn scrollbar_offset_from_thumb_top( - metrics: crate::pane::ScrollMetrics, - track: Rect, - thumb_top: usize, -) -> usize { - if metrics.max_offset_from_bottom == 0 { - return 0; - } - - let thumb_len = scrollbar_thumb(metrics, track) - .map(|thumb| thumb.len as usize) - .unwrap_or(1); - let max_thumb_top = track.height as usize - thumb_len.min(track.height as usize); - if max_thumb_top == 0 { - return 0; - } - - let desired_top = thumb_top.min(max_thumb_top); - let scrolled_from_top = ((desired_top * metrics.max_offset_from_bottom) as f32 - / max_thumb_top as f32) - .round() as usize; - metrics - .max_offset_from_bottom - .saturating_sub(scrolled_from_top) -} - -pub(crate) fn scrollbar_offset_from_row( - metrics: crate::pane::ScrollMetrics, - track: Rect, - row: u16, -) -> usize { - let thumb = match scrollbar_thumb(metrics, track) { - Some(thumb) => thumb, - None => return 0, - }; - let clamped_row = row.clamp(track.y, track.y + track.height.saturating_sub(1)); - let row_offset = clamped_row.saturating_sub(track.y) as usize; - let thumb_center = (thumb.len as usize) / 2; - let desired_top = row_offset.saturating_sub(thumb_center); - scrollbar_offset_from_thumb_top(metrics, track, desired_top) -} - -pub(crate) fn scrollbar_offset_from_drag_row( - metrics: crate::pane::ScrollMetrics, - track: Rect, - row: u16, - grab_row_offset: u16, -) -> usize { - let clamped_row = row.clamp(track.y, track.y + track.height.saturating_sub(1)); - let row_offset = clamped_row.saturating_sub(track.y) as usize; - let desired_top = row_offset.saturating_sub(grab_row_offset as usize); - scrollbar_offset_from_thumb_top(metrics, track, desired_top) -} - -fn render_scrollbar( - frame: &mut Frame, - metrics: crate::pane::ScrollMetrics, - track: Rect, - track_color: Color, - thumb_color: Color, - thumb_symbol: &str, -) { - if metrics.max_offset_from_bottom == 0 { - return; - } - - let Some(thumb) = scrollbar_thumb(metrics, track) else { - return; - }; - - let buf = frame.buffer_mut(); - for y in track.y..track.y + track.height { - let cell = &mut buf[(track.x, y)]; - cell.set_symbol("▕"); - cell.set_style(Style::default().fg(track_color)); - } - for y in thumb.top..thumb.top + thumb.len { - let cell = &mut buf[(track.x, y)]; - cell.set_symbol(thumb_symbol); - cell.set_style(Style::default().fg(thumb_color)); - } -} - -fn render_pane_scrollbar( - app: &AppState, - frame: &mut Frame, - info: &PaneInfo, - rt: &crate::pane::PaneRuntime, -) { - let Some(metrics) = rt.scroll_metrics() else { - return; - }; - let Some(track) = pane_scrollbar_rect(info) else { - return; - }; - - let (track_color, thumb_color, thumb_symbol) = if info.is_focused { - (app.palette.overlay0, app.palette.overlay1, "▐") - } else { - (app.palette.surface_dim, app.palette.overlay0, "▕") - }; - - render_scrollbar( - frame, - metrics, - track, - track_color, - thumb_color, - thumb_symbol, - ); -} - -fn render_selection_highlight( - selection: &Option<crate::selection::Selection>, - frame: &mut Frame, - pane_id: crate::layout::PaneId, - inner: Rect, - scroll_metrics: Option<crate::pane::ScrollMetrics>, - p: &Palette, -) { - if let Some(sel) = selection { - if sel.is_visible() && sel.pane_id == pane_id { - let buf = frame.buffer_mut(); - for y in 0..inner.height { - for x in 0..inner.width { - if sel.contains(y, x, scroll_metrics) { - let cell = &mut buf[(inner.x + x, inner.y + y)]; - cell.set_style(Style::default().fg(panel_contrast_fg(p)).bg(p.blue)); - } - } - } - } - } -} - -fn render_empty(app: &AppState, frame: &mut Frame, area: Rect) { - let p = &app.palette; - let lines = vec![ - Line::from(""), - Line::from(""), - Line::from(Span::styled( - " No workspaces yet", - Style::default().fg(p.overlay0), - )), - Line::from(""), - Line::from(Span::styled( - " A workspace is one project context.", - Style::default().fg(p.overlay1), - )), - Line::from(Span::styled( - " Its root pane (top-left) sets the default repo or folder name.", - Style::default().fg(p.overlay1), - )), - Line::from(""), - Line::from(vec![ - Span::styled(" Press ", Style::default().fg(p.overlay0)), - Span::styled( - format!("{}", app.keybinds.new_workspace_label), - Style::default().fg(p.accent).add_modifier(Modifier::BOLD), - ), - Span::styled(" to create one", Style::default().fg(p.overlay0)), - ]), - ]; - frame.render_widget( - Paragraph::new(lines).block( - Block::default() - .borders(Borders::ALL) - .border_style(Style::default().fg(p.surface_dim)), - ), - area, - ); -} - -const ONBOARDING_PREFIX_LABEL: &str = "ctrl+b"; - fn dim_background(frame: &mut Frame, area: Rect) { let buf = frame.buffer_mut(); for y in area.y..area.y + area.height { @@ -1801,1730 +217,7 @@ fn dim_background(frame: &mut Frame, area: Rect) { } } -fn render_panel_shell( - frame: &mut Frame, - area: Rect, - border_color: Color, - bg: Color, -) -> Option<Rect> { - if area.width < 2 || area.height < 2 { - return None; - } - - let block = Block::default() - .borders(Borders::ALL) - .border_style(Style::default().fg(border_color)) - .border_set(ratatui::symbols::border::PLAIN) - .style(Style::default().bg(bg)); - let inner = block.inner(area); - frame.render_widget(Clear, area); - frame.render_widget(block, area); - Some(inner) -} - -fn panel_contrast_fg(p: &Palette) -> Color { - match p.panel_bg { - Color::Reset => p.surface_dim, - color => color, - } -} - -pub(crate) const RELEASE_NOTES_MODAL_SIZE: (u16, u16) = (80, 24); - -pub(crate) fn centered_popup_rect(area: Rect, popup_w: u16, popup_h: u16) -> Option<Rect> { - let popup_w = popup_w.min(area.width.saturating_sub(4)); - let popup_h = popup_h.min(area.height.saturating_sub(2)); - if popup_w < 4 || popup_h < 4 { - return None; - } - - let popup_x = area.x + (area.width.saturating_sub(popup_w)) / 2; - let popup_y = area.y + (area.height.saturating_sub(popup_h)) / 2; - Some(Rect::new(popup_x, popup_y, popup_w, popup_h)) -} - -fn render_modal_shell( - frame: &mut Frame, - area: Rect, - popup_w: u16, - popup_h: u16, - p: &Palette, -) -> Option<Rect> { - let popup = centered_popup_rect(area, popup_w, popup_h)?; - render_panel_shell(frame, popup, p.accent, p.panel_bg) -} - -fn render_modal_header(frame: &mut Frame, area: Rect, title: &str, p: &Palette) { - let line = Line::from(vec![ - Span::styled( - title, - Style::default().fg(p.text).add_modifier(Modifier::BOLD), - ), - Span::raw(" "), - Span::styled("⬆", Style::default().fg(p.accent)), - ]); - frame.render_widget(Paragraph::new(line), area); -} - -#[derive(Debug, Clone, Copy)] -pub(crate) struct ModalStackAreas { - pub header: Rect, - pub content: Rect, - pub footer: Option<Rect>, - pub actions: Option<Rect>, -} - -pub(crate) fn modal_stack_areas( - inner: Rect, - header_height: u16, - footer_height: u16, - actions_height: u16, - gap: u16, -) -> ModalStackAreas { - #[derive(Clone, Copy)] - enum Slot { - Header, - Content, - Footer, - Actions, - } - - let mut constraints = Vec::new(); - let mut slots = Vec::new(); - let mut push = |slot: Slot, constraint: Constraint| { - if !slots.is_empty() { - constraints.push(Constraint::Length(gap)); - } - constraints.push(constraint); - slots.push(slot); - }; - - push(Slot::Header, Constraint::Length(header_height)); - push(Slot::Content, Constraint::Min(0)); - if footer_height > 0 { - push(Slot::Footer, Constraint::Length(footer_height)); - } - if actions_height > 0 { - push(Slot::Actions, Constraint::Length(actions_height)); - } - - let areas = Layout::vertical(constraints).split(inner); - let mut header = Rect::default(); - let mut content = Rect::default(); - let mut footer = None; - let mut actions = None; - - for (slot, area) in slots.into_iter().zip(areas.iter().step_by(2).copied()) { - match slot { - Slot::Header => header = area, - Slot::Content => content = area, - Slot::Footer => footer = Some(area), - Slot::Actions => actions = Some(area), - } - } - - ModalStackAreas { - header, - content, - footer, - actions, - } -} - -fn render_onboarding_overlay(app: &AppState, frame: &mut Frame, area: Rect) { - dim_background(frame, area); - - match app.onboarding_step { - 0 => render_onboarding_welcome(app, frame, area), - _ => render_onboarding_notifications(app, frame, area), - } -} - -fn render_release_notes_overlay(app: &AppState, frame: &mut Frame, area: Rect) { - let Some(notes) = &app.release_notes else { - return; - }; - - dim_background(frame, area); - - let Some(inner) = render_modal_shell( - frame, - area, - RELEASE_NOTES_MODAL_SIZE.0, - RELEASE_NOTES_MODAL_SIZE.1, - &app.palette, - ) else { - return; - }; - if inner.height < 8 || inner.width < 20 { - return; - } - - let stack = modal_stack_areas(inner, 2, 1, 0, 1); - let header_rows = - Layout::vertical([Constraint::Length(1), Constraint::Length(1)]).areas::<2>(stack.header); - - let header_title_area = Rect::new( - header_rows[0].x + 1, - header_rows[0].y, - header_rows[0].width.saturating_sub(2), - header_rows[0].height, - ); - let header_subtitle_area = Rect::new( - header_rows[1].x + 1, - header_rows[1].y, - header_rows[1].width.saturating_sub(2), - header_rows[1].height, - ); - - render_modal_header( - frame, - header_title_area, - &format!("v{}", notes.version), - &app.palette, - ); - let subtitle = if notes.preview { - "preview before updating" - } else { - "what's new in this release" - }; - frame.render_widget( - Paragraph::new(subtitle).style(Style::default().fg(app.palette.overlay1)), - header_subtitle_area, - ); - render_action_button( - frame, - release_notes_close_button_rect(header_rows[0]), - Some("esc"), - "close", - Style::default() - .fg(panel_contrast_fg(&app.palette)) - .bg(app.palette.accent) - .add_modifier(Modifier::BOLD), - ); - - let sections = release_notes_sections(stack.content, notes.preview); - let metrics = crate::pane::ScrollMetrics { - offset_from_bottom: app.release_notes_max_scroll().saturating_sub(notes.scroll) as usize, - max_offset_from_bottom: app.release_notes_max_scroll() as usize, - viewport_rows: sections.notes_body.height.max(1) as usize, - }; - let track = release_notes_scrollbar_rect(sections.notes_body, metrics); - let notes_text_area = track - .map(|_| { - Rect::new( - sections.notes_body.x, - sections.notes_body.y, - sections.notes_body.width.saturating_sub(1), - sections.notes_body.height, - ) - }) - .unwrap_or(sections.notes_body); - - if let Some(instructions_area) = sections.instructions { - render_release_notes_preview_panel(frame, instructions_area, ¬es.version, &app.palette); - } - - let body = Paragraph::new( - release_notes_lines(notes.body.as_str(), &app.palette) - .into_iter() - .map(|(_, line)| line) - .collect::<Vec<_>>(), - ) - .wrap(Wrap { trim: false }) - .scroll((notes.scroll, 0)); - frame.render_widget(body, notes_text_area); - if let Some(track) = track { - render_scrollbar( - frame, - metrics, - track, - app.palette.overlay0, - app.palette.overlay1, - "▐", - ); - } - - frame.render_widget( - Paragraph::new(Line::from(vec![ - Span::styled(" scroll ", Style::default().fg(app.palette.overlay0)), - Span::styled("wheel ↑↓", Style::default().fg(app.palette.text)), - Span::styled(" · ", Style::default().fg(app.palette.overlay0)), - Span::styled("close", Style::default().fg(app.palette.overlay0)), - Span::styled(" esc / enter ", Style::default().fg(app.palette.text)), - ])), - stack.footer.unwrap_or_default(), - ); -} - -fn release_notes_inline_spans<'a>( - text: &str, - base_style: Style, - code_style: Style, -) -> (usize, Vec<Span<'a>>) { - let mut spans = Vec::new(); - let mut width = 0; - let mut remaining = text; - - while let Some(start) = remaining.find('`') { - let (before, after_start) = remaining.split_at(start); - if !before.is_empty() { - width += before.chars().count(); - spans.push(Span::styled(before.to_string(), base_style)); - } - - let after_start = &after_start[1..]; - let Some(end) = after_start.find('`') else { - let literal = format!("`{after_start}"); - width += literal.chars().count(); - spans.push(Span::styled(literal, base_style)); - remaining = ""; - break; - }; - - let (code, after_end) = after_start.split_at(end); - width += code.chars().count(); - if !code.is_empty() { - spans.push(Span::styled(code.to_string(), code_style)); - } - remaining = &after_end[1..]; - } - - if !remaining.is_empty() { - width += remaining.chars().count(); - spans.push(Span::styled(remaining.to_string(), base_style)); - } - - if spans.is_empty() { - spans.push(Span::styled(String::new(), base_style)); - } - - (width, spans) -} - -pub(crate) fn release_notes_lines<'a>(body: &'a str, p: &Palette) -> Vec<(usize, Line<'a>)> { - let mut lines = Vec::new(); - let mut in_fenced_code_block = false; - let text_style = Style::default().fg(p.text); - let inline_code_style = Style::default() - .fg(p.accent) - .bg(p.surface0) - .add_modifier(Modifier::BOLD); - - for raw in body.lines() { - let trimmed = raw.trim_end(); - if trimmed.trim_start().starts_with("```") { - in_fenced_code_block = !in_fenced_code_block; - continue; - } - - if in_fenced_code_block { - let code_bg = p.surface1; - let gutter_style = Style::default().fg(p.accent).bg(code_bg); - let code_style = Style::default().fg(p.text).bg(code_bg); - let width = 2 + trimmed.chars().count(); - let mut spans = vec![ - Span::styled("▏", gutter_style), - Span::styled(" ", code_style), - ]; - if !trimmed.is_empty() { - spans.push(Span::styled(trimmed.to_string(), code_style)); - } - lines.push((width, Line::from(spans))); - continue; - } - - if trimmed.is_empty() { - lines.push((0, Line::raw(""))); - continue; - } - - if let Some(rest) = trimmed.strip_prefix("### ") { - let text = rest.trim().to_string(); - if text.is_empty() { - lines.push((0, Line::raw(""))); - continue; - } - let width = 1 + text.chars().count(); - lines.push(( - width, - Line::from(vec![ - Span::raw(" "), - Span::styled( - text.to_uppercase(), - Style::default().fg(p.accent).add_modifier(Modifier::BOLD), - ), - ]), - )); - continue; - } - - if let Some(rest) = trimmed.strip_prefix("- ") { - let (text_width, mut spans) = - release_notes_inline_spans(rest, text_style, inline_code_style); - let width = 3 + text_width; - let mut line_spans = vec![Span::styled(" • ", Style::default().fg(p.accent))]; - line_spans.append(&mut spans); - lines.push((width, Line::from(line_spans))); - continue; - } - - let (text_width, mut spans) = - release_notes_inline_spans(trimmed, text_style, inline_code_style); - let width = 1 + text_width; - let mut line_spans = vec![Span::raw(" ")]; - line_spans.append(&mut spans); - lines.push((width, Line::from(line_spans))); - } - - lines -} - -pub(crate) struct ReleaseNotesSections { - pub instructions: Option<Rect>, - pub notes_body: Rect, -} - -pub(crate) fn release_notes_sections(area: Rect, preview: bool) -> ReleaseNotesSections { - if preview && area.height >= 6 { - let rows = Layout::vertical([Constraint::Length(5), Constraint::Min(0)]).areas::<2>(area); - ReleaseNotesSections { - instructions: Some(rows[0]), - notes_body: rows[1], - } - } else { - ReleaseNotesSections { - instructions: None, - notes_body: area, - } - } -} - -fn release_notes_preview_lines<'a>(_version: &str, p: &Palette) -> Vec<Line<'a>> { - let title_style = Style::default().fg(p.text).add_modifier(Modifier::BOLD); - let text_style = Style::default().fg(p.text); - let code_style = Style::default() - .fg(p.accent) - .bg(p.surface0) - .add_modifier(Modifier::BOLD); - - vec![ - Line::from(vec![ - Span::styled( - "●", - Style::default().fg(p.accent).add_modifier(Modifier::BOLD), - ), - Span::styled(" update available", title_style), - ]), - Line::from(vec![ - Span::styled("quit herdr and run ", text_style), - Span::styled("herdr update", code_style), - Span::styled(" to install", text_style), - ]), - ] -} - -fn render_release_notes_preview_panel(frame: &mut Frame, area: Rect, _version: &str, p: &Palette) { - let rows = Layout::vertical([ - Constraint::Length(2), - Constraint::Length(1), - Constraint::Length(1), - Constraint::Length(1), - ]) - .areas::<4>(area); - - let text_area = Rect::new( - rows[0].x + 1, - rows[0].y, - rows[0].width.saturating_sub(2), - rows[0].height, - ); - frame.render_widget( - Paragraph::new(release_notes_preview_lines(_version, p)).wrap(Wrap { trim: false }), - text_area, - ); - - let divider_area = Rect::new(rows[2].x + 1, rows[2].y, rows[2].width.saturating_sub(2), 1); - frame.render_widget( - Paragraph::new(Line::from(vec![Span::styled( - "─".repeat(divider_area.width as usize), - Style::default().fg(p.surface1), - )])), - divider_area, - ); -} - -pub(crate) fn release_notes_close_button_rect(area: Rect) -> Rect { - let width = action_button_width(Some("esc"), "close"); - Rect::new(area.x + area.width.saturating_sub(width), area.y, width, 1) -} - -pub(crate) fn onboarding_welcome_continue_rect(area: Rect) -> Rect { - Rect::new( - area.x, - area.y, - action_button_width(Some("↵"), "continue"), - 1, - ) -} - -pub(crate) struct ActionButtonSpec<'a> { - pub hint: Option<&'a str>, - pub label: &'a str, -} - -pub(crate) fn action_button_row_rects( - area: Rect, - buttons: &[ActionButtonSpec<'_>], - gap: u16, - row_offset: u16, -) -> Vec<Rect> { - let widths: Vec<u16> = buttons - .iter() - .map(|button| action_button_width(button.hint, button.label)) - .collect(); - centered_button_row(area, &widths, gap, row_offset) -} - -pub(crate) fn onboarding_notification_button_rects(area: Rect) -> (Rect, Rect) { - let rects = action_button_row_rects( - area, - &[ - ActionButtonSpec { - hint: Some("esc"), - label: "back", - }, - ActionButtonSpec { - hint: Some("↵"), - label: "start", - }, - ], - 2, - 0, - ); - (rects[0], rects[1]) -} - -fn render_onboarding_welcome(app: &AppState, frame: &mut Frame, area: Rect) { - let Some(inner) = render_modal_shell(frame, area, 64, 16, &app.palette) else { - return; - }; - if inner.height < 11 { - return; - } - - let stack = modal_stack_areas(inner, 2, 0, 1, 1); - let header_rows = - Layout::vertical([Constraint::Length(1), Constraint::Length(1)]).areas::<2>(stack.header); - let content_rows = Layout::vertical([ - Constraint::Length(3), - Constraint::Length(1), - Constraint::Length(1), - Constraint::Min(0), - ]) - .areas::<4>(stack.content); - - frame.render_widget( - Paragraph::new(" herdr").style( - Style::default() - .fg(app.palette.text) - .add_modifier(Modifier::BOLD), - ), - header_rows[0], - ); - frame.render_widget( - Paragraph::new(" terminal workspace manager for coding agents") - .style(Style::default().fg(app.palette.overlay0)), - header_rows[1], - ); - - frame.render_widget( - Paragraph::new( - " this is a mouse-first terminal.\n click the sidebar to switch workspaces, drag pane\n borders to resize, right-click for context menus.", - ) - .style(Style::default().fg(app.palette.overlay1)), - content_rows[0], - ); - - let key_line = Line::from(vec![ - Span::styled(" ", Style::default()), - Span::styled( - ONBOARDING_PREFIX_LABEL, - Style::default() - .fg(app.palette.accent) - .add_modifier(Modifier::BOLD), - ), - Span::styled( - " enters navigate mode · ", - Style::default().fg(app.palette.overlay1), - ), - Span::styled( - "?", - Style::default() - .fg(app.palette.accent) - .add_modifier(Modifier::BOLD), - ), - Span::styled( - " shows keybinds and settings", - Style::default().fg(app.palette.overlay1), - ), - ]); - frame.render_widget(Paragraph::new(key_line), content_rows[2]); - - let continue_rect = onboarding_welcome_continue_rect(stack.actions.unwrap_or_default()); - render_action_button( - frame, - continue_rect, - Some("↵"), - "continue", - Style::default() - .fg(panel_contrast_fg(&app.palette)) - .bg(app.palette.accent) - .add_modifier(Modifier::BOLD), - ); -} - -fn render_onboarding_notifications(app: &AppState, frame: &mut Frame, area: Rect) { - let Some(inner) = render_modal_shell(frame, area, 56, 14, &app.palette) else { - return; - }; - - if inner.height < 11 { - return; - } - - let stack = modal_stack_areas(inner, 3, 0, 1, 1); - let header_rows = Layout::vertical([ - Constraint::Length(1), - Constraint::Length(1), - Constraint::Length(1), - ]) - .areas::<3>(stack.header); - let option_rows = Layout::vertical([ - Constraint::Length(1), - Constraint::Length(1), - Constraint::Length(1), - Constraint::Length(1), - Constraint::Min(0), - ]) - .areas::<5>(stack.content); - - render_modal_header(frame, header_rows[0], "notification style", &app.palette); - frame.render_widget( - Paragraph::new(" herdr watches background panes and can alert you") - .style(Style::default().fg(app.palette.overlay1)), - header_rows[1], - ); - frame.render_widget( - Paragraph::new(" when agents finish or need attention.") - .style(Style::default().fg(app.palette.overlay1)), - header_rows[2], - ); - - let options = [ - "quiet no interruptions", - "visual only top-right toasts", - "sound only sound alerts", - "both sound and toasts", - ]; - - for (idx, option) in options.iter().enumerate() { - let selected = idx == app.onboarding_list.selected; - let prefix = if selected { "›" } else { " " }; - let style = if selected { - Style::default() - .fg(panel_contrast_fg(&app.palette)) - .bg(app.palette.accent) - } else { - Style::default().fg(app.palette.text) - }; - frame.render_widget( - Paragraph::new(format!(" {prefix} {}. {option}", idx + 1)).style(style), - option_rows[idx], - ); - } - - let (back_rect, save_rect) = - onboarding_notification_button_rects(stack.actions.unwrap_or_default()); - render_action_button( - frame, - back_rect, - Some("esc"), - "back", - Style::default() - .fg(app.palette.text) - .bg(app.palette.surface0) - .add_modifier(Modifier::BOLD), - ); - render_action_button( - frame, - save_rect, - Some("↵"), - "start", - Style::default() - .fg(panel_contrast_fg(&app.palette)) - .bg(app.palette.accent) - .add_modifier(Modifier::BOLD), - ); -} - /// Floating overlay for navigate mode — appears at bottom of terminal area. -fn render_navigate_overlay(app: &AppState, frame: &mut Frame, area: Rect) { - let key = Style::default() - .fg(app.palette.accent) - .add_modifier(Modifier::BOLD); - let dim = Style::default().fg(app.palette.overlay0); - - let mode_style = Style::default() - .fg(panel_contrast_fg(&app.palette)) - .bg(app.palette.accent) - .add_modifier(Modifier::BOLD); - - let kb = &app.keybinds; - let line = Line::from(vec![ - Span::styled(" NAVIGATE ", mode_style), - Span::raw(" "), - Span::styled("esc", key), - Span::styled(" back ", dim), - Span::styled("↑↓", key), - Span::styled(" ws ", dim), - Span::styled("⇥", key), - Span::styled(" pane ", dim), - Span::styled(kb.new_tab_label.as_str(), key), - Span::styled(" new tab ", dim), - Span::styled(kb.split_vertical_label.as_str(), key), - Span::styled(" split│ ", dim), - Span::styled(kb.split_horizontal_label.as_str(), key), - Span::styled(" split─ ", dim), - Span::styled(kb.close_pane_label.as_str(), key), - Span::styled(" close ", dim), - Span::styled(kb.fullscreen_label.as_str(), key), - Span::styled(" full ", dim), - Span::styled(kb.resize_mode_label.as_str(), key), - Span::styled(" resize ", dim), - Span::styled("?", key), - Span::styled(" keybinds ", dim), - Span::styled("s", key), - Span::styled(" settings ", dim), - Span::styled("q", key), - Span::styled(" quit", dim), - ]); - - let overlay_y = area.y + area.height.saturating_sub(1); - let overlay_area = Rect::new(area.x, overlay_y, area.width, 1); - - frame.render_widget(Clear, overlay_area); - let bg = Style::default().bg(app.palette.panel_bg); - let buf = frame.buffer_mut(); - for x in overlay_area.x..overlay_area.x + overlay_area.width { - buf[(x, overlay_y)].set_style(bg); - } - frame.render_widget(Paragraph::new(line), overlay_area); - - if app.update_available.is_some() { - let status = Line::from(vec![Span::styled( - " update available", - Style::default() - .fg(app.palette.accent) - .add_modifier(Modifier::BOLD), - )]); - let width = 13u16.min(overlay_area.width); - let status_area = Rect::new( - overlay_area.x + overlay_area.width.saturating_sub(width), - overlay_area.y, - width, - overlay_area.height, - ); - frame.render_widget(Clear, status_area); - frame.render_widget( - Paragraph::new(status).alignment(Alignment::Right), - status_area, - ); - } -} - -fn render_global_launcher_menu(app: &AppState, frame: &mut Frame) { - let rect = app.global_menu_rect(); - let Some(inner) = render_panel_shell(frame, rect, app.palette.accent, app.palette.panel_bg) - else { - return; - }; - - let items = app.global_menu_labels(); - for (idx, item) in items.iter().enumerate() { - let y = inner.y + idx as u16; - if y >= inner.y + inner.height { - break; - } - let selected = idx == app.global_menu.highlighted; - let rect = Rect::new(inner.x, y, inner.width, 1); - - if *item == "update available" { - let line = if selected { - Line::from(vec![ - Span::styled( - " update available ", - Style::default() - .fg(panel_contrast_fg(&app.palette)) - .bg(app.palette.accent) - .add_modifier(Modifier::BOLD), - ), - Span::styled( - "● ", - Style::default() - .fg(panel_contrast_fg(&app.palette)) - .bg(app.palette.accent) - .add_modifier(Modifier::BOLD), - ), - ]) - } else { - Line::from(vec![ - Span::styled(" update available ", Style::default().fg(app.palette.text)), - Span::styled( - "● ", - Style::default() - .fg(app.palette.accent) - .add_modifier(Modifier::BOLD), - ), - ]) - }; - frame.render_widget(Paragraph::new(line).alignment(Alignment::Left), rect); - continue; - } - - let style = if selected { - Style::default() - .fg(panel_contrast_fg(&app.palette)) - .bg(app.palette.accent) - .add_modifier(Modifier::BOLD) - } else { - Style::default().fg(app.palette.text) - }; - frame.render_widget( - Paragraph::new(format!(" {item} ")) - .style(style) - .alignment(Alignment::Left), - rect, - ); - } -} - -fn optional_keybind_label(label: &Option<String>) -> String { - label.clone().unwrap_or_else(|| "unset".to_string()) -} - -fn keybind_help_groups(app: &AppState) -> Vec<(&'static str, Vec<(String, &'static str)>)> { - let kb = &app.keybinds; - let mut groups = Vec::new(); - - groups.push(( - "global", - vec![ - ( - crate::config::format_key_combo((app.prefix_code, app.prefix_mods)), - "navigate mode", - ), - ("prefix + ?".to_string(), "keybinds"), - ], - )); - - groups.push(( - "navigation", - vec![ - ("esc".to_string(), "back"), - ("↑ / ↓".to_string(), "workspace list"), - ("h j k l / arrows".to_string(), "move focus"), - ("tab / shift+tab".to_string(), "cycle pane"), - ("enter".to_string(), "open workspace"), - ("s".to_string(), "settings"), - ("q".to_string(), "quit"), - ], - )); - - let workspace_tab = vec![ - (kb.new_workspace_label.clone(), "new workspace"), - (kb.rename_workspace_label.clone(), "rename workspace"), - (kb.close_workspace_label.clone(), "close workspace"), - ( - optional_keybind_label(&kb.previous_workspace_label), - "previous workspace", - ), - ( - optional_keybind_label(&kb.next_workspace_label), - "next workspace", - ), - (kb.new_tab_label.clone(), "new tab"), - (optional_keybind_label(&kb.rename_tab_label), "rename tab"), - ( - optional_keybind_label(&kb.previous_tab_label), - "previous tab", - ), - (optional_keybind_label(&kb.next_tab_label), "next tab"), - (optional_keybind_label(&kb.close_tab_label), "close tab"), - ]; - groups.push(("workspaces / tabs", workspace_tab)); - - let panes = vec![ - (kb.split_vertical_label.clone(), "split vertical"), - (kb.split_horizontal_label.clone(), "split horizontal"), - (kb.close_pane_label.clone(), "close pane"), - (kb.fullscreen_label.clone(), "fullscreen"), - (kb.resize_mode_label.clone(), "resize mode"), - (kb.toggle_sidebar_label.clone(), "toggle sidebar"), - ( - optional_keybind_label(&kb.focus_pane_left_label), - "focus pane left", - ), - ( - optional_keybind_label(&kb.focus_pane_down_label), - "focus pane down", - ), - ( - optional_keybind_label(&kb.focus_pane_up_label), - "focus pane up", - ), - ( - optional_keybind_label(&kb.focus_pane_right_label), - "focus pane right", - ), - ]; - groups.push(("panes", panes)); - - if !kb.custom_commands.is_empty() { - groups.push(( - "custom", - kb.custom_commands - .iter() - .map(|binding| (binding.label.clone(), "custom command")) - .collect(), - )); - } - - groups -} - -pub(crate) fn keybind_help_lines(app: &AppState) -> Vec<(usize, Line<'static>)> { - let heading_style = Style::default() - .fg(app.palette.accent) - .add_modifier(Modifier::BOLD); - let key_style = Style::default() - .fg(app.palette.mauve) - .add_modifier(Modifier::BOLD); - let label_style = Style::default().fg(app.palette.text); - - let groups = keybind_help_groups(app); - let key_width = groups - .iter() - .flat_map(|(_, entries)| entries.iter().map(|(key, _)| key.chars().count())) - .max() - .unwrap_or(8); - - let mut lines = Vec::new(); - - for (group, entries) in groups { - lines.push(( - group.len() + 1, - Line::from(vec![Span::styled(format!(" {group}"), heading_style)]), - )); - for (key, label) in entries { - let padded_key = format!(" {:<width$} ", key, width = key_width); - let width = padded_key.chars().count() + label.chars().count(); - lines.push(( - width, - Line::from(vec![ - Span::styled(padded_key, key_style), - Span::styled(label.to_string(), label_style), - ]), - )); - } - lines.push((0, Line::raw(""))); - } - - lines -} - -fn render_keybind_help_overlay(app: &AppState, frame: &mut Frame) { - dim_background(frame, frame.area()); - - let Some(inner) = render_modal_shell(frame, frame.area(), 76, 22, &app.palette) else { - return; - }; - if inner.height < 6 || inner.width < 20 { - return; - } - - let stack = modal_stack_areas(inner, 2, 1, 0, 1); - let header_rows = - Layout::vertical([Constraint::Length(1), Constraint::Length(1)]).areas::<2>(stack.header); - - render_modal_header(frame, header_rows[0], "keybinds", &app.palette); - render_action_button( - frame, - release_notes_close_button_rect(header_rows[0]), - Some("esc"), - "close", - Style::default() - .fg(panel_contrast_fg(&app.palette)) - .bg(app.palette.accent) - .add_modifier(Modifier::BOLD), - ); - frame.render_widget( - Paragraph::new(" available commands and configured shortcuts") - .style(Style::default().fg(app.palette.overlay1)), - header_rows[1], - ); - - let body_area = stack.content; - let metrics = crate::pane::ScrollMetrics { - offset_from_bottom: app - .keybind_help_max_scroll() - .saturating_sub(app.keybind_help.scroll) as usize, - max_offset_from_bottom: app.keybind_help_max_scroll() as usize, - viewport_rows: body_area.height.max(1) as usize, - }; - let track = release_notes_scrollbar_rect(body_area, metrics); - let text_area = track - .map(|_| { - Rect::new( - body_area.x, - body_area.y, - body_area.width.saturating_sub(1), - body_area.height, - ) - }) - .unwrap_or(body_area); - - let body = Paragraph::new( - keybind_help_lines(app) - .into_iter() - .map(|(_, line)| line) - .collect::<Vec<_>>(), - ) - .wrap(Wrap { trim: false }) - .scroll((app.keybind_help.scroll, 0)); - frame.render_widget(body, text_area); - if let Some(track) = track { - render_scrollbar( - frame, - metrics, - track, - app.palette.overlay0, - app.palette.overlay1, - "▐", - ); - } - - frame.render_widget( - Paragraph::new(Line::from(vec![ - Span::styled(" scroll ", Style::default().fg(app.palette.overlay0)), - Span::styled("wheel ↑↓", Style::default().fg(app.palette.text)), - Span::styled(" · ", Style::default().fg(app.palette.overlay0)), - Span::styled("jump", Style::default().fg(app.palette.overlay0)), - Span::styled(" pgup / pgdn ", Style::default().fg(app.palette.text)), - Span::styled(" · ", Style::default().fg(app.palette.overlay0)), - Span::styled("close", Style::default().fg(app.palette.overlay0)), - Span::styled(" esc / enter ", Style::default().fg(app.palette.text)), - ])), - stack.footer.unwrap_or_default(), - ); -} - -/// Floating overlay for resize mode. -fn render_resize_overlay(app: &AppState, frame: &mut Frame, area: Rect) { - let key = Style::default() - .fg(app.palette.accent) - .add_modifier(Modifier::BOLD); - let dim = Style::default().fg(app.palette.overlay0); - - let mode_style = Style::default() - .fg(panel_contrast_fg(&app.palette)) - .bg(app.palette.mauve) - .add_modifier(Modifier::BOLD); - - let line = Line::from(vec![ - Span::styled(" RESIZE ", mode_style), - Span::raw(" "), - Span::styled("h/l", key), - Span::styled(" width ", dim), - Span::styled("j/k", key), - Span::styled(" height ", dim), - Span::styled("esc", key), - Span::styled(" done", dim), - ]); - - let overlay_y = area.y + area.height.saturating_sub(1); - let overlay_area = Rect::new(area.x, overlay_y, area.width, 1); - - frame.render_widget(Clear, overlay_area); - let bg = Style::default().bg(app.palette.panel_bg); - let buf = frame.buffer_mut(); - for x in overlay_area.x..overlay_area.x + overlay_area.width { - buf[(x, overlay_y)].set_style(bg); - } - frame.render_widget(Paragraph::new(line), overlay_area); -} - -/// Centered popup confirmation dialog with dimmed background. -pub(crate) fn rename_button_rects(inner: Rect) -> (Rect, Rect, Rect) { - let rects = action_button_row_rects( - inner, - &[ - ActionButtonSpec { - hint: Some("↵"), - label: "save", - }, - ActionButtonSpec { - hint: Some("^c"), - label: "clear", - }, - ActionButtonSpec { - hint: Some("esc"), - label: "cancel", - }, - ], - 2, - 3, - ); - (rects[0], rects[1], rects[2]) -} - -fn render_rename_overlay(app: &AppState, frame: &mut Frame, area: Rect) { - dim_background(frame, area); - - let title = match app.mode { - Mode::RenameWorkspace => "rename workspace", - Mode::RenameTab if app.creating_new_tab => "new tab", - Mode::RenameTab => "rename tab", - _ => return, - }; - - let Some(inner) = render_modal_shell(frame, area, 56, 7, &app.palette) else { - return; - }; - if inner.height < 4 { - return; - } - - let rows = Layout::vertical([ - Constraint::Length(1), - Constraint::Length(1), - Constraint::Length(1), - Constraint::Length(1), - Constraint::Min(0), - ]) - .areas::<5>(inner); - - render_modal_header(frame, rows[0], title, &app.palette); - - let input_rect = Rect::new(rows[2].x, rows[2].y, rows[2].width, 1); - frame.render_widget(Clear, input_rect); - frame.render_widget( - Paragraph::new(format!(" {}█", app.name_input)).style( - Style::default() - .fg(app.palette.text) - .bg(app.palette.surface0), - ), - input_rect, - ); - - let (save_rect, clear_rect, cancel_rect) = rename_button_rects(inner); - - render_action_button( - frame, - save_rect, - Some("↵"), - "save", - Style::default() - .fg(panel_contrast_fg(&app.palette)) - .bg(app.palette.accent) - .add_modifier(Modifier::BOLD), - ); - render_action_button( - frame, - clear_rect, - Some("^c"), - "clear", - Style::default() - .fg(app.palette.text) - .bg(app.palette.surface0) - .add_modifier(Modifier::BOLD), - ); - render_action_button( - frame, - cancel_rect, - Some("esc"), - "cancel", - Style::default() - .fg(app.palette.text) - .bg(app.palette.surface0) - .add_modifier(Modifier::BOLD), - ); -} - -fn render_confirm_close_overlay(app: &AppState, frame: &mut Frame, area: Rect) { - let ws_name = app - .workspaces - .get(app.selected) - .map(|ws| ws.display_name()) - .unwrap_or_else(|| "?".to_string()); - let pane_count = app - .workspaces - .get(app.selected) - .map(|ws| ws.layout.pane_count()) - .unwrap_or(0); - - let pane_text = if pane_count == 1 { - "1 pane".to_string() - } else { - format!("{pane_count} panes") - }; - - // Dim the entire background - let buf = frame.buffer_mut(); - for y in area.y..area.y + area.height { - for x in area.x..area.x + area.width { - let cell = &mut buf[(x, y)]; - cell.set_style(cell.style().add_modifier(Modifier::DIM)); - } - } - - // Centered popup - let Some(popup) = confirm_close_popup_rect(area) else { - return; - }; - - let warn = Style::default() - .fg(app.palette.red) - .add_modifier(Modifier::BOLD); - let dim = Style::default().fg(app.palette.overlay0); - - let title_line = Line::from(vec![Span::styled(" Close workspace?", warn)]); - - let detail_line = Line::from(vec![ - Span::styled( - format!(" {ws_name}"), - Style::default() - .fg(app.palette.text) - .add_modifier(Modifier::BOLD), - ), - Span::styled(format!(" — {pane_text}"), dim), - ]); - - let Some(inner) = render_panel_shell(frame, popup, app.palette.red, app.palette.panel_bg) - else { - return; - }; - - if inner.height >= 3 { - let rows = Layout::vertical([ - Constraint::Length(1), - Constraint::Length(1), - Constraint::Length(1), - ]) - .areas::<3>(inner); - - frame.render_widget(Paragraph::new(title_line), rows[0]); - frame.render_widget(Paragraph::new(detail_line), rows[1]); - - let (confirm_rect, cancel_rect) = confirm_close_button_rects(inner); - render_action_button( - frame, - confirm_rect, - Some("↵"), - "confirm", - Style::default() - .fg(panel_contrast_fg(&app.palette)) - .bg(app.palette.red) - .add_modifier(Modifier::BOLD), - ); - render_action_button( - frame, - cancel_rect, - Some("esc"), - "cancel", - Style::default() - .fg(app.palette.text) - .bg(app.palette.surface0) - .add_modifier(Modifier::BOLD), - ); - } -} - -pub(crate) fn action_button_text(hint: Option<&str>, label: &str) -> String { - match hint { - Some(hint) => format!(" {hint} {label} "), - None => format!(" {label} "), - } -} - -pub(crate) fn action_button_width(hint: Option<&str>, label: &str) -> u16 { - action_button_text(hint, label).chars().count() as u16 -} - -fn render_action_button( - frame: &mut Frame, - rect: Rect, - hint: Option<&str>, - label: &str, - style: Style, -) { - frame.render_widget( - Paragraph::new(action_button_text(hint, label)) - .style(style) - .alignment(Alignment::Center), - rect, - ); -} - -fn centered_button_row(inner: Rect, widths: &[u16], gap: u16, row_offset: u16) -> Vec<Rect> { - let total_w = widths - .iter() - .copied() - .sum::<u16>() - .saturating_add(gap.saturating_mul(widths.len().saturating_sub(1) as u16)); - let mut x = inner.x + inner.width.saturating_sub(total_w) / 2; - let y = inner.y + row_offset.min(inner.height.saturating_sub(1)); - widths - .iter() - .map(|w| { - let rect = Rect::new( - x, - y, - (*w).min(inner.width.saturating_sub(x.saturating_sub(inner.x))), - 1, - ); - x = x.saturating_add(*w).saturating_add(gap); - rect - }) - .collect() -} - -pub(crate) fn confirm_close_popup_rect(area: Rect) -> Option<Rect> { - centered_popup_rect(area, 44, 5) -} - -pub(crate) fn confirm_close_button_rects(inner: Rect) -> (Rect, Rect) { - let rects = action_button_row_rects( - inner, - &[ - ActionButtonSpec { - hint: Some("↵"), - label: "confirm", - }, - ActionButtonSpec { - hint: Some("esc"), - label: "cancel", - }, - ], - 2, - 2, - ); - (rects[0], rects[1]) -} - -pub(crate) fn settings_button_rects(inner: Rect) -> (Rect, Rect) { - let rects = action_button_row_rects( - inner, - &[ - ActionButtonSpec { - hint: Some("↵"), - label: "apply", - }, - ActionButtonSpec { - hint: Some("esc"), - label: "close", - }, - ], - 2, - inner.height.saturating_sub(1), - ); - (rects[0], rects[1]) -} - -/// Right-click context menu popup anchored near the click position. -// --------------------------------------------------------------------------- -// Settings overlay -// --------------------------------------------------------------------------- - -fn render_settings_overlay(app: &AppState, frame: &mut Frame, area: Rect) { - use crate::app::state::SettingsSection; - - let p = &app.palette; - let Some(popup) = centered_popup_rect(area, 56, 20) else { - return; - }; - - // Dim everything behind the modal - dim_background(frame, area); - - let Some(inner) = render_panel_shell(frame, popup, p.accent, p.panel_bg) else { - return; - }; - if inner.height < 4 || inner.width < 10 { - return; - } - - let stack = modal_stack_areas(inner, 3, 2, 0, 1); - let header_rows = Layout::vertical([ - Constraint::Length(1), - Constraint::Length(1), - Constraint::Length(1), - ]) - .areas::<3>(stack.header); - - // Title - frame.render_widget( - Paragraph::new(Line::from(vec![Span::styled( - " settings", - Style::default().fg(p.text).add_modifier(Modifier::BOLD), - )])), - header_rows[0], - ); - - // Tab bar - let tabs = Tabs::new(SettingsSection::ALL.iter().map(|s| s.label())) - .select( - SettingsSection::ALL - .iter() - .position(|section| *section == app.settings.section) - .unwrap_or(0), - ) - .style(Style::default().fg(p.overlay1)) - .highlight_style( - Style::default() - .fg(panel_contrast_fg(p)) - .bg(p.accent) - .add_modifier(Modifier::BOLD), - ) - .divider(" ") - .padding(" ", " "); - frame.render_widget(tabs, header_rows[1]); - - // Separator - let sep = "─".repeat(inner.width as usize); - frame.render_widget( - Paragraph::new(Span::styled(&sep, Style::default().fg(p.surface0))), - header_rows[2], - ); - - // Section content - let content_area = stack.content; - - match app.settings.section { - SettingsSection::Theme => { - render_settings_theme(app, frame, content_area); - } - SettingsSection::Sound => { - render_settings_toggle( - frame, - content_area, - p, - "sound alerts", - "play sounds when agents change state in background", - app.sound_enabled(), - app.settings.list.selected, - ); - } - SettingsSection::Toast => { - render_settings_toggle( - frame, - content_area, - p, - "visual toasts", - "show top-right notifications for background events", - app.toast_config.enabled, - app.settings.list.selected, - ); - } - } - - // Footer buttons + hints - if let Some(footer_area) = stack.footer { - let footer_rows = Layout::vertical([Constraint::Length(1), Constraint::Length(1)]) - .areas::<2>(footer_area); - let (apply_rect, close_rect) = settings_button_rects(inner); - render_action_button( - frame, - apply_rect, - Some("↵"), - "apply", - Style::default() - .fg(panel_contrast_fg(p)) - .bg(p.accent) - .add_modifier(Modifier::BOLD), - ); - render_action_button( - frame, - close_rect, - Some("esc"), - "close", - Style::default() - .fg(p.text) - .bg(p.surface0) - .add_modifier(Modifier::BOLD), - ); - - frame.render_widget( - Paragraph::new(Line::from(vec![ - Span::styled(" ↑↓", Style::default().fg(p.overlay0)), - Span::styled(" select ", Style::default().fg(p.overlay1)), - Span::styled("tab", Style::default().fg(p.overlay0)), - Span::styled(" section", Style::default().fg(p.overlay1)), - ])), - footer_rows[0], - ); - } -} - -/// Render the theme picker list inside the settings panel. -fn render_settings_theme(app: &AppState, frame: &mut Frame, area: Rect) { - use crate::app::state::THEME_NAMES; - - let p = &app.palette; - let items: Vec<ListItem> = THEME_NAMES - .iter() - .map(|name| { - let is_current = name.to_lowercase().replace([' ', '_'], "-") - == app.theme_name.to_lowercase().replace([' ', '_'], "-"); - let marker = if is_current { " ✓" } else { "" }; - ListItem::new(Line::from(vec![ - Span::styled(*name, Style::default().fg(p.subtext0)), - Span::styled(marker, Style::default().fg(p.green)), - ])) - }) - .collect(); - - let list = List::new(items) - .highlight_style( - Style::default() - .bg(p.surface0) - .fg(p.text) - .add_modifier(Modifier::BOLD), - ) - .highlight_symbol(" ▸ ") - .style(Style::default().fg(p.subtext0)); - - let mut state = ListState::default().with_selected(Some(app.settings.list.selected)); - frame.render_stateful_widget(list, area, &mut state); -} - -/// Reusable toggle widget for boolean settings (sound, toast). -fn render_settings_toggle( - frame: &mut Frame, - area: Rect, - p: &crate::app::state::Palette, - title: &str, - description: &str, - current_value: bool, - selected_idx: usize, -) { - let [desc_area, _, list_area] = Layout::vertical([ - Constraint::Length(1), - Constraint::Length(1), - Constraint::Min(2), - ]) - .areas::<3>(area); - - let max_desc_len = (desc_area.width as usize).saturating_sub(2); - let desc_text = if description.len() > max_desc_len { - format!(" {}…", &description[..max_desc_len.saturating_sub(2)]) - } else { - format!(" {description}") - }; - frame.render_widget( - Paragraph::new(Span::styled(desc_text, Style::default().fg(p.overlay1))), - desc_area, - ); - - let items: Vec<ListItem> = ["on", "off"] - .into_iter() - .map(|label| { - let is_active = (label == "on") == current_value; - let marker = if is_active { " ✓" } else { "" }; - ListItem::new(Line::from(vec![ - Span::styled(format!("{title}: {label}"), Style::default().fg(p.subtext0)), - Span::styled(marker, Style::default().fg(p.green)), - ])) - }) - .collect(); - - let list = List::new(items) - .highlight_style( - Style::default() - .bg(p.surface0) - .fg(p.text) - .add_modifier(Modifier::BOLD), - ) - .highlight_symbol(" ▸ "); - let mut state = ListState::default().with_selected(Some(selected_idx.min(1))); - frame.render_stateful_widget(list, list_area, &mut state); -} - -fn render_context_menu(app: &AppState, frame: &mut Frame) { - let Some(menu) = &app.context_menu else { - return; - }; - - let p = &app.palette; - let Some(menu_rect) = app.context_menu_rect() else { - return; - }; - let Some(inner) = render_panel_shell(frame, menu_rect, p.accent, p.panel_bg) else { - return; - }; - - let items: Vec<ListItem> = menu - .items() - .iter() - .map(|item| ListItem::new(Line::from(*item))) - .collect(); - let list = List::new(items) - .style(Style::default().fg(p.text)) - .highlight_style( - Style::default() - .bg(p.accent) - .fg(panel_contrast_fg(p)) - .add_modifier(Modifier::BOLD), - ) - .highlight_symbol(" "); - let mut state = ListState::default().with_selected(Some(menu.list.highlighted)); - frame.render_stateful_widget(list, inner, &mut state); -} - -fn render_toast_notification( - frame: &mut Frame, - area: Rect, - toast: &ToastNotification, - offset_for_warning: bool, - p: &Palette, -) { - let dot_color = match toast.kind { - ToastKind::NeedsAttention => p.red, - ToastKind::Finished => p.blue, - ToastKind::UpdateInstalled => p.accent, - }; - let content_width = (toast.title.len().max(toast.context.len()) as u16) + 4; - let width = content_width.saturating_add(2).min(area.width); - let height = 4u16.min(area.height); - let x = area.x + area.width.saturating_sub(width); - let y = area.y - + area - .height - .saturating_sub(height + if offset_for_warning { 1 } else { 0 }); - let toast_area = Rect::new(x, y, width, height); - - frame.render_widget(Clear, toast_area); - let block = Block::default() - .borders(Borders::ALL) - .border_style(Style::default().fg(p.overlay0)) - .style(Style::default().bg(p.panel_bg)); - let inner = block.inner(toast_area); - frame.render_widget(block, toast_area); - - if inner.height < 2 { - return; - } - - let [title_row, context_row] = - Layout::vertical([Constraint::Length(1), Constraint::Length(1)]).areas(inner); - - let title = Line::from(vec![ - Span::styled("●", Style::default().fg(dot_color)), - Span::raw(" "), - Span::styled( - &toast.title, - Style::default().fg(p.text).add_modifier(Modifier::BOLD), - ), - ]); - let context = Line::from(vec![ - Span::styled(" ", Style::default().fg(p.overlay0)), - Span::styled(&toast.context, Style::default().fg(p.overlay0)), - ]); - - frame.render_widget(Paragraph::new(title), title_row); - frame.render_widget(Paragraph::new(context), context_row); -} - -/// Visual badge for a pane's state + seen flag. -/// -/// | State | Icon | Color | -/// |--------------------|------|--------| -/// | Blocked | ● | Red | -/// | Working | ● | Yellow | -/// | Done (idle+unseen) | ● | Blue | -/// | Idle (seen) | ○ | Green | -/// | Unknown | · | Gray | -/// -/// Filled dot = needs attention (blocked/working, or finished unseen). -/// Hollow dot = nothing to do here. -fn render_config_diagnostic(frame: &mut Frame, area: Rect, message: &str, p: &Palette) { - let text = format!(" config warning: {message} "); - let width = text.len() as u16 + 2; - let notif_area = Rect::new( - area.x + area.width.saturating_sub(width.min(area.width)), - area.y, - width.min(area.width), - 1, - ); - - frame.render_widget(Clear, notif_area); - frame.render_widget( - Paragraph::new(Span::styled( - text, - Style::default() - .fg(panel_contrast_fg(p)) - .bg(p.yellow) - .add_modifier(Modifier::BOLD), - )), - notif_area, - ); -} - -/// Compact dot icon for workspace-level aggregate state (top section). -fn state_dot(state: AgentState, seen: bool, p: &Palette) -> (&'static str, Style) { - match (state, seen) { - (AgentState::Blocked, _) => ("●", Style::default().fg(p.red)), - (AgentState::Working, _) => ("●", Style::default().fg(p.yellow)), - (AgentState::Idle, false) => ("●", Style::default().fg(p.teal)), - (AgentState::Idle, true) => ("○", Style::default().fg(p.green)), - (AgentState::Unknown, _) => ("·", Style::default().fg(p.overlay0)), - } -} - -/// Rich icon for per-pane agent detail (bottom section). -/// Uses animated spinner for the working state. -fn agent_icon(state: AgentState, seen: bool, tick: u32, p: &Palette) -> (&'static str, Style) { - match (state, seen) { - (AgentState::Blocked, _) => ("◉", Style::default().fg(p.red)), - (AgentState::Working, _) => (spinner_frame(tick), Style::default().fg(p.yellow)), - (AgentState::Idle, false) => ("●", Style::default().fg(p.teal)), - (AgentState::Idle, true) => ("✓", Style::default().fg(p.green)), - (AgentState::Unknown, _) => ("○", Style::default().fg(p.overlay0)), - } -} - -/// State label for the agent detail panel. -fn state_label(state: AgentState, seen: bool) -> &'static str { - match (state, seen) { - (AgentState::Blocked, _) => "blocked", - (AgentState::Working, _) => "working", - (AgentState::Idle, false) => "done", - (AgentState::Idle, true) => "idle", - (AgentState::Unknown, _) => "idle", - } -} - -/// Color for the state label text. -fn state_label_color(state: AgentState, seen: bool, p: &Palette) -> Color { - match (state, seen) { - (AgentState::Blocked, _) => p.red, - (AgentState::Working, _) => p.yellow, - (AgentState::Idle, false) => p.teal, - (AgentState::Idle, true) => p.green, - (AgentState::Unknown, _) => p.overlay0, - } -} - fn _build_hints(items: &[(&str, &str)], key_style: Style, dim_style: Style) -> Vec<Span<'static>> { let mut spans = Vec::new(); spans.push(Span::raw(" ")); @@ -3540,9 +233,13 @@ fn _build_hints(items: &[(&str, &str)], key_style: Style, dim_style: Style) -> V #[cfg(test)] mod tests { + use super::keybind_help::keybind_help_groups; + use super::release_notes::{release_notes_lines, release_notes_preview_lines}; + use super::scrollbar::scrollbar_thumb; use super::*; - use crate::{detect::Agent, workspace::Workspace}; + use crate::{app::state::Palette, layout::PaneInfo, workspace::Workspace}; use ratatui::{backend::TestBackend, Terminal}; + use ratatui::{style::Color, text::Line}; #[tokio::test] async fn focused_pane_cursor_wins_during_terminal_render() { @@ -3607,6 +304,37 @@ mod tests { } #[test] + fn expanded_sidebar_workspace_rows_show_state_before_name_without_numbers() { + let mut app = crate::app::state::AppState::test_new(); + let mut ws = Workspace::test_new("one"); + let repo = temp_git_repo("main"); + ws.identity_cwd = repo.clone(); + let root_pane = ws.tabs[0].root_pane; + ws.tabs[0].pane_cwds.insert(root_pane, repo.clone()); + + app.workspaces = vec![ws]; + app.selected = 0; + app.mode = Mode::Navigate; + + compute_view(&mut app, Rect::new(0, 0, 80, 20)); + + let backend = TestBackend::new(80, 20); + let mut terminal = Terminal::new(backend).unwrap(); + terminal.draw(|frame| render(&app, frame)).unwrap(); + let buffer = terminal.backend().buffer(); + + let card = app.view.workspace_card_areas[0].rect; + let line1 = buffer_row_text(buffer, card, card.y); + let line2 = buffer_row_text(buffer, card, card.y + 1); + + assert!(line1.starts_with(" · one")); + assert!(!line1.contains("1 one")); + assert_eq!(line2, " main"); + + std::fs::remove_dir_all(repo).ok(); + } + + #[test] fn tab_bar_dims_auto_named_tabs_and_emphasizes_custom_tabs() { let mut app = crate::app::state::AppState::test_new(); let mut ws = Workspace::test_new("test"); @@ -3765,78 +493,11 @@ mod tests { } #[test] - fn all_workspaces_agent_panel_entries_use_workspace_and_optional_tab_labels() { - let mut app = crate::app::state::AppState::test_new(); - let mut first = Workspace::test_new("one"); - let first_pane = first.tabs[0].root_pane; - first.tabs[0] - .panes - .get_mut(&first_pane) - .unwrap() - .detected_agent = Some(Agent::Pi); - - let mut second = Workspace::test_new("two"); - let second_tab = second.test_add_tab(Some("logs")); - let second_pane = second.tabs[second_tab].root_pane; - second.tabs[second_tab] - .panes - .get_mut(&second_pane) - .unwrap() - .detected_agent = Some(Agent::Claude); - - app.workspaces = vec![first, second]; - app.active = Some(0); - app.selected = 0; - app.agent_panel_scope = AgentPanelScope::AllWorkspaces; - - let entries = agent_panel_entries(&app); - assert_eq!(entries[0].primary_label, "one"); - assert!(entries[0].primary_tab_label.is_none()); - assert_eq!(entries[0].agent_label.as_deref(), Some("pi")); - assert_eq!(entries[1].primary_label, "two"); - assert_eq!(entries[1].primary_tab_label.as_deref(), Some("logs")); - assert_eq!(entries[1].agent_label.as_deref(), Some("claude")); - } - - #[test] - fn all_workspaces_primary_label_truncates_workspace_and_tab() { - let entry = AgentPanelEntry { - ws_idx: 0, - tab_idx: 0, - pane_id: crate::layout::PaneId::from_raw(1), - primary_label: "agent-browser".into(), - primary_tab_label: Some("test-escalation".into()), - agent_label: Some("claude".into()), - state: AgentState::Idle, - seen: true, - }; - - let label = format_agent_panel_primary_label(&entry, 18); - - assert_eq!(label, "agent-bro… · test…"); - } - - #[test] - fn expanded_sidebar_sections_handle_tiny_heights() { - let (ws_area, detail_area) = expanded_sidebar_sections(Rect::new(0, 0, 20, 5), 0.9); - - assert_eq!(ws_area, Rect::new(0, 0, 19, 3)); - assert_eq!(detail_area, Rect::new(0, 3, 19, 2)); - } - - #[test] - fn sidebar_section_divider_is_hidden_for_tiny_heights() { - let divider = sidebar_section_divider_rect(Rect::new(0, 0, 20, 5), 0.5); - - assert_eq!(divider, Rect::default()); - } - - #[test] - fn pane_scrollbar_rect_uses_rightmost_inner_column() { + fn pane_scrollbar_rect_overlays_rightmost_inner_column() { let info = PaneInfo { id: crate::layout::PaneId::from_raw(1), rect: Rect::new(0, 0, 12, 8), - inner_rect: Rect::new(1, 1, 9, 6), + inner_rect: Rect::new(1, 1, 10, 6), scrollbar_rect: Some(Rect::new(10, 1, 1, 6)), is_focused: true, }; @@ -3844,6 +505,40 @@ mod tests { assert_eq!(pane_scrollbar_rect(&info), Some(Rect::new(10, 1, 1, 6))); } + #[tokio::test] + async fn compute_view_keeps_terminal_width_when_pane_scrollbar_is_visible() { + let mut app = crate::app::state::AppState::test_new(); + let mut ws = Workspace::test_new("test"); + let pane_id = ws.tabs[0].root_pane; + ws.tabs[0].runtimes.insert( + pane_id, + crate::pane::PaneRuntime::test_with_scrollback_bytes( + 12, + 4, + 4096, + b"000000000000\r\n111111111111\r\n222222222222\r\n333333333333\r\n444444444444\r\n", + ), + ); + + app.workspaces = vec![ws]; + app.active = Some(0); + app.selected = 0; + + compute_view(&mut app, Rect::new(0, 0, 40, 12)); + + let info = app.view.pane_infos.first().expect("pane info"); + assert_eq!(info.inner_rect.width, app.view.terminal_area.width); + assert_eq!( + info.scrollbar_rect, + Some(Rect::new( + info.inner_rect.x + info.inner_rect.width.saturating_sub(1), + info.inner_rect.y, + 1, + info.inner_rect.height, + )) + ); + } + #[test] fn scrollbar_stays_hidden_without_scrollback() { let metrics = crate::pane::ScrollMetrics { @@ -3915,6 +610,29 @@ mod tests { .collect::<String>() } + fn buffer_row_text(buffer: &ratatui::buffer::Buffer, area: Rect, row: u16) -> String { + (area.x..area.x + area.width) + .map(|x| buffer[(x, row)].symbol()) + .collect::<String>() + .trim_end() + .to_string() + } + + fn temp_git_repo(branch: &str) -> std::path::PathBuf { + let unique = std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .expect("unix time") + .as_nanos(); + let root = std::env::temp_dir().join(format!("herdr-ui-test-{unique}")); + std::fs::create_dir_all(root.join(".git")).expect("create .git dir"); + std::fs::write( + root.join(".git/HEAD"), + format!("ref: refs/heads/{branch}\n"), + ) + .expect("write HEAD"); + root + } + #[test] fn release_notes_inline_code_spans_are_styled_without_backticks() { let palette = Palette::catppuccin(); @@ -3933,10 +651,10 @@ mod tests { let lines = release_notes_preview_lines("0.5.0", &palette); assert_eq!(lines.len(), 2); - assert_eq!(line_text(&lines[0]), "● update available"); + assert_eq!(line_text(&lines[0]), "● update ready"); assert_eq!( line_text(&lines[1]), - "quit herdr and run herdr update to install" + "detach from this session, then run herdr update in your shell" ); assert_eq!(lines[0].spans[0].style.fg, Some(palette.accent)); assert_eq!(lines[0].spans[1].style.fg, Some(palette.text)); diff --git a/src/ui/dialogs.rs b/src/ui/dialogs.rs new file mode 100644 index 00000000..78f1d1cb --- /dev/null +++ b/src/ui/dialogs.rs @@ -0,0 +1,213 @@ +use ratatui::{ + layout::{Constraint, Layout, Rect}, + style::{Modifier, Style}, + text::{Line, Span}, + widgets::{Clear, Paragraph}, + Frame, +}; + +use super::widgets::{ + action_button_row_rects, centered_popup_rect, panel_contrast_fg, render_action_button, + render_modal_header, render_modal_shell, render_panel_shell, ActionButtonSpec, +}; +use crate::app::{AppState, Mode}; + +pub(crate) fn rename_button_rects(inner: Rect) -> (Rect, Rect, Rect) { + let rects = action_button_row_rects( + inner, + &[ + ActionButtonSpec { + hint: Some("↵"), + label: "save", + }, + ActionButtonSpec { + hint: Some("^c"), + label: "clear", + }, + ActionButtonSpec { + hint: Some("esc"), + label: "cancel", + }, + ], + 2, + 3, + ); + (rects[0], rects[1], rects[2]) +} + +pub(super) fn render_rename_overlay(app: &AppState, frame: &mut Frame, area: Rect) { + super::dim_background(frame, area); + + let title = match app.mode { + Mode::RenameWorkspace => "rename workspace", + Mode::RenameTab if app.creating_new_tab => "new tab", + Mode::RenameTab => "rename tab", + _ => return, + }; + + let Some(inner) = render_modal_shell(frame, area, 56, 7, &app.palette) else { + return; + }; + if inner.height < 4 { + return; + } + + let rows = Layout::vertical([ + Constraint::Length(1), + Constraint::Length(1), + Constraint::Length(1), + Constraint::Length(1), + Constraint::Min(0), + ]) + .areas::<5>(inner); + + render_modal_header(frame, rows[0], title, &app.palette); + + let input_rect = Rect::new(rows[2].x, rows[2].y, rows[2].width, 1); + frame.render_widget(Clear, input_rect); + frame.render_widget( + Paragraph::new(format!(" {}█", app.name_input)).style( + Style::default() + .fg(app.palette.text) + .bg(app.palette.surface0), + ), + input_rect, + ); + + let (save_rect, clear_rect, cancel_rect) = rename_button_rects(inner); + + render_action_button( + frame, + save_rect, + Some("↵"), + "save", + Style::default() + .fg(panel_contrast_fg(&app.palette)) + .bg(app.palette.accent) + .add_modifier(Modifier::BOLD), + ); + render_action_button( + frame, + clear_rect, + Some("^c"), + "clear", + Style::default() + .fg(app.palette.text) + .bg(app.palette.surface0) + .add_modifier(Modifier::BOLD), + ); + render_action_button( + frame, + cancel_rect, + Some("esc"), + "cancel", + Style::default() + .fg(app.palette.text) + .bg(app.palette.surface0) + .add_modifier(Modifier::BOLD), + ); +} + +pub(super) fn render_confirm_close_overlay(app: &AppState, frame: &mut Frame, area: Rect) { + let ws_name = app + .workspaces + .get(app.selected) + .map(|ws| ws.display_name()) + .unwrap_or_else(|| "?".to_string()); + let pane_count = app + .workspaces + .get(app.selected) + .map(|ws| ws.layout.pane_count()) + .unwrap_or(0); + + let pane_text = if pane_count == 1 { + "1 pane".to_string() + } else { + format!("{pane_count} panes") + }; + + super::dim_background(frame, area); + + let Some(popup) = confirm_close_popup_rect(area) else { + return; + }; + + let warn = Style::default() + .fg(app.palette.red) + .add_modifier(Modifier::BOLD); + let dim = Style::default().fg(app.palette.overlay0); + + let title_line = Line::from(vec![Span::styled(" Close workspace?", warn)]); + + let detail_line = Line::from(vec![ + Span::styled( + format!(" {ws_name}"), + Style::default() + .fg(app.palette.text) + .add_modifier(Modifier::BOLD), + ), + Span::styled(format!(" — {pane_text}"), dim), + ]); + + let Some(inner) = render_panel_shell(frame, popup, app.palette.red, app.palette.panel_bg) + else { + return; + }; + + if inner.height >= 3 { + let rows = Layout::vertical([ + Constraint::Length(1), + Constraint::Length(1), + Constraint::Length(1), + ]) + .areas::<3>(inner); + + frame.render_widget(Paragraph::new(title_line), rows[0]); + frame.render_widget(Paragraph::new(detail_line), rows[1]); + + let (confirm_rect, cancel_rect) = confirm_close_button_rects(inner); + render_action_button( + frame, + confirm_rect, + Some("↵"), + "confirm", + Style::default() + .fg(panel_contrast_fg(&app.palette)) + .bg(app.palette.red) + .add_modifier(Modifier::BOLD), + ); + render_action_button( + frame, + cancel_rect, + Some("esc"), + "cancel", + Style::default() + .fg(app.palette.text) + .bg(app.palette.surface0) + .add_modifier(Modifier::BOLD), + ); + } +} + +pub(crate) fn confirm_close_popup_rect(area: Rect) -> Option<Rect> { + centered_popup_rect(area, 44, 5) +} + +pub(crate) fn confirm_close_button_rects(inner: Rect) -> (Rect, Rect) { + let rects = action_button_row_rects( + inner, + &[ + ActionButtonSpec { + hint: Some("↵"), + label: "confirm", + }, + ActionButtonSpec { + hint: Some("esc"), + label: "cancel", + }, + ], + 2, + 2, + ); + (rects[0], rects[1]) +} diff --git a/src/ui/keybind_help.rs b/src/ui/keybind_help.rs new file mode 100644 index 00000000..ccff95ab --- /dev/null +++ b/src/ui/keybind_help.rs @@ -0,0 +1,240 @@ +use ratatui::{ + layout::{Constraint, Layout, Rect}, + style::{Modifier, Style}, + text::{Line, Span}, + widgets::{Paragraph, Wrap}, + Frame, +}; + +use super::release_notes::release_notes_close_button_rect; +use super::scrollbar::{release_notes_scrollbar_rect, render_scrollbar}; +use super::widgets::{ + modal_stack_areas, panel_contrast_fg, render_action_button, render_modal_header, + render_modal_shell, +}; +use crate::app::AppState; + +fn optional_keybind_label(label: &Option<String>) -> String { + label.clone().unwrap_or_else(|| "unset".to_string()) +} + +pub(super) fn keybind_help_groups( + app: &AppState, +) -> Vec<(&'static str, Vec<(String, &'static str)>)> { + let kb = &app.keybinds; + let mut groups = Vec::new(); + + groups.push(( + "global", + vec![ + ( + crate::config::format_key_combo((app.prefix_code, app.prefix_mods)), + "navigate mode", + ), + ("prefix + ?".to_string(), "keybinds"), + ], + )); + + groups.push(( + "navigation", + vec![ + ("esc".to_string(), "back"), + ("↑ / ↓".to_string(), "workspace list"), + ("h j k l / arrows".to_string(), "move focus"), + ("tab / shift+tab".to_string(), "cycle pane"), + ("enter".to_string(), "open workspace"), + ("s".to_string(), "settings"), + ("q".to_string(), "quit"), + ], + )); + + let mut workspace_tab = vec![ + (kb.new_workspace_label.clone(), "new workspace"), + (kb.rename_workspace_label.clone(), "rename workspace"), + (kb.close_workspace_label.clone(), "close workspace"), + ( + optional_keybind_label(&kb.previous_workspace_label), + "previous workspace", + ), + ( + optional_keybind_label(&kb.next_workspace_label), + "next workspace", + ), + (kb.new_tab_label.clone(), "new tab"), + (optional_keybind_label(&kb.rename_tab_label), "rename tab"), + ( + optional_keybind_label(&kb.previous_tab_label), + "previous tab", + ), + (optional_keybind_label(&kb.next_tab_label), "next tab"), + (optional_keybind_label(&kb.close_tab_label), "close tab"), + ]; + if let Some(label) = &kb.detach_label { + workspace_tab.insert(3, (label.clone(), "detach from server")); + } + groups.push(("workspaces / tabs", workspace_tab)); + + let panes = vec![ + (kb.split_vertical_label.clone(), "split vertical"), + (kb.split_horizontal_label.clone(), "split horizontal"), + (kb.close_pane_label.clone(), "close pane"), + (kb.fullscreen_label.clone(), "fullscreen"), + (kb.resize_mode_label.clone(), "resize mode"), + (kb.toggle_sidebar_label.clone(), "toggle sidebar"), + ( + optional_keybind_label(&kb.focus_pane_left_label), + "focus pane left", + ), + ( + optional_keybind_label(&kb.focus_pane_down_label), + "focus pane down", + ), + ( + optional_keybind_label(&kb.focus_pane_up_label), + "focus pane up", + ), + ( + optional_keybind_label(&kb.focus_pane_right_label), + "focus pane right", + ), + ]; + groups.push(("panes", panes)); + + if !kb.custom_commands.is_empty() { + groups.push(( + "custom", + kb.custom_commands + .iter() + .map(|binding| (binding.label.clone(), "custom command")) + .collect(), + )); + } + + groups +} + +pub(crate) fn keybind_help_lines(app: &AppState) -> Vec<(usize, Line<'static>)> { + let heading_style = Style::default() + .fg(app.palette.accent) + .add_modifier(Modifier::BOLD); + let key_style = Style::default() + .fg(app.palette.mauve) + .add_modifier(Modifier::BOLD); + let label_style = Style::default().fg(app.palette.text); + + let groups = keybind_help_groups(app); + let key_width = groups + .iter() + .flat_map(|(_, entries)| entries.iter().map(|(key, _)| key.chars().count())) + .max() + .unwrap_or(8); + + let mut lines = Vec::new(); + + for (group, entries) in groups { + lines.push(( + group.len() + 1, + Line::from(vec![Span::styled(format!(" {group}"), heading_style)]), + )); + for (key, label) in entries { + let padded_key = format!(" {:<width$} ", key, width = key_width); + let width = padded_key.chars().count() + label.chars().count(); + lines.push(( + width, + Line::from(vec![ + Span::styled(padded_key, key_style), + Span::styled(label.to_string(), label_style), + ]), + )); + } + lines.push((0, Line::raw(""))); + } + + lines +} + +pub(super) fn render_keybind_help_overlay(app: &AppState, frame: &mut Frame) { + super::dim_background(frame, frame.area()); + + let Some(inner) = render_modal_shell(frame, frame.area(), 76, 22, &app.palette) else { + return; + }; + if inner.height < 6 || inner.width < 20 { + return; + } + + let stack = modal_stack_areas(inner, 2, 1, 0, 1); + let header_rows = + Layout::vertical([Constraint::Length(1), Constraint::Length(1)]).areas::<2>(stack.header); + + render_modal_header(frame, header_rows[0], "keybinds", &app.palette); + render_action_button( + frame, + release_notes_close_button_rect(header_rows[0]), + Some("esc"), + "close", + Style::default() + .fg(panel_contrast_fg(&app.palette)) + .bg(app.palette.accent) + .add_modifier(Modifier::BOLD), + ); + frame.render_widget( + Paragraph::new(" available commands and configured shortcuts") + .style(Style::default().fg(app.palette.overlay1)), + header_rows[1], + ); + + let body_area = stack.content; + let metrics = crate::pane::ScrollMetrics { + offset_from_bottom: app + .keybind_help_max_scroll() + .saturating_sub(app.keybind_help.scroll) as usize, + max_offset_from_bottom: app.keybind_help_max_scroll() as usize, + viewport_rows: body_area.height.max(1) as usize, + }; + let track = release_notes_scrollbar_rect(body_area, metrics); + let text_area = track + .map(|_| { + Rect::new( + body_area.x, + body_area.y, + body_area.width.saturating_sub(1), + body_area.height, + ) + }) + .unwrap_or(body_area); + + let body = Paragraph::new( + keybind_help_lines(app) + .into_iter() + .map(|(_, line)| line) + .collect::<Vec<_>>(), + ) + .wrap(Wrap { trim: false }) + .scroll((app.keybind_help.scroll, 0)); + frame.render_widget(body, text_area); + if let Some(track) = track { + render_scrollbar( + frame, + metrics, + track, + app.palette.overlay0, + app.palette.overlay1, + "▐", + ); + } + + frame.render_widget( + Paragraph::new(Line::from(vec![ + Span::styled(" scroll ", Style::default().fg(app.palette.overlay0)), + Span::styled("wheel ↑↓", Style::default().fg(app.palette.text)), + Span::styled(" · ", Style::default().fg(app.palette.overlay0)), + Span::styled("jump", Style::default().fg(app.palette.overlay0)), + Span::styled(" pgup / pgdn ", Style::default().fg(app.palette.text)), + Span::styled(" · ", Style::default().fg(app.palette.overlay0)), + Span::styled("close", Style::default().fg(app.palette.overlay0)), + Span::styled(" esc / enter ", Style::default().fg(app.palette.text)), + ])), + stack.footer.unwrap_or_default(), + ); +} diff --git a/src/ui/menus.rs b/src/ui/menus.rs new file mode 100644 index 00000000..537ac9a1 --- /dev/null +++ b/src/ui/menus.rs @@ -0,0 +1,210 @@ +use ratatui::{ + layout::{Alignment, Rect}, + style::{Modifier, Style}, + text::{Line, Span}, + widgets::{Clear, List, ListItem, ListState, Paragraph}, + Frame, +}; + +use super::widgets::{panel_contrast_fg, render_panel_shell}; +use crate::app::AppState; + +fn render_bottom_bar(frame: &mut Frame, area: Rect, line: Line<'_>, bg: ratatui::style::Color) { + frame.render_widget(Clear, area); + let buf = frame.buffer_mut(); + for x in area.x..area.x + area.width { + buf[(x, area.y)].set_style(Style::default().bg(bg)); + } + frame.render_widget(Paragraph::new(line), area); +} + +pub(super) fn render_navigate_overlay(app: &AppState, frame: &mut Frame, area: Rect) { + let key = Style::default() + .fg(app.palette.accent) + .add_modifier(Modifier::BOLD); + let dim = Style::default().fg(app.palette.overlay0); + + let mode_style = Style::default() + .fg(panel_contrast_fg(&app.palette)) + .bg(app.palette.accent) + .add_modifier(Modifier::BOLD); + + let kb = &app.keybinds; + let line = Line::from(vec![ + Span::styled(" NAVIGATE ", mode_style), + Span::raw(" "), + Span::styled("esc", key), + Span::styled(" back ", dim), + Span::styled("↑↓", key), + Span::styled(" ws ", dim), + Span::styled("⇥", key), + Span::styled(" pane ", dim), + Span::styled(kb.new_tab_label.as_str(), key), + Span::styled(" new tab ", dim), + Span::styled(kb.split_vertical_label.as_str(), key), + Span::styled(" split│ ", dim), + Span::styled(kb.split_horizontal_label.as_str(), key), + Span::styled(" split─ ", dim), + Span::styled(kb.close_pane_label.as_str(), key), + Span::styled(" close ", dim), + Span::styled(kb.fullscreen_label.as_str(), key), + Span::styled(" full ", dim), + Span::styled(kb.resize_mode_label.as_str(), key), + Span::styled(" resize ", dim), + Span::styled("?", key), + Span::styled(" keybinds ", dim), + Span::styled("s", key), + Span::styled(" settings ", dim), + Span::styled("q", key), + Span::styled(" quit", dim), + ]); + + let overlay_y = area.y + area.height.saturating_sub(1); + let overlay_area = Rect::new(area.x, overlay_y, area.width, 1); + render_bottom_bar(frame, overlay_area, line, app.palette.panel_bg); + + if app.update_available.is_some() { + let status = Line::from(vec![Span::styled( + " update ready", + Style::default() + .fg(app.palette.accent) + .add_modifier(Modifier::BOLD), + )]); + let width = 13u16.min(overlay_area.width); + let status_area = Rect::new( + overlay_area.x + overlay_area.width.saturating_sub(width), + overlay_area.y, + width, + overlay_area.height, + ); + frame.render_widget(Clear, status_area); + frame.render_widget( + Paragraph::new(status).alignment(Alignment::Right), + status_area, + ); + } +} + +pub(super) fn render_global_launcher_menu(app: &AppState, frame: &mut Frame) { + let rect = app.global_menu_rect(); + let Some(inner) = render_panel_shell(frame, rect, app.palette.accent, app.palette.panel_bg) + else { + return; + }; + + let items = app.global_menu_labels(); + for (idx, item) in items.iter().enumerate() { + let y = inner.y + idx as u16; + if y >= inner.y + inner.height { + break; + } + let selected = idx == app.global_menu.highlighted; + let rect = Rect::new(inner.x, y, inner.width, 1); + + if *item == "update ready" { + let line = if selected { + Line::from(vec![ + Span::styled( + " update ready ", + Style::default() + .fg(panel_contrast_fg(&app.palette)) + .bg(app.palette.accent) + .add_modifier(Modifier::BOLD), + ), + Span::styled( + "● ", + Style::default() + .fg(panel_contrast_fg(&app.palette)) + .bg(app.palette.accent) + .add_modifier(Modifier::BOLD), + ), + ]) + } else { + Line::from(vec![ + Span::styled(" update ready ", Style::default().fg(app.palette.text)), + Span::styled( + "● ", + Style::default() + .fg(app.palette.accent) + .add_modifier(Modifier::BOLD), + ), + ]) + }; + frame.render_widget(Paragraph::new(line).alignment(Alignment::Left), rect); + continue; + } + + let style = if selected { + Style::default() + .fg(panel_contrast_fg(&app.palette)) + .bg(app.palette.accent) + .add_modifier(Modifier::BOLD) + } else { + Style::default().fg(app.palette.text) + }; + frame.render_widget( + Paragraph::new(format!(" {item} ")) + .style(style) + .alignment(Alignment::Left), + rect, + ); + } +} + +pub(super) fn render_resize_overlay(app: &AppState, frame: &mut Frame, area: Rect) { + let key = Style::default() + .fg(app.palette.accent) + .add_modifier(Modifier::BOLD); + let dim = Style::default().fg(app.palette.overlay0); + + let mode_style = Style::default() + .fg(panel_contrast_fg(&app.palette)) + .bg(app.palette.mauve) + .add_modifier(Modifier::BOLD); + + let line = Line::from(vec![ + Span::styled(" RESIZE ", mode_style), + Span::raw(" "), + Span::styled("h/l", key), + Span::styled(" width ", dim), + Span::styled("j/k", key), + Span::styled(" height ", dim), + Span::styled("esc", key), + Span::styled(" done", dim), + ]); + + let overlay_y = area.y + area.height.saturating_sub(1); + let overlay_area = Rect::new(area.x, overlay_y, area.width, 1); + render_bottom_bar(frame, overlay_area, line, app.palette.panel_bg); +} + +pub(super) fn render_context_menu(app: &AppState, frame: &mut Frame) { + let Some(menu) = &app.context_menu else { + return; + }; + + let p = &app.palette; + let Some(menu_rect) = app.context_menu_rect() else { + return; + }; + let Some(inner) = render_panel_shell(frame, menu_rect, p.accent, p.panel_bg) else { + return; + }; + + let items: Vec<ListItem> = menu + .items() + .iter() + .map(|item| ListItem::new(Line::from(*item))) + .collect(); + let list = List::new(items) + .style(Style::default().fg(p.text)) + .highlight_style( + Style::default() + .bg(p.accent) + .fg(panel_contrast_fg(p)) + .add_modifier(Modifier::BOLD), + ) + .highlight_symbol(" "); + let mut state = ListState::default().with_selected(Some(menu.list.highlighted)); + frame.render_stateful_widget(list, inner, &mut state); +} diff --git a/src/ui/onboarding.rs b/src/ui/onboarding.rs new file mode 100644 index 00000000..6f35c1a6 --- /dev/null +++ b/src/ui/onboarding.rs @@ -0,0 +1,215 @@ +use ratatui::{ + layout::{Constraint, Layout, Rect}, + style::{Modifier, Style}, + text::{Line, Span}, + widgets::Paragraph, + Frame, +}; + +use super::widgets::{ + action_button_row_rects, action_button_width, modal_stack_areas, panel_contrast_fg, + render_action_button, render_modal_header, render_modal_shell, ActionButtonSpec, +}; +use crate::app::AppState; + +const ONBOARDING_PREFIX_LABEL: &str = "ctrl+b"; + +pub(super) fn render_onboarding_overlay(app: &AppState, frame: &mut Frame, area: Rect) { + super::dim_background(frame, area); + + match app.onboarding_step { + 0 => render_onboarding_welcome(app, frame, area), + _ => render_onboarding_notifications(app, frame, area), + } +} + +pub(crate) fn onboarding_welcome_continue_rect(area: Rect) -> Rect { + Rect::new( + area.x, + area.y, + action_button_width(Some("↵"), "continue"), + 1, + ) +} + +pub(crate) fn onboarding_notification_button_rects(area: Rect) -> (Rect, Rect) { + let rects = action_button_row_rects( + area, + &[ + ActionButtonSpec { + hint: Some("esc"), + label: "back", + }, + ActionButtonSpec { + hint: Some("↵"), + label: "start", + }, + ], + 2, + 0, + ); + (rects[0], rects[1]) +} + +fn render_onboarding_welcome(app: &AppState, frame: &mut Frame, area: Rect) { + let Some(inner) = render_modal_shell(frame, area, 64, 16, &app.palette) else { + return; + }; + if inner.height < 11 { + return; + } + + let stack = modal_stack_areas(inner, 2, 0, 1, 1); + let header_rows = + Layout::vertical([Constraint::Length(1), Constraint::Length(1)]).areas::<2>(stack.header); + let content_rows = Layout::vertical([ + Constraint::Length(3), + Constraint::Length(1), + Constraint::Length(1), + Constraint::Min(0), + ]) + .areas::<4>(stack.content); + + frame.render_widget( + Paragraph::new(" herdr").style( + Style::default() + .fg(app.palette.text) + .add_modifier(Modifier::BOLD), + ), + header_rows[0], + ); + frame.render_widget( + Paragraph::new(" terminal workspace manager for coding agents") + .style(Style::default().fg(app.palette.overlay0)), + header_rows[1], + ); + + frame.render_widget( + Paragraph::new( + " this is a mouse-first terminal.\n click the sidebar to switch workspaces, drag pane\n borders to resize, right-click for context menus.", + ) + .style(Style::default().fg(app.palette.overlay1)), + content_rows[0], + ); + + let key_line = Line::from(vec![ + Span::styled(" ", Style::default()), + Span::styled( + ONBOARDING_PREFIX_LABEL, + Style::default() + .fg(app.palette.accent) + .add_modifier(Modifier::BOLD), + ), + Span::styled( + " enters navigate mode · ", + Style::default().fg(app.palette.overlay1), + ), + Span::styled( + "?", + Style::default() + .fg(app.palette.accent) + .add_modifier(Modifier::BOLD), + ), + Span::styled( + " shows keybinds and settings", + Style::default().fg(app.palette.overlay1), + ), + ]); + frame.render_widget(Paragraph::new(key_line), content_rows[2]); + + let continue_rect = onboarding_welcome_continue_rect(stack.actions.unwrap_or_default()); + render_action_button( + frame, + continue_rect, + Some("↵"), + "continue", + Style::default() + .fg(panel_contrast_fg(&app.palette)) + .bg(app.palette.accent) + .add_modifier(Modifier::BOLD), + ); +} + +fn render_onboarding_notifications(app: &AppState, frame: &mut Frame, area: Rect) { + let Some(inner) = render_modal_shell(frame, area, 56, 14, &app.palette) else { + return; + }; + + if inner.height < 11 { + return; + } + + let stack = modal_stack_areas(inner, 3, 0, 1, 1); + let header_rows = Layout::vertical([ + Constraint::Length(1), + Constraint::Length(1), + Constraint::Length(1), + ]) + .areas::<3>(stack.header); + let option_rows = Layout::vertical([ + Constraint::Length(1), + Constraint::Length(1), + Constraint::Length(1), + Constraint::Length(1), + Constraint::Min(0), + ]) + .areas::<5>(stack.content); + + render_modal_header(frame, header_rows[0], "notification style", &app.palette); + frame.render_widget( + Paragraph::new(" herdr watches background panes and can alert you") + .style(Style::default().fg(app.palette.overlay1)), + header_rows[1], + ); + frame.render_widget( + Paragraph::new(" when agents finish or need attention.") + .style(Style::default().fg(app.palette.overlay1)), + header_rows[2], + ); + + let options = [ + "quiet no interruptions", + "visual only top-right toasts", + "sound only sound alerts", + "both sound and toasts", + ]; + + for (idx, option) in options.iter().enumerate() { + let selected = idx == app.onboarding_list.selected; + let prefix = if selected { "›" } else { " " }; + let style = if selected { + Style::default() + .fg(panel_contrast_fg(&app.palette)) + .bg(app.palette.accent) + } else { + Style::default().fg(app.palette.text) + }; + frame.render_widget( + Paragraph::new(format!(" {prefix} {}. {option}", idx + 1)).style(style), + option_rows[idx], + ); + } + + let (back_rect, save_rect) = + onboarding_notification_button_rects(stack.actions.unwrap_or_default()); + render_action_button( + frame, + back_rect, + Some("esc"), + "back", + Style::default() + .fg(app.palette.text) + .bg(app.palette.surface0) + .add_modifier(Modifier::BOLD), + ); + render_action_button( + frame, + save_rect, + Some("↵"), + "start", + Style::default() + .fg(panel_contrast_fg(&app.palette)) + .bg(app.palette.accent) + .add_modifier(Modifier::BOLD), + ); +} diff --git a/src/ui/panes.rs b/src/ui/panes.rs new file mode 100644 index 00000000..7e1490db --- /dev/null +++ b/src/ui/panes.rs @@ -0,0 +1,252 @@ +use ratatui::{ + layout::Rect, + style::{Color, Modifier, Style}, + text::{Line, Span}, + widgets::{Block, Borders, Paragraph}, + Frame, +}; + +use super::scrollbar::{render_pane_scrollbar, should_show_scrollbar}; +use super::widgets::panel_contrast_fg; +use crate::app::state::Palette; +use crate::app::{AppState, Mode}; +use crate::layout::PaneInfo; + +/// Compute pane layout info and optionally resize pane runtimes to match. +pub(super) fn compute_pane_infos(app: &AppState, area: Rect, resize_panes: bool) -> Vec<PaneInfo> { + let Some(ws_idx) = app.active else { + return Vec::new(); + }; + let Some(ws) = app.workspaces.get(ws_idx) else { + return Vec::new(); + }; + + let multi_pane = ws.layout.pane_count() > 1; + let terminal_active = app.mode == Mode::Terminal; + + if ws.zoomed { + let focused_id = ws.layout.focused(); + let inner_rect = area; + let mut scrollbar_rect = None; + if let Some(rt) = ws.runtimes.get(&focused_id) { + if rt + .scroll_metrics() + .is_some_and(|metrics| should_show_scrollbar(metrics) && area.width > 0) + { + scrollbar_rect = Some(Rect::new( + area.x + area.width.saturating_sub(1), + area.y, + 1, + area.height, + )); + } + if resize_panes { + rt.resize(inner_rect.height, inner_rect.width); + } + } + return vec![PaneInfo { + id: focused_id, + rect: area, + inner_rect, + scrollbar_rect, + is_focused: true, + }]; + } + + let mut pane_infos = ws.layout.panes(area); + + for info in &mut pane_infos { + let pane_inner = if multi_pane { + let border_set = if info.is_focused && terminal_active { + ratatui::symbols::border::THICK + } else { + ratatui::symbols::border::PLAIN + }; + let block = Block::default() + .borders(Borders::ALL) + .border_set(border_set); + block.inner(info.rect) + } else { + area + }; + + let inner_rect = pane_inner; + let mut scrollbar_rect = None; + if let Some(rt) = ws.runtimes.get(&info.id) { + if rt + .scroll_metrics() + .is_some_and(|metrics| should_show_scrollbar(metrics) && pane_inner.width > 0) + { + scrollbar_rect = Some(Rect::new( + pane_inner.x + pane_inner.width.saturating_sub(1), + pane_inner.y, + 1, + pane_inner.height, + )); + } + if resize_panes { + rt.resize(inner_rect.height, inner_rect.width); + } + } + + info.inner_rect = inner_rect; + info.scrollbar_rect = scrollbar_rect; + } + + pane_infos +} + +pub(super) fn render_panes(app: &AppState, frame: &mut Frame, area: Rect) { + let Some(ws_idx) = app.active else { + render_empty(app, frame, area); + return; + }; + let Some(ws) = app.workspaces.get(ws_idx) else { + render_empty(app, frame, area); + return; + }; + + let multi_pane = ws.layout.pane_count() > 1; + let terminal_active = app.mode == Mode::Terminal; + + for info in &app.view.pane_infos { + if let Some(rt) = ws.runtimes.get(&info.id) { + if multi_pane { + let (border_style, border_set) = if info.is_focused && terminal_active { + ( + Style::default().fg(app.palette.accent), + ratatui::symbols::border::THICK, + ) + } else if info.is_focused { + ( + Style::default().fg(app.palette.accent), + ratatui::symbols::border::PLAIN, + ) + } else { + ( + Style::default().fg(app.palette.overlay0), + ratatui::symbols::border::PLAIN, + ) + }; + + let block = Block::default() + .borders(Borders::ALL) + .border_style(border_style) + .border_set(border_set); + frame.render_widget(block, info.rect); + } + + rt.render(frame, info.inner_rect, info.is_focused && terminal_active); + render_pane_scrollbar(app, frame, info, rt); + + let should_dim = !info.is_focused && multi_pane && !terminal_active; + if should_dim { + let inner = info.inner_rect; + let buf = frame.buffer_mut(); + for y in inner.y..inner.y + inner.height { + for x in inner.x..inner.x + inner.width { + let cell = &mut buf[(x, y)]; + let style = cell.style(); + let fg = style.fg.unwrap_or(Color::White); + let dimmed_fg = dim_color(fg); + cell.set_style(style.fg(dimmed_fg)); + } + } + } + + render_selection_highlight( + &app.selection, + frame, + info.id, + info.inner_rect, + rt.scroll_metrics(), + &app.palette, + ); + } + } +} + +/// Render selection highlight for a pane by inverting fg/bg colors. +/// Reduce a color's brightness by blending it toward black. +fn dim_color(color: Color) -> Color { + match color { + Color::Rgb(r, g, b) => Color::Rgb(r / 3, g / 3, b / 3), + Color::White => Color::DarkGray, + Color::Gray => Color::DarkGray, + Color::DarkGray => Color::Rgb(30, 30, 30), + Color::Red => Color::Rgb(60, 0, 0), + Color::Green => Color::Rgb(0, 60, 0), + Color::Yellow => Color::Rgb(60, 60, 0), + Color::Blue => Color::Rgb(0, 0, 60), + Color::Magenta => Color::Rgb(60, 0, 60), + Color::Cyan => Color::Rgb(0, 60, 60), + Color::LightRed => Color::Rgb(80, 30, 30), + Color::LightGreen => Color::Rgb(30, 80, 30), + Color::LightYellow => Color::Rgb(80, 80, 30), + Color::LightBlue => Color::Rgb(30, 30, 80), + Color::LightMagenta => Color::Rgb(80, 30, 80), + Color::LightCyan => Color::Rgb(30, 80, 80), + _ => Color::DarkGray, + } +} + +fn render_selection_highlight( + selection: &Option<crate::selection::Selection>, + frame: &mut Frame, + pane_id: crate::layout::PaneId, + inner: Rect, + scroll_metrics: Option<crate::pane::ScrollMetrics>, + p: &Palette, +) { + if let Some(sel) = selection { + if sel.is_visible() && sel.pane_id == pane_id { + let buf = frame.buffer_mut(); + for y in 0..inner.height { + for x in 0..inner.width { + if sel.contains(y, x, scroll_metrics) { + let cell = &mut buf[(inner.x + x, inner.y + y)]; + cell.set_style(Style::default().fg(panel_contrast_fg(p)).bg(p.blue)); + } + } + } + } + } +} + +fn render_empty(app: &AppState, frame: &mut Frame, area: Rect) { + let p = &app.palette; + let lines = vec![ + Line::from(""), + Line::from(""), + Line::from(Span::styled( + " No workspaces yet", + Style::default().fg(p.overlay0), + )), + Line::from(""), + Line::from(Span::styled( + " A workspace is one project context.", + Style::default().fg(p.overlay1), + )), + Line::from(Span::styled( + " Its root pane (top-left) sets the default repo or folder name.", + Style::default().fg(p.overlay1), + )), + Line::from(""), + Line::from(vec![ + Span::styled(" Press ", Style::default().fg(p.overlay0)), + Span::styled( + format!("{}", app.keybinds.new_workspace_label), + Style::default().fg(p.accent).add_modifier(Modifier::BOLD), + ), + Span::styled(" to create one", Style::default().fg(p.overlay0)), + ]), + ]; + frame.render_widget( + Paragraph::new(lines).block( + Block::default() + .borders(Borders::ALL) + .border_style(Style::default().fg(p.surface_dim)), + ), + area, + ); +} diff --git a/src/ui/release_notes.rs b/src/ui/release_notes.rs new file mode 100644 index 00000000..346b06d5 --- /dev/null +++ b/src/ui/release_notes.rs @@ -0,0 +1,345 @@ +use ratatui::{ + layout::{Constraint, Layout, Rect}, + style::{Modifier, Style}, + text::{Line, Span}, + widgets::{Paragraph, Wrap}, + Frame, +}; + +use super::scrollbar::{release_notes_scrollbar_rect, render_scrollbar}; +use super::widgets::{ + action_button_width, modal_stack_areas, panel_contrast_fg, render_action_button, + render_modal_header, render_modal_shell, +}; +use crate::app::{ + state::{Palette, ReleaseNotesState}, + AppState, +}; + +pub(crate) const RELEASE_NOTES_MODAL_SIZE: (u16, u16) = (80, 24); + +pub(super) fn render_release_notes_overlay(app: &AppState, frame: &mut Frame, area: Rect) { + let Some(notes) = &app.release_notes else { + return; + }; + + super::dim_background(frame, area); + + let Some(inner) = render_modal_shell( + frame, + area, + RELEASE_NOTES_MODAL_SIZE.0, + RELEASE_NOTES_MODAL_SIZE.1, + &app.palette, + ) else { + return; + }; + if inner.height < 8 || inner.width < 20 { + return; + } + + let stack = modal_stack_areas(inner, 2, 1, 0, 1); + let header_rows = + Layout::vertical([Constraint::Length(1), Constraint::Length(1)]).areas::<2>(stack.header); + + let header_title_area = Rect::new( + header_rows[0].x + 1, + header_rows[0].y, + header_rows[0].width.saturating_sub(2), + header_rows[0].height, + ); + let header_subtitle_area = Rect::new( + header_rows[1].x + 1, + header_rows[1].y, + header_rows[1].width.saturating_sub(2), + header_rows[1].height, + ); + + render_modal_header( + frame, + header_title_area, + &format!("v{}", notes.version), + &app.palette, + ); + let subtitle = if notes.preview { + "update ready" + } else { + "what's new in this release" + }; + frame.render_widget( + Paragraph::new(subtitle).style(Style::default().fg(app.palette.overlay1)), + header_subtitle_area, + ); + render_action_button( + frame, + release_notes_close_button_rect(header_rows[0]), + Some("esc"), + "close", + Style::default() + .fg(panel_contrast_fg(&app.palette)) + .bg(app.palette.accent) + .add_modifier(Modifier::BOLD), + ); + + let sections = release_notes_sections(stack.content, notes.preview); + let metrics = crate::pane::ScrollMetrics { + offset_from_bottom: app.release_notes_max_scroll().saturating_sub(notes.scroll) as usize, + max_offset_from_bottom: app.release_notes_max_scroll() as usize, + viewport_rows: sections.notes_body.height.max(1) as usize, + }; + let track = release_notes_scrollbar_rect(sections.notes_body, metrics); + let notes_text_area = track + .map(|_| { + Rect::new( + sections.notes_body.x, + sections.notes_body.y, + sections.notes_body.width.saturating_sub(1), + sections.notes_body.height, + ) + }) + .unwrap_or(sections.notes_body); + + if let Some(instructions_area) = sections.instructions { + render_release_notes_preview_panel(frame, instructions_area, ¬es.version, &app.palette); + } + + let body = Paragraph::new( + release_notes_display_lines(notes, &app.palette) + .into_iter() + .map(|(_, line)| line) + .collect::<Vec<_>>(), + ) + .wrap(Wrap { trim: false }) + .scroll((notes.scroll, 0)); + frame.render_widget(body, notes_text_area); + if let Some(track) = track { + render_scrollbar( + frame, + metrics, + track, + app.palette.overlay0, + app.palette.overlay1, + "▐", + ); + } + + frame.render_widget( + Paragraph::new(Line::from(vec![ + Span::styled(" scroll ", Style::default().fg(app.palette.overlay0)), + Span::styled("wheel ↑↓", Style::default().fg(app.palette.text)), + Span::styled(" · ", Style::default().fg(app.palette.overlay0)), + Span::styled("close", Style::default().fg(app.palette.overlay0)), + Span::styled(" esc / enter ", Style::default().fg(app.palette.text)), + ])), + stack.footer.unwrap_or_default(), + ); +} + +fn release_notes_inline_spans<'a>( + text: &str, + base_style: Style, + code_style: Style, +) -> (usize, Vec<Span<'a>>) { + let mut spans = Vec::new(); + let mut width = 0; + let mut remaining = text; + + while let Some(start) = remaining.find('`') { + let (before, after_start) = remaining.split_at(start); + if !before.is_empty() { + width += before.chars().count(); + spans.push(Span::styled(before.to_string(), base_style)); + } + + let after_start = &after_start[1..]; + let Some(end) = after_start.find('`') else { + let literal = format!("`{after_start}"); + width += literal.chars().count(); + spans.push(Span::styled(literal, base_style)); + remaining = ""; + break; + }; + + let (code, after_end) = after_start.split_at(end); + width += code.chars().count(); + if !code.is_empty() { + spans.push(Span::styled(code.to_string(), code_style)); + } + remaining = &after_end[1..]; + } + + if !remaining.is_empty() { + width += remaining.chars().count(); + spans.push(Span::styled(remaining.to_string(), base_style)); + } + + if spans.is_empty() { + spans.push(Span::styled(String::new(), base_style)); + } + + (width, spans) +} + +pub(crate) fn release_notes_lines<'a>(body: &'a str, p: &Palette) -> Vec<(usize, Line<'a>)> { + let mut lines = Vec::new(); + let mut in_fenced_code_block = false; + let text_style = Style::default().fg(p.text); + let inline_code_style = Style::default() + .fg(p.accent) + .bg(p.surface0) + .add_modifier(Modifier::BOLD); + + for raw in body.lines() { + let trimmed = raw.trim_end(); + if trimmed.trim_start().starts_with("```") { + in_fenced_code_block = !in_fenced_code_block; + continue; + } + + if in_fenced_code_block { + let code_bg = p.surface1; + let gutter_style = Style::default().fg(p.accent).bg(code_bg); + let code_style = Style::default().fg(p.text).bg(code_bg); + let width = 2 + trimmed.chars().count(); + let mut spans = vec![ + Span::styled("▏", gutter_style), + Span::styled(" ", code_style), + ]; + if !trimmed.is_empty() { + spans.push(Span::styled(trimmed.to_string(), code_style)); + } + lines.push((width, Line::from(spans))); + continue; + } + + if trimmed.is_empty() { + lines.push((0, Line::raw(""))); + continue; + } + + if let Some(rest) = trimmed.strip_prefix("### ") { + let text = rest.trim().to_string(); + if text.is_empty() { + lines.push((0, Line::raw(""))); + continue; + } + let width = 1 + text.chars().count(); + lines.push(( + width, + Line::from(vec![ + Span::raw(" "), + Span::styled( + text.to_uppercase(), + Style::default().fg(p.accent).add_modifier(Modifier::BOLD), + ), + ]), + )); + continue; + } + + if let Some(rest) = trimmed.strip_prefix("- ") { + let (text_width, mut spans) = + release_notes_inline_spans(rest, text_style, inline_code_style); + let width = 3 + text_width; + let mut line_spans = vec![Span::styled(" • ", Style::default().fg(p.accent))]; + line_spans.append(&mut spans); + lines.push((width, Line::from(line_spans))); + continue; + } + + let (text_width, mut spans) = + release_notes_inline_spans(trimmed, text_style, inline_code_style); + let width = 1 + text_width; + let mut line_spans = vec![Span::raw(" ")]; + line_spans.append(&mut spans); + lines.push((width, Line::from(line_spans))); + } + + lines +} + +pub(crate) struct ReleaseNotesSections { + pub instructions: Option<Rect>, + pub notes_body: Rect, +} + +pub(crate) fn release_notes_sections(area: Rect, preview: bool) -> ReleaseNotesSections { + if preview && area.height >= 6 { + let rows = Layout::vertical([Constraint::Length(5), Constraint::Min(0)]).areas::<2>(area); + ReleaseNotesSections { + instructions: Some(rows[0]), + notes_body: rows[1], + } + } else { + ReleaseNotesSections { + instructions: None, + notes_body: area, + } + } +} + +pub(super) fn release_notes_preview_lines<'a>(_version: &str, p: &Palette) -> Vec<Line<'a>> { + let title_style = Style::default().fg(p.text).add_modifier(Modifier::BOLD); + let text_style = Style::default().fg(p.text); + let code_style = Style::default() + .fg(p.accent) + .bg(p.surface0) + .add_modifier(Modifier::BOLD); + + vec![ + Line::from(vec![ + Span::styled( + "●", + Style::default().fg(p.accent).add_modifier(Modifier::BOLD), + ), + Span::styled(" update ready", title_style), + ]), + Line::from(vec![ + Span::styled("detach from this session, then run ", text_style), + Span::styled("herdr update", code_style), + Span::styled(" in your shell", text_style), + ]), + ] +} + +fn render_release_notes_preview_panel(frame: &mut Frame, area: Rect, _version: &str, p: &Palette) { + let rows = Layout::vertical([ + Constraint::Length(2), + Constraint::Length(1), + Constraint::Length(1), + Constraint::Length(1), + ]) + .areas::<4>(area); + + let text_area = Rect::new( + rows[0].x + 1, + rows[0].y, + rows[0].width.saturating_sub(2), + rows[0].height, + ); + frame.render_widget( + Paragraph::new(release_notes_preview_lines(_version, p)).wrap(Wrap { trim: false }), + text_area, + ); + + let divider_area = Rect::new(rows[2].x + 1, rows[2].y, rows[2].width.saturating_sub(2), 1); + frame.render_widget( + Paragraph::new(Line::from(vec![Span::styled( + "─".repeat(divider_area.width as usize), + Style::default().fg(p.surface1), + )])), + divider_area, + ); +} + +pub(crate) fn release_notes_display_lines<'a>( + notes: &'a ReleaseNotesState, + p: &Palette, +) -> Vec<(usize, Line<'a>)> { + release_notes_lines(notes.body.as_str(), p) +} + +pub(crate) fn release_notes_close_button_rect(area: Rect) -> Rect { + let width = action_button_width(Some("esc"), "close"); + Rect::new(area.x + area.width.saturating_sub(width), area.y, width, 1) +} diff --git a/src/ui/scrollbar.rs b/src/ui/scrollbar.rs new file mode 100644 index 00000000..34e739d0 --- /dev/null +++ b/src/ui/scrollbar.rs @@ -0,0 +1,191 @@ +use ratatui::{ + layout::Rect, + style::{Color, Style}, + Frame, +}; + +use crate::app::AppState; +use crate::layout::PaneInfo; + +pub(crate) fn pane_scrollbar_rect(info: &PaneInfo) -> Option<Rect> { + info.scrollbar_rect +} + +pub(crate) fn release_notes_scrollbar_rect( + body: Rect, + metrics: crate::pane::ScrollMetrics, +) -> Option<Rect> { + (should_show_scrollbar(metrics) && body.width > 1).then_some(Rect::new( + body.x + body.width - 1, + body.y, + 1, + body.height, + )) +} + +pub(crate) fn should_show_scrollbar(metrics: crate::pane::ScrollMetrics) -> bool { + metrics.max_offset_from_bottom > 0 +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub(crate) struct ScrollbarThumb { + pub top: u16, + pub len: u16, +} + +pub(crate) fn scrollbar_thumb( + metrics: crate::pane::ScrollMetrics, + track: Rect, +) -> Option<ScrollbarThumb> { + if metrics.max_offset_from_bottom == 0 || track.height == 0 { + return None; + } + + let track_height = track.height as usize; + let total_rows = metrics.max_offset_from_bottom + metrics.viewport_rows; + if total_rows == 0 { + return None; + } + + let thumb_len = ((metrics.viewport_rows * track_height) as f32 / total_rows as f32) + .round() + .max(1.0) + .min(track_height as f32) as usize; + let max_thumb_top = track_height.saturating_sub(thumb_len); + let scrolled_from_top = metrics + .max_offset_from_bottom + .saturating_sub(metrics.offset_from_bottom); + let thumb_top = if max_thumb_top == 0 || metrics.max_offset_from_bottom == 0 { + 0 + } else { + ((scrolled_from_top * max_thumb_top) as f32 / metrics.max_offset_from_bottom as f32) + .round() + .clamp(0.0, max_thumb_top as f32) as usize + }; + + Some(ScrollbarThumb { + top: track.y + thumb_top as u16, + len: thumb_len as u16, + }) +} + +pub(crate) fn scrollbar_thumb_grab_offset( + metrics: crate::pane::ScrollMetrics, + track: Rect, + row: u16, +) -> Option<u16> { + let thumb = scrollbar_thumb(metrics, track)?; + (row >= thumb.top && row < thumb.top + thumb.len).then_some(row - thumb.top) +} + +fn scrollbar_offset_from_thumb_top( + metrics: crate::pane::ScrollMetrics, + track: Rect, + thumb_top: usize, +) -> usize { + if metrics.max_offset_from_bottom == 0 { + return 0; + } + + let thumb_len = scrollbar_thumb(metrics, track) + .map(|thumb| thumb.len as usize) + .unwrap_or(1); + let max_thumb_top = track.height as usize - thumb_len.min(track.height as usize); + if max_thumb_top == 0 { + return 0; + } + + let desired_top = thumb_top.min(max_thumb_top); + let scrolled_from_top = ((desired_top * metrics.max_offset_from_bottom) as f32 + / max_thumb_top as f32) + .round() as usize; + metrics + .max_offset_from_bottom + .saturating_sub(scrolled_from_top) +} + +pub(crate) fn scrollbar_offset_from_row( + metrics: crate::pane::ScrollMetrics, + track: Rect, + row: u16, +) -> usize { + let thumb = match scrollbar_thumb(metrics, track) { + Some(thumb) => thumb, + None => return 0, + }; + let clamped_row = row.clamp(track.y, track.y + track.height.saturating_sub(1)); + let row_offset = clamped_row.saturating_sub(track.y) as usize; + let thumb_center = (thumb.len as usize) / 2; + let desired_top = row_offset.saturating_sub(thumb_center); + scrollbar_offset_from_thumb_top(metrics, track, desired_top) +} + +pub(crate) fn scrollbar_offset_from_drag_row( + metrics: crate::pane::ScrollMetrics, + track: Rect, + row: u16, + grab_row_offset: u16, +) -> usize { + let clamped_row = row.clamp(track.y, track.y + track.height.saturating_sub(1)); + let row_offset = clamped_row.saturating_sub(track.y) as usize; + let desired_top = row_offset.saturating_sub(grab_row_offset as usize); + scrollbar_offset_from_thumb_top(metrics, track, desired_top) +} + +pub(super) fn render_scrollbar( + frame: &mut Frame, + metrics: crate::pane::ScrollMetrics, + track: Rect, + track_color: Color, + thumb_color: Color, + thumb_symbol: &str, +) { + if metrics.max_offset_from_bottom == 0 { + return; + } + + let Some(thumb) = scrollbar_thumb(metrics, track) else { + return; + }; + + let buf = frame.buffer_mut(); + for y in track.y..track.y + track.height { + let cell = &mut buf[(track.x, y)]; + cell.set_symbol("▕"); + cell.set_style(Style::default().fg(track_color)); + } + for y in thumb.top..thumb.top + thumb.len { + let cell = &mut buf[(track.x, y)]; + cell.set_symbol(thumb_symbol); + cell.set_style(Style::default().fg(thumb_color)); + } +} + +pub(super) fn render_pane_scrollbar( + app: &AppState, + frame: &mut Frame, + info: &PaneInfo, + rt: &crate::pane::PaneRuntime, +) { + let Some(metrics) = rt.scroll_metrics() else { + return; + }; + let Some(track) = pane_scrollbar_rect(info) else { + return; + }; + + let (track_color, thumb_color, thumb_symbol) = if info.is_focused { + (app.palette.overlay0, app.palette.overlay1, "▐") + } else { + (app.palette.surface_dim, app.palette.overlay0, "▕") + }; + + render_scrollbar( + frame, + metrics, + track, + track_color, + thumb_color, + thumb_symbol, + ); +} diff --git a/src/ui/settings.rs b/src/ui/settings.rs new file mode 100644 index 00000000..1123f408 --- /dev/null +++ b/src/ui/settings.rs @@ -0,0 +1,238 @@ +use ratatui::{ + layout::{Constraint, Layout, Rect}, + style::{Modifier, Style}, + text::{Line, Span}, + widgets::{List, ListItem, ListState, Paragraph, Tabs}, + Frame, +}; + +use super::widgets::{ + action_button_row_rects, centered_popup_rect, modal_stack_areas, panel_contrast_fg, + render_action_button, render_panel_shell, ActionButtonSpec, +}; +use crate::app::{state::Palette, AppState}; + +pub(super) fn render_settings_overlay(app: &AppState, frame: &mut Frame, area: Rect) { + use crate::app::state::SettingsSection; + + let p = &app.palette; + let Some(popup) = centered_popup_rect(area, 56, 20) else { + return; + }; + + super::dim_background(frame, area); + + let Some(inner) = render_panel_shell(frame, popup, p.accent, p.panel_bg) else { + return; + }; + if inner.height < 4 || inner.width < 10 { + return; + } + + let stack = modal_stack_areas(inner, 3, 2, 0, 1); + let header_rows = Layout::vertical([ + Constraint::Length(1), + Constraint::Length(1), + Constraint::Length(1), + ]) + .areas::<3>(stack.header); + + frame.render_widget( + Paragraph::new(Line::from(vec![Span::styled( + " settings", + Style::default().fg(p.text).add_modifier(Modifier::BOLD), + )])), + header_rows[0], + ); + + let tabs = Tabs::new(SettingsSection::ALL.iter().map(|s| s.label())) + .select( + SettingsSection::ALL + .iter() + .position(|section| *section == app.settings.section) + .unwrap_or(0), + ) + .style(Style::default().fg(p.overlay1)) + .highlight_style( + Style::default() + .fg(panel_contrast_fg(p)) + .bg(p.accent) + .add_modifier(Modifier::BOLD), + ) + .divider(" ") + .padding(" ", " "); + frame.render_widget(tabs, header_rows[1]); + + let sep = "─".repeat(inner.width as usize); + frame.render_widget( + Paragraph::new(Span::styled(&sep, Style::default().fg(p.surface0))), + header_rows[2], + ); + + let content_area = stack.content; + + match app.settings.section { + SettingsSection::Theme => { + render_settings_theme(app, frame, content_area); + } + SettingsSection::Sound => { + render_settings_toggle( + frame, + content_area, + p, + "sound alerts", + "play sounds when agents change state in background", + app.sound_enabled(), + app.settings.list.selected, + ); + } + SettingsSection::Toast => { + render_settings_toggle( + frame, + content_area, + p, + "visual toasts", + "show top-right notifications for background events", + app.toast_config.enabled, + app.settings.list.selected, + ); + } + } + + if let Some(footer_area) = stack.footer { + let footer_rows = Layout::vertical([Constraint::Length(1), Constraint::Length(1)]) + .areas::<2>(footer_area); + let (apply_rect, close_rect) = settings_button_rects(inner); + render_action_button( + frame, + apply_rect, + Some("↵"), + "apply", + Style::default() + .fg(panel_contrast_fg(p)) + .bg(p.accent) + .add_modifier(Modifier::BOLD), + ); + render_action_button( + frame, + close_rect, + Some("esc"), + "close", + Style::default() + .fg(p.text) + .bg(p.surface0) + .add_modifier(Modifier::BOLD), + ); + + frame.render_widget( + Paragraph::new(Line::from(vec![ + Span::styled(" ↑↓", Style::default().fg(p.overlay0)), + Span::styled(" select ", Style::default().fg(p.overlay1)), + Span::styled("tab", Style::default().fg(p.overlay0)), + Span::styled(" section", Style::default().fg(p.overlay1)), + ])), + footer_rows[0], + ); + } +} + +pub(crate) fn settings_button_rects(inner: Rect) -> (Rect, Rect) { + let rects = action_button_row_rects( + inner, + &[ + ActionButtonSpec { + hint: Some("↵"), + label: "apply", + }, + ActionButtonSpec { + hint: Some("esc"), + label: "close", + }, + ], + 2, + inner.height.saturating_sub(1), + ); + (rects[0], rects[1]) +} + +fn render_settings_theme(app: &AppState, frame: &mut Frame, area: Rect) { + use crate::app::state::THEME_NAMES; + + let p = &app.palette; + let items: Vec<ListItem> = THEME_NAMES + .iter() + .map(|name| { + let is_current = name.to_lowercase().replace([' ', '_'], "-") + == app.theme_name.to_lowercase().replace([' ', '_'], "-"); + let marker = if is_current { " ✓" } else { "" }; + ListItem::new(Line::from(vec![ + Span::styled(*name, Style::default().fg(p.subtext0)), + Span::styled(marker, Style::default().fg(p.green)), + ])) + }) + .collect(); + + let list = List::new(items) + .highlight_style( + Style::default() + .bg(p.surface0) + .fg(p.text) + .add_modifier(Modifier::BOLD), + ) + .highlight_symbol(" ▸ ") + .style(Style::default().fg(p.subtext0)); + + let mut state = ListState::default().with_selected(Some(app.settings.list.selected)); + frame.render_stateful_widget(list, area, &mut state); +} + +fn render_settings_toggle( + frame: &mut Frame, + area: Rect, + p: &Palette, + title: &str, + description: &str, + current_value: bool, + selected_idx: usize, +) { + let [desc_area, _, list_area] = Layout::vertical([ + Constraint::Length(1), + Constraint::Length(1), + Constraint::Min(2), + ]) + .areas::<3>(area); + + let max_desc_len = (desc_area.width as usize).saturating_sub(2); + let desc_text = if description.len() > max_desc_len { + format!(" {}…", &description[..max_desc_len.saturating_sub(2)]) + } else { + format!(" {description}") + }; + frame.render_widget( + Paragraph::new(Span::styled(desc_text, Style::default().fg(p.overlay1))), + desc_area, + ); + + let items: Vec<ListItem> = ["on", "off"] + .into_iter() + .map(|label| { + let is_active = (label == "on") == current_value; + let marker = if is_active { " ✓" } else { "" }; + ListItem::new(Line::from(vec![ + Span::styled(format!("{title}: {label}"), Style::default().fg(p.subtext0)), + Span::styled(marker, Style::default().fg(p.green)), + ])) + }) + .collect(); + + let list = List::new(items) + .highlight_style( + Style::default() + .bg(p.surface0) + .fg(p.text) + .add_modifier(Modifier::BOLD), + ) + .highlight_symbol(" ▸ "); + let mut state = ListState::default().with_selected(Some(selected_idx.min(1))); + frame.render_stateful_widget(list, list_area, &mut state); +} diff --git a/src/ui/sidebar.rs b/src/ui/sidebar.rs new file mode 100644 index 00000000..36d1385a --- /dev/null +++ b/src/ui/sidebar.rs @@ -0,0 +1,940 @@ +use ratatui::{ + layout::{Alignment, Rect}, + style::{Modifier, Style}, + text::{Line, Span}, + widgets::Paragraph, + Frame, +}; + +use super::scrollbar::{render_scrollbar, should_show_scrollbar}; +use super::status::{agent_icon, state_dot, state_label, state_label_color}; +use crate::app::state::{AgentPanelScope, Palette}; +use crate::app::{AppState, Mode}; +use crate::detect::AgentState; + +const WORKSPACE_SECTION_HEADER_ROWS: u16 = 2; +const AGENT_PANEL_HEADER_ROWS: u16 = 3; + +pub(crate) struct AgentPanelEntry { + pub ws_idx: usize, + pub tab_idx: usize, + pub pane_id: crate::layout::PaneId, + pub primary_label: String, + pub primary_tab_label: Option<String>, + pub agent_label: Option<String>, + pub state: AgentState, + pub seen: bool, +} + +fn sidebar_section_heights(total_h: u16, split_ratio: f32) -> (u16, u16) { + if total_h == 0 { + return (0, 0); + } + + if total_h < 6 { + let ws_h = (total_h + 1) / 2; + return (ws_h, total_h.saturating_sub(ws_h)); + } + + let ratio = split_ratio.clamp(0.1, 0.9); + let ws_h = ((total_h as f32) * ratio).round() as u16; + let ws_h = ws_h.clamp(3, total_h.saturating_sub(3)); + let detail_h = total_h.saturating_sub(ws_h); + (ws_h, detail_h) +} + +pub(crate) fn expanded_sidebar_sections(area: Rect, split_ratio: f32) -> (Rect, Rect) { + let content = Rect::new(area.x, area.y, area.width.saturating_sub(1), area.height); + if content.width == 0 || content.height == 0 { + return (Rect::default(), Rect::default()); + } + + let (ws_h, detail_h) = sidebar_section_heights(content.height, split_ratio); + let ws_area = Rect::new(content.x, content.y, content.width, ws_h); + let detail_area = Rect::new(content.x, content.y + ws_h, content.width, detail_h); + (ws_area, detail_area) +} + +pub(crate) fn sidebar_section_divider_rect(area: Rect, split_ratio: f32) -> Rect { + let content = Rect::new(area.x, area.y, area.width.saturating_sub(1), area.height); + if content.width == 0 || content.height < 6 { + return Rect::default(); + } + + let (ws_h, _) = sidebar_section_heights(content.height, split_ratio); + Rect::new(content.x, content.y + ws_h, content.width, 1) +} + +fn agent_panel_current_workspace_idx(app: &AppState) -> Option<usize> { + if matches!( + app.mode, + Mode::Navigate + | Mode::RenameWorkspace + | Mode::Resize + | Mode::ConfirmClose + | Mode::ContextMenu + | Mode::Settings + | Mode::GlobalMenu + | Mode::KeybindHelp + ) { + Some(app.selected) + } else { + app.active + } +} + +fn agent_panel_toggle_label(scope: AgentPanelScope) -> &'static str { + match scope { + AgentPanelScope::CurrentWorkspace => "current", + AgentPanelScope::AllWorkspaces => "all", + } +} + +pub(crate) fn agent_panel_toggle_rect(area: Rect, scope: AgentPanelScope) -> Rect { + if area.width == 0 || area.height < 2 { + return Rect::default(); + } + + let label = agent_panel_toggle_label(scope); + let width = label.chars().count() as u16; + Rect::new( + area.x + area.width.saturating_sub(width), + area.y + 1, + width, + 1, + ) +} + +pub(crate) fn agent_panel_entries(app: &AppState) -> Vec<AgentPanelEntry> { + match app.agent_panel_scope { + AgentPanelScope::CurrentWorkspace => { + let Some(ws_idx) = agent_panel_current_workspace_idx(app) else { + return Vec::new(); + }; + let Some(ws) = app.workspaces.get(ws_idx) else { + return Vec::new(); + }; + ws.pane_details() + .into_iter() + .map(|detail| AgentPanelEntry { + ws_idx, + tab_idx: detail.tab_idx, + pane_id: detail.pane_id, + primary_label: detail.label, + primary_tab_label: None, + agent_label: None, + state: detail.state, + seen: detail.seen, + }) + .collect() + } + AgentPanelScope::AllWorkspaces => app + .workspaces + .iter() + .enumerate() + .flat_map(|(ws_idx, ws)| { + let multi_tab = ws.tabs.len() > 1; + let workspace_label = ws.display_name(); + ws.pane_details() + .into_iter() + .map(move |detail| AgentPanelEntry { + ws_idx, + tab_idx: detail.tab_idx, + pane_id: detail.pane_id, + primary_label: workspace_label.clone(), + primary_tab_label: multi_tab.then_some(detail.tab_label), + agent_label: Some(detail.agent_label), + state: detail.state, + seen: detail.seen, + }) + }) + .collect(), + } +} + +fn truncate_text(text: &str, max_width: usize) -> String { + let len = text.chars().count(); + if len <= max_width { + return text.to_string(); + } + if max_width == 0 { + return String::new(); + } + if max_width == 1 { + return "…".to_string(); + } + let prefix: String = text.chars().take(max_width.saturating_sub(1)).collect(); + format!("{prefix}…") +} + +fn format_agent_panel_primary_label(entry: &AgentPanelEntry, max_width: usize) -> String { + let Some(tab_label) = entry.primary_tab_label.as_deref() else { + return truncate_text(&entry.primary_label, max_width); + }; + + let separator = " · "; + let separator_width = separator.chars().count(); + if max_width <= separator_width + 2 { + return truncate_text( + &format!("{}{}{}", entry.primary_label, separator, tab_label), + max_width, + ); + } + + let available = max_width.saturating_sub(separator_width); + let min_tab = 4.min(available.saturating_sub(1)).max(1); + let preferred_workspace = ((available * 2) / 3).max(1); + let mut workspace_budget = preferred_workspace + .min(available.saturating_sub(min_tab)) + .max(1); + let mut tab_budget = available.saturating_sub(workspace_budget); + + let workspace_len = entry.primary_label.chars().count(); + let tab_len = tab_label.chars().count(); + + if workspace_len < workspace_budget { + let spare = workspace_budget - workspace_len; + workspace_budget = workspace_len; + tab_budget = (tab_budget + spare).min(available.saturating_sub(workspace_budget)); + } + if tab_len < tab_budget { + let spare = tab_budget - tab_len; + tab_budget = tab_len; + workspace_budget = (workspace_budget + spare).min(available.saturating_sub(tab_budget)); + } + + format!( + "{}{}{}", + truncate_text(&entry.primary_label, workspace_budget), + separator, + truncate_text(tab_label, tab_budget) + ) +} + +fn workspace_row_height(ws: &crate::workspace::Workspace) -> u16 { + if ws.branch().is_some() { + 2 + } else { + 1 + } +} + +pub(crate) fn workspace_list_rect(area: Rect, split_ratio: f32) -> Rect { + let (ws_area, _) = expanded_sidebar_sections(area, split_ratio); + ws_area +} + +pub(crate) fn workspace_list_body_rect(area: Rect, has_scrollbar: bool) -> Rect { + if area.width == 0 || area.height <= WORKSPACE_SECTION_HEADER_ROWS { + return Rect::default(); + } + + let body_y = area.y.saturating_add(WORKSPACE_SECTION_HEADER_ROWS); + let footer_y = area.y + area.height.saturating_sub(1); + let body_height = footer_y.saturating_sub(body_y); + let body_width = area.width.saturating_sub(u16::from(has_scrollbar)); + Rect::new(area.x, body_y, body_width, body_height) +} + +fn workspace_list_visible_count(app: &AppState, area: Rect, scroll: usize) -> usize { + let body = workspace_list_body_rect(area, false); + if body.width == 0 || body.height == 0 { + return 0; + } + + let mut used_rows = 0u16; + let mut visible = 0usize; + for ws in app.workspaces.iter().skip(scroll) { + let needed = workspace_row_height(ws).saturating_add(1); + if used_rows.saturating_add(needed) > body.height { + break; + } + used_rows = used_rows.saturating_add(needed); + visible += 1; + } + visible +} + +pub(crate) fn workspace_list_scroll_metrics( + app: &AppState, + area: Rect, +) -> crate::pane::ScrollMetrics { + let viewport_rows = workspace_list_visible_count(app, area, app.workspace_scroll); + let total_rows = app.workspaces.len(); + let max_offset_from_bottom = total_rows.saturating_sub(viewport_rows); + let offset_from_bottom = total_rows + .saturating_sub(app.workspace_scroll) + .saturating_sub(viewport_rows); + + crate::pane::ScrollMetrics { + offset_from_bottom, + max_offset_from_bottom, + viewport_rows, + } +} + +pub(crate) fn workspace_list_scrollbar_rect(app: &AppState, area: Rect) -> Option<Rect> { + let metrics = workspace_list_scroll_metrics(app, area); + let body = workspace_list_body_rect(area, true); + (should_show_scrollbar(metrics) && body.width > 0 && body.height > 0).then_some(Rect::new( + area.x + area.width.saturating_sub(1), + body.y, + 1, + body.height, + )) +} + +pub(crate) fn agent_panel_body_rect(area: Rect, has_scrollbar: bool) -> Rect { + if area.width == 0 || area.height <= AGENT_PANEL_HEADER_ROWS { + return Rect::default(); + } + + let body_y = area.y.saturating_add(AGENT_PANEL_HEADER_ROWS); + let body_height = (area.y + area.height).saturating_sub(body_y); + let body_width = area.width.saturating_sub(u16::from(has_scrollbar)); + Rect::new(area.x, body_y, body_width, body_height) +} + +fn agent_panel_visible_count(area: Rect) -> usize { + let body = agent_panel_body_rect(area, false); + if body.width == 0 || body.height < 2 { + return 0; + } + + let mut used_rows = 0u16; + let mut visible = 0usize; + while used_rows.saturating_add(2) <= body.height { + used_rows = used_rows.saturating_add(2); + visible += 1; + if used_rows < body.height { + used_rows = used_rows.saturating_add(1); + } + } + visible +} + +pub(crate) fn agent_panel_scroll_metrics(app: &AppState, area: Rect) -> crate::pane::ScrollMetrics { + let viewport_rows = agent_panel_visible_count(area); + let total_rows = agent_panel_entries(app).len(); + let max_offset_from_bottom = total_rows.saturating_sub(viewport_rows); + let offset_from_bottom = total_rows + .saturating_sub(app.agent_panel_scroll) + .saturating_sub(viewport_rows); + + crate::pane::ScrollMetrics { + offset_from_bottom, + max_offset_from_bottom, + viewport_rows, + } +} + +pub(crate) fn agent_panel_scrollbar_rect(app: &AppState, area: Rect) -> Option<Rect> { + let metrics = agent_panel_scroll_metrics(app, area); + let body = agent_panel_body_rect(area, true); + (should_show_scrollbar(metrics) && body.width > 0 && body.height > 0).then_some(Rect::new( + area.x + area.width.saturating_sub(1), + body.y, + 1, + body.height, + )) +} + +pub(crate) fn compute_workspace_card_areas( + app: &AppState, + area: Rect, +) -> Vec<crate::app::state::WorkspaceCardArea> { + let ws_area = workspace_list_rect(area, app.sidebar_section_split); + if ws_area == Rect::default() { + return Vec::new(); + } + + let metrics = workspace_list_scroll_metrics(app, ws_area); + let body = workspace_list_body_rect(ws_area, should_show_scrollbar(metrics)); + if body.width == 0 || body.height == 0 { + return Vec::new(); + } + + let mut row_y = body.y; + let body_bottom = body.y + body.height; + let mut cards = Vec::new(); + + for (ws_idx, ws) in app.workspaces.iter().enumerate().skip(app.workspace_scroll) { + let row_height = workspace_row_height(ws); + if row_y.saturating_add(row_height).saturating_add(1) > body_bottom { + break; + } + cards.push(crate::app::state::WorkspaceCardArea { + ws_idx, + rect: Rect::new(body.x, row_y, body.width, row_height), + }); + row_y = row_y.saturating_add(row_height + 1); + } + + cards +} + +/// Auto-scale sidebar width based on workspace identity + agent summary. +pub(crate) fn collapsed_sidebar_sections(area: Rect) -> (Rect, Option<u16>, Rect) { + let content = Rect::new(area.x, area.y, area.width.saturating_sub(1), area.height); + if content.width == 0 || content.height == 0 { + return (Rect::default(), None, Rect::default()); + } + + if content.height < 7 { + return (content, None, Rect::default()); + } + + let total_h = content.height as usize; + let ws_h = (total_h + 1) / 2; + let detail_h = total_h.saturating_sub(ws_h + 1); + if ws_h == 0 || detail_h == 0 { + return (content, None, Rect::default()); + } + + let divider_y = content.y + ws_h as u16; + let ws_area = Rect::new(content.x, content.y, content.width, ws_h as u16); + let detail_area = Rect::new(content.x, divider_y + 1, content.width, detail_h as u16); + (ws_area, Some(divider_y), detail_area) +} + +/// Collapsed sidebar: workspace glance on top, compact agent list below. +pub(super) fn render_sidebar_collapsed(app: &AppState, frame: &mut Frame, area: Rect) { + let is_navigating = matches!(app.mode, Mode::Navigate); + + let p = &app.palette; + let sep_style = if is_navigating { + Style::default().fg(p.accent) + } else { + Style::default().fg(p.surface_dim) + }; + let sep_x = area.x + area.width.saturating_sub(1); + let buf = frame.buffer_mut(); + for y in area.y..area.y + area.height { + buf[(sep_x, y)].set_symbol("│"); + buf[(sep_x, y)].set_style(sep_style); + } + + let (ws_area, divider_y, detail_area) = collapsed_sidebar_sections(area); + if ws_area == Rect::default() { + render_sidebar_toggle(app, frame, area, true, p); + return; + } + + for (visible_idx, ws) in app.workspaces.iter().enumerate() { + let y = ws_area.y + visible_idx as u16; + if y >= ws_area.y + ws_area.height { + break; + } + let (agg_state, agg_seen) = ws.aggregate_state(); + let (icon, icon_style) = state_dot(agg_state, agg_seen, p); + let is_selected = visible_idx == app.selected && is_navigating; + let is_active = Some(visible_idx) == app.active; + let row_style = if is_selected { + Style::default().bg(p.surface0) + } else if is_active { + Style::default().bg(p.surface_dim) + } else { + Style::default() + }; + let num_style = if is_selected { + Style::default().fg(p.overlay1).bg(p.surface0) + } else if is_active { + Style::default().fg(p.text).bg(p.surface_dim) + } else { + Style::default().fg(p.overlay0) + }; + + if is_selected || is_active { + let buf = frame.buffer_mut(); + for x in ws_area.x..ws_area.x + ws_area.width { + buf[(x, y)].set_style(row_style); + } + } + + frame.render_widget( + Paragraph::new(Line::from(vec![ + Span::styled(format!("{}", visible_idx + 1), num_style), + Span::styled(" ", row_style), + Span::styled(icon, icon_style), + ])), + Rect::new(ws_area.x, y, ws_area.width, 1), + ); + } + + if let Some(divider_y) = divider_y { + let buf = frame.buffer_mut(); + for x in ws_area.x..ws_area.x + ws_area.width { + buf[(x, divider_y)].set_symbol("─"); + buf[(x, divider_y)].set_style(Style::default().fg(p.surface_dim)); + } + } + + let detail_ws_idx = if is_navigating { + Some(app.selected) + } else { + app.active + }; + let detail_content_area = Rect::new( + detail_area.x, + detail_area.y, + detail_area.width, + detail_area.height.saturating_sub(1), + ); + if detail_content_area != Rect::default() { + if let Some(ws_idx) = detail_ws_idx { + if let Some(ws) = app.workspaces.get(ws_idx) { + for (detail_idx, detail) in ws.pane_details().iter().enumerate() { + let y = detail_content_area.y + detail_idx as u16; + if y >= detail_content_area.y + detail_content_area.height { + break; + } + let pane_num = ws + .public_pane_number(detail.pane_id) + .unwrap_or(detail_idx + 1); + let pane_style = Style::default().fg(p.overlay0); + let (icon, icon_style) = + agent_icon(detail.state, detail.seen, app.spinner_tick, p); + frame.render_widget( + Paragraph::new(Line::from(vec![ + Span::styled(format!("{pane_num}"), pane_style), + Span::styled(" ", pane_style), + Span::styled(icon, icon_style), + ])), + Rect::new(detail_content_area.x, y, detail_content_area.width, 1), + ); + } + } + } + } + + render_sidebar_toggle(app, frame, area, true, p); +} + +pub(crate) fn workspace_drop_indicator_row( + cards: &[crate::app::state::WorkspaceCardArea], + area: Rect, + insert_idx: usize, +) -> Option<u16> { + if area.height == 0 { + return None; + } + let list_bottom = area.y + area.height.saturating_sub(1); + + let first = cards.first()?; + if insert_idx == first.ws_idx { + return first.rect.y.checked_sub(1).filter(|y| *y < list_bottom); + } + + if let Some(card) = cards.iter().find(|card| card.ws_idx == insert_idx) { + return card.rect.y.checked_sub(1).filter(|y| *y < list_bottom); + } + + cards + .last() + .filter(|card| insert_idx == card.ws_idx.saturating_add(1)) + .map(|card| card.rect.y.saturating_add(card.rect.height)) + .filter(|y| *y < list_bottom) +} + +pub(super) fn render_sidebar(app: &AppState, frame: &mut Frame, area: Rect) { + let p = &app.palette; + let is_navigating = matches!(app.mode, Mode::Navigate); + let sep_style = if is_navigating { + Style::default().fg(p.accent) + } else { + Style::default().fg(p.surface_dim) + }; + + let sep_x = area.x + area.width.saturating_sub(1); + let buf = frame.buffer_mut(); + for y in area.y..area.y + area.height { + buf[(sep_x, y)].set_symbol("│"); + buf[(sep_x, y)].set_style(sep_style); + } + + let (ws_area, detail_area) = expanded_sidebar_sections(area, app.sidebar_section_split); + + render_workspace_list(app, frame, ws_area, is_navigating); + render_agent_detail(app, frame, detail_area); + render_sidebar_toggle(app, frame, area, false, p); +} + +fn render_workspace_list(app: &AppState, frame: &mut Frame, area: Rect, is_navigating: bool) { + let p = &app.palette; + let dragged_ws_idx = match app.drag.as_ref().map(|drag| &drag.target) { + Some(crate::app::state::DragTarget::WorkspaceReorder { source_ws_idx, .. }) => { + Some(*source_ws_idx) + } + _ => None, + }; + let insertion_row = match app.drag.as_ref().map(|drag| &drag.target) { + Some(crate::app::state::DragTarget::WorkspaceReorder { + insert_idx: Some(insert_idx), + .. + }) => workspace_drop_indicator_row(&app.view.workspace_card_areas, area, *insert_idx), + _ => None, + }; + + let list_bottom = area.y + area.height.saturating_sub(1); + if area.height > 0 { + frame.render_widget( + Paragraph::new(Line::from(vec![Span::styled( + " spaces", + Style::default().fg(p.overlay0).add_modifier(Modifier::BOLD), + )])), + Rect::new(area.x, area.y, area.width, 1), + ); + } + + let metrics = workspace_list_scroll_metrics(app, area); + let scrollbar_rect = workspace_list_scrollbar_rect(app, area); + let cards = &app.view.workspace_card_areas; + + for card in cards { + let i = card.ws_idx; + let ws = &app.workspaces[i]; + let row_y = card.rect.y; + let row_height = card.rect.height; + let selected = i == app.selected && is_navigating; + let is_active = Some(i) == app.active; + let is_dragged = dragged_ws_idx == Some(i); + let highlighted = selected || is_active || is_dragged; + let (agg_state, agg_seen) = ws.aggregate_state(); + + if highlighted { + let bg = if selected { + p.surface0 + } else if is_dragged { + p.surface1 + } else { + p.surface_dim + }; + let buf = frame.buffer_mut(); + for y in row_y..row_y + row_height { + if y >= list_bottom { + break; + } + for x in card.rect.x..card.rect.x + card.rect.width { + buf[(x, y)].set_style(Style::default().bg(bg)); + } + } + } + + if is_active { + let buf = frame.buffer_mut(); + for y in row_y..row_y + row_height { + if y >= list_bottom { + break; + } + buf[(card.rect.x, y)].set_symbol("▌"); + buf[(card.rect.x, y)].set_style(Style::default().fg(p.accent)); + } + } + + let name_style = if selected || is_active || is_dragged { + Style::default().fg(p.text).add_modifier(Modifier::BOLD) + } else { + Style::default().fg(p.subtext0) + }; + + let (icon, icon_style) = state_dot(agg_state, agg_seen, p); + let line1 = vec![ + Span::styled(" ", Style::default()), + Span::styled(icon, icon_style), + Span::styled(" ", Style::default()), + Span::styled(ws.display_name(), name_style), + ]; + + frame.render_widget( + Paragraph::new(Line::from(line1)), + Rect::new(card.rect.x, row_y, card.rect.width, 1), + ); + + if row_height > 1 && row_y + 1 < list_bottom { + if let Some(branch) = ws.branch() { + let upstream_label = ws.git_ahead_behind().and_then(|(ahead, behind)| { + let mut parts = Vec::new(); + if ahead > 0 { + parts.push((format!("↑{}", ahead), p.green)); + } + if behind > 0 { + parts.push((format!("↓{}", behind), p.red)); + } + (!parts.is_empty()).then_some(parts) + }); + let reserved = upstream_label + .as_ref() + .map(|parts| { + parts.iter().map(|(label, _)| label.len()).sum::<usize>() + parts.len() + }) + .unwrap_or(0); + let max_branch_len = (card.rect.width as usize).saturating_sub(5 + reserved); + let branch_display = if branch.len() > max_branch_len { + format!("{}…", &branch[..max_branch_len.saturating_sub(1)]) + } else { + branch + }; + let branch_color = if selected || is_active { + p.mauve + } else { + p.overlay0 + }; + let mut spans = vec![ + Span::styled(" ", Style::default()), + Span::styled(branch_display, Style::default().fg(branch_color)), + ]; + if let Some(parts) = upstream_label { + spans.push(Span::styled(" ", Style::default())); + for (idx, (label, color)) in parts.into_iter().enumerate() { + if idx > 0 { + spans.push(Span::styled(" ", Style::default())); + } + spans.push(Span::styled(label, Style::default().fg(color))); + } + } + frame.render_widget( + Paragraph::new(Line::from(spans)), + Rect::new(card.rect.x, row_y + 1, card.rect.width, 1), + ); + } + } + } + + if let Some(y) = insertion_row.filter(|y| *y < list_bottom) { + let indicator_right = scrollbar_rect + .map(|rect| rect.x) + .unwrap_or(area.x + area.width); + let buf = frame.buffer_mut(); + for x in area.x..indicator_right { + buf[(x, y)].set_symbol("─"); + buf[(x, y)].set_style(Style::default().fg(p.accent)); + } + } + + if let Some(track) = scrollbar_rect { + render_scrollbar(frame, metrics, track, p.surface_dim, p.overlay0, "▕"); + } + + if list_bottom > area.y { + let new_rect = app.sidebar_new_button_rect(); + frame.render_widget( + Paragraph::new(Span::styled("new", Style::default().fg(p.overlay0))), + new_rect, + ); + + let menu_rect = app.global_launcher_rect(); + let menu_line = if app.update_available.is_some() { + Line::from(vec![ + Span::styled("menu", Style::default().fg(p.overlay0)), + Span::styled( + " ●", + Style::default().fg(p.accent).add_modifier(Modifier::BOLD), + ), + ]) + } else { + Line::from(vec![Span::styled("menu", Style::default().fg(p.overlay0))]) + }; + frame.render_widget( + Paragraph::new(menu_line).alignment(Alignment::Right), + menu_rect, + ); + } +} + +fn render_agent_detail(app: &AppState, frame: &mut Frame, area: Rect) { + let p = &app.palette; + + if area.height < 3 { + return; + } + + let sep_line = "─".repeat(area.width as usize); + frame.render_widget( + Paragraph::new(Span::styled(&sep_line, Style::default().fg(p.surface_dim))), + Rect::new(area.x, area.y, area.width, 1), + ); + + frame.render_widget( + Paragraph::new(Line::from(vec![Span::styled( + " agents", + Style::default().fg(p.overlay0).add_modifier(Modifier::BOLD), + )])), + Rect::new(area.x, area.y + 1, area.width, 1), + ); + let toggle_rect = agent_panel_toggle_rect(area, app.agent_panel_scope); + if toggle_rect != Rect::default() { + frame.render_widget( + Paragraph::new(Span::styled( + agent_panel_toggle_label(app.agent_panel_scope), + Style::default().fg(p.overlay0).add_modifier(Modifier::BOLD), + )) + .alignment(Alignment::Right), + toggle_rect, + ); + } + + let details = agent_panel_entries(app); + let metrics = agent_panel_scroll_metrics(app, area); + let scrollbar_rect = agent_panel_scrollbar_rect(app, area); + let body = agent_panel_body_rect(area, should_show_scrollbar(metrics)); + if body == Rect::default() { + return; + } + + let mut row_y = body.y; + let body_bottom = body.y + body.height; + for detail in details.iter().skip(app.agent_panel_scroll) { + if row_y.saturating_add(1) >= body_bottom { + break; + } + + let (icon, icon_style) = agent_icon(detail.state, detail.seen, app.spinner_tick, p); + let label_color = state_label_color(detail.state, detail.seen, p); + let label = state_label(detail.state, detail.seen); + + let name_style = Style::default().fg(p.subtext0).add_modifier(Modifier::BOLD); + let status_style = Style::default().fg(label_color).add_modifier(Modifier::DIM); + let agent_style = Style::default().fg(p.overlay0).add_modifier(Modifier::DIM); + + let primary_label = + format_agent_panel_primary_label(detail, body.width.saturating_sub(3) as usize); + let name_line = Line::from(vec![ + Span::styled(" ", Style::default()), + Span::styled(icon, icon_style), + Span::styled(" ", Style::default()), + Span::styled(primary_label, name_style), + ]); + frame.render_widget( + Paragraph::new(name_line), + Rect::new(body.x, row_y, body.width, 1), + ); + row_y += 1; + + let mut status_spans = vec![ + Span::styled(" ", Style::default()), + Span::styled(label, status_style), + ]; + if let Some(agent_label) = &detail.agent_label { + status_spans.push(Span::styled(" · ", agent_style)); + status_spans.push(Span::styled(agent_label, agent_style)); + } + frame.render_widget( + Paragraph::new(Line::from(status_spans)), + Rect::new(body.x, row_y, body.width, 1), + ); + row_y += 1; + + if row_y < body_bottom { + row_y += 1; + } + } + + if let Some(track) = scrollbar_rect { + render_scrollbar(frame, metrics, track, p.surface_dim, p.overlay0, "▕"); + } +} + +pub(crate) fn collapsed_sidebar_toggle_rect(area: Rect) -> Rect { + let bottom_y = area.y + area.height.saturating_sub(1); + let content_w = area.width.saturating_sub(1); + if content_w == 0 || area.height == 0 { + return Rect::default(); + } + let x = area.x + content_w / 2; + Rect::new(x, bottom_y, 1, 1) +} + +fn render_sidebar_toggle( + app: &AppState, + frame: &mut Frame, + area: Rect, + collapsed: bool, + p: &Palette, +) { + if !collapsed { + return; + } + let toggle_area = collapsed_sidebar_toggle_rect(area); + if toggle_area == Rect::default() { + return; + } + let icon_style = if app.update_available.is_some() { + Style::default().fg(p.accent).add_modifier(Modifier::BOLD) + } else { + Style::default().fg(p.overlay0) + }; + frame.render_widget(Paragraph::new(Span::styled("»", icon_style)), toggle_area); +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::{detect::Agent, workspace::Workspace}; + + #[test] + fn all_workspaces_agent_panel_entries_use_workspace_and_optional_tab_labels() { + let mut app = crate::app::state::AppState::test_new(); + let mut first = Workspace::test_new("one"); + let first_pane = first.tabs[0].root_pane; + first.tabs[0] + .panes + .get_mut(&first_pane) + .unwrap() + .detected_agent = Some(Agent::Pi); + + let mut second = Workspace::test_new("two"); + let second_tab = second.test_add_tab(Some("logs")); + let second_pane = second.tabs[second_tab].root_pane; + second.tabs[second_tab] + .panes + .get_mut(&second_pane) + .unwrap() + .detected_agent = Some(Agent::Claude); + + app.workspaces = vec![first, second]; + app.active = Some(0); + app.selected = 0; + app.agent_panel_scope = AgentPanelScope::AllWorkspaces; + + let entries = agent_panel_entries(&app); + assert_eq!(entries[0].primary_label, "one"); + assert!(entries[0].primary_tab_label.is_none()); + assert_eq!(entries[0].agent_label.as_deref(), Some("pi")); + assert_eq!(entries[1].primary_label, "two"); + assert_eq!(entries[1].primary_tab_label.as_deref(), Some("logs")); + assert_eq!(entries[1].agent_label.as_deref(), Some("claude")); + } + + #[test] + fn all_workspaces_primary_label_truncates_workspace_and_tab() { + let entry = AgentPanelEntry { + ws_idx: 0, + tab_idx: 0, + pane_id: crate::layout::PaneId::from_raw(1), + primary_label: "agent-browser".into(), + primary_tab_label: Some("test-escalation".into()), + agent_label: Some("claude".into()), + state: AgentState::Idle, + seen: true, + }; + + let label = format_agent_panel_primary_label(&entry, 18); + + assert_eq!(label, "agent-bro… · test…"); + } + + #[test] + fn expanded_sidebar_sections_handle_tiny_heights() { + let (ws_area, detail_area) = expanded_sidebar_sections(Rect::new(0, 0, 20, 5), 0.9); + + assert_eq!(ws_area, Rect::new(0, 0, 19, 3)); + assert_eq!(detail_area, Rect::new(0, 3, 19, 2)); + } + + #[test] + fn sidebar_section_divider_is_hidden_for_tiny_heights() { + let divider = sidebar_section_divider_rect(Rect::new(0, 0, 20, 5), 0.5); + + assert_eq!(divider, Rect::default()); + } +} diff --git a/src/ui/status.rs b/src/ui/status.rs new file mode 100644 index 00000000..2eece8a0 --- /dev/null +++ b/src/ui/status.rs @@ -0,0 +1,135 @@ +use ratatui::{ + layout::{Constraint, Layout, Rect}, + style::{Color, Modifier, Style}, + text::{Line, Span}, + widgets::{Block, Borders, Clear, Paragraph}, + Frame, +}; + +use super::widgets::panel_contrast_fg; +use crate::{ + app::state::{Palette, ToastKind, ToastNotification}, + detect::AgentState, +}; + +pub(super) fn render_toast_notification( + frame: &mut Frame, + area: Rect, + toast: &ToastNotification, + offset_for_warning: bool, + p: &Palette, +) { + let dot_color = match toast.kind { + ToastKind::NeedsAttention => p.red, + ToastKind::Finished => p.blue, + ToastKind::UpdateInstalled => p.accent, + }; + let content_width = (toast.title.len().max(toast.context.len()) as u16) + 4; + let width = content_width.saturating_add(2).min(area.width); + let height = 4u16.min(area.height); + let x = area.x + area.width.saturating_sub(width); + let y = area.y + + area + .height + .saturating_sub(height + if offset_for_warning { 1 } else { 0 }); + let toast_area = Rect::new(x, y, width, height); + + frame.render_widget(Clear, toast_area); + let block = Block::default() + .borders(Borders::ALL) + .border_style(Style::default().fg(p.overlay0)) + .style(Style::default().bg(p.panel_bg)); + let inner = block.inner(toast_area); + frame.render_widget(block, toast_area); + + if inner.height < 2 { + return; + } + + let [title_row, context_row] = + Layout::vertical([Constraint::Length(1), Constraint::Length(1)]).areas(inner); + + let title = Line::from(vec![ + Span::styled("●", Style::default().fg(dot_color)), + Span::raw(" "), + Span::styled( + &toast.title, + Style::default().fg(p.text).add_modifier(Modifier::BOLD), + ), + ]); + let context = Line::from(vec![ + Span::styled(" ", Style::default().fg(p.overlay0)), + Span::styled(&toast.context, Style::default().fg(p.overlay0)), + ]); + + frame.render_widget(Paragraph::new(title), title_row); + frame.render_widget(Paragraph::new(context), context_row); +} + +pub(super) fn render_config_diagnostic(frame: &mut Frame, area: Rect, message: &str, p: &Palette) { + let text = format!(" config warning: {message} "); + let width = text.len() as u16 + 2; + let notif_area = Rect::new( + area.x + area.width.saturating_sub(width.min(area.width)), + area.y, + width.min(area.width), + 1, + ); + + frame.render_widget(Clear, notif_area); + frame.render_widget( + Paragraph::new(Span::styled( + text, + Style::default() + .fg(panel_contrast_fg(p)) + .bg(p.yellow) + .add_modifier(Modifier::BOLD), + )), + notif_area, + ); +} + +pub(super) fn state_dot(state: AgentState, seen: bool, p: &Palette) -> (&'static str, Style) { + match (state, seen) { + (AgentState::Blocked, _) => ("●", Style::default().fg(p.red)), + (AgentState::Working, _) => ("●", Style::default().fg(p.yellow)), + (AgentState::Idle, false) => ("●", Style::default().fg(p.teal)), + (AgentState::Idle, true) => ("○", Style::default().fg(p.green)), + (AgentState::Unknown, _) => ("·", Style::default().fg(p.overlay0)), + } +} + +pub(super) fn agent_icon( + state: AgentState, + seen: bool, + tick: u32, + p: &Palette, +) -> (&'static str, Style) { + match (state, seen) { + (AgentState::Blocked, _) => ("◉", Style::default().fg(p.red)), + (AgentState::Working, _) => (super::spinner_frame(tick), Style::default().fg(p.yellow)), + (AgentState::Idle, false) => ("●", Style::default().fg(p.teal)), + (AgentState::Idle, true) => ("✓", Style::default().fg(p.green)), + (AgentState::Unknown, _) => ("○", Style::default().fg(p.overlay0)), + } +} + +pub(super) fn state_label(state: AgentState, seen: bool) -> &'static str { + match (state, seen) { + (AgentState::Blocked, _) => "blocked", + (AgentState::Working, _) => "working", + (AgentState::Idle, false) => "done", + (AgentState::Idle, true) => "idle", + (AgentState::Unknown, _) => "idle", + } +} + +pub(super) fn state_label_color(state: AgentState, seen: bool, p: &Palette) -> Color { + match (state, seen) { + (AgentState::Blocked, _) => p.red, + (AgentState::Working, _) => p.yellow, + (AgentState::Idle, false) => p.teal, + (AgentState::Idle, true) => p.green, + (AgentState::Unknown, _) => p.overlay0, + } +} diff --git a/src/ui/tabs.rs b/src/ui/tabs.rs new file mode 100644 index 00000000..400ee65f --- /dev/null +++ b/src/ui/tabs.rs @@ -0,0 +1,356 @@ +use ratatui::{ + layout::Rect, + style::{Modifier, Style}, + widgets::Paragraph, + Frame, +}; + +use super::widgets::panel_contrast_fg; +use crate::app::AppState; + +const MIN_TAB_WIDTH: u16 = 8; +const NEW_TAB_WIDTH: u16 = 3; +const TAB_SCROLL_BUTTON_WIDTH: u16 = 3; + +#[derive(Debug, Clone, Default)] +pub(crate) struct TabBarView { + pub scroll: usize, + pub tab_hit_areas: Vec<Rect>, + pub scroll_left_hit_area: Rect, + pub scroll_right_hit_area: Rect, + pub new_tab_hit_area: Rect, +} + +fn tab_width(tab: &crate::workspace::Tab) -> u16 { + (tab.display_name().chars().count() as u16 + 4).max(MIN_TAB_WIDTH) +} + +fn layout_tab_hit_areas(ws: &crate::workspace::Workspace, area: Rect, scroll: usize) -> Vec<Rect> { + let mut rects = vec![Rect::default(); ws.tabs.len()]; + if area.width == 0 || area.height == 0 { + return rects; + } + + let mut x = area.x; + let right = area.x + area.width; + for idx in scroll..ws.tabs.len() { + if x >= right { + break; + } + let desired = tab_width(&ws.tabs[idx]); + let remaining = right.saturating_sub(x); + let width = desired.min(remaining).max(1); + rects[idx] = Rect::new(x, area.y, width, 1); + x = x.saturating_add(width + 1); + } + rects +} + +fn centered_tab_scroll(ws: &crate::workspace::Workspace, area: Rect) -> usize { + let mut best_scroll = ws.active_tab; + let mut best_distance = u16::MAX; + let viewport_center = area.x.saturating_mul(2).saturating_add(area.width); + + for scroll in 0..=ws.active_tab { + let rects = layout_tab_hit_areas(ws, area, scroll); + let Some(active_rect) = rects.get(ws.active_tab).copied() else { + continue; + }; + if active_rect.width == 0 { + continue; + } + + let active_center = active_rect + .x + .saturating_mul(2) + .saturating_add(active_rect.width); + let distance = active_center.abs_diff(viewport_center); + if distance <= best_distance { + best_distance = distance; + best_scroll = scroll; + } + } + + best_scroll +} + +fn trailing_tab_controls_x(tab_hit_areas: &[Rect], fallback_x: u16) -> u16 { + tab_hit_areas + .iter() + .rev() + .find(|rect| rect.width > 0) + .map(|rect| rect.x + rect.width) + .unwrap_or(fallback_x) +} + +fn max_tab_scroll(ws: &crate::workspace::Workspace, area: Rect) -> usize { + (0..ws.tabs.len()) + .find(|&scroll| { + layout_tab_hit_areas(ws, area, scroll) + .last() + .is_some_and(|rect| rect.width > 0) + }) + .unwrap_or(0) +} + +pub(crate) fn compute_tab_bar_view( + ws: &crate::workspace::Workspace, + area: Rect, + current_scroll: usize, + follow_active: bool, +) -> TabBarView { + if area.width == 0 || area.height == 0 { + return TabBarView::default(); + } + + let area_right = area.x + area.width; + let all_tabs_area = Rect::new( + area.x, + area.y, + area.width.saturating_sub(NEW_TAB_WIDTH), + area.height, + ); + let all_tabs = layout_tab_hit_areas(ws, all_tabs_area, 0); + let overflow = all_tabs.iter().any(|rect| rect.width == 0); + if !overflow { + let new_tab_x = trailing_tab_controls_x(&all_tabs, area.x); + let new_tab_hit_area = Rect::new( + new_tab_x, + area.y, + area_right.saturating_sub(new_tab_x).min(NEW_TAB_WIDTH), + 1, + ); + return TabBarView { + scroll: 0, + tab_hit_areas: all_tabs, + scroll_left_hit_area: Rect::default(), + scroll_right_hit_area: Rect::default(), + new_tab_hit_area, + }; + } + + let left_hit_area = Rect::new(area.x, area.y, TAB_SCROLL_BUTTON_WIDTH.min(area.width), 1); + let tab_area_x = left_hit_area.x + left_hit_area.width; + let reserved_trailing_width = NEW_TAB_WIDTH.saturating_add(TAB_SCROLL_BUTTON_WIDTH); + let tab_area_right = area_right.saturating_sub(reserved_trailing_width); + let tab_area = Rect::new( + tab_area_x, + area.y, + tab_area_right.saturating_sub(tab_area_x), + area.height, + ); + + let max_scroll = max_tab_scroll(ws, tab_area); + let scroll = if follow_active { + centered_tab_scroll(ws, tab_area).min(max_scroll) + } else { + current_scroll.min(max_scroll) + }; + let tab_hit_areas = layout_tab_hit_areas(ws, tab_area, scroll); + let trailing_x = trailing_tab_controls_x(&tab_hit_areas, tab_area_x).min(tab_area_right); + let right_hit_area = Rect::new( + trailing_x, + area.y, + area_right + .saturating_sub(trailing_x) + .min(TAB_SCROLL_BUTTON_WIDTH), + 1, + ); + let new_tab_x = right_hit_area.x + right_hit_area.width; + let new_tab_hit_area = Rect::new( + new_tab_x, + area.y, + area_right.saturating_sub(new_tab_x).min(NEW_TAB_WIDTH), + 1, + ); + + TabBarView { + scroll, + tab_hit_areas, + scroll_left_hit_area: left_hit_area, + scroll_right_hit_area: right_hit_area, + new_tab_hit_area, + } +} + +fn tab_drop_indicator_x( + app: &AppState, + ws: &crate::workspace::Workspace, + insert_idx: usize, +) -> Option<u16> { + let visible_tabs = app + .view + .tab_hit_areas + .iter() + .enumerate() + .filter(|(_, rect)| rect.width > 0); + let first_visible = visible_tabs.clone().next()?; + let last_visible = visible_tabs.last().unwrap_or(first_visible); + + if insert_idx == 0 { + return Some(if first_visible.0 == 0 { + first_visible.1.x + } else { + app.view.tab_scroll_left_hit_area.x + app.view.tab_scroll_left_hit_area.width + }); + } + + if let Some((_, rect)) = app + .view + .tab_hit_areas + .iter() + .enumerate() + .find(|(idx, rect)| *idx == insert_idx && rect.width > 0) + { + return Some(rect.x.saturating_sub(1)); + } + + if insert_idx >= ws.tabs.len() { + return Some(if last_visible.0 + 1 >= ws.tabs.len() { + last_visible.1.x + last_visible.1.width + } else { + app.view.tab_scroll_right_hit_area.x.saturating_sub(1) + }); + } + + None +} + +pub(super) fn render_tab_bar(app: &AppState, frame: &mut Frame, area: Rect) { + if area.width == 0 || area.height == 0 { + return; + } + let Some(active_ws_idx) = app.active else { + return; + }; + let Some(ws) = app.workspaces.get(active_ws_idx) else { + return; + }; + + let p = &app.palette; + + frame.render_widget( + Paragraph::new(" ".repeat(area.width as usize)).style(Style::default().bg(p.panel_bg)), + area, + ); + + let first_visible_idx = app + .view + .tab_hit_areas + .iter() + .enumerate() + .find(|(_, rect)| rect.width > 0) + .map(|(idx, _)| idx); + let last_visible_idx = app + .view + .tab_hit_areas + .iter() + .enumerate() + .rev() + .find(|(_, rect)| rect.width > 0) + .map(|(idx, _)| idx); + let can_scroll_left = app.view.tab_scroll_left_hit_area.width > 0 && app.tab_scroll > 0; + let can_scroll_right = app.view.tab_scroll_right_hit_area.width > 0 + && last_visible_idx.is_some_and(|idx| idx + 1 < ws.tabs.len()); + + if app.view.tab_scroll_left_hit_area.width > 0 { + let style = if can_scroll_left { + Style::default().fg(p.overlay1).bg(p.surface0) + } else { + Style::default() + .fg(p.overlay0) + .bg(p.surface0) + .add_modifier(Modifier::DIM) + }; + frame.render_widget( + Paragraph::new(" < ").style(style), + app.view.tab_scroll_left_hit_area, + ); + } + + if app.view.tab_scroll_right_hit_area.width > 0 { + let style = if can_scroll_right { + Style::default().fg(p.overlay1).bg(p.surface0) + } else { + Style::default() + .fg(p.overlay0) + .bg(p.surface0) + .add_modifier(Modifier::DIM) + }; + frame.render_widget( + Paragraph::new(" > ").style(style), + app.view.tab_scroll_right_hit_area, + ); + } + + for (idx, tab) in ws.tabs.iter().enumerate() { + let Some(rect) = app.view.tab_hit_areas.get(idx).copied() else { + break; + }; + if rect.width == 0 { + continue; + } + let active = idx == ws.active_tab; + let style = if active { + let base = Style::default().fg(panel_contrast_fg(p)).bg(p.accent); + if tab.is_auto_named() { + base.add_modifier(Modifier::DIM) + } else { + base.add_modifier(Modifier::BOLD) + } + } else if tab.is_auto_named() { + Style::default() + .fg(p.overlay0) + .bg(p.surface0) + .add_modifier(Modifier::DIM) + } else { + Style::default().fg(p.overlay1).bg(p.surface0) + }; + let width = rect.width as usize; + let name = tab.display_name(); + let text = format!(" {:width$}", name, width = width.saturating_sub(1)); + frame.render_widget(Paragraph::new(text).style(style), rect); + } + + if let Some(crate::app::state::DragState { + target: + crate::app::state::DragTarget::TabReorder { + ws_idx, + insert_idx: Some(insert_idx), + .. + }, + }) = &app.drag + { + if *ws_idx == active_ws_idx { + if let Some(x) = tab_drop_indicator_x(app, ws, *insert_idx) { + frame.buffer_mut()[(x.min(area.x + area.width.saturating_sub(1)), area.y)] + .set_symbol("│") + .set_style(Style::default().fg(p.accent)); + } + } + } + + if app.view.new_tab_hit_area.width > 0 { + frame.render_widget( + Paragraph::new(" + ").style(Style::default().fg(p.overlay1)), + app.view.new_tab_hit_area, + ); + } + + if first_visible_idx.is_some_and(|idx| idx > 0) { + let x = app.view.tab_scroll_left_hit_area.x + app.view.tab_scroll_left_hit_area.width; + if x < area.x + area.width { + frame.buffer_mut()[(x, area.y)] + .set_symbol("…") + .set_style(Style::default().fg(p.overlay0)); + } + } + if last_visible_idx.is_some_and(|idx| idx + 1 < ws.tabs.len()) { + let x = app.view.tab_scroll_right_hit_area.x.saturating_sub(1); + if x >= area.x && x < area.x + area.width { + frame.buffer_mut()[(x, area.y)] + .set_symbol("…") + .set_style(Style::default().fg(p.overlay0)); + } + } +} diff --git a/src/ui/widgets.rs b/src/ui/widgets.rs new file mode 100644 index 00000000..354b7884 --- /dev/null +++ b/src/ui/widgets.rs @@ -0,0 +1,209 @@ +use ratatui::{ + layout::{Alignment, Constraint, Layout, Rect}, + style::{Color, Modifier, Style}, + text::{Line, Span}, + widgets::{Block, Borders, Clear, Paragraph}, + Frame, +}; + +use crate::app::state::Palette; + +pub(super) fn render_panel_shell( + frame: &mut Frame, + area: Rect, + border_color: Color, + bg: Color, +) -> Option<Rect> { + if area.width < 2 || area.height < 2 { + return None; + } + + let block = Block::default() + .borders(Borders::ALL) + .border_style(Style::default().fg(border_color)) + .border_set(ratatui::symbols::border::PLAIN) + .style(Style::default().bg(bg)); + let inner = block.inner(area); + frame.render_widget(Clear, area); + frame.render_widget(block, area); + Some(inner) +} + +pub(super) fn panel_contrast_fg(p: &Palette) -> Color { + match p.panel_bg { + Color::Reset => p.surface_dim, + color => color, + } +} + +pub(crate) fn centered_popup_rect(area: Rect, popup_w: u16, popup_h: u16) -> Option<Rect> { + let popup_w = popup_w.min(area.width.saturating_sub(4)); + let popup_h = popup_h.min(area.height.saturating_sub(2)); + if popup_w < 4 || popup_h < 4 { + return None; + } + + let popup_x = area.x + (area.width.saturating_sub(popup_w)) / 2; + let popup_y = area.y + (area.height.saturating_sub(popup_h)) / 2; + Some(Rect::new(popup_x, popup_y, popup_w, popup_h)) +} + +pub(super) fn render_modal_shell( + frame: &mut Frame, + area: Rect, + popup_w: u16, + popup_h: u16, + p: &Palette, +) -> Option<Rect> { + let popup = centered_popup_rect(area, popup_w, popup_h)?; + render_panel_shell(frame, popup, p.accent, p.panel_bg) +} + +pub(super) fn render_modal_header(frame: &mut Frame, area: Rect, title: &str, p: &Palette) { + let line = Line::from(vec![ + Span::styled( + title, + Style::default().fg(p.text).add_modifier(Modifier::BOLD), + ), + Span::raw(" "), + Span::styled("⬆", Style::default().fg(p.accent)), + ]); + frame.render_widget(Paragraph::new(line), area); +} + +#[derive(Debug, Clone, Copy)] +pub(crate) struct ModalStackAreas { + pub header: Rect, + pub content: Rect, + pub footer: Option<Rect>, + pub actions: Option<Rect>, +} + +pub(crate) fn modal_stack_areas( + inner: Rect, + header_height: u16, + footer_height: u16, + actions_height: u16, + gap: u16, +) -> ModalStackAreas { + #[derive(Clone, Copy)] + enum Slot { + Header, + Content, + Footer, + Actions, + } + + let mut constraints = Vec::new(); + let mut slots = Vec::new(); + let mut push = |slot: Slot, constraint: Constraint| { + if !slots.is_empty() { + constraints.push(Constraint::Length(gap)); + } + constraints.push(constraint); + slots.push(slot); + }; + + push(Slot::Header, Constraint::Length(header_height)); + push(Slot::Content, Constraint::Min(0)); + if footer_height > 0 { + push(Slot::Footer, Constraint::Length(footer_height)); + } + if actions_height > 0 { + push(Slot::Actions, Constraint::Length(actions_height)); + } + + let areas = Layout::vertical(constraints).split(inner); + let mut header = Rect::default(); + let mut content = Rect::default(); + let mut footer = None; + let mut actions = None; + + for (slot, area) in slots.into_iter().zip(areas.iter().step_by(2).copied()) { + match slot { + Slot::Header => header = area, + Slot::Content => content = area, + Slot::Footer => footer = Some(area), + Slot::Actions => actions = Some(area), + } + } + + ModalStackAreas { + header, + content, + footer, + actions, + } +} + +pub(crate) fn action_button_text(hint: Option<&str>, label: &str) -> String { + match hint { + Some(hint) => format!(" {hint} {label} "), + None => format!(" {label} "), + } +} + +pub(crate) fn action_button_width(hint: Option<&str>, label: &str) -> u16 { + action_button_text(hint, label).chars().count() as u16 +} + +pub(crate) struct ActionButtonSpec<'a> { + pub hint: Option<&'a str>, + pub label: &'a str, +} + +pub(crate) fn action_button_row_rects( + area: Rect, + buttons: &[ActionButtonSpec<'_>], + gap: u16, + row_offset: u16, +) -> Vec<Rect> { + let widths: Vec<u16> = buttons + .iter() + .map(|button| action_button_width(button.hint, button.label)) + .collect(); + centered_button_row(area, &widths, gap, row_offset) +} + +pub(super) fn render_action_button( + frame: &mut Frame, + rect: Rect, + hint: Option<&str>, + label: &str, + style: Style, +) { + frame.render_widget( + Paragraph::new(action_button_text(hint, label)) + .style(style) + .alignment(Alignment::Center), + rect, + ); +} + +pub(super) fn centered_button_row( + inner: Rect, + widths: &[u16], + gap: u16, + row_offset: u16, +) -> Vec<Rect> { + let total_w = widths + .iter() + .copied() + .sum::<u16>() + .saturating_add(gap.saturating_mul(widths.len().saturating_sub(1) as u16)); + let mut x = inner.x + inner.width.saturating_sub(total_w) / 2; + let y = inner.y + row_offset.min(inner.height.saturating_sub(1)); + widths + .iter() + .map(|w| { + let rect = Rect::new( + x, + y, + (*w).min(inner.width.saturating_sub(x.saturating_sub(inner.x))), + 1, + ); + x = x.saturating_add(*w).saturating_add(gap); + rect + }) + .collect() +} diff --git a/src/update.rs b/src/update.rs index af446fed..ed592ac7 100644 --- a/src/update.rs +++ b/src/update.rs @@ -9,7 +9,11 @@ use std::collections::BTreeMap; use std::env; use std::fs; +use std::io::{self, BufRead, BufReader, IsTerminal, Write}; +use std::os::unix::net::UnixStream; +use std::path::Path; use std::process::Command; +use std::time::{Duration, Instant}; use serde::Deserialize; @@ -18,6 +22,9 @@ const CURRENT_VERSION: &str = env!("CARGO_PKG_VERSION"); const FAKE_UPDATE_VERSION_ENV: &str = "HERDR_FAKE_UPDATE_VERSION"; const FAKE_UPDATE_NOTES_VERSION_ENV: &str = "HERDR_FAKE_UPDATE_NOTES_VERSION"; const DEFAULT_FAKE_UPDATE_NOTES_VERSION: &str = "0.3.0"; +const SERVER_STOP_RESPONSE_TIMEOUT: Duration = Duration::from_secs(5); +const SERVER_SHUTDOWN_CONFIRM_TIMEOUT: Duration = Duration::from_secs(5); +const SERVER_SHUTDOWN_POLL_INTERVAL: Duration = Duration::from_millis(100); fn fake_release_notes_body(version: &str) -> String { let notes_version = env::var(FAKE_UPDATE_NOTES_VERSION_ENV) @@ -213,11 +220,174 @@ fn download_and_install(release: &ReleaseInfo) -> Result<(), String> { } // --------------------------------------------------------------------------- +// Upgrade flow helpers +// --------------------------------------------------------------------------- + +fn running_inside_herdr_env(herdr_env: Option<&str>) -> bool { + herdr_env == Some(crate::HERDR_ENV_VALUE) +} + +fn running_inside_herdr() -> bool { + running_inside_herdr_env(env::var(crate::HERDR_ENV_VAR).ok().as_deref()) +} + +fn api_server_is_running_at(socket_path: &Path) -> bool { + if !socket_path.exists() { + return false; + } + + UnixStream::connect(socket_path).is_ok() +} + +fn api_server_is_running() -> bool { + api_server_is_running_at(&crate::api::socket_path()) +} + +fn stop_server_via_api_at(socket_path: &Path, timeout: Duration) -> Result<(), String> { + use crate::api::schema::{EmptyParams, Method, Request}; + + let request = Request { + id: "update:server:stop".into(), + method: Method::ServerStop(EmptyParams::default()), + }; + + let mut stream = UnixStream::connect(socket_path) + .map_err(|e| format!("failed to connect to running server: {e}"))?; + stream + .set_write_timeout(Some(timeout)) + .map_err(|e| format!("failed to set server stop write timeout: {e}"))?; + stream + .set_read_timeout(Some(timeout)) + .map_err(|e| format!("failed to set server stop read timeout: {e}"))?; + stream + .write_all( + serde_json::to_string(&request) + .map_err(|e| e.to_string())? + .as_bytes(), + ) + .map_err(|e| format!("failed to send server stop request: {e}"))?; + stream + .write_all(b"\n") + .map_err(|e| format!("failed to finish server stop request: {e}"))?; + stream + .flush() + .map_err(|e| format!("failed to flush server stop request: {e}"))?; + + let mut reader = BufReader::new(stream); + let mut line = String::new(); + let read = reader + .read_line(&mut line) + .map_err(|e| format!("failed to read server stop response: {e}"))?; + if read == 0 || line.trim().is_empty() { + return Err("empty server stop response".into()); + } + let response: serde_json::Value = + serde_json::from_str(&line).map_err(|e| format!("invalid server response: {e}"))?; + if let Some(error) = response.get("error") { + return Err(format!("server stop failed: {error}")); + } + + Ok(()) +} + +fn stop_server_via_api() -> Result<(), String> { + stop_server_via_api_at(&crate::api::socket_path(), SERVER_STOP_RESPONSE_TIMEOUT) +} + +fn server_shutdown_confirmed_at(socket_path: &Path) -> Result<bool, String> { + if !socket_path.exists() { + return Ok(true); + } + + match UnixStream::connect(socket_path) { + Ok(_) => Ok(false), + Err(err) + if matches!( + err.kind(), + io::ErrorKind::ConnectionRefused + | io::ErrorKind::NotFound + | io::ErrorKind::TimedOut + ) => + { + Ok(true) + } + Err(err) => Err(format!( + "failed to confirm whether the old server stopped on {}: {err}", + socket_path.display() + )), + } +} + +fn wait_for_server_shutdown_at(socket_path: &Path, timeout: Duration) -> Result<(), String> { + let deadline = Instant::now() + timeout; + loop { + if server_shutdown_confirmed_at(socket_path)? { + return Ok(()); + } + if Instant::now() >= deadline { + return Err(format!( + "shutdown was requested, but the old server is still responding on {} after {} seconds", + socket_path.display(), + timeout.as_secs() + )); + } + std::thread::sleep(SERVER_SHUTDOWN_POLL_INTERVAL); + } +} + +fn wait_for_server_shutdown(timeout: Duration) -> Result<(), String> { + wait_for_server_shutdown_at(&crate::api::socket_path(), timeout) +} + +fn parse_stop_server_response(input: &str) -> Option<bool> { + let trimmed = input.trim().to_ascii_lowercase(); + match trimmed.as_str() { + "" | "y" | "yes" => Some(true), + "n" | "no" => Some(false), + _ => None, + } +} + +fn prompt_to_stop_running_server() -> Result<bool, String> { + if !io::stdin().is_terminal() { + eprintln!( + "a herdr server is still running on the old version. rerun `herdr update` interactively or stop it later with `herdr server stop`." + ); + return Ok(false); + } + + loop { + eprint!("a herdr server is still running on the old version. stop it now to apply the update? [Y/n] "); + io::stderr() + .flush() + .map_err(|e| format!("failed to flush prompt: {e}"))?; + + let mut input = String::new(); + let read = io::stdin() + .read_line(&mut input) + .map_err(|e| format!("failed to read prompt response: {e}"))?; + if read == 0 { + return Ok(false); + } + + if let Some(answer) = parse_stop_server_response(&input) { + return Ok(answer); + } + + eprintln!("please answer y or n"); + } +} + +// --------------------------------------------------------------------------- // Public API // --------------------------------------------------------------------------- /// Manual self-update command (`herdr update`). pub fn self_update() -> Result<Version, String> { + if running_inside_herdr() { + return Err("run `herdr update` outside herdr after detaching from the session".into()); + } + eprintln!("checking for updates..."); let current = Version::current(); @@ -239,6 +409,28 @@ pub fn self_update() -> Result<Version, String> { download_and_install(&release)?; eprintln!("updated to v{}", release.version); + if api_server_is_running() { + if prompt_to_stop_running_server()? { + match stop_server_via_api() { + Ok(()) => match wait_for_server_shutdown(SERVER_SHUTDOWN_CONFIRM_TIMEOUT) { + Ok(()) => eprintln!("stopped the running herdr server. run herdr again."), + Err(err) => eprintln!( + "update installed, but {err}\ntry `herdr server stop` from another shell, then run `herdr` again." + ), + }, + Err(err) => eprintln!( + "update installed, but failed to stop the running server: {err}\ntry `herdr server stop` from another shell, then run `herdr` again." + ), + } + } else { + eprintln!( + "update installed, but the old server is still running. restart it later to use the new version." + ); + } + } else { + eprintln!("update installed. run herdr again."); + } + Ok(release.version) } @@ -283,7 +475,7 @@ pub fn auto_update(events: tokio::sync::mpsc::Sender<crate::events::AppEvent>) { } tracing::info!( - "auto-update check: v{} available, waiting for manual install", + "auto-update check: v{} available, waiting for explicit install", release.version ); @@ -324,6 +516,42 @@ fn platform_target() -> (&'static str, &'static str) { #[cfg(test)] mod tests { use super::*; + use std::os::unix::net::UnixListener; + use std::sync::{ + atomic::{AtomicBool, Ordering}, + Arc, + }; + use std::thread; + + fn unique_test_socket_path(name: &str) -> std::path::PathBuf { + let nanos = std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .unwrap() + .as_nanos(); + std::env::temp_dir().join(format!( + "herdr-update-{name}-{}-{nanos}.sock", + std::process::id() + )) + } + + fn spawn_accept_loop(path: &Path) -> (Arc<AtomicBool>, thread::JoinHandle<()>) { + let listener = UnixListener::bind(path).unwrap(); + listener.set_nonblocking(true).unwrap(); + let running = Arc::new(AtomicBool::new(true)); + let running_thread = Arc::clone(&running); + let handle = thread::spawn(move || { + while running_thread.load(Ordering::Relaxed) { + match listener.accept() { + Ok((_stream, _)) => {} + Err(err) if err.kind() == io::ErrorKind::WouldBlock => { + thread::sleep(Duration::from_millis(10)); + } + Err(_) => break, + } + } + }); + (running, handle) + } #[test] fn parse_version_basic() { @@ -378,6 +606,105 @@ mod tests { } #[test] + fn running_inside_herdr_env_requires_marker() { + assert!(running_inside_herdr_env(Some(crate::HERDR_ENV_VALUE))); + assert!(!running_inside_herdr_env(None)); + assert!(!running_inside_herdr_env(Some("0"))); + } + + #[test] + fn parse_stop_server_response_defaults_yes_for_blank() { + assert_eq!(parse_stop_server_response(""), Some(true)); + assert_eq!(parse_stop_server_response("\n"), Some(true)); + assert_eq!(parse_stop_server_response("y"), Some(true)); + assert_eq!(parse_stop_server_response("yes"), Some(true)); + assert_eq!(parse_stop_server_response("n"), Some(false)); + assert_eq!(parse_stop_server_response("no"), Some(false)); + assert_eq!(parse_stop_server_response("later"), None); + } + + #[test] + fn stop_server_via_api_accepts_success_response() { + let socket_path = unique_test_socket_path("stop-ok"); + let listener = UnixListener::bind(&socket_path).unwrap(); + let handle = thread::spawn(move || { + let (mut stream, _) = listener.accept().unwrap(); + let mut request = String::new(); + BufReader::new(stream.try_clone().unwrap()) + .read_line(&mut request) + .unwrap(); + assert!( + request.contains("server.stop") + || request.contains("ServerStop") + || request.contains("server_stop") + || request.contains("ServerStop") + ); + stream + .write_all(b"{\"id\":\"update:server:stop\",\"result\":{}}\n") + .unwrap(); + stream.flush().unwrap(); + }); + + let result = stop_server_via_api_at(&socket_path, Duration::from_millis(200)); + let _ = handle.join(); + let _ = fs::remove_file(&socket_path); + assert!( + result.is_ok(), + "expected stop request to succeed: {result:?}" + ); + } + + #[test] + fn stop_server_via_api_times_out_when_server_never_replies() { + let socket_path = unique_test_socket_path("stop-timeout"); + let listener = UnixListener::bind(&socket_path).unwrap(); + let handle = thread::spawn(move || { + let (_stream, _) = listener.accept().unwrap(); + thread::sleep(Duration::from_millis(200)); + }); + + let err = stop_server_via_api_at(&socket_path, Duration::from_millis(50)).unwrap_err(); + let _ = handle.join(); + let _ = fs::remove_file(&socket_path); + assert!( + err.contains("failed to read server stop response") + || err.contains("empty server stop response"), + "unexpected error: {err}" + ); + } + + #[test] + fn wait_for_server_shutdown_succeeds_once_socket_stops_accepting() { + let socket_path = unique_test_socket_path("shutdown-ok"); + let (running, handle) = spawn_accept_loop(&socket_path); + let running_for_stop = Arc::clone(&running); + let stopper = thread::spawn(move || { + thread::sleep(Duration::from_millis(60)); + running_for_stop.store(false, Ordering::Relaxed); + }); + + let result = wait_for_server_shutdown_at(&socket_path, Duration::from_millis(500)); + running.store(false, Ordering::Relaxed); + let _ = stopper.join(); + let _ = handle.join(); + let _ = fs::remove_file(&socket_path); + assert!(result.is_ok(), "expected shutdown confirmation: {result:?}"); + } + + #[test] + fn wait_for_server_shutdown_times_out_while_socket_keeps_responding() { + let socket_path = unique_test_socket_path("shutdown-timeout"); + let (running, handle) = spawn_accept_loop(&socket_path); + + let err = + wait_for_server_shutdown_at(&socket_path, Duration::from_millis(120)).unwrap_err(); + running.store(false, Ordering::Relaxed); + let _ = handle.join(); + let _ = fs::remove_file(&socket_path); + assert!(err.contains("still responding"), "unexpected error: {err}"); + } + + #[test] fn version_ordering() { let v010 = Version::parse("0.1.0").unwrap(); let v011 = Version::parse("0.1.1").unwrap(); diff --git a/src/workspace.rs b/src/workspace.rs index 30e968fe..b80e5773 100644 --- a/src/workspace.rs +++ b/src/workspace.rs @@ -1,6 +1,6 @@ use std::collections::HashMap; use std::ops::{Deref, DerefMut}; -use std::path::{Path, PathBuf}; +use std::path::PathBuf; use std::sync::atomic::{AtomicBool, AtomicU64, Ordering}; use std::sync::Arc; use std::time::{SystemTime, UNIX_EPOCH}; @@ -9,11 +9,22 @@ use ratatui::layout::Direction; use tokio::sync::{mpsc, Notify}; use tracing::info; -use crate::detect::{Agent, AgentState}; use crate::events::AppEvent; -use crate::layout::{PaneId, TileLayout}; +use crate::layout::PaneId; +#[cfg(test)] +use crate::layout::TileLayout; use crate::pane::{PaneRuntime, PaneState}; +mod aggregate; +mod git; +mod tab; + +use self::git::git_ahead_behind; +pub use self::{ + git::{derive_label_from_cwd, git_branch}, + tab::Tab, +}; + static NEXT_WORKSPACE_ID: AtomicU64 = AtomicU64::new(1); pub(crate) fn generate_workspace_id() -> String { @@ -25,287 +36,6 @@ pub(crate) fn generate_workspace_id() -> String { format!("w{micros:x}{counter:x}") } -pub struct Tab { - pub custom_name: Option<String>, - pub number: usize, - /// Identity source for this tab's pane tree. - pub root_pane: PaneId, - pub layout: TileLayout, - /// Pane state — always present, testable without PTYs. - pub panes: HashMap<PaneId, PaneState>, - /// Best-effort cwd cache per pane. Live runtime cwd wins when available. - pub pane_cwds: HashMap<PaneId, PathBuf>, - /// Pane runtimes — only present in production (empty in tests). - pub runtimes: HashMap<PaneId, PaneRuntime>, - pub zoomed: bool, - pub events: mpsc::Sender<AppEvent>, - pub(crate) render_notify: Arc<Notify>, - pub(crate) render_dirty: Arc<AtomicBool>, -} - -impl Drop for Tab { - fn drop(&mut self) { - let runtimes = std::mem::take(&mut self.runtimes); - for (pane_id, runtime) in runtimes { - runtime.shutdown(pane_id); - } - } -} - -impl Tab { - pub fn new( - number: usize, - initial_cwd: PathBuf, - rows: u16, - cols: u16, - scrollback_limit_bytes: usize, - host_terminal_theme: crate::terminal_theme::TerminalTheme, - events: mpsc::Sender<AppEvent>, - render_notify: Arc<Notify>, - render_dirty: Arc<AtomicBool>, - ) -> std::io::Result<Self> { - let (layout, root_id) = TileLayout::new(); - let runtime = PaneRuntime::spawn( - root_id, - rows, - cols, - initial_cwd.clone(), - scrollback_limit_bytes, - host_terminal_theme, - events.clone(), - render_notify.clone(), - render_dirty.clone(), - )?; - - let mut panes = HashMap::new(); - panes.insert(root_id, PaneState::new()); - let mut pane_cwds = HashMap::new(); - pane_cwds.insert(root_id, initial_cwd); - let mut runtimes = HashMap::new(); - runtimes.insert(root_id, runtime); - - Ok(Self { - custom_name: None, - number, - root_pane: root_id, - layout, - panes, - pane_cwds, - runtimes, - zoomed: false, - events, - render_notify, - render_dirty, - }) - } - - pub fn display_name(&self) -> String { - self.custom_name - .clone() - .unwrap_or_else(|| self.number.to_string()) - } - - pub fn is_auto_named(&self) -> bool { - self.custom_name.is_none() - } - - pub fn set_custom_name(&mut self, name: String) { - self.custom_name = Some(name); - } - - pub fn split_focused( - &mut self, - direction: Direction, - rows: u16, - cols: u16, - cwd: Option<PathBuf>, - scrollback_limit_bytes: usize, - host_terminal_theme: crate::terminal_theme::TerminalTheme, - ) -> std::io::Result<PaneId> { - self.split_focused_with_runtime( - direction, - rows, - cols, - cwd, - scrollback_limit_bytes, - host_terminal_theme, - None, - ) - } - - pub fn split_focused_command( - &mut self, - direction: Direction, - rows: u16, - cols: u16, - cwd: Option<PathBuf>, - command: &str, - extra_env: &[(String, String)], - scrollback_limit_bytes: usize, - host_terminal_theme: crate::terminal_theme::TerminalTheme, - ) -> std::io::Result<PaneId> { - self.split_focused_with_runtime( - direction, - rows, - cols, - cwd, - scrollback_limit_bytes, - host_terminal_theme, - Some((command, extra_env)), - ) - } - - fn split_focused_with_runtime( - &mut self, - direction: Direction, - rows: u16, - cols: u16, - cwd: Option<PathBuf>, - scrollback_limit_bytes: usize, - host_terminal_theme: crate::terminal_theme::TerminalTheme, - command: Option<(&str, &[(String, String)])>, - ) -> std::io::Result<PaneId> { - let new_id = self.layout.split_focused(direction); - let actual_cwd = - cwd.unwrap_or_else(|| std::env::current_dir().unwrap_or_else(|_| "/".into())); - let runtime = if let Some((command, extra_env)) = command { - PaneRuntime::spawn_shell_command( - new_id, - rows, - cols, - actual_cwd.clone(), - command, - extra_env, - scrollback_limit_bytes, - host_terminal_theme, - self.events.clone(), - self.render_notify.clone(), - self.render_dirty.clone(), - )? - } else { - PaneRuntime::spawn( - new_id, - rows, - cols, - actual_cwd.clone(), - scrollback_limit_bytes, - host_terminal_theme, - self.events.clone(), - self.render_notify.clone(), - self.render_dirty.clone(), - )? - }; - self.panes.insert(new_id, PaneState::new()); - self.pane_cwds.insert(new_id, actual_cwd); - self.runtimes.insert(new_id, runtime); - self.zoomed = false; - Ok(new_id) - } - - pub fn close_focused(&mut self) -> Option<(PaneId, Option<PaneRuntime>)> { - let pane_id = self.layout.focused(); - self.detach_pane(pane_id) - } - - pub fn close_pane(&mut self, pane_id: PaneId) -> Option<(PaneId, Option<PaneRuntime>)> { - self.detach_pane(pane_id) - } - - pub fn remove_pane(&mut self, pane_id: PaneId) -> Option<(PaneId, Option<PaneRuntime>)> { - self.detach_pane(pane_id) - } - - fn detach_pane(&mut self, pane_id: PaneId) -> Option<(PaneId, Option<PaneRuntime>)> { - if self.layout.pane_count() <= 1 { - return None; - } - - let next_root = self.promoted_root_if_needed(pane_id); - - if self.layout.focused() == pane_id { - self.layout.close_focused(); - } else { - let prev_focus = self.layout.focused(); - self.layout.focus_pane(pane_id); - self.layout.close_focused(); - self.layout.focus_pane(prev_focus); - } - - self.panes.remove(&pane_id); - self.pane_cwds.remove(&pane_id); - let runtime = self.runtimes.remove(&pane_id); - self.zoomed = false; - if let Some(next_root) = next_root { - self.root_pane = next_root; - } - Some((pane_id, runtime)) - } - - fn promoted_root_if_needed(&self, closing: PaneId) -> Option<PaneId> { - if self.root_pane != closing { - return None; - } - self.layout.pane_ids().into_iter().find(|id| *id != closing) - } - - pub fn focused_runtime(&self) -> Option<&PaneRuntime> { - self.runtimes.get(&self.layout.focused()) - } - - pub fn cwd_for_pane(&self, pane_id: PaneId) -> Option<PathBuf> { - self.runtimes - .get(&pane_id) - .and_then(|rt| rt.cwd()) - .or_else(|| self.pane_cwds.get(&pane_id).cloned()) - } - - pub fn root_cwd(&self) -> Option<PathBuf> { - self.cwd_for_pane(self.root_pane) - } - - pub fn has_working_pane(&self) -> bool { - self.panes - .values() - .any(|pane| pane.state == AgentState::Working) - } - - #[cfg(test)] - #[allow(dead_code)] // retained for focused layout-order assertions in tests - pub fn pane_states(&self) -> Vec<(AgentState, bool)> { - self.layout - .pane_ids() - .iter() - .map(|id| { - self.panes - .get(id) - .map(|p| (p.state, p.seen)) - .unwrap_or((AgentState::Unknown, true)) - }) - .collect() - } - - pub fn pane_details(&self) -> Vec<PaneDetail> { - self.layout - .pane_ids() - .iter() - .filter_map(|id| { - let pane = self.panes.get(id)?; - let agent_label = pane.effective_agent_label()?.to_string(); - Some(PaneDetail { - pane_id: *id, - tab_idx: self.number.saturating_sub(1), - tab_label: self.display_name(), - label: agent_label.clone(), - agent_label, - agent: pane.effective_known_agent(), - state: pane.state, - seen: pane.seen, - }) - }) - .collect() - } -} - /// A named workspace containing tabs. pub struct Workspace { /// Stable public workspace identity, independent of display order. @@ -602,33 +332,6 @@ impl Workspace { .and_then(|cwd| git_ahead_behind(&cwd)); } - pub fn aggregate_state(&self) -> (AgentState, bool) { - self.tabs - .iter() - .flat_map(|tab| tab.panes.values()) - .map(|pane| (pane.state, pane.seen)) - .max_by_key(|(state, seen)| pane_attention_priority(*state, *seen)) - .unwrap_or((AgentState::Unknown, true)) - } - - pub fn has_working_pane(&self) -> bool { - self.tabs.iter().any(Tab::has_working_pane) - } - - pub fn pane_details(&self) -> Vec<PaneDetail> { - let multi_tab = self.tabs.len() > 1; - self.tabs - .iter() - .flat_map(Tab::pane_details) - .map(|mut detail| { - if multi_tab { - detail.label = format!("{}·{}", detail.tab_label, detail.agent_label); - } - detail - }) - .collect() - } - pub fn focused_runtime(&self) -> Option<&PaneRuntime> { self.active_tab().and_then(Tab::focused_runtime) } @@ -714,123 +417,9 @@ impl Workspace { } } -/// Detail info for a single pane, used by the agent detail panel. -pub struct PaneDetail { - pub pane_id: PaneId, - pub tab_idx: usize, - pub tab_label: String, - pub label: String, - pub agent_label: String, - #[allow(dead_code)] - pub agent: Option<Agent>, - pub state: AgentState, - pub seen: bool, -} - -fn pane_attention_priority(state: AgentState, seen: bool) -> u8 { - match (state, seen) { - (AgentState::Blocked, _) => 4, - (AgentState::Idle, false) => 3, - (AgentState::Working, _) => 2, - (AgentState::Idle, true) => 1, - (AgentState::Unknown, _) => 0, - } -} - -pub fn derive_label_from_cwd(cwd: &Path) -> String { - if let Some(repo_root) = git_repo_root(cwd) { - if let Some(name) = repo_root.file_name().and_then(|n| n.to_str()) { - return name.to_string(); - } - } - - if let Ok(home) = std::env::var("HOME") { - let home = Path::new(&home); - if cwd == home { - return "~".to_string(); - } - } - - cwd.file_name() - .and_then(|n| n.to_str()) - .filter(|s| !s.is_empty()) - .map(|s| s.to_string()) - .unwrap_or_else(|| cwd.display().to_string()) -} - -pub fn git_branch(cwd: &Path) -> Option<String> { - let repo_root = git_repo_root(cwd)?; - let git_dir = git_dir_for_repo_root(&repo_root)?; - let head = std::fs::read_to_string(git_dir.join("HEAD")).ok()?; - parse_git_head_branch(&head) -} - -fn git_dir_for_repo_root(repo_root: &Path) -> Option<PathBuf> { - let git_path = repo_root.join(".git"); - if git_path.is_dir() { - return Some(git_path); - } - - let gitdir = std::fs::read_to_string(&git_path).ok()?; - let relative = gitdir.trim().strip_prefix("gitdir:")?.trim(); - let resolved = Path::new(relative); - Some(if resolved.is_absolute() { - resolved.to_path_buf() - } else { - repo_root.join(resolved) - }) -} - -fn parse_git_head_branch(head: &str) -> Option<String> { - let branch = head.trim().strip_prefix("ref: refs/heads/")?; - (!branch.is_empty()).then(|| branch.to_string()) -} - -fn git_repo_root(start: &Path) -> Option<PathBuf> { - let mut current = if start.is_dir() { - start.to_path_buf() - } else { - start.parent()?.to_path_buf() - }; - - loop { - if current.join(".git").exists() { - return Some(current); - } - if !current.pop() { - return None; - } - } -} - -fn git_ahead_behind(cwd: &Path) -> Option<(usize, usize)> { - git_repo_root(cwd)?; - - let output = std::process::Command::new("git") - .arg("-C") - .arg(cwd) - .args(["rev-list", "--left-right", "--count", "HEAD...@{upstream}"]) - .output() - .ok()?; - - if !output.status.success() { - return None; - } - - let stdout = String::from_utf8(output.stdout).ok()?; - parse_git_ahead_behind_output(&stdout) -} - -fn parse_git_ahead_behind_output(stdout: &str) -> Option<(usize, usize)> { - let mut parts = stdout.split_whitespace(); - let ahead = parts.next()?.parse().ok()?; - let behind = parts.next()?.parse().ok()?; - Some((ahead, behind)) -} - #[cfg(test)] impl Workspace { - pub fn test_new(name: &str) -> Self { + pub(crate) fn test_new(name: &str) -> Self { let (events, _) = mpsc::channel(64); let render_notify = Arc::new(Notify::new()); let render_dirty = Arc::new(AtomicBool::new(false)); @@ -867,7 +456,7 @@ impl Workspace { } } - pub fn test_split(&mut self, direction: Direction) -> PaneId { + pub(crate) fn test_split(&mut self, direction: Direction) -> PaneId { let tab = self.active_tab_mut().expect("workspace must have tab"); let new_id = tab.layout.split_focused(direction); tab.panes.insert(new_id, PaneState::new()); @@ -877,7 +466,7 @@ impl Workspace { new_id } - pub fn test_add_tab(&mut self, name: Option<&str>) -> usize { + pub(crate) fn test_add_tab(&mut self, name: Option<&str>) -> usize { let (events, _) = mpsc::channel(64); let render_notify = Arc::new(Notify::new()); let render_dirty = Arc::new(AtomicBool::new(false)); @@ -909,68 +498,6 @@ impl Workspace { #[cfg(test)] mod tests { use super::*; - use crate::detect::{Agent, AgentState}; - - fn temp_test_dir(name: &str) -> PathBuf { - let unique = format!( - "herdr-workspace-tests-{}-{}-{}", - name, - std::process::id(), - SystemTime::now() - .duration_since(UNIX_EPOCH) - .unwrap() - .as_nanos() - ); - let path = std::env::temp_dir().join(unique); - std::fs::create_dir_all(&path).unwrap(); - path - } - - #[test] - fn aggregate_state_all_unknown() { - let ws = Workspace::test_new("test"); - let (state, seen) = ws.aggregate_state(); - assert_eq!(state, AgentState::Unknown); - assert!(seen); - } - - #[test] - fn aggregate_state_priority() { - let mut ws = Workspace::test_new("test"); - let id2 = ws.test_split(Direction::Horizontal); - let root_id = ws.tabs[0] - .panes - .keys() - .find(|id| **id != id2) - .copied() - .unwrap(); - ws.tabs[0].panes.get_mut(&root_id).unwrap().state = AgentState::Idle; - ws.tabs[0].panes.get_mut(&id2).unwrap().state = AgentState::Working; - - let (state, seen) = ws.aggregate_state(); - assert_eq!(state, AgentState::Working); - assert!(seen); - } - - #[test] - fn aggregate_state_done_unseen_beats_working() { - let mut ws = Workspace::test_new("test"); - let id2 = ws.test_split(Direction::Horizontal); - let root_id = ws.tabs[0] - .panes - .keys() - .find(|id| **id != id2) - .copied() - .unwrap(); - let root = ws.tabs[0].panes.get_mut(&root_id).unwrap(); - root.state = AgentState::Idle; - root.seen = false; - ws.tabs[0].panes.get_mut(&id2).unwrap().state = AgentState::Working; - - let (state, seen) = ws.aggregate_state(); - assert_eq!(state, AgentState::Idle); - assert!(!seen); - } #[test] fn workspace_identity_follows_first_tab_root_pane_cwd() { @@ -986,53 +513,6 @@ mod tests { } #[test] - fn git_branch_reads_head_from_standard_repo() { - let root = temp_test_dir("standard-repo"); - std::fs::create_dir_all(root.join(".git")).unwrap(); - std::fs::write(root.join(".git/HEAD"), "ref: refs/heads/main\n").unwrap(); - - assert_eq!(git_branch(&root).as_deref(), Some("main")); - - std::fs::remove_dir_all(root).unwrap(); - } - - #[test] - fn git_branch_reads_head_from_worktree_gitdir_file() { - let root = temp_test_dir("worktree"); - let worktree_git_dir = root.join(".bare/worktrees/feature"); - std::fs::create_dir_all(&worktree_git_dir).unwrap(); - std::fs::write(root.join(".git"), "gitdir: .bare/worktrees/feature\n").unwrap(); - std::fs::write(worktree_git_dir.join("HEAD"), "ref: refs/heads/feature\n").unwrap(); - - assert_eq!(git_branch(&root).as_deref(), Some("feature")); - - std::fs::remove_dir_all(root).unwrap(); - } - - #[test] - fn git_branch_returns_none_for_detached_head() { - let root = temp_test_dir("detached-head"); - std::fs::create_dir_all(root.join(".git")).unwrap(); - std::fs::write(root.join(".git/HEAD"), "3e1b9a8d\n").unwrap(); - - assert_eq!(git_branch(&root), None); - - std::fs::remove_dir_all(root).unwrap(); - } - - #[test] - fn pane_details_hide_plain_shells() { - let mut ws = Workspace::test_new("test"); - let root_pane = ws.tabs[0].root_pane; - ws.tabs[0].panes.get_mut(&root_pane).unwrap().detected_agent = Some(Agent::Pi); - ws.test_split(Direction::Horizontal); - - let details = ws.pane_details(); - assert_eq!(details.len(), 1); - assert_eq!(details[0].label, "pi"); - } - - #[test] fn moving_tab_keeps_active_identity_and_renumbers_auto_tabs() { let mut ws = Workspace::test_new("test"); let moved_root = ws.tabs[0].root_pane; @@ -1051,46 +531,4 @@ mod tests { assert_eq!(ws.tabs[2].root_pane, moved_root); assert_eq!(ws.tabs[ws.active_tab].root_pane, active_root); } - - #[test] - fn pane_details_include_tab_context_when_workspace_has_multiple_tabs() { - let mut ws = Workspace::test_new("test"); - ws.tabs[0].set_custom_name("main".into()); - let root_pane = ws.tabs[0].root_pane; - ws.tabs[0].panes.get_mut(&root_pane).unwrap().detected_agent = Some(Agent::Pi); - - let tab_idx = ws.test_add_tab(Some("logs")); - let second_root_pane = ws.tabs[tab_idx].root_pane; - ws.tabs[tab_idx] - .panes - .get_mut(&second_root_pane) - .unwrap() - .detected_agent = Some(Agent::Claude); - - let details = ws.pane_details(); - assert_eq!(details.len(), 2); - assert!(details.iter().any(|detail| detail.label == "main·pi")); - assert!(details.iter().any(|detail| detail.label == "logs·claude")); - } - - #[test] - fn pane_details_include_hook_reported_unknown_agents() { - let mut ws = Workspace::test_new("test"); - let root_pane = ws.tabs[0].root_pane; - ws.tabs[0] - .panes - .get_mut(&root_pane) - .unwrap() - .set_hook_authority( - "custom:hermes".into(), - "hermes".into(), - AgentState::Working, - None, - ); - - let details = ws.pane_details(); - assert_eq!(details.len(), 1); - assert_eq!(details[0].agent_label, "hermes"); - assert_eq!(details[0].agent, None); - } } diff --git a/src/workspace/aggregate.rs b/src/workspace/aggregate.rs new file mode 100644 index 00000000..53e08920 --- /dev/null +++ b/src/workspace/aggregate.rs @@ -0,0 +1,193 @@ +use crate::detect::{Agent, AgentState}; +use crate::layout::PaneId; + +use super::{Tab, Workspace}; + +/// Detail info for a single pane, used by the agent detail panel. +pub struct PaneDetail { + pub pane_id: PaneId, + pub tab_idx: usize, + pub tab_label: String, + pub label: String, + pub agent_label: String, + #[allow(dead_code)] + pub agent: Option<Agent>, + pub state: AgentState, + pub seen: bool, +} + +impl Tab { + pub fn has_working_pane(&self) -> bool { + self.panes + .values() + .any(|pane| pane.state == AgentState::Working) + } + + pub fn pane_details(&self) -> Vec<PaneDetail> { + self.layout + .pane_ids() + .iter() + .filter_map(|id| { + let pane = self.panes.get(id)?; + let agent_label = pane.effective_agent_label()?.to_string(); + Some(PaneDetail { + pane_id: *id, + tab_idx: self.number.saturating_sub(1), + tab_label: self.display_name(), + label: agent_label.clone(), + agent_label, + agent: pane.effective_known_agent(), + state: pane.state, + seen: pane.seen, + }) + }) + .collect() + } +} + +fn pane_attention_priority(state: AgentState, seen: bool) -> u8 { + match (state, seen) { + (AgentState::Blocked, _) => 4, + (AgentState::Idle, false) => 3, + (AgentState::Working, _) => 2, + (AgentState::Idle, true) => 1, + (AgentState::Unknown, _) => 0, + } +} + +impl Workspace { + pub fn aggregate_state(&self) -> (AgentState, bool) { + self.tabs + .iter() + .flat_map(|tab| tab.panes.values()) + .map(|pane| (pane.state, pane.seen)) + .max_by_key(|(state, seen)| pane_attention_priority(*state, *seen)) + .unwrap_or((AgentState::Unknown, true)) + } + + pub fn has_working_pane(&self) -> bool { + self.tabs.iter().any(Tab::has_working_pane) + } + + pub fn pane_details(&self) -> Vec<PaneDetail> { + let multi_tab = self.tabs.len() > 1; + self.tabs + .iter() + .flat_map(Tab::pane_details) + .map(|mut detail| { + if multi_tab { + detail.label = format!("{}·{}", detail.tab_label, detail.agent_label); + } + detail + }) + .collect() + } +} + +#[cfg(test)] +mod tests { + use ratatui::layout::Direction; + + use super::*; + use crate::detect::Agent; + + #[test] + fn aggregate_state_all_unknown() { + let ws = Workspace::test_new("test"); + let (state, seen) = ws.aggregate_state(); + assert_eq!(state, AgentState::Unknown); + assert!(seen); + } + + #[test] + fn aggregate_state_priority() { + let mut ws = Workspace::test_new("test"); + let id2 = ws.test_split(Direction::Horizontal); + let root_id = ws.tabs[0] + .panes + .keys() + .find(|id| **id != id2) + .copied() + .unwrap(); + ws.tabs[0].panes.get_mut(&root_id).unwrap().state = AgentState::Idle; + ws.tabs[0].panes.get_mut(&id2).unwrap().state = AgentState::Working; + + let (state, seen) = ws.aggregate_state(); + assert_eq!(state, AgentState::Working); + assert!(seen); + } + + #[test] + fn aggregate_state_done_unseen_beats_working() { + let mut ws = Workspace::test_new("test"); + let id2 = ws.test_split(Direction::Horizontal); + let root_id = ws.tabs[0] + .panes + .keys() + .find(|id| **id != id2) + .copied() + .unwrap(); + let root = ws.tabs[0].panes.get_mut(&root_id).unwrap(); + root.state = AgentState::Idle; + root.seen = false; + ws.tabs[0].panes.get_mut(&id2).unwrap().state = AgentState::Working; + + let (state, seen) = ws.aggregate_state(); + assert_eq!(state, AgentState::Idle); + assert!(!seen); + } + + #[test] + fn pane_details_hide_plain_shells() { + let mut ws = Workspace::test_new("test"); + let root_pane = ws.tabs[0].root_pane; + ws.tabs[0].panes.get_mut(&root_pane).unwrap().detected_agent = Some(Agent::Pi); + ws.test_split(Direction::Horizontal); + + let details = ws.pane_details(); + assert_eq!(details.len(), 1); + assert_eq!(details[0].label, "pi"); + } + + #[test] + fn pane_details_include_tab_context_when_workspace_has_multiple_tabs() { + let mut ws = Workspace::test_new("test"); + ws.tabs[0].set_custom_name("main".into()); + let root_pane = ws.tabs[0].root_pane; + ws.tabs[0].panes.get_mut(&root_pane).unwrap().detected_agent = Some(Agent::Pi); + + let tab_idx = ws.test_add_tab(Some("logs")); + let second_root_pane = ws.tabs[tab_idx].root_pane; + ws.tabs[tab_idx] + .panes + .get_mut(&second_root_pane) + .unwrap() + .detected_agent = Some(Agent::Claude); + + let details = ws.pane_details(); + assert_eq!(details.len(), 2); + assert!(details.iter().any(|detail| detail.label == "main·pi")); + assert!(details.iter().any(|detail| detail.label == "logs·claude")); + } + + #[test] + fn pane_details_include_hook_reported_unknown_agents() { + let mut ws = Workspace::test_new("test"); + let root_pane = ws.tabs[0].root_pane; + ws.tabs[0] + .panes + .get_mut(&root_pane) + .unwrap() + .set_hook_authority( + "custom:hermes".into(), + "hermes".into(), + AgentState::Working, + None, + ); + + let details = ws.pane_details(); + assert_eq!(details.len(), 1); + assert_eq!(details[0].agent_label, "hermes"); + assert_eq!(details[0].agent, None); + } +} diff --git a/src/workspace/git.rs b/src/workspace/git.rs new file mode 100644 index 00000000..ca453003 --- /dev/null +++ b/src/workspace/git.rs @@ -0,0 +1,149 @@ +use std::path::{Path, PathBuf}; + +pub fn derive_label_from_cwd(cwd: &Path) -> String { + if let Some(repo_root) = git_repo_root(cwd) { + if let Some(name) = repo_root.file_name().and_then(|n| n.to_str()) { + return name.to_string(); + } + } + + if let Ok(home) = std::env::var("HOME") { + let home = Path::new(&home); + if cwd == home { + return "~".to_string(); + } + } + + cwd.file_name() + .and_then(|n| n.to_str()) + .filter(|s| !s.is_empty()) + .map(|s| s.to_string()) + .unwrap_or_else(|| cwd.display().to_string()) +} + +pub fn git_branch(cwd: &Path) -> Option<String> { + let repo_root = git_repo_root(cwd)?; + let git_dir = git_dir_for_repo_root(&repo_root)?; + let head = std::fs::read_to_string(git_dir.join("HEAD")).ok()?; + parse_git_head_branch(&head) +} + +fn git_dir_for_repo_root(repo_root: &Path) -> Option<PathBuf> { + let git_path = repo_root.join(".git"); + if git_path.is_dir() { + return Some(git_path); + } + + let gitdir = std::fs::read_to_string(&git_path).ok()?; + let relative = gitdir.trim().strip_prefix("gitdir:")?.trim(); + let resolved = Path::new(relative); + Some(if resolved.is_absolute() { + resolved.to_path_buf() + } else { + repo_root.join(resolved) + }) +} + +fn parse_git_head_branch(head: &str) -> Option<String> { + let branch = head.trim().strip_prefix("ref: refs/heads/")?; + (!branch.is_empty()).then(|| branch.to_string()) +} + +fn git_repo_root(start: &Path) -> Option<PathBuf> { + let mut current = if start.is_dir() { + start.to_path_buf() + } else { + start.parent()?.to_path_buf() + }; + + loop { + if current.join(".git").exists() { + return Some(current); + } + if !current.pop() { + return None; + } + } +} + +pub(super) fn git_ahead_behind(cwd: &Path) -> Option<(usize, usize)> { + git_repo_root(cwd)?; + + let output = std::process::Command::new("git") + .arg("-C") + .arg(cwd) + .args(["rev-list", "--left-right", "--count", "HEAD...@{upstream}"]) + .output() + .ok()?; + + if !output.status.success() { + return None; + } + + let stdout = String::from_utf8(output.stdout).ok()?; + parse_git_ahead_behind_output(&stdout) +} + +fn parse_git_ahead_behind_output(stdout: &str) -> Option<(usize, usize)> { + let mut parts = stdout.split_whitespace(); + let ahead = parts.next()?.parse().ok()?; + let behind = parts.next()?.parse().ok()?; + Some((ahead, behind)) +} + +#[cfg(test)] +mod tests { + use std::time::{SystemTime, UNIX_EPOCH}; + + use super::*; + + fn temp_test_dir(name: &str) -> PathBuf { + let unique = format!( + "herdr-workspace-tests-{}-{}-{}", + name, + std::process::id(), + SystemTime::now() + .duration_since(UNIX_EPOCH) + .unwrap() + .as_nanos() + ); + let path = std::env::temp_dir().join(unique); + std::fs::create_dir_all(&path).unwrap(); + path + } + + #[test] + fn git_branch_reads_head_from_standard_repo() { + let root = temp_test_dir("standard-repo"); + std::fs::create_dir_all(root.join(".git")).unwrap(); + std::fs::write(root.join(".git/HEAD"), "ref: refs/heads/main\n").unwrap(); + + assert_eq!(git_branch(&root).as_deref(), Some("main")); + + std::fs::remove_dir_all(root).unwrap(); + } + + #[test] + fn git_branch_reads_head_from_worktree_gitdir_file() { + let root = temp_test_dir("worktree"); + let worktree_git_dir = root.join(".bare/worktrees/feature"); + std::fs::create_dir_all(&worktree_git_dir).unwrap(); + std::fs::write(root.join(".git"), "gitdir: .bare/worktrees/feature\n").unwrap(); + std::fs::write(worktree_git_dir.join("HEAD"), "ref: refs/heads/feature\n").unwrap(); + + assert_eq!(git_branch(&root).as_deref(), Some("feature")); + + std::fs::remove_dir_all(root).unwrap(); + } + + #[test] + fn git_branch_returns_none_for_detached_head() { + let root = temp_test_dir("detached-head"); + std::fs::create_dir_all(root.join(".git")).unwrap(); + std::fs::write(root.join(".git/HEAD"), "3e1b9a8d\n").unwrap(); + + assert_eq!(git_branch(&root), None); + + std::fs::remove_dir_all(root).unwrap(); + } +} diff --git a/src/workspace/tab.rs b/src/workspace/tab.rs new file mode 100644 index 00000000..f8b31eb5 --- /dev/null +++ b/src/workspace/tab.rs @@ -0,0 +1,265 @@ +use std::collections::HashMap; +use std::path::PathBuf; +use std::sync::atomic::AtomicBool; +use std::sync::Arc; + +use ratatui::layout::Direction; +use tokio::sync::{mpsc, Notify}; + +use crate::events::AppEvent; +use crate::layout::{PaneId, TileLayout}; +use crate::pane::{PaneRuntime, PaneState}; + +pub struct Tab { + pub custom_name: Option<String>, + pub number: usize, + /// Identity source for this tab's pane tree. + pub root_pane: PaneId, + pub layout: TileLayout, + /// Pane state — always present, testable without PTYs. + pub panes: HashMap<PaneId, PaneState>, + /// Best-effort cwd cache per pane. Live runtime cwd wins when available. + pub pane_cwds: HashMap<PaneId, PathBuf>, + /// Pane runtimes — only present in production (empty in tests). + pub runtimes: HashMap<PaneId, PaneRuntime>, + pub zoomed: bool, + pub events: mpsc::Sender<AppEvent>, + pub(crate) render_notify: Arc<Notify>, + pub(crate) render_dirty: Arc<AtomicBool>, +} + +impl Drop for Tab { + fn drop(&mut self) { + let runtimes = std::mem::take(&mut self.runtimes); + for (pane_id, runtime) in runtimes { + runtime.shutdown(pane_id); + } + } +} + +impl Tab { + pub fn new( + number: usize, + initial_cwd: PathBuf, + rows: u16, + cols: u16, + scrollback_limit_bytes: usize, + host_terminal_theme: crate::terminal_theme::TerminalTheme, + events: mpsc::Sender<AppEvent>, + render_notify: Arc<Notify>, + render_dirty: Arc<AtomicBool>, + ) -> std::io::Result<Self> { + let (layout, root_id) = TileLayout::new(); + let runtime = PaneRuntime::spawn( + root_id, + rows, + cols, + initial_cwd.clone(), + scrollback_limit_bytes, + host_terminal_theme, + events.clone(), + render_notify.clone(), + render_dirty.clone(), + )?; + + let mut panes = HashMap::new(); + panes.insert(root_id, PaneState::new()); + let mut pane_cwds = HashMap::new(); + pane_cwds.insert(root_id, initial_cwd); + let mut runtimes = HashMap::new(); + runtimes.insert(root_id, runtime); + + Ok(Self { + custom_name: None, + number, + root_pane: root_id, + layout, + panes, + pane_cwds, + runtimes, + zoomed: false, + events, + render_notify, + render_dirty, + }) + } + + pub fn display_name(&self) -> String { + self.custom_name + .clone() + .unwrap_or_else(|| self.number.to_string()) + } + + pub fn is_auto_named(&self) -> bool { + self.custom_name.is_none() + } + + pub fn set_custom_name(&mut self, name: String) { + self.custom_name = Some(name); + } + + pub fn split_focused( + &mut self, + direction: Direction, + rows: u16, + cols: u16, + cwd: Option<PathBuf>, + scrollback_limit_bytes: usize, + host_terminal_theme: crate::terminal_theme::TerminalTheme, + ) -> std::io::Result<PaneId> { + self.split_focused_with_runtime( + direction, + rows, + cols, + cwd, + scrollback_limit_bytes, + host_terminal_theme, + None, + ) + } + + pub fn split_focused_command( + &mut self, + direction: Direction, + rows: u16, + cols: u16, + cwd: Option<PathBuf>, + command: &str, + extra_env: &[(String, String)], + scrollback_limit_bytes: usize, + host_terminal_theme: crate::terminal_theme::TerminalTheme, + ) -> std::io::Result<PaneId> { + self.split_focused_with_runtime( + direction, + rows, + cols, + cwd, + scrollback_limit_bytes, + host_terminal_theme, + Some((command, extra_env)), + ) + } + + fn split_focused_with_runtime( + &mut self, + direction: Direction, + rows: u16, + cols: u16, + cwd: Option<PathBuf>, + scrollback_limit_bytes: usize, + host_terminal_theme: crate::terminal_theme::TerminalTheme, + command: Option<(&str, &[(String, String)])>, + ) -> std::io::Result<PaneId> { + let new_id = self.layout.split_focused(direction); + let actual_cwd = + cwd.unwrap_or_else(|| std::env::current_dir().unwrap_or_else(|_| "/".into())); + let runtime = if let Some((command, extra_env)) = command { + PaneRuntime::spawn_shell_command( + new_id, + rows, + cols, + actual_cwd.clone(), + command, + extra_env, + scrollback_limit_bytes, + host_terminal_theme, + self.events.clone(), + self.render_notify.clone(), + self.render_dirty.clone(), + )? + } else { + PaneRuntime::spawn( + new_id, + rows, + cols, + actual_cwd.clone(), + scrollback_limit_bytes, + host_terminal_theme, + self.events.clone(), + self.render_notify.clone(), + self.render_dirty.clone(), + )? + }; + self.panes.insert(new_id, PaneState::new()); + self.pane_cwds.insert(new_id, actual_cwd); + self.runtimes.insert(new_id, runtime); + self.zoomed = false; + Ok(new_id) + } + + pub fn close_focused(&mut self) -> Option<(PaneId, Option<PaneRuntime>)> { + let pane_id = self.layout.focused(); + self.detach_pane(pane_id) + } + + pub fn close_pane(&mut self, pane_id: PaneId) -> Option<(PaneId, Option<PaneRuntime>)> { + self.detach_pane(pane_id) + } + + pub fn remove_pane(&mut self, pane_id: PaneId) -> Option<(PaneId, Option<PaneRuntime>)> { + self.detach_pane(pane_id) + } + + fn detach_pane(&mut self, pane_id: PaneId) -> Option<(PaneId, Option<PaneRuntime>)> { + if self.layout.pane_count() <= 1 { + return None; + } + + let next_root = self.promoted_root_if_needed(pane_id); + + if self.layout.focused() == pane_id { + self.layout.close_focused(); + } else { + let prev_focus = self.layout.focused(); + self.layout.focus_pane(pane_id); + self.layout.close_focused(); + self.layout.focus_pane(prev_focus); + } + + self.panes.remove(&pane_id); + self.pane_cwds.remove(&pane_id); + let runtime = self.runtimes.remove(&pane_id); + self.zoomed = false; + if let Some(next_root) = next_root { + self.root_pane = next_root; + } + Some((pane_id, runtime)) + } + + fn promoted_root_if_needed(&self, closing: PaneId) -> Option<PaneId> { + if self.root_pane != closing { + return None; + } + self.layout.pane_ids().into_iter().find(|id| *id != closing) + } + + pub fn focused_runtime(&self) -> Option<&PaneRuntime> { + self.runtimes.get(&self.layout.focused()) + } + + pub fn cwd_for_pane(&self, pane_id: PaneId) -> Option<PathBuf> { + self.runtimes + .get(&pane_id) + .and_then(|rt| rt.cwd()) + .or_else(|| self.pane_cwds.get(&pane_id).cloned()) + } + + pub fn root_cwd(&self) -> Option<PathBuf> { + self.cwd_for_pane(self.root_pane) + } + + #[cfg(test)] + #[allow(dead_code)] // retained for focused layout-order assertions in tests + pub fn pane_states(&self) -> Vec<(crate::detect::AgentState, bool)> { + self.layout + .pane_ids() + .iter() + .map(|id| { + self.panes + .get(id) + .map(|p| (p.state, p.seen)) + .unwrap_or((crate::detect::AgentState::Unknown, true)) + }) + .collect() + } +} diff --git a/tests/api_ping.rs b/tests/api_ping.rs index acd7f1b8..b8de04f3 100644 --- a/tests/api_ping.rs +++ b/tests/api_ping.rs @@ -1,3 +1,5 @@ +mod support; + use std::fs; use std::io::{Read, Write}; use std::os::unix::net::UnixStream; @@ -7,6 +9,10 @@ use std::thread; use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH}; use portable_pty::{native_pty_system, Child, CommandBuilder, MasterPty, PtySize}; +use support::{ + cleanup_test_base, register_runtime_dir, register_spawned_herdr_pid, + unregister_spawned_herdr_pid, +}; fn unique_test_dir() -> PathBuf { let nanos = SystemTime::now() @@ -21,24 +27,31 @@ struct SpawnedHerdr { child: Box<dyn Child + Send + Sync>, } -fn cleanup_spawned_herdr(mut spawned: SpawnedHerdr, base: PathBuf) { - let pid = spawned.child.process_id(); - let _ = spawned.child.kill(); - - if let Some(pid) = pid { - let deadline = Instant::now() + Duration::from_secs(2); - while Instant::now() < deadline { - let mut status = 0; - let result = unsafe { libc::waitpid(pid as libc::pid_t, &mut status, libc::WNOHANG) }; - if result == pid as libc::pid_t || result == -1 { - break; +impl Drop for SpawnedHerdr { + fn drop(&mut self) { + let pid = self.child.process_id(); + let _ = self.child.kill(); + + if let Some(pid) = pid { + let deadline = Instant::now() + Duration::from_secs(2); + while Instant::now() < deadline { + let mut status = 0; + let result = + unsafe { libc::waitpid(pid as libc::pid_t, &mut status, libc::WNOHANG) }; + if result == pid as libc::pid_t || result == -1 { + break; + } + thread::sleep(Duration::from_millis(20)); } - thread::sleep(Duration::from_millis(20)); + + unregister_spawned_herdr_pid(Some(pid)); } } +} +fn cleanup_spawned_herdr(spawned: SpawnedHerdr, base: PathBuf) { drop(spawned); - let _ = fs::remove_dir_all(base); + cleanup_test_base(&base); } fn test_lock() -> MutexGuard<'static, ()> { @@ -71,6 +84,7 @@ fn spawn_herdr_with_path( ) -> SpawnedHerdr { fs::create_dir_all(config_home.join("herdr")).unwrap(); fs::create_dir_all(runtime_dir).unwrap(); + register_runtime_dir(runtime_dir); fs::write( config_home.join("herdr/config.toml"), "onboarding = false\n", @@ -87,10 +101,11 @@ fn spawn_herdr_with_path( .unwrap(); let mut cmd = CommandBuilder::new(env!("CARGO_BIN_EXE_herdr")); - cmd.arg("--no-session"); + cmd.arg("server"); cmd.env("XDG_CONFIG_HOME", config_home); cmd.env("XDG_RUNTIME_DIR", runtime_dir); cmd.env("HERDR_SOCKET_PATH", socket_path); + cmd.env_remove("HERDR_CLIENT_SOCKET_PATH"); cmd.env("SHELL", "/bin/sh"); cmd.env_remove("HERDR_ENV"); if let Some(path) = path_override { @@ -98,6 +113,7 @@ fn spawn_herdr_with_path( } let child = pair.slave.spawn_command(cmd).unwrap(); + register_spawned_herdr_pid(child.process_id()); SpawnedHerdr { _master: pair.master, diff --git a/tests/auto_detect.rs b/tests/auto_detect.rs new file mode 100644 index 00000000..4c92d62c --- /dev/null +++ b/tests/auto_detect.rs @@ -0,0 +1,706 @@ +//! Integration tests for auto-detect launch behavior. + +#![cfg(not(target_os = "macos"))] + +mod support; + +use std::fs; +use std::io::{BufRead, BufReader, Write}; +use std::os::unix::net::UnixStream; +use std::path::{Path, PathBuf}; +use std::process::Command; +use std::sync::{Mutex, MutexGuard, OnceLock}; +use std::thread; +use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH}; + +use portable_pty::{native_pty_system, Child, CommandBuilder, MasterPty, PtySize}; +use serde_json::Value; +use support::{ + cleanup_test_base, register_runtime_dir, register_spawned_herdr_pid, + unregister_spawned_herdr_pid, +}; + +fn unique_test_dir() -> PathBuf { + let nanos = SystemTime::now() + .duration_since(UNIX_EPOCH) + .map(|d| d.as_nanos()) + .unwrap_or(0); + PathBuf::from(format!( + "/tmp/herdr-autodetect-test-{}-{nanos}", + std::process::id() + )) +} + +struct SpawnedHerdr { + _master: Box<dyn MasterPty + Send>, + child: Box<dyn Child + Send + Sync>, +} + +impl Drop for SpawnedHerdr { + fn drop(&mut self) { + let pid = self.child.process_id(); + let _ = self.child.kill(); + + if let Some(pid) = pid { + let deadline = Instant::now() + Duration::from_secs(2); + while Instant::now() < deadline { + let mut status = 0; + let result = + unsafe { libc::waitpid(pid as libc::pid_t, &mut status, libc::WNOHANG) }; + if result == pid as libc::pid_t || result == -1 { + break; + } + thread::sleep(Duration::from_millis(20)); + } + + unregister_spawned_herdr_pid(Some(pid)); + } + } +} + +fn cleanup_spawned_herdr(spawned: SpawnedHerdr, base: PathBuf) { + drop(spawned); + cleanup_test_base(&base); +} + +fn wait_for_socket(path: &Path, timeout: Duration) { + let deadline = Instant::now() + timeout; + while Instant::now() < deadline { + if path.exists() && UnixStream::connect(path).is_ok() { + return; + } + thread::sleep(Duration::from_millis(25)); + } + panic!("socket did not appear at {}", path.display()); +} + +fn test_lock() -> MutexGuard<'static, ()> { + static LOCK: OnceLock<Mutex<()>> = OnceLock::new(); + LOCK.get_or_init(|| Mutex::new(())) + .lock() + .unwrap_or_else(|poisoned| poisoned.into_inner()) +} + +fn spawn_server( + config_home: &Path, + runtime_dir: &Path, + api_socket_path: &Path, + _client_socket_path: &Path, +) -> SpawnedHerdr { + fs::create_dir_all(config_home.join("herdr")).unwrap(); + fs::create_dir_all(runtime_dir).unwrap(); + register_runtime_dir(runtime_dir); + fs::write( + config_home.join("herdr/config.toml"), + "onboarding = false\n", + ) + .unwrap(); + + let pair = native_pty_system() + .openpty(PtySize { + rows: 24, + cols: 80, + pixel_width: 0, + pixel_height: 0, + }) + .unwrap(); + + let mut cmd = CommandBuilder::new(env!("CARGO_BIN_EXE_herdr")); + cmd.arg("server"); + cmd.env("XDG_CONFIG_HOME", config_home); + cmd.env("XDG_RUNTIME_DIR", runtime_dir); + cmd.env("HERDR_SOCKET_PATH", api_socket_path); + cmd.env_remove("HERDR_CLIENT_SOCKET_PATH"); + cmd.env("SHELL", "/bin/sh"); + cmd.env_remove("HERDR_ENV"); + + let child = pair.slave.spawn_command(cmd).unwrap(); + register_spawned_herdr_pid(child.process_id()); + drop(pair.slave); + + SpawnedHerdr { + _master: pair.master, + child, + } +} + +/// Spawn `herdr` (no subcommand) — the auto-detect launch path. +fn spawn_herdr_auto( + config_home: &Path, + runtime_dir: &Path, + api_socket_path: &Path, + _client_socket_path: &Path, +) -> SpawnedHerdr { + fs::create_dir_all(config_home.join("herdr")).unwrap(); + fs::create_dir_all(runtime_dir).unwrap(); + register_runtime_dir(runtime_dir); + fs::write( + config_home.join("herdr/config.toml"), + "onboarding = false\n", + ) + .unwrap(); + + let pair = native_pty_system() + .openpty(PtySize { + rows: 24, + cols: 80, + pixel_width: 0, + pixel_height: 0, + }) + .unwrap(); + + let mut cmd = CommandBuilder::new(env!("CARGO_BIN_EXE_herdr")); + // No subcommand, no --no-session → auto-detect launch + cmd.env("XDG_CONFIG_HOME", config_home); + cmd.env("XDG_RUNTIME_DIR", runtime_dir); + cmd.env("HERDR_SOCKET_PATH", api_socket_path); + cmd.env_remove("HERDR_CLIENT_SOCKET_PATH"); + cmd.env("SHELL", "/bin/sh"); + cmd.env_remove("HERDR_ENV"); + + let child = pair.slave.spawn_command(cmd).unwrap(); + register_spawned_herdr_pid(child.process_id()); + drop(pair.slave); + + SpawnedHerdr { + _master: pair.master, + child, + } +} + +/// Spawn `herdr --no-session` — the monolithic escape hatch. +fn spawn_herdr_no_session( + config_home: &Path, + runtime_dir: &Path, + api_socket_path: &Path, +) -> SpawnedHerdr { + fs::create_dir_all(config_home.join("herdr")).unwrap(); + fs::create_dir_all(runtime_dir).unwrap(); + register_runtime_dir(runtime_dir); + fs::write( + config_home.join("herdr/config.toml"), + "onboarding = false\n", + ) + .unwrap(); + + let pair = native_pty_system() + .openpty(PtySize { + rows: 24, + cols: 80, + pixel_width: 0, + pixel_height: 0, + }) + .unwrap(); + + let mut cmd = CommandBuilder::new(env!("CARGO_BIN_EXE_herdr")); + cmd.arg("--no-session"); + cmd.env("XDG_CONFIG_HOME", config_home); + cmd.env("XDG_RUNTIME_DIR", runtime_dir); + cmd.env("HERDR_SOCKET_PATH", api_socket_path); + cmd.env("SHELL", "/bin/sh"); + cmd.env_remove("HERDR_ENV"); + + let child = pair.slave.spawn_command(cmd).unwrap(); + register_spawned_herdr_pid(child.process_id()); + drop(pair.slave); + + SpawnedHerdr { + _master: pair.master, + child, + } +} + +fn ping_socket(socket_path: &Path) -> String { + let mut stream = UnixStream::connect(socket_path).expect("should connect to API socket"); + + let request = r#"{"id":"1","method":"ping","params":{}}"#; + writeln!(stream, "{}", request).unwrap(); + + let mut reader = BufReader::new(stream); + let mut response = String::new(); + reader.read_line(&mut response).unwrap(); + response.trim().to_string() +} + +fn run_cli(socket_path: &Path, args: &[&str]) -> std::process::Output { + let mut command = Command::new(env!("CARGO_BIN_EXE_herdr")); + command.args(args); + command.env("HERDR_SOCKET_PATH", socket_path); + command.output().unwrap() +} + +fn process_exists(pid: u32) -> bool { + let result = unsafe { libc::kill(pid as i32, 0) }; + if result == 0 { + true + } else { + std::io::Error::last_os_error().raw_os_error() == Some(libc::EPERM) + } +} + +fn read_json_line(stream: UnixStream) -> Value { + let mut reader = BufReader::new(stream); + let mut response = String::new(); + reader.read_line(&mut response).unwrap(); + serde_json::from_str(&response).unwrap() +} + +fn wait_for_pid_exit(pid: u32, timeout: Duration) -> bool { + let deadline = Instant::now() + timeout; + while Instant::now() < deadline { + if !process_exists(pid) { + return true; + } + thread::sleep(Duration::from_millis(20)); + } + false +} + +// --------------------------------------------------------------------------- +// Tests +// --------------------------------------------------------------------------- + +/// Running `herdr` with no server present starts a server +/// and attaches as client. +#[test] +fn auto_detect_no_server_spawns_server_and_attaches() { + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + // Ensure no server is running initially. + assert!( + !api_socket.exists(), + "api socket should not exist initially" + ); + assert!( + !client_socket.exists(), + "client socket should not exist initially" + ); + + // Run `herdr` (no subcommand) — should auto-detect, spawn server, attach as client. + let herdr = spawn_herdr_auto(&config_home, &runtime_dir, &api_socket, &client_socket); + + // Wait for both sockets to appear (server was spawned). + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_socket(&client_socket, Duration::from_secs(10)); + + // Verify the API socket responds to ping (server is running). + let response = ping_socket(&api_socket); + assert!( + response.contains("pong"), + "API socket should respond to ping: {response}" + ); + + // Verify the client socket accepts connections (server is listening on it). + let _stream = UnixStream::connect(&client_socket) + .expect("should connect to client socket (server is listening)"); + + // Verify the client process is running. + let client_pid = herdr.child.process_id().expect("client should have PID"); + assert!( + process_exists(client_pid), + "client process should be running" + ); + + cleanup_spawned_herdr(herdr, base); +} + +/// Running `herdr` with a server already running attaches +/// as client directly (no second server). +#[test] +fn auto_detect_server_running_attaches_directly() { + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + // Start a server explicitly. + let server = spawn_server(&config_home, &runtime_dir, &api_socket, &client_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_socket(&client_socket, Duration::from_secs(10)); + + let server_pid = server.child.process_id().expect("server should have PID"); + + // Verify server is running. + assert!(process_exists(server_pid), "server should be running"); + + // Run `herdr` (no subcommand) — should detect the running server and attach. + let client = spawn_herdr_auto(&config_home, &runtime_dir, &api_socket, &client_socket); + + // Wait a moment for the client to attach. + thread::sleep(Duration::from_millis(500)); + + // Verify the client is running. + let client_pid = client.child.process_id().expect("client should have PID"); + assert!( + process_exists(client_pid), + "client process should be running" + ); + + // Verify the server is still the same one (no second server spawned). + assert!( + process_exists(server_pid), + "original server should still be running" + ); + + // Verify API still responds. + let response = ping_socket(&api_socket); + assert!( + response.contains("pong"), + "API should still respond to ping: {response}" + ); + + cleanup_spawned_herdr(client, PathBuf::from("/nonexistent")); + cleanup_spawned_herdr(server, base); +} + +/// Socket path resolution is consistent between server and client. +/// Both derive the client socket from the `HERDR_SOCKET_PATH` override, +/// so overriding the API socket keeps both endpoints aligned. +#[test] +fn auto_detect_socket_path_consistency() { + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + // Run `herdr` with custom socket paths. + let herdr = spawn_herdr_auto(&config_home, &runtime_dir, &api_socket, &client_socket); + + // Wait for both sockets to appear at the custom paths. + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_socket(&client_socket, Duration::from_secs(10)); + + // Verify sockets exist at the specified paths. + assert!( + api_socket.exists(), + "API socket should exist at custom path" + ); + assert!( + client_socket.exists(), + "client socket should exist at custom path" + ); + + // Verify API responds (server is using the custom API socket path). + let response = ping_socket(&api_socket); + assert!( + response.contains("pong"), + "API should respond at custom path: {response}" + ); + + // Verify client socket accepts connections (server is using the custom + // client socket path). + let _stream = UnixStream::connect(&client_socket) + .expect("should connect to client socket at custom path"); + + cleanup_spawned_herdr(herdr, base); +} + +/// `herdr --no-session` bypasses server/client and runs +/// monolithically. No server process is spawned. No client socket is created. +#[test] +fn no_session_flag_runs_monolithically() { + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + // Run `herdr --no-session` — monolithic mode, no server/client. + let herdr = spawn_herdr_no_session(&config_home, &runtime_dir, &api_socket); + + // Wait for the API socket (monolithic mode creates it). + wait_for_socket(&api_socket, Duration::from_secs(10)); + + // Verify the API socket exists and responds. + let response = ping_socket(&api_socket); + assert!( + response.contains("pong"), + "monolithic API should respond: {response}" + ); + + // Verify NO client socket was created — this is the key distinction + // between monolithic mode and server/client mode. + assert!( + !client_socket.exists(), + "no client socket should exist in monolithic mode" + ); + + // Verify the API socket is served by the monolithic process itself, + // not by a separate server. We can check this by verifying the client + // PID matches what would be serving the socket — in monolithic mode, + // there is only one herdr process. + let client_pid = herdr.child.process_id().expect("should have PID"); + assert!( + process_exists(client_pid), + "monolithic process should be running" + ); + + cleanup_spawned_herdr(herdr, base); +} + +/// CLI subcommands work through the server's JSON API socket. +#[test] +fn cli_subcommands_work_through_server() { + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + // Start a server. + let server = spawn_server(&config_home, &runtime_dir, &api_socket, &client_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_socket(&client_socket, Duration::from_secs(10)); + + // Test `herdr workspace list` through the server's API socket. + let output = run_cli(&api_socket, &["workspace", "list"]); + let stdout = String::from_utf8_lossy(&output.stdout); + assert!( + output.status.success(), + "workspace list should succeed: stderr={}", + String::from_utf8_lossy(&output.stderr) + ); + // The response should be valid JSON with a "result" field. + assert!( + stdout.contains("result"), + "workspace list output should contain 'result': {stdout}" + ); + + // Test `herdr pane list` through the server's API socket. + let output = run_cli(&api_socket, &["pane", "list"]); + let stdout = String::from_utf8_lossy(&output.stdout); + assert!( + output.status.success(), + "pane list should succeed: stderr={}", + String::from_utf8_lossy(&output.stderr) + ); + assert!( + stdout.contains("result"), + "pane list output should contain 'result': {stdout}" + ); + + cleanup_spawned_herdr(server, base); +} + +/// Verify that the server spawned by auto-detect +/// persists after the client exits, and a new `herdr` can reattach. +#[test] +fn auto_detect_server_persists_and_reattaches() { + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + // Run `herdr` — auto-detect spawns server + attaches client. + let mut client1 = spawn_herdr_auto(&config_home, &runtime_dir, &api_socket, &client_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_socket(&client_socket, Duration::from_secs(10)); + + // Verify API responds. + let response = ping_socket(&api_socket); + assert!( + response.contains("pong"), + "API should respond before client exit: {response}" + ); + + // Kill the first client. + let client1_pid = client1.child.process_id().expect("client1 should have PID"); + let _ = client1.child.kill(); + let _ = wait_for_pid_exit(client1_pid, Duration::from_secs(2)); + drop(client1); + + // Wait a moment for the server to process the disconnect. + thread::sleep(Duration::from_millis(500)); + + // Verify server is still running after client exit — the API should + // still respond because the server is a separate daemon process. + let response = ping_socket(&api_socket); + assert!( + response.contains("pong"), + "API should still respond after client exit (server persists): {response}" + ); + + // The client socket should still exist (server is still listening). + assert!( + client_socket.exists(), + "client socket should still exist after client exit" + ); + + // Run `herdr` again — should detect the running server and reattach. + let client2 = spawn_herdr_auto(&config_home, &runtime_dir, &api_socket, &client_socket); + thread::sleep(Duration::from_millis(500)); + + // Verify the new client is running. + let client2_pid = client2.child.process_id().expect("client2 should have PID"); + assert!( + process_exists(client2_pid), + "second client should be running" + ); + + // Verify API still responds (same server). + let response = ping_socket(&api_socket); + assert!( + response.contains("pong"), + "API should still respond after reattach: {response}" + ); + + cleanup_spawned_herdr(client2, PathBuf::from("/nonexistent")); + cleanup_test_base(&base); +} + +/// Verify that the default API and client +/// sockets live in the app config directory when no env override is set. +#[test] +fn auto_detect_default_socket_path_from_config_dir() { + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + + // Don't set HERDR_SOCKET_PATH or HERDR_CLIENT_SOCKET_PATH. + // The default paths should come from the app config directory, not XDG_RUNTIME_DIR. + let app_dir_name = if cfg!(debug_assertions) { + "herdr-dev" + } else { + "herdr" + }; + let api_socket = config_home.join(app_dir_name).join("herdr.sock"); + let client_socket = config_home.join(app_dir_name).join("herdr-client.sock"); + + // Spawn server with XDG_RUNTIME_DIR set to a different directory to prove it is ignored. + fs::create_dir_all(config_home.join(app_dir_name)).unwrap(); + fs::create_dir_all(&runtime_dir).unwrap(); + register_runtime_dir(&runtime_dir); + fs::write( + config_home.join(app_dir_name).join("config.toml"), + "onboarding = false\n", + ) + .unwrap(); + + let pair = native_pty_system() + .openpty(PtySize { + rows: 24, + cols: 80, + pixel_width: 0, + pixel_height: 0, + }) + .unwrap(); + + let mut cmd = CommandBuilder::new(env!("CARGO_BIN_EXE_herdr")); + cmd.arg("server"); + cmd.env("XDG_CONFIG_HOME", &config_home); + cmd.env("XDG_RUNTIME_DIR", &runtime_dir); + cmd.env("SHELL", "/bin/sh"); + cmd.env_remove("HERDR_ENV"); + // Explicitly remove socket overrides to test default path resolution. + cmd.env_remove("HERDR_SOCKET_PATH"); + cmd.env_remove("HERDR_CLIENT_SOCKET_PATH"); + + let child = pair.slave.spawn_command(cmd).unwrap(); + register_spawned_herdr_pid(child.process_id()); + drop(pair.slave); + let server = SpawnedHerdr { + _master: pair.master, + child, + }; + + // Wait for sockets to appear at the default config-dir paths. + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_socket(&client_socket, Duration::from_secs(10)); + + // Verify both sockets exist. + assert!(api_socket.exists(), "API socket should exist in config dir"); + assert!( + client_socket.exists(), + "client socket should exist in config dir" + ); + + // Verify API responds. + let response = ping_socket(&api_socket); + assert!( + response.contains("pong"), + "API should respond at config-dir path: {response}" + ); + + cleanup_spawned_herdr(server, base); +} + +#[test] +fn auto_detect_respects_nested_guard_before_auto_attach() { + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + let server = spawn_server(&config_home, &runtime_dir, &api_socket, &client_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_socket(&client_socket, Duration::from_secs(10)); + + let baseline = read_json_line({ + let mut stream = UnixStream::connect(&api_socket).unwrap(); + writeln!( + stream, + r#"{{"id":"ws_before","method":"workspace.list","params":{{}}}}"# + ) + .unwrap(); + stream + }); + let baseline_count = baseline["result"]["workspaces"] + .as_array() + .map(|workspaces| workspaces.len()) + .unwrap_or(0); + + let output = Command::new(env!("CARGO_BIN_EXE_herdr")) + .env("XDG_CONFIG_HOME", &config_home) + .env("XDG_RUNTIME_DIR", &runtime_dir) + .env("HERDR_SOCKET_PATH", &api_socket) + .env_remove("HERDR_CLIENT_SOCKET_PATH") + .env("HERDR_ENV", "1") + .output() + .unwrap(); + + assert!( + !output.status.success(), + "nested launch should fail before auto-attach" + ); + let stderr = String::from_utf8_lossy(&output.stderr); + assert!( + stderr.contains("nested herdr is disabled by default"), + "stderr should mention nested-launch guard: {stderr}" + ); + + let after = read_json_line({ + let mut stream = UnixStream::connect(&api_socket).unwrap(); + writeln!( + stream, + r#"{{"id":"ws_after","method":"workspace.list","params":{{}}}}"# + ) + .unwrap(); + stream + }); + let after_count = after["result"]["workspaces"] + .as_array() + .map(|workspaces| workspaces.len()) + .unwrap_or(0); + assert_eq!( + after_count, baseline_count, + "nested launch should not auto-attach or mutate server state" + ); + + cleanup_spawned_herdr(server, base); +} diff --git a/tests/cli_wrapper.rs b/tests/cli_wrapper.rs index 8c8574d3..92684bff 100644 --- a/tests/cli_wrapper.rs +++ b/tests/cli_wrapper.rs @@ -1,5 +1,7 @@ #![cfg(not(target_os = "macos"))] +mod support; + use std::fs; use std::io::{BufRead, BufReader, Write}; use std::os::unix::net::{UnixListener, UnixStream}; @@ -9,6 +11,10 @@ use std::thread; use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH}; use portable_pty::{native_pty_system, Child, CommandBuilder, MasterPty, PtySize}; +use support::{ + cleanup_test_base, register_runtime_dir, register_spawned_herdr_pid, + unregister_spawned_herdr_pid, +}; fn unique_test_dir() -> PathBuf { let nanos = SystemTime::now() @@ -23,24 +29,31 @@ struct SpawnedHerdr { child: Box<dyn Child + Send + Sync>, } -fn cleanup_spawned_herdr(mut spawned: SpawnedHerdr, base: PathBuf) { - let pid = spawned.child.process_id(); - let _ = spawned.child.kill(); - - if let Some(pid) = pid { - let deadline = Instant::now() + Duration::from_secs(2); - while Instant::now() < deadline { - let mut status = 0; - let result = unsafe { libc::waitpid(pid as libc::pid_t, &mut status, libc::WNOHANG) }; - if result == pid as libc::pid_t || result == -1 { - break; +impl Drop for SpawnedHerdr { + fn drop(&mut self) { + let pid = self.child.process_id(); + let _ = self.child.kill(); + + if let Some(pid) = pid { + let deadline = Instant::now() + Duration::from_secs(2); + while Instant::now() < deadline { + let mut status = 0; + let result = + unsafe { libc::waitpid(pid as libc::pid_t, &mut status, libc::WNOHANG) }; + if result == pid as libc::pid_t || result == -1 { + break; + } + thread::sleep(Duration::from_millis(20)); } - thread::sleep(Duration::from_millis(20)); + + unregister_spawned_herdr_pid(Some(pid)); } } +} +fn cleanup_spawned_herdr(spawned: SpawnedHerdr, base: PathBuf) { drop(spawned); - let _ = fs::remove_dir_all(base); + cleanup_test_base(&base); } fn wait_for_socket(path: &Path, timeout: Duration) { @@ -66,6 +79,7 @@ fn spawn_herdr_with_path( ) -> SpawnedHerdr { fs::create_dir_all(config_home.join("herdr")).unwrap(); fs::create_dir_all(runtime_dir).unwrap(); + register_runtime_dir(runtime_dir); fs::write( config_home.join("herdr/config.toml"), "onboarding = false\n", @@ -82,10 +96,11 @@ fn spawn_herdr_with_path( .unwrap(); let mut cmd = CommandBuilder::new(env!("CARGO_BIN_EXE_herdr")); - cmd.arg("--no-session"); + cmd.arg("server"); cmd.env("XDG_CONFIG_HOME", config_home); cmd.env("XDG_RUNTIME_DIR", runtime_dir); cmd.env("HERDR_SOCKET_PATH", socket_path); + cmd.env_remove("HERDR_CLIENT_SOCKET_PATH"); cmd.env("SHELL", "/bin/sh"); cmd.env_remove("HERDR_ENV"); if let Some(path) = path_override { @@ -93,6 +108,7 @@ fn spawn_herdr_with_path( } let child = pair.slave.spawn_command(cmd).unwrap(); + register_spawned_herdr_pid(child.process_id()); SpawnedHerdr { _master: pair.master, child, @@ -106,6 +122,28 @@ fn run_cli(socket_path: &Path, args: &[&str]) -> std::process::Output { command.output().unwrap() } +fn run_cli_json(socket_path: &Path, args: &[&str]) -> serde_json::Value { + let output = run_cli(socket_path, args); + assert!( + output.status.success(), + "command failed: herdr {}\nstatus: {:?}\nstderr: {}\nstdout: {}", + args.join(" "), + output.status.code(), + String::from_utf8_lossy(&output.stderr), + String::from_utf8_lossy(&output.stdout) + ); + + serde_json::from_slice(&output.stdout).unwrap_or_else(|err| { + panic!( + "failed to parse JSON response for `herdr {}`: {}\nstdout: {}\nstderr: {}", + args.join(" "), + err, + String::from_utf8_lossy(&output.stdout), + String::from_utf8_lossy(&output.stderr) + ) + }) +} + fn process_exists(pid: u32) -> bool { let result = unsafe { libc::kill(pid as i32, 0) }; if result == 0 { @@ -126,6 +164,118 @@ fn wait_for_pid_exit(pid: u32, timeout: Duration) -> bool { !process_exists(pid) } +fn wait_for_pid_file(pid_file: &Path, timeout: Duration) -> Result<u32, String> { + const STABLE_PID_CONTENT_WINDOW: Duration = Duration::from_millis(250); + + let deadline = Instant::now() + timeout; + let mut last_contents = String::new(); + let mut stable_candidate: Option<(String, u32, Instant)> = None; + + while Instant::now() < deadline { + if let Ok(contents) = fs::read_to_string(pid_file) { + let trimmed = contents.trim().to_string(); + last_contents = contents; + + if let Ok(pid) = trimmed.parse::<u32>() { + match &stable_candidate { + Some((candidate_text, candidate_pid, stable_since)) + if candidate_text == &trimmed && *candidate_pid == pid => + { + if stable_since.elapsed() >= STABLE_PID_CONTENT_WINDOW { + return Ok(pid); + } + } + _ => { + stable_candidate = Some((trimmed, pid, Instant::now())); + } + } + } else { + stable_candidate = None; + } + } + + thread::sleep(Duration::from_millis(25)); + } + + Err(format!( + "pid file {} did not contain stable parseable pid before timeout; last contents={:?}", + pid_file.display(), + last_contents + )) +} + +#[test] +fn wait_for_pid_file_retries_until_pid_is_written() { + let base = unique_test_dir(); + fs::create_dir_all(&base).unwrap(); + let pid_file = base.join("delayed.pid"); + fs::write(&pid_file, "").unwrap(); + + let writer = thread::spawn({ + let pid_file = pid_file.clone(); + move || { + thread::sleep(Duration::from_millis(100)); + fs::write(pid_file, "424242\n").unwrap(); + } + }); + + let pid = wait_for_pid_file(&pid_file, Duration::from_secs(2)).unwrap(); + assert_eq!(pid, 424242); + + writer.join().unwrap(); + cleanup_test_base(&base); +} + +#[test] +fn wait_for_pid_file_errors_when_file_never_contains_pid() { + let base = unique_test_dir(); + fs::create_dir_all(&base).unwrap(); + let pid_file = base.join("empty.pid"); + fs::write(&pid_file, "").unwrap(); + + let err = wait_for_pid_file(&pid_file, Duration::from_millis(150)).unwrap_err(); + assert!( + err.contains("did not contain stable parseable pid"), + "unexpected error: {err}" + ); + + cleanup_test_base(&base); +} + +#[test] +fn wait_for_pid_file_rejects_partial_write_race_until_stable_contents() { + let base = unique_test_dir(); + fs::create_dir_all(&base).unwrap(); + let pid_file = base.join("partial-race.pid"); + fs::write(&pid_file, "").unwrap(); + + let writer = thread::spawn({ + let pid_file = pid_file.clone(); + move || { + thread::sleep(Duration::from_millis(40)); + fs::write(&pid_file, "12").unwrap(); + thread::sleep(Duration::from_millis(40)); + fs::write(&pid_file, "123").unwrap(); + thread::sleep(Duration::from_millis(40)); + fs::write(&pid_file, "1234").unwrap(); + thread::sleep(Duration::from_millis(200)); + fs::write(&pid_file, "424242\n").unwrap(); + } + }); + + let start = Instant::now(); + let pid = wait_for_pid_file(&pid_file, Duration::from_secs(2)).unwrap(); + assert_eq!(pid, 424242); + assert!( + start.elapsed() >= Duration::from_millis(300), + "helper should wait for stable complete contents, elapsed={:?}", + start.elapsed() + ); + + writer.join().unwrap(); + cleanup_test_base(&base); +} + fn send_request(socket_path: &Path, json: &str) -> serde_json::Value { let mut stream = UnixStream::connect(socket_path).unwrap(); stream.write_all(json.as_bytes()).unwrap(); @@ -205,7 +355,106 @@ fn pane_run_sends_one_send_input_request_with_enter_key() { second_line ); - fs::remove_dir_all(base).unwrap(); + cleanup_test_base(&base); +} + +#[test] +fn integration_commands_honor_socket_override_when_server_is_missing() { + let base = unique_test_dir(); + let home_dir = base.join("home"); + let extensions_dir = home_dir.join(".pi/agent/extensions"); + fs::create_dir_all(&extensions_dir).unwrap(); + + let runtime_dir = base.join("runtime"); + fs::create_dir_all(&runtime_dir).unwrap(); + register_runtime_dir(&runtime_dir); + let missing_socket = runtime_dir.join("missing.sock"); + + let expected_extension = extensions_dir.join("herdr-agent-state.ts"); + assert!( + !expected_extension.exists(), + "test setup should start without extension file" + ); + + let workspace_list = Command::new(env!("CARGO_BIN_EXE_herdr")) + .args(["workspace", "list"]) + .env("HERDR_SOCKET_PATH", &missing_socket) + .env("HOME", &home_dir) + .output() + .unwrap(); + assert_eq!(workspace_list.status.code(), Some(1)); + + let integration_install = Command::new(env!("CARGO_BIN_EXE_herdr")) + .args(["integration", "install", "pi"]) + .env("HERDR_SOCKET_PATH", &missing_socket) + .env("HOME", &home_dir) + .output() + .unwrap(); + assert_eq!(integration_install.status.code(), Some(1)); + assert!( + !expected_extension.exists(), + "integration install should not run local install logic when socket is missing" + ); + + let integration_uninstall = Command::new(env!("CARGO_BIN_EXE_herdr")) + .args(["integration", "uninstall", "pi"]) + .env("HERDR_SOCKET_PATH", &missing_socket) + .env("HOME", &home_dir) + .output() + .unwrap(); + assert_eq!(integration_uninstall.status.code(), Some(1)); + assert!( + !expected_extension.exists(), + "integration uninstall should also be socket-backed when socket is missing" + ); + + cleanup_test_base(&base); +} + +#[test] +fn server_stop_command_shuts_down_running_server() { + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let socket_path = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + let mut herdr = spawn_herdr(&config_home, &runtime_dir, &socket_path); + wait_for_socket(&socket_path, Duration::from_secs(5)); + wait_for_socket(&client_socket, Duration::from_secs(5)); + + let stopped = run_cli(&socket_path, &["server", "stop"]); + assert!( + stopped.status.success(), + "stderr: {}", + String::from_utf8_lossy(&stopped.stderr) + ); + assert!( + stopped.stdout.is_empty(), + "server stop should not print stdout: {}", + String::from_utf8_lossy(&stopped.stdout) + ); + + let pid = herdr.child.process_id(); + let exit_status = herdr.child.wait().unwrap(); + unregister_spawned_herdr_pid(pid); + assert!(exit_status.success(), "server stop should exit cleanly"); + + let deadline = Instant::now() + Duration::from_secs(3); + while Instant::now() < deadline && (socket_path.exists() || client_socket.exists()) { + thread::sleep(Duration::from_millis(25)); + } + + assert!( + !socket_path.exists() || UnixStream::connect(&socket_path).is_err(), + "api socket should be removed or stale after server stop" + ); + assert!( + !client_socket.exists() || UnixStream::connect(&client_socket).is_err(), + "client socket should be removed or stale after server stop" + ); + + cleanup_spawned_herdr(herdr, base); } #[test] @@ -636,11 +885,9 @@ fn closing_pane_terminates_processes_inside_it() { } assert!(pid_file.exists(), "pid file was not created"); - let pid: u32 = fs::read_to_string(&pid_file) - .unwrap() - .trim() - .parse() - .unwrap(); + let pid = wait_for_pid_file(&pid_file, Duration::from_secs(3)).unwrap_or_else(|err| { + panic!("failed to read pane child pid: {err}"); + }); assert!(process_exists(pid), "child process was not running"); let closed = run_cli(&socket_path, &["pane", "close", pane_id]); @@ -691,11 +938,9 @@ fn closing_workspace_terminates_processes_inside_it() { } assert!(pid_file.exists(), "pid file was not created"); - let pid: u32 = fs::read_to_string(&pid_file) - .unwrap() - .trim() - .parse() - .unwrap(); + let pid = wait_for_pid_file(&pid_file, Duration::from_secs(3)).unwrap_or_else(|err| { + panic!("failed to read pane child pid: {err}"); + }); assert!(process_exists(pid), "child process was not running"); let closed = run_cli(&socket_path, &["workspace", "close", "1"]); @@ -722,42 +967,37 @@ fn workspace_ids_are_stable_and_pane_numbers_stay_compact() { let herdr = spawn_herdr(&config_home, &runtime_dir, &socket_path); wait_for_socket(&socket_path, Duration::from_secs(5)); - let ws1 = run_cli( + let ws1_json = run_cli_json( &socket_path, &["workspace", "create", "--cwd", base.to_str().unwrap()], ); - assert!(ws1.status.success()); - let ws1_json: serde_json::Value = serde_json::from_slice(&ws1.stdout).unwrap(); let ws1_id = ws1_json["result"]["workspace"]["workspace_id"] .as_str() .unwrap() .to_string(); - let split_12 = run_cli( + let split_12_json = run_cli_json( &socket_path, &["pane", "split", "1-1", "--direction", "right", "--no-focus"], ); - let split_12_json: serde_json::Value = serde_json::from_slice(&split_12.stdout).unwrap(); assert_eq!( split_12_json["result"]["pane"]["pane_id"], format!("{ws1_id}-2") ); - let split_13 = run_cli( + let split_13_json = run_cli_json( &socket_path, &["pane", "split", "1-1", "--direction", "down", "--no-focus"], ); - let split_13_json: serde_json::Value = serde_json::from_slice(&split_13.stdout).unwrap(); assert_eq!( split_13_json["result"]["pane"]["pane_id"], format!("{ws1_id}-3") ); - let ws2 = run_cli( + let ws2_json = run_cli_json( &socket_path, &["workspace", "create", "--cwd", "/tmp", "--no-focus"], ); - let ws2_json: serde_json::Value = serde_json::from_slice(&ws2.stdout).unwrap(); let ws2_id = ws2_json["result"]["workspace"]["workspace_id"] .as_str() .unwrap() @@ -765,22 +1005,25 @@ fn workspace_ids_are_stable_and_pane_numbers_stay_compact() { assert_ne!(ws2_id, ws1_id); let ws2_focus = run_cli(&socket_path, &["workspace", "focus", &ws2_id]); - assert!(ws2_focus.status.success()); - let ws2_split = run_cli( + assert!( + ws2_focus.status.success(), + "stderr: {}", + String::from_utf8_lossy(&ws2_focus.stderr) + ); + + let ws2_split_json = run_cli_json( &socket_path, &["pane", "split", "2-1", "--direction", "right", "--no-focus"], ); - let ws2_split_json: serde_json::Value = serde_json::from_slice(&ws2_split.stdout).unwrap(); assert_eq!( ws2_split_json["result"]["pane"]["pane_id"], format!("{ws2_id}-2") ); - let ws3 = run_cli( + let ws3_json = run_cli_json( &socket_path, &["workspace", "create", "--cwd", "/", "--no-focus"], ); - let ws3_json: serde_json::Value = serde_json::from_slice(&ws3.stdout).unwrap(); let ws3_id = ws3_json["result"]["workspace"]["workspace_id"] .as_str() .unwrap() @@ -789,10 +1032,13 @@ fn workspace_ids_are_stable_and_pane_numbers_stay_compact() { assert_ne!(ws3_id, ws2_id); let close_ws2 = run_cli(&socket_path, &["workspace", "close", &ws2_id]); - assert!(close_ws2.status.success()); + assert!( + close_ws2.status.success(), + "stderr: {}", + String::from_utf8_lossy(&close_ws2.stderr) + ); - let workspaces = run_cli(&socket_path, &["workspace", "list"]); - let workspaces_json: serde_json::Value = serde_json::from_slice(&workspaces.stdout).unwrap(); + let workspaces_json = run_cli_json(&socket_path, &["workspace", "list"]); let ids: Vec<String> = workspaces_json["result"]["workspaces"] .as_array() .unwrap() @@ -801,11 +1047,10 @@ fn workspace_ids_are_stable_and_pane_numbers_stay_compact() { .collect(); assert_eq!(ids, vec![ws1_id.clone(), ws3_id.clone()]); - let new_ws = run_cli( + let new_ws_json = run_cli_json( &socket_path, &["workspace", "create", "--cwd", "/var/tmp", "--no-focus"], ); - let new_ws_json: serde_json::Value = serde_json::from_slice(&new_ws.stdout).unwrap(); let new_ws_id = new_ws_json["result"]["workspace"]["workspace_id"] .as_str() .unwrap() @@ -814,17 +1059,20 @@ fn workspace_ids_are_stable_and_pane_numbers_stay_compact() { assert_ne!(new_ws_id, ws2_id); assert_ne!(new_ws_id, ws3_id); - let ws3_panes = run_cli(&socket_path, &["pane", "list", "--workspace", &ws3_id]); - let ws3_panes_json: serde_json::Value = serde_json::from_slice(&ws3_panes.stdout).unwrap(); + let ws3_panes_json = run_cli_json(&socket_path, &["pane", "list", "--workspace", &ws3_id]); assert_eq!( ws3_panes_json["result"]["panes"][0]["pane_id"], format!("{ws3_id}-1") ); let close_middle = run_cli(&socket_path, &["pane", "close", &format!("{ws1_id}-2")]); - assert!(close_middle.status.success()); - let ws1_panes = run_cli(&socket_path, &["pane", "list", "--workspace", &ws1_id]); - let ws1_panes_json: serde_json::Value = serde_json::from_slice(&ws1_panes.stdout).unwrap(); + assert!( + close_middle.status.success(), + "stderr: {}", + String::from_utf8_lossy(&close_middle.stderr) + ); + + let ws1_panes_json = run_cli_json(&socket_path, &["pane", "list", "--workspace", &ws1_id]); let pane_ids: Vec<String> = ws1_panes_json["result"]["panes"] .as_array() .unwrap() diff --git a/tests/client_mode.rs b/tests/client_mode.rs new file mode 100644 index 00000000..882bcb1c --- /dev/null +++ b/tests/client_mode.rs @@ -0,0 +1,1221 @@ +//! Integration tests for thin client mode. + +mod support; + +use std::fs; +use std::io::{BufRead, BufReader, Read, Write}; +use std::os::unix::net::UnixStream; +use std::path::PathBuf; +use std::sync::{Mutex, MutexGuard, OnceLock}; +use std::thread; +use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH}; + +use portable_pty::{native_pty_system, Child, CommandBuilder, MasterPty, PtySize}; +use support::{ + cleanup_test_base, register_runtime_dir, register_spawned_herdr_pid, + unregister_spawned_herdr_pid, +}; + +fn unique_test_dir() -> PathBuf { + let nanos = SystemTime::now() + .duration_since(UNIX_EPOCH) + .map(|d| d.as_nanos()) + .unwrap_or(0); + PathBuf::from(format!( + "/tmp/herdr-client-test-{}-{nanos}", + std::process::id() + )) +} + +struct SpawnedHerdr { + _master: Box<dyn MasterPty + Send>, + child: Box<dyn Child + Send + Sync>, +} + +impl Drop for SpawnedHerdr { + fn drop(&mut self) { + let pid = self.child.process_id(); + let _ = self.child.kill(); + + if let Some(pid) = pid { + let deadline = Instant::now() + Duration::from_secs(2); + while Instant::now() < deadline { + let mut status = 0; + let result = + unsafe { libc::waitpid(pid as libc::pid_t, &mut status, libc::WNOHANG) }; + if result == pid as libc::pid_t || result == -1 { + break; + } + thread::sleep(Duration::from_millis(20)); + } + + unregister_spawned_herdr_pid(Some(pid)); + } + } +} + +fn cleanup_spawned_herdr(spawned: SpawnedHerdr, base: PathBuf) { + drop(spawned); + cleanup_test_base(&base); +} + +fn test_lock() -> MutexGuard<'static, ()> { + static LOCK: OnceLock<Mutex<()>> = OnceLock::new(); + LOCK.get_or_init(|| Mutex::new(())) + .lock() + .unwrap_or_else(|poisoned| poisoned.into_inner()) +} + +fn wait_for_socket(path: &PathBuf, timeout: Duration) { + let deadline = Instant::now() + timeout; + while Instant::now() < deadline { + if path.exists() && UnixStream::connect(path).is_ok() { + return; + } + thread::sleep(Duration::from_millis(25)); + } + panic!("socket did not appear at {}", path.display()); +} + +fn wait_for_file(path: &PathBuf, timeout: Duration) { + let deadline = Instant::now() + timeout; + while Instant::now() < deadline { + if path.exists() { + return; + } + thread::sleep(Duration::from_millis(25)); + } + panic!("file did not appear at {}", path.display()); +} + +fn spawn_client_process( + config_home: &PathBuf, + runtime_dir: &PathBuf, + api_socket_path: &PathBuf, +) -> SpawnedHerdr { + register_runtime_dir(runtime_dir); + let pair = native_pty_system() + .openpty(PtySize { + rows: 24, + cols: 80, + pixel_width: 0, + pixel_height: 0, + }) + .unwrap(); + + let mut cmd = CommandBuilder::new(env!("CARGO_BIN_EXE_herdr")); + cmd.arg("client"); + cmd.env("XDG_CONFIG_HOME", config_home); + cmd.env("XDG_RUNTIME_DIR", runtime_dir); + cmd.env("HERDR_SOCKET_PATH", api_socket_path); + cmd.env_remove("HERDR_CLIENT_SOCKET_PATH"); + cmd.env("SHELL", "/bin/sh"); + cmd.env_remove("HERDR_ENV"); + + let child = pair.slave.spawn_command(cmd).unwrap(); + register_spawned_herdr_pid(child.process_id()); + drop(pair.slave); + + SpawnedHerdr { + _master: pair.master, + child, + } +} + +fn spawn_server( + config_home: &PathBuf, + runtime_dir: &PathBuf, + api_socket_path: &PathBuf, + _client_socket_path: &PathBuf, +) -> SpawnedHerdr { + fs::create_dir_all(config_home.join("herdr")).unwrap(); + fs::create_dir_all(runtime_dir).unwrap(); + register_runtime_dir(runtime_dir); + fs::write( + config_home.join("herdr/config.toml"), + "onboarding = false\n", + ) + .unwrap(); + + let pair = native_pty_system() + .openpty(PtySize { + rows: 24, + cols: 80, + pixel_width: 0, + pixel_height: 0, + }) + .unwrap(); + + let mut cmd = CommandBuilder::new(env!("CARGO_BIN_EXE_herdr")); + cmd.arg("server"); + cmd.env("XDG_CONFIG_HOME", config_home); + cmd.env("XDG_RUNTIME_DIR", runtime_dir); + cmd.env("HERDR_SOCKET_PATH", api_socket_path); + cmd.env_remove("HERDR_CLIENT_SOCKET_PATH"); + cmd.env("SHELL", "/bin/sh"); + cmd.env_remove("HERDR_ENV"); + + let child = pair.slave.spawn_command(cmd).unwrap(); + register_spawned_herdr_pid(child.process_id()); + drop(pair.slave); + + SpawnedHerdr { + _master: pair.master, + child, + } +} + +fn ping_socket(socket_path: &PathBuf) -> String { + let mut stream = UnixStream::connect(socket_path).expect("should connect to API socket"); + + let request = r#"{"id":"1","method":"ping","params":{}}"#; + writeln!(stream, "{}", request).unwrap(); + + let mut reader = BufReader::new(stream); + let mut response = String::new(); + reader.read_line(&mut response).unwrap(); + response.trim().to_string() +} + +// --------------------------------------------------------------------------- +// Bincode v2 varint encoding helpers (same as server_headless.rs tests) +// --------------------------------------------------------------------------- + +/// Encode a varint u32 value according to bincode v2 VarintEncoding. +fn encode_varint_u32(v: u32) -> Vec<u8> { + if v < 251 { + vec![v as u8] + } else if v < 65536 { + let mut buf = vec![251u8]; + buf.extend_from_slice(&(v as u16).to_le_bytes()); + buf + } else { + let mut buf = vec![252u8]; + buf.extend_from_slice(&v.to_le_bytes()); + buf + } +} + +/// Encode a varint u16 value. +fn encode_varint_u16(v: u16) -> Vec<u8> { + if v < 251 { + vec![v as u8] + } else { + let mut buf = vec![251u8]; + buf.extend_from_slice(&v.to_le_bytes()); + buf + } +} + +/// Encode an enum variant with its fields. +fn encode_varint_enum(variant_idx: u32, fields: &[&[u8]]) -> Vec<u8> { + let mut buf = encode_varint_u32(variant_idx); + for field in fields { + buf.extend_from_slice(field); + } + buf +} + +/// Frame a message with u32LE length prefix. +fn frame_message(payload: &[u8]) -> Vec<u8> { + let len = payload.len() as u32; + let mut framed = len.to_le_bytes().to_vec(); + framed.extend_from_slice(payload); + framed +} + +/// Decode a varint u32 from a byte slice at the given offset. +fn decode_varint_u32(payload: &[u8], offset: usize) -> Result<(u32, usize), String> { + if offset >= payload.len() { + return Err("payload too short for varint".into()); + } + let first_byte = payload[offset]; + match first_byte { + 0..=250 => Ok((first_byte as u32, 1)), + 251 => { + if offset + 3 > payload.len() { + return Err("payload too short for u16 varint".into()); + } + let v = u16::from_le_bytes( + payload[offset + 1..offset + 3] + .try_into() + .map_err(|e: std::array::TryFromSliceError| e.to_string())?, + ); + Ok((v as u32, 3)) + } + 252 => { + if offset + 5 > payload.len() { + return Err("payload too short for u32 varint".into()); + } + let v = u32::from_le_bytes( + payload[offset + 1..offset + 5] + .try_into() + .map_err(|e: std::array::TryFromSliceError| e.to_string())?, + ); + Ok((v, 5)) + } + _ => Err(format!("unsupported varint tag: {first_byte}")), + } +} + +/// Sends a Hello message over the client socket and reads the Welcome response. +fn client_handshake( + stream: &mut UnixStream, + version: u32, + cols: u16, + rows: u16, +) -> Result<(u32, Option<String>), String> { + stream + .set_read_timeout(Some(Duration::from_secs(5))) + .map_err(|e| e.to_string())?; + + // Encode Hello message using bincode v2 varint format. + // ClientMessage::Hello is variant 0. + let hello_payload = encode_varint_enum( + 0, + &[ + &encode_varint_u32(version), + &encode_varint_u16(cols), + &encode_varint_u16(rows), + ], + ); + let framed = frame_message(&hello_payload); + stream.write_all(&framed).map_err(|e| e.to_string())?; + stream.flush().map_err(|e| e.to_string())?; + + // Read the framed response. + let mut len_buf = [0u8; 4]; + stream.read_exact(&mut len_buf).map_err(|e| e.to_string())?; + let len = u32::from_le_bytes(len_buf) as usize; + + if len > 2 * 1024 * 1024 { + return Err(format!("oversized response: {len}")); + } + + let mut payload = vec![0u8; len]; + stream.read_exact(&mut payload).map_err(|e| e.to_string())?; + + // Decode Welcome: ServerMessage variant 0 = Welcome { version: u32, error: Option<String> } + decode_welcome(&payload) +} + +/// Decode a ServerMessage::Welcome from bincode v2 payload. +fn decode_welcome(payload: &[u8]) -> Result<(u32, Option<String>), String> { + let mut offset = 0; + + // Variant index (should be 0 for Welcome) + let (variant, consumed) = decode_varint_u32(payload, offset)?; + offset += consumed; + if variant != 0 { + return Err(format!( + "expected Welcome (variant 0), got variant {variant}" + )); + } + + // version: u32 + let (version, consumed) = decode_varint_u32(payload, offset)?; + offset += consumed; + + // error: Option<String> — discriminant is always 1 byte + if offset >= payload.len() { + return Err("payload too short for Option tag".into()); + } + let option_tag = payload[offset]; + offset += 1; + + let error = if option_tag == 1 { + // Some(String) — length as varint + UTF-8 bytes + let (str_len, consumed) = decode_varint_u32(payload, offset)?; + offset += consumed; + let str_len = str_len as usize; + + if offset + str_len > payload.len() { + return Err("payload too short for string content".into()); + } + let s = String::from_utf8(payload[offset..offset + str_len].to_vec()) + .map_err(|e| e.to_string())?; + Some(s) + } else { + None + }; + + Ok((version, error)) +} + +/// Read a framed ServerMessage from the stream, returning the variant index +/// and the raw payload for further decoding. +fn read_server_message(stream: &mut UnixStream) -> Result<(u32, Vec<u8>), String> { + stream + .set_read_timeout(Some(Duration::from_secs(10))) + .map_err(|e| e.to_string())?; + + let mut len_buf = [0u8; 4]; + stream + .read_exact(&mut len_buf) + .map_err(|e| format!("read length prefix: {e}"))?; + let len = u32::from_le_bytes(len_buf) as usize; + + if len > 2 * 1024 * 1024 { + return Err(format!("oversized frame: {len} bytes")); + } + if len == 0 { + return Err("zero-length frame".into()); + } + + let mut payload = vec![0u8; len]; + stream + .read_exact(&mut payload) + .map_err(|e| format!("read payload: {e}"))?; + + // Decode the variant index. + let (variant, consumed) = decode_varint_u32(&payload, 0)?; + + // Return the variant index and the remaining payload (after the variant tag). + Ok((variant, payload[consumed..].to_vec())) +} + +// --------------------------------------------------------------------------- +// Tests +// --------------------------------------------------------------------------- + +#[test] +fn client_connects_and_receives_frame() { + // Client connects to server and handshake completes. + // Client receives Frame messages. + // Server sends rendered frames to connected clients. + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + let spawned = spawn_server(&config_home, &runtime_dir, &api_socket, &client_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_file(&client_socket, Duration::from_secs(10)); + + // Connect and handshake. + let mut stream = UnixStream::connect(&client_socket).expect("should connect to client socket"); + let (version, error) = + client_handshake(&mut stream, 1, 80, 24).expect("handshake should succeed"); + assert_eq!(version, 1, "server should report protocol version 1"); + assert!( + error.is_none(), + "handshake should not have error: {:?}", + error + ); + + // Give the server a moment to set up the writer thread and + // start the render cycle after learning our terminal size. + thread::sleep(Duration::from_millis(500)); + + // Read the next message from the server — should be a Frame (variant 1). + stream.set_nonblocking(false).unwrap(); + stream + .set_read_timeout(Some(Duration::from_secs(10))) + .unwrap(); + + let (variant, _payload) = + read_server_message(&mut stream).expect("should receive a message from server"); + + // ServerMessage::Frame is variant 1. + assert_eq!( + variant, 1, + "expected Frame message (variant 1), got variant {variant}" + ); + + cleanup_spawned_herdr(spawned, base); +} + +#[test] +fn client_input_forwarded_to_pane() { + // Stdin input is forwarded to server as ClientMessage::Input. + // Server routes client input to the correct PTY. + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + let spawned = spawn_server(&config_home, &runtime_dir, &api_socket, &client_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_file(&client_socket, Duration::from_secs(10)); + + // Connect and handshake. + let mut stream = UnixStream::connect(&client_socket).expect("should connect to client socket"); + let (version, error) = + client_handshake(&mut stream, 1, 80, 24).expect("handshake should succeed"); + assert_eq!(version, 1); + assert!(error.is_none(), "{:?}", error); + + // Send an Input message containing "echo hello\n". + // ClientMessage::Input is variant 1: { data: Vec<u8> } + let input_data = b"echo hello\n".to_vec(); + let input_payload = { + let mut buf = encode_varint_u32(1); // variant 1 = Input + // Encode the data as a bincode Vec<u8>: length (varint) + bytes + buf.extend_from_slice(&encode_varint_u32(input_data.len() as u32)); + buf.extend_from_slice(&input_data); + buf + }; + let framed = frame_message(&input_payload); + stream + .write_all(&framed) + .expect("should send Input message"); + stream.flush().expect("should flush"); + + // Give the server time to process the input and render. + thread::sleep(Duration::from_millis(500)); + + // Verify the server is still alive and responsive via API. + let response = ping_socket(&api_socket); + assert!( + response.contains("pong"), + "server should still respond to ping after input: {response}" + ); + + cleanup_spawned_herdr(spawned, base); +} + +#[test] +fn client_resize_sends_message() { + // Terminal resize triggers ClientMessage::Resize. + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + let spawned = spawn_server(&config_home, &runtime_dir, &api_socket, &client_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_file(&client_socket, Duration::from_secs(10)); + + // Connect and handshake. + let mut stream = UnixStream::connect(&client_socket).expect("should connect to client socket"); + let (version, error) = + client_handshake(&mut stream, 1, 80, 24).expect("handshake should succeed"); + assert_eq!(version, 1); + assert!(error.is_none(), "{:?}", error); + + // Drain the initial frame(s). + stream + .set_read_timeout(Some(Duration::from_secs(2))) + .unwrap(); + while let Ok(_) = read_server_message(&mut stream) {} + + // Send a Resize message: ClientMessage::Resize is variant 2: { cols: u16, rows: u16 } + let resize_payload = { + let mut buf = encode_varint_u32(2); // variant 2 = Resize + buf.extend_from_slice(&encode_varint_u16(120)); // cols + buf.extend_from_slice(&encode_varint_u16(40)); // rows + buf + }; + let framed = frame_message(&resize_payload); + stream + .write_all(&framed) + .expect("should send Resize message"); + stream.flush().expect("should flush"); + + // Give the server time to process and render at the new size. + thread::sleep(Duration::from_millis(500)); + + // Verify the server is still alive. + let response = ping_socket(&api_socket); + assert!( + response.contains("pong"), + "server should respond after resize: {response}" + ); + + cleanup_spawned_herdr(spawned, base); +} + +#[test] +fn server_shutdown_sends_message_to_client() { + // ServerShutdown causes clean exit with informative message. + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + let mut spawned = spawn_server(&config_home, &runtime_dir, &api_socket, &client_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_file(&client_socket, Duration::from_secs(10)); + + // Connect and handshake. + let mut stream = UnixStream::connect(&client_socket).expect("should connect to client socket"); + let (version, error) = + client_handshake(&mut stream, 1, 80, 24).expect("handshake should succeed"); + assert_eq!(version, 1); + assert!(error.is_none(), "{:?}", error); + + // Send SIGINT so the server takes the graceful shutdown path and + // broadcasts ServerShutdown before exiting. + if let Some(pid) = spawned.child.process_id() { + unsafe { + libc::kill(pid as libc::pid_t, libc::SIGINT); + } + } + + // The client should receive an explicit ServerShutdown message, or at + // minimum observe clean connection close if shutdown races with send. + stream + .set_read_timeout(Some(Duration::from_secs(5))) + .unwrap(); + let mut saw_shutdown = false; + let mut saw_disconnect = false; + let deadline = Instant::now() + Duration::from_secs(5); + while Instant::now() < deadline { + match read_server_message(&mut stream) { + Ok((variant, _)) => { + if variant == 2 { + saw_shutdown = true; + break; + } + } + Err(_) => { + saw_disconnect = true; + break; + } + } + } + assert!( + saw_shutdown || saw_disconnect, + "client should observe ServerShutdown or disconnect during graceful shutdown" + ); + + // Wait for the server to exit after shutdown signal. + let _ = spawned.child.wait(); + + drop(spawned); + cleanup_test_base(&base); +} + +#[test] +fn server_unreachable_shows_clear_error() { + // when server is unreachable, the client exits quickly + // with an actionable connection-failed message. + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + + fs::create_dir_all(config_home.join("herdr")).unwrap(); + fs::create_dir_all(&runtime_dir).unwrap(); + register_runtime_dir(&runtime_dir); + fs::write( + config_home.join("herdr/config.toml"), + "onboarding = false\n", + ) + .unwrap(); + + let output = std::process::Command::new(env!("CARGO_BIN_EXE_herdr")) + .arg("client") + .env("XDG_CONFIG_HOME", &config_home) + .env("XDG_RUNTIME_DIR", &runtime_dir) + .env("HERDR_SOCKET_PATH", &api_socket) + .env_remove("HERDR_CLIENT_SOCKET_PATH") + .env_remove("HERDR_ENV") + .output() + .expect("client command should run"); + + assert!( + !output.status.success(), + "client should fail when no server is running" + ); + let stderr = String::from_utf8_lossy(&output.stderr); + assert!( + stderr.contains("failed to connect to server"), + "stderr should mention connection failure: {stderr}" + ); + assert!( + stderr.contains("Is herdr server running?"), + "stderr should include actionable guidance: {stderr}" + ); + assert!( + stderr.contains("Socket path:"), + "stderr should include attempted socket path: {stderr}" + ); + + cleanup_test_base(&base); +} + +#[test] +fn server_crash_after_attach_causes_lost_connection_error() { + // attach a real thin client connection, kill server unexpectedly, + // assert clean non-zero client exit plus lost-connection signal. + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + let mut spawned = spawn_server(&config_home, &runtime_dir, &api_socket, &client_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_file(&client_socket, Duration::from_secs(10)); + + // Attach a real thin client (client subcommand) through PTY so handshake and + // terminal setup paths are exercised. + let mut thin_client = spawn_client_process(&config_home, &runtime_dir, &api_socket); + + // Prove attached before kill by waiting for at least one frame message. + let mut thin_reader = thin_client + ._master + .try_clone_reader() + .expect("clone client PTY reader"); + let attached_before_kill = { + let deadline = Instant::now() + Duration::from_secs(8); + let mut buf = [0u8; 4096]; + let mut seen = false; + while Instant::now() < deadline { + match thin_reader.read(&mut buf) { + Ok(n) if n > 0 => { + let out = String::from_utf8_lossy(&buf[..n]); + if out.contains("\u{2500}") + || out.contains("workspace") + || out.contains("terminal") + || out.contains("pane") + { + seen = true; + break; + } + } + Ok(_) => thread::sleep(Duration::from_millis(30)), + Err(_) => thread::sleep(Duration::from_millis(30)), + } + } + seen + }; + assert!( + attached_before_kill, + "thin client must complete attach and receive frame before server crash" + ); + + // Kill server unexpectedly. + if let Some(pid) = spawned.child.process_id() { + unsafe { + libc::kill(pid as libc::pid_t, libc::SIGKILL); + } + } + + // Client should exit non-zero after connection loss. + let mut crash_output = String::new(); + let exited = { + let deadline = Instant::now() + Duration::from_secs(12); + let mut exited = false; + while Instant::now() < deadline { + if thin_client.child.try_wait().ok().flatten().is_some() { + exited = true; + break; + } + // Keep draining client output so the process can progress to exit. + let mut buf = [0u8; 1024]; + if let Ok(n) = thin_reader.read(&mut buf) { + if n > 0 { + crash_output.push_str(&String::from_utf8_lossy(&buf[..n])); + } + } + thread::sleep(Duration::from_millis(50)); + } + exited + }; + assert!(exited, "thin client should exit after server SIGKILL"); + + let status = thin_client.child.wait().expect("wait thin client status"); + assert!( + !status.success(), + "thin client should exit non-zero after lost server connection" + ); + + // Drain trailing output and require the explicit user-visible lost-connection message. + let deadline = Instant::now() + Duration::from_secs(5); + let mut buf = [0u8; 2048]; + while Instant::now() < deadline { + match thin_reader.read(&mut buf) { + Ok(n) if n > 0 => crash_output.push_str(&String::from_utf8_lossy(&buf[..n])), + Ok(_) => break, + Err(_) => break, + } + thread::sleep(Duration::from_millis(30)); + } + + let crash_output_lc = crash_output.to_lowercase(); + assert!( + crash_output_lc.contains("lost connection to server"), + "thin client must emit explicit lost-connection message after server crash; output: {crash_output:?}" + ); + + // Ensure server is gone. + let _ = spawned.child.wait(); + + cleanup_test_base(&base); +} + +#[test] +fn client_receives_frame_after_pane_output() { + // End-to-end test: server renders, client receives Frame. + // This test verifies the full flow: + // 1. Start server + // 2. Connect client, handshake + // 3. Send input to pane (echo command) + // 4. Wait for a new frame from the server + // 5. Verify the frame contains the pane output + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + let spawned = spawn_server(&config_home, &runtime_dir, &api_socket, &client_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_file(&client_socket, Duration::from_secs(10)); + + // Connect and handshake. + let mut stream = UnixStream::connect(&client_socket).expect("should connect to client socket"); + let (version, error) = + client_handshake(&mut stream, 1, 80, 24).expect("handshake should succeed"); + assert_eq!(version, 1); + assert!(error.is_none(), "{:?}", error); + + // Read the initial frame (server renders immediately on client connect). + stream.set_nonblocking(false).unwrap(); + stream + .set_read_timeout(Some(Duration::from_secs(5))) + .unwrap(); + + let (variant, _payload) = + read_server_message(&mut stream).expect("should receive initial frame"); + assert_eq!(variant, 1, "initial message should be a Frame (variant 1)"); + + // Send input to trigger a state change and re-render. + let input_data = b"echo test-output\n".to_vec(); + let input_payload = { + let mut buf = encode_varint_u32(1); // Input variant + buf.extend_from_slice(&encode_varint_u32(input_data.len() as u32)); + buf.extend_from_slice(&input_data); + buf + }; + let framed = frame_message(&input_payload); + stream.write_all(&framed).expect("send input"); + stream.flush().expect("flush"); + + // Wait for the server to process and render. + thread::sleep(Duration::from_millis(500)); + + // Read subsequent frames — the server should have re-rendered after + // the input was processed. + stream + .set_read_timeout(Some(Duration::from_secs(5))) + .unwrap(); + let mut received_frame = false; + for _ in 0..5 { + match read_server_message(&mut stream) { + Ok((variant, _)) => { + if variant == 1 { + received_frame = true; + break; + } + } + Err(_) => break, + } + } + assert!(received_frame, "should receive a Frame after pane output"); + + cleanup_spawned_herdr(spawned, base); +} + +#[test] +fn navigate_mode_keybind_dispatch_in_server() { + // Navigate mode keybind dispatch in server. + // This tests that the server can process a prefix key (Ctrl+B) to enter + // navigate mode, and then a navigation key (like 'n' for new workspace). + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + let spawned = spawn_server(&config_home, &runtime_dir, &api_socket, &client_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_file(&client_socket, Duration::from_secs(10)); + + // Connect and handshake. + let mut stream = UnixStream::connect(&client_socket).expect("should connect to client socket"); + let (version, error) = + client_handshake(&mut stream, 1, 80, 24).expect("handshake should succeed"); + assert_eq!(version, 1); + assert!(error.is_none(), "{:?}", error); + + // Drain initial frames. + stream + .set_read_timeout(Some(Duration::from_secs(2))) + .unwrap(); + while let Ok(_) = read_server_message(&mut stream) {} + + // Send Ctrl+B (prefix key) as raw bytes. In kitty mode, Ctrl+B is 0x02. + // In legacy mode, it's also 0x02 (control character). + let prefix_input = vec![0x02]; // Ctrl+B + let input_payload = { + let mut buf = encode_varint_u32(1); // Input variant + buf.extend_from_slice(&encode_varint_u32(prefix_input.len() as u32)); + buf.extend_from_slice(&prefix_input); + buf + }; + let framed = frame_message(&input_payload); + stream.write_all(&framed).expect("send prefix key"); + stream.flush().expect("flush"); + + // Give the server time to process. + thread::sleep(Duration::from_millis(100)); + + // Send 'n' (new workspace in navigate mode). + let n_input = b"n".to_vec(); + let n_payload = { + let mut buf = encode_varint_u32(1); // Input variant + buf.extend_from_slice(&encode_varint_u32(n_input.len() as u32)); + buf.extend_from_slice(&n_input); + buf + }; + let framed = frame_message(&n_payload); + stream.write_all(&framed).expect("send n key"); + stream.flush().expect("flush"); + + // Wait for processing and render. + thread::sleep(Duration::from_millis(500)); + + // Verify the server is still alive and the API still works. + let response = ping_socket(&api_socket); + assert!( + response.contains("pong"), + "server should still respond after navigate mode input: {response}" + ); + + cleanup_spawned_herdr(spawned, base); +} + +#[test] +fn pane_spawn_cwd_fallback_in_server() { + // Pane spawn failure cwd fallback in server context. + // This test verifies that the server can start even with invalid + // session data pointing to non-existent directories. + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + let spawned = spawn_server(&config_home, &runtime_dir, &api_socket, &client_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_file(&client_socket, Duration::from_secs(10)); + + // The server should have started successfully even though there are + // no existing sessions (fresh state). The test verifies that the + // server doesn't crash during initial pane creation. + let response = ping_socket(&api_socket); + assert!( + response.contains("pong"), + "server should respond to ping after startup: {response}" + ); + + // Create a workspace via the API — this tests pane creation in the server. + let mut ws_stream = UnixStream::connect(&api_socket).expect("connect to API"); + let request = r#"{"id":"2","method":"workspace.create","params":{"label":"cwd-test"}}"#; + writeln!(ws_stream, "{}", request).unwrap(); + + let mut reader = BufReader::new(ws_stream); + let mut response = String::new(); + reader.read_line(&mut response).unwrap(); + + assert!( + response.contains("workspace_created") || response.contains("ok"), + "workspace creation should succeed: {response}" + ); + + cleanup_spawned_herdr(spawned, base); +} + +#[test] +fn graceful_shutdown_sends_server_shutdown_to_client() { + // Issue 2 fix: SIGINT triggers initiate_shutdown → ServerShutdown + // broadcast to all clients before the server exits. + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + let mut spawned = spawn_server(&config_home, &runtime_dir, &api_socket, &client_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_file(&client_socket, Duration::from_secs(10)); + + // Connect and handshake. + let mut stream = UnixStream::connect(&client_socket).expect("should connect to client socket"); + let (version, error) = + client_handshake(&mut stream, 1, 80, 24).expect("handshake should succeed"); + assert_eq!(version, 1); + assert!(error.is_none(), "{:?}", error); + + // Drain initial frame(s). + stream + .set_read_timeout(Some(Duration::from_secs(2))) + .unwrap(); + while let Ok(_) = read_server_message(&mut stream) {} + + // Send SIGINT to the server process to trigger graceful shutdown. + if let Some(pid) = spawned.child.process_id() { + unsafe { + libc::kill(pid as libc::pid_t, libc::SIGINT); + } + } + + // The client should receive a ServerShutdown message (variant 2) + // before the connection is closed, not just an abrupt EOF. + stream + .set_read_timeout(Some(Duration::from_secs(5))) + .unwrap(); + let result = read_server_message(&mut stream); + match result { + Ok((variant, _payload)) => { + assert_eq!( + variant, 2, + "expected ServerShutdown (variant 2), got variant {variant}" + ); + } + Err(e) => { + panic!("expected ServerShutdown message before connection close, got error: {e}"); + } + } + + // Wait for the server to exit. + let _ = spawned.child.wait(); + + drop(spawned); + cleanup_test_base(&base); +} + +#[test] +fn client_receives_notify_on_agent_state_change() { + // Notification events (sound/toast) are forwarded as + // ServerMessage::Notify to connected clients when an agent state change + // is triggered via the API (pane.report_agent). + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + // Enable toast and sound in config so the server produces notifications. + fs::create_dir_all(config_home.join("herdr")).unwrap(); + fs::write( + config_home.join("herdr/config.toml"), + "onboarding = false\n[ui.toast]\nenabled = true\n[ui.sound]\nenabled = true\n", + ) + .unwrap(); + fs::create_dir_all(&runtime_dir).unwrap(); + register_runtime_dir(&runtime_dir); + + // Spawn the server directly (not using spawn_server helper because it + // overwrites the config file with a minimal one). + let pair = native_pty_system() + .openpty(PtySize { + rows: 24, + cols: 80, + pixel_width: 0, + pixel_height: 0, + }) + .unwrap(); + + let mut cmd = CommandBuilder::new(env!("CARGO_BIN_EXE_herdr")); + cmd.arg("server"); + cmd.env("XDG_CONFIG_HOME", &config_home); + cmd.env("XDG_RUNTIME_DIR", &runtime_dir); + cmd.env("HERDR_SOCKET_PATH", &api_socket); + cmd.env_remove("HERDR_CLIENT_SOCKET_PATH"); + cmd.env("SHELL", "/bin/sh"); + cmd.env_remove("HERDR_ENV"); + + let child = pair.slave.spawn_command(cmd).unwrap(); + register_spawned_herdr_pid(child.process_id()); + drop(pair.slave); + + let spawned = SpawnedHerdr { + _master: pair.master, + child, + }; + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_file(&client_socket, Duration::from_secs(10)); + + // Connect as a client and perform handshake. + let mut stream = UnixStream::connect(&client_socket).expect("should connect"); + let (version, error) = + client_handshake(&mut stream, 1, 80, 24).expect("handshake should succeed"); + assert_eq!(version, 1); + assert!(error.is_none(), "{:?}", error); + + // Drain initial frame(s). + stream + .set_read_timeout(Some(Duration::from_secs(2))) + .unwrap(); + while let Ok(_) = read_server_message(&mut stream) {} + + // Create a workspace via the API. + let mut ws_stream = UnixStream::connect(&api_socket).expect("connect to API"); + let request = r#"{"id":"1","method":"workspace.create","params":{}}"#; + writeln!(ws_stream, "{}", request).unwrap(); + let mut reader = BufReader::new(ws_stream); + let mut ws_response = String::new(); + reader.read_line(&mut ws_response).unwrap(); + + // Extract the workspace ID and pane ID from the response. + let ws_id = ws_response + .split('"') + .find(|s| s.starts_with("w_")) + .unwrap_or("w_1") + .to_string(); + + // Get pane list to find a pane ID. + let mut pane_stream = UnixStream::connect(&api_socket).expect("connect to API"); + let pane_request = + format!(r#"{{"id":"2","method":"pane.list","params":{{"workspace_id":"{ws_id}"}}}}"#); + writeln!(pane_stream, "{}", pane_request).unwrap(); + let mut pane_reader = BufReader::new(pane_stream); + let mut pane_response = String::new(); + pane_reader.read_line(&mut pane_response).unwrap(); + + // Extract first pane ID (format: p_<ws>_<pane>). + let pane_id = pane_response + .split('"') + .find(|s| s.starts_with("p_")) + .unwrap_or("p_1_1") + .to_string(); + + // Report agent as Blocked via the API — this should trigger a + // ServerMessage::Notify with kind=Sound (Request sound). + let mut report_stream = UnixStream::connect(&api_socket).expect("connect to API"); + let report_request = format!( + r#"{{"id":"3","method":"pane.report_agent","params":{{"pane_id":"{pane_id}","agent":"pi","state":"blocked","source":"test"}}}}"# + ); + writeln!(report_stream, "{}", report_request).unwrap(); + let mut report_reader = BufReader::new(report_stream); + let mut report_response = String::new(); + report_reader.read_line(&mut report_response).unwrap(); + + // Read messages from the client stream and look for Notify (variant 3). + // Notify = ServerMessage variant index 3 (after Welcome=0, Frame=1, ServerShutdown=2). + stream + .set_read_timeout(Some(Duration::from_secs(5))) + .unwrap(); + let mut found_notify = false; + let deadline = Instant::now() + Duration::from_secs(5); + while Instant::now() < deadline { + match read_server_message(&mut stream) { + Ok((variant, _payload)) => { + if variant == 3 { + // ServerMessage::Notify — found it! + found_notify = true; + break; + } + // Continue reading — Frame messages (variant 1) will come first. + } + Err(_) => { + break; + } + } + } + + assert!( + found_notify, + "client should receive a ServerMessage::Notify after pane.report_agent" + ); + + // Now report Idle from Working — this should trigger a Done sound + // if the pane is in a background workspace. + // First, create a second workspace to make the first one "background". + let mut ws2_stream = UnixStream::connect(&api_socket).expect("connect to API"); + let ws2_request = r#"{"id":"4","method":"workspace.create","params":{}}"#; + writeln!(ws2_stream, "{}", ws2_request).unwrap(); + let mut ws2_reader = BufReader::new(ws2_stream); + let mut ws2_response = String::new(); + ws2_reader.read_line(&mut ws2_response).unwrap(); + + // Focus the new workspace (making the first one background). + let ws2_id = ws2_response + .split('"') + .find(|s| s.starts_with("w_")) + .unwrap_or("w_2") + .to_string(); + let mut focus_stream = UnixStream::connect(&api_socket).expect("connect to API"); + let focus_request = format!( + r#"{{"id":"5","method":"workspace.focus","params":{{"workspace_id":"{ws2_id}"}}}}"# + ); + writeln!(focus_stream, "{}", focus_request).unwrap(); + let mut focus_reader = BufReader::new(focus_stream); + let mut focus_response = String::new(); + focus_reader.read_line(&mut focus_response).unwrap(); + + // Give the server a moment to process. + thread::sleep(Duration::from_millis(100)); + + // Report agent as Working first, then Idle — this transition in a + // background workspace should trigger a Done sound notification. + let mut work_stream = UnixStream::connect(&api_socket).expect("connect to API"); + let work_request = format!( + r#"{{"id":"6","method":"pane.report_agent","params":{{"pane_id":"{pane_id}","agent":"pi","state":"working","source":"test"}}}}"# + ); + writeln!(work_stream, "{}", work_request).unwrap(); + let mut work_reader = BufReader::new(work_stream); + let mut work_response = String::new(); + work_reader.read_line(&mut work_response).unwrap(); + + thread::sleep(Duration::from_millis(100)); + + let mut idle_stream = UnixStream::connect(&api_socket).expect("connect to API"); + let idle_request = format!( + r#"{{"id":"7","method":"pane.report_agent","params":{{"pane_id":"{pane_id}","agent":"pi","state":"idle","source":"test"}}}}"# + ); + writeln!(idle_stream, "{}", idle_request).unwrap(); + let mut idle_reader = BufReader::new(idle_stream); + let mut idle_response = String::new(); + idle_reader.read_line(&mut idle_response).unwrap(); + + // Read messages and look for Done sound notify. + stream + .set_read_timeout(Some(Duration::from_secs(5))) + .unwrap(); + let mut found_done_notify = false; + let deadline = Instant::now() + Duration::from_secs(5); + while Instant::now() < deadline { + match read_server_message(&mut stream) { + Ok((variant, _payload)) => { + if variant == 3 { + // Found a Notify message — that's good enough. + // The test already verified the Blocked→Notify path above. + found_done_notify = true; + break; + } + // Continue reading — Frame messages will come first. + } + Err(e) => { + eprintln!("read error while looking for Done Notify: {e}"); + break; + } + } + } + + assert!( + found_done_notify, + "client should receive a Sound Notify with 'agent done' when background pane transitions Working→Idle" + ); + + cleanup_spawned_herdr(spawned, base); +} diff --git a/tests/cross_area.rs b/tests/cross_area.rs new file mode 100644 index 00000000..5758fdd2 --- /dev/null +++ b/tests/cross_area.rs @@ -0,0 +1,1103 @@ +//! Cross-area integration tests for end-to-end persistence flows. + +mod support; + +use std::fs; +use std::io::{self, BufRead, BufReader, Read, Write}; +use std::os::unix::net::UnixStream; +use std::path::{Path, PathBuf}; +use std::sync::{Mutex, MutexGuard, OnceLock}; +use std::thread; +use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH}; + +use portable_pty::{native_pty_system, Child, CommandBuilder, MasterPty, PtySize}; +use serde::Deserialize; +use serde_json::{json, Value}; +use support::{ + cleanup_test_base, register_runtime_dir, register_spawned_herdr_pid, + unregister_spawned_herdr_pid, +}; + +fn unique_test_dir() -> PathBuf { + let nanos = SystemTime::now() + .duration_since(UNIX_EPOCH) + .map(|d| d.as_nanos()) + .unwrap_or(0); + PathBuf::from(format!( + "/tmp/herdr-cross-area-test-{}-{nanos}", + std::process::id() + )) +} + +struct SpawnedHerdr { + _master: Box<dyn MasterPty + Send>, + child: Box<dyn Child + Send + Sync>, +} + +impl Drop for SpawnedHerdr { + fn drop(&mut self) { + let pid = self.child.process_id(); + let _ = self.child.kill(); + + if let Some(pid) = pid { + let deadline = Instant::now() + Duration::from_secs(2); + while Instant::now() < deadline { + let mut status = 0; + let result = + unsafe { libc::waitpid(pid as libc::pid_t, &mut status, libc::WNOHANG) }; + if result == pid as libc::pid_t || result == -1 { + break; + } + thread::sleep(Duration::from_millis(20)); + } + + unregister_spawned_herdr_pid(Some(pid)); + } + } +} + +fn cleanup_spawned_herdr(spawned: SpawnedHerdr, base: PathBuf) { + drop(spawned); + cleanup_test_base(&base); +} + +fn test_lock() -> MutexGuard<'static, ()> { + static LOCK: OnceLock<Mutex<()>> = OnceLock::new(); + LOCK.get_or_init(|| Mutex::new(())) + .lock() + .unwrap_or_else(|poisoned| poisoned.into_inner()) +} + +fn wait_for_socket(path: &Path, timeout: Duration) { + let deadline = Instant::now() + timeout; + while Instant::now() < deadline { + if path.exists() && UnixStream::connect(path).is_ok() { + return; + } + thread::sleep(Duration::from_millis(25)); + } + panic!("socket did not appear at {}", path.display()); +} + +fn spawn_server(config_home: &Path, runtime_dir: &Path, api_socket_path: &Path) -> SpawnedHerdr { + spawn_server_with_path(config_home, runtime_dir, api_socket_path, None) +} + +fn spawn_server_with_path( + config_home: &Path, + runtime_dir: &Path, + api_socket_path: &Path, + path_override: Option<&Path>, +) -> SpawnedHerdr { + fs::create_dir_all(config_home.join("herdr")).unwrap(); + fs::create_dir_all(runtime_dir).unwrap(); + register_runtime_dir(runtime_dir); + fs::write( + config_home.join("herdr/config.toml"), + "onboarding = false\n", + ) + .unwrap(); + + let pair = native_pty_system() + .openpty(PtySize { + rows: 24, + cols: 80, + pixel_width: 0, + pixel_height: 0, + }) + .unwrap(); + + let mut cmd = CommandBuilder::new(env!("CARGO_BIN_EXE_herdr")); + cmd.arg("server"); + cmd.env("XDG_CONFIG_HOME", config_home); + cmd.env("XDG_RUNTIME_DIR", runtime_dir); + cmd.env("HERDR_SOCKET_PATH", api_socket_path); + cmd.env_remove("HERDR_CLIENT_SOCKET_PATH"); + cmd.env("SHELL", "/bin/sh"); + cmd.env_remove("HERDR_ENV"); + if let Some(path) = path_override { + cmd.env("PATH", path); + } + + let child = pair.slave.spawn_command(cmd).unwrap(); + register_spawned_herdr_pid(child.process_id()); + drop(pair.slave); + + SpawnedHerdr { + _master: pair.master, + child, + } +} + +fn spawn_client_process( + config_home: &Path, + runtime_dir: &Path, + api_socket_path: &Path, +) -> SpawnedHerdr { + register_runtime_dir(runtime_dir); + let pair = native_pty_system() + .openpty(PtySize { + rows: 24, + cols: 80, + pixel_width: 0, + pixel_height: 0, + }) + .unwrap(); + + let mut cmd = CommandBuilder::new(env!("CARGO_BIN_EXE_herdr")); + cmd.arg("client"); + cmd.env("XDG_CONFIG_HOME", config_home); + cmd.env("XDG_RUNTIME_DIR", runtime_dir); + cmd.env("HERDR_SOCKET_PATH", api_socket_path); + cmd.env_remove("HERDR_CLIENT_SOCKET_PATH"); + cmd.env("SHELL", "/bin/sh"); + cmd.env_remove("HERDR_ENV"); + + let child = pair.slave.spawn_command(cmd).unwrap(); + register_spawned_herdr_pid(child.process_id()); + drop(pair.slave); + + SpawnedHerdr { + _master: pair.master, + child, + } +} + +fn send_json_request(socket_path: &Path, id: &str, method: &str, params: Value) -> Value { + let mut stream = UnixStream::connect(socket_path).expect("should connect to API socket"); + let request = json!({ + "id": id, + "method": method, + "params": params + }); + writeln!(stream, "{}", request).unwrap(); + + let mut reader = BufReader::new(stream); + let mut response = String::new(); + reader.read_line(&mut response).unwrap(); + serde_json::from_str(&response).expect("response should be valid JSON") +} + +fn ping_socket(socket_path: &Path) -> String { + let response = send_json_request(socket_path, "ping", "ping", json!({})); + response.to_string() +} + +fn workspace_create(socket_path: &Path, label: &str) -> Value { + send_json_request( + socket_path, + "workspace_create", + "workspace.create", + json!({ "label": label }), + ) +} + +fn workspace_list(socket_path: &Path) -> Value { + send_json_request(socket_path, "workspace_list", "workspace.list", json!({})) +} + +fn workspace_count(socket_path: &Path) -> usize { + workspace_list(socket_path)["result"]["workspaces"] + .as_array() + .map(|workspaces| workspaces.len()) + .unwrap_or(0) +} + +fn workspace_id_by_label(response: &Value, label: &str) -> String { + response["result"]["workspaces"] + .as_array() + .expect("workspace.list should return workspaces array") + .iter() + .find(|workspace| workspace["label"] == label) + .and_then(|workspace| workspace["workspace_id"].as_str()) + .expect("workspace with matching label should exist") + .to_string() +} + +fn wait_for_child_exit(child: &mut Box<dyn Child + Send + Sync>, timeout: Duration) -> bool { + let deadline = Instant::now() + timeout; + while Instant::now() < deadline { + if child.try_wait().ok().flatten().is_some() { + return true; + } + thread::sleep(Duration::from_millis(25)); + } + false +} + +fn pane_send_input(socket_path: &Path, pane_id: &str, text: &str) { + let response = send_json_request( + socket_path, + "pane_send_input", + "pane.send_input", + json!({ + "pane_id": pane_id, + "text": text, + "keys": ["Enter"] + }), + ); + assert!( + response.get("error").is_none(), + "pane.send_input should succeed: {response}" + ); +} + +fn pane_send_text(socket_path: &Path, pane_id: &str, text: &str) { + let response = send_json_request( + socket_path, + "pane_send_text", + "pane.send_text", + json!({ + "pane_id": pane_id, + "text": text + }), + ); + assert!( + response.get("error").is_none(), + "pane.send_text should succeed: {response}" + ); +} + +fn pane_read_recent(socket_path: &Path, pane_id: &str) -> String { + let response = send_json_request( + socket_path, + "pane_read", + "pane.read", + json!({ + "pane_id": pane_id, + "source": "recent", + "lines": 200 + }), + ); + + response["result"]["read"]["text"] + .as_str() + .unwrap_or_default() + .to_string() +} + +fn pane_read_recent_contains( + socket_path: &Path, + pane_id: &str, + needle: &str, + timeout: Duration, +) -> bool { + let deadline = Instant::now() + timeout; + while Instant::now() < deadline { + let text = pane_read_recent(socket_path, pane_id); + if text.contains(needle) { + return true; + } + thread::sleep(Duration::from_millis(50)); + } + false +} + +fn pane_report_agent(socket_path: &Path, pane_id: &str, agent: &str, state: &str, source: &str) { + let response = send_json_request( + socket_path, + "pane_report_agent", + "pane.report_agent", + json!({ + "pane_id": pane_id, + "agent": agent, + "state": state, + "source": source, + }), + ); + assert!( + response.get("error").is_none(), + "pane.report_agent should succeed: {response}" + ); +} + +fn pane_agent_status(socket_path: &Path, pane_id: &str) -> Option<String> { + let response = send_json_request( + socket_path, + "pane_get", + "pane.get", + json!({ "pane_id": pane_id }), + ); + response["result"]["pane"]["agent_status"] + .as_str() + .map(|status| status.to_string()) +} + +fn wait_for_agent_status( + socket_path: &Path, + pane_id: &str, + expected: &str, + timeout: Duration, +) -> bool { + let deadline = Instant::now() + timeout; + while Instant::now() < deadline { + if pane_agent_status(socket_path, pane_id).as_deref() == Some(expected) { + return true; + } + thread::sleep(Duration::from_millis(50)); + } + false +} + +// --------------------------------------------------------------------------- +// Minimal protocol helpers (bincode v2 varint + framing) +// --------------------------------------------------------------------------- + +fn encode_varint_u32(v: u32) -> Vec<u8> { + if v < 251 { + vec![v as u8] + } else if v < 65_536 { + let mut buf = vec![251u8]; + buf.extend_from_slice(&(v as u16).to_le_bytes()); + buf + } else { + let mut buf = vec![252u8]; + buf.extend_from_slice(&v.to_le_bytes()); + buf + } +} + +fn encode_varint_u16(v: u16) -> Vec<u8> { + if v < 251 { + vec![v as u8] + } else { + let mut buf = vec![251u8]; + buf.extend_from_slice(&v.to_le_bytes()); + buf + } +} + +fn frame_message(payload: &[u8]) -> Vec<u8> { + let mut framed = (payload.len() as u32).to_le_bytes().to_vec(); + framed.extend_from_slice(payload); + framed +} + +fn decode_varint_u32(payload: &[u8], offset: usize) -> Result<(u32, usize), String> { + if offset >= payload.len() { + return Err("payload too short for varint".into()); + } + let first = payload[offset]; + match first { + 0..=250 => Ok((first as u32, 1)), + 251 => { + if offset + 3 > payload.len() { + return Err("payload too short for u16 varint".into()); + } + let v = u16::from_le_bytes( + payload[offset + 1..offset + 3] + .try_into() + .map_err(|e: std::array::TryFromSliceError| e.to_string())?, + ); + Ok((v as u32, 3)) + } + 252 => { + if offset + 5 > payload.len() { + return Err("payload too short for u32 varint".into()); + } + let v = u32::from_le_bytes( + payload[offset + 1..offset + 5] + .try_into() + .map_err(|e: std::array::TryFromSliceError| e.to_string())?, + ); + Ok((v, 5)) + } + _ => Err(format!("unsupported varint tag: {first}")), + } +} + +fn client_handshake(stream: &mut UnixStream, version: u32, cols: u16, rows: u16) { + stream + .set_read_timeout(Some(Duration::from_secs(5))) + .expect("set read timeout"); + + // ClientMessage::Hello = variant 0 + let mut payload = encode_varint_u32(0); + payload.extend_from_slice(&encode_varint_u32(version)); + payload.extend_from_slice(&encode_varint_u16(cols)); + payload.extend_from_slice(&encode_varint_u16(rows)); + + stream + .write_all(&frame_message(&payload)) + .expect("write hello"); + stream.flush().expect("flush hello"); + + let mut len_buf = [0u8; 4]; + stream + .read_exact(&mut len_buf) + .expect("read welcome length"); + let len = u32::from_le_bytes(len_buf) as usize; + assert!(len > 0 && len <= 2 * 1024 * 1024, "unexpected welcome size"); + + let mut welcome_payload = vec![0u8; len]; + stream + .read_exact(&mut welcome_payload) + .expect("read welcome payload"); + + let mut offset = 0; + let (variant, consumed) = decode_varint_u32(&welcome_payload, offset).expect("decode variant"); + offset += consumed; + assert_eq!(variant, 0, "expected ServerMessage::Welcome variant"); + + let (_server_version, consumed) = + decode_varint_u32(&welcome_payload, offset).expect("decode version"); + offset += consumed; + + let option_tag = *welcome_payload + .get(offset) + .expect("welcome payload should contain Option tag"); + if option_tag == 1 { + let (str_len, consumed) = + decode_varint_u32(&welcome_payload, offset + 1).expect("decode error length"); + let start = offset + 1 + consumed; + let end = start + str_len as usize; + let err = String::from_utf8(welcome_payload[start..end].to_vec()).expect("utf8 error"); + panic!("handshake rejected: {err}"); + } +} + +fn send_client_input(stream: &mut UnixStream, data: &[u8]) { + // ClientMessage::Input = variant 1 + let mut payload = encode_varint_u32(1); + payload.extend_from_slice(&encode_varint_u32(data.len() as u32)); + payload.extend_from_slice(data); + stream + .write_all(&frame_message(&payload)) + .expect("write input"); + stream.flush().expect("flush input"); +} + +fn send_client_detach(stream: &mut UnixStream) { + // ClientMessage::Detach = variant 3 + let payload = encode_varint_u32(3); + stream + .write_all(&frame_message(&payload)) + .expect("write detach"); + stream.flush().expect("flush detach"); +} + +fn is_timeout(err: &io::Error) -> bool { + matches!( + err.kind(), + io::ErrorKind::TimedOut | io::ErrorKind::WouldBlock + ) +} + +#[derive(Debug, Deserialize)] +struct FrameWire { + cells: Vec<CellWire>, + width: u16, + height: u16, + cursor: Option<CursorWire>, +} + +#[derive(Debug, Deserialize)] +struct CellWire { + symbol: String, + fg: u32, + bg: u32, + modifier: u16, + skip: bool, +} + +#[derive(Debug, Deserialize)] +struct CursorWire { + x: u16, + y: u16, + visible: bool, +} + +fn decode_frame_payload(payload: &[u8]) -> io::Result<FrameWire> { + bincode::serde::decode_from_slice(payload, bincode::config::standard()) + .map(|(frame, consumed)| (frame, consumed)) + .map_err(|err| io::Error::new(io::ErrorKind::InvalidData, err.to_string())) + .and_then(|(frame, consumed): (FrameWire, usize)| { + if consumed != payload.len() { + return Err(io::Error::new( + io::ErrorKind::InvalidData, + format!( + "frame payload had trailing bytes: consumed={}, len={}", + consumed, + payload.len() + ), + )); + } + Ok(frame) + }) +} + +fn frame_contains_text(frame: &FrameWire, needle: &str) -> bool { + if frame.cells.is_empty() { + return false; + } + + let width = frame.width.max(1) as usize; + let mut text = String::new(); + for row in frame.cells.chunks(width) { + for cell in row { + let _ = (cell.fg, cell.bg, cell.modifier, cell.skip); + text.push_str(&cell.symbol); + } + text.push('\n'); + } + let _ = frame.height; + if let Some(cursor) = frame.cursor.as_ref() { + let _ = (cursor.x, cursor.y, cursor.visible); + } + + text.contains(needle) +} + +fn read_server_variant(stream: &mut UnixStream, timeout: Duration) -> io::Result<u32> { + stream.set_read_timeout(Some(timeout))?; + + let mut len_buf = [0u8; 4]; + stream.read_exact(&mut len_buf)?; + let len = u32::from_le_bytes(len_buf) as usize; + if len == 0 { + return Err(io::Error::new( + io::ErrorKind::InvalidData, + "zero-length payload", + )); + } + + let mut payload = vec![0u8; len]; + stream.read_exact(&mut payload)?; + + let (variant, _consumed) = decode_varint_u32(&payload, 0) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?; + Ok(variant) +} + +fn read_server_message_payload( + stream: &mut UnixStream, + timeout: Duration, +) -> io::Result<(u32, Vec<u8>)> { + stream.set_read_timeout(Some(timeout))?; + + let mut len_buf = [0u8; 4]; + stream.read_exact(&mut len_buf)?; + let len = u32::from_le_bytes(len_buf) as usize; + if len == 0 { + return Err(io::Error::new( + io::ErrorKind::InvalidData, + "zero-length payload", + )); + } + + let mut payload = vec![0u8; len]; + stream.read_exact(&mut payload)?; + + let (variant, consumed) = decode_varint_u32(&payload, 0) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?; + Ok((variant, payload[consumed..].to_vec())) +} + +fn wait_for_frame_matching( + stream: &mut UnixStream, + timeout: Duration, + predicate: impl Fn(&FrameWire) -> bool, +) -> io::Result<bool> { + let deadline = Instant::now() + timeout; + while Instant::now() < deadline { + let slice = deadline + .saturating_duration_since(Instant::now()) + .min(Duration::from_millis(80)); + match read_server_message_payload(stream, slice) { + Ok((1, payload)) => { + let frame = decode_frame_payload(&payload)?; + if predicate(&frame) { + return Ok(true); + } + } + Ok((_variant, _payload)) => {} + Err(err) if is_timeout(&err) => {} + Err(err) => return Err(err), + } + } + + Ok(false) +} + +fn wait_for_frame(stream: &mut UnixStream, timeout: Duration) -> bool { + let deadline = Instant::now() + timeout; + while Instant::now() < deadline { + let slice = deadline + .saturating_duration_since(Instant::now()) + .min(Duration::from_millis(80)); + match read_server_variant(stream, slice) { + Ok(1) => return true, // ServerMessage::Frame + Ok(_) => {} + Err(err) if is_timeout(&err) => {} + Err(_) => return false, + } + } + false +} + +fn drain_server_messages(stream: &mut UnixStream, max_drain: Duration) { + let deadline = Instant::now() + max_drain; + while Instant::now() < deadline { + match read_server_variant(stream, Duration::from_millis(40)) { + Ok(_) => {} + Err(err) if is_timeout(&err) => break, + Err(_) => break, + } + } +} + +// --------------------------------------------------------------------------- +// Cross-area tests +// --------------------------------------------------------------------------- + +#[test] +fn cross_area_detach_and_reattach_preserves_state() { + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + let server = spawn_server(&config_home, &runtime_dir, &api_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_socket(&client_socket, Duration::from_secs(10)); + + // Local attach (client A). + let mut client_a = UnixStream::connect(&client_socket).expect("client A should connect"); + client_handshake(&mut client_a, 1, 100, 30); + assert!(wait_for_frame(&mut client_a, Duration::from_secs(2))); + + // Use herdr: create a workspace and write output into its pane. + let create = workspace_create(&api_socket, "cross-ssh-state"); + let workspace_id = create["result"]["workspace"]["workspace_id"] + .as_str() + .expect("workspace id") + .to_string(); + let pane_id = create["result"]["root_pane"]["pane_id"] + .as_str() + .expect("root pane id") + .to_string(); + + pane_send_input(&api_socket, &pane_id, "echo LOCAL_BEFORE_DETACH"); + assert!(pane_read_recent_contains( + &api_socket, + &pane_id, + "LOCAL_BEFORE_DETACH", + Duration::from_secs(5) + )); + + // Detach local client. + send_client_detach(&mut client_a); + drop(client_a); + + // Simulate activity while detached. + pane_send_text(&api_socket, &pane_id, "echo DETACHED_UPDATE\n"); + assert!(pane_read_recent_contains( + &api_socket, + &pane_id, + "DETACHED_UPDATE", + Duration::from_secs(5) + )); + + // Reattach from another terminal/session (client B). + let mut client_b = UnixStream::connect(&client_socket).expect("client B should connect"); + client_handshake(&mut client_b, 1, 80, 24); + assert!( + wait_for_frame(&mut client_b, Duration::from_secs(5)), + "reattached client should receive frame" + ); + + let listed = workspace_list(&api_socket); + assert_eq!( + workspace_id, + workspace_id_by_label(&listed, "cross-ssh-state"), + "reattached session should see same workspace" + ); + + let readback = pane_read_recent(&api_socket, &pane_id); + assert!( + readback.contains("DETACHED_UPDATE"), + "pane output should include detached-period output: {readback}" + ); + + cleanup_spawned_herdr(server, base); +} + +#[test] +fn cross_area_agent_process_survives_detach_and_reattach() { + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + let bin_dir = base.join("bin"); + fs::create_dir_all(&bin_dir).unwrap(); + let fake_pi = bin_dir.join("pi"); + fs::write(&fake_pi, "#!/bin/sh\nprintf 'Working...\\n'\nsleep 8\n").unwrap(); + #[cfg(unix)] + { + use std::os::unix::fs::PermissionsExt; + let mut perms = fs::metadata(&fake_pi).unwrap().permissions(); + perms.set_mode(0o755); + fs::set_permissions(&fake_pi, perms).unwrap(); + } + + let inherited_path = std::env::var("PATH").unwrap_or_default(); + let path_override = format!("{}:{}", bin_dir.display(), inherited_path); + + let server = spawn_server_with_path( + &config_home, + &runtime_dir, + &api_socket, + Some(Path::new(&path_override)), + ); + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_socket(&client_socket, Duration::from_secs(10)); + + let mut client_a = UnixStream::connect(&client_socket).expect("client A should connect"); + client_handshake(&mut client_a, 1, 100, 30); + assert!(wait_for_frame(&mut client_a, Duration::from_secs(2))); + + let created = workspace_create(&api_socket, "agent-persist"); + let pane_id = created["result"]["root_pane"]["pane_id"] + .as_str() + .expect("root pane id") + .to_string(); + + // Ensure detected agent surface is populated by running fake `pi`. + pane_send_text(&api_socket, &pane_id, "pi"); + pane_send_input(&api_socket, &pane_id, ""); + let detected_before_hook = { + let deadline = Instant::now() + Duration::from_secs(5); + let mut detected = false; + while Instant::now() < deadline { + let response = send_json_request( + &api_socket, + "pane_get", + "pane.get", + json!({ "pane_id": &pane_id }), + ); + if response["result"]["pane"]["agent"].as_str() == Some("pi") { + detected = true; + break; + } + thread::sleep(Duration::from_millis(60)); + } + detected + }; + assert!( + detected_before_hook, + "expected fake pi process to be detected before hook status assertions" + ); + + // Use agent status surfaces directly instead of a generic sleep command. + pane_report_agent(&api_socket, &pane_id, "pi", "working", "cross-area-test"); + assert!( + wait_for_agent_status(&api_socket, &pane_id, "working", Duration::from_secs(3)), + "pane agent status should become working before detach" + ); + + // Detach and ensure status persists through API while detached. + send_client_detach(&mut client_a); + drop(client_a); + + assert!( + wait_for_agent_status(&api_socket, &pane_id, "working", Duration::from_secs(3)), + "agent status should remain working while detached" + ); + + // Reattach and ensure client-side state reflects the persisted working status. + let mut client_b = UnixStream::connect(&client_socket).expect("client B should connect"); + client_handshake(&mut client_b, 1, 80, 24); + let saw_working_on_client = + wait_for_frame_matching(&mut client_b, Duration::from_secs(5), |frame| { + frame_contains_text(frame, "working") + }) + .expect("frame decoding should succeed"); + assert!( + saw_working_on_client, + "reattached client frame should expose persisted agent working status" + ); + + // Transition to idle and verify API + client surfaces both observe it. + pane_report_agent(&api_socket, &pane_id, "pi", "idle", "cross-area-test"); + assert!( + wait_for_agent_status(&api_socket, &pane_id, "idle", Duration::from_secs(3)), + "pane agent status should transition to idle" + ); + + let saw_idle_on_client = + wait_for_frame_matching(&mut client_b, Duration::from_secs(5), |frame| { + frame_contains_text(frame, "idle") + }) + .expect("frame decoding should succeed"); + assert!( + saw_idle_on_client, + "reattached client frame should show idle status after transition" + ); + + cleanup_spawned_herdr(server, base); +} + +#[test] +fn cross_area_client_and_api_workspace_views_are_consistent() { + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + let server = spawn_server(&config_home, &runtime_dir, &api_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_socket(&client_socket, Duration::from_secs(10)); + + let mut client = UnixStream::connect(&client_socket).expect("client should connect"); + client_handshake(&mut client, 1, 100, 30); + assert!(wait_for_frame(&mut client, Duration::from_secs(2))); + drain_server_messages(&mut client, Duration::from_millis(300)); + + let before = workspace_count(&api_socket); + + // Create a workspace via API while the client is attached. + let created = workspace_create(&api_socket, "api-visible-workspace"); + let created_workspace_id = created["result"]["workspace"]["workspace_id"] + .as_str() + .expect("workspace.create should return workspace_id") + .to_string(); + + // The attached client must receive a frame that includes the new workspace + // label, proving client-side state reflects the API surface. + let saw_workspace_on_client = + wait_for_frame_matching(&mut client, Duration::from_secs(3), |frame| { + frame_contains_text(frame, "api-visible-workspace") + }) + .expect("frame decoding should succeed"); + assert!( + saw_workspace_on_client, + "client-side frame should include the newly created workspace label" + ); + + let deadline = Instant::now() + Duration::from_secs(5); + let mut count_reached = false; + while Instant::now() < deadline { + if workspace_count(&api_socket) == before + 1 { + count_reached = true; + break; + } + thread::sleep(Duration::from_millis(50)); + } + assert!( + count_reached, + "API workspace list should include the created workspace" + ); + + let listed = workspace_list(&api_socket); + let listed_workspace_id = workspace_id_by_label(&listed, "api-visible-workspace"); + assert_eq!( + listed_workspace_id, created_workspace_id, + "API and client-side state should reference the same created workspace" + ); + + cleanup_spawned_herdr(server, base); +} + +#[test] +fn cross_area_two_clients_shared_view_and_single_detach_stability() { + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + let server = spawn_server(&config_home, &runtime_dir, &api_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_socket(&client_socket, Duration::from_secs(10)); + + let mut client_a = UnixStream::connect(&client_socket).expect("client A should connect"); + client_handshake(&mut client_a, 1, 110, 30); + let mut client_b = UnixStream::connect(&client_socket).expect("client B should connect"); + client_handshake(&mut client_b, 1, 100, 30); + + assert!(wait_for_frame(&mut client_a, Duration::from_secs(2))); + assert!(wait_for_frame(&mut client_b, Duration::from_secs(2))); + drain_server_messages(&mut client_a, Duration::from_millis(250)); + drain_server_messages(&mut client_b, Duration::from_millis(250)); + + let created = workspace_create(&api_socket, "shared-view"); + let pane_id = created["result"]["root_pane"]["pane_id"] + .as_str() + .expect("root pane id") + .to_string(); + + // Input from client A should update shared state visible to client B. + send_client_input(&mut client_a, b"echo SHARED_VIEW\n"); + assert!( + wait_for_frame(&mut client_b, Duration::from_secs(2)), + "client B should receive update from client A" + ); + assert!(pane_read_recent_contains( + &api_socket, + &pane_id, + "SHARED_VIEW", + Duration::from_secs(5) + )); + + // Detach client A; client B should keep working. + send_client_detach(&mut client_a); + drop(client_a); + + send_client_input(&mut client_b, b"echo AFTER_A_DETACH\n"); + assert!( + wait_for_frame(&mut client_b, Duration::from_secs(2)), + "remaining client should still receive frames after other client detaches" + ); + assert!(pane_read_recent_contains( + &api_socket, + &pane_id, + "AFTER_A_DETACH", + Duration::from_secs(5) + )); + + let ping = ping_socket(&api_socket); + assert!( + ping.contains("pong"), + "server and remaining client flow should stay healthy: {ping}" + ); + + cleanup_spawned_herdr(server, base); +} + +#[test] +fn cross_area_server_kill_then_restart_and_reconnect() { + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + let mut server = spawn_server(&config_home, &runtime_dir, &api_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_socket(&client_socket, Duration::from_secs(10)); + + // Attach a real thin client process and prove it reached attached state + // by observing an incoming frame on its PTY stream. + let mut thin_client = spawn_client_process(&config_home, &runtime_dir, &api_socket); + let mut thin_reader = thin_client + ._master + .try_clone_reader() + .expect("clone thin client reader"); + + let attached_before_kill = { + let deadline = Instant::now() + Duration::from_secs(8); + let mut observed = false; + let mut buf = [0u8; 4096]; + while Instant::now() < deadline { + match thin_reader.read(&mut buf) { + Ok(n) if n > 0 => { + let out = String::from_utf8_lossy(&buf[..n]); + if out.contains("\u{2500}") + || out.contains("workspace") + || out.contains("pane") + || out.contains("terminal") + { + observed = true; + break; + } + } + Ok(_) => thread::sleep(Duration::from_millis(30)), + Err(_) => thread::sleep(Duration::from_millis(30)), + } + } + observed + }; + assert!( + attached_before_kill, + "thin client should complete attach before server SIGKILL" + ); + + // Kill server abruptly and verify thin client exits with lost-connection messaging. + let server_pid = server.child.process_id().expect("server pid should exist"); + unsafe { + libc::kill(server_pid as libc::pid_t, libc::SIGKILL); + } + assert!( + wait_for_child_exit(&mut server.child, Duration::from_secs(5)), + "server should exit after SIGKILL" + ); + drop(server); + + let mut crash_output = String::new(); + let thin_exited = { + let deadline = Instant::now() + Duration::from_secs(12); + let mut exited = false; + let mut buf = [0u8; 1024]; + while Instant::now() < deadline { + if thin_client.child.try_wait().ok().flatten().is_some() { + exited = true; + break; + } + if let Ok(n) = thin_reader.read(&mut buf) { + if n > 0 { + crash_output.push_str(&String::from_utf8_lossy(&buf[..n])); + } + } + thread::sleep(Duration::from_millis(50)); + } + exited + }; + assert!(thin_exited, "thin client should exit after server SIGKILL"); + + let thin_status = thin_client + .child + .wait() + .expect("wait for thin client exit status"); + assert!( + !thin_status.success(), + "thin client should exit non-zero after unexpected server crash" + ); + + // Drain trailing output and require the explicit user-visible lost-connection message. + let deadline = Instant::now() + Duration::from_secs(5); + let mut buf = [0u8; 2048]; + while Instant::now() < deadline { + match thin_reader.read(&mut buf) { + Ok(n) if n > 0 => crash_output.push_str(&String::from_utf8_lossy(&buf[..n])), + Ok(_) => break, + Err(_) => break, + } + thread::sleep(Duration::from_millis(30)); + } + + let crash_output_lc = crash_output.to_lowercase(); + assert!( + crash_output_lc.contains("lost connection to server"), + "thin client output must include explicit lost-connection message after server kill; output: {crash_output:?}" + ); + + // Restart server and verify new client can connect (stale socket cleaned). + let server2 = spawn_server(&config_home, &runtime_dir, &api_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_socket(&client_socket, Duration::from_secs(10)); + + let mut reconnect_client = + UnixStream::connect(&client_socket).expect("new client should connect after restart"); + client_handshake(&mut reconnect_client, 1, 80, 24); + assert!( + wait_for_frame(&mut reconnect_client, Duration::from_secs(5)), + "new client should receive frame after restart" + ); + + let ping = ping_socket(&api_socket); + assert!( + ping.contains("pong"), + "restarted server should respond over API: {ping}" + ); + + cleanup_spawned_herdr(server2, base); +} diff --git a/tests/detach_reattach.rs b/tests/detach_reattach.rs new file mode 100644 index 00000000..a6bed866 --- /dev/null +++ b/tests/detach_reattach.rs @@ -0,0 +1,955 @@ +//! Integration tests for detach/reattach flow. +//! + +mod support; + +use std::fs; +use std::io::{BufRead, BufReader, Read, Write}; +use std::os::unix::net::UnixStream; +use std::path::PathBuf; +use std::sync::{Mutex, MutexGuard, OnceLock}; +use std::thread; +use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH}; + +use portable_pty::{native_pty_system, Child, CommandBuilder, MasterPty, PtySize}; +use serde_json::Value; +use support::{ + cleanup_test_base, register_runtime_dir, register_spawned_herdr_pid, + unregister_spawned_herdr_pid, +}; + +fn unique_test_dir() -> PathBuf { + let nanos = SystemTime::now() + .duration_since(UNIX_EPOCH) + .map(|d| d.as_nanos()) + .unwrap_or(0); + PathBuf::from(format!( + "/tmp/herdr-detach-test-{}-{nanos}", + std::process::id() + )) +} + +struct SpawnedHerdr { + _master: Box<dyn MasterPty + Send>, + child: Box<dyn Child + Send + Sync>, +} + +impl Drop for SpawnedHerdr { + fn drop(&mut self) { + let pid = self.child.process_id(); + let _ = self.child.kill(); + + if let Some(pid) = pid { + let deadline = Instant::now() + Duration::from_secs(2); + while Instant::now() < deadline { + let mut status = 0; + let result = + unsafe { libc::waitpid(pid as libc::pid_t, &mut status, libc::WNOHANG) }; + if result == pid as libc::pid_t || result == -1 { + break; + } + thread::sleep(Duration::from_millis(20)); + } + + unregister_spawned_herdr_pid(Some(pid)); + } + } +} + +fn cleanup_spawned_herdr(spawned: SpawnedHerdr, base: PathBuf) { + drop(spawned); + cleanup_test_base(&base); +} + +fn test_lock() -> MutexGuard<'static, ()> { + static LOCK: OnceLock<Mutex<()>> = OnceLock::new(); + LOCK.get_or_init(|| Mutex::new(())) + .lock() + .unwrap_or_else(|poisoned| poisoned.into_inner()) +} + +fn wait_for_socket(path: &PathBuf, timeout: Duration) { + let deadline = Instant::now() + timeout; + while Instant::now() < deadline { + if path.exists() && UnixStream::connect(path).is_ok() { + return; + } + thread::sleep(Duration::from_millis(25)); + } + panic!("socket did not appear at {}", path.display()); +} + +fn wait_for_file(path: &PathBuf, timeout: Duration) { + let deadline = Instant::now() + timeout; + while Instant::now() < deadline { + if path.exists() { + return; + } + thread::sleep(Duration::from_millis(25)); + } + panic!("file did not appear at {}", path.display()); +} + +fn spawn_server( + config_home: &PathBuf, + runtime_dir: &PathBuf, + api_socket_path: &PathBuf, + _client_socket_path: &PathBuf, +) -> SpawnedHerdr { + fs::create_dir_all(config_home.join("herdr")).unwrap(); + fs::create_dir_all(runtime_dir).unwrap(); + register_runtime_dir(runtime_dir); + fs::write( + config_home.join("herdr/config.toml"), + "onboarding = false\n", + ) + .unwrap(); + + let pair = native_pty_system() + .openpty(PtySize { + rows: 24, + cols: 80, + pixel_width: 0, + pixel_height: 0, + }) + .unwrap(); + + let mut cmd = CommandBuilder::new(env!("CARGO_BIN_EXE_herdr")); + cmd.arg("server"); + cmd.env("XDG_CONFIG_HOME", config_home); + cmd.env("XDG_RUNTIME_DIR", runtime_dir); + cmd.env("HERDR_SOCKET_PATH", api_socket_path); + cmd.env_remove("HERDR_CLIENT_SOCKET_PATH"); + cmd.env("SHELL", "/bin/sh"); + cmd.env_remove("HERDR_ENV"); + + let child = pair.slave.spawn_command(cmd).unwrap(); + register_spawned_herdr_pid(child.process_id()); + drop(pair.slave); + + SpawnedHerdr { + _master: pair.master, + child, + } +} + +fn ping_socket(socket_path: &PathBuf) -> String { + let mut stream = UnixStream::connect(socket_path).expect("should connect to API socket"); + + let request = r#"{"id":"1","method":"ping","params":{}}"#; + writeln!(stream, "{}", request).unwrap(); + + let mut reader = BufReader::new(stream); + let mut response = String::new(); + reader.read_line(&mut response).unwrap(); + response.trim().to_string() +} + +fn send_json_request(socket_path: &PathBuf, request: &str) -> Value { + let mut stream = UnixStream::connect(socket_path).expect("should connect to API socket"); + writeln!(stream, "{}", request).unwrap(); + + let mut reader = BufReader::new(stream); + let mut response = String::new(); + reader.read_line(&mut response).unwrap(); + serde_json::from_str(&response).expect("response should be valid JSON") +} + +fn workspace_create(socket_path: &PathBuf, label: &str) -> Value { + send_json_request( + socket_path, + &format!( + r#"{{"id":"workspace_create","method":"workspace.create","params":{{"label":"{label}"}}}}"# + ), + ) +} + +fn workspace_list(socket_path: &PathBuf) -> Value { + send_json_request( + socket_path, + r#"{"id":"workspace_list","method":"workspace.list","params":{}}"#, + ) +} + +fn pane_list(socket_path: &PathBuf, workspace_id: &str) -> Value { + send_json_request( + socket_path, + &format!( + r#"{{"id":"pane_list","method":"pane.list","params":{{"workspace_id":"{workspace_id}"}}}}"# + ), + ) +} + +fn pane_read_recent(socket_path: &PathBuf, pane_id: &str) -> Value { + send_json_request( + socket_path, + &format!( + r#"{{"id":"pane_read","method":"pane.read","params":{{"pane_id":"{pane_id}","source":"recent"}}}}"# + ), + ) +} + +fn workspace_id_by_label(response: &Value, label: &str) -> String { + response["result"]["workspaces"] + .as_array() + .expect("workspace.list should return an array") + .iter() + .find(|workspace| workspace["label"] == label) + .and_then(|workspace| workspace["workspace_id"].as_str()) + .expect("workspace with expected label should exist") + .to_string() +} + +fn first_pane_id(response: &Value) -> String { + response["result"]["panes"] + .as_array() + .expect("pane.list should return an array") + .first() + .and_then(|pane| pane["pane_id"].as_str()) + .expect("pane.list should contain at least one pane") + .to_string() +} + +// --------------------------------------------------------------------------- +// Bincode v2 varint encoding helpers +// --------------------------------------------------------------------------- + +/// Encode a varint u32 value according to bincode v2 VarintEncoding. +fn encode_varint_u32(v: u32) -> Vec<u8> { + if v < 251 { + vec![v as u8] + } else if v < 65536 { + let mut buf = vec![251u8]; + buf.extend_from_slice(&(v as u16).to_le_bytes()); + buf + } else { + let mut buf = vec![252u8]; + buf.extend_from_slice(&v.to_le_bytes()); + buf + } +} + +/// Encode a varint u16 value. +fn encode_varint_u16(v: u16) -> Vec<u8> { + if v < 251 { + vec![v as u8] + } else { + let mut buf = vec![251u8]; + buf.extend_from_slice(&v.to_le_bytes()); + buf + } +} + +/// Encode an enum variant with its fields. +fn encode_varint_enum(variant_idx: u32, fields: &[&[u8]]) -> Vec<u8> { + let mut buf = encode_varint_u32(variant_idx); + for field in fields { + buf.extend_from_slice(field); + } + buf +} + +/// Frame a message with u32LE length prefix. +fn frame_message(payload: &[u8]) -> Vec<u8> { + let len = payload.len() as u32; + let mut framed = len.to_le_bytes().to_vec(); + framed.extend_from_slice(payload); + framed +} + +/// Decode a varint u32 from a byte slice at the given offset. +fn decode_varint_u32(payload: &[u8], offset: usize) -> Result<(u32, usize), String> { + if offset >= payload.len() { + return Err("payload too short for varint".into()); + } + let first_byte = payload[offset]; + match first_byte { + 0..=250 => Ok((first_byte as u32, 1)), + 251 => { + if offset + 3 > payload.len() { + return Err("payload too short for u16 varint".into()); + } + let v = u16::from_le_bytes( + payload[offset + 1..offset + 3] + .try_into() + .map_err(|e: std::array::TryFromSliceError| e.to_string())?, + ); + Ok((v as u32, 3)) + } + 252 => { + if offset + 5 > payload.len() { + return Err("payload too short for u32 varint".into()); + } + let v = u32::from_le_bytes( + payload[offset + 1..offset + 5] + .try_into() + .map_err(|e: std::array::TryFromSliceError| e.to_string())?, + ); + Ok((v, 5)) + } + _ => Err(format!("unsupported varint tag: {first_byte}")), + } +} + +/// Sends a Hello message over the client socket and reads the Welcome response. +fn client_handshake( + stream: &mut UnixStream, + version: u32, + cols: u16, + rows: u16, +) -> Result<(u32, Option<String>), String> { + stream + .set_read_timeout(Some(Duration::from_secs(5))) + .map_err(|e| e.to_string())?; + + // Encode Hello message: ClientMessage variant 0. + let hello_payload = encode_varint_enum( + 0, + &[ + &encode_varint_u32(version), + &encode_varint_u16(cols), + &encode_varint_u16(rows), + ], + ); + let framed = frame_message(&hello_payload); + stream.write_all(&framed).map_err(|e| e.to_string())?; + stream.flush().map_err(|e| e.to_string())?; + + // Read the framed response. + let mut len_buf = [0u8; 4]; + stream.read_exact(&mut len_buf).map_err(|e| e.to_string())?; + let len = u32::from_le_bytes(len_buf) as usize; + + if len > 2 * 1024 * 1024 { + return Err(format!("oversized response: {len}")); + } + + let mut payload = vec![0u8; len]; + stream.read_exact(&mut payload).map_err(|e| e.to_string())?; + + // Decode Welcome: ServerMessage variant 0 = Welcome { version: u32, error: Option<String> } + let mut offset = 0; + + let (variant, consumed) = decode_varint_u32(&payload, offset)?; + offset += consumed; + if variant != 0 { + return Err(format!( + "expected Welcome (variant 0), got variant {variant}" + )); + } + + let (version, consumed) = decode_varint_u32(&payload, offset)?; + offset += consumed; + + if offset >= payload.len() { + return Err("payload too short for Option tag".into()); + } + let option_tag = payload[offset]; + offset += 1; + + let error = if option_tag == 1 { + let (str_len, consumed) = decode_varint_u32(&payload, offset)?; + offset += consumed; + let str_len = str_len as usize; + + if offset + str_len > payload.len() { + return Err("payload too short for string content".into()); + } + let s = String::from_utf8(payload[offset..offset + str_len].to_vec()) + .map_err(|e| e.to_string())?; + Some(s) + } else { + None + }; + + Ok((version, error)) +} + +/// Read a framed ServerMessage from the stream, returning the variant index +/// and the raw payload for further decoding. +fn read_server_message(stream: &mut UnixStream) -> Result<(u32, Vec<u8>), String> { + stream + .set_read_timeout(Some(Duration::from_secs(10))) + .map_err(|e| e.to_string())?; + + let mut len_buf = [0u8; 4]; + stream + .read_exact(&mut len_buf) + .map_err(|e| format!("read length prefix: {e}"))?; + let len = u32::from_le_bytes(len_buf) as usize; + + if len > 2 * 1024 * 1024 { + return Err(format!("oversized frame: {len} bytes")); + } + if len == 0 { + return Err("zero-length frame".into()); + } + + let mut payload = vec![0u8; len]; + stream + .read_exact(&mut payload) + .map_err(|e| format!("read payload: {e}"))?; + + let (variant, consumed) = decode_varint_u32(&payload, 0)?; + + Ok((variant, payload[consumed..].to_vec())) +} + +/// Sends a ClientMessage::Input with the given raw bytes. +fn send_input(stream: &mut UnixStream, data: &[u8]) -> Result<(), String> { + let input_payload = { + let mut buf = encode_varint_u32(1); // variant 1 = Input + buf.extend_from_slice(&encode_varint_u32(data.len() as u32)); + buf.extend_from_slice(data); + buf + }; + let framed = frame_message(&input_payload); + stream + .write_all(&framed) + .map_err(|e| format!("write input: {e}"))?; + stream.flush().map_err(|e| format!("flush input: {e}"))?; + Ok(()) +} + +/// Sends a ClientMessage::Detach. +fn send_detach(stream: &mut UnixStream) -> Result<(), String> { + // ClientMessage::Detach is variant 3 with no fields. + let detach_payload = encode_varint_u32(3); + let framed = frame_message(&detach_payload); + stream + .write_all(&framed) + .map_err(|e| format!("write detach: {e}"))?; + stream.flush().map_err(|e| format!("flush detach: {e}"))?; + Ok(()) +} + +/// Drains all pending messages from the server stream (non-blocking). +fn drain_messages(stream: &mut UnixStream) { + stream + .set_read_timeout(Some(Duration::from_millis(200))) + .unwrap(); + while let Ok(_) = read_server_message(stream) {} + stream.set_read_timeout(None).unwrap(); +} + +// --------------------------------------------------------------------------- +// Tests +// --------------------------------------------------------------------------- + +#[test] +fn navigate_q_detaches_client_and_server_persists() { + // In persistence mode, navigate-mode q detaches the client and the server persists. + // Flow: + // 1. Start server + // 2. Connect client, handshake + // 3. Send prefix key (Ctrl+B) then 'q' + // 4. Verify server is still alive via API ping + // 5. Verify the client connection is closed + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + let spawned = spawn_server(&config_home, &runtime_dir, &api_socket, &client_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_file(&client_socket, Duration::from_secs(10)); + + // Connect and handshake. + let mut stream = UnixStream::connect(&client_socket).expect("should connect to client socket"); + let (version, error) = + client_handshake(&mut stream, 1, 80, 24).expect("handshake should succeed"); + assert_eq!(version, 1); + assert!(error.is_none(), "{:?}", error); + + // Drain initial frames. + drain_messages(&mut stream); + + // Send prefix key (Ctrl+B = 0x02) then 'q' (quit/detach in persistence mode). + send_input(&mut stream, &[0x02]).expect("send prefix"); + thread::sleep(Duration::from_millis(300)); + + // Drain any frames generated by entering navigate mode. + drain_messages(&mut stream); + + send_input(&mut stream, b"q").expect("send detach key"); + + // Give the server time to process the detach. + thread::sleep(Duration::from_millis(500)); + + // Verify server is still alive and responsive. + let response = ping_socket(&api_socket); + assert!( + response.contains("pong"), + "server should still respond to ping after client detach: {response}" + ); + + // The client should receive a ServerShutdown with reason "detached" + // shortly after the quit/detach key. There may be some frames in + // between from the mode change, so we read multiple messages. + stream + .set_read_timeout(Some(Duration::from_secs(5))) + .unwrap(); + let mut got_shutdown = false; + let deadline = Instant::now() + Duration::from_secs(5); + while Instant::now() < deadline { + match read_server_message(&mut stream) { + Ok((variant, _payload)) => { + if variant == 2 { + // ServerMessage::ServerShutdown — detach acknowledged. + got_shutdown = true; + break; + } + // Variant 1 = Frame — may arrive before the shutdown. + // Keep reading. + } + Err(_) => { + // Connection closed — also acceptable. + got_shutdown = true; // consider this a successful detach + break; + } + } + } + assert!( + got_shutdown, + "client should receive ServerShutdown after quit/detach key" + ); + + cleanup_spawned_herdr(spawned, base); +} + +#[test] +fn explicit_detach_message_causes_clean_disconnect() { + // Client sends ClientMessage::Detach + // directly (not via keybind), server handles it gracefully. + // This is the flow when the client process is exiting cleanly (Ctrl+C). + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + let spawned = spawn_server(&config_home, &runtime_dir, &api_socket, &client_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_file(&client_socket, Duration::from_secs(10)); + + // Connect and handshake. + let mut stream = UnixStream::connect(&client_socket).expect("should connect"); + let (version, error) = + client_handshake(&mut stream, 1, 80, 24).expect("handshake should succeed"); + assert_eq!(version, 1); + assert!(error.is_none(), "{:?}", error); + + // Drain initial frames. + drain_messages(&mut stream); + + // Send ClientMessage::Detach directly. + send_detach(&mut stream).expect("send detach message"); + + // Give the server time to process. + thread::sleep(Duration::from_millis(500)); + + // Verify server is still alive. + let response = ping_socket(&api_socket); + assert!( + response.contains("pong"), + "server should persist after client Detach message: {response}" + ); + + // The client connection should eventually be closed. + // After sending Detach, the server removes the client. + // We may still receive a few queued frames before the connection closes. + stream + .set_read_timeout(Some(Duration::from_secs(3))) + .unwrap(); + + // Drain remaining messages until EOF or error. + let mut got_eof = false; + let deadline = Instant::now() + Duration::from_secs(3); + while Instant::now() < deadline { + match read_server_message(&mut stream) { + Ok((variant, _)) => { + // May receive frames or other messages before disconnect. + let _ = variant; + } + Err(_) => { + got_eof = true; + break; + } + } + } + assert!( + got_eof, + "client connection should be closed after explicit Detach message" + ); + + cleanup_spawned_herdr(spawned, base); +} + +#[test] +fn reattach_after_detach_shows_current_state() { + // Flow: + // 1. Start server + // 2. Connect client A, create a workspace via API + // 3. Client A detaches + // 4. Connect client B (reattach), verify it receives a frame + // 5. Verify client B can see the workspace created by client A + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + let spawned = spawn_server(&config_home, &runtime_dir, &api_socket, &client_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_file(&client_socket, Duration::from_secs(10)); + + // --- Client A --- + let mut stream_a = UnixStream::connect(&client_socket).expect("client A should connect"); + let (version, error) = + client_handshake(&mut stream_a, 1, 80, 24).expect("handshake should succeed"); + assert_eq!(version, 1); + assert!(error.is_none(), "{:?}", error); + + // Drain initial frames. + drain_messages(&mut stream_a); + + // Create a workspace via API while client A is attached. + let mut ws_stream = UnixStream::connect(&api_socket).expect("connect to API"); + let request = r#"{"id":"1","method":"workspace.create","params":{"label":"reattach-test"}}"#; + writeln!(ws_stream, "{}", request).unwrap(); + let mut reader = BufReader::new(ws_stream); + let mut ws_response = String::new(); + reader.read_line(&mut ws_response).unwrap(); + assert!( + ws_response.contains("workspace_created") || ws_response.contains("ok"), + "workspace creation should succeed: {ws_response}" + ); + + // Give the server time to process and render. + thread::sleep(Duration::from_millis(300)); + + // Client A detaches (send ClientMessage::Detach). + send_detach(&mut stream_a).expect("send detach"); + + // Give the server time to process the detach. + thread::sleep(Duration::from_millis(500)); + + // Verify server is still alive. + let response = ping_socket(&api_socket); + assert!( + response.contains("pong"), + "server should persist after detach: {response}" + ); + + // --- Client B (reattach) --- + let mut stream_b = UnixStream::connect(&client_socket).expect("client B should connect"); + let (version, error) = + client_handshake(&mut stream_b, 1, 80, 24).expect("handshake should succeed"); + assert_eq!(version, 1); + assert!( + error.is_none(), + "reattach handshake should succeed: {:?}", + error + ); + + // Client B should receive a frame with the current state, + // including the workspace created while client A was attached. + stream_b.set_nonblocking(false).unwrap(); + stream_b + .set_read_timeout(Some(Duration::from_secs(5))) + .unwrap(); + + let mut received_frame = false; + let deadline = Instant::now() + Duration::from_secs(5); + while Instant::now() < deadline { + match read_server_message(&mut stream_b) { + Ok((variant, _payload)) => { + if variant == 1 { + // ServerMessage::Frame + received_frame = true; + break; + } + } + Err(_) => break, + } + } + assert!( + received_frame, + "reattached client should receive a Frame with current state" + ); + + // Verify the workspace still exists via API. + let mut list_stream = UnixStream::connect(&api_socket).expect("connect to API"); + let list_request = r#"{"id":"2","method":"workspace.list","params":{}}"#; + writeln!(list_stream, "{}", list_request).unwrap(); + let mut list_reader = BufReader::new(list_stream); + let mut list_response = String::new(); + list_reader.read_line(&mut list_response).unwrap(); + assert!( + list_response.contains("reattach-test"), + "workspace should still exist after detach/reattach: {list_response}" + ); + + cleanup_spawned_herdr(spawned, base); +} + +#[test] +fn processes_survive_during_and_after_detach() { + // PTY processes continue running during and after detach. + // + // Simplified flow: + // 1. Start server + // 2. Connect client, send "echo SURVIVED" to the pane + // 3. Detach client + // 4. Verify server is still alive and API works + // 5. Reattach and verify we can receive a frame + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + let spawned = spawn_server(&config_home, &runtime_dir, &api_socket, &client_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_file(&client_socket, Duration::from_secs(10)); + + // Verify server starts with a workspace (session restore or fresh state). + let response = ping_socket(&api_socket); + assert!( + response.contains("pong"), + "server should respond to ping: {response}" + ); + + // Connect and handshake. + let mut stream = UnixStream::connect(&client_socket).expect("should connect"); + let (version, error) = + client_handshake(&mut stream, 1, 80, 24).expect("handshake should succeed"); + assert_eq!(version, 1); + assert!(error.is_none(), "{:?}", error); + + // Drain initial frames. + drain_messages(&mut stream); + + // Send input to the pane — the fresh server should have at least one + // pane with a shell running. + send_input(&mut stream, b"echo SURVIVED_DETACH\n").expect("send echo command"); + + // Wait for the shell to process the command. + thread::sleep(Duration::from_millis(500)); + + // Drain any frames generated by the input. + drain_messages(&mut stream); + + // Detach the client via explicit Detach message. + send_detach(&mut stream).expect("send detach"); + thread::sleep(Duration::from_millis(500)); + + // Verify server is still alive after detach. + let response = ping_socket(&api_socket); + assert!( + response.contains("pong"), + "server should persist after detach: {response}" + ); + + // Wait a moment while detached. + thread::sleep(Duration::from_secs(1)); + + // Reattach — verify we can connect and receive a frame. + let mut stream_b = UnixStream::connect(&client_socket).expect("should reattach"); + let (version, error) = + client_handshake(&mut stream_b, 1, 80, 24).expect("reattach handshake should succeed"); + assert_eq!(version, 1); + assert!(error.is_none(), "{:?}", error); + + // Verify the reattached client receives a frame. + stream_b + .set_read_timeout(Some(Duration::from_secs(5))) + .unwrap(); + let mut received_frame = false; + let deadline = Instant::now() + Duration::from_secs(5); + while Instant::now() < deadline { + match read_server_message(&mut stream_b) { + Ok((variant, _)) => { + if variant == 1 { + received_frame = true; + break; + } + } + Err(_) => break, + } + } + assert!( + received_frame, + "reattached client should receive a Frame showing current state" + ); + + cleanup_spawned_herdr(spawned, base); +} + +#[test] +fn server_persists_after_client_connection_drop() { + // Server continues running after a client + // disconnects (not just detach — also connection drop). + // Verify that after a client connection is abruptly closed (not via Detach), + // the server continues running and can accept new connections. + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + let spawned = spawn_server(&config_home, &runtime_dir, &api_socket, &client_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_file(&client_socket, Duration::from_secs(10)); + + // Connect and handshake. + let mut stream = UnixStream::connect(&client_socket).expect("should connect"); + let (version, error) = + client_handshake(&mut stream, 1, 80, 24).expect("handshake should succeed"); + assert_eq!(version, 1); + assert!(error.is_none(), "{:?}", error); + + // Drain initial frames. + drain_messages(&mut stream); + + // Drop the connection abruptly (simulating client crash). + drop(stream); + + // Give the server time to detect the disconnection. + thread::sleep(Duration::from_millis(500)); + + // Verify server is still alive. + let response = ping_socket(&api_socket); + assert!( + response.contains("pong"), + "server should persist after client connection drop: {response}" + ); + + // Reattach — verify we can connect and handshake again. + let mut stream_b = UnixStream::connect(&client_socket).expect("should reattach"); + let (version, error) = + client_handshake(&mut stream_b, 1, 80, 24).expect("reattach handshake should succeed"); + assert_eq!(version, 1); + assert!(error.is_none(), "reattach should succeed: {:?}", error); + + cleanup_spawned_herdr(spawned, base); +} + +#[test] +fn output_accumulated_while_detached_visible_on_reattach() { + // Output produced while detached is visible in the + // reattached client's scrollback. + // + // Simplified flow: + // 1. Start server, attach client A + // 2. Detach client A (without sending any special input) + // 3. Use API to send text to a pane while detached + // 4. Reattach as client B + // 5. Verify client B receives a frame + // 6. Verify the pane content via API includes the text sent while detached + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + let spawned = spawn_server(&config_home, &runtime_dir, &api_socket, &client_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_file(&client_socket, Duration::from_secs(10)); + + // Connect and handshake client A. + let mut stream_a = UnixStream::connect(&client_socket).expect("client A should connect"); + let (version, error) = + client_handshake(&mut stream_a, 1, 80, 24).expect("handshake should succeed"); + assert_eq!(version, 1); + assert!(error.is_none(), "{:?}", error); + + // Detach client A immediately. + send_detach(&mut stream_a).expect("send detach"); + thread::sleep(Duration::from_millis(500)); + + // Verify server alive. + let response = ping_socket(&api_socket); + assert!( + response.contains("pong"), + "server should persist: {response}" + ); + + // Use API to send text to a pane while no client is attached. + // First create a workspace and find its pane. + let ws_create_response = workspace_create(&api_socket, "scrollback-test"); + assert_eq!(ws_create_response["result"]["type"], "workspace_created"); + + thread::sleep(Duration::from_millis(300)); + + // Find the workspace and pane IDs. + let ws_response = workspace_list(&api_socket); + let ws_id = workspace_id_by_label(&ws_response, "scrollback-test"); + + // Get pane list for this workspace. + let pane_response = pane_list(&api_socket, &ws_id); + let pane_id = first_pane_id(&pane_response); + + // Send text to the pane via API while detached. + let mut send_stream = UnixStream::connect(&api_socket).expect("connect to API"); + let send_request = format!( + r#"{{"id":"4","method":"pane.send_text","params":{{"pane_id":"{pane_id}","text":"echo DURING_DETACH\n"}}}}"# + ); + writeln!(send_stream, "{}", send_request).unwrap(); + let mut send_reader = BufReader::new(send_stream); + let mut send_response = String::new(); + send_reader.read_line(&mut send_response).unwrap(); + + // Wait for the echo command to execute. + thread::sleep(Duration::from_millis(500)); + + // --- Client B (reattach) --- + let mut stream_b = UnixStream::connect(&client_socket).expect("client B should connect"); + let (version, error) = + client_handshake(&mut stream_b, 1, 80, 24).expect("reattach handshake should succeed"); + assert_eq!(version, 1); + assert!(error.is_none(), "{:?}", error); + + // Client B should receive a frame with the current state. + stream_b + .set_read_timeout(Some(Duration::from_secs(5))) + .unwrap(); + let mut received_frame = false; + let deadline = Instant::now() + Duration::from_secs(5); + while Instant::now() < deadline { + match read_server_message(&mut stream_b) { + Ok((variant, _)) => { + if variant == 1 { + received_frame = true; + break; + } + } + Err(_) => break, + } + } + assert!( + received_frame, + "reattached client should receive a Frame showing current state" + ); + + // Verify the pane content via API includes the output sent while detached. + let read_response = pane_read_recent(&api_socket, &pane_id); + + // The pane output should contain the text sent while detached. + assert!( + read_response["result"]["read"]["text"] + .as_str() + .unwrap_or_default() + .contains("DURING_DETACH"), + "pane should contain output produced while detached: {read_response}" + ); + + cleanup_spawned_herdr(spawned, base); +} diff --git a/tests/multi_client.rs b/tests/multi_client.rs new file mode 100644 index 00000000..dee24f08 --- /dev/null +++ b/tests/multi_client.rs @@ -0,0 +1,1019 @@ +//! Integration tests for multi-client server behavior. + +mod support; + +use std::fs; +use std::io::{self, BufRead, BufReader, Read, Write}; +use std::os::unix::net::UnixStream; +use std::path::{Path, PathBuf}; +use std::sync::{Mutex, MutexGuard, OnceLock}; +use std::thread; +use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH}; + +use portable_pty::{native_pty_system, Child, CommandBuilder, MasterPty, PtySize}; +use serde::Deserialize; +use serde_json::Value; +use support::{ + cleanup_test_base, register_runtime_dir, register_spawned_herdr_pid, + unregister_spawned_herdr_pid, +}; + +fn unique_test_dir() -> PathBuf { + let nanos = SystemTime::now() + .duration_since(UNIX_EPOCH) + .map(|d| d.as_nanos()) + .unwrap_or(0); + PathBuf::from(format!( + "/tmp/herdr-multi-client-test-{}-{nanos}", + std::process::id() + )) +} + +struct SpawnedHerdr { + _master: Box<dyn MasterPty + Send>, + child: Box<dyn Child + Send + Sync>, +} + +impl Drop for SpawnedHerdr { + fn drop(&mut self) { + let pid = self.child.process_id(); + let _ = self.child.kill(); + + if let Some(pid) = pid { + let deadline = Instant::now() + Duration::from_secs(2); + while Instant::now() < deadline { + let mut status = 0; + let result = + unsafe { libc::waitpid(pid as libc::pid_t, &mut status, libc::WNOHANG) }; + if result == pid as libc::pid_t || result == -1 { + break; + } + thread::sleep(Duration::from_millis(20)); + } + + unregister_spawned_herdr_pid(Some(pid)); + } + } +} + +fn cleanup_spawned_herdr(spawned: SpawnedHerdr, base: PathBuf) { + drop(spawned); + cleanup_test_base(&base); +} + +fn wait_for_child_exit(child: &mut Box<dyn Child + Send + Sync>) { + let _ = child.kill(); + let _ = child.wait(); +} + +fn test_lock() -> MutexGuard<'static, ()> { + static LOCK: OnceLock<Mutex<()>> = OnceLock::new(); + LOCK.get_or_init(|| Mutex::new(())) + .lock() + .unwrap_or_else(|poisoned| poisoned.into_inner()) +} + +fn wait_for_socket(path: &Path, timeout: Duration) { + let deadline = Instant::now() + timeout; + while Instant::now() < deadline { + if path.exists() && UnixStream::connect(path).is_ok() { + return; + } + thread::sleep(Duration::from_millis(25)); + } + panic!("socket did not appear at {}", path.display()); +} + +fn wait_for_file(path: &Path, timeout: Duration) { + let deadline = Instant::now() + timeout; + while Instant::now() < deadline { + if path.exists() { + return; + } + thread::sleep(Duration::from_millis(25)); + } + panic!("file did not appear at {}", path.display()); +} + +fn spawn_server(config_home: &Path, runtime_dir: &Path, api_socket_path: &Path) -> SpawnedHerdr { + fs::create_dir_all(config_home.join("herdr")).unwrap(); + fs::create_dir_all(runtime_dir).unwrap(); + register_runtime_dir(runtime_dir); + fs::write( + config_home.join("herdr/config.toml"), + "onboarding = false\n", + ) + .unwrap(); + + let pair = native_pty_system() + .openpty(PtySize { + rows: 24, + cols: 80, + pixel_width: 0, + pixel_height: 0, + }) + .unwrap(); + + let mut cmd = CommandBuilder::new(env!("CARGO_BIN_EXE_herdr")); + cmd.arg("server"); + cmd.env("XDG_CONFIG_HOME", config_home); + cmd.env("XDG_RUNTIME_DIR", runtime_dir); + cmd.env("HERDR_SOCKET_PATH", api_socket_path); + cmd.env_remove("HERDR_CLIENT_SOCKET_PATH"); + cmd.env("SHELL", "/bin/sh"); + cmd.env_remove("HERDR_ENV"); + + let child = pair.slave.spawn_command(cmd).unwrap(); + register_spawned_herdr_pid(child.process_id()); + drop(pair.slave); + + SpawnedHerdr { + _master: pair.master, + child, + } +} + +fn spawn_client_process( + config_home: &Path, + runtime_dir: &Path, + api_socket_path: &Path, +) -> SpawnedHerdr { + register_runtime_dir(runtime_dir); + let pair = native_pty_system() + .openpty(PtySize { + rows: 24, + cols: 80, + pixel_width: 0, + pixel_height: 0, + }) + .unwrap(); + + let mut cmd = CommandBuilder::new(env!("CARGO_BIN_EXE_herdr")); + cmd.arg("client"); + cmd.env("XDG_CONFIG_HOME", config_home); + cmd.env("XDG_RUNTIME_DIR", runtime_dir); + cmd.env("HERDR_SOCKET_PATH", api_socket_path); + cmd.env_remove("HERDR_CLIENT_SOCKET_PATH"); + cmd.env("SHELL", "/bin/sh"); + cmd.env_remove("HERDR_ENV"); + + let child = pair.slave.spawn_command(cmd).unwrap(); + register_spawned_herdr_pid(child.process_id()); + drop(pair.slave); + + SpawnedHerdr { + _master: pair.master, + child, + } +} + +fn server_log_path(config_home: &Path) -> PathBuf { + let app_dir = if cfg!(debug_assertions) { + "herdr-dev" + } else { + "herdr" + }; + config_home.join(app_dir).join("herdr-server.log") +} + +fn count_log_occurrences(path: &Path, needle: &str) -> usize { + fs::read_to_string(path) + .ok() + .map(|text| text.lines().filter(|line| line.contains(needle)).count()) + .unwrap_or(0) +} + +fn wait_for_log_occurrence_count( + path: &Path, + needle: &str, + min_count: usize, + timeout: Duration, +) -> bool { + let deadline = Instant::now() + timeout; + while Instant::now() < deadline { + if count_log_occurrences(path, needle) >= min_count { + return true; + } + thread::sleep(Duration::from_millis(40)); + } + false +} + +fn ping_socket(socket_path: &Path) -> String { + let mut stream = UnixStream::connect(socket_path).expect("should connect to API socket"); + writeln!( + stream, + "{{\"id\":\"ping\",\"method\":\"ping\",\"params\":{{}}}}" + ) + .unwrap(); + + let mut reader = BufReader::new(stream); + let mut response = String::new(); + reader.read_line(&mut response).unwrap(); + response.trim().to_string() +} + +fn send_json_request(socket_path: &Path, request: &str) -> Value { + let mut stream = UnixStream::connect(socket_path).expect("should connect to API socket"); + writeln!(stream, "{request}").unwrap(); + + let mut reader = BufReader::new(stream); + let mut response = String::new(); + reader.read_line(&mut response).unwrap(); + + serde_json::from_str(&response).expect("response should be valid JSON") +} + +fn create_workspace_and_root_pane(socket_path: &Path, label: &str) -> (String, String) { + let response = send_json_request( + socket_path, + &format!( + "{{\"id\":\"ws_create\",\"method\":\"workspace.create\",\"params\":{{\"label\":\"{label}\"}}}}" + ), + ); + + if response.get("error").is_some() { + panic!("workspace.create failed: {response}"); + } + + let workspace_id = response + .pointer("/result/workspace/workspace_id") + .and_then(Value::as_str) + .expect("workspace.create should return workspace id") + .to_string(); + + let pane_id = response + .pointer("/result/root_pane/pane_id") + .and_then(Value::as_str) + .expect("workspace.create should return root pane id") + .to_string(); + + (workspace_id, pane_id) +} + +fn pane_send_input(socket_path: &Path, pane_id: &str, text: &str) { + let request = format!( + "{{\"id\":\"send_input\",\"method\":\"pane.send_input\",\"params\":{{\"pane_id\":\"{pane_id}\",\"text\":\"{}\",\"keys\":[\"Enter\"]}}}}", + text.replace('"', "\\\"") + ); + let response = send_json_request(socket_path, &request); + if response.get("error").is_some() { + panic!("pane.send_input failed: {response}"); + } +} + +fn pane_read_recent(socket_path: &Path, pane_id: &str, lines: usize) -> String { + let response = send_json_request( + socket_path, + &format!( + "{{\"id\":\"pane_read\",\"method\":\"pane.read\",\"params\":{{\"pane_id\":\"{pane_id}\",\"source\":\"recent\",\"lines\":{lines}}}}}" + ), + ); + + if response.get("error").is_some() { + panic!("pane.read failed: {response}"); + } + + response + .pointer("/result/read/text") + .and_then(Value::as_str) + .unwrap_or_default() + .to_string() +} + +fn pane_read_recent_contains( + socket_path: &Path, + pane_id: &str, + needle: &str, + timeout: Duration, +) -> bool { + let deadline = Instant::now() + timeout; + while Instant::now() < deadline { + if pane_read_recent(socket_path, pane_id, 200).contains(needle) { + return true; + } + thread::sleep(Duration::from_millis(50)); + } + false +} + +fn parse_size_after_marker(text: &str, marker: &str) -> Option<(u16, u16)> { + let mut seen_marker = false; + for line in text.lines() { + if !seen_marker { + if line.contains(marker) { + seen_marker = true; + } + continue; + } + + let mut parts = line.split_whitespace(); + let Some(rows_raw) = parts.next() else { + continue; + }; + let Some(cols_raw) = parts.next() else { + continue; + }; + + let Ok(rows) = rows_raw.parse::<u16>() else { + continue; + }; + let Ok(cols) = cols_raw.parse::<u16>() else { + continue; + }; + + return Some((rows, cols)); + } + + None +} + +fn try_read_pane_tty_size( + socket_path: &Path, + pane_id: &str, + timeout: Duration, +) -> Option<(u16, u16)> { + let marker = format!( + "SIZE_MARKER_{}_{}", + std::process::id(), + SystemTime::now() + .duration_since(UNIX_EPOCH) + .map(|d| d.as_nanos()) + .unwrap_or(0) + ); + + pane_send_input(socket_path, pane_id, &format!("echo {marker}; stty size")); + + let deadline = Instant::now() + timeout; + while Instant::now() < deadline { + let text = pane_read_recent(socket_path, pane_id, 200); + if let Some(size) = parse_size_after_marker(&text, &marker) { + return Some(size); + } + thread::sleep(Duration::from_millis(50)); + } + + None +} + +fn read_pane_tty_size(socket_path: &Path, pane_id: &str, timeout: Duration) -> (u16, u16) { + if let Some(size) = try_read_pane_tty_size(socket_path, pane_id, timeout) { + return size; + } + + let snapshot = pane_read_recent(socket_path, pane_id, 200); + panic!( + "did not observe tty size after marker. pane output:\n{}", + snapshot + ); +} + +// --------------------------------------------------------------------------- +// Minimal bincode v2 varint helpers for protocol tests +// --------------------------------------------------------------------------- + +fn encode_varint_u32(v: u32) -> Vec<u8> { + if v < 251 { + vec![v as u8] + } else if v < 65536 { + let mut buf = vec![251u8]; + buf.extend_from_slice(&(v as u16).to_le_bytes()); + buf + } else { + let mut buf = vec![252u8]; + buf.extend_from_slice(&v.to_le_bytes()); + buf + } +} + +fn encode_varint_u16(v: u16) -> Vec<u8> { + if v < 251 { + vec![v as u8] + } else { + let mut buf = vec![251u8]; + buf.extend_from_slice(&v.to_le_bytes()); + buf + } +} + +fn encode_varint_enum(variant_idx: u32, fields: &[&[u8]]) -> Vec<u8> { + let mut buf = encode_varint_u32(variant_idx); + for field in fields { + buf.extend_from_slice(field); + } + buf +} + +fn frame_message(payload: &[u8]) -> Vec<u8> { + let len = payload.len() as u32; + let mut framed = len.to_le_bytes().to_vec(); + framed.extend_from_slice(payload); + framed +} + +fn decode_varint_u32(payload: &[u8], offset: usize) -> Result<(u32, usize), String> { + if offset >= payload.len() { + return Err("payload too short for varint".into()); + } + let first_byte = payload[offset]; + match first_byte { + 0..=250 => Ok((first_byte as u32, 1)), + 251 => { + if offset + 3 > payload.len() { + return Err("payload too short for u16 varint".into()); + } + let v = u16::from_le_bytes( + payload[offset + 1..offset + 3] + .try_into() + .map_err(|e: std::array::TryFromSliceError| e.to_string())?, + ); + Ok((v as u32, 3)) + } + 252 => { + if offset + 5 > payload.len() { + return Err("payload too short for u32 varint".into()); + } + let v = u32::from_le_bytes( + payload[offset + 1..offset + 5] + .try_into() + .map_err(|e: std::array::TryFromSliceError| e.to_string())?, + ); + Ok((v, 5)) + } + _ => Err(format!("unsupported varint tag: {first_byte}")), + } +} + +fn is_timeout(err: &io::Error) -> bool { + matches!( + err.kind(), + io::ErrorKind::TimedOut | io::ErrorKind::WouldBlock + ) +} + +fn read_server_variant(stream: &mut UnixStream, timeout: Duration) -> io::Result<u32> { + stream.set_read_timeout(Some(timeout))?; + + let mut len_buf = [0u8; 4]; + stream.read_exact(&mut len_buf)?; + let len = u32::from_le_bytes(len_buf) as usize; + if len == 0 { + return Err(io::Error::new( + io::ErrorKind::InvalidData, + "zero-length payload", + )); + } + + let mut payload = vec![0u8; len]; + stream.read_exact(&mut payload)?; + + let (variant, _consumed) = decode_varint_u32(&payload, 0) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?; + Ok(variant) +} + +fn client_handshake( + stream: &mut UnixStream, + version: u32, + cols: u16, + rows: u16, +) -> Result<(), String> { + stream + .set_read_timeout(Some(Duration::from_secs(5))) + .map_err(|e| e.to_string())?; + + // ClientMessage::Hello = variant 0 + let hello_payload = encode_varint_enum( + 0, + &[ + &encode_varint_u32(version), + &encode_varint_u16(cols), + &encode_varint_u16(rows), + ], + ); + stream + .write_all(&frame_message(&hello_payload)) + .map_err(|e| e.to_string())?; + stream.flush().map_err(|e| e.to_string())?; + + // Read ServerMessage::Welcome = variant 0 + let mut len_buf = [0u8; 4]; + stream.read_exact(&mut len_buf).map_err(|e| e.to_string())?; + let len = u32::from_le_bytes(len_buf) as usize; + let mut payload = vec![0u8; len]; + stream.read_exact(&mut payload).map_err(|e| e.to_string())?; + + let mut offset = 0; + let (variant, consumed) = decode_varint_u32(&payload, offset)?; + offset += consumed; + if variant != 0 { + return Err(format!("expected Welcome variant 0, got {variant}")); + } + + let (_server_version, consumed) = decode_varint_u32(&payload, offset)?; + offset += consumed; + + if offset >= payload.len() { + return Err("payload too short for Welcome.error option tag".into()); + } + let option_tag = payload[offset]; + offset += 1; + + if option_tag == 1 { + let (str_len, consumed) = decode_varint_u32(&payload, offset)?; + offset += consumed; + let str_len = str_len as usize; + if offset + str_len > payload.len() { + return Err("payload too short for welcome error string".into()); + } + let err = String::from_utf8(payload[offset..offset + str_len].to_vec()) + .map_err(|e| e.to_string())?; + return Err(format!("handshake rejected: {err}")); + } + + Ok(()) +} + +fn connect_raw_client(client_socket: &Path, cols: u16, rows: u16) -> UnixStream { + let mut stream = UnixStream::connect(client_socket).expect("should connect to client socket"); + client_handshake(&mut stream, 1, cols, rows).expect("handshake should succeed"); + stream +} + +fn send_client_input(stream: &mut UnixStream, data: &[u8]) { + // ClientMessage::Input = variant 1 + let payload = { + let mut buf = encode_varint_u32(1); + buf.extend_from_slice(&encode_varint_u32(data.len() as u32)); + buf.extend_from_slice(data); + buf + }; + stream.write_all(&frame_message(&payload)).unwrap(); + stream.flush().unwrap(); +} + +fn send_client_detach(stream: &mut UnixStream) { + // ClientMessage::Detach = variant 3 + let payload = encode_varint_u32(3); + stream.write_all(&frame_message(&payload)).unwrap(); + stream.flush().unwrap(); +} + +#[derive(Debug, Deserialize)] +struct FrameWire { + cells: Vec<CellWire>, + width: u16, + height: u16, + cursor: Option<CursorWire>, +} + +#[derive(Debug, Deserialize)] +struct CellWire { + symbol: String, + fg: u32, + bg: u32, + modifier: u16, + skip: bool, +} + +#[derive(Debug, Deserialize)] +struct CursorWire { + x: u16, + y: u16, + visible: bool, +} + +fn decode_frame_payload(payload: &[u8]) -> io::Result<FrameWire> { + bincode::serde::decode_from_slice(payload, bincode::config::standard()) + .map(|(frame, consumed)| (frame, consumed)) + .map_err(|err| io::Error::new(io::ErrorKind::InvalidData, err.to_string())) + .and_then(|(frame, consumed): (FrameWire, usize)| { + if consumed != payload.len() { + return Err(io::Error::new( + io::ErrorKind::InvalidData, + format!( + "frame payload had trailing bytes: consumed={}, len={}", + consumed, + payload.len() + ), + )); + } + Ok(frame) + }) +} + +fn read_server_message_payload( + stream: &mut UnixStream, + timeout: Duration, +) -> io::Result<(u32, Vec<u8>)> { + stream.set_read_timeout(Some(timeout))?; + + let mut len_buf = [0u8; 4]; + stream.read_exact(&mut len_buf)?; + let len = u32::from_le_bytes(len_buf) as usize; + if len == 0 { + return Err(io::Error::new( + io::ErrorKind::InvalidData, + "zero-length payload", + )); + } + + let mut payload = vec![0u8; len]; + stream.read_exact(&mut payload)?; + + let (variant, consumed) = decode_varint_u32(&payload, 0) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?; + + Ok((variant, payload[consumed..].to_vec())) +} + +fn drain_server_messages(stream: &mut UnixStream, max_drain: Duration) { + let deadline = Instant::now() + max_drain; + while Instant::now() < deadline { + match read_server_variant(stream, Duration::from_millis(50)) { + Ok(_) => {} + Err(err) if is_timeout(&err) => break, + Err(_) => break, + } + } +} + +fn wait_for_frame(stream: &mut UnixStream, timeout: Duration) -> bool { + let deadline = Instant::now() + timeout; + while Instant::now() < deadline { + let remaining = deadline.saturating_duration_since(Instant::now()); + let slice = remaining.min(Duration::from_millis(75)); + match read_server_variant(stream, slice) { + Ok(1) => return true, // ServerMessage::Frame + Ok(_) => {} + Err(err) if is_timeout(&err) => {} + Err(_) => return false, + } + } + false +} + +fn wait_for_frame_matching( + stream: &mut UnixStream, + timeout: Duration, + predicate: impl Fn(&FrameWire) -> bool, +) -> io::Result<bool> { + let deadline = Instant::now() + timeout; + while Instant::now() < deadline { + let slice = deadline + .saturating_duration_since(Instant::now()) + .min(Duration::from_millis(80)); + match read_server_message_payload(stream, slice) { + Ok((1, frame_payload)) => { + let frame = decode_frame_payload(&frame_payload)?; + if predicate(&frame) { + return Ok(true); + } + } + Ok((_variant, _payload)) => {} + Err(err) if is_timeout(&err) => {} + Err(err) => return Err(err), + } + } + + Ok(false) +} + +fn frame_contains_text(frame: &FrameWire, needle: &str) -> bool { + if frame.cells.is_empty() { + return false; + } + + let row_width = frame.width.max(1) as usize; + let mut full_text = String::new(); + + for row in frame.cells.chunks(row_width) { + for cell in row { + let _ = (cell.fg, cell.bg, cell.modifier, cell.skip); + full_text.push_str(&cell.symbol); + } + full_text.push('\n'); + } + + let _ = frame.height; + if let Some(cursor) = frame.cursor.as_ref() { + let _ = (cursor.x, cursor.y, cursor.visible); + } + + full_text.contains(needle) +} + +#[test] +fn multi_client_allows_multiple_simultaneous_connections() { + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + let server = spawn_server(&config_home, &runtime_dir, &api_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_file(&client_socket, Duration::from_secs(10)); + + let mut client_a = connect_raw_client(&client_socket, 120, 40); + let mut client_b = connect_raw_client(&client_socket, 100, 30); + + assert!( + wait_for_frame(&mut client_a, Duration::from_secs(2)), + "client A should receive frames" + ); + assert!( + wait_for_frame(&mut client_b, Duration::from_secs(2)), + "client B should receive frames" + ); + + let ping = ping_socket(&api_socket); + assert!( + ping.contains("pong"), + "server should remain responsive: {ping}" + ); + + cleanup_spawned_herdr(server, base); +} + +#[test] +fn multi_client_effective_size_shrinks_when_smaller_client_joins() { + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + let server = spawn_server(&config_home, &runtime_dir, &api_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_file(&client_socket, Duration::from_secs(10)); + + let (_workspace_id, pane_id) = create_workspace_and_root_pane(&api_socket, "size-shrink"); + + let mut large = connect_raw_client(&client_socket, 120, 40); + assert!(wait_for_frame(&mut large, Duration::from_secs(2))); + let large_only_size = read_pane_tty_size(&api_socket, &pane_id, Duration::from_secs(5)); + + let mut small = connect_raw_client(&client_socket, 80, 24); + assert!(wait_for_frame(&mut small, Duration::from_secs(2))); + let with_small_size = read_pane_tty_size(&api_socket, &pane_id, Duration::from_secs(5)); + + assert!( + with_small_size.0 < large_only_size.0 && with_small_size.1 < large_only_size.1, + "effective pane size should shrink when smaller client joins: before={:?}, after={:?}", + large_only_size, + with_small_size + ); + + cleanup_spawned_herdr(server, base); +} + +#[test] +fn multi_client_broadcasts_frame_updates_to_all_clients_within_500ms() { + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + let server = spawn_server(&config_home, &runtime_dir, &api_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_file(&client_socket, Duration::from_secs(10)); + + let mut client_a = connect_raw_client(&client_socket, 100, 30); + let mut client_b = connect_raw_client(&client_socket, 100, 30); + + // Ensure we have an active pane that can reflect input changes. + let (_workspace_id, pane_id) = + create_workspace_and_root_pane(&api_socket, "broadcast-client-a-to-b"); + + // Drain initial frames so we measure the frame caused by new input. + drain_server_messages(&mut client_a, Duration::from_millis(300)); + drain_server_messages(&mut client_b, Duration::from_millis(300)); + + let marker = format!( + "MB{}", + SystemTime::now() + .duration_since(UNIX_EPOCH) + .map(|d| d.as_millis()) + .unwrap_or(0) + ); + + let start = Instant::now(); + send_client_input(&mut client_a, marker.as_bytes()); + let received = wait_for_frame_matching(&mut client_b, Duration::from_millis(500), |frame| { + frame_contains_text(frame, &marker) + }) + .expect("frame decoding should succeed"); + + assert!( + received, + "client B should receive a broadcast frame containing client A marker within 500ms" + ); + assert!( + start.elapsed() <= Duration::from_millis(500), + "broadcast frame containing marker should arrive within 500ms, got {:?}", + start.elapsed() + ); + assert!( + pane_read_recent_contains(&api_socket, &pane_id, &marker, Duration::from_secs(5)), + "pane output should include client A marker so broadcast reflects a real state change" + ); + + cleanup_spawned_herdr(server, base); +} + +#[test] +fn multi_client_disconnect_recalculates_to_next_smallest() { + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + let server = spawn_server(&config_home, &runtime_dir, &api_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_file(&client_socket, Duration::from_secs(10)); + + let (_workspace_id, pane_id) = + create_workspace_and_root_pane(&api_socket, "size-next-smallest"); + + let mut c120 = connect_raw_client(&client_socket, 120, 40); + let mut c100 = connect_raw_client(&client_socket, 100, 30); + let mut c80 = connect_raw_client(&client_socket, 80, 24); + + assert!(wait_for_frame(&mut c120, Duration::from_secs(2))); + assert!(wait_for_frame(&mut c100, Duration::from_secs(2))); + assert!(wait_for_frame(&mut c80, Duration::from_secs(2))); + + let size_with_three = read_pane_tty_size(&api_socket, &pane_id, Duration::from_secs(5)); + + // Smallest client disconnects; effective size should increase to the next-smallest. + send_client_detach(&mut c80); + drop(c80); + + let deadline = Instant::now() + Duration::from_secs(8); + let mut size_after_smallest_disconnect = None; + while Instant::now() < deadline { + let maybe_size = try_read_pane_tty_size(&api_socket, &pane_id, Duration::from_millis(400)); + if let Some(size) = maybe_size { + if size.0 > size_with_three.0 && size.1 > size_with_three.1 { + size_after_smallest_disconnect = Some(size); + break; + } + } + thread::sleep(Duration::from_millis(60)); + } + + assert!( + size_after_smallest_disconnect.is_some(), + "effective pane size should increase after smallest disconnects: before={:?}, last_seen={:?}", + size_with_three, + try_read_pane_tty_size(&api_socket, &pane_id, Duration::from_millis(300)) + ); + + cleanup_spawned_herdr(server, base); +} + +#[test] +fn multi_client_smallest_leaving_resizes_up_for_remaining_clients() { + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + let server = spawn_server(&config_home, &runtime_dir, &api_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_file(&client_socket, Duration::from_secs(10)); + + let (_workspace_id, pane_id) = create_workspace_and_root_pane(&api_socket, "size-resize-up"); + + let mut large = connect_raw_client(&client_socket, 120, 40); + let mut small = connect_raw_client(&client_socket, 80, 24); + + assert!(wait_for_frame(&mut large, Duration::from_secs(2))); + assert!(wait_for_frame(&mut small, Duration::from_secs(2))); + + let size_with_small_client = read_pane_tty_size(&api_socket, &pane_id, Duration::from_secs(5)); + + drain_server_messages(&mut large, Duration::from_millis(250)); + + send_client_detach(&mut small); + drop(small); + + // Remaining client should receive a new (larger) frame. + assert!( + wait_for_frame(&mut large, Duration::from_secs(2)), + "remaining client should receive resized-up frame" + ); + + let size_after_small_leaves = read_pane_tty_size(&api_socket, &pane_id, Duration::from_secs(5)); + + assert!( + size_after_small_leaves.0 > size_with_small_client.0 + && size_after_small_leaves.1 > size_with_small_client.1, + "remaining clients should get larger effective pane size after smallest leaves: before={:?}, after={:?}", + size_with_small_client, + size_after_small_leaves + ); + + cleanup_spawned_herdr(server, base); +} + +#[test] +fn multi_client_client_crash_sigkill_does_not_affect_server() { + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + let server = spawn_server(&config_home, &runtime_dir, &api_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_file(&client_socket, Duration::from_secs(10)); + + let mut survivor = connect_raw_client(&client_socket, 100, 30); + assert!(wait_for_frame(&mut survivor, Duration::from_secs(2))); + + let log_path = server_log_path(&config_home); + let connected_before = count_log_occurrences(&log_path, "client connected"); + + let crashing_client = spawn_client_process(&config_home, &runtime_dir, &api_socket); + + let attached_before_kill = wait_for_log_occurrence_count( + &log_path, + "client connected", + connected_before + 1, + Duration::from_secs(8), + ); + assert!( + attached_before_kill, + "thin client must complete handshake/attachment before SIGKILL" + ); + + if let Some(pid) = crashing_client.child.process_id() { + unsafe { + libc::kill(pid as libc::pid_t, libc::SIGKILL); + } + } + let mut crashing_client = crashing_client; + wait_for_child_exit(&mut crashing_client.child); + + let ping = ping_socket(&api_socket); + assert!( + ping.contains("pong"), + "server should stay healthy after SIGKILLed client: {ping}" + ); + + drain_server_messages(&mut survivor, Duration::from_millis(250)); + send_client_input(&mut survivor, b"echo survivor-still-works\n"); + assert!( + wait_for_frame(&mut survivor, Duration::from_secs(2)), + "remaining client should continue receiving frames" + ); + + cleanup_spawned_herdr(server, base); +} + +#[test] +fn multi_client_rapid_connect_disconnect_stress_10_cycles() { + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + let server = spawn_server(&config_home, &runtime_dir, &api_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_file(&client_socket, Duration::from_secs(10)); + + for i in 0..10u16 { + let mut client = connect_raw_client(&client_socket, 80 + i, 24 + (i % 4)); + let _ = wait_for_frame(&mut client, Duration::from_millis(500)); + send_client_detach(&mut client); + drop(client); + thread::sleep(Duration::from_millis(40)); + } + + let ping = ping_socket(&api_socket); + assert!( + ping.contains("pong"), + "server should remain healthy after rapid connect/disconnect: {ping}" + ); + + let mut final_client = connect_raw_client(&client_socket, 100, 30); + assert!( + wait_for_frame(&mut final_client, Duration::from_secs(2)), + "new client should still connect and receive frames after stress" + ); + + cleanup_spawned_herdr(server, base); +} diff --git a/tests/server_headless.rs b/tests/server_headless.rs new file mode 100644 index 00000000..98ca0b08 --- /dev/null +++ b/tests/server_headless.rs @@ -0,0 +1,713 @@ +//! Integration tests for headless server mode. + +mod support; + +use std::fs; +use std::io::{BufRead, BufReader, Read, Write}; +use std::os::unix::fs::FileTypeExt; +use std::os::unix::net::UnixStream; +use std::path::{Path, PathBuf}; +use std::sync::{Mutex, MutexGuard, OnceLock}; +use std::thread; +use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH}; + +use portable_pty::{native_pty_system, Child, CommandBuilder, MasterPty, PtySize}; +use support::{ + cleanup_test_base, register_runtime_dir, register_spawned_herdr_pid, + unregister_spawned_herdr_pid, +}; + +fn unique_test_dir() -> PathBuf { + let nanos = SystemTime::now() + .duration_since(UNIX_EPOCH) + .map(|d| d.as_nanos()) + .unwrap_or(0); + PathBuf::from(format!( + "/tmp/herdr-server-test-{}-{nanos}", + std::process::id() + )) +} + +struct SpawnedHerdr { + _master: Box<dyn MasterPty + Send>, + child: Box<dyn Child + Send + Sync>, +} + +impl Drop for SpawnedHerdr { + fn drop(&mut self) { + let pid = self.child.process_id(); + let _ = self.child.kill(); + + if let Some(pid) = pid { + let deadline = Instant::now() + Duration::from_secs(2); + while Instant::now() < deadline { + let mut status = 0; + let result = + unsafe { libc::waitpid(pid as libc::pid_t, &mut status, libc::WNOHANG) }; + if result == pid as libc::pid_t || result == -1 { + break; + } + thread::sleep(Duration::from_millis(20)); + } + + unregister_spawned_herdr_pid(Some(pid)); + } + } +} + +fn cleanup_spawned_herdr(spawned: SpawnedHerdr, base: PathBuf) { + drop(spawned); + cleanup_test_base(&base); +} + +fn test_lock() -> MutexGuard<'static, ()> { + static LOCK: OnceLock<Mutex<()>> = OnceLock::new(); + LOCK.get_or_init(|| Mutex::new(())) + .lock() + .unwrap_or_else(|poisoned| poisoned.into_inner()) +} + +fn wait_for_socket(path: &Path, timeout: Duration) { + let deadline = Instant::now() + timeout; + while Instant::now() < deadline { + if path.exists() && UnixStream::connect(path).is_ok() { + return; + } + thread::sleep(Duration::from_millis(25)); + } + panic!("socket did not appear at {}", path.display()); +} + +fn wait_for_file(path: &Path, timeout: Duration) { + let deadline = Instant::now() + timeout; + while Instant::now() < deadline { + if path.exists() { + return; + } + thread::sleep(Duration::from_millis(25)); + } + panic!("file did not appear at {}", path.display()); +} + +fn spawn_server( + config_home: &Path, + runtime_dir: &Path, + api_socket_path: &Path, + _client_socket_path: &Path, +) -> SpawnedHerdr { + fs::create_dir_all(config_home.join("herdr")).unwrap(); + fs::create_dir_all(runtime_dir).unwrap(); + register_runtime_dir(runtime_dir); + fs::write( + config_home.join("herdr/config.toml"), + "onboarding = false\n", + ) + .unwrap(); + + let pair = native_pty_system() + .openpty(PtySize { + rows: 24, + cols: 80, + pixel_width: 0, + pixel_height: 0, + }) + .unwrap(); + + let mut cmd = CommandBuilder::new(env!("CARGO_BIN_EXE_herdr")); + cmd.arg("server"); + cmd.env("XDG_CONFIG_HOME", config_home); + cmd.env("XDG_RUNTIME_DIR", runtime_dir); + cmd.env("HERDR_SOCKET_PATH", api_socket_path); + cmd.env_remove("HERDR_CLIENT_SOCKET_PATH"); + cmd.env("SHELL", "/bin/sh"); + cmd.env_remove("HERDR_ENV"); + + let child = pair.slave.spawn_command(cmd).unwrap(); + register_spawned_herdr_pid(child.process_id()); + drop(pair.slave); + + SpawnedHerdr { + _master: pair.master, + child, + } +} + +fn ping_socket(socket_path: &Path) -> String { + let mut stream = UnixStream::connect(socket_path).expect("should connect to API socket"); + + let request = r#"{"id":"1","method":"ping","params":{}}"#; + writeln!(stream, "{}", request).unwrap(); + + let mut reader = BufReader::new(stream); + let mut response = String::new(); + reader.read_line(&mut response).unwrap(); + response.trim().to_string() +} + +/// Sends a Hello message over the client socket and reads the Welcome response. +/// Uses bincode v2 wire format: [u32LE length][bincode payload] +/// bincode v2 standard config uses VarintEncoding: +/// - Integers < 251 are encoded as a single byte +/// - Enum variant index is encoded as u32 varint +/// - Option discriminant is always a single byte (0=None, 1=Some) +/// - String: length (varint) + UTF-8 bytes +fn client_handshake( + stream: &mut UnixStream, + version: u32, + cols: u16, + rows: u16, +) -> Result<(u32, Option<String>), String> { + stream + .set_read_timeout(Some(Duration::from_secs(5))) + .map_err(|e| e.to_string())?; + + // Encode Hello message using bincode v2 varint format. + // ClientMessage::Hello is variant 0. + let hello_payload = encode_varint_enum( + 0, + &[ + &encode_varint_u32(version), + &encode_varint_u16(cols), + &encode_varint_u16(rows), + ], + ); + let framed = frame_message(&hello_payload); + stream.write_all(&framed).map_err(|e| e.to_string())?; + stream.flush().map_err(|e| e.to_string())?; + + // Read the framed response. + let mut len_buf = [0u8; 4]; + stream.read_exact(&mut len_buf).map_err(|e| e.to_string())?; + let len = u32::from_le_bytes(len_buf) as usize; + + if len > 2 * 1024 * 1024 { + return Err(format!("oversized response: {len}")); + } + + let mut payload = vec![0u8; len]; + stream.read_exact(&mut payload).map_err(|e| e.to_string())?; + + // Decode Welcome: ServerMessage variant 0 = Welcome { version: u32, error: Option<String> } + decode_welcome(&payload) +} + +/// Encode a varint u32 value according to bincode v2 VarintEncoding. +fn encode_varint_u32(v: u32) -> Vec<u8> { + if v < 251 { + vec![v as u8] + } else if v < 65536 { + let mut buf = vec![251u8]; + buf.extend_from_slice(&(v as u16).to_le_bytes()); + buf + } else { + let mut buf = vec![252u8]; + buf.extend_from_slice(&v.to_le_bytes()); + buf + } +} + +/// Encode a varint u16 value. +fn encode_varint_u16(v: u16) -> Vec<u8> { + if v < 251 { + vec![v as u8] + } else { + let mut buf = vec![251u8]; + buf.extend_from_slice(&v.to_le_bytes()); + buf + } +} + +/// Encode an enum variant with its fields. +fn encode_varint_enum(variant_idx: u32, fields: &[&[u8]]) -> Vec<u8> { + let mut buf = encode_varint_u32(variant_idx); + for field in fields { + buf.extend_from_slice(field); + } + buf +} + +/// Frame a message with u32LE length prefix. +fn frame_message(payload: &[u8]) -> Vec<u8> { + let len = payload.len() as u32; + let mut framed = len.to_le_bytes().to_vec(); + framed.extend_from_slice(payload); + framed +} + +/// Decode a varint u32 from a byte slice at the given offset. +/// Returns (value, bytes_consumed). +fn decode_varint_u32(payload: &[u8], offset: usize) -> Result<(u32, usize), String> { + if offset >= payload.len() { + return Err("payload too short for varint".into()); + } + let first_byte = payload[offset]; + match first_byte { + 0..=250 => Ok((first_byte as u32, 1)), + 251 => { + if offset + 3 > payload.len() { + return Err("payload too short for u16 varint".into()); + } + let v = u16::from_le_bytes( + payload[offset + 1..offset + 3] + .try_into() + .map_err(|e: std::array::TryFromSliceError| e.to_string())?, + ); + Ok((v as u32, 3)) + } + 252 => { + if offset + 5 > payload.len() { + return Err("payload too short for u32 varint".into()); + } + let v = u32::from_le_bytes( + payload[offset + 1..offset + 5] + .try_into() + .map_err(|e: std::array::TryFromSliceError| e.to_string())?, + ); + Ok((v, 5)) + } + _ => Err(format!("unsupported varint tag: {first_byte}")), + } +} + +/// Decode a varint u16 from a byte slice at the given offset. +#[allow(dead_code)] +fn decode_varint_u16(payload: &[u8], offset: usize) -> Result<(u16, usize), String> { + if offset >= payload.len() { + return Err("payload too short for varint".into()); + } + let first_byte = payload[offset]; + match first_byte { + 0..=250 => Ok((first_byte as u16, 1)), + 251 => { + if offset + 3 > payload.len() { + return Err("payload too short for u16 varint".into()); + } + let v = u16::from_le_bytes( + payload[offset + 1..offset + 3] + .try_into() + .map_err(|e: std::array::TryFromSliceError| e.to_string())?, + ); + Ok((v, 3)) + } + _ => Err(format!("unsupported varint tag for u16: {first_byte}")), + } +} + +/// Decode a ServerMessage::Welcome from bincode v2 payload. +fn decode_welcome(payload: &[u8]) -> Result<(u32, Option<String>), String> { + let mut offset = 0; + + // Variant index (should be 0 for Welcome) + let (variant, consumed) = decode_varint_u32(payload, offset)?; + offset += consumed; + if variant != 0 { + return Err(format!( + "expected Welcome (variant 0), got variant {variant}" + )); + } + + // version: u32 + let (version, consumed) = decode_varint_u32(payload, offset)?; + offset += consumed; + + // error: Option<String> — discriminant is always 1 byte + if offset >= payload.len() { + return Err("payload too short for Option tag".into()); + } + let option_tag = payload[offset]; + offset += 1; + + let error = if option_tag == 1 { + // Some(String) — length as varint + UTF-8 bytes + let (str_len, consumed) = decode_varint_u32(payload, offset)?; + offset += consumed; + let str_len = str_len as usize; + + if offset + str_len > payload.len() { + return Err("payload too short for string content".into()); + } + let s = String::from_utf8(payload[offset..offset + str_len].to_vec()) + .map_err(|e| e.to_string())?; + Some(s) + } else { + None + }; + + Ok((version, error)) +} + +// --------------------------------------------------------------------------- +// Tests +// --------------------------------------------------------------------------- + +#[test] +fn server_creates_both_sockets() { + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + let spawned = spawn_server(&config_home, &runtime_dir, &api_socket, &client_socket); + + // Wait for both sockets to appear. + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_file(&client_socket, Duration::from_secs(10)); + + // Verify the client socket is a socket file. + let metadata = fs::metadata(&client_socket).unwrap(); + let file_type = metadata.file_type(); + assert!( + file_type.is_socket(), + "client socket should be a socket file" + ); + + // Verify the API socket works. + let response = ping_socket(&api_socket); + assert!( + response.contains("pong"), + "ping should return pong: {response}" + ); + + cleanup_spawned_herdr(spawned, base); +} + +#[test] +fn server_starts_without_terminal() { + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + let spawned = spawn_server(&config_home, &runtime_dir, &api_socket, &client_socket); + + // Wait for the API socket to appear — proves the server started. + wait_for_socket(&api_socket, Duration::from_secs(10)); + + // The server process should be running. + if let Some(pid) = spawned.child.process_id() { + let result = unsafe { libc::kill(pid as libc::pid_t, 0) }; + assert_eq!(result, 0, "server process should be running"); + } + + cleanup_spawned_herdr(spawned, base); +} + +#[test] +fn server_api_responds_to_ping() { + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + let spawned = spawn_server(&config_home, &runtime_dir, &api_socket, &client_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + + // Ping the API socket. + let response = ping_socket(&api_socket); + assert!( + response.contains("pong"), + "API should respond to ping: {response}" + ); + + cleanup_spawned_herdr(spawned, base); +} + +#[test] +fn server_removes_client_socket_on_exit() { + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + let mut spawned = spawn_server(&config_home, &runtime_dir, &api_socket, &client_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_file(&client_socket, Duration::from_secs(10)); + + // Kill the server. + let _ = spawned.child.kill(); + let _ = spawned.child.wait(); + + // Give it a moment to clean up. + thread::sleep(Duration::from_millis(300)); + + // The client socket should be removed (best-effort by Drop). + // If it still exists, it should be stale (not connectable). + if client_socket.exists() { + assert!( + UnixStream::connect(&client_socket).is_err(), + "stale client socket should not accept connections" + ); + } + + drop(spawned); + cleanup_test_base(&base); +} + +#[test] +fn server_cleans_up_stale_client_socket() { + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + // Create a stale client socket file (simulating a crashed server). + fs::create_dir_all(&runtime_dir).unwrap(); + register_runtime_dir(&runtime_dir); + { + let _listener = std::os::unix::net::UnixListener::bind(&client_socket).unwrap(); + // Drop the listener so the socket becomes stale. + } + + // Now start the server — it should clean up the stale socket. + let spawned = spawn_server(&config_home, &runtime_dir, &api_socket, &client_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + + // The API should work. + let response = ping_socket(&api_socket); + assert!( + response.contains("pong"), + "API should respond to ping: {response}" + ); + + cleanup_spawned_herdr(spawned, base); +} + +#[test] +fn server_persists_after_client_disconnect() { + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + let spawned = spawn_server(&config_home, &runtime_dir, &api_socket, &client_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_file(&client_socket, Duration::from_secs(10)); + + // Connect to the client socket and then immediately disconnect. + { + let _stream = UnixStream::connect(&client_socket).expect("should connect to client socket"); + // Immediately drop the connection. + } + + // Give the server a moment to process the disconnect. + thread::sleep(Duration::from_millis(200)); + + // The server should still be running and the API should still respond. + let response = ping_socket(&api_socket); + assert!( + response.contains("pong"), + "API should still respond after client disconnect: {response}" + ); + + cleanup_spawned_herdr(spawned, base); +} + +#[test] +fn duplicate_server_start_fails_gracefully() { + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + // Start the first server. + let spawned1 = spawn_server(&config_home, &runtime_dir, &api_socket, &client_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + + // Try to start a second server — it should fail. + let pair = native_pty_system() + .openpty(PtySize { + rows: 24, + cols: 80, + pixel_width: 0, + pixel_height: 0, + }) + .unwrap(); + + let mut cmd = CommandBuilder::new(env!("CARGO_BIN_EXE_herdr")); + cmd.arg("server"); + cmd.env("XDG_CONFIG_HOME", &config_home); + cmd.env("XDG_RUNTIME_DIR", &runtime_dir); + cmd.env("HERDR_SOCKET_PATH", &api_socket); + cmd.env_remove("HERDR_CLIENT_SOCKET_PATH"); + cmd.env("SHELL", "/bin/sh"); + cmd.env_remove("HERDR_ENV"); + + let mut child2 = pair.slave.spawn_command(cmd).unwrap(); + register_spawned_herdr_pid(child2.process_id()); + drop(pair.slave); + + // Wait for the second server to exit. + let exit_status = child2.wait().unwrap(); + unregister_spawned_herdr_pid(child2.process_id()); + + // The second server should exit with a non-zero code. + assert!(!exit_status.success(), "duplicate server start should fail"); + + cleanup_spawned_herdr(spawned1, base); +} + +#[test] +fn client_handshake_succeeds() { + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + let spawned = spawn_server(&config_home, &runtime_dir, &api_socket, &client_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_file(&client_socket, Duration::from_secs(10)); + + // Connect to the client socket and perform a handshake. + let mut stream = UnixStream::connect(&client_socket).expect("should connect to client socket"); + + // Send Hello with version 1, 80 cols, 24 rows. + let (version, error) = + client_handshake(&mut stream, 1, 80, 24).expect("handshake should succeed"); + + assert_eq!(version, 1, "server should report protocol version 1"); + assert!( + error.is_none(), + "handshake should not have an error: {:?}", + error + ); + + cleanup_spawned_herdr(spawned, base); +} + +#[test] +fn client_handshake_rejects_incompatible_version() { + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + let spawned = spawn_server(&config_home, &runtime_dir, &api_socket, &client_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_file(&client_socket, Duration::from_secs(10)); + + // Connect to the client socket and send Hello with version 0 (pre-persistence). + let mut stream = UnixStream::connect(&client_socket).expect("should connect to client socket"); + + let (version, error) = client_handshake(&mut stream, 0, 80, 24) + .expect("should read Welcome response even on rejection"); + + assert_eq!(version, 1, "server should report its version 1"); + assert!( + error.is_some(), + "version 0 should be rejected with an error" + ); + + cleanup_spawned_herdr(spawned, base); +} + +#[test] +fn client_handshake_clamps_small_terminal_size() { + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + let spawned = spawn_server(&config_home, &runtime_dir, &api_socket, &client_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_file(&client_socket, Duration::from_secs(10)); + + // Send Hello with 0x0 terminal size — should be clamped. + let mut stream = UnixStream::connect(&client_socket).expect("should connect to client socket"); + + let (version, error) = client_handshake(&mut stream, 1, 0, 0) + .expect("handshake with 0x0 should succeed (server clamps)"); + + assert_eq!(version, 1); + assert!( + error.is_none(), + "0x0 size should be accepted (clamped): {:?}", + error + ); + + cleanup_spawned_herdr(spawned, base); +} + +#[test] +fn no_hello_client_closed_within_five_seconds() { + // Client connection that sends no Hello is closed within 5 seconds. + // The server sets a handshake timeout of 4 seconds to guarantee the connection + // is closed within the 5-second deadline even with OS overhead. + let _lock = test_lock(); + let base = unique_test_dir(); + let config_home = base.join("config"); + let runtime_dir = base.join("runtime"); + let api_socket = runtime_dir.join("herdr.sock"); + let client_socket = runtime_dir.join("herdr-client.sock"); + + let spawned = spawn_server(&config_home, &runtime_dir, &api_socket, &client_socket); + wait_for_socket(&api_socket, Duration::from_secs(10)); + wait_for_file(&client_socket, Duration::from_secs(10)); + + // Connect but don't send Hello — just a raw connection. + let mut stream = UnixStream::connect(&client_socket).expect("should connect to client socket"); + + // Set a read timeout longer than the handshake timeout so we can detect + // when the server closes the connection. + stream + .set_read_timeout(Some(Duration::from_secs(6))) + .unwrap(); + + let start = Instant::now(); + + // Try to read from the stream. The server should close the connection + // within 5 seconds, causing our read to return with an error (EOF or + // connection reset). + let mut buf = [0u8; 1024]; + let result = stream.read(&mut buf); + let elapsed = start.elapsed(); + + // The read should fail (connection closed by server). + assert!( + result.is_err() || result.unwrap() == 0, + "server should close the connection when no Hello is sent" + ); + + // The connection should be closed within 5 seconds. + assert!( + elapsed < Duration::from_secs(5), + "connection should be closed within 5 seconds, took {:?}", + elapsed + ); + + // Verify the server is still healthy — a proper client can still connect. + let mut good_stream = + UnixStream::connect(&client_socket).expect("should connect after no-hello client"); + let (version, error) = client_handshake(&mut good_stream, 1, 80, 24) + .expect("proper handshake should still work after no-hello client"); + assert_eq!(version, 1); + assert!(error.is_none()); + + // API should still work. + let response = ping_socket(&api_socket); + assert!( + response.contains("pong"), + "server should still respond to ping: {response}" + ); + + cleanup_spawned_herdr(spawned, base); +} diff --git a/tests/support/mod.rs b/tests/support/mod.rs new file mode 100644 index 00000000..567db154 --- /dev/null +++ b/tests/support/mod.rs @@ -0,0 +1,418 @@ +use std::collections::HashSet; +use std::fs; +use std::path::{Path, PathBuf}; +use std::sync::{Mutex, Once, OnceLock}; +use std::thread; +use std::time::{Duration, Instant}; + +static PID_REGISTRY: OnceLock<Mutex<HashSet<u32>>> = OnceLock::new(); +static RUNTIME_DIR_REGISTRY: OnceLock<Mutex<HashSet<PathBuf>>> = OnceLock::new(); +static INIT: Once = Once::new(); +static CLEANUP_GUARD: OnceLock<CleanupGuard> = OnceLock::new(); +const WATCHDOG_SCAN_INTERVAL: Duration = Duration::from_secs(1); +const RUNTIME_OWNER_MARKER: &str = ".herdr-test-owner-pid"; + +pub fn register_spawned_herdr_pid(pid: Option<u32>) { + let Some(pid) = pid else { + return; + }; + + ensure_cleanup_hooks(); + let mut registry = pid_registry_lock(); + registry.insert(pid); +} + +pub fn unregister_spawned_herdr_pid(pid: Option<u32>) { + let Some(pid) = pid else { + return; + }; + + if let Some(registry) = PID_REGISTRY.get() { + let mut guard = registry + .lock() + .unwrap_or_else(|poisoned| poisoned.into_inner()); + guard.remove(&pid); + } +} + +pub fn register_runtime_dir(path: &Path) { + ensure_cleanup_hooks(); + + let _ = fs::create_dir_all(path); + let _ = fs::write( + path.join(RUNTIME_OWNER_MARKER), + std::process::id().to_string(), + ); + + let mut runtime_dirs = runtime_dir_registry_lock(); + runtime_dirs.insert(path.to_path_buf()); +} + +pub fn unregister_runtime_dir(path: &Path) { + if let Some(registry) = RUNTIME_DIR_REGISTRY.get() { + let mut guard = registry + .lock() + .unwrap_or_else(|poisoned| poisoned.into_inner()); + guard.remove(path); + } +} + +pub fn cleanup_test_base(base: &Path) { + let runtime_dir = base.join("runtime"); + let runtime_dirs = HashSet::from([runtime_dir.clone()]); + + terminate_servers_for_runtime_dirs(&runtime_dirs); + unregister_runtime_dir(&runtime_dir); + let _ = fs::remove_dir_all(base); +} + +pub fn cleanup_registered_herdr_pids() { + let pids: Vec<u32> = { + let mut registry = pid_registry_lock(); + registry.drain().collect() + }; + + for pid in pids { + terminate_pid(pid); + } + + let runtime_dirs: HashSet<PathBuf> = { + let mut runtime_dirs = runtime_dir_registry_lock(); + runtime_dirs.drain().collect() + }; + + terminate_servers_for_runtime_dirs(&runtime_dirs); + let _ = cleanup_servers_with_missing_runtime_dir(); +} + +fn ensure_cleanup_hooks() { + INIT.call_once(|| { + let _ = cleanup_servers_with_missing_runtime_dir(); + start_global_watchdog(); + + let _ = CLEANUP_GUARD.set(CleanupGuard); + + let previous_hook = std::panic::take_hook(); + std::panic::set_hook(Box::new(move |panic_info| { + cleanup_registered_herdr_pids(); + previous_hook(panic_info); + })); + + let _ = ctrlc::set_handler(|| { + cleanup_registered_herdr_pids(); + std::process::exit(130); + }); + + unsafe { + libc::atexit(run_atexit_cleanup); + } + }); +} + +fn pid_registry_lock() -> std::sync::MutexGuard<'static, HashSet<u32>> { + PID_REGISTRY + .get_or_init(|| Mutex::new(HashSet::new())) + .lock() + .unwrap_or_else(|poisoned| poisoned.into_inner()) +} + +fn runtime_dir_registry_lock() -> std::sync::MutexGuard<'static, HashSet<PathBuf>> { + RUNTIME_DIR_REGISTRY + .get_or_init(|| Mutex::new(HashSet::new())) + .lock() + .unwrap_or_else(|poisoned| poisoned.into_inner()) +} + +fn registered_runtime_dirs_snapshot() -> HashSet<PathBuf> { + if let Some(runtime_dirs) = RUNTIME_DIR_REGISTRY.get() { + runtime_dirs + .lock() + .unwrap_or_else(|poisoned| poisoned.into_inner()) + .clone() + } else { + HashSet::new() + } +} + +fn should_terminate_runtime_dir( + runtime_dir: &Path, + registered_runtime_dirs: &HashSet<PathBuf>, +) -> bool { + if !registered_runtime_dirs.contains(runtime_dir) { + return false; + } + + if !runtime_dir.exists() { + return true; + } + + !runtime_dir_owner_alive(runtime_dir) +} + +fn start_global_watchdog() { + thread::spawn(|| loop { + thread::sleep(WATCHDOG_SCAN_INTERVAL); + + if let Err(err) = cleanup_servers_with_missing_runtime_dir() { + eprintln!("herdr test cleanup watchdog error: {err}"); + } + }); +} + +fn cleanup_servers_with_missing_runtime_dir() -> std::io::Result<()> { + let registered_runtime_dirs = registered_runtime_dirs_snapshot(); + if registered_runtime_dirs.is_empty() { + return Ok(()); + } + + for pid in iter_worktree_server_pids()? { + let Some(runtime_dir) = process_runtime_dir(pid)? else { + continue; + }; + + if should_terminate_runtime_dir(&runtime_dir, ®istered_runtime_dirs) { + terminate_pid(pid); + } + } + + Ok(()) +} + +fn terminate_servers_for_runtime_dirs(runtime_dirs: &HashSet<PathBuf>) { + if runtime_dirs.is_empty() { + return; + } + + let Ok(pids) = iter_worktree_server_pids() else { + return; + }; + + for pid in pids { + let Ok(runtime_dir) = process_runtime_dir(pid) else { + continue; + }; + + let Some(runtime_dir) = runtime_dir else { + continue; + }; + + if runtime_dirs.contains(&runtime_dir) { + terminate_pid(pid); + } + } +} + +fn iter_worktree_server_pids() -> std::io::Result<Vec<u32>> { + let own_pid = std::process::id(); + let mut pids = Vec::new(); + + for entry in fs::read_dir("/proc")? { + let entry = entry?; + let file_name = entry.file_name(); + let Some(pid) = file_name.to_str().and_then(|name| name.parse::<u32>().ok()) else { + continue; + }; + + if pid == own_pid { + continue; + } + + if is_worktree_herdr_server_process(pid) { + pids.push(pid); + } + } + + Ok(pids) +} + +fn is_worktree_herdr_server_process(pid: u32) -> bool { + let Some(exe_path) = proc_link_target(pid, "exe") else { + return false; + }; + + if !is_worktree_herdr_binary(&exe_path) { + return false; + } + + let Ok(cmdline) = read_cmdline(pid) else { + return false; + }; + + cmdline.iter().any(|arg| arg == "server") +} + +fn proc_link_target(pid: u32, link: &str) -> Option<PathBuf> { + fs::read_link(format!("/proc/{pid}/{link}")).ok() +} + +fn read_cmdline(pid: u32) -> std::io::Result<Vec<String>> { + let cmdline = fs::read(format!("/proc/{pid}/cmdline"))?; + Ok(cmdline + .split(|byte| *byte == 0) + .filter(|chunk| !chunk.is_empty()) + .map(|chunk| String::from_utf8_lossy(chunk).to_string()) + .collect()) +} + +fn process_runtime_dir(pid: u32) -> std::io::Result<Option<PathBuf>> { + let environ = fs::read(format!("/proc/{pid}/environ"))?; + + let mut socket_path: Option<PathBuf> = None; + + for entry in environ.split(|byte| *byte == 0) { + if entry.is_empty() { + continue; + } + + let kv = String::from_utf8_lossy(entry); + if let Some(value) = kv.strip_prefix("XDG_RUNTIME_DIR=") { + return Ok(Some(PathBuf::from(value))); + } + + if let Some(value) = kv.strip_prefix("HERDR_SOCKET_PATH=") { + socket_path = Some(PathBuf::from(value)); + } + } + + Ok(socket_path.and_then(|path| path.parent().map(Path::to_path_buf))) +} + +fn runtime_dir_owner_alive(runtime_dir: &Path) -> bool { + let marker = runtime_dir.join(RUNTIME_OWNER_MARKER); + let Ok(contents) = fs::read_to_string(marker) else { + return false; + }; + + let Ok(owner_pid) = contents.trim().parse::<libc::pid_t>() else { + return false; + }; + + process_exists(owner_pid) +} + +fn is_worktree_herdr_binary(path: &Path) -> bool { + path.ends_with("target/debug/herdr") + && path + .components() + .any(|component| component.as_os_str() == "herdr-worktrees") +} + +extern "C" fn run_atexit_cleanup() { + cleanup_registered_herdr_pids(); +} + +struct CleanupGuard; + +impl Drop for CleanupGuard { + fn drop(&mut self) { + cleanup_registered_herdr_pids(); + } +} + +fn terminate_pid(pid: u32) { + let pid_t = pid as libc::pid_t; + + if process_exists(pid_t) { + unsafe { + libc::kill(pid_t, libc::SIGTERM); + } + } + + if wait_for_pid_exit(pid_t, Duration::from_millis(400)) { + return; + } + + if process_exists(pid_t) { + unsafe { + libc::kill(pid_t, libc::SIGKILL); + } + } + + let _ = wait_for_pid_exit(pid_t, Duration::from_secs(2)); +} + +fn wait_for_pid_exit(pid: libc::pid_t, timeout: Duration) -> bool { + let deadline = Instant::now() + timeout; + + while Instant::now() < deadline { + if !process_exists(pid) { + return true; + } + + let mut status = 0; + let result = unsafe { libc::waitpid(pid, &mut status, libc::WNOHANG) }; + if result == pid { + return true; + } + + if result == -1 { + match std::io::Error::last_os_error().raw_os_error() { + Some(libc::ECHILD) => { + // Not our child (or already reaped elsewhere). Poll /proc existence + // until the process is truly gone. + if !process_exists(pid) { + return true; + } + } + Some(libc::ESRCH) => return true, + _ => { + if !process_exists(pid) { + return true; + } + } + } + } + + thread::sleep(Duration::from_millis(20)); + } + + !process_exists(pid) +} + +fn process_exists(pid: libc::pid_t) -> bool { + let result = unsafe { libc::kill(pid, 0) }; + if result == 0 { + true + } else { + std::io::Error::last_os_error().raw_os_error() == Some(libc::EPERM) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + fn unique_missing_runtime_dir(label: &str) -> PathBuf { + let unique = std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .unwrap_or_default() + .as_nanos(); + std::env::temp_dir().join(format!( + "herdr-watchdog-scoping-{label}-{}-{unique}", + std::process::id() + )) + } + + #[test] + fn watchdog_scoping_does_not_terminate_missing_unregistered_runtime_dir() { + let runtime_dir = unique_missing_runtime_dir("unregistered"); + let registered_runtime_dirs = HashSet::new(); + + assert!( + !should_terminate_runtime_dir(&runtime_dir, ®istered_runtime_dirs), + "missing runtime dirs must not be killable until they are proven session-owned" + ); + } + + #[test] + fn watchdog_scoping_terminates_missing_registered_runtime_dir() { + let runtime_dir = unique_missing_runtime_dir("registered"); + let mut registered_runtime_dirs = HashSet::new(); + registered_runtime_dirs.insert(runtime_dir.clone()); + + assert!( + should_terminate_runtime_dir(&runtime_dir, ®istered_runtime_dirs), + "missing runtime dirs that are session-owned should be considered killable" + ); + } +} diff --git a/website/assets/sidebar-agents.png b/website/assets/sidebar-agents.png Binary files differindex 1d5c5041..06e03fb2 100644 --- a/website/assets/sidebar-agents.png +++ b/website/assets/sidebar-agents.png diff --git a/website/assets/sidebar-workspaces.png b/website/assets/sidebar-workspaces.png Binary files differindex a8160f1e..2d5aa629 100644 --- a/website/assets/sidebar-workspaces.png +++ b/website/assets/sidebar-workspaces.png diff --git a/website/css/style.css b/website/css/style.css new file mode 100644 index 00000000..54061ec9 --- /dev/null +++ b/website/css/style.css @@ -0,0 +1,719 @@ +*, +*::before, +*::after { + margin: 0; + padding: 0; + box-sizing: border-box; + scrollbar-width: thin; + scrollbar-color: var(--border-bright) var(--mantle); +} + +*::-webkit-scrollbar { + width: 10px; + height: 10px; +} + +*::-webkit-scrollbar-track { + background: var(--mantle); +} + +*::-webkit-scrollbar-thumb { + background: var(--border-bright); + border: 2px solid var(--mantle); + border-radius: 999px; +} + +*::-webkit-scrollbar-thumb:hover { + background: var(--text-dim); +} + +*::-webkit-scrollbar-corner { + background: var(--mantle); +} + +:root { + --base: #11111b; + --surface: #1e1e2e; + --mantle: #181825; + --overlay: #262637; + --border: #313244; + --border-bright: #45475a; + --white: #cdd6f4; + --text: #a6adc8; + --text-dim: #6c7086; + --text-faint: #45475a; + --green: #a6e3a1; + --blue: #89b4fa; + --red: #f38ba8; + --yellow: #f9e2af; + --mauve: #cba6f7; + --max-w: 880px; +} + +html { + background: var(--base); + color: var(--text); + font-family: "JetBrains Mono", monospace; + font-size: 17px; + -webkit-font-smoothing: antialiased; + scroll-behavior: smooth; +} + +body { + overflow-x: clip; +} + +a { + color: var(--text); + text-decoration: none; + border-bottom: 1px solid var(--border); + transition: + color 0.15s, + border-color 0.15s; +} +a:hover { + color: var(--green); + border-color: var(--green); +} + +::selection { + background: var(--overlay); + color: var(--white); +} + +/* ── State dots ── */ +.dot { + display: inline-block; + width: 8px; + height: 8px; + border-radius: 50%; + flex-shrink: 0; +} +.dot-blocked { + background: var(--red); +} +.dot-working { + background: var(--yellow); +} +.dot-done { + background: var(--blue); +} +.dot-idle { + background: var(--green); +} + +.text-blocked { + color: var(--red); +} +.text-working { + color: var(--yellow); +} +.text-done { + color: var(--blue); +} +.text-idle { + color: var(--green); +} + +/* ── Sections ── */ +.section { + max-width: var(--max-w); + margin: 0 auto; + padding: 0 2rem; +} + +.section-rule { + border: none; + border-top: 1px solid var(--border); + max-width: var(--max-w); + margin: 0 auto; +} + +.gap { + height: 5rem; +} +.gap-lg { + height: 7rem; +} +.gap-sm { + height: 3rem; +} + +.section-heading { + display: flex; + align-items: center; + gap: 0.65rem; + margin-bottom: 2rem; +} + +.section-heading h2 { + font-size: 0.75rem; + font-weight: 600; + text-transform: uppercase; + letter-spacing: 0.15em; + color: var(--text-dim); +} + +/* ── Hero ── */ +.hero { + position: relative; + max-width: var(--max-w); + margin: 0 auto; + padding: 6rem 2rem 0; + overflow: hidden; +} + +.hero-pasture { + position: absolute; + inset: 0; + overflow: hidden; + pointer-events: none; + z-index: 0; +} + +.hero > *:not(.hero-pasture) { + position: relative; + z-index: 1; +} + +.hero .sheep-el { + position: absolute; + font-family: "JetBrains Mono", monospace; + line-height: 1.15; + white-space: pre; + pointer-events: none; + user-select: none; + will-change: transform; +} + +.hero-logo { + width: 56px; + height: 56px; + border-radius: 14px; + margin-right: 1rem; + vertical-align: middle; +} + +.hero-name { + font-size: 1.5rem; + font-weight: 500; + text-transform: lowercase; + letter-spacing: 0.05em; + color: var(--white); + margin-bottom: 2rem; + display: inline-block; +} + +.hero-tagline { + font-size: 2.75rem; + font-weight: 700; + color: var(--white); + letter-spacing: -0.03em; + line-height: 1.1; + margin-bottom: 1.5rem; +} + +.hero-dots { + display: flex; + gap: 0.6rem; + margin-bottom: 3rem; +} + +.hero-dots .dot { + width: 10px; + height: 10px; +} + +.manifesto { + font-size: 1rem; + line-height: 1.9; + color: var(--text-dim); + margin-bottom: 3rem; +} + +.manifesto p + p { + margin-top: 1rem; +} +.manifesto strong { + color: var(--white); + font-weight: 500; +} + +.install-row { + display: flex; + align-items: center; + gap: 0.75rem; + margin-bottom: 1rem; + flex-wrap: wrap; +} + +.install-box { + display: inline-flex; + align-items: center; + gap: 0.5rem; + background: var(--mantle); + border: 1px solid var(--border); + border-radius: 6px; + padding: 0.55rem 0.9rem; + font-size: 0.875rem; + max-width: 100%; +} + +.install-box .prompt { + color: var(--green); +} +.install-box code { + color: var(--text); + white-space: normal; + overflow-wrap: anywhere; + word-break: break-word; +} + +.copy-btn { + background: none; + border: 1px solid var(--border); + border-radius: 4px; + color: var(--text-dim); + font-family: inherit; + font-size: 0.75rem; + padding: 0.35rem 0.6rem; + cursor: pointer; + transition: + color 0.15s, + border-color 0.15s; +} +.copy-btn:hover { + border-color: var(--text-dim); + color: var(--text); +} +.copy-btn.copied { + border-color: var(--green); + color: var(--green); +} + +.hero-meta { + font-size: 0.7rem; + color: var(--text-faint); + overflow-wrap: anywhere; +} + +.hero-meta a { + color: var(--text-dim); + border: none; +} +.hero-meta a:hover { + color: var(--green); +} + +/* ── Demo ── */ +.demo { + max-width: var(--max-w); + margin: 0 auto; + padding: 0 2rem; +} + +.demo-frame { + border: 1px solid var(--border); + border-radius: 8px; + overflow: hidden; +} + +.demo-frame video { + display: block; + width: 100%; + height: auto; +} + +/* ── Comparison ── */ +.position-table { + width: 100%; + border-collapse: collapse; + font-size: 0.875rem; +} + +.position-table th { + text-align: left; + font-size: 0.75rem; + font-weight: 600; + text-transform: uppercase; + letter-spacing: 0.1em; + color: var(--text-faint); + padding: 0.6rem 1rem; + border-bottom: 1px solid var(--border); + background: var(--mantle); +} + +.position-table th.herdr-col { + color: var(--green); +} + +.position-table td { + padding: 0.5rem 1rem; + color: var(--text-dim); + line-height: 1.55; + border-bottom: 1px solid var(--border); + vertical-align: top; +} + +.position-table tr:last-child td { + border-bottom: none; +} +.position-table td:first-child { + width: 11rem; + color: var(--text); + font-weight: 500; +} +.position-table td.herdr-col { + color: var(--text); +} + +.mark { + color: var(--text-faint); +} +.mark-yes { + color: var(--green); +} + +/* ── Prose block ── */ +.prose-block { + font-size: 0.875rem; + line-height: 1.85; + color: var(--text-dim); +} + +.prose-block strong { + color: var(--white); + font-weight: 500; +} + +/* ── Detach flow ── */ +.detach-flow { + background: var(--mantle); + border: 1px solid var(--border); + border-radius: 6px; + padding: 1.75rem 2rem; +} + +.detach-line { + font-size: 0.875rem; + line-height: 2.2; + color: var(--text-dim); +} + +.detach-line .prompt { + color: var(--green); +} +.detach-line .cmd { + color: var(--white); +} +.detach-line .key { + color: var(--blue); +} +.detach-line .comment { + color: var(--text-faint); +} +.detach-line .dim { + color: var(--text-faint); +} + +/* ── Awareness ── */ +.awareness-split { + display: grid; + grid-template-columns: 1fr; + gap: 1.5rem; + margin-bottom: 1.5rem; +} + +.awareness-panel { + display: flex; + gap: 1.25rem; + align-items: flex-start; +} + +.awareness-panel-img { + flex-shrink: 0; + width: 240px; + border: 1px solid var(--border); + border-radius: 4px; + overflow: hidden; +} + +.awareness-panel-img img { + display: block; + width: 100%; + height: auto; + image-rendering: auto; +} + +.awareness-panel-text h3 { + font-size: 0.875rem; + font-weight: 500; + color: var(--white); + margin-bottom: 0.35rem; +} + +.awareness-panel-text p { + font-size: 0.875rem; + color: var(--text-dim); + line-height: 1.65; +} + +.state-bar { + display: flex; + gap: 2rem; + padding: 0.5rem 0 0; +} + +.state-bar-item { + display: flex; + align-items: center; + gap: 0.5rem; + font-size: 0.875rem; + color: var(--text-dim); +} + +/* ── Terminal ── */ +.terminal-block { + background: var(--mantle); + border: 1px solid var(--border); + border-radius: 6px; + padding: 1.75rem 2rem; +} + +.terminal-block p { + font-size: 0.875rem; + line-height: 1.85; + color: var(--text-dim); +} + +.terminal-block strong { + color: var(--white); + font-weight: 500; +} + +.term-pills { + display: flex; + gap: 0.4rem; + flex-wrap: wrap; + margin-top: 1.25rem; +} + +.term-pill { + font-size: 0.75rem; + color: var(--text-dim); + background: var(--base); + padding: 0.2rem 0.6rem; + border: 1px solid var(--border); + border-radius: 4px; +} + +/* ── Comparison ── */ +.table-wrap { + width: 100%; + border: 1px solid var(--border); + border-radius: 6px; + overflow-x: auto; + overflow-y: hidden; + -webkit-overflow-scrolling: touch; +} + +.agents-table { + width: 100%; + border-collapse: collapse; + font-size: 0.875rem; +} + +.agents-table th { + text-align: left; + padding: 0.6rem 1rem; + color: var(--text-faint); + font-weight: 600; + font-size: 0.75rem; + text-transform: uppercase; + letter-spacing: 0.1em; + background: var(--mantle); + border-bottom: 1px solid var(--border); +} + +.agents-table td { + padding: 0.5rem 1rem; + border-bottom: 1px solid var(--border); + color: var(--text-dim); +} + +.agents-table tr:last-child td { + border-bottom: none; +} +.agents-table td:first-child { + color: var(--text); + font-weight: 500; +} + +.agents-table a { + border-bottom: 1px solid var(--border-bright); +} +.agents-table a:hover { + border-color: var(--green); +} + +.check { + color: var(--green); +} +.partial { + color: var(--yellow); +} +.untested { + color: var(--text-faint); + font-size: 0.75rem; +} + +/* ── API ── */ +.api-grid { + display: grid; + grid-template-columns: minmax(0, 0.82fr) minmax(0, 1.18fr); + gap: 2rem; + align-items: start; +} + +.api-grid > * { + min-width: 0; +} + +.api-text p { + font-size: 0.875rem; + color: var(--text-dim); + line-height: 1.85; + margin-bottom: 0.75rem; +} + +.api-text strong { + color: var(--white); + font-weight: 500; +} + +.api-links { + display: flex; + gap: 0.5rem; + margin-top: 0.75rem; + flex-wrap: wrap; +} + +.api-links a { + font-size: 0.75rem; + color: var(--text-dim); + padding: 0.3rem 0.65rem; + border: 1px solid var(--border); + border-radius: 4px; + transition: + color 0.15s, + border-color 0.15s; +} +.api-links a:hover { + border-color: var(--green); + color: var(--green); +} + +.code-block { + background: var(--mantle); + border: 1px solid var(--border); + border-radius: 6px; + padding: 1.25rem 1.5rem; + overflow-x: auto; + -webkit-overflow-scrolling: touch; +} + +.code-block pre { + font-size: 0.72rem; + line-height: 1.9; + color: var(--text-dim); +} + +.code-block .comment { + color: var(--text-faint); +} +.code-block .cmd { + color: var(--green); +} +.code-block .flag { + color: var(--blue); +} +.code-block .str { + color: var(--yellow); +} + +/* ── Footer ── */ +.footer { + max-width: var(--max-w); + margin: 0 auto; + padding: 2rem 2rem 4rem; + text-align: center; +} + +.footer p { + font-size: 0.7rem; + color: var(--text-faint); + line-height: 2; +} + +.footer a { + color: var(--text-dim); + border: none; +} +.footer a:hover { + color: var(--green); +} + +/* ── Responsive ── */ +@media (max-width: 768px) { + .hero, + .section, + .demo, + .footer { + padding-left: 1.25rem; + padding-right: 1.25rem; + } + .hero { + padding-top: 4rem; + } + .hero-tagline { + font-size: 2rem; + } + .manifesto { + font-size: 0.875rem; + } + .awareness-panel { + flex-direction: column; + align-items: flex-start; + } + .awareness-panel-img { + width: min(100%, 220px); + } + .api-grid { + grid-template-columns: 1fr; + } + .state-bar { + gap: 1.25rem; + flex-wrap: wrap; + } + .position-table { + min-width: 42rem; + } + .agents-table { + min-width: 38rem; + } + .position-table td:first-child { + width: 11rem; + } +} + +@media (max-width: 480px) { + .hero { + padding-top: 3rem; + } + .hero-tagline { + font-size: 1.7rem; + } + .manifesto { + font-size: 0.875rem; + } +} diff --git a/website/index.html b/website/index.html index f73c66ec..e639d355 100644 --- a/website/index.html +++ b/website/index.html @@ -1,978 +1,702 @@ -<!DOCTYPE html> +<!doctype html> <html lang="en"> -<head> - <meta charset="utf-8"> - <meta name="viewport" content="width=device-width, initial-scale=1"> - <title>herdr — supervise multiple coding agents in one terminal</title> - <meta name="description" content="Run Claude Code, Codex, pi, opencode, droid, and amp side by side in your existing terminal. Workspaces, panes, agent detection, and notifications for blocked, done, and working states."> - <meta name="theme-color" content="#0d1117"> - <link rel="canonical" href="https://herdr.dev/"> - - <!-- Open Graph --> - <meta property="og:type" content="website"> - <meta property="og:site_name" content="herdr"> - <meta property="og:title" content="herdr — supervise multiple coding agents in one terminal"> - <meta property="og:description" content="Run Claude Code, Codex, pi, opencode, droid, and amp side by side in your existing terminal. Workspaces, panes, agent detection, and notifications for blocked, done, and working states."> - <meta property="og:url" content="https://herdr.dev/"> - <meta property="og:image" content="https://herdr.dev/assets/og-card.png"> - <meta property="og:image:width" content="1200"> - <meta property="og:image:height" content="630"> - - <!-- Twitter / X --> - <meta name="twitter:card" content="summary_large_image"> - <meta name="twitter:title" content="herdr — supervise multiple coding agents in one terminal"> - <meta name="twitter:description" content="Run Claude Code, Codex, pi, opencode, droid, and amp side by side in your existing terminal with workspaces, panes, and agent state detection."> - <meta name="twitter:image" content="https://herdr.dev/assets/og-card.png"> - - <link rel="icon" type="image/png" href="/assets/logo.png"> - <link rel="apple-touch-icon" href="/assets/logo.png"> - <link rel="preconnect" href="https://fonts.googleapis.com"> - <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin> - <link href="https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;500;700&display=swap" rel="stylesheet"> - <style> - *, *::before, *::after { margin: 0; padding: 0; box-sizing: border-box; } - - :root { - --bg: #0d1117; - --bg-raised: #161b22; - --bg-surface: #1c2129; - --border: #21262d; - --border-bright: #30363d; - --text: #e6edf3; - --text-muted: #8b949e; - --text-dim: #484f58; - --green: #4ade80; - --green-dim: rgba(74, 222, 128, 0.12); - --red: #f87171; - --blue: #60a5fa; - --yellow: #fbbf24; - --max-w: 1080px; - } - - html { - background: var(--bg); - color: var(--text); - font-family: 'JetBrains Mono', 'Fira Code', 'SF Mono', monospace; - -webkit-font-smoothing: antialiased; - scroll-behavior: smooth; - } - - body { overflow-x: hidden; } - - /* ── Hero ── */ - .hero { - position: relative; - max-width: var(--max-w); - margin: 0 auto; - padding: 4rem 2rem 0; - text-align: center; - overflow: hidden; - } - - .hero-pasture { - position: absolute; - inset: 0; - overflow: hidden; - pointer-events: none; - z-index: 0; - } - - .hero > *:not(.hero-pasture) { - position: relative; - z-index: 1; - } - - .hero .sheep-el { - position: absolute; - font-family: 'JetBrains Mono', monospace; - line-height: 1.15; - white-space: pre; - pointer-events: none; - user-select: none; - will-change: transform; - } - - .hero-logo { - width: 80px; - height: 80px; - border-radius: 18px; - margin-bottom: 1.25rem; - } - - .hero h1 { - font-size: 3rem; - font-weight: 700; - letter-spacing: -0.03em; - color: #fff; - } - - .hero-tagline { - font-size: 1.1rem; - color: var(--green); - margin: 0.25rem 0 1.25rem; - } - - .hero-desc { - font-size: 0.875rem; - color: var(--text-muted); - line-height: 1.8; - max-width: 640px; - margin: 0 auto 2rem; - } - - .hero-desc p + p { margin-top: 0.6rem; } - - /* install box */ - .install-box { - display: inline-flex; - align-items: center; - gap: 0.75rem; - background: var(--bg-raised); - border: 1px solid var(--border); - border-radius: 8px; - padding: 0.65rem 1rem; - font-size: 0.825rem; - margin-bottom: 0.75rem; - transition: border-color 0.2s; - } - - .install-box:hover { border-color: var(--border-bright); } - .install-box .prompt { color: var(--green); } - .install-box code { color: var(--text); } - - .copy-btn { - background: none; - border: 1px solid var(--border); - color: var(--text-dim); - font-family: inherit; - font-size: 0.7rem; - padding: 0.2rem 0.5rem; - border-radius: 4px; - cursor: pointer; - transition: all 0.2s; - } - .copy-btn:hover { border-color: var(--green); color: var(--green); } - .copy-btn.copied { border-color: var(--green); color: var(--green); } - - .hero-links { - display: flex; - justify-content: center; - gap: 1.5rem; - margin-top: 0.5rem; - font-size: 0.8rem; - } - .hero-links a { - color: var(--text-dim); - text-decoration: none; - transition: color 0.2s; - } - .hero-links a:hover { color: var(--green); } - - /* screenshot */ - .hero-screenshot { - max-width: var(--max-w); - margin: 3rem auto 0; - padding: 0 2rem; - } - - .screenshot-frame { - position: relative; - border-radius: 12px; - overflow: hidden; - border: 1px solid var(--border); - box-shadow: - 0 0 0 1px rgba(0,0,0,0.3), - 0 24px 80px rgba(0,0,0,0.5), - 0 0 120px rgba(74, 222, 128, 0.03); - } - - .screenshot-frame img, - .screenshot-frame video { - display: block; - width: 100%; - height: auto; - } - - .screenshot-label { - text-align: center; - font-size: 0.7rem; - color: var(--text-dim); - margin-top: 1rem; - } - - /* ── Divider ── */ - .section-gap { height: 5rem; } - - /* ── Two-column features ── */ - .features { - max-width: var(--max-w); - margin: 0 auto; - padding: 0 2rem; - display: grid; - grid-template-columns: 1fr 1fr; - gap: 2rem; - } - - .feature-card { - background: var(--bg-raised); - border: 1px solid var(--border); - border-radius: 10px; - padding: 2rem; - } - - .feature-card h2 { - font-size: 1rem; - font-weight: 700; - margin-bottom: 0.25rem; - color: #fff; - } - - .feature-card .subtitle { - font-size: 0.75rem; - color: var(--green); - margin-bottom: 1.25rem; - } - - .feature-list { - list-style: none; - } - - .feature-list li { - font-size: 0.8rem; - color: var(--text-muted); - line-height: 1.7; - padding-left: 1.2rem; - position: relative; - } - - .feature-list li::before { - content: '›'; - position: absolute; - left: 0; - color: var(--text-dim); - } - - .feature-list li + li { margin-top: 0.4rem; } - - /* ── Awareness section ── */ - .awareness { - max-width: var(--max-w); - margin: 0 auto; - padding: 0 2rem; - } - - .awareness-header { - margin-bottom: 1.5rem; - } - - .awareness-header h2 { - font-size: 1rem; - font-weight: 700; - color: #fff; - margin-bottom: 0.3rem; - } - - .awareness-desc { - font-size: 0.8rem; - color: var(--text-muted); - line-height: 1.7; - } - - .awareness-dual { - display: grid; - grid-template-columns: 1fr 1fr; - gap: 2rem; - margin-bottom: 1.5rem; - } - - .awareness-panel { - background: var(--bg-raised); - border: 1px solid var(--border); - border-radius: 10px; - padding: 1.5rem; - display: flex; - gap: 1.25rem; - align-items: flex-start; - } - - .awareness-panel-img { - flex-shrink: 0; - border: 1px solid var(--border); - border-radius: 6px; - overflow: hidden; - } - - .awareness-panel-img img { - display: block; - height: auto; - width: auto; - max-height: 120px; - image-rendering: auto; - } - - .awareness-panel-text h3 { - font-size: 0.85rem; - font-weight: 700; - color: #fff; - margin-bottom: 0.4rem; - } - - .awareness-panel-text p { - font-size: 0.75rem; - color: var(--text-muted); - line-height: 1.7; - } - - .state-bar { - display: flex; - justify-content: center; - gap: 2rem; - padding: 1rem 0 0; - } - - .state-bar-item { - display: flex; - align-items: center; - gap: 0.5rem; - font-size: 0.75rem; - color: var(--text-muted); - } - - .state-dot { - flex-shrink: 0; - width: 8px; - height: 8px; - border-radius: 50%; - display: inline-block; - } - - .state-dot.red { background: var(--red); box-shadow: 0 0 8px rgba(248,113,113,0.4); } - .state-dot.blue { background: var(--blue); box-shadow: 0 0 8px rgba(96,165,250,0.4); } - .state-dot.yellow { background: var(--yellow); box-shadow: 0 0 8px rgba(251,191,36,0.3); } - .state-dot.green { background: var(--green); opacity: 0.5; } - - /* ── Agents table ── */ - .agents-section { - max-width: var(--max-w); - margin: 0 auto; - padding: 0 2rem; - } - - .agents-section h2 { - font-size: 1rem; - font-weight: 700; - color: #fff; - margin-bottom: 0.3rem; - } - - .agents-section .section-desc { - font-size: 0.775rem; - color: var(--text-muted); - margin-bottom: 1.25rem; - line-height: 1.6; - } - - .agents-table-wrap { - border: 1px solid var(--border); - border-radius: 10px; - overflow: hidden; - } - - .agents-table { - width: 100%; - border-collapse: collapse; - font-size: 0.8rem; - } - - .agents-table th { - text-align: left; - padding: 0.7rem 1rem; - color: var(--text-muted); - font-weight: 500; - font-size: 0.7rem; - text-transform: uppercase; - letter-spacing: 0.05em; - background: var(--bg-surface); - border-bottom: 1px solid var(--border); - } - - .agents-table td { - padding: 0.6rem 1rem; - border-bottom: 1px solid var(--border); - color: var(--text-muted); - } - - .agents-table tr:last-child td { border-bottom: none; } - - .agents-table td:first-child { - color: var(--text); - font-weight: 500; - } - - .agents-table a { - color: inherit; - text-decoration: none; - border-bottom: 1px solid var(--border); - transition: all 0.2s; - } - .agents-table a:hover { color: var(--green); border-color: var(--green); } - - .check { color: var(--green); } - .partial { color: var(--yellow); } - .untested { color: var(--text-dim); font-size: 0.7rem; } - - /* ── How it works ── */ - .how-section { - max-width: var(--max-w); - margin: 0 auto; - padding: 0 2rem; - } - - .how-section h2 { - font-size: 1rem; - font-weight: 700; - color: #fff; - margin-bottom: 1.25rem; - } - - .how-grid { - display: grid; - grid-template-columns: repeat(3, 1fr); - gap: 1.5rem; - } - - .how-step { - background: var(--bg-raised); - border: 1px solid var(--border); - border-radius: 10px; - padding: 1.5rem; - } - - .how-step .step-num { - font-size: 0.7rem; - color: var(--green); - margin-bottom: 0.5rem; - } - - .how-step h3 { - font-size: 0.85rem; - font-weight: 700; - color: #fff; - margin-bottom: 0.4rem; - } - - .how-step p { - font-size: 0.75rem; - color: var(--text-muted); - line-height: 1.65; - } - - .how-step code { - font-size: 0.725rem; - background: var(--bg); - padding: 0.15rem 0.35rem; - border-radius: 3px; - color: var(--text); - } - - /* ── API teaser ── */ - .api-section { - max-width: var(--max-w); - margin: 0 auto; - padding: 0 2rem; - } - - .api-card { - background: var(--bg-raised); - border: 1px solid var(--border); - border-radius: 10px; - padding: 2rem; - display: grid; - grid-template-columns: 1fr 1fr; - gap: 2rem; - align-items: start; - } - - .api-card h2 { - font-size: 1rem; - font-weight: 700; - color: #fff; - margin-bottom: 0.3rem; - } - - .api-card .subtitle { - font-size: 0.75rem; - color: var(--green); - margin-bottom: 1rem; - } - - .api-card p { - font-size: 0.8rem; - color: var(--text-muted); - line-height: 1.7; - } - - .api-card p + p { margin-top: 0.6rem; } - - .api-doc-links { - display: flex; - gap: 0.75rem; - margin-top: 1.25rem; - } - - .api-doc-links a { - font-size: 0.75rem; - color: var(--text); - text-decoration: none; - padding: 0.4rem 0.75rem; - border: 1px solid var(--border); - border-radius: 6px; - transition: all 0.2s; - } - .api-doc-links a:hover { border-color: var(--green); color: var(--green); } - - .code-block { - background: var(--bg); - border: 1px solid var(--border); - border-radius: 8px; - padding: 1.25rem; - overflow-x: auto; - } - - .code-block pre { - font-size: 0.725rem; - line-height: 1.8; - color: var(--text-muted); - } - - .code-block .comment { color: var(--text-dim); } - .code-block .cmd { color: var(--green); } - .code-block .flag { color: var(--blue); } - .code-block .str { color: var(--yellow); } - - /* ── Footer ── */ - .footer { - max-width: var(--max-w); - margin: 0 auto; - padding: 4rem 2rem 3rem; - text-align: center; - } - - .footer-line { - border: none; - border-top: 1px solid var(--border); - margin-bottom: 2rem; - } - - .footer p { - font-size: 0.75rem; - color: var(--text-dim); - line-height: 1.8; - } - - .footer a { - color: var(--text-muted); - text-decoration: none; - transition: color 0.2s; - } - .footer a:hover { color: var(--green); } - - /* ── Responsive ── */ - @media (max-width: 768px) { - .hero { padding-top: 3rem; } - .hero h1 { font-size: 2.25rem; } - .features { grid-template-columns: 1fr; } - .how-grid { grid-template-columns: 1fr; } - .api-card { grid-template-columns: 1fr; } - .awareness-dual { grid-template-columns: 1fr; } - .state-bar { gap: 1rem; flex-wrap: wrap; } - .hero-screenshot { padding: 0 1rem; } - .state-grid { grid-template-columns: 1fr 1fr; } - } - - @media (max-width: 480px) { - .hero h1 { font-size: 1.75rem; } - .install-box { font-size: 0.7rem; padding: 0.5rem 0.75rem; } - .state-grid { grid-template-columns: 1fr; } - } - </style> -</head> -<body> - - <!-- ── Hero ── --> - <section class="hero" id="hero"> - <img src="/assets/logo.png" alt="herdr" class="hero-logo"> - <h1>herdr</h1> - <p class="hero-tagline">supervise multiple coding agents in one terminal.</p> - <div class="hero-desc"> - <p>run Claude Code, Codex, pi, opencode, droid, amp, and plain shells side by side in your existing terminal. see which agent is blocked, done, or still working without leaving the command line.</p> - <p>workspaces, tabs, panes, automatic agent detection, and notifications. no electron, no web dashboard, no separate gui window.</p> - </div> - <div class="install-box"> - <span class="prompt">$</span> - <code id="install-cmd">curl -fsSL https://herdr.dev/install.sh | sh</code> - <button class="copy-btn" id="copy-btn">copy</button> - </div> - <div class="hero-links"> - <a href="https://github.com/ogulcancelik/herdr">github</a> - <a href="https://github.com/ogulcancelik/herdr/blob/master/CONFIGURATION.md">docs</a> - <a href="https://github.com/ogulcancelik/herdr/blob/master/SOCKET_API.md">api</a> - </div> - </section> - - <!-- ── Demo ── --> - <div class="hero-screenshot"> - <div class="screenshot-frame"> - <video autoplay muted loop playsinline preload="auto" poster="/assets/hero-screenshot.png"> - <source src="/assets/demo.mp4" type="video/mp4"> - </video> - </div> - </div> - - <div class="section-gap"></div> - - <!-- ── For you / For your agents ── --> - <section class="features"> - <div class="feature-card"> - <h2>for you</h2> - <p class="subtitle">supervise, triage, act</p> - <ul class="feature-list"> - <li>one place to see all running agents across workspaces</li> - <li>sidebar rolls up each workspace to its most urgent state</li> - <li>switch contexts instantly — click or keyboard</li> - <li>sound alerts and toast notifications for background events</li> - <li>mouse-native: click panes, drag borders, select text to copy</li> - <li>session persistence — close and reopen, everything restores</li> - <li>9 built-in themes, full color token overrides</li> - </ul> - </div> - <div class="feature-card"> - <h2>for your agents</h2> - <p class="subtitle">orchestrate, spawn, wait</p> - <ul class="feature-list"> - <li>create workspaces and split panes programmatically</li> - <li>spawn other agents in sibling panes</li> - <li>read output from any pane in the session</li> - <li>send text and keys into other panes</li> - <li>wait for output patterns or agent state changes</li> - <li>subscribe to real-time events over the socket</li> - <li>ship an agent skill or use the socket API directly</li> - </ul> + <head> + <meta charset="utf-8" /> + <meta name="viewport" content="width=device-width, initial-scale=1" /> + <title>herdr — tmux for agents</title> + <meta + name="description" + content="Persistent terminal multiplexer for coding agents. Detach and reattach, agents keep running. Built-in awareness for blocked, done, and working states. Lives inside your terminal." + /> + <meta name="theme-color" content="#11111b" /> + <link rel="canonical" href="https://herdr.dev/" /> + + <meta property="og:type" content="website" /> + <meta property="og:site_name" content="herdr" /> + <meta property="og:title" content="herdr — tmux for agents" /> + <meta + property="og:description" + content="Persistent terminal multiplexer for coding agents. Detach, reattach, agents keep running." + /> + <meta property="og:url" content="https://herdr.dev/" /> + <meta + property="og:image" + content="https://herdr.dev/assets/og-card.png" + /> + <meta property="og:image:width" content="1200" /> + <meta property="og:image:height" content="630" /> + + <meta name="twitter:card" content="summary_large_image" /> + <meta name="twitter:title" content="herdr — tmux for agents" /> + <meta + name="twitter:description" + content="Persistent terminal multiplexer for coding agents. Detach, reattach, agents keep running." + /> + <meta + name="twitter:image" + content="https://herdr.dev/assets/og-card.png" + /> + + <link rel="icon" type="image/png" href="/assets/logo.png" /> + <link rel="apple-touch-icon" href="/assets/logo.png" /> + <link rel="preconnect" href="https://fonts.googleapis.com" /> + <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin /> + <link + href="https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@300;400;500;600;700&display=swap" + rel="stylesheet" + /> + <link rel="stylesheet" href="/css/style.css" /> + </head> + <body> + <!-- ── Hero ── --> + <section class="hero" id="hero"> + <div class="hero-pasture" aria-hidden="true"></div> + <img src="/assets/logo.png" alt="herdr" class="hero-logo" /> + <span class="hero-name">herdr</span> + <p class="hero-tagline">tmux for agents.</p> + <div class="hero-dots"> + <span class="dot dot-blocked"></span> + <span class="dot dot-working"></span> + <span class="dot dot-done"></span> + <span class="dot dot-idle"></span> + </div> + <div class="manifesto"> + <p> + <strong + >herdr is an agent multiplexer that lives in your + terminal.</strong + > + </p> + <p> + workspaces, tabs, panes. mouse-native: click, drag, split. + every agent at a glance: + <span class="text-blocked">blocked</span>, + <span class="text-working">working</span>, + <span class="text-done">done</span>. detach and reattach, + agents keep running. no gui app, no electron, no mac-only + native wrapper. you see the agent's own terminal, not + someone's interpretation of it. + </p> + </div> + <div class="install-row"> + <div class="install-box"> + <span class="prompt">$</span> + <code id="install-cmd" + >curl -fsSL https://herdr.dev/install.sh | sh</code + > + </div> + <button class="copy-btn" id="copy-btn">copy</button> + </div> + <div class="hero-meta"> + <a href="https://github.com/ogulcancelik/herdr">github</a> · + <a + href="https://github.com/ogulcancelik/herdr/blob/master/CONFIGURATION.md" + >docs</a + > + · + <a + href="https://github.com/ogulcancelik/herdr/blob/master/SOCKET_API.md" + >api</a + > + · linux · macos · agpl-3.0 + </div> + </section> + + <div class="gap-lg"></div> + + <!-- ── Demo ── --> + <div class="demo"> + <div class="demo-frame"> + <video + autoplay + muted + loop + playsinline + preload="auto" + poster="/assets/hero-screenshot.png" + > + <source src="/assets/demo.mp4" type="video/mp4" /> + </video> + </div> </div> - </section> - <div class="section-gap"></div> + <div class="gap-lg"></div> + <hr class="section-rule" /> + <div class="gap"></div> - <!-- ── Awareness ── --> - <section class="awareness"> - <div class="awareness-header"> - <h2>ambient awareness</h2> - <p class="awareness-desc">the sidebar is split into two layers. scan the workspace list for the most urgent signal, then drill into the agents causing it in the selected workspace or across all workspaces.</p> - </div> - <div class="awareness-dual"> - <div class="awareness-panel"> - <div class="awareness-panel-img"> - <img src="/assets/sidebar-workspaces.png" alt="herdr sidebar workspace list"> + <!-- ── Comparison ── --> + <section class="section"> + <div class="section-heading"> + <span class="dot dot-idle"></span> + <h2>how it compares</h2> + </div> + <div class="table-wrap"> + <table class="position-table"> + <thead> + <tr> + <th></th> + <th>tmux</th> + <th>gui managers</th> + <th class="herdr-col">herdr</th> + </tr> + </thead> + <tbody> + <tr> + <td>persistent sessions</td> + <td><span class="mark-yes">✓</span></td> + <td><span class="mark">—</span></td> + <td class="herdr-col"> + <span class="mark-yes">✓</span> + </td> + </tr> + <tr> + <td>detach / reattach</td> + <td><span class="mark-yes">✓</span></td> + <td><span class="mark">—</span></td> + <td class="herdr-col"> + <span class="mark-yes">✓</span> + </td> + </tr> + <tr> + <td>panes, tabs, workspaces</td> + <td><span class="mark-yes">✓</span></td> + <td><span class="mark-yes">✓</span></td> + <td class="herdr-col"> + <span class="mark-yes">✓</span> + </td> + </tr> + <tr> + <td>agent awareness</td> + <td><span class="mark">—</span></td> + <td><span class="mark-yes">✓</span></td> + <td class="herdr-col"> + <span class="mark-yes">✓</span> + </td> + </tr> + <tr> + <td>lives in your terminal</td> + <td><span class="mark-yes">✓</span></td> + <td><span class="mark">—</span></td> + <td class="herdr-col"> + <span class="mark-yes">✓</span> + </td> + </tr> + <tr> + <td>real terminal views</td> + <td><span class="mark-yes">✓</span></td> + <td><span class="mark">—</span></td> + <td class="herdr-col"> + <span class="mark-yes">✓</span> + </td> + </tr> + <tr> + <td>mouse-native</td> + <td><span class="mark">—</span></td> + <td><span class="mark-yes">✓</span></td> + <td class="herdr-col"> + <span class="mark-yes">✓</span> + </td> + </tr> + <tr> + <td>lightweight binary</td> + <td><span class="mark-yes">✓</span></td> + <td><span class="mark">—</span></td> + <td class="herdr-col"> + <span class="mark-yes">✓</span> + </td> + </tr> + <tr> + <td>agents can orchestrate</td> + <td><span class="mark">?</span></td> + <td><span class="mark">?</span></td> + <td class="herdr-col"> + <span class="mark-yes">✓</span> + </td> + </tr> + </tbody> + </table> + </div> + </section> + + <div class="gap"></div> + <hr class="section-rule" /> + <div class="gap"></div> + + <!-- ── Persistence ── --> + <section class="section"> + <div class="section-heading"> + <span class="dot dot-done"></span> + <h2>persistence</h2> + </div> + <div class="prose-block"> + <p> + start herdr on your desktop or server. run your agents, + split panes, do your work. press + <strong>ctrl+b q</strong> to detach. close your terminal, + close your laptop; your agents keep running. open a new + terminal, run <strong>herdr</strong>, you're back. same + session, same panes, same agents. + </p> + </div> + </section> + + <div class="gap"></div> + <hr class="section-rule" /> + <div class="gap"></div> + + <!-- ── From anywhere ── --> + <section class="section"> + <div class="section-heading"> + <span class="dot dot-done"></span> + <h2>from anywhere</h2> + </div> + <div class="prose-block"> + <p> + need to check on your agents from your phone? just ssh in + and run herdr. any ssh client works. no app to download, no + account to create. + </p> + </div> + <div class="detach-flow" style="margin-top: 1.5rem"> + <div class="detach-line"> + <span class="prompt">$</span> <span class="cmd">ssh</span> + <span class="comment">you@yourserver</span> + </div> + <div class="detach-line"> + <span class="prompt">$</span> <span class="cmd">herdr</span> </div> - <div class="awareness-panel-text"> - <h3>workspaces</h3> - <p>each workspace shows one aggregate dot — the most urgent state across all its agents. yellow means something is working. you scan the full list in a glance.</p> + <div class="detach-line"> + <span class="dim"> + same session, same agents, same state.</span + > </div> </div> - <div class="awareness-panel"> - <div class="awareness-panel-img"> - <img src="/assets/sidebar-agents.png" alt="herdr sidebar agent list"> + </section> + + <div class="gap"></div> + <hr class="section-rule" /> + <div class="gap"></div> + + <!-- ── Awareness ── --> + <section class="section"> + <div class="section-heading"> + <span class="dot dot-working"></span> + <h2>agent awareness</h2> + </div> + <div class="awareness-split"> + <div class="awareness-panel"> + <div class="awareness-panel-img"> + <img + src="/assets/sidebar-workspaces.png" + alt="workspaces" + /> + </div> + <div class="awareness-panel-text"> + <h3>workspaces</h3> + <p> + each workspace rolls up to its most urgent state. + scan the full list in a glance. + </p> + </div> </div> - <div class="awareness-panel-text"> - <h3>agents</h3> - <p>the bottom section shows which specific agents are running in the selected workspace, or across all workspaces when you switch the panel scope. pi is working, droid is idle.</p> + <div class="awareness-panel"> + <div class="awareness-panel-img"> + <img src="/assets/sidebar-agents.png" alt="agents" /> + </div> + <div class="awareness-panel-text"> + <h3>agents</h3> + <p> + see which agents are running, blocked, or finished. + no checking panes one by one. + </p> + </div> </div> </div> - </div> - <div class="state-bar"> - <div class="state-bar-item"><span class="state-dot red"></span> blocked</div> - <div class="state-bar-item"><span class="state-dot blue"></span> done</div> - <div class="state-bar-item"><span class="state-dot yellow"></span> working</div> - <div class="state-bar-item"><span class="state-dot green"></span> idle</div> - </div> - </section> - - <div class="section-gap"></div> - - <!-- ── How it works ── --> - <section class="how-section"> - <h2>how it works</h2> - <div class="how-grid"> - <div class="how-step"> - <div class="step-num">01</div> - <h3>install and launch</h3> - <p>one binary, no dependencies. run <code>herdr</code> in your terminal. onboarding takes 10 seconds.</p> + <div class="state-bar"> + <div class="state-bar-item"> + <span class="dot dot-blocked"></span> blocked + </div> + <div class="state-bar-item"> + <span class="dot dot-working"></span> working + </div> + <div class="state-bar-item"> + <span class="dot dot-done"></span> done + </div> + <div class="state-bar-item"> + <span class="dot dot-idle"></span> idle + </div> </div> - <div class="how-step"> - <div class="step-num">02</div> - <h3>create workspaces</h3> - <p>press <code>n</code> to create a workspace. it opens as a terminal context, labels itself from git repo or folder name.</p> + </section> + + <div class="gap"></div> + <hr class="section-rule" /> + <div class="gap"></div> + + <!-- ── Terminal ── --> + <section class="section"> + <div class="section-heading"> + <span class="dot dot-idle"></span> + <h2>lives in your terminal</h2> </div> - <div class="how-step"> - <div class="step-num">03</div> - <h3>launch agents</h3> - <p>start your agents in panes like you normally would. herdr detects them automatically — no hooks, no config.</p> + <div class="terminal-block"> + <p> + not a gui window. not a web dashboard. not electron. + <strong + >herdr runs inside whatever terminal you already + use.</strong + > + a single rust binary, no dependencies, nothing to configure. + it even works inside tmux. + </p> + <div class="term-pills"> + <span class="term-pill">ghostty</span> + <span class="term-pill">alacritty</span> + <span class="term-pill">kitty</span> + <span class="term-pill">wezterm</span> + <span class="term-pill">iterm2</span> + <span class="term-pill">tmux</span> + </div> </div> - </div> - </section> - - <div class="section-gap"></div> - - <!-- ── Supported agents ── --> - <section class="agents-section"> - <h2>supported agents</h2> - <p class="section-desc">herdr detects agents by reading foreground process and terminal output patterns. zero config required.</p> - <div class="agents-table-wrap"> - <table class="agents-table"> - <thead> - <tr> - <th>agent</th> - <th>idle / done</th> - <th>working</th> - <th>blocked</th> - </tr> - </thead> - <tbody> - <tr> - <td><a href="https://pi.dev">pi</a></td> - <td><span class="check">✓</span></td> - <td><span class="check">✓</span></td> - <td><span class="partial">partial</span></td> - </tr> - <tr> - <td><a href="https://docs.anthropic.com/en/docs/claude-code">claude code</a></td> - <td><span class="check">✓</span></td> - <td><span class="check">✓</span></td> - <td><span class="check">✓</span></td> - </tr> - <tr> - <td><a href="https://github.com/openai/codex">codex</a></td> - <td><span class="check">✓</span></td> - <td><span class="check">✓</span></td> - <td><span class="check">✓</span></td> - </tr> - <tr> - <td><a href="https://factory.ai">droid</a></td> - <td><span class="check">✓</span></td> - <td><span class="check">✓</span></td> - <td><span class="check">✓</span></td> - </tr> - <tr> - <td><a href="https://ampcode.com">amp</a></td> - <td><span class="check">✓</span></td> - <td><span class="check">✓</span></td> - <td><span class="partial">partial</span></td> - </tr> - <tr> - <td><a href="https://github.com/anomalyco/opencode">opencode</a></td> - <td><span class="check">✓</span></td> - <td><span class="check">✓</span></td> - <td><span class="check">✓</span></td> - </tr> - <tr> - <td><a href="https://github.com/google-gemini/gemini-cli">gemini cli</a></td> - <td colspan="3"><span class="untested">detected, not fully tested</span></td> - </tr> - <tr> - <td><a href="https://cursor.com/cli">cursor agent</a></td> - <td colspan="3"><span class="untested">detected, not fully tested</span></td> - </tr> - <tr> - <td><a href="https://github.com/cline/cline">cline</a></td> - <td colspan="3"><span class="untested">detected, not fully tested</span></td> - </tr> - </tbody> - </table> - </div> - </section> + </section> - <div class="section-gap"></div> + <div class="gap"></div> + <hr class="section-rule" /> + <div class="gap"></div> - <!-- ── API ── --> - <section class="api-section"> - <div class="api-card"> - <div> + <!-- ── Agents ── --> + <section class="section"> + <div class="section-heading"> + <span class="dot dot-blocked"></span> + <h2>supported agents</h2> + </div> + <div class="table-wrap"> + <table class="agents-table"> + <thead> + <tr> + <th>agent</th> + <th>idle / done</th> + <th>working</th> + <th>blocked</th> + </tr> + </thead> + <tbody> + <tr> + <td><a href="https://pi.dev">pi</a></td> + <td><span class="check">✓</span></td> + <td><span class="check">✓</span></td> + <td><span class="partial">partial</span></td> + </tr> + <tr> + <td> + <a + href="https://docs.anthropic.com/en/docs/claude-code" + >claude code</a + > + </td> + <td><span class="check">✓</span></td> + <td><span class="check">✓</span></td> + <td><span class="check">✓</span></td> + </tr> + <tr> + <td> + <a href="https://github.com/openai/codex" + >codex</a + > + </td> + <td><span class="check">✓</span></td> + <td><span class="check">✓</span></td> + <td><span class="check">✓</span></td> + </tr> + <tr> + <td><a href="https://factory.ai">droid</a></td> + <td><span class="check">✓</span></td> + <td><span class="check">✓</span></td> + <td><span class="check">✓</span></td> + </tr> + <tr> + <td><a href="https://ampcode.com">amp</a></td> + <td><span class="check">✓</span></td> + <td><span class="check">✓</span></td> + <td><span class="check">✓</span></td> + </tr> + <tr> + <td> + <a href="https://github.com/anomalyco/opencode" + >opencode</a + > + </td> + <td><span class="check">✓</span></td> + <td><span class="check">✓</span></td> + <td><span class="check">✓</span></td> + </tr> + <tr> + <td> + <a + href="https://github.com/google-gemini/gemini-cli" + >gemini cli</a + > + </td> + <td colspan="3"> + <span class="untested" + >detected, not fully tested</span + > + </td> + </tr> + <tr> + <td> + <a href="https://cursor.com/cli" + >cursor agent</a + > + </td> + <td colspan="3"> + <span class="untested" + >detected, not fully tested</span + > + </td> + </tr> + <tr> + <td> + <a href="https://github.com/cline/cline" + >cline</a + > + </td> + <td colspan="3"> + <span class="untested" + >detected, not fully tested</span + > + </td> + </tr> + </tbody> + </table> + </div> + </section> + + <div class="gap"></div> + <hr class="section-rule" /> + <div class="gap"></div> + + <!-- ── API ── --> + <section class="section"> + <div class="section-heading"> + <span class="dot dot-done"></span> <h2>socket api</h2> - <p class="subtitle">agents can use herdr too</p> - <p>herdr exposes a local unix socket that agents can talk to directly. create workspaces and tabs, split panes, spawn agents, read output, and wait for state changes.</p> - <p>the same surface is available as CLI commands (<code>herdr workspace</code>, <code>herdr tab</code>, <code>herdr pane</code>, <code>herdr wait</code>) and as a reusable agent skill.</p> - <div class="api-doc-links"> - <a href="https://github.com/ogulcancelik/herdr/blob/master/SOCKET_API.md">socket api docs →</a> - <a href="https://github.com/ogulcancelik/herdr/blob/master/SKILL.md">agent skill →</a> - </div> </div> - <div class="code-block"> - <pre><span class="comment"># create a workspace with a label</span> -<span class="cmd">herdr</span> workspace create <span class="flag">--cwd</span> <span class="str">~/project</span> <span class="flag">--label</span> <span class="str">"api server"</span> + <div class="api-grid"> + <div class="api-text"> + <p> + <strong>agents can use herdr too.</strong> the local + unix socket lets agents create workspaces, split panes, + spawn other agents, read output, and wait for state + changes. + </p> + <p> + available as CLI commands or as a reusable agent skill. + </p> + <div class="api-links"> + <a + href="https://github.com/ogulcancelik/herdr/blob/master/SOCKET_API.md" + >socket api →</a + > + <a + href="https://github.com/ogulcancelik/herdr/blob/master/SKILL.md" + >agent skill →</a + > + </div> + </div> + <div class="code-block"> + <pre><span class="comment"># create a workspace and tab</span> +<span class="cmd">herdr</span> workspace create <span class="flag">--cwd</span> <span class="str">~/project</span> <span class="flag">--label</span> <span class="str">"api"</span> +<span class="cmd">herdr</span> tab create <span class="flag">--label</span> <span class="str">"logs"</span> -<span class="comment"># split a pane and run a command</span> +<span class="comment"># split a pane and run</span> <span class="cmd">herdr</span> pane split <span class="str">1-1</span> <span class="flag">--direction</span> <span class="str">right</span> <span class="cmd">herdr</span> pane run <span class="str">1-2</span> <span class="str">"npm test"</span> -<span class="comment"># wait for an agent to finish</span> +<span class="comment"># wait for an agent</span> <span class="cmd">herdr</span> wait agent-status <span class="str">1-1</span> <span class="flag">--status</span> <span class="str">done</span> -<span class="comment"># read pane output</span> -<span class="cmd">herdr</span> pane read <span class="str">1-2</span> <span class="flag">--source</span> <span class="str">recent-unwrapped</span> <span class="flag">--lines</span> <span class="str">50</span></pre> +<span class="comment"># read output</span> +<span class="cmd">herdr</span> pane read <span class="str">1-2</span> <span class="flag">--source</span> <span class="str">recent</span> <span class="flag">--lines</span> <span class="str">50</span></pre> + </div> </div> - </div> - </section> - - <div class="section-gap"></div> - - <!-- ── Footer ── --> - <footer class="footer"> - <hr class="footer-line"> - <p> - <a href="https://github.com/ogulcancelik/herdr">github</a> · - <a href="https://github.com/ogulcancelik/herdr/blob/master/CONFIGURATION.md">configuration</a> · - <a href="https://github.com/ogulcancelik/herdr/blob/master/SOCKET_API.md">api</a> · - <a href="https://github.com/ogulcancelik/herdr/releases">releases</a> - </p> - <p style="margin-top: 0.75rem;">linux · macos · agpl-3.0</p> - </footer> - - <script> - (function() { - 'use strict'; - - // ── Sheep ── - var hero = document.getElementById('hero'); - var pasture = document.createElement('div'); - pasture.className = 'hero-pasture'; - pasture.setAttribute('aria-hidden', 'true'); - hero.prepend(pasture); - - var SR = [ - [' ,ww',' wWWWWWWW_)'," `WWWWWW'",' II II'], - [' ,ww',' wWWWWWWW_)'," `WWWWWW'",' II II'] - ]; - var SL = [ - [' ww,','(_WWWWWWWw'," 'WWWWWW`",' II II'], - [' ww,','(_WWWWWWWw'," 'WWWWWW`",' II II'] - ]; - - var heroW = hero.offsetWidth; - var heroH = hero.offsetHeight; - var heroRect = hero.getBoundingClientRect(); - var mx = -9999, my = -9999; - - document.addEventListener('mousemove', function(e) { - mx = e.clientX - heroRect.left; - my = e.clientY - heroRect.top; - }); - document.addEventListener('mouseleave', function() { mx = -9999; my = -9999; }); - - window.addEventListener('resize', function() { - heroW = hero.offsetWidth; - heroH = hero.offsetHeight; - heroRect = hero.getBoundingClientRect(); - }); - window.addEventListener('scroll', function() { - heroRect = hero.getBoundingClientRect(); - }); - - var flock = []; - var count = window.matchMedia('(max-width: 640px)').matches ? 4 : 8; - - for (var i = 0; i < count; i++) { - var el = document.createElement('pre'); - el.className = 'sheep-el'; - var opacity = 0.04 + Math.random() * 0.035; - var size = 10 + Math.random() * 4; - el.style.cssText = 'font-size:' + size + 'px;color:rgba(255,255,255,' + opacity + ')'; - pasture.appendChild(el); - - flock.push({ - el: el, - x: Math.random() * heroW, - y: 30 + Math.random() * (heroH - 80), - dir: Math.random() > 0.5 ? 1 : -1, - speed: 0.15 + Math.random() * 0.3, - frame: 0, - ft: 0, - fi: 400 + Math.random() * 300, - svx: 0, - svy: 0 - }); - } - - var last = 0; - function tick(ts) { - var dt = Math.min(ts - last, 100); - last = ts; - for (var i = 0; i < flock.length; i++) { - var s = flock[i]; - s.ft += dt; - if (s.ft > s.fi) { s.ft = 0; s.frame ^= 1; } - - // mouse scatter - var dx = s.x - mx, dy = s.y - my; - var d = Math.sqrt(dx * dx + dy * dy); - if (d < 120 && d > 1) { - var f = (1 - d / 120) * 0.6; - s.svx += (dx / d) * f; - s.svy += (dy / d) * f; + </section> + + <div class="gap-lg"></div> + + <!-- ── Footer ── --> + <footer class="footer"> + <p> + <a href="https://github.com/ogulcancelik/herdr">github</a> · + <a + href="https://github.com/ogulcancelik/herdr/blob/master/CONFIGURATION.md" + >configuration</a + > + · + <a + href="https://github.com/ogulcancelik/herdr/blob/master/SOCKET_API.md" + >api</a + > + · + <a + href="https://github.com/egithub.com/ogulcancelik/herdr/releases" + >releases</a + > + </p> + </footer> + + <script> + (function () { + "use strict"; + + var hero = document.getElementById("hero"); + var pasture = hero.querySelector(".hero-pasture"); + + var SR = [ + [" ,ww", " wWWWWWWW_)", " `WWWWWW'", " II II"], + [" ,ww", " wWWWWWWW_)", " `WWWWWW'", " II II"], + ]; + var SL = [ + [" ww,", "(_WWWWWWWw", " 'WWWWWW`", " II II"], + [" ww,", "(_WWWWWWWw", " 'WWWWWW`", " II II"], + ]; + + var heroW = hero.offsetWidth; + var heroH = hero.offsetHeight; + var heroRect = hero.getBoundingClientRect(); + var mx = -9999, + my = -9999; + + document.addEventListener("mousemove", function (e) { + mx = e.clientX - heroRect.left; + my = e.clientY - heroRect.top; + }); + document.addEventListener("mouseleave", function () { + mx = -9999; + my = -9999; + }); + + window.addEventListener("resize", function () { + heroW = hero.offsetWidth; + heroH = hero.offsetHeight; + heroRect = hero.getBoundingClientRect(); + }); + window.addEventListener("scroll", function () { + heroRect = hero.getBoundingClientRect(); + }); + + var flock = []; + var count = window.matchMedia("(max-width: 640px)").matches + ? 3 + : 5; + + for (var i = 0; i < count; i++) { + var el = document.createElement("pre"); + el.className = "sheep-el"; + var opacity = 0.04 + Math.random() * 0.035; + var size = 9 + Math.random() * 3; + el.style.cssText = + "font-size:" + + size + + "px;color:rgba(203,166,247," + + opacity + + ")"; + pasture.appendChild(el); + + flock.push({ + el: el, + x: Math.random() * heroW, + y: 30 + Math.random() * (heroH - 80), + dir: Math.random() > 0.5 ? 1 : -1, + speed: 0.1 + Math.random() * 0.2, + frame: 0, + ft: 0, + fi: 400 + Math.random() * 300, + svx: 0, + svy: 0, + }); + } + + var last = 0; + function tick(ts) { + var dt = Math.min(ts - last, 100); + last = ts; + for (var i = 0; i < flock.length; i++) { + var s = flock[i]; + s.ft += dt; + if (s.ft > s.fi) { + s.ft = 0; + s.frame ^= 1; + } + + var dx = s.x - mx, + dy = s.y - my; + var d = Math.sqrt(dx * dx + dy * dy); + if (d < 120 && d > 1) { + var f = (1 - d / 120) * 0.4; + s.svx += (dx / d) * f; + s.svy += (dy / d) * f; + } + s.x += s.svx; + s.y += s.svy; + s.svx *= 0.97; + s.svy *= 0.97; + + s.x += s.dir * s.speed * (dt / 16); + if (s.dir > 0 && s.x > heroW + 100) s.x = -100; + if (s.dir < 0 && s.x < -100) s.x = heroW + 100; + if (s.y < -40) s.y = heroH + 20; + if (s.y > heroH + 40) s.y = -20; + var frames = s.dir > 0 ? SR : SL; + s.el.textContent = frames[s.frame].join("\n"); + s.el.style.transform = + "translate3d(" + s.x + "px," + s.y + "px,0)"; + } + requestAnimationFrame(tick); + } + requestAnimationFrame(function (ts) { + last = ts; + tick(ts); + }); + + // Copy + var copyBtn = document.getElementById("copy-btn"); + var installCmd = document.getElementById("install-cmd"); + + function fallbackCopy(text) { + var ta = document.createElement("textarea"); + ta.value = text; + ta.style.cssText = "position:fixed;left:-9999px"; + document.body.appendChild(ta); + ta.select(); + document.execCommand("copy"); + document.body.removeChild(ta); } - s.x += s.svx; - s.y += s.svy; - s.svx *= 0.97; - s.svy *= 0.97; - - s.x += s.dir * s.speed * (dt / 16); - if (s.dir > 0 && s.x > heroW + 100) s.x = -100; - if (s.dir < 0 && s.x < -100) s.x = heroW + 100; - if (s.y < -40) s.y = heroH + 20; - if (s.y > heroH + 40) s.y = -20; - var frames = s.dir > 0 ? SR : SL; - s.el.textContent = frames[s.frame].join('\n'); - s.el.style.transform = 'translate3d(' + s.x + 'px,' + s.y + 'px,0)'; - } - requestAnimationFrame(tick); - } - requestAnimationFrame(function(ts) { last = ts; tick(ts); }); - - // ── Copy ── - var copyBtn = document.getElementById('copy-btn'); - var installCmd = document.getElementById('install-cmd'); - - function fallbackCopy(text) { - var ta = document.createElement('textarea'); - ta.value = text; - ta.style.cssText = 'position:fixed;left:-9999px'; - document.body.appendChild(ta); - ta.select(); - document.execCommand('copy'); - document.body.removeChild(ta); - } - - function showCopied() { - copyBtn.textContent = 'copied!'; - copyBtn.classList.add('copied'); - setTimeout(function() { - copyBtn.textContent = 'copy'; - copyBtn.classList.remove('copied'); - }, 2000); - } - - copyBtn.addEventListener('click', function() { - var text = installCmd.textContent; - if (navigator.clipboard && navigator.clipboard.writeText) { - navigator.clipboard.writeText(text).then(showCopied).catch(function() { - fallbackCopy(text); - showCopied(); + + function showCopied() { + copyBtn.textContent = "copied!"; + copyBtn.classList.add("copied"); + setTimeout(function () { + copyBtn.textContent = "copy"; + copyBtn.classList.remove("copied"); + }, 2000); + } + + copyBtn.addEventListener("click", function () { + var text = installCmd.textContent; + if (navigator.clipboard && navigator.clipboard.writeText) { + navigator.clipboard + .writeText(text) + .then(showCopied) + .catch(function () { + fallbackCopy(text); + showCopied(); + }); + } else { + fallbackCopy(text); + showCopied(); + } }); - } else { - fallbackCopy(text); - showCopied(); - } - }); - })(); - </script> -</body> + })(); + </script> + </body> </html> |
