diff --git a/packages/tui/Cargo.lock b/packages/tui/Cargo.lock index dd5a65d5..0a970e96 100644 --- a/packages/tui/Cargo.lock +++ b/packages/tui/Cargo.lock @@ -23,6 +23,12 @@ version = "1.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53" +[[package]] +name = "base64" +version = "0.22.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6" + [[package]] name = "bitflags" version = "2.13.2" @@ -104,6 +110,7 @@ dependencies = [ name = "codework-tui" version = "0.0.1" dependencies = [ + "base64", "chrono", "crossterm", "futures-util", diff --git a/packages/tui/Cargo.toml b/packages/tui/Cargo.toml index fadc1e8c..c0f1db0e 100644 --- a/packages/tui/Cargo.toml +++ b/packages/tui/Cargo.toml @@ -25,3 +25,5 @@ chrono = "0.4" # tree through ratatui, so it costs no extra build to depend on it directly rather than # assume every character is one column wide. unicode-width = "0.2" + +base64 = "0.22" diff --git a/packages/tui/README.md b/packages/tui/README.md index 0b90a84f..90d204bd 100644 --- a/packages/tui/README.md +++ b/packages/tui/README.md @@ -2,12 +2,10 @@ A fast and lightweight terminal interface for [CodeWork](https://www.codework.sh), written in **Rust**. -The TUI is an early skeleton. Today it opens one screen: the landing site's hero — its wordmark over -the same hairline lattice the site draws it on, with a prompt line under it that takes typing. A -leading slash on an empty line opens a menu of the app's commands, as a chat prompt does; as this is -written there are two, `theme`, which lists every palette the site ships, and `exit`. The prompt -cannot be sent, and model selection and the session view are not built yet; the launcher and the RPC -transport they will need are already in place. +The TUI connects to the CodeWork server to send prompts and follow conversations through +`thread.sync`. It supports a multiline composer, saved per-thread drafts, a live thread browser, +model and thinking selection, queued prompt management, +collapsible work logs, conversation forks, Git review, clipboard copying, and older history on demand. --- @@ -81,20 +79,94 @@ pnpm start ## Keyboard Shortcuts -| Shortcut | Action | -| :------------------- | :--------------------------------------------- | -| _any character_ | Type it into the prompt | -| `←` `→` | Move the prompt's caret | -| `Home` `End` | Jump to the start or the end of the prompt | -| `Backspace` `Delete` | Erase a character | -| _paste_ | Insert the clipboard at the caret, on one line | -| `/` | Ask for the command menu | -| `↑` `↓` | Move through a menu | -| `Enter` | Take the entry a menu is on | -| `Esc` | Close the menu, or exit the app | -| `Ctrl+C` | Exit the app | -| `Ctrl+D` | Exit the app | -| `q` | Exit the app (`Ctrl+X`, then `q`) | +| Shortcut | Action | +| --- | --- | +| `Enter` | Send, or steer a running thread | +| `Shift+Enter` / `Ctrl+J` | Insert a newline; pasted code keeps its indentation | +| `↑` / `↓` while typing | Move between composer lines | +| `Home` / `End` | Move to the start/end of the current line | +| `Ctrl+Home` / `Ctrl+End` | Move to the start/end of the whole draft | +| `Ctrl+P` / `/session` | Open the live thread browser; Ctrl+P preserves the current draft | +| `Alt+Enter` | Queue a follow-up | +| `Shift+↑` / `Shift+↓`, mouse wheel, `PageUp` / `PageDown` | Scroll; fetch older history at the top (plain arrows also scroll when the composer is empty) | +| `/queue`, `Alt+↑` / `Alt+↓` | Focus and navigate queued prompts above the composer | +| `l` / `Enter` in queue | Switch steer/follow-up lane, or Send Now when parked/idle | +| `e` in queue | Edit in place; Enter saves, Escape cancels | +| `w` in queue | Cancel and prepend to the composer when cancellation succeeds, preserving the existing draft | +| `Delete` / `d` in queue | Cancel without restoring | +| `Ctrl+G`, `/git`, `/diff` | Review the active thread's Git changes | +| `Ctrl+O` | Toggle the focused turn's work log, or the latest turn | +| `Ctrl+↑` / `Ctrl+↓` | Focus a turn; Space or Enter toggles its work log | +| `/fork` | Pick a committed message; Enter forks after it, `b` forks before a user message and restores its text | +| `/copy`, `Ctrl+Y` | Copy the selected or last assistant answer via OSC 52 | +| `/model`, `/thinking`, `/session`, `/theme` | Open the corresponding picker (`/session` lists threads) | +| `/new`, `/reload` | Start a new session or reload plugins | +| `Esc` | Close editing/focus/menu, interrupt a running thread, clear the composer, or exit | +| `Ctrl+C`, `Ctrl+D`, `Ctrl+X` then `q` | Exit | + +The composer grows to six visible text rows and scrolls to keep the caret visible. Drafts +are saved after 400 ms of inactivity and when switching threads or exiting. They live in +`/tui/drafts/`, separated by server endpoint and thread; the default home is +`~/.codework` and can be changed with `CODEWORK_HOME_DIR`. Empty drafts are removed. +Scroll position and work-log choices are remembered while this TUI stays open. + +The browser groups threads by project and session, with main/fork/subagent labels and +idle/starting/running/parked states. It watches `index.sync` and refreshes `thread.list` +without losing the current filter or selection. Closing it stops the subscription. + +OSC 52 sends clipboard content through the terminal, including over SSH. Clipboard access +must be enabled in the terminal (and forwarded by any terminal multiplexer). + +## Git Review + +Open a thread, then press `Ctrl+G` or run `/git` or `/diff`. The session header shows its +branch and changed-file count once the server publishes Git status. The review screen shows +branch/HEAD, added/modified/deleted files, line counts, and patches fetched on demand. +It resolves the thread's placement first, then the session's space, including remote spaces. + +| Key | Action | +| --- | --- | +| `↑` / `↓`, mouse wheel | Select files, or scroll when the patch has focus | +| `Enter` / `Tab` | Focus the patch / switch focus between files and patch | +| `[` / `]`, `←` / `→` | Previous/next file | +| `n` / `p` | Next/previous hunk | +| `PageUp` / `PageDown`, `Home` / `End` | Navigate the patch | +| `v` | Cycle auto, unified, and split layout (split needs sufficient width) | +| `r` | Fetch the selected patch again | +| `Esc` | Return to files, then conversation | +| `Ctrl+G` | Return directly to the conversation | + +Wide terminals show files and patch together; narrow terminals show the focused pane. +Inline tool diffs retain their compact preview. The review screen reuses the same renderer +with the preview line cap removed. It labels cached and truncated server responses and +reports binary/metadata-only or omitted text patches explicitly. + +The existing Git daemon reports the combined working-tree difference against HEAD, with +untracked files included within its limits. This interface uses `plugin.git.status` and +`daemon.call` (`git` / `diff`); it does not run Git on the client. Status appears after the +server mounts the space. Git staging, committing, pushing, and separate staged/unstaged +views are not exposed by the current RPC contract. + +## Verification + +```bash +cd packages/tui +cargo test +cargo clippy --all-targets -- -D warnings +``` + +The terminal integration test launches the real binary in a Python 3 standard-library PTY +against a deterministic local WebSocket peer; it does not need provider credentials. +The restart test also launches the binary twice, checks a live browser update, and verifies +that multiline text survives switching threads, restarting, and sending. Its artifact is +`__artifacts__/composer.json`. +The Git integration test creates a real temporary repository and launches the real binary +against a deterministic RPC peer serving that repository's patches. Its request artifact is +`__artifacts__/git.json`; `__artifacts__/git.txt` checks the review screen, including cached +and truncated states. +The suite records the queue, fork, and paging RPCs in `__artifacts__/terminal.json` and checks +rendered conversation output in `__artifacts__/conversation.txt`. Regenerate intentional +changes with `UPDATE_ARTIFACTS=1 cargo test`, then rerun `cargo test` without that variable. --- diff --git a/packages/tui/__artifacts__/composer.json b/packages/tui/__artifacts__/composer.json new file mode 100644 index 00000000..68d75e9d --- /dev/null +++ b/packages/tui/__artifacts__/composer.json @@ -0,0 +1,14 @@ +{ + "savedDrafts": [ + { + "caret": 10, + "text": "fork draft" + } + ], + "sent": { + "delivery": "followUp", + "sessionId": "session", + "text": "fn main() {\n 🦀\n}\ntail", + "threadId": "main" + } +} diff --git a/packages/tui/__artifacts__/conversation.txt b/packages/tui/__artifacts__/conversation.txt new file mode 100644 index 00000000..863a224f --- /dev/null +++ b/packages/tui/__artifacts__/conversation.txt @@ -0,0 +1,18 @@ + ● Conversation /workspace default model +──────────────────────────────────────────────────────────────────────────────────────── + ❯ Explain the change + 00:00 + ▸ default model worked for 1m 2s + + The conversation is ready. + 00:01 · /fork · ctrl+y copy + + + + + Queued · parked · l Send Now + ↳ [follow-up] Next question + ┌────────────────────────────────────────────────────────────────────────── alpha ─┐ + │❯ build me flappy bird │ + └──────────────────────────────────────────────────────────────────────────────────┘ + enter send · ctrl+j newline · ctrl+p threads · alt+↑ queue · ctrl+o work \ No newline at end of file diff --git a/packages/tui/__artifacts__/git.json b/packages/tui/__artifacts__/git.json new file mode 100644 index 00000000..00fb32e0 --- /dev/null +++ b/packages/tui/__artifacts__/git.json @@ -0,0 +1,46 @@ +[ + { + "input": { + "context": 3, + "files": [ + "notes with spaces.txt" + ] + }, + "method": "diff", + "plugin": "git", + "spaceId": "space" + }, + { + "input": { + "context": 3, + "files": [ + "obsolete.txt" + ] + }, + "method": "diff", + "plugin": "git", + "spaceId": "space" + }, + { + "input": { + "context": 3, + "files": [ + "src/main.rs" + ] + }, + "method": "diff", + "plugin": "git", + "spaceId": "space" + }, + { + "input": { + "context": 3, + "files": [ + "src/main.rs" + ] + }, + "method": "diff", + "plugin": "git", + "spaceId": "space" + } +] diff --git a/packages/tui/__artifacts__/git.txt b/packages/tui/__artifacts__/git.txt new file mode 100644 index 00000000..efd60664 --- /dev/null +++ b/packages/tui/__artifacts__/git.txt @@ -0,0 +1,18 @@ +Git Changes · main · 01234567 +2 files · +2 -2 · working tree vs HEAD +┌ Files ────────────────────────┐┌ notes with spaces.txt · auto ───────────────────────────────────┐ +│❯ M notes with spaces.txt +1 -1││ 1 + New notes │ +│ M src/a.rs +1 -1 ││ │ +│ ││ │ +│ ││ │ +│ ││ │ +│ ││ │ +│ ││ │ +│ ││ │ +│ ││ │ +│ ││ │ +│ ││ │ +└───────────────────────────────┘└─────────────────────────────────────────────────────────────────┘ +cached · server snapshot; the space is not mounted +truncated · some patches or files were omitted by the server +↑↓ move/scroll · tab focus · [] files · n/p hunks · v view · r refresh · esc back diff --git a/packages/tui/__artifacts__/terminal.json b/packages/tui/__artifacts__/terminal.json new file mode 100644 index 00000000..9c8e28a2 --- /dev/null +++ b/packages/tui/__artifacts__/terminal.json @@ -0,0 +1,46 @@ +[ + { + "payload": { + "before": 8, + "limit": 60, + "sessionId": "session", + "threadId": "main" + }, + "tag": "thread.page" + }, + { + "payload": { + "delivery": "steer", + "messageId": "q", + "sessionId": "session", + "threadId": "main" + }, + "tag": "thread.update" + }, + { + "payload": { + "messageId": "q", + "sessionId": "session", + "text": "rewritten", + "threadId": "main" + }, + "tag": "thread.update" + }, + { + "payload": { + "messageId": "q", + "sessionId": "session", + "threadId": "main" + }, + "tag": "thread.cancel" + }, + { + "payload": { + "entryId": "old", + "mode": "before", + "sessionId": "session", + "threadId": "main" + }, + "tag": "thread.fork" + } +] diff --git a/packages/tui/src/app.rs b/packages/tui/src/app.rs index 5575f899..141173b4 100644 --- a/packages/tui/src/app.rs +++ b/packages/tui/src/app.rs @@ -1,42 +1,42 @@ -//! Application state, and the only place that mutates it. -//! -//! `update` is the single entry point for change: it takes an event and reports -//! whether the screen needs redrawing. That report is the whole redraw policy — -//! there is no tick, so an idle TUI does no work and no repaint. - -use std::cell::Cell; -use std::collections::BTreeMap; -use std::time::{SystemTime, UNIX_EPOCH}; - -use crossterm::event::{KeyCode, KeyEvent, KeyModifiers}; -use ratatui::style::Color; -use tokio::sync::mpsc; - +//! The thread projection and keyboard interactions. Network tasks return scoped events; +//! only this module mutates conversation state. use crate::action::{Action, Keymap, Resolution}; +use crate::draft::DraftStore; use crate::event::{AppEvent, RpcEvent}; use crate::menu::{Entry, Menu, Preview}; use crate::prompt::Prompt; +use crate::rpc::protocol::{ForkMode, ForkResponse, ThreadRefPayload}; use crate::rpc::{RpcClient, StreamEvent}; use crate::theme::{self, Palette}; -use crate::tool::ToolCall; +use crate::tool::{ToolCall, ToolStatus}; use crate::types::{ - HistoryEntry, ModelList, Part, PromptDelivery, ServerInfo, SessionInfo, ToolResultContent, - UsageReport, + DeltaKind, HistoryEntry, InboxState, LiveDelta, ModelList, Part, PromptDelivery, ServerInfo, + ThreadInfo, ThreadItem, ToolResultContent, }; +use base64::Engine; +use crossterm::event::{KeyCode, KeyEvent, KeyModifiers}; +use ratatui::style::Color; +use std::cell::Cell; +use std::collections::{BTreeMap, BTreeSet}; +use std::io::Write; +use std::sync::Arc; +use std::time::{SystemTime, UNIX_EPOCH}; +use tokio::sync::mpsc; -/// What a leading slash offers. Only commands the app can actually perform are listed, and an -/// entry's name is what choosing it matches on. const COMMANDS: &[Entry] = &[ Entry::item("model", "pick a model"), Entry::item("thinking", "set thinking effort"), - Entry::item("session", "switch or resume a session"), - Entry::item("new", "start a new session"), - Entry::item("reload", "reload server plugins"), + Entry::item("session", "switch threads"), + Entry::item("new", "start a session"), + Entry::item("queue", "manage queued prompts"), + Entry::item("fork", "pick a committed message; b to re-edit"), + Entry::item("copy", "copy last assistant answer"), + Entry::item("git", "review working-tree changes"), + Entry::item("diff", "review working-tree patches"), + Entry::item("reload", "reload plugins"), Entry::item("theme", "pick a palette"), Entry::item("exit", "close the app"), ]; - -/// Thinking effort levels in ascending order, matching `packages/codework/src/acp/config.ts`. const THINKING_LEVELS: &[(&str, &str)] = &[ ("off", "Off"), ("minimal", "Minimal"), @@ -47,13 +47,11 @@ const THINKING_LEVELS: &[(&str, &str)] = &[ ("max", "Max"), ]; -/// The screens the TUI can show. #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum Screen { Welcome, Session, } - #[derive(Debug, Clone, PartialEq, Eq)] pub enum TurnState { Running, @@ -61,324 +59,276 @@ pub enum TurnState { Failed(String), Interrupted(String), } - -#[derive(Debug, Clone, PartialEq, Eq)] +#[derive(Debug, Clone)] pub struct RetryStatus { pub attempt: u64, pub max_retries: u64, pub delay_ms: u64, pub message: String, } - -#[derive(Debug, Clone, PartialEq, Eq)] +#[derive(Debug, Clone)] pub struct QueuedPrompt { pub message_id: String, pub prompt: String, pub delivery: PromptDelivery, pub admitted: bool, - pub dispatched: bool, -} - -#[derive(Debug, Clone, Default, PartialEq, Eq)] -pub struct AssistantDraft { - pub message_id: String, - pub thinking_parts: BTreeMap, - pub text_parts: BTreeMap, } - #[derive(Debug, Clone)] pub struct Turn { pub prompt_id: Option, pub prompt: String, pub thinking: String, + pub notes: String, pub text: String, pub tools: Vec, pub notices: Vec, pub retry: Option, pub state: TurnState, - pub drafts: Vec, + pub created_at: u64, + pub updated_at: u64, + pub work_open: Option, + pub answer_present: bool, + pub last_draft: bool, } - impl Turn { pub fn new(prompt: impl Into) -> Self { Self { prompt_id: None, prompt: prompt.into(), thinking: String::new(), + notes: String::new(), text: String::new(), tools: Vec::new(), notices: Vec::new(), retry: None, state: TurnState::Running, - drafts: Vec::new(), + created_at: 0, + updated_at: 0, + work_open: None, + answer_present: false, + last_draft: false, } } - - pub fn with_id(message_id: impl Into, prompt: impl Into) -> Self { + pub fn with_id(id: impl Into, prompt: impl Into) -> Self { let mut turn = Self::new(prompt); - turn.prompt_id = Some(message_id.into()); + turn.prompt_id = Some(id.into()); turn } - - fn draft_mut(&mut self, message_id: &str) -> &mut AssistantDraft { - if let Some(pos) = self.drafts.iter().position(|d| d.message_id == message_id) { - return &mut self.drafts[pos]; - } - self.drafts.push(AssistantDraft { - message_id: message_id.to_string(), - thinking_parts: BTreeMap::new(), - text_parts: BTreeMap::new(), - }); - self.drafts.last_mut().expect("draft inserted") - } - - pub fn start_llm(&mut self, message_id: &str) { - self.retry = None; - let _ = self.draft_mut(message_id); - self.sync_thinking(); - self.sync_text(); - } - - pub fn fail_llm(&mut self, message_id: &str) { - self.drafts.retain(|d| d.message_id != message_id); - self.sync_thinking(); - self.sync_text(); - } - - pub fn start_text_part(&mut self, message_id: &str, part_index: usize) { - self.retry = None; - self.draft_mut(message_id) - .text_parts - .entry(part_index) - .or_default(); - } - - pub fn append_text_delta( - &mut self, - message_id: Option<&str>, - part_index: Option, - delta: &str, - ) { - self.retry = None; - let msg_id = message_id - .map(str::to_string) - .or_else(|| self.drafts.last().map(|d| d.message_id.clone())) - .unwrap_or_default(); - let idx = part_index.unwrap_or(0); - self.draft_mut(&msg_id) - .text_parts - .entry(idx) - .or_default() - .push_str(delta); - self.sync_text(); - } - - pub fn end_text_part(&mut self, message_id: &str, part_index: usize, content: String) { - self.retry = None; - self.draft_mut(message_id) - .text_parts - .insert(part_index, content); - self.sync_text(); + pub fn working(&self) -> bool { + self.state == TurnState::Running + && (!self.last_draft + || !self.answer_present + || self.tools.iter().any(|t| t.status == ToolStatus::Running)) } - - pub fn start_thinking_part(&mut self, message_id: &str, part_index: usize) { - self.retry = None; - self.draft_mut(message_id) - .thinking_parts - .entry(part_index) - .or_default(); - } - - pub fn append_thinking_delta( - &mut self, - message_id: Option<&str>, - part_index: Option, - delta: &str, - ) { - self.retry = None; - let msg_id = message_id - .map(str::to_string) - .or_else(|| self.drafts.last().map(|d| d.message_id.clone())) - .unwrap_or_default(); - let idx = part_index.unwrap_or(0); - self.draft_mut(&msg_id) - .thinking_parts - .entry(idx) - .or_default() - .push_str(delta); - self.sync_thinking(); + pub fn work_expanded(&self) -> bool { + self.work_open.unwrap_or_else(|| self.working()) } - - pub fn end_thinking_part(&mut self, message_id: &str, part_index: usize, content: String) { - self.retry = None; - self.draft_mut(message_id) - .thinking_parts - .insert(part_index, content); - self.sync_thinking(); + pub fn duration(&self) -> String { + format_elapsed(self.updated_at.saturating_sub(self.created_at)) } - - pub fn sync_text(&mut self) { - let mut combined = String::new(); - for draft in &self.drafts { - for part in draft.text_parts.values() { - if part.is_empty() { - continue; - } - if !combined.is_empty() && !combined.ends_with('\n') && !part.starts_with('\n') { - combined.push_str("\n\n"); - } - combined.push_str(part); - } - } - self.text = combined; + pub fn has_work(&self) -> bool { + !self.thinking.is_empty() || !self.notes.is_empty() || !self.tools.is_empty() } +} - pub fn sync_thinking(&mut self) { - let mut combined = String::new(); - for draft in &self.drafts { - for part in draft.thinking_parts.values() { - if part.is_empty() { - continue; - } - if !combined.is_empty() && !combined.ends_with('\n') && !part.starts_with('\n') { - combined.push('\n'); - } - combined.push_str(part); - } +pub fn format_elapsed(ms: u64) -> String { + let seconds = ((ms.saturating_add(500)) / 1000).max(1); + if seconds < 60 { + format!("{seconds}s") + } else if seconds < 3600 { + if seconds.is_multiple_of(60) { + format!("{}m", seconds / 60) + } else { + format!("{}m {}s", seconds / 60, seconds % 60) } - self.thinking = combined; + } else { + format!("{}h {}m", seconds / 3600, (seconds / 60) % 60) } } +pub fn osc52(text: &str) -> String { + format!( + "\x1b]52;c;{}\x07", + base64::engine::general_purpose::STANDARD.encode(text) + ) +} -/// A menu open over the active screen, taking navigation keys while it is there. pub enum Popup { - /// What a leading slash asks for. Commands(Menu), - /// Selectable `provider/model` identifiers. - Models { search: Prompt, menu: Menu }, - /// Selectable thinking effort levels. + Models { + search: Prompt, + menu: Menu, + }, Thinking(Menu), - /// Sessions on the server (`session.list`). Sessions { search: Prompt, menu: Menu, - sessions: Vec, + sessions: Vec, }, - /// The palettes the site ships, filtered by `search`, and the one that was on screen before - /// the picker opened so Escape can put it back. Themes { search: Prompt, menu: Menu, initial: &'static Palette, }, + Fork(Menu), } - impl Popup { pub fn menu(&self) -> &Menu { match self { - Popup::Commands(menu) - | Popup::Thinking(menu) - | Popup::Models { menu, .. } - | Popup::Sessions { menu, .. } - | Popup::Themes { menu, .. } => menu, + Self::Commands(menu) + | Self::Thinking(menu) + | Self::Fork(menu) + | Self::Models { menu, .. } + | Self::Sessions { menu, .. } + | Self::Themes { menu, .. } => menu, } } - fn menu_mut(&mut self) -> &mut Menu { match self { - Popup::Commands(menu) - | Popup::Thinking(menu) - | Popup::Models { menu, .. } - | Popup::Sessions { menu, .. } - | Popup::Themes { menu, .. } => menu, + Self::Commands(menu) + | Self::Thinking(menu) + | Self::Fork(menu) + | Self::Models { menu, .. } + | Self::Sessions { menu, .. } + | Self::Themes { menu, .. } => menu, } } - - /// The menu's own search prompt, when it has one. pub fn search(&self) -> Option<&Prompt> { match self { - Popup::Commands(_) | Popup::Thinking(_) => None, - Popup::Models { search, .. } - | Popup::Sessions { search, .. } - | Popup::Themes { search, .. } => Some(search), + Self::Models { search, .. } + | Self::Sessions { search, .. } + | Self::Themes { search, .. } => Some(search), + _ => None, } } - - /// What the menu calls itself, on its border. pub fn title(&self) -> &'static str { match self { - Popup::Commands(_) => "commands", - Popup::Models { .. } => "models", - Popup::Thinking(_) => "thinking", - Popup::Sessions { .. } => "sessions", - Popup::Themes { .. } => "themes", + Self::Commands(_) => "commands", + Self::Models { .. } => "models", + Self::Thinking(_) => "thinking", + Self::Sessions { .. } => "threads", + Self::Themes { .. } => "themes", + Self::Fork(_) => "fork · enter at · b before user · esc close", } } } +#[derive(Debug, Clone, PartialEq)] +pub enum OperationResult { + Cancel { + id: String, + restore: Option, + cancelled: bool, + }, + Update { + id: String, + delivery: Option, + text: Option, + updated: bool, + }, + QueueFailed { + id: String, + error: String, + }, + PageFailed(String), + Fork(ForkResponse), + Page { + before: u64, + entries: Vec, + }, + Info(ThreadInfo), + Sent { + id: String, + }, + SendFailed { + id: String, + error: String, + }, + Notice(String), +} + +pub struct QueueEdit { + pub id: String, + pub text: Prompt, +} +struct Remembered { + prompt: Prompt, + scroll: usize, + work: BTreeMap, +} pub struct App { pub screen: Screen, - /// The palette every screen draws with. Held here rather than read from a global, so a frame - /// is a pure function of the app and can be reproduced from a test backend. pub theme: &'static Palette, - /// The prompt line: its text and where the caret is in it. pub prompt: Prompt, - /// The menu on screen, if there is one. pub popup: Option, - /// A line of plain truth about the prompt or RPC status, shown in place of the key hints. pub notice: Option, - /// Verified server identity (`pid` and `version`) from `server.info`. pub server_info: Option, - /// Active server session, once created or attached. - pub session: Option, - /// Available models and the resolved settings default from `model.list`. + pub session: Option, pub models: Option, - /// Selected `(provider, model)` override; when `None`, the server uses its configured default. pub model: Option<(String, String)>, - /// Selected thinking effort level. pub thinking: Option, - /// Cumulative token and cost usage for the active session. - pub usage: UsageReport, - /// Conversation turns in the active session. pub turns: Vec, - /// Prompts submitted while a turn is running (`steer` or `followUp`), awaiting promotion. pub queued_prompts: Vec, - /// Whether a prompt turn is currently streaming from the server. pub busy: bool, - /// Whether the stream socket dropped and is reconnecting. pub reconnecting: bool, - /// Durable `session.log` cursor (`max(last durable.seq, last log.synced.seq)`). - pub log_cursor: Option, - /// Scroll offset in lines from the bottom of the session transcript. + pub entries: Vec, + pub floor: Option, pub scroll: usize, - /// Maximum scroll offset computed by the last transcript render pass. pub max_scroll: Cell, pub should_quit: bool, + pub queue_focus: Option, + pub queue_edit: Option, + pub focused_turn: Option, + pub queue_pending: BTreeSet, + pub git: crate::git::Git, + git_generation: u64, + git_stream: Option, + git_patch: Option, + drafts: DraftStore, + remembered: BTreeMap, + work_restore: BTreeMap, + draft_revision: u64, + draft_timer: Option, + browser_generation: u64, + browser_stream: Option, + info_revision: u64, + paging: bool, + creating: bool, + generation: u64, next_prompt_seq: u64, + early: BTreeMap>, + revisions: BTreeMap, prompt_stream: Option, - initial_prompt_id: Option, - history_request: Cell, - history_revision: u64, keymap: Keymap, + client: Arc, tx: mpsc::UnboundedSender, } - impl Default for App { fn default() -> Self { let (tx, _) = mpsc::unbounded_channel(); - Self::new(tx) + Self::with_client(tx, RpcClient::default()) } } - impl Drop for App { fn drop(&mut self) { - self.stop_prompt_stream(); + self.stop_stream(); + self.stop_browser(); + self.stop_git(); + if let Some(timer) = self.draft_timer.take() { + timer.abort(); + } + let _ = self.drafts.save(&self.draft_key(), &self.prompt); } } - impl App { - pub fn new(tx: mpsc::UnboundedSender) -> Self { - let app = Self { + pub fn with_client(tx: mpsc::UnboundedSender, client: RpcClient) -> Self { + Self::with_storage(tx, client, DraftStore::default()) + } + pub fn with_storage( + tx: mpsc::UnboundedSender, + client: RpcClient, + drafts: DraftStore, + ) -> Self { + let mut app = Self { screen: Screen::Welcome, theme: theme::default_palette(), prompt: Prompt::default(), @@ -389,1590 +339,1650 @@ impl App { models: None, model: None, thinking: None, - usage: UsageReport::default(), turns: Vec::new(), queued_prompts: Vec::new(), busy: false, reconnecting: false, - log_cursor: None, + entries: Vec::new(), + floor: None, scroll: 0, max_scroll: Cell::new(0), should_quit: false, + queue_focus: None, + queue_edit: None, + focused_turn: None, + queue_pending: BTreeSet::new(), + git: crate::git::Git::default(), + git_generation: 0, + git_stream: None, + git_patch: None, + drafts, + remembered: BTreeMap::new(), + work_restore: BTreeMap::new(), + draft_revision: 0, + draft_timer: None, + browser_generation: 0, + browser_stream: None, + info_revision: 0, + paging: false, + creating: false, + generation: 0, next_prompt_seq: 1, + early: BTreeMap::new(), + revisions: BTreeMap::new(), prompt_stream: None, - initial_prompt_id: None, - history_request: Cell::new(0), - history_revision: 0, keymap: Keymap::new(), + client: Arc::new(client), tx, }; - app.spawn_server_info(); - app.spawn_list_models(); + app.restore_draft(); app } - - fn next_message_id(&mut self) -> String { - let seq = self.next_prompt_seq; - self.next_prompt_seq += 1; - let millis = SystemTime::now() - .duration_since(UNIX_EPOCH) - .unwrap_or_default() - .as_millis(); - format!("msg_{millis}_{seq}") + pub fn new(tx: mpsc::UnboundedSender) -> Self { + let client = RpcClient::default(); + let drafts = crate::rpc::client::codework_home_dir() + .map(|home| DraftStore::at(&home, client.url())) + .unwrap_or_default(); + let app = Self::with_storage(tx, client, drafts); + let tx = app.tx.clone(); + let client = app.client.clone(); + tokio::spawn(async move { + let _ = tx.send(AppEvent::rpc(RpcEvent::ServerInfoLoaded( + client.verify_server().await, + ))); + }); + app.spawn_list_models(); + app } - - /// The terminal background colour for the active screen. pub fn background(&self) -> Color { - match self.screen { - Screen::Welcome => self.theme.field_bg, - Screen::Session => self.theme.bg, - } - } - - fn active_host_dir(&self) -> Option { - match &self.session { - Some(session) => session.host_dir.clone(), - None => std::env::current_dir() - .ok() - .map(|p| p.to_string_lossy().to_string()), + if self.screen == Screen::Welcome { + self.theme.field_bg + } else { + self.theme.bg } } - - fn apply_session(&mut self, info: SessionInfo) { - let same_session = self.session.as_ref().map(|s| &s.id) == Some(&info.id); - let host_changed = self.session.as_ref().map(|s| &s.host_dir) != Some(&info.host_dir); - if !same_session { - self.history_request.set(self.history_request.get() + 1); - self.log_cursor = None; - } - self.model = info - .model - .as_ref() - .map(|m| (m.provider.clone(), m.id.clone())); - if info.thinking_level.is_some() || !same_session { - self.thinking = info.thinking_level.clone(); - } - self.session = Some(info); - if host_changed || self.models.is_none() { - self.spawn_list_models(); - } + fn address(&self) -> Option { + self.session.as_ref().map(|t| ThreadRefPayload { + session_id: t.session.id.clone(), + thread_id: t.id.clone(), + }) } - - /// Active `(provider, id)` pair: the session override when set, otherwise the resolved - /// default from `model.list`. pub fn active_model(&self) -> Option<(&str, &str)> { - if let Some((provider, id)) = &self.model { - return Some((provider.as_str(), id.as_str())); - } - self.models + self.model .as_ref() - .map(|list| (list.default.provider.as_str(), list.default.id.as_str())) + .map(|(p, m)| (p.as_str(), m.as_str())) + .or_else(|| { + self.models + .as_ref()? + .default + .as_ref() + .map(|m| (m.provider.as_str(), m.id.as_str())) + }) + } + pub fn model_label(&self) -> String { + self.active_model() + .map(|(p, m)| format!("{p}/{m}")) + .unwrap_or_else(|| "default model".into()) } - - /// Thinking levels supported by the active model, when present in `model.list`. pub fn active_thinking_levels(&self) -> Option<&[String]> { let (provider, id) = self.active_model()?; - let list = self.models.as_ref()?; - let p = list.providers.iter().find(|p| p.id == provider)?; - let m = p.models.iter().find(|m| m.id == id)?; - (!m.thinking_levels.is_empty()).then_some(m.thinking_levels.as_slice()) - } - - /// Display label for the active model. - pub fn model_label(&self) -> String { - if let Some((provider, id)) = &self.model { - return format!("{provider}/{id}"); - } - if let Some(list) = &self.models { - return format!("{}/{}", list.default.provider, list.default.id); - } - if let Some(model) = &self.usage.model { - return model.clone(); - } - "default model".to_string() + let model = self + .models + .as_ref()? + .providers + .iter() + .find(|p| p.id == provider)? + .models + .iter() + .find(|m| m.id == id)?; + (!model.thinking_levels.is_empty()).then_some(model.thinking_levels.as_slice()) } - - /// Effective thinking effort level for the active model: the session override when set, and - /// otherwise the resolved default from `model.list` (clamped to the active model's supported - /// levels). pub fn thinking_label(&self) -> Option { - let requested = self.thinking.as_deref().or_else(|| { + let level = self.thinking.as_deref().or_else(|| { self.models + .as_ref()? + .default .as_ref() - .map(|list| list.default.thinking_level.as_str()) - .filter(|level| !level.is_empty()) + .map(|d| d.thinking_level.as_str()) })?; Some(match self.active_thinking_levels() { - Some(supported) => clamp_thinking_level(requested, supported), - None => requested.to_string(), + Some(supported) => clamp_thinking_level(level, supported), + None => level.to_string(), }) } - fn thinking_entries(&self) -> Vec { match self.active_thinking_levels() { Some(levels) => levels .iter() - .map(|level| { - let label = thinking_level_name(level); - Entry::owned(level.clone(), level.clone(), label) - }) + .map(|l| Entry::owned(l.clone(), l.clone(), thinking_level_name(l))) .collect(), None => THINKING_LEVELS .iter() - .map(|&(id, label)| Entry::item(id, label)) + .map(|&(l, name)| Entry::item(l, name)) .collect(), } } + fn spawn_list_models(&self) { + let tx = self.tx.clone(); + let client = self.client.clone(); + let host = self + .session + .as_ref() + .and_then(|t| t.session.host_dir.clone()) + .or_else(|| { + std::env::current_dir() + .ok() + .map(|p| p.to_string_lossy().to_string()) + }); + if let Ok(handle) = tokio::runtime::Handle::try_current() { + handle.spawn(async move { + let _ = tx.send(AppEvent::rpc(RpcEvent::ModelsLoaded( + client.list_models(host.as_deref()).await, + ))); + }); + } + } + fn stop_stream(&mut self) { + if let Some(task) = self.prompt_stream.take() { + task.abort(); + } + } + fn follow(&mut self) { + self.stop_stream(); + let Some(address) = self.address() else { + return; + }; + let tx = self.tx.clone(); + let client = self.client.clone(); + let generation = self.generation; + if let Ok(handle) = tokio::runtime::Handle::try_current() { + self.prompt_stream = Some( + handle + .spawn(async move { + client.follow_thread(address, tx, generation).await; + }) + .abort_handle(), + ); + } + } + fn apply_info(&mut self, info: ThreadInfo) { + self.busy = info.run_state.is_busy(); + self.model = info + .model + .as_ref() + .map(|m| (m.provider.clone(), m.id.clone())); + self.thinking = info.thinking_level.clone(); + self.session = Some(info); + self.ensure_git(); + self.rebuild(); + } + pub fn switch_thread(&mut self, info: ThreadInfo) { + self.remember(); + self.stop_browser(); + self.popup = None; + self.git.open = false; + self.git.patch_focus = false; + self.stop_stream(); + self.generation += 1; + self.entries.clear(); + self.turns.clear(); + self.queued_prompts.clear(); + self.early.clear(); + self.revisions.clear(); + self.floor = None; + self.info_revision = 0; + self.scroll = 0; + self.max_scroll.set(0); + self.paging = false; + self.queue_focus = None; + self.queue_edit = None; + self.queue_pending.clear(); + self.focused_turn = None; + self.screen = Screen::Session; + self.reconnecting = false; + self.apply_info(info); + self.restore_draft(); + self.follow(); + self.spawn_list_models(); + } + fn spawn_operation(&self, operation: F) + where + F: FnOnce(Arc, ThreadRefPayload) -> Fut + Send + 'static, + Fut: std::future::Future> + Send + 'static, + { + let Some(address) = self.address() else { + return; + }; + let client = self.client.clone(); + let tx = self.tx.clone(); + let generation = self.generation; + if let Ok(handle) = tokio::runtime::Handle::try_current() { + handle.spawn(async move { + let result = operation(client, address.clone()).await; + let _ = tx.send(AppEvent::rpc(RpcEvent::Operation { + address, + generation, + result, + })); + }); + } + } - /// Apply one event. Returns whether the screen needs to be drawn again. pub fn update(&mut self, event: AppEvent) -> bool { - match event { + let before = self.prompt.clone(); + let redraw = match event { AppEvent::Key(key) => self.handle_key(key), - AppEvent::Scroll(delta) => self.handle_scroll(delta), - AppEvent::Paste(text) => self.handle_paste(&text), + AppEvent::Scroll(delta) => { + if self.git.open { + if self.git.patch_focus { + self.git.scroll_by(-delta); + } else { + self.select_git_file(if delta > 0 { -1 } else { 1 }); + } + true + } else if self.popup.is_some() { + self.step_menu(if delta > 0 { -1 } else { 1 }) + } else { + self.scroll_by(delta) + } + } + AppEvent::Paste(text) => self.paste(&text), AppEvent::Resize => true, - AppEvent::Rpc(rpc) => self.handle_rpc(rpc), + AppEvent::SaveDraft { revision } => { + if revision == self.draft_revision { + self.save_draft(); + return self.notice.is_some(); + } + false + } + AppEvent::Rpc(event) => self.handle_rpc(*event), + }; + if self.prompt != before { + self.schedule_draft(); + } + redraw + } + fn draft_key(&self) -> String { + self.address() + .map(|a| format!("{}/{}", a.session_id, a.thread_id)) + .unwrap_or_else(|| { + format!( + "new:{}", + std::env::current_dir().unwrap_or_default().display() + ) + }) + } + fn save_draft(&mut self) { + if let Err(error) = self.drafts.save(&self.draft_key(), &self.prompt) { + self.notice = Some(error); } } - - fn handle_scroll(&mut self, delta: isize) -> bool { - if self.popup.is_some() { - let step = if delta > 0 { -1 } else { 1 }; - return self.step_menu(step); + fn schedule_draft(&mut self) { + self.draft_revision += 1; + if let Some(timer) = self.draft_timer.take() { + timer.abort(); } - if self.screen == Screen::Session { - return self.scroll_by(delta); + let revision = self.draft_revision; + let tx = self.tx.clone(); + if let Ok(handle) = tokio::runtime::Handle::try_current() { + self.draft_timer = Some( + handle + .spawn(async move { + tokio::time::sleep(std::time::Duration::from_millis(400)).await; + let _ = tx.send(AppEvent::SaveDraft { revision }); + }) + .abort_handle(), + ); + } + } + fn remember(&mut self) { + self.save_draft(); + let work = self + .turns + .iter() + .filter_map(|turn| Some((turn.prompt_id.clone()?, turn.work_open?))) + .collect(); + self.remembered.insert( + self.draft_key(), + Remembered { + prompt: self.prompt.clone(), + scroll: self.scroll, + work, + }, + ); + } + fn restore_draft(&mut self) { + self.prompt = Prompt::default(); + self.scroll = 0; + self.work_restore.clear(); + let key = self.draft_key(); + if let Some(saved) = self.remembered.remove(&key) { + self.prompt = saved.prompt; + self.scroll = saved.scroll; + self.work_restore = saved.work; + } else { + match self.drafts.load(&key) { + Ok(Some(prompt)) => self.prompt = prompt, + Ok(None) => {} + Err(error) => self.notice = Some(error), + } + } + self.draft_revision += 1; + } + fn stop_browser(&mut self) { + self.browser_generation += 1; + if let Some(task) = self.browser_stream.take() { + task.abort(); + } + } + fn open_browser(&mut self) { + self.stop_browser(); + let generation = self.browser_generation; + self.popup = Some(Popup::Sessions { + search: Prompt::default(), + menu: Menu::new(Vec::new()), + sessions: Vec::new(), + }); + self.notice = None; + let tx = self.tx.clone(); + let client = self.client.clone(); + if let Ok(handle) = tokio::runtime::Handle::try_current() { + self.browser_stream = Some( + handle + .spawn(async move { + client.watch_threads(tx, generation).await; + }) + .abort_handle(), + ); } - false } - fn scroll_by(&mut self, delta: isize) -> bool { let cap = self.max_scroll.get(); let current = self.scroll.min(cap); - let next = if delta >= 0 { + self.scroll = if delta >= 0 { current.saturating_add(delta as usize).min(cap) } else { - current.saturating_sub((-delta) as usize) + current.saturating_sub(delta.unsigned_abs()) }; - if next == self.scroll { - return false; + if delta > 0 && self.scroll == cap && self.floor.is_some_and(|f| f > 1) && !self.paging { + if let Some(before) = self.entries.first().map(|e| e.seq) { + self.paging = true; + self.spawn_operation(move |client, address| async move { + Ok(match client.page_thread(address, before, 60).await { + Ok(entries) => OperationResult::Page { before, entries }, + Err(error) => OperationResult::PageFailed(error), + }) + }); + } } - self.scroll = next; true } - - fn handle_paste(&mut self, text: &str) -> bool { - if let Some(popup) = &mut self.popup { - match popup { - Popup::Themes { - search, - menu, - initial, - } => { - if !search.insert_text(text) { - return false; - } - self.theme = filter_themes(search.text(), menu, *initial); - return true; - } - Popup::Models { search, menu } => { - if !search.insert_text(text) { - return false; - } - let selected = menu.selected().map(|e| e.id.to_string()); - *menu = filter_models(search.text(), self.models.as_ref(), selected.as_deref()); - return true; - } - Popup::Sessions { - search, - menu, - sessions, - } => { - if !search.insert_text(text) { - return false; - } - *menu = filter_sessions( - search.text(), - sessions, - menu.selected().map(|e| e.id.as_ref()), - ); - return true; - } - Popup::Thinking(_) => return false, - Popup::Commands(_) => {} - } + fn paste(&mut self, text: &str) -> bool { + if self.git.open { + return false; } - let changed = self.prompt.insert_text(text); - if changed { - self.notice = None; - self.sync_commands(); + if let Some(edit) = &mut self.queue_edit { + return edit.text.insert_text(text); + } + match &mut self.popup { + Some( + Popup::Models { search, .. } + | Popup::Sessions { search, .. } + | Popup::Themes { search, .. }, + ) => { + search.insert_inline(text); + self.filter_popup(); + } + Some(Popup::Thinking(_) | Popup::Fork(_)) => return false, + _ => { + self.prompt.insert_text(text); + self.sync_commands(); + } } - changed + true } - fn handle_key(&mut self, key: KeyEvent) -> bool { - // Named actions first, so a key bound to the app is never typed into the prompt. match self.keymap.resolve(key) { Resolution::Action(Action::Exit) => { self.should_quit = true; - return false; + return true; } Resolution::Consumed => return false, Resolution::Unbound => {} } - - if key.code == KeyCode::Esc { - return self.escape(); + if key.code == KeyCode::Char('g') && key.modifiers == KeyModifiers::CONTROL { + if self.git.open { + self.git.open = false; + } else { + self.open_git(); + } + return true; } - - if self.popup.is_some() { - if self.menu_key(key) { + if self.git.open { + return self.git_key(key); + } + if key.code == KeyCode::Char('p') && key.modifiers == KeyModifiers::CONTROL { + self.open_browser(); + return true; + } + let newline = (key.code == KeyCode::Enter && key.modifiers == KeyModifiers::SHIFT) + || (key.code == KeyCode::Char('j') && key.modifiers == KeyModifiers::CONTROL); + if newline && self.popup.is_none() { + if let Some(edit) = &mut self.queue_edit { + edit.text.insert_text("\n"); + } else { + self.prompt.insert_text("\n"); + } + return true; + } + if self.queue_edit.is_some() { + if key.code == KeyCode::Esc { + self.queue_edit = None; return true; } - match &mut self.popup { - Some(Popup::Themes { - search, - menu, - initial, - }) => { - if !search.edit(key) { - return false; - } - self.theme = filter_themes(search.text(), menu, *initial); - return true; - } - Some(Popup::Models { search, menu }) => { - if !search.edit(key) { - return false; - } - let selected = menu.selected().map(|e| e.id.to_string()); - *menu = filter_models(search.text(), self.models.as_ref(), selected.as_deref()); - return true; + if key.code == KeyCode::Enter { + let edit = self.queue_edit.take().unwrap(); + let text = edit.text.text().trim().to_string(); + if !text.is_empty() { + self.queue_update(edit.id, None, Some(text)); } - Some(Popup::Sessions { - search, - menu, - sessions, - }) => { - if !search.edit(key) { - return false; - } - *menu = filter_sessions( - search.text(), - sessions, - menu.selected().map(|e| e.id.as_ref()), - ); - return true; - } - Some(Popup::Thinking(_)) => return false, - Some(Popup::Commands(_)) | None => {} + return true; } + return self.queue_edit.as_mut().unwrap().text.edit(key); } - - if self.screen == Screen::Session { - match key.code { - KeyCode::PageUp => return self.scroll_by(10), - KeyCode::PageDown => return self.scroll_by(-10), - KeyCode::Up - if key.modifiers.contains(KeyModifiers::SHIFT) - || self.prompt.text().is_empty() => - { - return self.scroll_by(1); - } - KeyCode::Down - if key.modifiers.contains(KeyModifiers::SHIFT) - || self.prompt.text().is_empty() => - { - return self.scroll_by(-1); + if key.code == KeyCode::Esc { + if let Some(popup) = self.popup.take() { + if matches!(popup, Popup::Sessions { .. }) { + self.stop_browser(); } - _ => {} - } - } - - if key.code == KeyCode::Enter { - let alternate = key - .modifiers - .intersects(KeyModifiers::ALT | KeyModifiers::CONTROL | KeyModifiers::SUPER); - let default_busy = if alternate { - PromptDelivery::FollowUp - } else { - PromptDelivery::Steer - }; - return self.submit_prompt(default_busy); - } - - let edited = self.prompt.edit(key); - if edited { - self.notice = None; - self.sync_commands(); - } - edited - } - - fn handle_rpc(&mut self, event: RpcEvent) -> bool { - match event { - RpcEvent::ServerInfoLoaded(Ok(info)) => { - self.server_info = Some(info); - true - } - RpcEvent::ServerInfoLoaded(Err(err)) => { - self.notice = Some(err); - true - } - RpcEvent::ModelsLoaded(Ok(models)) => { - self.models = Some(models); - let active_model = self.model_label(); - let active_thinking = self.thinking_label().unwrap_or_else(|| "off".to_string()); - let thinking_entries = self.thinking_entries(); - match &mut self.popup { - Some(Popup::Models { search, menu }) => { - let selected = menu - .selected() - .map(|e| e.id.to_string()) - .unwrap_or(active_model); - *menu = filter_models(search.text(), self.models.as_ref(), Some(&selected)); - } - Some(Popup::Thinking(menu)) => { - let selected = menu - .selected() - .map(|e| e.id.to_string()) - .unwrap_or(active_thinking); - *menu = Menu::at(thinking_entries, &selected); - } + match popup { + Popup::Themes { initial, .. } => self.theme = initial, + Popup::Commands(_) => self.prompt.clear(), _ => {} } - true - } - RpcEvent::ModelsLoaded(Err(err)) => { - self.notice = Some(err); - true - } - RpcEvent::SessionsLoaded(Ok(mut sessions)) => { - sessions.sort_by(|a, b| b.updated_at.cmp(&a.updated_at)); - let current_id = self.session.as_ref().map(|s| s.id.as_str()); - let menu = filter_sessions("", &sessions, current_id); - self.popup = Some(Popup::Sessions { - search: Prompt::default(), - menu, - sessions, - }); - true - } - RpcEvent::SessionsLoaded(Err(err)) => { - self.notice = Some(err); - true - } - RpcEvent::SessionHistoryRefresh { session_id } => { - if self.session.as_ref().is_some_and(|s| s.id == session_id) { - self.spawn_session_history(&session_id); - } - false - } - RpcEvent::SessionHistoryLoaded { - session_id, - request_id, - revision, - result, - } => { - if !self.session.as_ref().is_some_and(|s| s.id == session_id) - || request_id != self.history_request.get() - { - return false; - } - if revision != self.history_revision { - self.spawn_session_history(&session_id); - return false; - } - let entries = match result { - Ok(entries) => entries, - Err(err) => { - self.notice = Some(err); - return true; - } - }; - let was_empty = self.turns.is_empty(); - crate::rpc::client::advance_log_cursor( - &mut self.log_cursor, - crate::rpc::client::history_cursor(&entries), - ); - self.sync_turns_from_history(&entries); - self.busy = self - .turns - .last() - .is_some_and(|turn| turn.state == TurnState::Running); - if was_empty { - self.scroll = 0; - } - let stream_running = self - .prompt_stream - .as_ref() - .is_some_and(|task| !task.is_finished()); - if !stream_running { - if let Some(session_id) = self.session.as_ref().map(|s| s.id.clone()) { - self.spawn_follow_session(session_id, self.log_cursor, self.busy); - } - } - true - } - RpcEvent::SessionConfigured(Ok(info)) => { - self.apply_session(info); - true + return true; } - RpcEvent::SessionConfigured(Err(err)) => { - self.notice = Some(err); - true + if self.queue_focus.take().is_some() || self.focused_turn.take().is_some() { + return true; } - RpcEvent::PluginsReloaded(Ok((count, failure))) => { - self.notice = Some(match failure { - Some(err) => format!("plugin reload failed: {err}"), - None => format!("reloaded {count} plugin(s)"), + if self.busy { + self.spawn_operation(|client, address| async move { + client.interrupt_thread(address).await?; + Ok(OperationResult::Notice("interrupt requested".into())) }); - true + } else if !self.prompt.text().is_empty() { + self.prompt.clear(); + } else { + self.should_quit = true; } - RpcEvent::PluginsReloaded(Err(err)) => { - self.notice = Some(err); - true + return true; + } + if self.popup.is_some() { + if key.code == KeyCode::Char('b') && matches!(self.popup, Some(Popup::Fork(_))) { + return self.fork_selected(ForkMode::Before); } - RpcEvent::PromptDispatched { - session_id, - message_id, - result, - } => { - if self.session.as_ref().is_none_or(|s| s.id != session_id) { - return false; - } - match result { - Ok(()) => { - if let Some(queued) = self - .queued_prompts - .iter_mut() - .find(|q| q.message_id == message_id) - { - queued.admitted = true; - } - } - Err(err) => { - self.queued_prompts.retain(|q| q.message_id != message_id); - if let Some(turn) = self.turns.last_mut() { - if turn.prompt_id.as_deref() == Some(message_id.as_str()) { - turn.state = TurnState::Failed(err.clone()); - self.busy = false; - } - } - self.notice = Some(err); - } - } - true + match key.code { + KeyCode::Up => return self.step_menu(-1), + KeyCode::Down => return self.step_menu(1), + KeyCode::Enter => return self.choose(), + _ => {} } - RpcEvent::Stream(stream) => self.handle_stream(stream), - RpcEvent::SessionStream { session_id, event } => { - if self.session.as_ref().is_some_and(|s| s.id == session_id) { - self.handle_stream(event) - } else { - false + match &mut self.popup { + Some( + Popup::Models { search, .. } + | Popup::Sessions { search, .. } + | Popup::Themes { search, .. }, + ) => { + search.edit(key); + self.filter_popup(); + return true; } + Some(Popup::Thinking(_) | Popup::Fork(_)) => return false, + _ => {} } } - } - - fn refresh_open_config_popups(&mut self) { - let active_model = self.model_label(); - let active_thinking = self.thinking_label().unwrap_or_else(|| "off".to_string()); - let thinking_entries = self.thinking_entries(); - match &mut self.popup { - Some(Popup::Models { search, menu }) => { - let selected = menu - .selected() - .map(|e| e.id.to_string()) - .unwrap_or(active_model); - *menu = filter_models(search.text(), self.models.as_ref(), Some(&selected)); - } - Some(Popup::Thinking(menu)) => { - let selected = menu - .selected() - .map(|e| e.id.to_string()) - .unwrap_or(active_thinking); - *menu = Menu::at(thinking_entries, &selected); - } - _ => {} + if key.modifiers == KeyModifiers::ALT && matches!(key.code, KeyCode::Up | KeyCode::Down) { + self.focus_queue(if key.code == KeyCode::Up { -1 } else { 1 }); + return true; } - } - - fn handle_stream(&mut self, event: StreamEvent) -> bool { - // A snapshot requested before this event cannot replace the newer UI state. - self.history_revision += 1; - match event { - StreamEvent::SessionCreated(info) => { - self.apply_session(info); - } - StreamEvent::ExecutionStarted => { - self.busy = true; - } - StreamEvent::PromptAdmitted { - message_id, - prompt, - delivery, - } => { - let initial_admitted = - self.initial_prompt_id.as_deref() == Some(message_id.as_str()); - let already_in_turns = self - .turns - .iter() - .any(|t| t.prompt_id.as_deref() == Some(message_id.as_str())) - || self.turns.last().is_some_and(|t| { - t.prompt_id.is_none() - && t.prompt == prompt - && t.state == TurnState::Running - && t.text.is_empty() - && t.thinking.is_empty() - && t.tools.is_empty() - }); - if already_in_turns { - if let Some(last) = self.turns.last_mut() { - if last.prompt_id.is_none() && last.prompt == prompt { - last.prompt_id = Some(message_id); - } - } - } else if let Some(existing) = self - .queued_prompts - .iter_mut() - .find(|q| q.message_id == message_id) - { - if !prompt.is_empty() { - existing.prompt = prompt; - } - existing.delivery = delivery; - existing.admitted = true; - existing.dispatched = true; - } else { - self.queued_prompts.push(QueuedPrompt { - message_id, - prompt, - delivery, - admitted: true, - dispatched: true, - }); - } - if initial_admitted { - self.initial_prompt_id = None; - if let Some(session_id) = self.session.as_ref().map(|s| s.id.clone()) { - self.dispatch_pending_queued_prompts(&session_id); + if self.queue_focus.is_some() { + return self.queue_key(key); + } + if key.modifiers == KeyModifiers::CONTROL { + match key.code { + KeyCode::Char('o') => { + let at = self + .focused_turn + .or_else(|| self.turns.len().checked_sub(1)); + if let Some(turn) = at.and_then(|at| self.turns.get_mut(at)) { + turn.work_open = Some(!turn.work_expanded()); } - } - } - StreamEvent::PromptPromoted { - message_id, - prompt, - delivery: _, - } => { - let queued_prompt = self - .queued_prompts - .iter() - .position(|q| q.message_id == message_id) - .map(|idx| self.queued_prompts.remove(idx)); - let resolved_prompt = if !prompt.is_empty() { - prompt - } else { - queued_prompt.map(|q| q.prompt).unwrap_or_default() - }; - - let already_active = self - .turns - .iter() - .any(|t| t.prompt_id.as_deref() == Some(message_id.as_str())); - if already_active { return true; } - - // If the initial turn was created without a `prompt_id` (e.g. in tests) and matches - // this prompt before any assistant output arrived, bind `prompt_id` to it in place. - if let Some(last) = self.turns.last_mut() { - if last.prompt_id.is_none() - && last.prompt == resolved_prompt - && last.state == TurnState::Running - && last.text.is_empty() - && last.thinking.is_empty() - && last.tools.is_empty() - && last.drafts.is_empty() - { - last.prompt_id = Some(message_id); - return true; - } - if last.state == TurnState::Running { - last.retry = None; - last.state = TurnState::Succeeded; - } - } - - self.busy = true; - self.screen = Screen::Session; - self.turns.push(Turn::with_id(message_id, resolved_prompt)); - if self.notice.as_deref() == Some("steering current turn...") - || self.notice.as_deref() == Some("queued follow-up prompt") - { - self.notice = None; - } - } - StreamEvent::ConfigChanged { - model, - thinking_level, - } => { - if let Some(model_ref) = model { - self.model = Some((model_ref.provider.clone(), model_ref.id.clone())); - if let Some(session) = &mut self.session { - session.model = Some(model_ref); - } - if thinking_level.is_none() { - if let (Some(level), Some(supported)) = - (self.thinking.clone(), self.active_thinking_levels()) - { - self.thinking = Some(clamp_thinking_level(&level, supported)); - } + KeyCode::Up | KeyCode::Down => { + if !self.turns.is_empty() { + let at = self.focused_turn.unwrap_or(self.turns.len() - 1); + self.focused_turn = Some(if key.code == KeyCode::Up { + at.saturating_sub(1) + } else { + (at + 1).min(self.turns.len() - 1) + }); } + return true; } - if let Some(level) = thinking_level { - self.thinking = Some(level.clone()); - if let Some(session) = &mut self.session { - session.thinking_level = Some(level); - } + KeyCode::Char('y') => { + self.copy_reply(); + return true; } - self.refresh_open_config_popups(); + _ => {} } - StreamEvent::SessionForked { - session_id, - source_session_id, - source_entry_id, - base_seq: _, - } => { - let active_id = self.session.as_ref().map(|s| s.id.as_str()); - let msg = if active_id == Some(source_session_id.as_str()) - && session_id != source_session_id - { - format!("forked session {session_id} from {source_entry_id}") - } else { - format!("session forked from {source_session_id} at {source_entry_id}") - }; - self.notice = Some(msg.clone()); - if let Some(turn) = self.turns.last_mut() { - if !turn.notices.contains(&msg) { - turn.notices.push(msg); - } + } + if let Some(at) = self.focused_turn { + if matches!(key.code, KeyCode::Char(' ') | KeyCode::Enter) { + if let Some(turn) = self.turns.get_mut(at) { + turn.work_open = Some(!turn.work_expanded()); } + return true; } - StreamEvent::TurnStarted => { - self.busy = true; - if let Some(turn) = self.turns.last_mut() { - turn.retry = None; - if turn.state != TurnState::Running { - turn.state = TurnState::Running; - } - } else { - self.turns.push(Turn::new(String::new())); - } + } + match key.code { + KeyCode::PageUp => return self.scroll_by(10), + KeyCode::PageDown => return self.scroll_by(-10), + KeyCode::Up + if self.prompt.text().is_empty() || key.modifiers.contains(KeyModifiers::SHIFT) => + { + return self.scroll_by(1) } - StreamEvent::TurnEnded { message_id: _ } => { - if let Some(turn) = self.turns.last_mut() { - turn.retry = None; - } + KeyCode::Down + if self.prompt.text().is_empty() || key.modifiers.contains(KeyModifiers::SHIFT) => + { + return self.scroll_by(-1) } - StreamEvent::TurnAborted { reason, message } => { - if let Some(turn) = self.turns.last_mut() { - turn.retry = None; - if reason == "interrupted" { - turn.state = TurnState::Interrupted( - message.unwrap_or_else(|| "interrupted".to_string()), - ); + KeyCode::Enter => { + self.submit_prompt( + if key + .modifiers + .intersects(KeyModifiers::ALT | KeyModifiers::CONTROL) + { + PromptDelivery::FollowUp } else { - turn.state = TurnState::Failed(message.unwrap_or(reason)); - } - } - } - StreamEvent::RetryScheduled { - attempt, - max_retries, - delay_ms, - message, - } => { - if let Some(turn) = self.turns.last_mut() { - turn.retry = Some(RetryStatus { - attempt, - max_retries, - delay_ms, - message, - }); - } - } - StreamEvent::RetryFinished { - attempt, - success, - message, - } => { - if let Some(turn) = self.turns.last_mut() { - turn.retry = None; - if !success { - if let Some(msg) = message.filter(|m| !m.is_empty()) { - turn.notices.push(format!("retry {attempt} failed: {msg}")); - } - } - } - } - StreamEvent::LlmStarted { message_id, model } => { - if let Some(model) = model { - self.usage.model = Some(model); - } - if let Some(turn) = self.turns.last_mut() { - turn.start_llm(&message_id); - } - } - StreamEvent::LlmFailed { - message_id, - reason: _, - error: _, - } => { - if let Some(turn) = self.turns.last_mut() { - turn.fail_llm(&message_id); - } - } - StreamEvent::TextStart { - message_id, - part_index, - } => { - if let Some(turn) = self.turns.last_mut() { - turn.start_text_part(&message_id, part_index); - } - } - StreamEvent::TextDelta { - message_id, - part_index, - delta, - } => { - if let Some(turn) = self.turns.last_mut() { - turn.append_text_delta(message_id.as_deref(), part_index, &delta); - } - } - StreamEvent::TextEnd { - message_id, - part_index, - content, - } => { - if let Some(turn) = self.turns.last_mut() { - turn.end_text_part(&message_id, part_index, content); - } - } - StreamEvent::ThinkingStart { - message_id, - part_index, - } => { - if let Some(turn) = self.turns.last_mut() { - turn.start_thinking_part(&message_id, part_index); - } + PromptDelivery::Steer + }, + ); + return true; } - StreamEvent::ThinkingDelta { - message_id, - part_index, - delta, - } => { - if let Some(turn) = self.turns.last_mut() { - turn.append_thinking_delta(message_id.as_deref(), part_index, &delta); - } + _ => {} + } + if self.prompt.edit(key) { + self.notice = None; + self.sync_commands(); + return true; + } + false + } + fn sync_commands(&mut self) { + let Some(query) = self.prompt.text().strip_prefix('/') else { + if matches!(self.popup, Some(Popup::Commands(_))) { + self.popup = None; } - StreamEvent::ThinkingEnd { - message_id, - part_index, - content, - } => { - if let Some(turn) = self.turns.last_mut() { - turn.end_thinking_part(&message_id, part_index, content); - } + return; + }; + let query = query.to_ascii_lowercase(); + let mut menu = Menu::new(COMMANDS.to_vec()); + menu.filter(|e| e.name.starts_with(&query)); + self.popup = if menu.entries().is_empty() { + None + } else { + Some(Popup::Commands(menu)) + }; + } + fn filter_popup(&mut self) { + match &mut self.popup { + Some(Popup::Models { search, menu }) => { + *menu = filter_models(search.text(), self.models.as_ref(), None) + } + Some(Popup::Themes { + search, + menu, + initial, + }) => self.theme = filter_themes(search.text(), menu, initial), + Some(Popup::Sessions { + search, + menu, + sessions, + }) => { + *menu = crate::browser::menu( + sessions, + search.text(), + menu.selected().map(|e| e.id.as_ref()), + ); } - StreamEvent::ToolStarted { - call_id, - name, - label, - arguments, - } => { - if let Some(turn) = self.turns.last_mut() { - let started = ToolCall::start(call_id.clone(), name, label, &arguments); - if let Some(existing) = turn.tools.iter_mut().find(|t| t.call_id == call_id) { - existing.name = started.name; - existing.target = started.target; - existing.label = started.label; - } else { - turn.tools.push(started); - } + _ => {} + } + } + fn step_menu(&mut self, step: isize) -> bool { + if let Some(popup) = &mut self.popup { + popup.menu_mut().step(step); + if let Popup::Themes { menu, .. } = popup { + if let Some(p) = menu.selected().and_then(|e| theme_named(&e.name)) { + self.theme = p; } } - StreamEvent::ToolProgress { - call_id, - output, - details, - } => { - if let Some(turn) = self.turns.last_mut() { - if let Some(existing) = turn.tools.iter_mut().find(|t| t.call_id == call_id) { - existing.apply_progress(output, details.as_ref()); - } else { - let mut call = ToolCall::start( - call_id, - "tool".to_string(), - None, - &serde_json::Value::Null, - ); - call.apply_progress(output, details.as_ref()); - turn.tools.push(call); - } - } + } + true + } + fn choose(&mut self) -> bool { + if matches!(self.popup, Some(Popup::Fork(_))) { + return self.fork_selected(ForkMode::At); + } + let Some(chosen) = self + .popup + .as_ref() + .and_then(|p| p.menu().selected()) + .cloned() + else { + return false; + }; + match self.popup.take().unwrap() { + Popup::Commands(_) => { + self.prompt.clear(); + self.command(&chosen.id); } - StreamEvent::ToolSettled { - call_id, - name, - is_error, - arguments, - output, - details, - } => { - if let Some(turn) = self.turns.last_mut() { - if let Some(existing) = turn.tools.iter_mut().find(|t| t.call_id == call_id) { - existing.apply_settlement( - name, - &arguments, - output, - details.as_ref(), - is_error, - ); - } else { - turn.tools.push(ToolCall::settled( - call_id, - name, - &arguments, - output, - details.as_ref(), - is_error, - )); - } + Popup::Models { .. } => { + if let Some(model) = parse_model(&chosen.id) { + self.model = Some(model); + self.configure(); } } - StreamEvent::Notice(notice) => { - if let Some(turn) = self.turns.last_mut() { - turn.notices.push(notice); - } + Popup::Thinking(_) => { + self.thinking = Some(chosen.id.to_string()); + self.configure(); } - StreamEvent::Usage(usage) => { - self.usage.total_tokens += usage.total_tokens; - self.usage.input_tokens += usage.input_tokens; - self.usage.output_tokens += usage.output_tokens; - self.usage.cost += usage.cost; - if usage.model.is_some() { - self.usage.model = usage.model; + Popup::Themes { .. } => { + if let Some(theme) = theme_named(&chosen.name) { + self.theme = theme; } } - StreamEvent::LogSynced { seq } => { - let prev = self.log_cursor; - crate::rpc::client::advance_log_cursor(&mut self.log_cursor, seq); - if self.log_cursor != prev { - if let Some(session_id) = self.session.as_ref().map(|s| s.id.clone()) { - self.spawn_session_history(&session_id); - } + Popup::Sessions { sessions, .. } => { + if let Some(info) = sessions.into_iter().find(|t| t.id == chosen.id.as_ref()) { + self.switch_thread(info); } } - StreamEvent::Disconnected => { - self.reconnecting = true; - } - StreamEvent::Reconnected => { - self.reconnecting = false; - if self.initial_prompt_id.is_none() { - if let Some(session_id) = self.session.as_ref().map(|s| s.id.clone()) { - self.reconcile_queued_prompts(&session_id); - self.spawn_session_history(&session_id); - } - } + Popup::Fork(_) => {} + } + true + } + fn command(&mut self, name: &str) { + match name { + "model" => { + self.popup = Some(Popup::Models { + search: Prompt::default(), + menu: filter_models("", self.models.as_ref(), Some(&self.model_label())), + }) } - StreamEvent::Succeeded => { - if let Some(turn) = self.turns.last_mut() { - turn.retry = None; - if turn.state == TurnState::Running { - turn.state = TurnState::Succeeded; - } - } - self.busy = false; - self.reconnecting = false; - self.spawn_session_refresh(); + "thinking" => { + self.popup = Some(Popup::Thinking(Menu::at( + self.thinking_entries(), + &self.thinking_label().unwrap_or_default(), + ))) } - StreamEvent::Failed(err) => { - if let Some(turn) = self.turns.last_mut() { - turn.retry = None; - turn.state = TurnState::Failed(err); - } - self.busy = false; - self.reconnecting = false; + "theme" => { + self.popup = Some(Popup::Themes { + search: Prompt::default(), + menu: themes(self.theme.name), + initial: self.theme, + }) } - StreamEvent::Interrupted(reason) => { - if let Some(turn) = self.turns.last_mut() { - turn.retry = None; - turn.state = TurnState::Interrupted(reason); - } + "queue" => self.focus_queue(-1), + "fork" => self.open_fork(), + "copy" => self.copy_reply(), + "session" => self.open_browser(), + "git" | "diff" => self.open_git(), + "new" => { + self.remember(); + self.stop_browser(); + self.stop_stream(); + self.stop_git(); + self.git = crate::git::Git::default(); + self.generation += 1; + self.session = None; + self.entries.clear(); + self.turns.clear(); + self.queued_prompts.clear(); + self.queue_focus = None; + self.queue_edit = None; + self.queue_pending.clear(); + self.early.clear(); + self.revisions.clear(); + self.floor = None; + self.paging = false; + self.scroll = 0; self.busy = false; - self.reconnecting = false; - } + self.screen = Screen::Welcome; + self.restore_draft(); + } + "reload" => self.spawn_operation(|client, _| async move { + let (count, error) = client.reload_plugins().await?; + Ok(OperationResult::Notice( + error.unwrap_or_else(|| format!("reloaded {count} plugins")), + )) + }), + "exit" => self.should_quit = true, + _ => {} } - true } - - fn submit_prompt(&mut self, default_busy_delivery: PromptDelivery) -> bool { - let Some((text, delivery)) = - parse_prompt_submission(self.prompt.text(), default_busy_delivery, self.busy) - else { - return false; - }; - - self.history_revision += 1; - let message_id = self.next_message_id(); - self.prompt.clear(); - self.screen = Screen::Session; - self.scroll = 0; - - let stream_running = self - .prompt_stream - .as_ref() - .is_some_and(|task| !task.is_finished()); - let awaiting_subscription = self.initial_prompt_id.is_some() || self.reconnecting; - if self.busy || (stream_running && awaiting_subscription) { - let session_id = self - .session - .as_ref() - .filter(|_| self.initial_prompt_id.is_none() && !self.reconnecting) - .map(|s| s.id.clone()); - let dispatched = session_id.is_some(); - self.queued_prompts.push(QueuedPrompt { - message_id: message_id.clone(), - prompt: text.clone(), - delivery, - admitted: false, - dispatched, - }); - self.notice = Some(match delivery { - PromptDelivery::Steer => "steering current turn...".to_string(), - PromptDelivery::FollowUp => "queued follow-up prompt".to_string(), - }); - if let Some(session_id) = session_id { - self.spawn_send_prompt(session_id, text, delivery, message_id); - } - return true; + fn stop_git(&mut self) { + if let Some(task) = self.git_stream.take() { + task.abort(); } - - self.notice = None; - self.busy = true; - self.reconnecting = false; - self.turns - .push(Turn::with_id(message_id.clone(), text.clone())); - - if stream_running { - if let Some(session_id) = self.session.as_ref().map(|s| s.id.clone()) { - self.spawn_send_prompt(session_id, text, delivery, message_id); - return true; - } + if let Some(task) = self.git_patch.take() { + task.abort(); } - self.initial_prompt_id = Some(message_id.clone()); - + } + fn ensure_git(&mut self) { + let space = self.session.as_ref().map(|thread| { + thread + .placement + .as_ref() + .map(|p| p.space_id.clone()) + .unwrap_or_else(|| thread.session.space_id.clone()) + }); + if self.git.space_id == space { + return; + } + let open = self.git.open; + let view = self.git.view; + self.stop_git(); + self.git_generation += 1; + self.git = space + .clone() + .map(crate::git::Git::for_space) + .unwrap_or_default(); + self.git.open = open; + self.git.view = view; + let Some(space) = space else { + return; + }; + let client = self.client.clone(); let tx = self.tx.clone(); - let existing_session_id = self.session.as_ref().map(|s| s.id.clone()); - let after = self.log_cursor; - let model = self.model.clone(); - let thinking = self.thinking.clone(); - + let generation = self.git_generation; if let Ok(handle) = tokio::runtime::Handle::try_current() { - let task = handle.spawn(async move { - let client = RpcClient::default(); - let session_id = match existing_session_id { - Some(id) => id, - None => match client.create_session(None, model, thinking).await { - Ok(info) => { - let id = info.id.clone(); - let _ = tx.send(AppEvent::Rpc(RpcEvent::Stream( - StreamEvent::SessionCreated(info), - ))); - id - } - Err(err) => { - let _ = - tx.send(AppEvent::Rpc(RpcEvent::Stream(StreamEvent::Failed(err)))); - return; - } - }, - }; - - let (stream_tx, mut stream_rx) = mpsc::unbounded_channel(); - let stream = client.watch_session_from( - session_id.clone(), - after, - Some((text, delivery, message_id)), - true, - stream_tx, - ); - tokio::pin!(stream); - // Own the stream and forwarding in one task so switching sessions cancels both. - loop { - tokio::select! { - biased; - Some(event) = stream_rx.recv() => { - if tx.send(AppEvent::Rpc(RpcEvent::SessionStream { - session_id: session_id.clone(), event, - })).is_err() { - break; - } - } - _ = &mut stream => break, - } - } - while let Ok(event) = stream_rx.try_recv() { - let _ = tx.send(AppEvent::Rpc(RpcEvent::SessionStream { - session_id: session_id.clone(), - event, - })); - } - }); - self.prompt_stream = Some(task.abort_handle()); + self.git_stream = Some( + handle + .spawn(async move { + client.watch_git(space, tx, generation).await; + }) + .abort_handle(), + ); } - - true } - - fn spawn_follow_session( - &mut self, - session_id: String, - after: Option, - initially_busy: bool, - ) { + fn open_git(&mut self) { + if self.session.is_none() { + self.notice = Some("Open a thread before reviewing its Git changes".into()); + return; + } + self.stop_browser(); + self.popup = None; + self.ensure_git(); + self.git.open = true; + self.git.patch_focus = false; + self.load_git_diff(); + } + fn load_git_diff(&mut self) { + if let Some(task) = self.git_patch.take() { + task.abort(); + } + self.git.request += 1; + self.git.error = None; + let Some((space, file)) = self.git.space_id.clone().zip(self.git.selected.clone()) else { + self.git.loading = false; + return; + }; + self.git.loading = true; + let client = self.client.clone(); let tx = self.tx.clone(); + let generation = self.git_generation; + let request_id = self.git.request; if let Ok(handle) = tokio::runtime::Handle::try_current() { - let task = handle.spawn(async move { - let client = RpcClient::default(); - let (stream_tx, mut stream_rx) = mpsc::unbounded_channel(); - let stream = - client.follow_session(session_id.clone(), after, initially_busy, stream_tx); - tokio::pin!(stream); - loop { - tokio::select! { - biased; - Some(event) = stream_rx.recv() => { - if tx.send(AppEvent::Rpc(RpcEvent::SessionStream { - session_id: session_id.clone(), event, - })).is_err() { - break; - } - } - _ = &mut stream => break, - } - } - while let Ok(event) = stream_rx.try_recv() { - let _ = tx.send(AppEvent::Rpc(RpcEvent::SessionStream { - session_id: session_id.clone(), - event, - })); - } - }); - self.prompt_stream = Some(task.abort_handle()); + self.git_patch = Some( + handle + .spawn(async move { + let result = client.git_diff(&space, &file).await; + let _ = tx.send(AppEvent::rpc(RpcEvent::GitDiff { + space_id: space, + generation, + request_id, + file, + result, + })); + }) + .abort_handle(), + ); } } - - fn dispatch_pending_queued_prompts(&mut self, session_id: &str) { - let mut to_send = Vec::new(); - for queued in &mut self.queued_prompts { - if !queued.dispatched && !queued.admitted { - queued.dispatched = true; - to_send.push(( - queued.prompt.clone(), - queued.delivery, - queued.message_id.clone(), - )); - } - } - for (text, delivery, message_id) in to_send { - self.spawn_send_prompt(session_id.to_string(), text, delivery, message_id); + fn select_git_file(&mut self, delta: isize) { + let previous = self.git.selected.clone(); + self.git.select(delta); + if self.git.selected != previous { + self.load_git_diff(); } } - - fn reconcile_queued_prompts(&mut self, session_id: &str) { - let mut to_send = Vec::new(); - let mut to_reconcile = Vec::new(); - for queued in &mut self.queued_prompts { - if !queued.dispatched && !queued.admitted { - queued.dispatched = true; - to_send.push(( - queued.prompt.clone(), - queued.delivery, - queued.message_id.clone(), - )); - } else if queued.dispatched { - to_reconcile.push(( - queued.prompt.clone(), - queued.delivery, - queued.message_id.clone(), - )); + fn git_key(&mut self, key: KeyEvent) -> bool { + match key.code { + KeyCode::Esc => { + if self.git.patch_focus { + self.git.patch_focus = false; + } else { + self.git.open = false; + } + } + KeyCode::Tab => self.git.patch_focus = !self.git.patch_focus, + KeyCode::Enter => self.git.patch_focus = true, + KeyCode::Char('r') => self.load_git_diff(), + KeyCode::Char('v') => { + self.git.view = self.git.view.next(); + self.git.scroll = 0; + } + KeyCode::Char('n') => self.git.jump_hunk(true, self.theme), + KeyCode::Char('p') => self.git.jump_hunk(false, self.theme), + KeyCode::Home => self.git.scroll = 0, + KeyCode::End => self.git.scroll = self.git.max_scroll.get(), + KeyCode::PageDown => self.git.scroll_by(12), + KeyCode::PageUp => self.git.scroll_by(-12), + KeyCode::Up if self.git.patch_focus => self.git.scroll_by(-1), + KeyCode::Down if self.git.patch_focus => self.git.scroll_by(1), + KeyCode::Up + | KeyCode::Down + | KeyCode::Left + | KeyCode::Right + | KeyCode::Char('[') + | KeyCode::Char(']') => { + self.select_git_file( + if matches!(key.code, KeyCode::Up | KeyCode::Left | KeyCode::Char('[')) { + -1 + } else { + 1 + }, + ); } + _ => {} } - for (text, delivery, message_id) in to_send { - self.spawn_send_prompt(session_id.to_string(), text, delivery, message_id); + true + } + fn configure(&self) { + let model = self.model.clone(); + let thinking = self.thinking_label(); + self.spawn_operation(move |client, address| async move { + Ok(OperationResult::Info( + client.configure_thread(address, model, thinking).await?, + )) + }); + } + fn submit_prompt(&mut self, delivery: PromptDelivery) { + let Some((text, delivery)) = + parse_prompt_submission(self.prompt.text(), delivery, self.busy) + else { + return; + }; + if self.creating { + self.notice = Some("creating session…".into()); + return; } - for (text, delivery, message_id) in to_reconcile { - self.spawn_reconcile_prompt(session_id.to_string(), text, delivery, message_id); + self.prompt.clear(); + self.popup = None; + self.scroll = 0; + let millis = SystemTime::now() + .duration_since(UNIX_EPOCH) + .unwrap_or_default() + .as_millis(); + let id = format!("msg_{millis}_{}", self.next_prompt_seq); + self.next_prompt_seq += 1; + if self.session.is_none() { + self.creating = true; + let tx = self.tx.clone(); + let client = self.client.clone(); + let model = self.model.clone(); + let thinking = self.thinking.clone(); + let host = std::env::current_dir() + .ok() + .map(|p| p.to_string_lossy().to_string()); + if let Ok(handle) = tokio::runtime::Handle::try_current() { + handle.spawn(async move { + let result = client.create_session(host, model, thinking).await; + let _ = tx.send(AppEvent::rpc(RpcEvent::Created { + result, + text, + delivery, + id, + })); + }); + } + } else { + self.dispatch(text, delivery, id); } } - - fn spawn_reconcile_prompt( - &self, - session_id: String, - text: String, - delivery: PromptDelivery, - message_id: String, - ) { - let tx = self.tx.clone(); - if let Ok(handle) = tokio::runtime::Handle::try_current() { - handle.spawn(async move { - let client = RpcClient::default(); - match client.session_message(&session_id, &message_id).await { - Ok(true) => { - let _ = tx.send(AppEvent::Rpc(RpcEvent::SessionHistoryRefresh { - session_id, - })); - } - Ok(false) => { - let result = client - .send_prompt(&session_id, &text, delivery, &message_id) - .await; - let _ = tx.send(AppEvent::Rpc(RpcEvent::PromptDispatched { - session_id, - message_id, - result, - })); - } - Err(_) => {} + fn dispatch(&mut self, text: String, delivery: PromptDelivery, id: String) { + self.queued_prompts.push(QueuedPrompt { + message_id: id.clone(), + prompt: text.clone(), + delivery, + admitted: false, + }); + self.spawn_operation(move |client, address| async move { + Ok( + match client + .send_prompt(address, text, delivery, id.clone()) + .await + { + Ok(()) => OperationResult::Sent { id }, + Err(error) => OperationResult::SendFailed { id, error }, + }, + ) + }); + } + fn focus_queue(&mut self, step: isize) { + if self.queued_prompts.is_empty() { + self.queue_focus = None; + self.notice = Some("queue is empty".into()); + return; + } + let at = self + .queue_focus + .as_ref() + .and_then(|id| self.queued_prompts.iter().position(|q| &q.message_id == id)); + let at = at + .map(|at| (at as isize + step).rem_euclid(self.queued_prompts.len() as isize) as usize) + .unwrap_or(0); + self.queue_focus = Some(self.queued_prompts[at].message_id.clone()); + self.focused_turn = None; + self.notice = None; + } + fn queue_key(&mut self, key: KeyEvent) -> bool { + match key.code { + KeyCode::Up => self.focus_queue(-1), + KeyCode::Down => self.focus_queue(1), + KeyCode::Char('l') | KeyCode::Enter => { + if let Some(q) = self.selected_queue().cloned() { + let delivery = if self.session.as_ref().is_some_and(|t| t.parked) + || !self.busy + || q.delivery == PromptDelivery::FollowUp + { + PromptDelivery::Steer + } else { + PromptDelivery::FollowUp + }; + self.queue_update(q.message_id, Some(delivery), None); } - }); + } + KeyCode::Char('e') => { + if let Some(q) = self + .selected_queue() + .filter(|q| !self.queue_pending.contains(&q.message_id)) + { + let mut text = Prompt::default(); + text.insert_text(&q.prompt); + self.queue_edit = Some(QueueEdit { + id: q.message_id.clone(), + text, + }); + } + } + KeyCode::Char('w') => self.queue_cancel(true), + KeyCode::Delete | KeyCode::Char('d') => self.queue_cancel(false), + _ => {} } + true } - - fn stop_prompt_stream(&mut self) { - if let Some(task) = self.prompt_stream.take() { - task.abort(); - } - self.initial_prompt_id = None; + fn selected_queue(&self) -> Option<&QueuedPrompt> { + self.queued_prompts + .iter() + .find(|q| Some(&q.message_id) == self.queue_focus.as_ref()) } - - fn spawn_session_refresh(&self) { - let Some(session_id) = self.session.as_ref().map(|s| s.id.clone()) else { + fn queue_cancel(&mut self, restore: bool) { + let Some(q) = self.selected_queue().cloned() else { return; }; - let tx = self.tx.clone(); - if let Ok(handle) = tokio::runtime::Handle::try_current() { - handle.spawn(async move { - if let Ok(info) = RpcClient::default().session_info(&session_id).await { - let _ = tx.send(AppEvent::Rpc(RpcEvent::SessionStream { - session_id, - event: StreamEvent::SessionCreated(info), - })); - } - }); - } - } - - fn spawn_send_prompt( - &self, - session_id: String, - text: String, - delivery: PromptDelivery, - message_id: String, - ) { - let tx = self.tx.clone(); - if let Ok(handle) = tokio::runtime::Handle::try_current() { - handle.spawn(async move { - let result = RpcClient::default() - .send_prompt(&session_id, &text, delivery, &message_id) - .await; - let _ = tx.send(AppEvent::Rpc(RpcEvent::PromptDispatched { - session_id, - message_id, - result, - })); - }); + if !q.admitted || !self.queue_pending.insert(q.message_id.clone()) { + return; } + self.spawn_operation(move |client, address| async move { + let cancelled = match client + .cancel_queued_prompt(address, q.message_id.clone()) + .await + { + Ok(cancelled) => cancelled, + Err(error) => { + return Ok(OperationResult::QueueFailed { + id: q.message_id, + error, + }) + } + }; + Ok(OperationResult::Cancel { + id: q.message_id, + restore: restore.then_some(q.prompt), + cancelled, + }) + }); } - - /// Open, filter, or close the command menu to match a leading slash on the prompt line. - fn sync_commands(&mut self) { - let Some(query) = self.prompt.text().strip_prefix('/') else { - if matches!(self.popup, Some(Popup::Commands(_))) { - self.popup = None; - } + fn queue_update(&mut self, id: String, delivery: Option, text: Option) { + if !self + .queued_prompts + .iter() + .any(|q| q.message_id == id && q.admitted) + || !self.queue_pending.insert(id.clone()) + { return; - }; - let query = query.to_ascii_lowercase(); - let mut menu = match self.popup.take() { - Some(Popup::Commands(menu)) => menu, - _ => Menu::new(COMMANDS.to_vec()), - }; - menu.filter(|entry| entry.name.starts_with(&query)); - if !menu.entries().is_empty() { - self.popup = Some(Popup::Commands(menu)); } + self.spawn_operation(move |client, address| async move { + let updated = match client + .update_queued_prompt(address, id.clone(), delivery, text.clone()) + .await + { + Ok(updated) => updated, + Err(error) => return Ok(OperationResult::QueueFailed { id, error }), + }; + Ok(OperationResult::Update { + id, + delivery, + text, + updated, + }) + }); } - - /// A key for the menu on screen: the arrows walk it and Enter takes what it is on. - fn menu_key(&mut self, key: KeyEvent) -> bool { - let step = match key.code { - KeyCode::Up => -1, - KeyCode::Down => 1, - KeyCode::Enter => return self.choose(), - _ => return false, - }; - self.step_menu(step) + pub fn open_fork(&mut self) { + let entries = self + .entries + .iter() + .filter(|e| e.state == "committed") + .map(|e| { + Entry::owned( + e.id.clone(), + format!("{} · {}", e.role, text_of(e)), + format!("#{}", e.seq), + ) + }) + .collect(); + self.popup = Some(Popup::Fork(Menu::new(entries))); } - - fn step_menu(&mut self, step: isize) -> bool { - let Some(popup) = &mut self.popup else { + fn fork_selected(&mut self, mode: ForkMode) -> bool { + let Some(id) = self + .popup + .as_ref() + .and_then(|p| p.menu().selected()) + .map(|e| e.id.to_string()) + else { return false; }; - if !popup.menu_mut().step(step) { - return false; - } - // Walking the theme picker previews each palette on the whole screen as the cursor lands - // on it; Enter keeps it and Escape puts the initial one back. - if let Popup::Themes { menu, .. } = popup { - if let Some(palette) = menu.selected().and_then(|entry| theme_named(&entry.name)) { - self.theme = palette; - } + if mode == ForkMode::Before && !self.entries.iter().any(|e| e.id == id && e.role == "user") + { + self.notice = Some("before is available for user messages".into()); + return true; } + self.popup = None; + self.spawn_operation(move |client, address| async move { + Ok(OperationResult::Fork( + client.fork_thread(address, id, mode).await?, + )) + }); true } + fn copy_reply(&mut self) { + let text = self + .focused_turn + .and_then(|at| self.turns.get(at)) + .or_else(|| self.turns.iter().rev().find(|t| !t.text.is_empty())) + .map(|t| t.text.as_str()) + .unwrap_or(""); + if text.is_empty() { + self.notice = Some("no assistant reply to copy".into()); + return; + } + let mut out = std::io::stdout().lock(); + self.notice = Some( + match out + .write_all(osc52(text).as_bytes()) + .and_then(|_| out.flush()) + { + Ok(()) => "copy sent to terminal clipboard".into(), + Err(e) => format!("copy failed: {e}"), + }, + ); + } - /// Take the entry the cursor is on. - fn choose(&mut self) -> bool { - let Some(chosen) = self - .popup - .as_ref() - .and_then(|popup| popup.menu().selected()) - .cloned() - else { - return false; - }; - let Some(popup) = self.popup.take() else { - return false; - }; - match popup { - Popup::Commands(_) => { - self.prompt.clear(); - match chosen.id.as_ref() { - "model" => { - let current = self.model_label(); - self.popup = Some(Popup::Models { - search: Prompt::default(), - menu: filter_models("", self.models.as_ref(), Some(¤t)), - }); - self.spawn_list_models(); - } - "thinking" => { - let current = self.thinking_label().unwrap_or_else(|| "off".to_string()); - self.popup = - Some(Popup::Thinking(Menu::at(self.thinking_entries(), ¤t))); - if self.models.is_none() { - self.spawn_list_models(); + fn handle_rpc(&mut self, event: RpcEvent) -> bool { + match event { + RpcEvent::ServerInfoLoaded(result) => match result { + Ok(info) => self.server_info = Some(info), + Err(error) => self.notice = Some(error), + }, + RpcEvent::ModelsLoaded(result) => match result { + Ok(models) => self.models = Some(models), + Err(error) => self.notice = Some(error), + }, + RpcEvent::ThreadsLoaded { generation, result } => { + if generation != self.browser_generation + || !matches!(self.popup, Some(Popup::Sessions { .. })) + { + return false; + } + match result { + Ok(threads) => { + if let Some(Popup::Sessions { + search, + menu, + sessions, + }) = &mut self.popup + { + let selected = menu + .selected() + .map(|e| e.id.to_string()) + .or_else(|| self.session.as_ref().map(|t| t.id.clone())); + *menu = + crate::browser::menu(&threads, search.text(), selected.as_deref()); + *sessions = threads; } + self.notice = None; } - "session" => { - self.notice = Some("loading sessions...".to_string()); - self.spawn_list_sessions(); + Err(error) => self.notice = Some(error), + } + } + RpcEvent::Git { + space_id, + generation, + event, + } => { + if self.git.space_id.as_ref() != Some(&space_id) + || generation != self.git_generation + { + return false; + } + match event { + crate::git::GitEvent::Connected => self.git.connection_error = None, + crate::git::GitEvent::Disconnected(error) => { + self.git.connection_error = Some(error) } - "new" => { - self.stop_prompt_stream(); - self.session = None; - self.turns.clear(); - self.queued_prompts.clear(); - self.usage = UsageReport::default(); - self.busy = false; - self.reconnecting = false; - self.log_cursor = None; - self.scroll = 0; - self.notice = Some("started a new session".to_string()); - self.spawn_list_models(); + crate::git::GitEvent::Status(status) => { + if self.git.apply_status(status) && self.git.open { + self.load_git_diff(); + } } - "reload" => { - self.notice = Some("reloading plugins...".to_string()); - self.spawn_reload_plugins(); + } + } + RpcEvent::GitDiff { + space_id, + generation, + request_id, + file, + result, + } => { + if self.git.space_id.as_ref() != Some(&space_id) + || generation != self.git_generation + || request_id != self.git.request + || self.git.selected.as_ref() != Some(&file) + { + return false; + } + self.git.loading = false; + match result { + Ok(diff) => { + self.git.diff = Some(diff); + self.git.error = None; } - "theme" => { - self.popup = Some(Popup::Themes { - search: Prompt::default(), - menu: themes(self.theme.name), - initial: self.theme, - }); + Err(error) => { + self.git.diff = None; + self.git.error = Some(error); } - "exit" => self.should_quit = true, - _ => {} } } - Popup::Models { .. } => { - if let Some((provider, id)) = parse_model(&chosen.id) { - self.model = Some((provider.clone(), id.clone())); - if let (Some(level), Some(supported)) = - (self.thinking.clone(), self.active_thinking_levels()) - { - self.thinking = Some(clamp_thinking_level(&level, supported)); + RpcEvent::Created { + result, + text, + delivery, + id, + } => { + self.creating = false; + match result { + Ok(info) => { + self.switch_thread(info); + self.dispatch(text, delivery, id); + } + Err(error) => { + self.prompt.insert_text(&text); + self.notice = Some(error); } - self.notice = Some(format!("model set to {provider}/{id}")); - self.spawn_configure_session(); } } - Popup::Thinking(_) => { - let level = chosen.id.to_string(); - self.thinking = Some(level.clone()); - self.notice = Some(format!("thinking effort set to {level}")); - self.spawn_configure_session(); - } - Popup::Sessions { sessions, .. } => { - if let Some(info) = sessions.into_iter().find(|s| s.id == chosen.id.as_ref()) { - self.stop_prompt_stream(); - let session_id = info.id.clone(); - let title = info.title.clone(); - self.log_cursor = None; - self.apply_session(info); - self.turns.clear(); - self.queued_prompts.clear(); - self.usage = UsageReport::default(); - self.busy = false; - self.reconnecting = false; - self.scroll = 0; - self.screen = Screen::Session; - self.notice = Some(format!("switched to session {title}")); - self.spawn_session_refresh(); - self.spawn_session_history(&session_id); + RpcEvent::ThreadStream { + address, + generation, + event, + } => { + if self.address().as_ref() != Some(&address) || generation != self.generation { + return false; + } + match event { + StreamEvent::Item(item) => self.apply_item(item), + StreamEvent::Info { rev, info } => { + if rev >= self.info_revision { + self.info_revision = rev; + self.apply_info(*info); + } + } + StreamEvent::Event(envelope) => self.apply_event(envelope), + StreamEvent::Reset => { + self.entries.clear(); + self.turns.clear(); + self.early.clear(); + self.revisions.clear(); + self.queued_prompts.clear(); + self.floor = None; + self.info_revision = 0; + self.paging = false; + self.scroll = 0; + } + StreamEvent::Disconnected => self.reconnecting = true, + StreamEvent::Reconnected => self.reconnecting = false, + StreamEvent::Failed(error) => { + self.reconnecting = false; + self.notice = Some(error); + } } } - Popup::Themes { .. } => { - if let Some(palette) = theme_named(&chosen.name) { - self.theme = palette; + RpcEvent::Operation { + address, + generation, + result, + } => { + if self.address().as_ref() != Some(&address) || generation != self.generation { + return false; + } + match result { + Err(error) => { + self.notice = Some(error); + } + Ok(OperationResult::PageFailed(error)) => { + self.paging = false; + self.notice = Some(error); + } + Ok(OperationResult::QueueFailed { id, error }) => { + self.queue_pending.remove(&id); + self.notice = Some(error); + } + Ok(OperationResult::Cancel { + id, + restore, + cancelled, + }) => { + self.queue_pending.remove(&id); + if cancelled { + self.queued_prompts.retain(|q| q.message_id != id); + if let Some(text) = restore { + let current = self.prompt.text().to_string(); + self.prompt = Prompt::default(); + self.prompt.insert_text(&if current.trim().is_empty() { + text + } else { + format!("{text}\n\n{current}") + }); + self.queue_focus = None; + } + } else { + self.notice = Some("message was already sent or removed".into()); + } + self.reconcile_focus(); + } + Ok(OperationResult::Update { + id, + delivery, + text, + updated, + }) => { + self.queue_pending.remove(&id); + if updated { + if let Some(q) = + self.queued_prompts.iter_mut().find(|q| q.message_id == id) + { + if let Some(delivery) = delivery { + q.delivery = delivery; + } + if let Some(text) = text { + q.prompt = text; + } + } + } else { + self.notice = Some("message was already sent or removed".into()); + } + } + Ok(OperationResult::Fork(reply)) => { + self.switch_thread(reply.thread); + if let Some(text) = reply.text { + self.prompt.clear(); + self.prompt.insert_text(&text); + } + } + Ok(OperationResult::Page { before, entries }) => { + self.paging = false; + let oldest = entries.iter().map(|e| e.seq).min(); + let known: BTreeSet<_> = + self.entries.iter().map(|e| e.id.clone()).collect(); + self.entries.extend( + entries + .into_iter() + .filter(|e| e.seq < before && !known.contains(&e.id)), + ); + self.entries.sort_by_key(|e| e.seq); + self.floor = Some(oldest.filter(|seq| *seq < before).unwrap_or(1)); + self.rebuild(); + } + Ok(OperationResult::Info(info)) => self.apply_info(info), + Ok(OperationResult::SendFailed { id, error }) => { + if let Some(at) = + self.queued_prompts.iter().position(|q| q.message_id == id) + { + let queued = self.queued_prompts.remove(at); + if self.prompt.text().is_empty() { + self.prompt.insert_text(&queued.prompt); + } else { + self.notice = Some(format!("{error} · unsent: {}", queued.prompt)); + self.reconcile_focus(); + return true; + } + } + self.reconcile_focus(); + self.notice = Some(error); + } + Ok(OperationResult::Sent { id }) => { + if let Some(q) = self.queued_prompts.iter_mut().find(|q| q.message_id == id) + { + q.admitted = true; + } + } + Ok(OperationResult::Notice(text)) => self.notice = Some(text), } } } true } - - /// Close what is open, interrupt a running turn, or leave when idle. - fn escape(&mut self) -> bool { - if let Some(popup) = self.popup.take() { - match popup { - Popup::Commands(_) => self.prompt.clear(), - Popup::Themes { initial, .. } => self.theme = initial, - Popup::Models { .. } | Popup::Thinking(_) | Popup::Sessions { .. } => {} - } - return true; - } - if self.busy { - self.spawn_interrupt(); - self.notice = Some("interrupting turn...".to_string()); - return true; - } - if !self.prompt.text().is_empty() { - self.prompt.clear(); - return true; - } - self.should_quit = true; - false - } - - fn spawn_server_info(&self) { - let tx = self.tx.clone(); - if let Ok(handle) = tokio::runtime::Handle::try_current() { - handle.spawn(async move { - let res = RpcClient::default().verify_server().await; - let _ = tx.send(AppEvent::Rpc(RpcEvent::ServerInfoLoaded(res))); - }); - } - } - - fn spawn_list_models(&self) { - let host_dir = self.active_host_dir(); - let tx = self.tx.clone(); - if let Ok(handle) = tokio::runtime::Handle::try_current() { - handle.spawn(async move { - let res = RpcClient::default().list_models(host_dir.as_deref()).await; - let _ = tx.send(AppEvent::Rpc(RpcEvent::ModelsLoaded(res))); - }); + fn reconcile_focus(&mut self) { + if self + .queue_edit + .as_ref() + .is_some_and(|edit| !self.queued_prompts.iter().any(|q| q.message_id == edit.id)) + { + self.queue_edit = None; } - } - - fn spawn_list_sessions(&self) { - let tx = self.tx.clone(); - if let Ok(handle) = tokio::runtime::Handle::try_current() { - handle.spawn(async move { - let res = RpcClient::default().list_sessions().await; - let _ = tx.send(AppEvent::Rpc(RpcEvent::SessionsLoaded(res))); - }); + if self + .queue_focus + .as_ref() + .is_some_and(|id| !self.queued_prompts.iter().any(|q| &q.message_id == id)) + { + self.queue_focus = self.queued_prompts.first().map(|q| q.message_id.clone()); } } - - fn spawn_session_history(&self, session_id: &str) { - let session_id = session_id.to_string(); - let request_id = self.history_request.get() + 1; - self.history_request.set(request_id); - let revision = self.history_revision; - let tx = self.tx.clone(); - if let Ok(handle) = tokio::runtime::Handle::try_current() { - handle.spawn(async move { - let result = RpcClient::default().session_history(&session_id).await; - let _ = tx.send(AppEvent::Rpc(RpcEvent::SessionHistoryLoaded { - session_id, - request_id, - revision, - result, - })); - }); + pub fn apply_item(&mut self, item: ThreadItem) { + match item { + ThreadItem::Synced { floor, .. } => { + if let Some(floor) = floor { + self.floor = Some(floor); + } + return; + } + ThreadItem::Entry { mut entry, rev } => { + let key = format!("entry:{}", entry.id); + if self.revisions.get(&key).is_some_and(|old| *old >= rev) { + return; + } + self.revisions.insert(key, rev); + if let Some(at) = self.entries.iter().position(|e| e.id == entry.id) { + let previous = &self.entries[at]; + if entry.state == "draft" { + if previous.state != "draft" { + return; + } + merge_streamed(&mut entry.parts, &previous.parts); + } + self.entries[at] = entry; + } else { + if let Some(parts) = self.early.remove(&entry.id) { + if entry.state == "draft" { + merge_streamed(&mut entry.parts, &parts); + } + } + self.queued_prompts.retain(|q| q.message_id != entry.id); + self.entries.push(entry); + self.entries.sort_by_key(|e| e.seq); + } + } + ThreadItem::Inbox { prompt, state, rev } => { + let key = format!("inbox:{}", prompt.id); + if self.revisions.get(&key).is_some_and(|old| *old >= rev) { + return; + } + self.revisions.insert(key, rev); + if state == InboxState::Pending && !self.entries.iter().any(|e| e.id == prompt.id) { + let q = QueuedPrompt { + message_id: prompt.id.clone(), + prompt: prompt.text, + delivery: prompt.delivery, + admitted: true, + }; + if let Some(at) = self + .queued_prompts + .iter() + .position(|q| q.message_id == prompt.id) + { + self.queued_prompts[at] = q; + } else { + self.queued_prompts.push(q); + } + } else { + self.queued_prompts.retain(|q| q.message_id != prompt.id); + } + self.reconcile_focus(); + return; + } + ThreadItem::Delta { delta } => { + if let Some(entry) = self.entries.iter_mut().find(|e| e.id == delta.entry_id) { + if entry.state != "draft" { + return; + } + fold_delta(&mut entry.parts, &delta); + } else { + fold_delta( + self.early.entry(delta.entry_id.clone()).or_default(), + &delta, + ); + } + } } + self.reconcile_focus(); + self.rebuild(); } - - fn spawn_configure_session(&self) { - let Some(session) = &self.session else { + fn apply_event(&mut self, envelope: crate::rpc::protocol::EventEnvelope) { + let Some(data) = envelope.data else { return; }; - let session_id = session.id.clone(); - let model = self.model.clone(); - let thinking = self.thinking.clone(); - let tx = self.tx.clone(); - if let Ok(handle) = tokio::runtime::Handle::try_current() { - handle.spawn(async move { - let res = RpcClient::default() - .configure_session(&session_id, model, thinking) - .await; - let _ = tx.send(AppEvent::Rpc(RpcEvent::SessionConfigured(res))); - }); - } - } - - fn spawn_reload_plugins(&self) { - let tx = self.tx.clone(); - if let Ok(handle) = tokio::runtime::Handle::try_current() { - handle.spawn(async move { - let res = RpcClient::default().reload_plugins().await; - let _ = tx.send(AppEvent::Rpc(RpcEvent::PluginsReloaded(res))); - }); + if data.get("threadId").and_then(serde_json::Value::as_str) + != self.session.as_ref().map(|t| t.id.as_str()) + { + return; } - } - - fn spawn_interrupt(&self) { - let Some(session) = &self.session else { + let Some(turn) = self.turns.last_mut() else { return; }; - let session_id = session.id.clone(); - if let Ok(handle) = tokio::runtime::Handle::try_current() { - handle.spawn(async move { - let _ = RpcClient::default().interrupt_session(&session_id).await; - }); + match envelope.event_type.as_str() { + "session.tool.progress" => { + let id = data + .get("callID") + .and_then(serde_json::Value::as_str) + .unwrap_or(""); + if let Some(tool) = turn + .tools + .iter_mut() + .find(|t| t.call_id == id && t.status == ToolStatus::Running) + { + if let Some(partial) = data.get("partial") { + let output = partial.as_str().map(str::to_string).or_else(|| { + partial + .get("content") + .and_then(serde_json::Value::as_array) + .map(|blocks| { + blocks + .iter() + .filter_map(|b| { + b.get("text").and_then(serde_json::Value::as_str) + }) + .collect::>() + .join("\n") + }) + }); + tool.apply_progress(output, partial.get("details")); + } + } + } + "session.retry.scheduled" => { + turn.retry = Some(RetryStatus { + attempt: data["attempt"].as_u64().unwrap_or(0), + max_retries: data["maxRetries"].as_u64().unwrap_or(0), + delay_ms: data["delayMs"].as_u64().unwrap_or(0), + message: data["message"].as_str().unwrap_or("").to_string(), + }); + } + "session.retry.finished" => turn.retry = None, + "plugin.updated" => { + self.notice = data + .get("message") + .and_then(serde_json::Value::as_str) + .map(str::to_string) + } + _ => {} } } - - fn sync_turns_from_history(&mut self, entries: &[HistoryEntry]) { - self.queued_prompts - .retain(|q| !entries.iter().any(|e| e.id == q.message_id)); - - let mut next_turns = turns_from_history(entries); - let last_entry_is_user = entries.last().is_some_and(|e| e.role == "user"); - let total_next = next_turns.len(); - - for (idx, turn) in next_turns.iter_mut().enumerate() { - let Some(prompt_id) = turn.prompt_id.as_deref() else { - continue; - }; - let Some(existing) = self - .turns - .iter() - .find(|t| t.prompt_id.as_deref() == Some(prompt_id)) - else { - continue; - }; - - for notice in &existing.notices { - if !turn.notices.contains(notice) { - turn.notices.push(notice.clone()); + fn rebuild(&mut self) { + let mut turns = turns_from_history(&self.entries); + if self.busy { + if let Some(last) = turns.last_mut() { + if matches!(last.state, TurnState::Succeeded) { + last.state = TurnState::Running; } } - - if idx + 1 == total_next - && last_entry_is_user - && existing.state == TurnState::Running - && self.busy + } + if !self.busy { + if let Some((last, run)) = turns + .last_mut() + .zip(self.session.as_ref().and_then(|t| t.last_run.as_ref())) { - turn.state = TurnState::Running; - } - - if turn.state == TurnState::Running { - if turn.retry.is_none() { - turn.retry = existing.retry.clone(); - } - for draft in &existing.drafts { - let target = turn.draft_mut(&draft.message_id); - for (&part_idx, thinking) in &draft.thinking_parts { - let entry = target.thinking_parts.entry(part_idx).or_default(); - if entry.len() < thinking.len() { - *entry = thinking.clone(); - } - } - for (&part_idx, text) in &draft.text_parts { - let entry = target.text_parts.entry(part_idx).or_default(); - if entry.len() < text.len() { - *entry = text.clone(); - } + if run.started_at >= last.created_at { + if let Some(error) = &run.error { + last.state = match error { + crate::types::RunError::Interrupted { reason } => { + TurnState::Interrupted(reason.clone()) + } + _ => TurnState::Failed(error.message().to_string()), + }; } } - turn.sync_thinking(); - turn.sync_text(); } - - if matches!( - existing.state, - TurnState::Failed(_) | TurnState::Interrupted(_) - ) || (existing.state == TurnState::Succeeded && turn.state == TurnState::Running) + } + for turn in &mut turns { + if let Some(open) = turn + .prompt_id + .as_ref() + .and_then(|id| self.work_restore.remove(id)) { - turn.state = existing.state.clone(); - turn.retry = None; + turn.work_open = Some(open); } - - for existing_tool in &existing.tools { - if let Some(tool) = turn - .tools - .iter_mut() - .find(|t| t.call_id == existing_tool.call_id) - { - if tool.patch.is_none() && existing_tool.patch.is_some() { - tool.patch = existing_tool.patch.clone(); - } - if tool.output.is_none() && existing_tool.output.is_some() { - tool.output = existing_tool.output.clone(); - } - if tool.summary.is_none() && existing_tool.summary.is_some() { - tool.summary = existing_tool.summary.clone(); + if let Some(previous) = self + .turns + .iter() + .find(|p| p.prompt_id == turn.prompt_id && p.created_at == turn.created_at) + { + if turn.state == TurnState::Running { + turn.retry = previous.retry.clone(); + for tool in &mut turn.tools { + if tool.status == ToolStatus::Running { + if let Some(old) = + previous.tools.iter().find(|t| t.call_id == tool.call_id) + { + tool.output = old.output.clone(); + tool.summary = old.summary.clone(); + } + } } - } else if turn.state == TurnState::Running { - turn.tools.push(existing_tool.clone()); + } + if previous.working() == turn.working() { + turn.work_open = previous.work_open; } } } + self.turns = turns; + } +} - if self.busy { - if let Some(last_local) = self.turns.last() { - if last_local.state == TurnState::Running { - let in_history = last_local.prompt_id.as_deref().is_some_and(|id| { - next_turns - .iter() - .any(|t| t.prompt_id.as_deref() == Some(id)) - }); - if !in_history { - next_turns.push(last_local.clone()); - } - } +fn text_of(entry: &HistoryEntry) -> String { + entry + .parts + .iter() + .filter_map(|p| { + if let Part::Text { text } = p { + Some(text.as_str()) + } else { + None + } + }) + .collect::>() + .join("\n\n") +} +fn part_text(part: &Part) -> Option<&str> { + match part { + Part::Text { text } => Some(text), + Part::Thinking { thinking, .. } => Some(thinking), + _ => None, + } +} +fn merge_streamed(parts: &mut Vec, held: &[Part]) { + for (at, old) in held.iter().enumerate() { + if let Some(next) = parts.get_mut(at) { + if std::mem::discriminant(next) == std::mem::discriminant(old) + && part_text(next) + .zip(part_text(old)) + .is_some_and(|(next, old)| old.len() > next.len() && old.starts_with(next)) + { + *next = old.clone(); } + } else { + parts.push(old.clone()); } - - self.turns = next_turns; } } +fn fold_delta(parts: &mut Vec, delta: &LiveDelta) { + let held = parts.get(delta.part_index); + let text = held.and_then(part_text).unwrap_or(""); + let same_kind = matches!( + (held, delta.kind), + (Some(Part::Text { .. }), DeltaKind::Text) + | (Some(Part::Thinking { .. }), DeltaKind::Thinking) + ); + if !(delta.offset == 0 && text.is_empty()) + && (!same_kind || text.encode_utf16().count() != delta.offset) + { + return; + } + let next = format!("{text}{}", delta.delta); + while parts.len() <= delta.part_index { + parts.push(Part::Text { + text: String::new(), + }); + } + parts[delta.part_index] = match delta.kind { + DeltaKind::Text => Part::Text { text: next }, + DeltaKind::Thinking => Part::Thinking { + thinking: next, + redacted: None, + }, + }; +} fn theme_named(name: &str) -> Option<&'static Palette> { theme::PALETTES.iter().find(|palette| palette.name == name) @@ -2064,14 +2074,16 @@ fn model_entries(models: Option<&ModelList>) -> Vec { let Some(list) = models else { return Vec::new(); }; - let default_key = format!("{}/{}", list.default.provider, list.default.id); - let default_provider_available = list.providers.iter().any(|p| p.id == list.default.provider); + let default = list.default.as_ref(); + let default_key = default.map(|d| format!("{}/{}", d.provider, d.id)); + let default_provider_available = + default.is_some_and(|d| list.providers.iter().any(|p| p.id == d.provider)); let mut entries: Vec = Vec::new(); for provider in &list.providers { for model in &provider.models { let id = format!("{}/{}", provider.id, model.id); - let is_default = provider.id == list.default.provider && model.id == list.default.id; + let is_default = default.is_some_and(|d| provider.id == d.provider && model.id == d.id); let detail = if is_default { format!("{} · {} · default", provider.name, model.name) } else { @@ -2081,31 +2093,40 @@ fn model_entries(models: Option<&ModelList>) -> Vec { } } - if !entries.iter().any(|e| e.id.as_ref() == default_key) { - let provider_name = list - .default + if let Some(default) = default.filter(|_| { + !entries + .iter() + .any(|e| Some(e.id.as_ref()) == default_key.as_deref()) + }) { + let provider_name = default .provider_name .as_deref() .filter(|s| !s.is_empty()) .or_else(|| { list.providers .iter() - .find(|p| p.id == list.default.provider) + .find(|p| p.id == default.provider) .map(|p| p.name.as_str()) }) - .unwrap_or(&list.default.provider); - let model_name = list - .default + .unwrap_or(&default.provider); + let model_name = default .name .as_deref() .filter(|s| !s.is_empty()) - .unwrap_or(&list.default.id); + .unwrap_or(&default.id); let detail = if default_provider_available { format!("{provider_name} · {model_name} · default") } else { format!("{provider_name} · {model_name} · default (no credentials)") }; - entries.insert(0, Entry::owned(default_key.clone(), default_key, detail)); + entries.insert( + 0, + Entry::owned( + default_key.clone().unwrap_or_default(), + default_key.clone().unwrap_or_default(), + detail, + ), + ); } entries @@ -2131,7 +2152,6 @@ fn filter_models(query: &str, models: Option<&ModelList>, active: Option<&str>) menu } -/// Reconstruct conversation turns from the server's `session.history` entries. pub fn turns_from_history(entries: &[HistoryEntry]) -> Vec { let mut turns: Vec = Vec::new(); @@ -2147,6 +2167,9 @@ pub fn turns_from_history(entries: &[HistoryEntry]) -> Vec { .collect::>() .join("\n\n"); let mut turn = Turn::with_id(entry.id.clone(), prompt); + turn.created_at = entry.created_at; + turn.updated_at = entry.updated_at; + turn.last_draft = entry.state == "draft"; turn.state = entry_turn_state(&entry.state); turns.push(turn); continue; @@ -2161,17 +2184,51 @@ pub fn turns_from_history(entries: &[HistoryEntry]) -> Vec { let Some(turn) = turns.last_mut() else { continue; }; - turn.state = entry_turn_state(&entry.state); - - for (part_idx, part) in entry.parts.iter().enumerate() { + turn.last_draft = entry.state == "draft"; + turn.state = entry + .error + .as_ref() + .map(|e| TurnState::Failed(e.clone())) + .unwrap_or_else(|| entry_turn_state(&entry.state)); + if turn.created_at == 0 { + turn.created_at = entry.created_at; + } + turn.updated_at = turn.updated_at.max(entry.updated_at); + // The last assistant entry alone owns the answer; previous text is work. + if !turn.text.is_empty() { + if !turn.notes.is_empty() { + turn.notes.push_str("\n\n"); + } + turn.notes.push_str(&turn.text); + } + turn.text.clear(); + turn.answer_present = entry + .parts + .iter() + .any(|part| matches!(part, Part::Text { .. })); + for part in &entry.parts { + if let Part::ToolCall { + time: Some(time), .. + } = part + { + turn.updated_at = turn.updated_at.max(time.end); + } + } + for part in &entry.parts { match part { Part::Text { text } if !text.is_empty() => { - turn.end_text_part(&entry.id, part_idx, text.clone()); + if !turn.text.is_empty() { + turn.text.push_str("\n\n"); + } + turn.text.push_str(text); } Part::Thinking { thinking, redacted } if redacted != &Some(true) && !thinking.is_empty() => { - turn.end_thinking_part(&entry.id, part_idx, thinking.clone()); + if !turn.thinking.is_empty() { + turn.thinking.push('\n'); + } + turn.thinking.push_str(thinking); } Part::ToolCall { call_id, @@ -2232,79 +2289,6 @@ fn entry_turn_state(state: &str) -> TurnState { } } -/// Build the session picker's menu from the server's `session.list` response, sorted by -/// `updated_at` (newest first). -fn filter_sessions(query: &str, sessions: &[SessionInfo], active: Option<&str>) -> Menu { - let now_ms = std::time::SystemTime::now() - .duration_since(std::time::UNIX_EPOCH) - .unwrap_or_default() - .as_millis() as u64; - filter_sessions_at(query, sessions, active, now_ms) -} - -fn filter_sessions_at( - query: &str, - sessions: &[SessionInfo], - active: Option<&str>, - now_ms: u64, -) -> Menu { - let needle = query.trim().to_ascii_lowercase(); - let mut ordered: Vec<&SessionInfo> = sessions.iter().collect(); - ordered.sort_by(|a, b| b.updated_at.cmp(&a.updated_at)); - let entries: Vec = ordered - .into_iter() - .map(|s| { - let title = if s.title.is_empty() { - s.id.clone() - } else { - s.title.clone() - }; - Entry::owned(s.id.clone(), title, session_detail(s, now_ms)) - }) - .collect(); - let mut menu = Menu::at(entries, active.unwrap_or("")); - menu.filter(|entry| { - needle.is_empty() - || entry.name.to_ascii_lowercase().contains(&needle) - || entry.detail.to_ascii_lowercase().contains(&needle) - || entry.id.to_ascii_lowercase().contains(&needle) - }); - menu -} - -fn session_detail(session: &SessionInfo, now_ms: u64) -> String { - let location = session - .project - .as_ref() - .map(|p| p.name.as_str()) - .filter(|name| !name.is_empty()) - .unwrap_or_else(|| session.host_dir.as_deref().unwrap_or(&session.directory)); - match format_ago(session.updated_at, now_ms) { - Some(age) if !location.is_empty() => format!("{location} · {age}"), - Some(age) => age, - None => location.to_string(), - } -} - -fn format_ago(updated_at: u64, now_ms: u64) -> Option { - if updated_at == 0 { - return None; - } - let elapsed = now_ms.saturating_sub(updated_at); - const MINUTE: u64 = 60_000; - const HOUR: u64 = 60 * MINUTE; - const DAY: u64 = 24 * HOUR; - Some(if elapsed >= DAY { - format!("{}d", elapsed / DAY) - } else if elapsed >= HOUR { - format!("{}h", elapsed / HOUR) - } else if elapsed >= MINUTE { - format!("{}m", elapsed / MINUTE) - } else { - "now".to_string() - }) -} - /// The theme picker: one entry per palette the site ships, its cursor on `active`. fn themes(active: &str) -> Menu { Menu::at( @@ -2324,1052 +2308,3 @@ fn themes(active: &str) -> Menu { active, ) } - -#[cfg(test)] -mod tests { - use super::*; - use crate::tool::ToolStatus; - use crate::types::{ - DefaultModel, ModelOption, ModelProvider, ModelRef, ProjectInfo, ToolResult, ToolTime, - }; - use serde_json::json; - - #[test] - fn history_cannot_resurrect_completed_turns_or_cross_sessions() { - let mut app = App::default(); - app.session = Some( - serde_json::from_value(json!({ - "id": "ses", "title": "Session", "directory": "/workspace", "updatedAt": 0 - })) - .unwrap(), - ); - app.turns.push(Turn::with_id("prompt", "Question")); - app.busy = true; - let entries = vec![ - HistoryEntry { - id: "prompt".into(), - seq: 1, - role: "user".into(), - state: "committed".into(), - created_at: 0, - parts: vec![], - }, - HistoryEntry { - id: "answer".into(), - seq: 2, - role: "assistant".into(), - state: "draft".into(), - created_at: 0, - parts: vec![], - }, - ]; - let stale = history_event(&app, entries.clone()); - app.handle_stream(StreamEvent::TextEnd { - message_id: "answer".into(), - part_index: 0, - content: "Finished".into(), - }); - app.handle_stream(StreamEvent::Succeeded); - app.update(stale); - assert!(!app.busy); - assert_eq!(app.turns[0].state, TurnState::Succeeded); - assert_eq!(app.turns[0].text, "Finished"); - - let wrong_session = history_event(&app, entries.clone()); - app.session.as_mut().unwrap().id = "other".into(); - app.turns.clear(); - app.log_cursor = None; - app.update(wrong_session); - assert!(app.turns.is_empty()); - assert_eq!(app.log_cursor, None); - - // A newer request wins even when there were no intervening stream events. - let outdated = history_event(&app, entries); - app.history_request.set(app.history_request.get() + 1); - app.update(outdated); - assert!(app.turns.is_empty()); - } - - fn history_event(app: &App, entries: Vec) -> AppEvent { - AppEvent::Rpc(RpcEvent::SessionHistoryLoaded { - session_id: app.session.as_ref().unwrap().id.clone(), - request_id: app.history_request.get(), - revision: app.history_revision, - result: Ok(entries), - }) - } - - #[test] - fn waits_for_initial_admission_before_dispatching_pending_prompts() { - let mut app = App::default(); - app.prompt.insert_text("initial"); - app.submit_prompt(PromptDelivery::FollowUp); - let initial_id = app.turns[0].prompt_id.clone().unwrap(); - app.prompt.insert_text("second"); - app.submit_prompt(PromptDelivery::Steer); - let info = serde_json::from_value(json!({ - "id": "ses_startup", "title": "Startup", "directory": "/workspace", "updatedAt": 0 - })) - .unwrap(); - app.handle_stream(StreamEvent::SessionCreated(info)); - assert!(!app.queued_prompts[0].dispatched); - app.handle_stream(StreamEvent::PromptAdmitted { - message_id: initial_id, - prompt: "initial".to_string(), - delivery: PromptDelivery::FollowUp, - }); - assert!(app.queued_prompts[0].dispatched); - } - - #[test] - fn retains_pending_prompts_across_execution_terminals() { - for terminal in [ - StreamEvent::Succeeded, - StreamEvent::Failed("provider failed".to_string()), - StreamEvent::Interrupted("user".to_string()), - ] { - let mut app = App::default(); - app.turns.push(Turn::with_id("initial", "initial")); - app.busy = true; - app.queued_prompts.push(QueuedPrompt { - message_id: "pending".to_string(), - prompt: "next".to_string(), - delivery: PromptDelivery::FollowUp, - admitted: false, - dispatched: true, - }); - app.handle_stream(terminal); - assert_eq!(app.queued_prompts.len(), 1); - app.handle_stream(StreamEvent::PromptPromoted { - message_id: "pending".to_string(), - prompt: "next".to_string(), - delivery: PromptDelivery::FollowUp, - }); - assert!(app.queued_prompts.is_empty()); - assert!(app.busy); - assert_eq!( - app.turns.last().unwrap().prompt_id.as_deref(), - Some("pending") - ); - } - } - - #[test] - fn correlates_identical_queued_prompts_by_id() { - let mut app = App::default(); - for (id, delivery) in [ - ("follow", PromptDelivery::FollowUp), - ("steer", PromptDelivery::Steer), - ] { - app.queued_prompts.push(QueuedPrompt { - message_id: id.to_string(), - prompt: "same text".to_string(), - delivery, - admitted: false, - dispatched: true, - }); - } - // A different client can submit the same text and delivery. - app.handle_stream(StreamEvent::PromptAdmitted { - message_id: "external".to_string(), - prompt: "same text".to_string(), - delivery: PromptDelivery::FollowUp, - }); - assert_eq!(app.queued_prompts.len(), 3); - app.handle_stream(StreamEvent::PromptPromoted { - message_id: "steer".to_string(), - prompt: "same text".to_string(), - delivery: PromptDelivery::Steer, - }); - let ids: Vec<_> = app - .queued_prompts - .iter() - .map(|q| q.message_id.as_str()) - .collect(); - assert_eq!(ids, ["follow", "external"]); - } - - #[test] - fn reconstructs_turns_from_history_entries() { - let entries = vec![ - HistoryEntry { - id: "u1".to_string(), - seq: 1, - role: "user".to_string(), - state: "committed".to_string(), - created_at: 1_000, - parts: vec![Part::Text { - text: "Read Cargo.toml and run cargo check".to_string(), - }], - }, - HistoryEntry { - id: "a1".to_string(), - seq: 2, - role: "assistant".to_string(), - state: "committed".to_string(), - created_at: 1_100, - parts: vec![ - Part::Thinking { - thinking: "Checking Cargo.toml first.".to_string(), - redacted: None, - }, - Part::Thinking { - thinking: "secret".to_string(), - redacted: Some(true), - }, - Part::ToolCall { - call_id: "call_1".to_string(), - name: "read".to_string(), - arguments: json!({ "path": "Cargo.toml" }), - status: "completed".to_string(), - result: Some(ToolResult { - content: vec![ToolResultContent::Text { - text: "[package]\nname = \"codework-tui\"".to_string(), - }], - is_error: false, - details: None, - }), - time: Some(ToolTime { start: 10, end: 20 }), - }, - ], - }, - HistoryEntry { - id: "a2".to_string(), - seq: 3, - role: "assistant".to_string(), - state: "committed".to_string(), - created_at: 1_200, - parts: vec![ - Part::ToolCall { - call_id: "call_2".to_string(), - name: "bash".to_string(), - arguments: json!({ "command": "cargo check" }), - status: "error".to_string(), - result: Some(ToolResult { - content: vec![ToolResultContent::Text { - text: "compile error".to_string(), - }], - is_error: true, - details: None, - }), - time: None, - }, - Part::Text { - text: "The check failed.".to_string(), - }, - ], - }, - HistoryEntry { - id: "u2".to_string(), - seq: 4, - role: "user".to_string(), - state: "committed".to_string(), - created_at: 2_000, - parts: vec![Part::Text { - text: "Fix it".to_string(), - }], - }, - HistoryEntry { - id: "a3".to_string(), - seq: 5, - role: "assistant".to_string(), - state: "draft".to_string(), - created_at: 2_100, - parts: vec![Part::ToolCall { - call_id: "call_3".to_string(), - name: "edit".to_string(), - arguments: json!({ "path": "src/app.rs" }), - status: "running".to_string(), - result: None, - time: None, - }], - }, - HistoryEntry { - id: "u3".to_string(), - seq: 6, - role: "user".to_string(), - state: "committed".to_string(), - created_at: 3_000, - parts: vec![Part::Text { - text: "Stop".to_string(), - }], - }, - HistoryEntry { - id: "a4".to_string(), - seq: 7, - role: "assistant".to_string(), - state: "aborted".to_string(), - created_at: 3_100, - parts: vec![Part::Text { - text: "Partial reply".to_string(), - }], - }, - ]; - - let turns = turns_from_history(&entries); - assert_eq!(turns.len(), 3); - - assert_eq!(turns[0].prompt, "Read Cargo.toml and run cargo check"); - assert_eq!(turns[0].thinking, "Checking Cargo.toml first."); - assert_eq!(turns[0].text, "The check failed."); - assert_eq!(turns[0].state, TurnState::Succeeded); - assert_eq!(turns[0].tools.len(), 2); - assert_eq!(turns[0].tools[0].call_id, "call_1"); - assert_eq!(turns[0].tools[0].target.as_deref(), Some("Cargo.toml")); - assert_eq!(turns[0].tools[0].status, ToolStatus::Completed); - assert_eq!(turns[0].tools[1].call_id, "call_2"); - assert_eq!(turns[0].tools[1].target.as_deref(), Some("cargo check")); - assert_eq!(turns[0].tools[1].status, ToolStatus::Failed); - assert_eq!(turns[0].tools[1].output.as_deref(), Some("compile error")); - - assert_eq!(turns[1].prompt, "Fix it"); - assert_eq!(turns[1].state, TurnState::Running); - assert_eq!(turns[1].tools.len(), 1); - assert_eq!(turns[1].tools[0].status, ToolStatus::Running); - assert_eq!(turns[1].tools[0].target.as_deref(), Some("src/app.rs")); - - assert_eq!(turns[2].prompt, "Stop"); - assert_eq!(turns[2].text, "Partial reply"); - assert_eq!( - turns[2].state, - TurnState::Interrupted("aborted".to_string()) - ); - } - - #[test] - fn sorts_sessions_by_updated_at_and_formats_project_activity() { - let now_ms = 1_000_000_000u64; - let sessions = vec![ - SessionInfo { - id: "ses_older".to_string(), - title: "Older session".to_string(), - directory: "/workspace/alpha".to_string(), - host_dir: Some("/Users/prem/alpha".to_string()), - sandbox: None, - project: None, - updated_at: now_ms - 2 * 3_600_000, - model: None, - thinking_level: None, - }, - SessionInfo { - id: "ses_newest".to_string(), - title: "Newest session".to_string(), - directory: "/workspace/codework".to_string(), - host_dir: Some("/Users/prem/codework".to_string()), - sandbox: None, - project: Some(ProjectInfo { - id: "prj_1".to_string(), - name: "codework".to_string(), - }), - updated_at: now_ms - 5 * 60_000, - model: None, - thinking_level: None, - }, - SessionInfo { - id: "ses_oldest".to_string(), - title: "Oldest session".to_string(), - directory: "/workspace/notes".to_string(), - host_dir: None, - sandbox: None, - project: Some(ProjectInfo { - id: "prj_2".to_string(), - name: "notes".to_string(), - }), - updated_at: now_ms - 3 * 86_400_000, - model: None, - thinking_level: None, - }, - ]; - - let menu = filter_sessions_at("", &sessions, None, now_ms); - let entries = menu.entries(); - assert_eq!(entries.len(), 3); - assert_eq!(entries[0].id.as_ref(), "ses_newest"); - assert_eq!(entries[0].detail.as_ref(), "codework · 5m"); - assert_eq!(entries[1].id.as_ref(), "ses_older"); - assert_eq!(entries[1].detail.as_ref(), "/Users/prem/alpha · 2h"); - assert_eq!(entries[2].id.as_ref(), "ses_oldest"); - assert_eq!(entries[2].detail.as_ref(), "notes · 3d"); - } - - #[test] - fn syncs_model_and_loads_history_on_session_switch() { - let mut app = App::default(); - - let first = SessionInfo { - id: "ses_1".to_string(), - title: "First".to_string(), - directory: "/workspace/one".to_string(), - host_dir: None, - sandbox: None, - project: None, - updated_at: 1_000, - model: Some(ModelRef { - provider: "anthropic".to_string(), - id: "claude-sonnet-4-5".to_string(), - }), - thinking_level: None, - }; - let second = SessionInfo { - id: "ses_2".to_string(), - title: "Second".to_string(), - directory: "/workspace/two".to_string(), - host_dir: None, - sandbox: None, - project: None, - updated_at: 2_000, - model: None, - thinking_level: None, - }; - - // Creating a session syncs `app.model` from `info.model`. - app.update(AppEvent::Rpc(RpcEvent::Stream( - StreamEvent::SessionCreated(first.clone()), - ))); - assert_eq!( - app.model, - Some(("anthropic".to_string(), "claude-sonnet-4-5".to_string())) - ); - - // Opening `/session` sorts newest (`ses_2`) first, places the cursor on the active - // session (`ses_1`), and choosing `ses_2` clears `app.model` back to `None`. - app.update(AppEvent::Rpc(RpcEvent::SessionsLoaded(Ok(vec![ - first, second, - ])))); - app.update(AppEvent::Key(KeyEvent::from(KeyCode::Up))); - app.update(AppEvent::Key(KeyEvent::from(KeyCode::Enter))); - assert_eq!(app.session.as_ref().map(|s| s.id.as_str()), Some("ses_2")); - assert_eq!(app.model, None); - assert_eq!(app.screen, Screen::Session); - - // Delivering `SessionHistoryLoaded` populates `app.turns`. - app.update(history_event( - &app, - vec![ - HistoryEntry { - id: "m1".to_string(), - seq: 1, - role: "user".to_string(), - state: "committed".to_string(), - created_at: 2_000, - parts: vec![Part::Text { - text: "Resume me".to_string(), - }], - }, - HistoryEntry { - id: "m2".to_string(), - seq: 2, - role: "assistant".to_string(), - state: "committed".to_string(), - created_at: 2_100, - parts: vec![Part::Text { - text: "Resumed!".to_string(), - }], - }, - ], - )); - assert_eq!(app.turns.len(), 1); - assert_eq!(app.turns[0].prompt, "Resume me"); - assert_eq!(app.turns[0].text, "Resumed!"); - assert_eq!(app.turns[0].state, TurnState::Succeeded); - assert!(!app.busy); - } - - #[test] - fn populates_model_picker_and_flags_unavailable_default() { - let mut app = App::default(); - assert_eq!(app.model_label(), "default model"); - assert_eq!(app.thinking_label(), None); - - let list = ModelList { - providers: vec![ModelProvider { - id: "anthropic".to_string(), - name: "Anthropic".to_string(), - models: vec![ModelOption { - id: "claude-sonnet-4-5".to_string(), - name: "Claude Sonnet 4.5".to_string(), - thinking_levels: vec![ - "off".to_string(), - "low".to_string(), - "medium".to_string(), - "high".to_string(), - ], - }], - }], - default: DefaultModel { - provider: "openai".to_string(), - id: "gpt-5.6-luna".to_string(), - thinking_level: "medium".to_string(), - name: Some("GPT-5.6 Luna".to_string()), - provider_name: Some("OpenAI".to_string()), - }, - }; - - app.update(AppEvent::Rpc(RpcEvent::ModelsLoaded(Ok(list)))); - assert_eq!(app.model_label(), "openai/gpt-5.6-luna"); - assert_eq!(app.thinking_label().as_deref(), Some("medium")); - - // Open `/model` via command menu. - app.update(AppEvent::Paste("/model".to_string())); - app.update(AppEvent::Key(KeyEvent::from(KeyCode::Enter))); - - let Some(Popup::Models { menu, .. }) = &app.popup else { - panic!("expected Models popup"); - }; - let entries = menu.entries(); - assert_eq!(entries.len(), 2); - assert_eq!(entries[0].id.as_ref(), "openai/gpt-5.6-luna"); - assert_eq!( - entries[0].detail.as_ref(), - "OpenAI · GPT-5.6 Luna · default (no credentials)" - ); - assert_eq!(entries[1].id.as_ref(), "anthropic/claude-sonnet-4-5"); - assert_eq!(entries[1].detail.as_ref(), "Anthropic · Claude Sonnet 4.5"); - assert_eq!(menu.cursor(), 0); - } - - #[test] - fn filters_thinking_options_to_active_model_and_clamps_default() { - let mut app = App::default(); - let list = ModelList { - providers: vec![ - ModelProvider { - id: "anthropic".to_string(), - name: "Anthropic".to_string(), - models: vec![ModelOption { - id: "claude-sonnet-4-5".to_string(), - name: "Claude Sonnet 4.5".to_string(), - thinking_levels: vec![ - "off".to_string(), - "low".to_string(), - "medium".to_string(), - "high".to_string(), - ], - }], - }, - ModelProvider { - id: "local".to_string(), - name: "Local".to_string(), - models: vec![ModelOption { - id: "qwen3-coder:30b".to_string(), - name: "Qwen3 Coder 30B".to_string(), - thinking_levels: vec!["off".to_string()], - }], - }, - ], - default: DefaultModel { - provider: "local".to_string(), - id: "qwen3-coder:30b".to_string(), - thinking_level: "medium".to_string(), - name: Some("Qwen3 Coder 30B".to_string()), - provider_name: Some("Local".to_string()), - }, - }; - - app.update(AppEvent::Rpc(RpcEvent::ModelsLoaded(Ok(list)))); - assert_eq!(app.model_label(), "local/qwen3-coder:30b"); - // Default thinkingLevel is "medium", clamped to the default model's only supported level ("off"). - assert_eq!(app.thinking_label().as_deref(), Some("off")); - - // `/thinking` for the non-reasoning default model offers only `["off"]`. - app.update(AppEvent::Paste("/thinking".to_string())); - app.update(AppEvent::Key(KeyEvent::from(KeyCode::Enter))); - let Some(Popup::Thinking(menu)) = &app.popup else { - panic!("expected Thinking popup"); - }; - let ids: Vec<&str> = menu.entries().iter().map(|e| e.id.as_ref()).collect(); - assert_eq!(ids, vec!["off"]); - app.update(AppEvent::Key(KeyEvent::from(KeyCode::Esc))); - - // Switch to `anthropic/claude-sonnet-4-5` via `/model`. - app.thinking = Some("max".to_string()); - app.update(AppEvent::Paste("/model".to_string())); - app.update(AppEvent::Key(KeyEvent::from(KeyCode::Enter))); - let Some(Popup::Models { menu, .. }) = &app.popup else { - panic!("expected Models popup"); - }; - // Default `local/qwen3-coder:30b` is in `providers`, so it is marked `default` without - // `(no credentials)` and the cursor starts on it. - assert_eq!(menu.entries().len(), 2); - assert_eq!( - menu.entries()[1].detail.as_ref(), - "Local · Qwen3 Coder 30B · default" - ); - assert_eq!(menu.cursor(), 1); - - // Move up to `anthropic/claude-sonnet-4-5` and choose it. - app.update(AppEvent::Key(KeyEvent::from(KeyCode::Up))); - app.update(AppEvent::Key(KeyEvent::from(KeyCode::Enter))); - assert_eq!( - app.model, - Some(("anthropic".to_string(), "claude-sonnet-4-5".to_string())) - ); - // `app.thinking` ("max") is clamped to the highest level `claude-sonnet-4-5` supports ("high"). - assert_eq!(app.thinking.as_deref(), Some("high")); - - // `/thinking` now offers only `claude-sonnet-4-5`'s supported levels, with cursor on "high". - app.update(AppEvent::Paste("/thinking".to_string())); - app.update(AppEvent::Key(KeyEvent::from(KeyCode::Enter))); - let Some(Popup::Thinking(menu)) = &app.popup else { - panic!("expected Thinking popup"); - }; - let ids: Vec<&str> = menu.entries().iter().map(|e| e.id.as_ref()).collect(); - assert_eq!(ids, vec!["off", "low", "medium", "high"]); - assert_eq!(menu.selected().map(|e| e.id.as_ref()), Some("high")); - } - - #[test] - fn records_server_info_and_surfaces_mismatch_notice() { - let mut app = App::default(); - assert!(app.server_info.is_none()); - assert!(app.notice.is_none()); - - app.update(AppEvent::Rpc(RpcEvent::ServerInfoLoaded(Ok(ServerInfo { - pid: 4242, - version: "0.3.0".to_string(), - })))); - assert_eq!( - app.server_info, - Some(ServerInfo { - pid: 4242, - version: "0.3.0".to_string(), - }) - ); - assert!(app.notice.is_none()); - - let mismatch = "Server at ws://127.0.0.1:7533/rpc/v1 runs version 0.2.0, expected 0.3.0 from service.json".to_string(); - app.update(AppEvent::Rpc(RpcEvent::ServerInfoLoaded(Err( - mismatch.clone() - )))); - assert_eq!(app.notice.as_deref(), Some(mismatch.as_str())); - } - - #[test] - fn submits_steer_and_follow_up_prompts_while_busy_and_promotes_them_into_turns() { - let mut app = App::default(); - app.session = Some(SessionInfo { - id: "ses_live".to_string(), - title: "Live".to_string(), - directory: "/workspace".to_string(), - host_dir: None, - sandbox: None, - project: None, - updated_at: 1_000, - model: None, - thinking_level: None, - }); - - // 1. Submit initial prompt while idle. - app.update(AppEvent::Paste("Build the feature".to_string())); - app.update(AppEvent::Key(KeyEvent::from(KeyCode::Enter))); - assert!(app.busy); - assert_eq!(app.turns.len(), 1); - assert_eq!(app.turns[0].prompt, "Build the feature"); - assert!(app.queued_prompts.is_empty()); - - let initial_id = app.turns[0].prompt_id.clone().expect("initial prompt_id"); - // Admitting & promoting the initial prompt does not duplicate it into queued_prompts or turns. - app.update(AppEvent::Rpc(RpcEvent::Stream( - StreamEvent::PromptAdmitted { - message_id: initial_id.clone(), - prompt: "Build the feature".to_string(), - delivery: PromptDelivery::FollowUp, - }, - ))); - app.update(AppEvent::Rpc(RpcEvent::Stream( - StreamEvent::PromptPromoted { - message_id: initial_id, - prompt: "Build the feature".to_string(), - delivery: PromptDelivery::FollowUp, - }, - ))); - assert!(app.queued_prompts.is_empty()); - assert_eq!(app.turns.len(), 1); - - // 2. While busy, plain Enter submits a `steer` prompt. - app.update(AppEvent::Paste("Keep the public API unchanged".to_string())); - app.update(AppEvent::Key(KeyEvent::from(KeyCode::Enter))); - assert_eq!(app.prompt.text(), ""); - assert_eq!(app.queued_prompts.len(), 1); - assert_eq!( - app.queued_prompts[0].prompt, - "Keep the public API unchanged" - ); - assert_eq!(app.queued_prompts[0].delivery, PromptDelivery::Steer); - assert!(!app.queued_prompts[0].admitted); - assert_eq!(app.notice.as_deref(), Some("steering current turn...")); - let steer_id = app.queued_prompts[0].message_id.clone(); - - // 3. While busy, Alt+Enter submits a `followUp` prompt. - app.update(AppEvent::Paste("Run cargo test afterwards".to_string())); - app.update(AppEvent::Key(KeyEvent::new( - KeyCode::Enter, - KeyModifiers::ALT, - ))); - assert_eq!(app.queued_prompts.len(), 2); - assert_eq!(app.queued_prompts[1].prompt, "Run cargo test afterwards"); - assert_eq!(app.queued_prompts[1].delivery, PromptDelivery::FollowUp); - assert_eq!(app.notice.as_deref(), Some("queued follow-up prompt")); - let follow_id = app.queued_prompts[1].message_id.clone(); - - // 4. `session.prompt.admitted` marks the steer as admitted. - app.update(AppEvent::Rpc(RpcEvent::Stream( - StreamEvent::PromptAdmitted { - message_id: steer_id.clone(), - prompt: "Keep the public API unchanged".to_string(), - delivery: PromptDelivery::Steer, - }, - ))); - assert!(app.queued_prompts[0].admitted); - - // 5. `session.prompt.promoted` removes the steer from `queued_prompts` and promotes it - // into `app.turns`, settling the previous running step. - app.update(AppEvent::Rpc(RpcEvent::Stream( - StreamEvent::PromptPromoted { - message_id: steer_id, - prompt: "Keep the public API unchanged".to_string(), - delivery: PromptDelivery::Steer, - }, - ))); - assert_eq!(app.queued_prompts.len(), 1); - assert_eq!(app.queued_prompts[0].message_id, follow_id); - assert_eq!(app.turns.len(), 2); - assert_eq!(app.turns[0].state, TurnState::Succeeded); - assert_eq!(app.turns[1].prompt, "Keep the public API unchanged"); - assert_eq!(app.turns[1].state, TurnState::Running); - - // 6. Promoting the follow-up moves it from `queued_prompts` into `app.turns`. - app.update(AppEvent::Rpc(RpcEvent::Stream( - StreamEvent::PromptPromoted { - message_id: follow_id, - prompt: "Run cargo test afterwards".to_string(), - delivery: PromptDelivery::FollowUp, - }, - ))); - assert!(app.queued_prompts.is_empty()); - assert_eq!(app.turns.len(), 3); - assert_eq!(app.turns[1].state, TurnState::Succeeded); - assert_eq!(app.turns[2].prompt, "Run cargo test afterwards"); - assert_eq!(app.turns[2].state, TurnState::Running); - } - - #[test] - fn handles_retries_tool_progress_config_changes_fork_and_part_correlation() { - let mut app = App::default(); - app.session = Some(SessionInfo { - id: "ses_1".to_string(), - title: "Session 1".to_string(), - directory: "/workspace".to_string(), - host_dir: None, - sandbox: None, - project: None, - updated_at: 1_000, - model: None, - thinking_level: None, - }); - app.busy = true; - app.turns.push(Turn::with_id("msg_u1", "Check and test")); - - // 1. First LLM attempt streams partial thinking + text, then fails and schedules a retry. - app.update(AppEvent::Rpc(RpcEvent::Stream(StreamEvent::TurnStarted))); - app.update(AppEvent::Rpc(RpcEvent::Stream(StreamEvent::LlmStarted { - message_id: "assistant_1".to_string(), - model: Some("openai/gpt-5.6-luna".to_string()), - }))); - app.update(AppEvent::Rpc(RpcEvent::Stream( - StreamEvent::ThinkingStart { - message_id: "assistant_1".to_string(), - part_index: 0, - }, - ))); - app.update(AppEvent::Rpc(RpcEvent::Stream( - StreamEvent::ThinkingDelta { - message_id: Some("assistant_1".to_string()), - part_index: Some(0), - delta: "aborted thought".to_string(), - }, - ))); - app.update(AppEvent::Rpc(RpcEvent::Stream(StreamEvent::TextStart { - message_id: "assistant_1".to_string(), - part_index: 1, - }))); - app.update(AppEvent::Rpc(RpcEvent::Stream(StreamEvent::TextDelta { - message_id: Some("assistant_1".to_string()), - part_index: Some(1), - delta: "broken partial output".to_string(), - }))); - assert_eq!(app.turns[0].thinking, "aborted thought"); - assert_eq!(app.turns[0].text, "broken partial output"); - - // `session.llm.failed` discards the failed draft's parts. - app.update(AppEvent::Rpc(RpcEvent::Stream(StreamEvent::LlmFailed { - message_id: "assistant_1".to_string(), - reason: "error".to_string(), - error: Some("503 Service Unavailable".to_string()), - }))); - assert_eq!(app.turns[0].thinking, ""); - assert_eq!(app.turns[0].text, ""); - - // `session.retry.scheduled` records the backoff status on the turn. - app.update(AppEvent::Rpc(RpcEvent::Stream( - StreamEvent::RetryScheduled { - attempt: 1, - max_retries: 3, - delay_ms: 2_000, - message: "openai/gpt-5.6-luna: Unavailable".to_string(), - }, - ))); - assert_eq!( - app.turns[0].retry, - Some(RetryStatus { - attempt: 1, - max_retries: 3, - delay_ms: 2_000, - message: "openai/gpt-5.6-luna: Unavailable".to_string(), - }) - ); - - // 2. Second LLM attempt succeeds with multi-part correlation (`partIndex` 0 thinking, - // `partIndex` 1 & 2 text) and `TextEnd` replaces rather than duplicates deltas. - app.update(AppEvent::Rpc(RpcEvent::Stream(StreamEvent::LlmStarted { - message_id: "assistant_2".to_string(), - model: Some("openai/gpt-5.6-luna".to_string()), - }))); - assert!(app.turns[0].retry.is_none()); - - app.update(AppEvent::Rpc(RpcEvent::Stream( - StreamEvent::ThinkingDelta { - message_id: Some("assistant_2".to_string()), - part_index: Some(0), - delta: "First thought".to_string(), - }, - ))); - app.update(AppEvent::Rpc(RpcEvent::Stream(StreamEvent::ThinkingEnd { - message_id: "assistant_2".to_string(), - part_index: 0, - content: "First thought, refined.".to_string(), - }))); - app.update(AppEvent::Rpc(RpcEvent::Stream(StreamEvent::TextDelta { - message_id: Some("assistant_2".to_string()), - part_index: Some(1), - delta: "Hello ".to_string(), - }))); - app.update(AppEvent::Rpc(RpcEvent::Stream(StreamEvent::TextDelta { - message_id: Some("assistant_2".to_string()), - part_index: Some(1), - delta: "world!".to_string(), - }))); - app.update(AppEvent::Rpc(RpcEvent::Stream(StreamEvent::TextEnd { - message_id: "assistant_2".to_string(), - part_index: 1, - content: "Hello world!".to_string(), - }))); - app.update(AppEvent::Rpc(RpcEvent::Stream(StreamEvent::TextEnd { - message_id: "assistant_2".to_string(), - part_index: 2, - content: "Second paragraph.".to_string(), - }))); - app.update(AppEvent::Rpc(RpcEvent::Stream( - StreamEvent::RetryFinished { - attempt: 1, - success: true, - message: None, - }, - ))); - - assert_eq!(app.turns[0].thinking, "First thought, refined."); - assert_eq!(app.turns[0].text, "Hello world!\n\nSecond paragraph."); - - // 3. Tool starts and streams live `session.tool.progress` before settling. - app.update(AppEvent::Rpc(RpcEvent::Stream(StreamEvent::ToolStarted { - call_id: "call_1".to_string(), - name: "bash".to_string(), - label: Some("bash".to_string()), - arguments: json!({ "command": "cargo test" }), - }))); - app.update(AppEvent::Rpc(RpcEvent::Stream(StreamEvent::ToolProgress { - call_id: "call_1".to_string(), - output: Some("running 5 tests\ntest a ... ok\ntest b ... ok".to_string()), - details: None, - }))); - assert_eq!(app.turns[0].tools[0].status, ToolStatus::Running); - assert_eq!(app.turns[0].tools[0].summary.as_deref(), Some("3 lines")); - assert_eq!( - app.turns[0].tools[0].output.as_deref(), - Some("running 5 tests\ntest a ... ok\ntest b ... ok") - ); - - // 4. `session.config.changed` merges model and thinking level independently. - app.update(AppEvent::Rpc(RpcEvent::Stream( - StreamEvent::ConfigChanged { - model: Some(ModelRef { - provider: "anthropic".to_string(), - id: "claude-sonnet-4-5".to_string(), - }), - thinking_level: None, - }, - ))); - assert_eq!( - app.model, - Some(("anthropic".to_string(), "claude-sonnet-4-5".to_string())) - ); - app.update(AppEvent::Rpc(RpcEvent::Stream( - StreamEvent::ConfigChanged { - model: None, - thinking_level: Some("high".to_string()), - }, - ))); - assert_eq!( - app.model, - Some(("anthropic".to_string(), "claude-sonnet-4-5".to_string())) - ); - assert_eq!(app.thinking.as_deref(), Some("high")); - - // 5. `session.next.forked` surfaces a fork notification. - app.update(AppEvent::Rpc(RpcEvent::Stream( - StreamEvent::SessionForked { - session_id: "ses_2".to_string(), - source_session_id: "ses_1".to_string(), - source_entry_id: "entry_4".to_string(), - base_seq: 9, - }, - ))); - assert_eq!( - app.notice.as_deref(), - Some("forked session ses_2 from entry_4") - ); - assert!(app.turns[0] - .notices - .contains(&"forked session ses_2 from entry_4".to_string())); - } - - #[test] - fn tracks_log_cursor_and_merges_history_snapshots_with_live_drafts() { - let mut app = App::default(); - app.session = Some(SessionInfo { - id: "ses_sync".to_string(), - title: "Sync".to_string(), - directory: "/workspace".to_string(), - host_dir: None, - sandbox: None, - project: None, - updated_at: 1_000, - model: None, - thinking_level: None, - }); - app.busy = true; - - // Turn 1 is actively streaming live deltas in memory; a queued prompt is waiting. - let mut live_turn = Turn::with_id("u1", "Explain the bug"); - live_turn.append_thinking_delta(Some("a1"), Some(0), "Inspecting client.rs..."); - live_turn.append_text_delta(Some("a1"), Some(1), "The socket drops before "); - app.turns.push(live_turn); - app.queued_prompts.push(QueuedPrompt { - message_id: "u2".to_string(), - prompt: "Also add a test".to_string(), - delivery: PromptDelivery::FollowUp, - admitted: true, - dispatched: true, - }); - - // 1. Mid-turn history snapshot arrives while `a1` is still `state: "draft"` (empty in DB): - // live draft deltas are preserved and `log_cursor` advances to 2. - app.update(history_event( - &app, - vec![ - HistoryEntry { - id: "u1".to_string(), - seq: 1, - role: "user".to_string(), - state: "committed".to_string(), - created_at: 1_000, - parts: vec![Part::Text { - text: "Explain the bug".to_string(), - }], - }, - HistoryEntry { - id: "a1".to_string(), - seq: 2, - role: "assistant".to_string(), - state: "draft".to_string(), - created_at: 1_050, - parts: vec![], - }, - ], - )); - assert_eq!(app.log_cursor, Some(2)); - assert!(app.busy); - assert_eq!(app.turns.len(), 1); - assert_eq!(app.turns[0].thinking, "Inspecting client.rs..."); - assert_eq!(app.turns[0].text, "The socket drops before "); - assert_eq!(app.queued_prompts.len(), 1); - - // 2. `LogSynced` with `seq: 5` advances `log_cursor` to `max(2, 5) = 5`; a smaller seq - // never moves it backwards. - app.update(AppEvent::Rpc(RpcEvent::Stream(StreamEvent::LogSynced { - seq: Some(5), - }))); - assert_eq!(app.log_cursor, Some(5)); - app.update(AppEvent::Rpc(RpcEvent::Stream(StreamEvent::LogSynced { - seq: Some(3), - }))); - assert_eq!(app.log_cursor, Some(5)); - - // 3. Reconnect history snapshot arrives after both turns settled during a disconnect: - // `u2` is removed from `queued_prompts`, both turns are `Succeeded`, and `busy` is false. - app.update(history_event( - &app, - vec![ - HistoryEntry { - id: "u1".to_string(), - seq: 1, - role: "user".to_string(), - state: "committed".to_string(), - created_at: 1_000, - parts: vec![Part::Text { - text: "Explain the bug".to_string(), - }], - }, - HistoryEntry { - id: "a1".to_string(), - seq: 2, - role: "assistant".to_string(), - state: "committed".to_string(), - created_at: 1_100, - parts: vec![Part::Text { - text: "The socket drops before reconciliation.".to_string(), - }], - }, - HistoryEntry { - id: "u2".to_string(), - seq: 6, - role: "user".to_string(), - state: "committed".to_string(), - created_at: 1_200, - parts: vec![Part::Text { - text: "Also add a test".to_string(), - }], - }, - HistoryEntry { - id: "a2".to_string(), - seq: 7, - role: "assistant".to_string(), - state: "committed".to_string(), - created_at: 1_300, - parts: vec![Part::Text { - text: "Added reconnect tests.".to_string(), - }], - }, - ], - )); - assert_eq!(app.log_cursor, Some(7)); - assert!(!app.busy); - assert!(app.queued_prompts.is_empty()); - assert_eq!(app.turns.len(), 2); - assert_eq!(app.turns[0].state, TurnState::Succeeded); - assert_eq!(app.turns[0].text, "The socket drops before reconciliation."); - assert_eq!(app.turns[1].prompt, "Also add a test"); - assert_eq!(app.turns[1].state, TurnState::Succeeded); - assert_eq!(app.turns[1].text, "Added reconnect tests."); - } -} diff --git a/packages/tui/src/browser.rs b/packages/tui/src/browser.rs new file mode 100644 index 00000000..2fe9938f --- /dev/null +++ b/packages/tui/src/browser.rs @@ -0,0 +1,69 @@ +//! A grouped view of the harness's thread list; no Desktop app-server dependency. +use crate::{ + menu::{Entry, Menu}, + types::{RunState, ThreadInfo, ThreadOrigin}, +}; + +pub fn menu(threads: &[ThreadInfo], query: &str, selected: Option<&str>) -> Menu { + let mut threads: Vec<_> = threads.iter().collect(); + threads.sort_by_key(|t| { + ( + project(t).to_lowercase(), + t.session.id.clone(), + origin_rank(&t.origin), + std::cmp::Reverse(t.updated_at), + t.id.clone(), + ) + }); + let entries = threads + .into_iter() + .map(|t| { + let state = match t.run_state { + RunState::Starting => "starting", + RunState::Running => "running", + RunState::Idle if t.parked => "parked", + RunState::Idle => "idle", + }; + let (mark, origin) = match &t.origin { + ThreadOrigin::Main => ("●", "main".to_string()), + ThreadOrigin::Fork { thread_id, .. } => ("⑂", format!("fork of {thread_id}")), + ThreadOrigin::Subagent { thread_id, .. } => { + ("↳", format!("subagent of {thread_id}")) + } + }; + Entry::owned( + t.id.clone(), + format!("{mark} {}", t.display_title()), + format!( + "{} / {} · {state} · {origin} · {}", + project(t), + t.session.slug, + t.working_directory() + ), + ) + }) + .collect(); + let mut menu = Menu::at(entries, selected.unwrap_or("")); + let query = query.to_lowercase(); + menu.filter(|e| { + e.name.to_lowercase().contains(&query) + || e.detail.to_lowercase().contains(&query) + || e.id.to_lowercase().contains(&query) + }); + menu +} +fn project(t: &ThreadInfo) -> &str { + t.session + .project + .as_ref() + .map(|p| p.name.as_str()) + .filter(|name| !name.is_empty()) + .unwrap_or_else(|| t.working_directory()) +} +fn origin_rank(origin: &ThreadOrigin) -> u8 { + match origin { + ThreadOrigin::Main => 0, + ThreadOrigin::Fork { .. } => 1, + ThreadOrigin::Subagent { .. } => 2, + } +} diff --git a/packages/tui/src/conversation.rs b/packages/tui/src/conversation.rs new file mode 100644 index 00000000..eb7e6a06 --- /dev/null +++ b/packages/tui/src/conversation.rs @@ -0,0 +1,200 @@ +//! Failure modes considered before implementation: multiline paste losing indentation; +//! Unicode caret positions splitting characters; vertical moves losing the desired column; +//! drafts leaking between threads/servers, lost on restart, or overwritten by a stale save; +//! withdrawal replacing an unsent draft; live browser refresh losing its filter/selection; +//! closed or superseded browser subscriptions reopening the picker. +use crate::{ + app::{App, Popup}, + draft::DraftStore, + event::{AppEvent, RpcEvent}, + prompt::Prompt, + rpc::RpcClient, + types::ThreadInfo, +}; +use crossterm::event::{KeyCode, KeyEvent, KeyModifiers}; +use serde_json::json; +use std::time::{SystemTime, UNIX_EPOCH}; +use tokio::sync::mpsc; + +fn thread(id: &str) -> ThreadInfo { + serde_json::from_value(json!({"id":id,"session":{"id":"session","spaceId":"space","slug":"Chat","directory":"/workspace","mainThreadId":"main","project":{"id":"project","name":"CodeWork"}}})).unwrap() +} +fn key(app: &mut App, code: KeyCode, modifiers: KeyModifiers) { + app.update(AppEvent::Key(KeyEvent::new(code, modifiers))); +} +fn root() -> std::path::PathBuf { + std::env::temp_dir().join(format!( + "codework-tui-conversation-{}-{}", + std::process::id(), + SystemTime::now() + .duration_since(UNIX_EPOCH) + .unwrap() + .as_nanos() + )) +} + +#[test] +fn multiline_paste_and_unicode_navigation_preserve_source_text() { + let mut prompt = Prompt::default(); + prompt.insert_text("fn main() {\r\n\tprintln!(\"🦀\");\r\n}\x1b"); + assert_eq!(prompt.text(), "fn main() {\n\tprintln!(\"🦀\");\n}"); + prompt.edit(KeyEvent::new(KeyCode::Home, KeyModifiers::NONE)); + assert_eq!(prompt.before_caret(), "fn main() {\n\tprintln!(\"🦀\");\n"); + prompt.edit(KeyEvent::new(KeyCode::Up, KeyModifiers::NONE)); + assert_eq!(prompt.before_caret(), "fn main() {\n"); + prompt.edit(KeyEvent::new(KeyCode::End, KeyModifiers::NONE)); + assert!(prompt.before_caret().ends_with("\");")); + prompt.edit(KeyEvent::new(KeyCode::Char('j'), KeyModifiers::CONTROL)); + assert!(prompt.text().contains("\");\n\n}")); + let layout = prompt.layout(12); + assert!(layout.lines.len() > 3); + assert!(layout.caret.0 < 12); + assert!(layout.caret.1 < layout.lines.len()); + let mut vertical = Prompt::default(); + vertical.insert_text("abcdef\nx\nabcdef"); + vertical.edit(KeyEvent::new(KeyCode::Up, KeyModifiers::NONE)); + vertical.edit(KeyEvent::new(KeyCode::Up, KeyModifiers::NONE)); + assert_eq!(vertical.before_caret(), "abcdef"); +} + +#[test] +fn drafts_survive_restart_and_are_isolated_by_endpoint_and_thread() { + let root = root(); + let store = DraftStore::at(&root, "ws://one/rpc"); + let mut draft = Prompt::default(); + draft.insert_text("first\n\t🦀"); + draft.edit(KeyEvent::new(KeyCode::Left, KeyModifiers::NONE)); + store.save("session/main", &draft).unwrap(); + let restored = DraftStore::at(&root, "ws://one/rpc") + .load("session/main") + .unwrap() + .unwrap(); + assert_eq!(restored.text(), draft.text()); + assert_eq!(restored.before_caret(), draft.before_caret()); + assert!(store.load("session/fork").unwrap().is_none()); + assert!(DraftStore::at(&root, "ws://two/rpc") + .load("session/main") + .unwrap() + .is_none()); + store.save("session/main", &Prompt::default()).unwrap(); + assert!(store.load("session/main").unwrap().is_none()); + std::fs::remove_dir_all(root).unwrap(); +} + +#[test] +fn switch_and_restart_restore_each_threads_draft_scroll_and_work_state() { + let root = root(); + let (tx, _) = mpsc::unbounded_channel(); + let mut app = App::with_storage( + tx, + RpcClient::new("ws://one/rpc"), + DraftStore::at(&root, "ws://one/rpc"), + ); + app.switch_thread(thread("main")); + app.update(AppEvent::Paste("main\n draft".into())); + app.scroll = 17; + let user = serde_json::from_value( + json!({"id":"u","seq":1,"role":"user","parts":[{"type":"text","text":"Question"}]}), + ) + .unwrap(); + let answer=serde_json::from_value(json!({"id":"a","seq":2,"role":"assistant","parts":[{"type":"thinking","thinking":"work"},{"type":"text","text":"Answer"}]})).unwrap(); + app.apply_item(crate::types::ThreadItem::Entry { + entry: user, + rev: 1, + }); + app.apply_item(crate::types::ThreadItem::Entry { + entry: answer, + rev: 2, + }); + app.turns[0].work_open = Some(true); + let entries = app.entries.clone(); + app.switch_thread(thread("fork")); + assert!(app.prompt.text().is_empty()); + app.update(AppEvent::Paste("fork draft".into())); + app.switch_thread(thread("main")); + assert_eq!(app.prompt.text(), "main\n draft"); + assert_eq!(app.scroll, 17); + for (at, entry) in entries.into_iter().enumerate() { + app.apply_item(crate::types::ThreadItem::Entry { + entry, + rev: at as u64 + 1, + }); + } + assert!(app.turns[0].work_expanded()); + drop(app); + let (tx, _) = mpsc::unbounded_channel(); + let mut restarted = App::with_storage( + tx, + RpcClient::new("ws://one/rpc"), + DraftStore::at(&root, "ws://one/rpc"), + ); + restarted.switch_thread(thread("main")); + assert_eq!(restarted.prompt.text(), "main\n draft"); + // Drop before cleaning the private test directory so shutdown cannot recreate it. + drop(restarted); + std::fs::remove_dir_all(root).unwrap(); +} + +#[test] +fn withdrawal_prepends_text_without_destroying_current_draft() { + use crate::{app::OperationResult, rpc::protocol::ThreadRefPayload}; + let mut app = App::default(); + app.session = Some(thread("main")); + app.prompt.insert_text("unsent\n draft"); + app.update(AppEvent::rpc(RpcEvent::Operation { + address: ThreadRefPayload { + session_id: "session".into(), + thread_id: "main".into(), + }, + generation: 0, + result: Ok(OperationResult::Cancel { + id: "queued".into(), + restore: Some("withdrawn\nmessage".into()), + cancelled: true, + }), + })); + assert_eq!(app.prompt.text(), "withdrawn\nmessage\n\nunsent\n draft"); +} + +#[test] +fn browser_refresh_keeps_filter_and_selection_and_displays_group_and_state() { + let mut app = App::default(); + app.prompt.insert_text("keep my draft"); + key(&mut app, KeyCode::Char('p'), KeyModifiers::CONTROL); + app.update(AppEvent::rpc(RpcEvent::ThreadsLoaded { + generation: 1, + result: Ok(vec![thread("main"), thread("fork")]), + })); + app.update(AppEvent::Paste("codework".into())); + key(&mut app, KeyCode::Down, KeyModifiers::NONE); + let selected = app + .popup + .as_ref() + .unwrap() + .menu() + .selected() + .unwrap() + .id + .to_string(); + let mut updated = thread(&selected); + updated.parked = true; + updated.title = Some("Renamed".into()); + app.update(AppEvent::rpc(RpcEvent::ThreadsLoaded { + generation: 1, + result: Ok(vec![updated, thread("new")]), + })); + let Some(Popup::Sessions { search, menu, .. }) = &app.popup else { + panic!("browser closed") + }; + assert_eq!(search.text(), "codework"); + assert_eq!(menu.selected().unwrap().id.as_ref(), selected); + assert!(menu.selected().unwrap().detail.contains("parked")); + assert!(menu.selected().unwrap().detail.contains("CodeWork")); + key(&mut app, KeyCode::Esc, KeyModifiers::NONE); + assert_eq!(app.prompt.text(), "keep my draft"); + app.update(AppEvent::rpc(RpcEvent::ThreadsLoaded { + generation: 1, + result: Ok(vec![thread("late")]), + })); + assert!(app.popup.is_none()); +} diff --git a/packages/tui/src/diff.rs b/packages/tui/src/diff.rs index 22ba2ac2..521e179e 100644 --- a/packages/tui/src/diff.rs +++ b/packages/tui/src/diff.rs @@ -24,6 +24,35 @@ pub const DEFAULT_MAX_DIFF_LINES: usize = 60; /// (matching OpenCode's `ctx.width > 120` threshold minus the 4-column transcript indent). pub const SPLIT_MIN_WIDTH: usize = 116; +#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)] +pub enum View { + #[default] + Auto, + Unified, + Split, +} +impl View { + pub fn label(self) -> &'static str { + match self { + Self::Auto => "auto", + Self::Unified => "unified", + Self::Split => "split", + } + } + pub fn next(self) -> Self { + match self { + Self::Auto => Self::Unified, + Self::Unified => Self::Split, + Self::Split => Self::Auto, + } + } +} +pub struct RenderedDiff { + pub lines: Vec>, + pub hunks: Vec, + pub summary: DiffSummary, +} + /// Added/removed counts for the whole patch, before any truncation. #[derive(Debug, Clone, Copy, Default, PartialEq, Eq)] pub struct DiffSummary { @@ -78,7 +107,20 @@ fn parse_hunks(patch: &str) -> (Vec, DiffSummary) { let mut old_ln = 1usize; let mut new_ln = 1usize; + let has_headers = patch.lines().any(|line| line.starts_with("@@")); + let mut in_hunk = !has_headers && !patch.lines().any(|line| line.starts_with("diff --git ")); for raw in patch.lines() { + if raw.starts_with("@@") { + in_hunk = true; + } + if !in_hunk + || raw.starts_with("diff --git ") + || raw.starts_with("index ") + || raw.starts_with("Binary files ") + || raw.starts_with("GIT binary patch") + { + continue; + } if raw.starts_with("--- ") || raw.starts_with("+++ ") || raw.starts_with('\\') { continue; } @@ -162,16 +204,36 @@ pub fn render_diff( max_lines: usize, palette: &Palette, ) -> (Vec>, DiffSummary) { + let rendered = render_view(patch, max_width, max_lines, palette, View::Auto); + (rendered.lines, rendered.summary) +} + +pub fn render_view( + patch: &str, + max_width: usize, + max_lines: usize, + palette: &Palette, + view: View, +) -> RenderedDiff { let (hunks, summary) = parse_hunks(patch); if hunks.is_empty() || max_width < 8 { - return (Vec::new(), summary); + return RenderedDiff { + lines: Vec::new(), + hunks: Vec::new(), + summary, + }; } let has_old = summary.removed > 0 || hunks .iter() .any(|h| h.lines.iter().any(|l| l.kind == Kind::Context)); - let use_split = max_width >= SPLIT_MIN_WIDTH && has_old && summary.added > 0; + let split_width = match view { + View::Auto => max_width >= SPLIT_MIN_WIDTH, + View::Unified => false, + View::Split => max_width >= 40, + }; + let use_split = split_width && has_old && summary.added > 0; let mut all_lines = if use_split { render_split(&hunks, max_width, palette) @@ -188,7 +250,26 @@ pub fn render_diff( )])); } - (all_lines, summary) + // Each hunk contributes its data rows plus one separator before subsequent hunks. + let mut hunks_at = Vec::new(); + let mut offset = 0; + for (at, hunk) in hunks.iter().enumerate() { + if at > 0 { + offset += 1; + } + hunks_at.push(offset); + offset += if use_split { + render_split(std::slice::from_ref(hunk), max_width, palette).len() + } else { + hunk.lines.len() + }; + } + hunks_at.retain(|row| *row < all_lines.len()); + RenderedDiff { + lines: all_lines, + hunks: hunks_at, + summary, + } } fn render_unified(hunks: &[Hunk], max_width: usize, palette: &Palette) -> Vec> { diff --git a/packages/tui/src/draft.rs b/packages/tui/src/draft.rs new file mode 100644 index 00000000..b8932524 --- /dev/null +++ b/packages/tui/src/draft.rs @@ -0,0 +1,94 @@ +//! Private, local drafts. Each server/thread gets its own file so independent TUIs +//! editing different threads cannot overwrite each other's drafts. +use crate::prompt::Prompt; +use base64::{engine::general_purpose::URL_SAFE_NO_PAD, Engine}; +use serde::{Deserialize, Serialize}; +use std::{ + fs, + io::{self, Write}, + path::{Path, PathBuf}, +}; + +#[derive(Default)] +pub struct DraftStore { + root: Option, +} +#[derive(Serialize, Deserialize)] +struct SavedDraft { + text: String, + caret: usize, +} +impl DraftStore { + pub fn at(home: &Path, endpoint: &str) -> Self { + Self { + root: Some( + home.join("tui/drafts") + .join(URL_SAFE_NO_PAD.encode(endpoint)), + ), + } + } + fn path(&self, key: &str) -> Option { + Some( + self.root + .as_ref()? + .join(format!("{}.json", URL_SAFE_NO_PAD.encode(key))), + ) + } + pub fn load(&self, key: &str) -> Result, String> { + let Some(path) = self.path(key) else { + return Ok(None); + }; + let source = match fs::read_to_string(&path) { + Ok(source) => source, + Err(error) if error.kind() == io::ErrorKind::NotFound => return Ok(None), + Err(error) => return Err(format!("Could not read draft: {error}")), + }; + let saved: SavedDraft = serde_json::from_str(&source) + .map_err(|error| format!("Could not read draft: {error}"))?; + Ok(Some(Prompt::restore(&saved.text, saved.caret))) + } + pub fn save(&self, key: &str, prompt: &Prompt) -> Result<(), String> { + let Some(path) = self.path(key) else { + return Ok(()); + }; + let write = || -> io::Result<()> { + if prompt.text().is_empty() { + return match fs::remove_file(&path) { + Err(error) if error.kind() == io::ErrorKind::NotFound => Ok(()), + result => result, + }; + } + let parent = path.parent().unwrap(); + let mut builder = fs::DirBuilder::new(); + builder.recursive(true); + #[cfg(unix)] + { + use std::os::unix::fs::DirBuilderExt; + builder.mode(0o700); + } + builder.create(parent)?; + let temporary = path.with_extension(format!("{}.tmp", std::process::id())); + let mut options = fs::OpenOptions::new(); + options.write(true).create(true).truncate(true); + #[cfg(unix)] + { + use std::os::unix::fs::OpenOptionsExt; + options.mode(0o600); + } + let mut file = options.open(&temporary)?; + serde_json::to_writer( + &mut file, + &SavedDraft { + text: prompt.text().to_string(), + caret: prompt.caret(), + }, + )?; + file.write_all(b"\n")?; + file.sync_all()?; + drop(file); + fs::rename(temporary, path)?; + Ok(()) + }; + write().map_err(|error| format!("Could not save draft: {error}")) + } +} diff --git a/packages/tui/src/event.rs b/packages/tui/src/event.rs index e60f00ea..13065991 100644 --- a/packages/tui/src/event.rs +++ b/packages/tui/src/event.rs @@ -10,34 +10,44 @@ use crossterm::event::{Event, KeyEvent, KeyEventKind, MouseEventKind}; use tokio::sync::mpsc; use crate::rpc::StreamEvent; -use crate::types::{HistoryEntry, ModelList, ServerInfo, SessionInfo}; +use crate::types::{ModelList, ServerInfo, ThreadInfo}; /// Asynchronous results arriving from the RPC server. #[derive(Debug, Clone, PartialEq)] pub enum RpcEvent { - Stream(StreamEvent), - SessionStream { - session_id: String, - event: StreamEvent, - }, ServerInfoLoaded(Result), ModelsLoaded(Result), - SessionsLoaded(Result, String>), - SessionHistoryRefresh { - session_id: String, + ThreadsLoaded { + generation: u64, + result: Result, String>, + }, + Git { + space_id: String, + generation: u64, + event: crate::git::GitEvent, }, - SessionHistoryLoaded { - session_id: String, + GitDiff { + space_id: String, + generation: u64, request_id: u64, - revision: u64, - result: Result, String>, + file: String, + result: Result, + }, + Created { + result: Result, + text: String, + delivery: crate::types::PromptDelivery, + id: String, + }, + ThreadStream { + address: crate::rpc::protocol::ThreadRefPayload, + generation: u64, + event: StreamEvent, }, - SessionConfigured(Result), - PluginsReloaded(Result<(u64, Option), String>), - PromptDispatched { - session_id: String, - message_id: String, - result: Result<(), String>, + Operation { + address: crate::rpc::protocol::ThreadRefPayload, + generation: u64, + result: Result, }, } @@ -58,8 +68,17 @@ pub enum AppEvent { /// view reads its own dimensions from the frame it is drawing into, so a /// stale copy in state would be one more thing to keep in sync. Resize, + SaveDraft { + revision: u64, + }, /// An event or response from the CodeWork RPC server. - Rpc(RpcEvent), + Rpc(Box), +} + +impl AppEvent { + pub fn rpc(event: RpcEvent) -> Self { + Self::Rpc(Box::new(event)) + } } pub struct EventHandler { @@ -77,17 +96,14 @@ impl EventHandler { pub fn new() -> Self { let (tx, rx) = mpsc::unbounded_channel(); let reader_tx = tx.clone(); - std::thread::spawn(move || loop { - match crossterm::event::read() { - Ok(event) => { - let Some(event) = translate(event) else { - continue; - }; - if reader_tx.send(event).is_err() { - break; - } + std::thread::spawn(move || { + while let Ok(event) = crossterm::event::read() { + let Some(event) = translate(event) else { + continue; + }; + if reader_tx.send(event).is_err() { + break; } - Err(_) => break, } }); Self { tx, rx } diff --git a/packages/tui/src/git.rs b/packages/tui/src/git.rs new file mode 100644 index 00000000..61b50035 --- /dev/null +++ b/packages/tui/src/git.rs @@ -0,0 +1,197 @@ +//! Git daemon DTOs and review state. Paths and patches come from the server's active +//! space so the client works with remote machines and sandboxes too. +use crate::{ + diff::{self, RenderedDiff, View}, + theme::Palette, +}; +use serde::{Deserialize, Serialize}; +use std::cell::Cell; + +#[cfg(test)] +mod tests; + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize)] +#[serde(rename_all = "lowercase")] +pub enum Change { + Added, + Deleted, + Modified, +} +impl Change { + pub fn label(self) -> &'static str { + match self { + Self::Added => "A", + Self::Deleted => "D", + Self::Modified => "M", + } + } +} +#[derive(Debug, Clone, PartialEq, Eq, Deserialize)] +pub struct File { + pub file: String, + pub status: Change, + pub additions: u64, + pub deletions: u64, +} +#[derive(Debug, Clone, PartialEq, Eq, Deserialize)] +pub struct Status { + #[serde(rename = "spaceId")] + pub space_id: String, + #[serde(rename = "observedAt")] + pub observed_at: u64, + pub available: bool, + #[serde(default)] + pub branch: Option, + #[serde(default)] + pub head: Option, + #[serde(default)] + pub files: Vec, + #[serde(default)] + pub reason: Option, + #[serde(default)] + pub message: Option, +} +#[derive(Debug, Clone, PartialEq, Eq, Deserialize)] +pub struct FileDiff { + pub file: String, + pub patch: String, + pub status: Change, + pub additions: u64, + pub deletions: u64, +} +#[derive(Debug, Clone, PartialEq, Eq, Deserialize)] +pub struct Diff { + pub files: Vec, + #[serde(default)] + pub cached: bool, + #[serde(default)] + pub truncated: bool, +} +#[derive(Debug, Clone, PartialEq)] +pub enum GitEvent { + Status(Status), + Connected, + Disconnected(String), +} + +#[derive(Default)] +pub struct Git { + pub space_id: Option, + pub status: Option, + pub open: bool, + pub patch_focus: bool, + pub selected: Option, + pub diff: Option, + pub loading: bool, + pub error: Option, + pub connection_error: Option, + pub scroll: usize, + pub max_scroll: Cell, + pub width: Cell, + pub view: View, + pub request: u64, +} +impl Git { + pub fn for_space(space_id: String) -> Self { + Self { + space_id: Some(space_id), + ..Self::default() + } + } + pub fn apply_status(&mut self, mut status: Status) -> bool { + if self.space_id.as_deref() != Some(&status.space_id) + || self + .status + .as_ref() + .is_some_and(|held| held.observed_at > status.observed_at) + { + return false; + } + status.files.sort_by(|a, b| a.file.cmp(&b.file)); + let previous = self.selected.clone(); + if !status.available { + status.files.clear(); + } + if !self + .selected + .as_ref() + .is_some_and(|selected| status.files.iter().any(|file| &file.file == selected)) + { + self.selected = status.files.first().map(|file| file.file.clone()); + } + if self.selected != previous { + self.scroll = 0; + } + self.status = Some(status); + self.diff = None; + self.error = None; + self.loading = false; + self.request += 1; + true + } + pub fn select(&mut self, delta: isize) { + let Some(status) = &self.status else { + return; + }; + if status.files.is_empty() { + return; + } + let at = status + .files + .iter() + .position(|file| Some(&file.file) == self.selected.as_ref()) + .unwrap_or(0); + let next = (at as isize + delta).clamp(0, status.files.len() as isize - 1) as usize; + if at != next { + self.selected = Some(status.files[next].file.clone()); + self.diff = None; + self.error = None; + self.scroll = 0; + } + } + pub fn branch_label(&self) -> Option { + let status = self.status.as_ref().filter(|status| status.available)?; + let branch = status + .branch + .as_deref() + .unwrap_or(if status.head.is_some() { + "detached" + } else { + "unborn" + }); + Some(format!("{branch} · {} changed", status.files.len())) + } + pub fn rendered(&self, width: usize, palette: &Palette) -> RenderedDiff { + let patch = self + .diff + .as_ref() + .and_then(|diff| { + diff.files + .iter() + .find(|file| Some(&file.file) == self.selected.as_ref()) + }) + .map(|file| file.patch.as_str()) + .unwrap_or(""); + diff::render_view(patch, width, 0, palette, self.view) + } + pub fn scroll_by(&mut self, delta: isize) { + self.scroll = if delta < 0 { + self.scroll.saturating_sub(delta.unsigned_abs()) + } else { + self.scroll + .saturating_add(delta as usize) + .min(self.max_scroll.get()) + }; + } + pub fn jump_hunk(&mut self, forward: bool, palette: &Palette) { + let rendered = self.rendered(self.width.get(), palette); + let target = if forward { + rendered.hunks.iter().find(|row| **row > self.scroll) + } else { + rendered.hunks.iter().rev().find(|row| **row < self.scroll) + }; + if let Some(row) = target { + self.scroll = (*row).min(self.max_scroll.get()); + } + } +} diff --git a/packages/tui/src/git/tests.rs b/packages/tui/src/git/tests.rs new file mode 100644 index 00000000..37f03fd2 --- /dev/null +++ b/packages/tui/src/git/tests.rs @@ -0,0 +1,184 @@ +//! Written before implementation. Failure modes: wrong-space or stale replies showing another +//! checkout's patch; status updates moving selection; omitted/binary patches appearing clean; +//! Git headers corrupting line numbers; long patches silently truncated; review keys sending +//! prompts or destroying drafts. The terminal E2E uses a real Git repository and the real binary. +use super::*; +use crate::{ + app::App, + event::{AppEvent, RpcEvent}, + rpc::RpcClient, + types::ThreadInfo, +}; +use crossterm::event::{KeyCode, KeyEvent, KeyModifiers}; +use serde_json::json; + +fn thread(space: &str) -> ThreadInfo { + serde_json::from_value(json!({"id":"main","session":{"id":"session","spaceId":space,"slug":"Git test","directory":"/workspace","mainThreadId":"main"}})).unwrap() +} +fn status(space: &str, at: u64, files: &[&str]) -> Status { + serde_json::from_value(json!({"spaceId":space,"observedAt":at,"available":true,"branch":"main","head":"0123456789abcdef","files":files.iter().map(|file|json!({"file":file,"status":"modified","additions":1,"deletions":1})).collect::>()})).unwrap() +} +fn key(app: &mut App, code: KeyCode) { + app.update(AppEvent::Key(KeyEvent::new(code, KeyModifiers::NONE))); +} + +#[test] +fn status_preserves_selection_and_rejects_older_or_wrong_space_data() { + let mut git = Git::for_space("space".into()); + git.apply_status(status("space", 1, &["b.rs", "a.rs"])); + assert_eq!(git.selected.as_deref(), Some("a.rs")); + git.select(1); + assert_eq!(git.selected.as_deref(), Some("b.rs")); + git.apply_status(status("space", 2, &["c.rs", "b.rs"])); + assert_eq!(git.selected.as_deref(), Some("b.rs")); + git.apply_status(status("other", 3, &["wrong"])); + git.apply_status(status("space", 1, &["old"])); + assert_eq!(git.status.as_ref().unwrap().files.len(), 2); + git.apply_status(status("space", 3, &["c.rs"])); + assert_eq!(git.selected.as_deref(), Some("c.rs")); +} + +#[test] +fn review_preserves_composer_and_checks_space_generation_and_patch_request() { + let mut app = App::default(); + app.switch_thread(thread("space")); + app.prompt.insert_text("unsent\n draft"); + app.update(AppEvent::rpc(RpcEvent::Git { + space_id: "space".into(), + generation: 1, + event: GitEvent::Status(status("space", 1, &["a.rs"])), + })); + app.update(AppEvent::Key(KeyEvent::new( + KeyCode::Char('g'), + KeyModifiers::CONTROL, + ))); + assert!(app.git.open); + let request = app.git.request; + let patch = Diff { + files: vec![FileDiff { + file: "a.rs".into(), + patch: "@@ -1 +1 @@\n-old\n+new\n".into(), + status: Change::Modified, + additions: 1, + deletions: 1, + }], + cached: false, + truncated: false, + }; + for (space, generation, request_id) in [ + ("other", 1, request), + ("space", 99, request), + ("space", 1, request.saturating_sub(1)), + ] { + app.update(AppEvent::rpc(RpcEvent::GitDiff { + space_id: space.into(), + generation, + request_id, + file: "a.rs".into(), + result: Ok(patch.clone()), + })); + assert!(app.git.diff.is_none()); + } + app.update(AppEvent::rpc(RpcEvent::GitDiff { + space_id: "space".into(), + generation: 1, + request_id: request, + file: "a.rs".into(), + result: Ok(patch), + })); + assert!(app.git.diff.is_some()); + key(&mut app, KeyCode::Enter); + key(&mut app, KeyCode::Esc); + key(&mut app, KeyCode::Esc); + assert!(!app.git.open); + assert_eq!(app.prompt.text(), "unsent\n draft"); + assert!(!app.should_quit); + let mut moved = thread("original"); + moved.placement = Some(crate::types::ThreadPlacement { + space_id: "override".into(), + directory: "/remote".into(), + }); + app.switch_thread(moved); + assert_eq!(app.git.space_id.as_deref(), Some("override")); +} + +#[test] +fn full_git_patches_share_rendering_without_metadata_or_preview_truncation() { + let mut patch="diff --git a/file b/file\nindex 123..456 100644\n--- a/file\n+++ b/file\n@@ -1,2 +1,2 @@\n-old\n+new\n context\n@@ -20 +20 @@\n-before\n+after\n".to_string(); + patch.push_str(&" context\n".repeat(80)); + let rendered = crate::diff::render_view( + &patch, + 80, + 0, + crate::theme::default_palette(), + crate::diff::View::Unified, + ); + let text = rendered + .lines + .iter() + .map(|line| { + line.spans + .iter() + .map(|span| span.content.as_ref()) + .collect::() + }) + .collect::>() + .join("\n"); + assert!(!text.contains("diff --git")); + assert!(!text.contains("index 123")); + assert!(text.contains("after")); + assert!(rendered.lines.len() > 60); + assert_eq!(rendered.hunks.len(), 2); + assert_eq!(rendered.hunks[0], 0); +} + +#[test] +fn git_screen_records_repeatable_cached_and_truncated_states() { + use ratatui::{backend::TestBackend, Terminal}; + let mut app = App::with_client( + tokio::sync::mpsc::unbounded_channel().0, + RpcClient::default(), + ); + app.session = Some(thread("space")); + app.git = Git::for_space("space".into()); + app.git + .apply_status(status("space", 1, &["src/a.rs", "notes with spaces.txt"])); + app.git.open = true; + app.git.diff = Some(Diff { + files: vec![FileDiff { + file: "notes with spaces.txt".into(), + patch: "@@ -0,0 +1 @@\n+New notes\n".into(), + status: Change::Added, + additions: 1, + deletions: 0, + }], + cached: true, + truncated: true, + }); + app.git.loading = false; + let mut terminal = Terminal::new(TestBackend::new(100, 18)).unwrap(); + terminal.draw(|frame| crate::ui::view(&app, frame)).unwrap(); + let buffer = terminal.backend().buffer(); + let rendered = (0..18) + .map(|y| { + (0..100) + .map(|x| buffer[(x, y)].symbol()) + .collect::() + .trim_end() + .to_string() + }) + .collect::>() + .join("\n") + + "\n"; + assert!(rendered.contains("cached")); + assert!(rendered.contains("truncated")); + assert!(rendered.contains("New notes")); + let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("__artifacts__/git.txt"); + if std::env::var_os("UPDATE_ARTIFACTS").is_some() { + std::fs::write(&path, &rendered).unwrap(); + } + assert_eq!( + rendered, + std::fs::read_to_string(path).expect("run UPDATE_ARTIFACTS=1 cargo test") + ); +} diff --git a/packages/tui/src/main.rs b/packages/tui/src/main.rs index 69ee3b49..f88ac618 100644 --- a/packages/tui/src/main.rs +++ b/packages/tui/src/main.rs @@ -1,10 +1,17 @@ mod action; mod app; +mod browser; +#[cfg(test)] +mod conversation; mod diff; +mod draft; mod event; +mod git; mod menu; mod prompt; mod rpc; +#[cfg(test)] +mod tests; mod theme; mod tool; mod tui; diff --git a/packages/tui/src/menu.rs b/packages/tui/src/menu.rs index 0a9b5c75..dd58c313 100644 --- a/packages/tui/src/menu.rs +++ b/packages/tui/src/menu.rs @@ -48,8 +48,8 @@ impl Entry { ) -> Self { Self { id: Cow::Owned(id.into()), - name: Cow::Owned(name.into()), - detail: Cow::Owned(detail.into()), + name: Cow::Owned(name.into().replace(['\r', '\n', '\t'], " ")), + detail: Cow::Owned(detail.into().replace(['\r', '\n', '\t'], " ")), preview: None, } } diff --git a/packages/tui/src/prompt.rs b/packages/tui/src/prompt.rs index dc69ae5f..0c636a7e 100644 --- a/packages/tui/src/prompt.rs +++ b/packages/tui/src/prompt.rs @@ -12,10 +12,11 @@ use crossterm::event::{KeyCode, KeyEvent, KeyModifiers}; /// /// The caret is a UTF-8 byte offset into `text`, kept on a character boundary by every operation /// that moves it so slicing before or after the caret is direct. -#[derive(Default)] +#[derive(Default, Clone, PartialEq, Eq)] pub struct Prompt { text: String, caret: usize, + preferred_column: Option, } impl Prompt { @@ -33,18 +34,30 @@ impl Prompt { pub fn clear(&mut self) { self.text.clear(); self.caret = 0; + self.preferred_column = None; } /// Apply one key. Reports whether the prompt changed, which is the redraw. pub fn edit(&mut self, key: KeyEvent) -> bool { match (key.code, key.modifiers) { - (KeyCode::Char('a'), KeyModifiers::CONTROL) | (KeyCode::Home, _) => self.jump(0), + (KeyCode::Enter, KeyModifiers::SHIFT) | (KeyCode::Char('j'), KeyModifiers::CONTROL) => { + self.insert_text("\n") + } + (KeyCode::Home, KeyModifiers::CONTROL) => self.jump(0), + (KeyCode::End, KeyModifiers::CONTROL) => self.jump(self.text.len()), + (KeyCode::Char('a'), KeyModifiers::CONTROL) | (KeyCode::Home, _) => { + self.jump(self.line_start()) + } (KeyCode::Char('e'), KeyModifiers::CONTROL) | (KeyCode::End, _) => { - self.jump(self.text.len()) + self.jump(self.line_end()) + } + (KeyCode::Up, KeyModifiers::NONE) => self.vertical(-1), + (KeyCode::Down, KeyModifiers::NONE) => self.vertical(1), + (KeyCode::Char('u'), KeyModifiers::CONTROL) => { + self.remove_range(self.line_start()..self.caret) } - (KeyCode::Char('u'), KeyModifiers::CONTROL) => self.remove_range(0..self.caret), (KeyCode::Char('k'), KeyModifiers::CONTROL) => { - self.remove_range(self.caret..self.text.len()) + self.remove_range(self.caret..self.line_end()) } (KeyCode::Char('w'), KeyModifiers::CONTROL) | (KeyCode::Backspace, KeyModifiers::ALT) => { @@ -89,8 +102,7 @@ impl Prompt { /// Insert text at the caret, as a paste arrives. /// - /// Line breaks and tabs are turned into spaces so pasted lines do not run together, and any - /// other control characters are dropped. + /// Preserve newlines and indentation; normalize CRLF/CR and drop terminal control bytes. pub fn insert_text(&mut self, text: &str) -> bool { let mut clean = String::with_capacity(text.len()); let mut chars = text.chars().peekable(); @@ -100,9 +112,9 @@ impl Prompt { if chars.peek() == Some(&'\n') { chars.next(); } - clean.push(' '); + clean.push('\n'); } - '\n' | '\t' => clean.push(' '), + '\n' | '\t' => clean.push(ch), ch if !ch.is_control() => clean.push(ch), _ => {} } @@ -112,9 +124,123 @@ impl Prompt { } self.text.insert_str(self.caret, &clean); self.caret += clean.len(); + self.preferred_column = None; true } + pub fn insert_inline(&mut self, text: &str) -> bool { + self.insert_text(&text.replace(['\r', '\n', '\t'], " ")) + } + + pub fn caret(&self) -> usize { + self.caret + } + pub fn restore(text: &str, caret: usize) -> Self { + let mut prompt = Self::default(); + prompt.insert_text(text); + let mut at = caret.min(prompt.text.len()); + while !prompt.text.is_char_boundary(at) { + at -= 1; + } + prompt.caret = at; + prompt + } + fn line_start(&self) -> usize { + self.text[..self.caret].rfind('\n').map_or(0, |at| at + 1) + } + fn line_end(&self) -> usize { + self.text[self.caret..] + .find('\n') + .map_or(self.text.len(), |at| self.caret + at) + } + pub fn current_line(&self) -> (&str, &str) { + let start = self.line_start(); + ( + &self.text[start..self.line_end()], + &self.text[start..self.caret], + ) + } + + fn vertical(&mut self, direction: isize) -> bool { + let start = self.line_start(); + let end = self.line_end(); + let desired = self + .preferred_column + .unwrap_or_else(|| columns(&self.text[start..self.caret])); + let target = if direction < 0 { + if start == 0 { + return false; + } + let end = start - 1; + let start = self.text[..end].rfind('\n').map_or(0, |at| at + 1); + start..end + } else { + if end == self.text.len() { + return false; + } + let start = end + 1; + let end = self.text[start..] + .find('\n') + .map_or(self.text.len(), |at| start + at); + start..end + }; + let mut column = 0; + let mut at = target.start; + for (offset, ch) in self.text[target.clone()].char_indices() { + let width = cell_width(ch, column); + if column + width > desired { + break; + } + column += width; + at = target.start + offset + ch.len_utf8(); + } + let changed = self.jump(at); + self.preferred_column = Some(desired); + changed + } + + /// Character wrapping preserves indentation and shares caret geometry with rendering. + pub fn layout(&self, width: usize) -> PromptLayout { + let width = width.max(1); + let mut lines = vec![String::new()]; + let mut column = 0; + let mut caret = (0, 0); + for (at, ch) in self.text.char_indices() { + let cells = cell_width(ch, column); + if ch != '\n' && (column >= width || (ch != '\t' && column + cells > width)) { + lines.push(String::new()); + column = 0; + } + if at == self.caret { + caret = (column.min(width - 1), lines.len() - 1); + } + if ch == '\n' { + lines.push(String::new()); + column = 0; + } else if ch == '\t' { + for _ in 0..cell_width(ch, column) { + if column >= width { + lines.push(String::new()); + column = 0; + } + lines.last_mut().unwrap().push(' '); + column += 1; + } + } else { + lines.last_mut().unwrap().push(ch); + column += cell_width(ch, column); + } + } + if self.caret == self.text.len() { + if column >= width { + lines.push(String::new()); + column = 0; + } + caret = (column, lines.len() - 1); + } + PromptLayout { lines, caret } + } + fn remove_range(&mut self, range: Range) -> bool { if range.is_empty() { return false; @@ -122,6 +248,7 @@ impl Prompt { let start = range.start; self.text.replace_range(range, ""); self.caret = start; + self.preferred_column = None; true } @@ -130,6 +257,7 @@ impl Prompt { return false; } self.caret = caret; + self.preferred_column = None; true } @@ -167,3 +295,19 @@ impl Prompt { .map_or(self.text.len(), |(idx, _)| self.caret + idx) } } + +pub struct PromptLayout { + pub lines: Vec, + pub caret: (usize, usize), +} +fn cell_width(ch: char, column: usize) -> usize { + if ch == '\t' { + 4 - column % 4 + } else { + unicode_width::UnicodeWidthChar::width(ch).unwrap_or(0) + } +} +fn columns(text: &str) -> usize { + text.chars() + .fold(0, |column, ch| column + cell_width(ch, column)) +} diff --git a/packages/tui/src/rpc/client.rs b/packages/tui/src/rpc/client.rs index 024d624e..1bf00c4b 100644 --- a/packages/tui/src/rpc/client.rs +++ b/packages/tui/src/rpc/client.rs @@ -1,34 +1,18 @@ -use std::path::{Path, PathBuf}; -use std::sync::atomic::{AtomicU64, Ordering}; -use std::time::{Duration, SystemTime, UNIX_EPOCH}; - +//! Thread RPC transport. One socket per unary call; one resumable socket per thread sync. +use super::protocol::*; +use crate::event::{AppEvent, RpcEvent}; +use crate::types::{ + ModelList, PromptDelivery, ServerInfo, ServiceRegistration, ThreadInfo, ThreadItem, +}; use futures_util::{SinkExt, StreamExt}; -use serde::Serialize; +use serde::{de::DeserializeOwned, Serialize}; use serde_json::Value; +use std::path::{Path, PathBuf}; +use std::sync::atomic::{AtomicU64, Ordering}; +use std::time::Duration; use tokio::sync::mpsc; -use tokio::time::sleep; -use tokio_tungstenite::connect_async; -use tokio_tungstenite::tungstenite::Message; - -use crate::rpc::protocol::{ - ConfigureSessionPayload, CreateSessionPayload, ExitPayload, ListModelsPayload, ModelRefPayload, - PromptSessionPayload, RpcAck, RpcRequest, RuntimePayload, ServerMessage, - SessionHistoryResponse, SessionIdPayload, SessionLogPayload, SessionMessagePayload, - SessionMessageResponse, -}; -use crate::types::{ - HistoryEntry, ModelList, ModelRef, PromptDelivery, ServerInfo, ServiceRegistration, - SessionInfo, UsageReport, -}; - +use tokio_tungstenite::{connect_async, tungstenite::Message}; pub const DEFAULT_SERVER_URL: &str = "ws://127.0.0.1:7433/rpc/v1"; - -/// How long to wait between reconnection attempts, and how many to make before -/// giving the turn up. The server outlives this client, so a short window is -/// enough to cover a restart and far short of hanging the UI forever. -const RECONNECT_DELAY: Duration = Duration::from_secs(1); -const RECONNECT_ATTEMPTS: u32 = 30; - /// Resolve the CodeWork home directory (`CODEWORK_HOME_DIR`, otherwise `~/.codework`). pub fn codework_home_dir() -> Option { let user_home = std::env::var("HOME") @@ -139,141 +123,20 @@ pub fn verify_registration( #[derive(Debug, Clone, PartialEq)] pub enum StreamEvent { - SessionCreated(SessionInfo), - PromptAdmitted { - message_id: String, - prompt: String, - delivery: PromptDelivery, - }, - PromptPromoted { - message_id: String, - prompt: String, - delivery: PromptDelivery, - }, - ConfigChanged { - model: Option, - thinking_level: Option, - }, - SessionForked { - session_id: String, - source_session_id: String, - source_entry_id: String, - base_seq: u64, - }, - TurnStarted, - TurnEnded { - message_id: String, - }, - TurnAborted { - reason: String, - message: Option, - }, - RetryScheduled { - attempt: u64, - max_retries: u64, - delay_ms: u64, - message: String, - }, - RetryFinished { - attempt: u64, - success: bool, - message: Option, - }, - LlmStarted { - message_id: String, - model: Option, - }, - LlmFailed { - message_id: String, - reason: String, - error: Option, - }, - TextStart { - message_id: String, - part_index: usize, - }, - TextDelta { - message_id: Option, - part_index: Option, - delta: String, - }, - TextEnd { - message_id: String, - part_index: usize, - content: String, - }, - ThinkingStart { - message_id: String, - part_index: usize, - }, - ThinkingDelta { - message_id: Option, - part_index: Option, - delta: String, - }, - ThinkingEnd { - message_id: String, - part_index: usize, - content: String, - }, - ToolStarted { - call_id: String, - name: String, - label: Option, - /// The tool call's raw arguments — the command, path, or query. - arguments: Value, - }, - ToolProgress { - call_id: String, - /// Partial text output reported while the tool is still running. - output: Option, - /// Optional structured progress details reported by the tool. - details: Option, - }, - ToolSettled { - call_id: String, - name: Option, - is_error: bool, - /// The arguments the terminal part carries, repeated from `started`. - arguments: Value, - /// Text output returned by the tool in `result.content`. - output: Option, - /// The tool's own success/failure struct. Arbitrary JSON: the shape is the - /// tool's to define, so it is interpreted downstream rather than here. - details: Option, - }, - /// A plugin or runtime warning surfaced during the turn (as ACP's `Feed.notice` does). - Notice(String), - Usage(UsageReport), - /// `session.log` replay reached the head sequence read when the call began. - LogSynced { - seq: Option, - }, - ExecutionStarted, - Succeeded, - Failed(String), - Interrupted(String), - /// The transport dropped mid-stream. Distinct from `Failed`: the work is not - /// necessarily over, only the socket is, so the UI shows reconnecting rather - /// than an error. + Item(ThreadItem), + Info { rev: u64, info: Box }, + Event(EventEnvelope), + Reset, Disconnected, - /// The server answered again after a `Disconnected`. Reconnected, + Failed(String), } -/// Advance a `session.log` cursor (`after`) to `max(cursor, next_seq)`. -pub fn advance_log_cursor(cursor: &mut Option, next_seq: Option) { - if let Some(seq) = next_seq { - *cursor = Some(cursor.map_or(seq, |prev| prev.max(seq))); - } -} - -/// Highest durable sequence in a `session.history` snapshot, used as the initial `after` -/// cursor when opening or resuming an existing session. -pub fn history_cursor(entries: &[HistoryEntry]) -> Option { - entries.iter().map(|entry| entry.seq).max() +#[derive(Debug, Default, Clone)] +pub struct SyncCursor { + pub store_id: Option, + pub rev: Option, } - pub struct RpcClient { url: String, expected: Option, @@ -350,7 +213,7 @@ impl RpcClient { text.push('\n'); write - .send(Message::Text(text.into())) + .send(Message::Text(text)) .await .map_err(|e| format!("Send error: {}", e))?; @@ -386,1128 +249,604 @@ impl RpcClient { Err("Connection closed before response received".to_string()) } - /// Whether this endpoint currently accepts a WebSocket connection. - #[cfg(test)] - pub async fn is_server_running(&self) -> bool { - matches!( - tokio::time::timeout(Duration::from_millis(1500), connect_async(&self.url)).await, - Ok(Ok(_)) - ) - } - - /// Probe the server's identity (`server.info` -> `{ pid, version }`). - pub async fn server_info(&self) -> Result { - let value = self.call("server.info", serde_json::json!({})).await?; - parse_server_info(&value) - } - - /// Probe `server.info` and, when a `/service.json` registration applies to this - /// endpoint, confirm that the answering process matches the registered `pid` and `version`. pub async fn verify_server(&self) -> Result { - let info = self.server_info().await?; + let info: ServerInfo = self.request("server.info", serde_json::json!({})).await?; if let Some(expected) = &self.expected { verify_registration(expected, &info)?; } Ok(info) } - /// Create a session, letting the server pick the default model from settings when `model` is - /// `None` (matching ACP's `newSession`). + async fn request( + &self, + tag: &str, + payload: P, + ) -> Result { + let value = tokio::time::timeout(Duration::from_secs(30), self.call(tag, payload)) + .await + .map_err(|_| format!("{tag} timed out"))??; + serde_json::from_value(value).map_err(|e| format!("Invalid {tag} response: {e}")) + } + pub async fn create_session( &self, host_dir: Option, model: Option<(String, String)>, thinking_level: Option, - ) -> Result { - let dir = host_dir.or_else(|| { - std::env::current_dir() - .ok() - .map(|p| p.to_string_lossy().to_string()) - }); - let runtime = if model.is_some() || thinking_level.is_some() { - Some(RuntimePayload { - model: model.map(|(provider, id)| ModelRefPayload { provider, id }), - thinking_level, - }) - } else { - None - }; - let value = self - .call( - "session.create", - CreateSessionPayload { - host_dir: dir, - runtime, + ) -> Result { + self.request( + "session.create", + CreateSessionPayload { + directory: None, + host_dir, + runtime: if model.is_some() || thinking_level.is_some() { + Some(RuntimePayload { + model: model.map(|(provider, id)| ModelRefPayload { provider, id }), + thinking_level, + }) + } else { + None }, - ) - .await?; - parse_session_info(&value) + }, + ) + .await } - /// List all sessions on the server (`session.list`). - pub async fn list_sessions(&self) -> Result, String> { - let value = self.call("session.list", serde_json::json!({})).await?; - let Some(items) = value.as_array() else { - return Ok(Vec::new()); - }; - Ok(items - .iter() - .filter_map(|item| parse_session_info(item).ok()) - .collect()) + pub async fn list_threads(&self) -> Result, String> { + self.request("thread.list", ListThreadsPayload { session_id: None }) + .await } - /// List the models available for `host_dir` and the resolved settings default (`model.list`). - pub async fn list_models(&self, host_dir: Option<&str>) -> Result { - let value = self - .call("model.list", ListModelsPayload { host_dir }) - .await?; - parse_model_list(&value) + /// Index commits invalidate the browser's complete thread list, including removals. + /// Reopening from zero on reconnect avoids maintaining a second index projection. + pub async fn watch_threads(&self, tx: mpsc::UnboundedSender, generation: u64) { + for _ in 0..30 { + let result = self.watch_index_once(&tx, generation).await; + if tx.is_closed() { + return; + } + if let Err(error) = result { + let _ = tx.send(AppEvent::rpc(RpcEvent::ThreadsLoaded { + generation, + result: Err(format!("Thread browser reconnecting: {error}")), + })); + } + tokio::time::sleep(Duration::from_secs(1)).await; + } + } + async fn watch_index_once( + &self, + tx: &mpsc::UnboundedSender, + generation: u64, + ) -> Result<(), String> { + let (mut ws, _) = connect_async(&self.url).await.map_err(|e| e.to_string())?; + let id = self.next_request_id(); + ws.send(Message::Text( + serde_json::to_string(&RpcRequest::new( + id, + "index.sync", + serde_json::json!({"after":0}), + )) + .map_err(|e| e.to_string())? + + "\n", + )) + .await + .map_err(|e| e.to_string())?; + while let Some(message) = ws.next().await { + match message.map_err(|e| e.to_string())? { + Message::Text(text) => { + for line in text.lines().filter(|line| !line.trim().is_empty()) { + match serde_json::from_str::(line) + .map_err(|e| e.to_string())? + { + ServerMessage::Chunk { request_id, values } + if as_request_id(&request_id) == Some(id) => + { + if values.iter().any(|value| value["_tag"] == "Synced") { + let threads = self.list_threads().await?; + tx.send(AppEvent::rpc(RpcEvent::ThreadsLoaded { + generation, + result: Ok(threads), + })) + .map_err(|_| "UI closed".to_string())?; + } + ws.send(Message::Text( + serde_json::to_string(&RpcAck::new(id)) + .map_err(|e| e.to_string())? + + "\n", + )) + .await + .map_err(|e| e.to_string())?; + } + ServerMessage::Exit { request_id, exit } + if as_request_id(&request_id) == Some(id) => + { + return Err(match exit { + ExitPayload::Failure { cause } => format_cause(cause.as_ref()), + _ => "Index subscription ended".into(), + }) + } + ServerMessage::Defect { defect } => { + return Err(format_cause(defect.as_ref())) + } + _ => {} + } + } + } + Message::Ping(bytes) => ws + .send(Message::Pong(bytes)) + .await + .map_err(|e| e.to_string())?, + Message::Close(_) => break, + _ => {} + } + } + Err("Index connection closed".into()) } - /// Fetch a session's current info (`session.info`), used to pick up auto-generated titles. - pub async fn session_info(&self, session_id: &str) -> Result { - let value = self - .call( - "session.info", - SessionIdPayload { - session_id: session_id.to_string(), - }, - ) - .await?; - parse_session_info(&value) + pub async fn list_models(&self, host_dir: Option<&str>) -> Result { + self.request("model.list", ListModelsPayload { host_dir }) + .await } - /// Fetch a session's active-branch conversation history (`session.history`). - pub async fn session_history(&self, session_id: &str) -> Result, String> { - let value = self - .call( - "session.history", - SessionIdPayload { - session_id: session_id.to_string(), - }, - ) - .await?; - parse_session_history(&value) + pub async fn thread_info(&self, address: ThreadRefPayload) -> Result { + self.request("thread.info", address).await } - /// Update a session's model or thinking effort (`session.configure`, matching ACP's - /// `setConfigOption`). - pub async fn configure_session( + pub async fn configure_thread( &self, - session_id: &str, + address: ThreadRefPayload, model: Option<(String, String)>, thinking_level: Option, - ) -> Result { - let value = self - .call( - "session.configure", - ConfigureSessionPayload { - session_id: session_id.to_string(), - runtime: RuntimePayload { - model: model.map(|(provider, id)| ModelRefPayload { provider, id }), - thinking_level, - }, + ) -> Result { + self.request( + "thread.configure", + ConfigureThreadPayload { + session_id: address.session_id, + thread_id: address.thread_id, + runtime: RuntimePayload { + model: model.map(|(provider, id)| ModelRefPayload { provider, id }), + thinking_level, }, - ) - .await?; - parse_session_info(&value) + }, + ) + .await } - pub async fn interrupt_session(&self, session_id: &str) -> Result { - let value = self - .call( - "session.interrupt", - SessionIdPayload { - session_id: session_id.to_string(), - }, - ) - .await?; - Ok(value - .get("interrupted") - .and_then(|v| v.as_bool()) - .unwrap_or(false)) + pub async fn interrupt_thread(&self, address: ThreadRefPayload) -> Result<(), String> { + self.call("thread.interrupt", address).await.map(|_| ()) } - /// Reload server plugins (`plugin.reload`). pub async fn reload_plugins(&self) -> Result<(u64, Option), String> { let value = self.call("plugin.reload", serde_json::json!({})).await?; - let count = value.get("plugins").and_then(|v| v.as_u64()).unwrap_or(0); - let failure = value - .get("failure") - .and_then(|v| v.as_str()) - .map(str::to_string); - Ok((count, failure)) + Ok(( + value["plugins"].as_u64().unwrap_or(0), + value["failure"].as_str().map(str::to_string), + )) } - /// Admit a prompt into a running session (`session.prompt`) with the chosen delivery mode - /// (`steer` or `followUp`) and correlation `message_id`. pub async fn send_prompt( &self, - session_id: &str, - text: &str, + address: ThreadRefPayload, + text: String, delivery: PromptDelivery, - message_id: &str, + id: String, ) -> Result<(), String> { self.call( - "session.prompt", - PromptSessionPayload { - session_id: session_id.to_string(), - text: text.to_string(), + "thread.prompt", + PromptThreadPayload { + session_id: address.session_id, + thread_id: address.thread_id, + text, delivery: delivery.as_str(), - id: message_id.to_string(), + id, }, ) .await .map(|_| ()) } - /// Check whether a prompt materialized into the conversation (`session.message`). - pub async fn session_message( + pub async fn cancel_queued_prompt( &self, - session_id: &str, - message_id: &str, + address: ThreadRefPayload, + message_id: String, ) -> Result { - let value = self - .call( - "session.message", - SessionMessagePayload { - session_id: session_id.to_string(), - message_id: message_id.to_string(), + let reply: CancelledResponse = self + .request( + "thread.cancel", + ThreadMessagePayload { + session_id: address.session_id, + thread_id: address.thread_id, + message_id, }, ) .await?; - parse_session_message(&value) + Ok(reply.cancelled) } - /// Wait until a session has no work running or queued (`session.wait`). - #[allow(dead_code)] - pub async fn wait_session(&self, session_id: &str) -> Result<(), String> { - self.call( - "session.wait", - SessionIdPayload { - session_id: session_id.to_string(), + pub async fn update_queued_prompt( + &self, + address: ThreadRefPayload, + message_id: String, + delivery: Option, + text: Option, + ) -> Result { + let reply: UpdatedResponse = self + .request( + "thread.update", + UpdatePromptPayload { + address, + message_id, + delivery, + text, + }, + ) + .await?; + Ok(reply.updated) + } + + pub async fn fork_thread( + &self, + address: ThreadRefPayload, + entry_id: String, + mode: ForkMode, + ) -> Result { + self.request( + "thread.fork", + ForkThreadPayload { + address, + entry_id, + mode, }, ) .await - .map(|_| ()) } - /// Stream durable events for `session_id` via `session.log` (`{ sessionId, after, follow }`), - /// advancing `cursor` to `max(last durable.seq, last log.synced.seq)` and resuming from - /// `cursor` on reconnect when `follow` is `true`. - #[allow(dead_code)] - pub async fn session_log( + pub async fn page_thread( &self, - session_id: &str, - after: Option, - follow: bool, - cursor: &mut Option, - event_tx: &mpsc::UnboundedSender, - ) -> Result<(), String> { - advance_log_cursor(cursor, after); - let mut attempt = 0u32; - let mut seen_durable_seqs = std::collections::HashSet::new(); + address: ThreadRefPayload, + before: u64, + limit: u64, + ) -> Result, String> { + let reply: ThreadHistoryResponse = self + .request( + "thread.page", + PageThreadPayload { + address, + before, + limit, + }, + ) + .await?; + Ok(reply.entries) + } + + pub async fn git_diff(&self, space_id: &str, file: &str) -> Result { + self.request( + "daemon.call", + GitDiffPayload { + plugin: "git", + space_id, + method: "diff", + input: GitDiffInput { + files: [file], + context: 3, + }, + }, + ) + .await + } - loop { - match self - .stream_session_log_once( - session_id, - follow, - cursor, - &mut seen_durable_seqs, - attempt > 0, - event_tx, - ) - .await - { - Ok(true) => return Ok(()), - Ok(false) => { - attempt += 1; - if attempt > RECONNECT_ATTEMPTS { - let _ = event_tx.send(StreamEvent::Failed(format!( - "Lost the connection to {} and could not reconnect", - self.url - ))); - return Ok(()); - } - let _ = event_tx.send(StreamEvent::Disconnected); - sleep(RECONNECT_DELAY).await; - } - Err(message) => { - let _ = event_tx.send(StreamEvent::Failed(message)); - return Ok(()); + /// Space daemons have no threadId: request their type without a thread filter, + /// then select the active space from the replay and every subsequent live event. + pub async fn watch_git( + &self, + space_id: String, + tx: mpsc::UnboundedSender, + generation: u64, + ) { + for attempt in 0..30 { + if let Err(error) = self.git_events_once(&space_id, &tx, generation).await { + if tx.is_closed() { + return; } + let _ = tx.send(AppEvent::rpc(RpcEvent::Git { + space_id: space_id.clone(), + generation, + event: crate::git::GitEvent::Disconnected(error), + })); + } + if attempt < 29 { + tokio::time::sleep(Duration::from_secs(1)).await; } } } - - /// One connection's worth of `session.log`. `Ok(true)` means a non-followed replay completed; - /// `Ok(false)` means the socket dropped and a follower should reconnect from `cursor`. - pub async fn stream_session_log_once( + async fn git_events_once( &self, - session_id: &str, - follow: bool, - cursor: &mut Option, - seen_durable_seqs: &mut std::collections::HashSet, - is_retry: bool, - event_tx: &mpsc::UnboundedSender, - ) -> Result { - let (ws_stream, _) = match connect_async(&self.url).await { - Ok(stream) => stream, - Err(_) => return Ok(false), + space_id: &str, + tx: &mpsc::UnboundedSender, + generation: u64, + ) -> Result<(), String> { + let (mut ws, _) = connect_async(&self.url).await.map_err(|e| e.to_string())?; + let id = self.next_request_id(); + let payload = EventSubscribePayload { + thread_id: None, + types: Some(vec!["plugin.git.status".into()]), }; - - let (mut write, mut read) = ws_stream.split(); - let log_id = self.next_request_id(); - let log_req = RpcRequest::new( - log_id, - "session.log", - SessionLogPayload { - session_id: session_id.to_string(), - after: *cursor, - follow: Some(follow), - }, - ); - let mut log_text = serde_json::to_string(&log_req).map_err(|e| e.to_string())?; - log_text.push('\n'); - write - .send(Message::Text(log_text)) - .await - .map_err(|e| format!("Failed to subscribe to session.log: {}", e))?; - - let mut reconnected = is_retry; - let mut saw_synced = false; - - while let Some(msg_res) = read.next().await { - let msg = match msg_res { - Ok(m) => m, - Err(_) => return Ok(!follow && saw_synced), - }; - - if let Message::Text(txt) = msg { - for line in txt.lines() { - let line = line.trim(); - if line.is_empty() { - continue; - } - - let parsed: ServerMessage = match serde_json::from_str(line) { - Ok(m) => m, - Err(_) => continue, - }; - - match parsed { - ServerMessage::Chunk { request_id, values } => { - if let Some(id_num) = as_request_id(&request_id) { - let ack = RpcAck::new(id_num); - if let Ok(mut ack_json) = serde_json::to_string(&ack) { - ack_json.push('\n'); - let _ = write.send(Message::Text(ack_json)).await; - } - } - - for env in values { - if env.event_type == "log.synced" { - if env - .aggregate_id - .as_deref() - .is_none_or(|agg| agg == session_id) - { - if reconnected { - reconnected = false; - let _ = event_tx.send(StreamEvent::Reconnected); - } - advance_log_cursor(cursor, env.seq); - saw_synced = true; - let _ = - event_tx.send(StreamEvent::LogSynced { seq: env.seq }); - } - continue; - } - - let data = match &env.data { - Some(d) => d, - None => continue, - }; - - let s_id = data.get("sessionId").and_then(|v| v.as_str()); - let source_id = - data.get("sourceSessionId").and_then(|v| v.as_str()); - let durable_agg = - env.durable.as_ref().map(|d| d.aggregate_id.as_str()); - let matches_session = s_id == Some(session_id) - || durable_agg == Some(session_id) - || (env.event_type == "session.next.forked" - && source_id == Some(session_id)); - if !matches_session { - continue; - } - - if reconnected { - reconnected = false; - let _ = event_tx.send(StreamEvent::Reconnected); - } - - if let Some(seq) = env.durable_seq() { - if durable_agg.is_none_or(|agg| agg == session_id) { - advance_log_cursor(cursor, Some(seq)); - if !seen_durable_seqs.insert(seq) { - continue; + ws.send(Message::Text( + serde_json::to_string(&RpcRequest::new(id, "event.subscribe", payload)) + .map_err(|e| e.to_string())? + + "\n", + )) + .await + .map_err(|e| e.to_string())?; + let send = |event| { + tx.send(AppEvent::rpc(RpcEvent::Git { + space_id: space_id.to_string(), + generation, + event, + })) + .map_err(|_| "UI closed".to_string()) + }; + while let Some(message) = ws.next().await { + match message.map_err(|e| e.to_string())? { + Message::Text(text) => { + for line in text.lines().filter(|line| !line.trim().is_empty()) { + match serde_json::from_str::(line) + .map_err(|e| e.to_string())? + { + ServerMessage::Chunk { request_id, values } + if as_request_id(&request_id) == Some(id) => + { + for value in values { + let envelope: EventEnvelope = + serde_json::from_value(value).map_err(|e| e.to_string())?; + if envelope.event_type == "server.connected" { + send(crate::git::GitEvent::Connected)?; + } else if envelope.event_type == "plugin.git.status" { + if let Some(data) = + envelope.data.filter(|data| data["spaceId"] == space_id) + { + let status = serde_json::from_value(data) + .map_err(|e| e.to_string())?; + send(crate::git::GitEvent::Status(status))?; } } } - - for stream_event in - decode_durable_session_events(env.event_type.as_str(), data) - { - let _ = event_tx.send(stream_event); - } + ws.send(Message::Text( + serde_json::to_string(&RpcAck::new(id)) + .map_err(|e| e.to_string())? + + "\n", + )) + .await + .map_err(|e| e.to_string())?; } + ServerMessage::Exit { request_id, exit } + if as_request_id(&request_id) == Some(id) => + { + return Err(match exit { + ExitPayload::Failure { cause } => format_cause(cause.as_ref()), + _ => "Git subscription ended".into(), + }) + } + ServerMessage::Defect { defect } => { + return Err(format_cause(defect.as_ref())) + } + _ => {} } - ServerMessage::Exit { request_id, exit } - if as_request_id(&request_id) == Some(log_id) => - { - return match exit { - ExitPayload::Success { .. } => Ok(true), - ExitPayload::Failure { cause } => Err(format_cause(cause.as_ref())), - }; - } - ServerMessage::Defect { defect } => { - return Err(format_cause(defect.as_ref())); - } - _ => {} } } + Message::Ping(bytes) => ws + .send(Message::Pong(bytes)) + .await + .map_err(|e| e.to_string())?, + Message::Close(_) => break, + _ => {} } } - - Ok(!follow && saw_synced) + Err("Git status connection closed".into()) } - /// Stream one prompt, reconnecting the socket when the transport drops. - /// - /// The session lives on the server, not this socket, so a dropped connection - /// is not the end of the turn: the stream is re-established and retried until - /// it terminates or the server has been gone longer than the grace period. - /// Every drop is announced as `Disconnected` so the UI can show reconnecting, - /// and the first event after a retry as `Reconnected` so it can clear it. - #[allow(dead_code)] - pub async fn prompt_session( - &self, - session_id: String, - prompt_text: String, - event_tx: mpsc::UnboundedSender, - ) -> Result<(), String> { - let millis = SystemTime::now() - .duration_since(UNIX_EPOCH) - .unwrap_or_default() - .as_millis(); - // One stable id regardless of retries, so a prompt re-admitted on a new - // connection is recognized as the same message rather than a duplicate. - let prompt_message_id = format!("msg_{}_{}", millis, self.next_request_id()); - self.prompt_session_with( - session_id, - prompt_text, - PromptDelivery::FollowUp, - prompt_message_id, - event_tx, - ) - .await - } - - pub async fn prompt_session_with( + /// Owns a resumable subscription. The app cancels this task when switching threads. + /// Metadata is refreshed on sync commits; queue/entry/delta ordering stays on one channel. + pub async fn follow_thread( &self, - session_id: String, - prompt_text: String, - delivery: PromptDelivery, - prompt_message_id: String, - event_tx: mpsc::UnboundedSender, - ) -> Result<(), String> { - self.stream_prompt( - session_id, - None, - prompt_text, - delivery, - prompt_message_id, - true, - event_tx, - false, - ) - .await + address: ThreadRefPayload, + tx: mpsc::UnboundedSender, + generation: u64, + ) { + let mut cursor = SyncCursor::default(); + for attempt in 0..30 { + match self.sync_once(&address, &tx, generation, &mut cursor).await { + Ok(()) => return, + Err(error) => { + if tx.is_closed() { + return; + } + let _ = tx.send(AppEvent::rpc(RpcEvent::ThreadStream { + address: address.clone(), + generation, + event: if attempt == 29 { + StreamEvent::Failed(error) + } else { + StreamEvent::Disconnected + }, + })); + if attempt < 29 { + tokio::time::sleep(Duration::from_secs(1)).await; + } + } + } + } } - /// Keep observing the session across busy periods, until the caller cancels the task. - #[allow(dead_code)] - pub async fn watch_session_with( + async fn sync_once( &self, - session_id: String, - prompt_text: String, - delivery: PromptDelivery, - prompt_message_id: String, - event_tx: mpsc::UnboundedSender, + address: &ThreadRefPayload, + tx: &mpsc::UnboundedSender, + generation: u64, + cursor: &mut SyncCursor, ) -> Result<(), String> { - self.stream_prompt( - session_id, - None, - prompt_text, - delivery, - prompt_message_id, - true, - event_tx, - true, - ) + let (mut ws, _) = connect_async(&self.url).await.map_err(|e| e.to_string())?; + let send = |event| { + tx.send(AppEvent::rpc(RpcEvent::ThreadStream { + address: address.clone(), + generation, + event, + })) + .map_err(|_| "UI closed".to_string()) + }; + // A restarted/replaced server may have reused revisions. Verify its store before resuming. + if cursor.store_id.is_some() { + let info = self.verify_server().await?; + if cursor.store_id.as_deref() != Some(&info.store_id) { + cursor.rev = None; + cursor.store_id = None; + send(StreamEvent::Reset)?; + } + } + let id = self.next_request_id(); + let payload = ThreadSyncPayload { + session_id: address.session_id.clone(), + thread_id: address.thread_id.clone(), + after: cursor.rev, + budget: None, + }; + ws.send(Message::Text( + serde_json::to_string(&RpcRequest::new(id, "thread.sync", payload)) + .map_err(|e| e.to_string())? + + "\n", + )) .await - } - - /// Keep observing a session starting from `after` in `session.log` and optionally dispatching - /// an initial prompt. - pub async fn watch_session_from( - &self, - session_id: String, - after: Option, - initial_prompt: Option<(String, PromptDelivery, String)>, - initially_busy: bool, - event_tx: mpsc::UnboundedSender, - ) -> Result<(), String> { - let (prompt_text, delivery, prompt_message_id) = initial_prompt - .unwrap_or_else(|| (String::new(), PromptDelivery::FollowUp, String::new())); - let turn_active = !prompt_message_id.is_empty() || initially_busy; - self.stream_prompt( - session_id, - after, - prompt_text, - delivery, - prompt_message_id, - turn_active, - event_tx, - true, - ) + .map_err(|e| e.to_string())?; + let event_id = self.next_request_id(); + let subscription = EventSubscribePayload { + thread_id: Some(address.thread_id.clone()), + types: Some(vec![ + "session.tool.progress".into(), + "session.retry.scheduled".into(), + "session.retry.finished".into(), + "plugin.updated".into(), + ]), + }; + ws.send(Message::Text( + serde_json::to_string(&RpcRequest::new(event_id, "event.subscribe", subscription)) + .map_err(|e| e.to_string())? + + "\n", + )) .await - } - - /// Follow an existing session without dispatching a prompt, combining `session.log` (`after`, - /// `follow: true`) and `event.subscribe`. - pub async fn follow_session( - &self, - session_id: String, - after: Option, - initially_busy: bool, - event_tx: mpsc::UnboundedSender, - ) -> Result<(), String> { - self.watch_session_from(session_id, after, None, initially_busy, event_tx) - .await - } - - #[allow(clippy::too_many_arguments)] - async fn stream_prompt( - &self, - session_id: String, - after: Option, - prompt_text: String, - delivery: PromptDelivery, - prompt_message_id: String, - initially_busy: bool, - event_tx: mpsc::UnboundedSender, - keep_alive: bool, - ) -> Result<(), String> { - let mut prompt_dispatched = prompt_message_id.is_empty(); - let mut log_cursor = after; - let mut turn_active = initially_busy || !prompt_message_id.is_empty(); - let mut initial_prompt_settled = prompt_message_id.is_empty(); - let mut seen_durable_seqs = std::collections::HashSet::new(); - let mut attempt = 0u32; - - loop { - match self - .stream_session_once_with_cursor( - &session_id, - &prompt_text, - delivery, - &prompt_message_id, - &mut prompt_dispatched, - &mut log_cursor, - &mut turn_active, - &mut initial_prompt_settled, - &mut seen_durable_seqs, - attempt > 0, - keep_alive, - &event_tx, - ) - .await - { - Ok(true) => { - // Refresh session metadata so an auto-generated title from the first prompt - // reaches the UI, matching ACP's `session_info_update`. - if let Ok(info) = self.session_info(&session_id).await { - let _ = event_tx.send(StreamEvent::SessionCreated(info)); - } - return Ok(()); - } - Ok(false) => { - attempt += 1; - if attempt > RECONNECT_ATTEMPTS { - let _ = event_tx.send(StreamEvent::Failed(format!( - "Lost the connection to {} and could not reconnect", - self.url - ))); - return Ok(()); + .map_err(|e| e.to_string())?; + let mut metadata = tokio::task::JoinSet::new(); + send(StreamEvent::Reconnected)?; + while let Some(message) = ws.next().await { + match message.map_err(|e| e.to_string())? { + Message::Text(text) => { + for line in text.lines().filter(|s| !s.trim().is_empty()) { + match serde_json::from_str::(line) + .map_err(|e| e.to_string())? + { + ServerMessage::Chunk { request_id, values } + if as_request_id(&request_id) == Some(id) => + { + for value in values { + let item: ThreadItem = + serde_json::from_value(value).map_err(|e| e.to_string())?; + if let ThreadItem::Synced { store_id, rev, .. } = &item { + cursor.store_id = Some(store_id.clone()); + cursor.rev = Some(*rev); + } + let synced = match &item { + ThreadItem::Synced { rev, .. } => Some(*rev), + _ => None, + }; + send(StreamEvent::Item(item))?; + if let Some(rev) = synced { + // Do not block the delta stream on a metadata round trip. + let client = RpcClient::new(&self.url); + let address = address.clone(); + let tx = tx.clone(); + while metadata.try_join_next().is_some() {} + metadata.spawn(async move { + if let Ok(info) = + client.thread_info(address.clone()).await + { + let _ = tx.send(AppEvent::rpc( + RpcEvent::ThreadStream { + address, + generation, + event: StreamEvent::Info { + rev, + info: Box::new(info), + }, + }, + )); + } + }); + } + } + ws.send(Message::Text( + serde_json::to_string(&RpcAck::new(id)) + .map_err(|e| e.to_string())? + + "\n", + )) + .await + .map_err(|e| e.to_string())?; + } + ServerMessage::Chunk { request_id, values } + if as_request_id(&request_id) == Some(event_id) => + { + for value in values { + let envelope: EventEnvelope = + serde_json::from_value(value).map_err(|e| e.to_string())?; + send(StreamEvent::Event(envelope))?; + } + ws.send(Message::Text( + serde_json::to_string(&RpcAck::new(event_id)) + .map_err(|e| e.to_string())? + + "\n", + )) + .await + .map_err(|e| e.to_string())?; + } + ServerMessage::Exit { + request_id, + exit: ExitPayload::Failure { cause }, + } if as_request_id(&request_id) == Some(event_id) => { + return Err(format_cause(cause.as_ref())) + } + ServerMessage::Exit { request_id, exit } + if as_request_id(&request_id) == Some(id) => + { + return match exit { + ExitPayload::Failure { cause } => { + Err(format_cause(cause.as_ref())) + } + ExitPayload::Success { .. } => { + Err("Thread subscription ended".into()) + } + } + } + ServerMessage::Defect { defect } => { + return Err(format_cause(defect.as_ref())) + } + _ => {} + } } - let _ = event_tx.send(StreamEvent::Disconnected); - - sleep(RECONNECT_DELAY).await; - } - Err(message) => { - let _ = event_tx.send(StreamEvent::Failed(message)); - return Ok(()); } + Message::Ping(bytes) => ws + .send(Message::Pong(bytes)) + .await + .map_err(|e| e.to_string())?, + Message::Close(_) => break, + _ => {} } } - } - - /// One connection's worth of a prompt. `Ok(true)` means the turn ended; - /// `Ok(false)` means the socket dropped and the caller should retry. - #[allow(clippy::too_many_arguments, dead_code)] - async fn stream_session_once( - &self, - session_id: &str, - prompt_text: &str, - delivery: PromptDelivery, - prompt_message_id: &str, - prompt_dispatched: &mut bool, - is_retry: bool, - keep_alive: bool, - event_tx: &mpsc::UnboundedSender, - ) -> Result { - let mut log_cursor = None; - let mut turn_active = !prompt_message_id.is_empty(); - let mut initial_prompt_settled = prompt_message_id.is_empty(); - let mut seen_durable_seqs = std::collections::HashSet::new(); - self.stream_session_once_with_cursor( - session_id, - prompt_text, - delivery, - prompt_message_id, - prompt_dispatched, - &mut log_cursor, - &mut turn_active, - &mut initial_prompt_settled, - &mut seen_durable_seqs, - is_retry, - keep_alive, - event_tx, - ) - .await - } - - /// One connection's worth of a session stream, combining `event.subscribe`, `session.log` - /// (`follow: true`, `after: *log_cursor`), and on reconnect `session.message` + `session.wait` - /// reconciliation. - #[allow(clippy::too_many_arguments)] - async fn stream_session_once_with_cursor( - &self, - session_id: &str, - prompt_text: &str, - delivery: PromptDelivery, - prompt_message_id: &str, - prompt_dispatched: &mut bool, - log_cursor: &mut Option, - turn_active: &mut bool, - initial_prompt_settled: &mut bool, - seen_durable_seqs: &mut std::collections::HashSet, - is_retry: bool, - keep_alive: bool, - event_tx: &mpsc::UnboundedSender, - ) -> Result { - let (ws_stream, _) = match connect_async(&self.url).await { - Ok(stream) => stream, - // The server is not up yet: leave the retry to the reconnect loop. - Err(_) => return Ok(false), - }; - - let (mut write, mut read) = ws_stream.split(); - - // 1. Subscribe to events - let sub_id = self.next_request_id(); - let sub_req = RpcRequest::new(sub_id, "event.subscribe", serde_json::json!({})); - let mut sub_text = serde_json::to_string(&sub_req).map_err(|e| e.to_string())?; - sub_text.push('\n'); - write - .send(Message::Text(sub_text.into())) - .await - .map_err(|e| format!("Failed to subscribe to events: {}", e))?; - - let mut prompt_req_id: Option = None; - let mut log_req_id: Option = None; - let mut message_check_req_id: Option = None; - let mut wait_req_id: Option = None; - let mut completion_log_id: Option = None; - let mut pending_terminal: Option = None; - let mut log_synced = false; - // On a retry, the first matching event is proof the socket is back. - let mut reconnected = is_retry; - let mut notices = std::collections::HashSet::new(); - let mut seen_event_ids = std::collections::HashSet::new(); - - while let Some(msg_res) = read.next().await { - let msg = match msg_res { - Ok(m) => m, - // A read error is a dropped socket, not a dead turn: retry. - Err(_) => return Ok(false), - }; - - if let Message::Text(txt) = msg { - for line in txt.lines() { - let line = line.trim(); - if line.is_empty() { - continue; - } - - let parsed: ServerMessage = match serde_json::from_str(line) { - Ok(m) => m, - Err(_) => continue, - }; - - match parsed { - ServerMessage::Chunk { request_id, values } => { - let chunk_req_id = as_request_id(&request_id); - if let Some(id_num) = chunk_req_id { - let ack = RpcAck::new(id_num); - if let Ok(mut ack_json) = serde_json::to_string(&ack) { - ack_json.push('\n'); - let _ = write.send(Message::Text(ack_json.into())).await; - } - } - - let from_log = log_req_id.is_some() && chunk_req_id == log_req_id; - let from_completion_log = - completion_log_id.is_some() && chunk_req_id == completion_log_id; - if chunk_req_id != Some(sub_id) && !from_log && !from_completion_log { - continue; - } - for env in values { - if env.event_type == "server.connected" { - if reconnected { - reconnected = false; - let _ = event_tx.send(StreamEvent::Reconnected); - } - if !prompt_message_id.is_empty() && !*prompt_dispatched { - *prompt_dispatched = true; - *turn_active = true; - let prompt_id = self.next_request_id(); - prompt_req_id = Some(prompt_id); - let prompt_req = RpcRequest::new( - prompt_id, - "session.prompt", - PromptSessionPayload { - session_id: session_id.to_string(), - text: prompt_text.to_string(), - delivery: delivery.as_str(), - id: prompt_message_id.to_string(), - }, - ); - if let Ok(mut p_json) = serde_json::to_string(&prompt_req) { - p_json.push('\n'); - let _ = write.send(Message::Text(p_json)).await; - } - } else if is_retry { - if !prompt_message_id.is_empty() && !*initial_prompt_settled - { - // Reconcile whether `prompt_message_id` materialized - // into the conversation before the disconnect. - let msg_id = self.next_request_id(); - message_check_req_id = Some(msg_id); - let msg_req = RpcRequest::new( - msg_id, - "session.message", - SessionMessagePayload { - session_id: session_id.to_string(), - message_id: prompt_message_id.to_string(), - }, - ); - if let Ok(mut m_json) = serde_json::to_string(&msg_req) - { - m_json.push('\n'); - let _ = write.send(Message::Text(m_json)).await; - } - } else if *turn_active { - let wait_id = self.next_request_id(); - wait_req_id = Some(wait_id); - let wait_req = RpcRequest::new( - wait_id, - "session.wait", - SessionIdPayload { - session_id: session_id.to_string(), - }, - ); - if let Ok(mut w_json) = serde_json::to_string(&wait_req) - { - w_json.push('\n'); - let _ = write.send(Message::Text(w_json)).await; - } - } - } else if prompt_message_id.is_empty() && *turn_active { - let wait_id = self.next_request_id(); - wait_req_id = Some(wait_id); - let wait_req = RpcRequest::new( - wait_id, - "session.wait", - SessionIdPayload { - session_id: session_id.to_string(), - }, - ); - if let Ok(mut w_json) = serde_json::to_string(&wait_req) { - w_json.push('\n'); - let _ = write.send(Message::Text(w_json)).await; - } - } - - // Subscribe to durable `session.log` (replay after cursor + follow) - let log_id = self.next_request_id(); - log_req_id = Some(log_id); - let log_req = RpcRequest::new( - log_id, - "session.log", - SessionLogPayload { - session_id: session_id.to_string(), - after: *log_cursor, - follow: Some(true), - }, - ); - if let Ok(mut l_json) = serde_json::to_string(&log_req) { - l_json.push('\n'); - let _ = write.send(Message::Text(l_json)).await; - } - continue; - } - - if env.event_type == "log.synced" { - if (from_log || from_completion_log) - && env - .aggregate_id - .as_deref() - .is_none_or(|agg| agg == session_id) - { - if reconnected { - reconnected = false; - let _ = event_tx.send(StreamEvent::Reconnected); - } - advance_log_cursor(log_cursor, env.seq); - let _ = - event_tx.send(StreamEvent::LogSynced { seq: env.seq }); - if from_log { - log_synced = true; - if completion_log_id.is_none() { - if let Some(terminal) = pending_terminal.take() { - *turn_active = false; - *initial_prompt_settled = true; - let _ = event_tx.send(terminal); - if !keep_alive { - return Ok(true); - } - } - } - } - } - continue; - } - - let data = match &env.data { - Some(d) => d, - None => continue, - }; - - // Plugin failure notices can be process-wide or session-scoped, - // matching ACP's `Feed.notice`. - if env.event_type == "plugin.updated" { - let matches_session = data - .get("sessionId") - .and_then(|v| v.as_str()) - .is_none_or(|s| s == session_id); - if matches_session - && data.get("status").and_then(|v| v.as_str()) - == Some("failed") - { - if let Some(err) = - data.get("error").and_then(|v| v.as_str()) - { - if notices.insert(err.to_string()) { - let _ = event_tx - .send(StreamEvent::Notice(err.to_string())); - } - } - } - continue; - } - - // Verify sessionId matches (or sourceSessionId for fork notices) - let s_id = data.get("sessionId").and_then(|v| v.as_str()); - let source_id = - data.get("sourceSessionId").and_then(|v| v.as_str()); - let durable_agg = - env.durable.as_ref().map(|d| d.aggregate_id.as_str()); - let matches_session = s_id == Some(session_id) - || durable_agg == Some(session_id) - || (env.event_type == "session.next.forked" - && source_id == Some(session_id)); - if !matches_session { - continue; - } - - // The first real event on a retried socket proves the - // connection is back; the UI can stop showing reconnecting. - if reconnected { - reconnected = false; - let _ = event_tx.send(StreamEvent::Reconnected); - } - - if let Some(seq) = env.durable_seq() { - if durable_agg.is_none_or(|agg| agg == session_id) { - // Only ordered replay/follow may advance `after`. A live - // event can arrive ahead of unread replay on this socket. - if from_log || from_completion_log { - advance_log_cursor(log_cursor, Some(seq)); - } - if !seen_durable_seqs.insert(seq) { - continue; - } - } - } - if let Some(id) = env.id.as_ref().filter(|s| !s.is_empty()) { - if !seen_event_ids.insert(id.clone()) { - continue; - } - } - - // Both sources use the same decoder, so either copy recovers - // completed parts when deduplication chooses its winner. - let decoded = - decode_durable_session_events(env.event_type.as_str(), data); - - for stream_event in decoded { - if matches!( - stream_event, - StreamEvent::ExecutionStarted - | StreamEvent::PromptPromoted { .. } - | StreamEvent::TurnStarted - ) { - *turn_active = true; - } - let is_terminal = matches!( - stream_event, - StreamEvent::Succeeded - | StreamEvent::Failed(_) - | StreamEvent::Interrupted(_) - ); - if is_terminal - && (completion_log_id.is_some() - || (is_retry && !log_synced)) - { - pending_terminal = Some(stream_event); - continue; - } - if is_terminal { - *turn_active = false; - *initial_prompt_settled = true; - } - let _ = event_tx.send(stream_event); - if is_terminal && !keep_alive { - return Ok(true); - } - } - } - } - ServerMessage::Exit { request_id, exit } => { - let id = as_request_id(&request_id); - if message_check_req_id.is_some() && id == message_check_req_id { - message_check_req_id = None; - match exit { - ExitPayload::Success { value } => { - let found = parse_session_message(&value).unwrap_or(false); - if found { - let wait_id = self.next_request_id(); - wait_req_id = Some(wait_id); - let wait_req = RpcRequest::new( - wait_id, - "session.wait", - SessionIdPayload { - session_id: session_id.to_string(), - }, - ); - if let Ok(mut w_json) = serde_json::to_string(&wait_req) - { - w_json.push('\n'); - let _ = write.send(Message::Text(w_json)).await; - } - } else { - *turn_active = true; - let prompt_id = self.next_request_id(); - prompt_req_id = Some(prompt_id); - let prompt_req = RpcRequest::new( - prompt_id, - "session.prompt", - PromptSessionPayload { - session_id: session_id.to_string(), - text: prompt_text.to_string(), - delivery: delivery.as_str(), - id: prompt_message_id.to_string(), - }, - ); - if let Ok(mut p_json) = - serde_json::to_string(&prompt_req) - { - p_json.push('\n'); - let _ = write.send(Message::Text(p_json)).await; - } - } - } - ExitPayload::Failure { cause } => { - return Err(format_cause(cause.as_ref())); - } - } - } else if prompt_req_id.is_some() && id == prompt_req_id { - prompt_req_id = None; - if let ExitPayload::Failure { cause } = exit { - if is_retry && is_prompt_conflict(cause.as_ref()) { - let wait_id = self.next_request_id(); - wait_req_id = Some(wait_id); - let wait_req = RpcRequest::new( - wait_id, - "session.wait", - SessionIdPayload { - session_id: session_id.to_string(), - }, - ); - if let Ok(mut w_json) = serde_json::to_string(&wait_req) { - w_json.push('\n'); - let _ = write.send(Message::Text(w_json)).await; - } - } else { - return Err(format_cause(cause.as_ref())); - } - } - } else if wait_req_id.is_some() && id == wait_req_id { - wait_req_id = None; - match exit { - ExitPayload::Success { .. } => { - if *turn_active || pending_terminal.is_some() { - // `wait` and the follower run independently. Pin a - // replay AFTER idle so all committed output is drained - // before reporting completion, even if follow lags. - pending_terminal.get_or_insert(StreamEvent::Succeeded); - let drain_id = self.next_request_id(); - completion_log_id = Some(drain_id); - let req = RpcRequest::new( - drain_id, - "session.log", - SessionLogPayload { - session_id: session_id.to_string(), - after: *log_cursor, - follow: Some(false), - }, - ); - let mut text = serde_json::to_string(&req) - .map_err(|e| e.to_string())?; - text.push('\n'); - if write.send(Message::Text(text)).await.is_err() { - return Ok(false); - } - } - } - ExitPayload::Failure { cause } => { - return Err(format_cause(cause.as_ref())); - } - } - } else if completion_log_id.is_some() && id == completion_log_id { - match exit { - ExitPayload::Success { .. } => { - completion_log_id = None; - if let Some(terminal) = pending_terminal.take() { - *turn_active = false; - *initial_prompt_settled = true; - let _ = event_tx.send(terminal); - if !keep_alive { - return Ok(true); - } - } - } - ExitPayload::Failure { cause } => { - return Err(format_cause(cause.as_ref())) - } - } - } else if id == Some(sub_id) - || (log_req_id.is_some() && id == log_req_id) - { - if let ExitPayload::Failure { cause } = exit { - return Err(format_cause(cause.as_ref())); - } - } - } - ServerMessage::Defect { defect } => { - return Err(format_cause(defect.as_ref())); - } - _ => {} - } - } - } - } - - // The socket ended without a terminal event: the server went away mid-turn. - Ok(false) + Err("Thread connection closed".into()) } } fn as_request_id(value: &Value) -> Option { - match value { - Value::Number(n) => n.as_u64(), - Value::String(s) => s.parse::().ok(), - _ => None, - } -} - -fn parse_server_info(value: &Value) -> Result { - serde_json::from_value::(value.clone()) - .map_err(|e| format!("Invalid server.info response: {e}")) -} - -fn parse_session_info(value: &Value) -> Result { - serde_json::from_value::(value.clone()) - .map_err(|e| format!("Invalid session response: {e}")) -} - -fn parse_session_history(value: &Value) -> Result, String> { - serde_json::from_value::(value.clone()) - .map(|res| res.entries) - .map_err(|e| format!("Invalid session history response: {e}")) -} - -fn parse_model_list(value: &Value) -> Result { - serde_json::from_value::(value.clone()) - .map_err(|e| format!("Invalid model list response: {e}")) -} - -fn parse_session_message(value: &Value) -> Result { - serde_json::from_value::(value.clone()) - .map(|res| res.found) - .map_err(|e| format!("Invalid session.message response: {e}")) -} - -fn is_prompt_conflict(cause: Option<&Value>) -> bool { - let Some(cause) = cause else { - return false; - }; - match cause { - Value::Array(items) => items.iter().any(|item| is_prompt_conflict(Some(item))), - Value::Object(_) => { - if str_field(cause, "_tag") == Some("PromptConflictError") { - return true; - } - cause - .get("error") - .or_else(|| cause.get("failure")) - .is_some_and(|inner| is_prompt_conflict(Some(inner))) - } - _ => false, - } + value.as_u64().or_else(|| value.as_str()?.parse().ok()) } fn str_field<'a>(value: &'a Value, key: &str) -> Option<&'a str> { @@ -1840,1374 +1179,76 @@ fn format_tagged_error(tag: &str, err: &Value) -> String { } } -/// Decode one durable `session.log` event into its `StreamEvent`(s), including completed thinking -/// and text parts carried on `session.llm.ended` when live deltas were not observed. -pub fn decode_durable_session_events(event_type: &str, data: &Value) -> Vec { - if event_type == "session.llm.ended" { - let mut events = llm_ended_part_events(data); - if let Some(usage) = llm_ended_usage_event(data) { - events.push(usage); - } - return events; - } - decode_session_event(event_type, data).into_iter().collect() -} +#[cfg(test)] +mod tests { + use super::*; + use serde_json::json; + use std::time::{SystemTime, UNIX_EPOCH}; + #[test] + fn resolves_server_endpoint_from_env_or_service_json_or_default() { + let temp = std::env::temp_dir().join(format!( + "codework-tui-discovery-{}-{}", + std::process::id(), + SystemTime::now() + .duration_since(UNIX_EPOCH) + .unwrap_or_default() + .as_nanos() + )); + std::fs::create_dir_all(&temp).expect("temp dir"); -fn llm_ended_part_events(data: &Value) -> Vec { - let mut out = Vec::new(); - let Some(msg) = data.get("message") else { - return out; - }; - let message_id = data - .get("messageId") - .or_else(|| msg.get("messageId")) - .and_then(Value::as_str) - .unwrap_or_default() - .to_string(); - let Some(parts) = msg.get("parts").and_then(Value::as_array) else { - return out; - }; - for (part_index, part) in parts.iter().enumerate() { - match part.get("type").and_then(Value::as_str) { - Some("thinking") => { - if part.get("redacted").and_then(Value::as_bool) == Some(true) { - continue; - } - if let Some(thinking) = part - .get("thinking") - .and_then(Value::as_str) - .filter(|s| !s.is_empty()) - { - out.push(StreamEvent::ThinkingEnd { - message_id: message_id.clone(), - part_index, - content: thinking.to_string(), - }); - } - } - Some("text") => { - if let Some(text) = part - .get("text") - .and_then(Value::as_str) - .filter(|s| !s.is_empty()) - { - out.push(StreamEvent::TextEnd { - message_id: message_id.clone(), - part_index, - content: text.to_string(), - }); - } - } - _ => {} - } - } - out -} + // 1. No env, no service.json -> DEFAULT_SERVER_URL + let (url, reg) = resolve_server_endpoint(None, Some(&temp)); + assert_eq!(url, DEFAULT_SERVER_URL); + assert!(reg.is_none()); -/// Decode one session-scoped `EventEnvelope` payload into a `StreamEvent`. -pub fn decode_session_event(event_type: &str, data: &Value) -> Option { - match event_type { - "session.prompt.admitted" => Some(prompt_event(data, false)), - "session.prompt.promoted" => Some(prompt_event(data, true)), - "session.config.changed" => Some(config_changed_event(data)), - "session.next.forked" => Some(session_forked_event(data)), - "session.turn.started" => Some(StreamEvent::TurnStarted), - "session.turn.ended" => Some(turn_ended_event(data)), - "session.turn.aborted" => Some(turn_aborted_event(data)), - "session.retry.scheduled" => Some(retry_scheduled_event(data)), - "session.retry.finished" => Some(retry_finished_event(data)), - "session.llm.started" => Some(llm_started_event(data)), - "session.llm.failed" => Some(llm_failed_event(data)), - "session.llm.text.start" | "session.llm.text-start" => Some(text_start_event(data)), - "session.llm.text.delta" | "session.llm.text-delta" => text_delta_event(data), - "session.llm.text.end" | "session.llm.text-end" => Some(text_end_event(data)), - "session.llm.thinking.start" | "session.llm.thinking-start" => { - Some(thinking_start_event(data)) - } - "session.llm.thinking.delta" | "session.llm.thinking-delta" => thinking_delta_event(data), - "session.llm.thinking.end" | "session.llm.thinking-end" => Some(thinking_end_event(data)), - "session.tool.started" => Some(started_event(data)), - "session.tool.progress" => Some(progress_event(data)), - "session.tool.settled" => Some(settled_event(data)), - "session.llm.ended" => llm_ended_usage_event(data), - "session.execution.started" => Some(StreamEvent::ExecutionStarted), - "session.execution.succeeded" => Some(StreamEvent::Succeeded), - "session.execution.failed" => { - let err_msg = data - .get("error") - .map(|e| format_cause(Some(e))) - .filter(|msg| !msg.is_empty() && msg != "RPC request failed") - .unwrap_or_else(|| "Execution failed".to_string()); - Some(StreamEvent::Failed(err_msg)) - } - "session.execution.interrupted" => { - let reason = data - .get("reason") - .and_then(|v| v.as_str()) - .unwrap_or("Interrupted"); - Some(StreamEvent::Interrupted(reason.to_string())) - } - _ => None, - } -} + // 2. Write `/service.json` -> discovered when CODEWORK_RPC_SERVER is unset + let service_json = json!({ + "pid": 4242, + "version": "0.3.0", + "url": "ws://127.0.0.1:7533/rpc/v1", + "port": 7533 + }); + std::fs::write( + service_json_path(&temp), + serde_json::to_string(&service_json).expect("json"), + ) + .expect("write service.json"); -fn prompt_event(data: &Value, promoted: bool) -> StreamEvent { - let message_id = data - .get("messageId") - .and_then(Value::as_str) - .unwrap_or_default() - .to_string(); - let delivery = match data.get("delivery").and_then(Value::as_str) { - Some("followUp") => PromptDelivery::FollowUp, - _ => PromptDelivery::Steer, - }; - let prompt = data - .get("prompt") - .and_then(|p| { - if let Some(s) = p.as_str() { - return Some(s.to_string()); - } - p.get("parts").and_then(Value::as_array).map(|parts| { - parts - .iter() - .filter_map(|part| { - if part.get("type").and_then(Value::as_str) == Some("text") { - part.get("text").and_then(Value::as_str) - } else { - None - } - }) - .collect::>() - .join("\n\n") + let (url, reg) = resolve_server_endpoint(None, Some(&temp)); + assert_eq!(url, "ws://127.0.0.1:7533/rpc/v1"); + assert_eq!( + reg, + Some(ServiceRegistration { + pid: 4242, + version: "0.3.0".to_string(), + url: "ws://127.0.0.1:7533/rpc/v1".to_string(), + port: 7533, }) - }) - .or_else(|| data.get("text").and_then(Value::as_str).map(str::to_string)) - .unwrap_or_default(); - - if promoted { - StreamEvent::PromptPromoted { - message_id, - prompt, - delivery, - } - } else { - StreamEvent::PromptAdmitted { - message_id, - prompt, - delivery, - } - } -} - -fn config_changed_event(data: &Value) -> StreamEvent { - let model = data - .get("model") - .and_then(|m| serde_json::from_value::(m.clone()).ok()); - let thinking_level = data - .get("thinkingLevel") - .and_then(Value::as_str) - .map(str::to_string); - StreamEvent::ConfigChanged { - model, - thinking_level, - } -} - -fn session_forked_event(data: &Value) -> StreamEvent { - let session_id = data - .get("sessionId") - .and_then(Value::as_str) - .unwrap_or_default() - .to_string(); - let source_session_id = data - .get("sourceSessionId") - .and_then(Value::as_str) - .unwrap_or_default() - .to_string(); - let source_entry_id = data - .get("sourceEntryId") - .and_then(Value::as_str) - .unwrap_or_default() - .to_string(); - let base_seq = data.get("baseSeq").and_then(Value::as_u64).unwrap_or(0); - StreamEvent::SessionForked { - session_id, - source_session_id, - source_entry_id, - base_seq, - } -} + ); -fn turn_ended_event(data: &Value) -> StreamEvent { - let message_id = data - .get("messageId") - .and_then(Value::as_str) - .unwrap_or_default() - .to_string(); - StreamEvent::TurnEnded { message_id } -} + // 3. Explicit CODEWORK_RPC_SERVER matching service.json keeps the registration + let (url, reg) = resolve_server_endpoint(Some("ws://127.0.0.1:7533/rpc/v1"), Some(&temp)); + assert_eq!(url, "ws://127.0.0.1:7533/rpc/v1"); + assert!(reg.is_some()); -fn turn_aborted_event(data: &Value) -> StreamEvent { - let cause = data.get("cause"); - let reason = cause - .and_then(|c| c.get("_tag").and_then(Value::as_str).or_else(|| c.as_str())) - .unwrap_or("aborted") - .to_string(); - let message = cause - .and_then(|c| c.get("message")) - .and_then(Value::as_str) - .or_else(|| data.get("message").and_then(Value::as_str)) - .map(str::to_string); - StreamEvent::TurnAborted { reason, message } -} + // 4. Explicit CODEWORK_RPC_SERVER pointing elsewhere overrides service.json without + // pinning a mismatched local registration + let (url, reg) = resolve_server_endpoint(Some("ws://127.0.0.1:9999/rpc/v1"), Some(&temp)); + assert_eq!(url, "ws://127.0.0.1:9999/rpc/v1"); + assert!(reg.is_none()); -fn retry_scheduled_event(data: &Value) -> StreamEvent { - let attempt = data.get("attempt").and_then(Value::as_u64).unwrap_or(1); - let max_retries = data.get("maxRetries").and_then(Value::as_u64).unwrap_or(0); - let delay_ms = data.get("delayMs").and_then(Value::as_u64).unwrap_or(0); - let message = data - .get("message") - .and_then(Value::as_str) - .unwrap_or_default() - .to_string(); - StreamEvent::RetryScheduled { - attempt, - max_retries, - delay_ms, - message, - } -} + // 5. Home resolution expands `~` and defaults to `/.codework` + assert_eq!( + resolve_codework_home(None, Some(Path::new("/Users/prem"))), + Some(PathBuf::from("/Users/prem/.codework")) + ); + assert_eq!( + resolve_codework_home(Some("~/custom-cw"), Some(Path::new("/Users/prem"))), + Some(PathBuf::from("/Users/prem/custom-cw")) + ); -fn retry_finished_event(data: &Value) -> StreamEvent { - let attempt = data.get("attempt").and_then(Value::as_u64).unwrap_or(1); - let success = data - .get("success") - .and_then(Value::as_bool) - .unwrap_or(false); - let message = data - .get("message") - .and_then(Value::as_str) - .map(str::to_string); - StreamEvent::RetryFinished { - attempt, - success, - message, + let _ = std::fs::remove_dir_all(&temp); } -} - -fn llm_started_event(data: &Value) -> StreamEvent { - let message_id = data - .get("messageId") - .and_then(Value::as_str) - .unwrap_or_default() - .to_string(); - let model = data - .get("message") - .and_then(|m| m.get("responseModel").or_else(|| m.get("model"))) - .and_then(Value::as_str) - .map(str::to_string); - StreamEvent::LlmStarted { message_id, model } -} - -fn llm_failed_event(data: &Value) -> StreamEvent { - let message_id = data - .get("messageId") - .and_then(Value::as_str) - .unwrap_or_default() - .to_string(); - let reason = data - .get("reason") - .and_then(Value::as_str) - .unwrap_or("error") - .to_string(); - let error = data - .get("message") - .and_then(|m| m.get("errorMessage").or_else(|| m.get("message"))) - .and_then(Value::as_str) - .or_else(|| data.get("error").and_then(Value::as_str)) - .map(str::to_string); - StreamEvent::LlmFailed { - message_id, - reason, - error, - } -} - -fn text_start_event(data: &Value) -> StreamEvent { - let message_id = data - .get("messageId") - .and_then(Value::as_str) - .unwrap_or_default() - .to_string(); - let part_index = data.get("partIndex").and_then(Value::as_u64).unwrap_or(0) as usize; - StreamEvent::TextStart { - message_id, - part_index, - } -} - -fn text_delta_event(data: &Value) -> Option { - let delta = data.get("delta").and_then(Value::as_str)?.to_string(); - let message_id = data - .get("messageId") - .and_then(Value::as_str) - .map(str::to_string); - let part_index = data - .get("partIndex") - .and_then(Value::as_u64) - .map(|i| i as usize); - Some(StreamEvent::TextDelta { - message_id, - part_index, - delta, - }) -} - -fn text_end_event(data: &Value) -> StreamEvent { - let message_id = data - .get("messageId") - .and_then(Value::as_str) - .unwrap_or_default() - .to_string(); - let part_index = data.get("partIndex").and_then(Value::as_u64).unwrap_or(0) as usize; - let content = data - .get("content") - .and_then(Value::as_str) - .unwrap_or_default() - .to_string(); - StreamEvent::TextEnd { - message_id, - part_index, - content, - } -} - -fn thinking_start_event(data: &Value) -> StreamEvent { - let message_id = data - .get("messageId") - .and_then(Value::as_str) - .unwrap_or_default() - .to_string(); - let part_index = data.get("partIndex").and_then(Value::as_u64).unwrap_or(0) as usize; - StreamEvent::ThinkingStart { - message_id, - part_index, - } -} - -fn thinking_delta_event(data: &Value) -> Option { - let delta = data.get("delta").and_then(Value::as_str)?.to_string(); - let message_id = data - .get("messageId") - .and_then(Value::as_str) - .map(str::to_string); - let part_index = data - .get("partIndex") - .and_then(Value::as_u64) - .map(|i| i as usize); - Some(StreamEvent::ThinkingDelta { - message_id, - part_index, - delta, - }) -} - -fn thinking_end_event(data: &Value) -> StreamEvent { - let message_id = data - .get("messageId") - .and_then(Value::as_str) - .unwrap_or_default() - .to_string(); - let part_index = data.get("partIndex").and_then(Value::as_u64).unwrap_or(0) as usize; - let content = data - .get("content") - .and_then(Value::as_str) - .unwrap_or_default() - .to_string(); - StreamEvent::ThinkingEnd { - message_id, - part_index, - content, - } -} - -fn llm_ended_usage_event(data: &Value) -> Option { - let msg = data.get("message")?; - let usage = msg.get("usage")?; - let total_tokens = usage - .get("totalTokens") - .and_then(|v| v.as_u64()) - .unwrap_or(0); - let input_tokens = usage.get("input").and_then(|v| v.as_u64()).unwrap_or(0); - let output_tokens = usage.get("output").and_then(|v| v.as_u64()).unwrap_or(0); - let cost = usage - .get("cost") - .and_then(|c| c.get("total")) - .and_then(|v| v.as_f64()) - .unwrap_or(0.0); - let model = msg - .get("responseModel") - .or_else(|| msg.get("model")) - .and_then(|v| v.as_str()) - .map(|s| s.to_string()); - - Some(StreamEvent::Usage(UsageReport { - total_tokens, - input_tokens, - output_tokens, - cost, - model, - })) -} - -/// Reads a `session.tool.started` payload. Every field is best-effort: a missing -/// or malformed one yields a plain `tool` line rather than an error. -fn started_event(data: &Value) -> StreamEvent { - let call_id = data - .get("callID") - .and_then(|v| v.as_str()) - .unwrap_or("tool") - .to_string(); - let name = data - .get("name") - .and_then(|v| v.as_str()) - .unwrap_or("tool") - .to_string(); - let label = data - .get("label") - .and_then(|v| v.as_str()) - .map(str::to_string); - let arguments = data.get("arguments").cloned().unwrap_or(Value::Null); - StreamEvent::ToolStarted { - call_id, - name, - label, - arguments, - } -} - -/// Reads a `session.tool.progress` payload (`{ callID, partial: { content, details } }`). -fn progress_event(data: &Value) -> StreamEvent { - let call_id = data - .get("callID") - .and_then(|v| v.as_str()) - .unwrap_or("tool") - .to_string(); - let partial = data.get("partial"); - let output = partial - .and_then(|p| { - if let Some(s) = p.as_str() { - return Some(s.to_string()); - } - if let Some(blocks) = p.get("content").and_then(Value::as_array) { - let text = blocks - .iter() - .filter_map(|block| { - if block.get("type").and_then(Value::as_str) == Some("text") { - block.get("text").and_then(Value::as_str) - } else { - None - } - }) - .collect::>() - .join("\n"); - return Some(text); - } - p.get("output").and_then(Value::as_str).map(str::to_string) - }) - .filter(|text| !text.is_empty()); - let details = partial.and_then(|p| p.get("details")).cloned(); - StreamEvent::ToolProgress { - call_id, - output, - details, - } -} - -/// Reads a `session.tool.settled` payload. The terminal `part` carries both the -/// call's `arguments` and its `result.details`, whose shape is the tool's own -/// (the `edit` tool's `patch` and `firstChangedLine`, a `read`'s line window, a -/// `bash`'s `exitCode`), so it is carried through opaquely. -fn settled_event(data: &Value) -> StreamEvent { - let call_id = data - .get("callID") - .and_then(|v| v.as_str()) - .unwrap_or("tool") - .to_string(); - let part = data.get("part"); - let name = part - .and_then(|p| p.get("name")) - .and_then(|v| v.as_str()) - .map(str::to_string); - let arguments = part - .and_then(|p| p.get("arguments")) - .cloned() - .unwrap_or(Value::Null); - let result = part.and_then(|p| p.get("result")); - let is_error = result - .and_then(|r| r.get("isError")) - .and_then(|v| v.as_bool()) - .unwrap_or(false); - let output = result - .and_then(|r| r.get("content")) - .and_then(|c| c.as_array()) - .map(|blocks| { - blocks - .iter() - .filter_map(|block| { - if block.get("type").and_then(|v| v.as_str()) == Some("text") { - block.get("text").and_then(|v| v.as_str()) - } else { - None - } - }) - .collect::>() - .join("\n") - }) - .filter(|text| !text.is_empty()); - let details = result.and_then(|r| r.get("details")).cloned(); - StreamEvent::ToolSettled { - call_id, - name, - is_error, - arguments, - output, - details, - } -} - -#[cfg(test)] -mod tests { - use super::*; - use serde_json::json; - - type TestSocket = tokio_tungstenite::WebSocketStream; - - async fn request(ws: &mut TestSocket, tag: &str) -> Value { - while let Some(message) = ws.next().await { - if let Message::Text(text) = message.unwrap() { - let value: Value = serde_json::from_str(text.trim()).unwrap(); - if value["tag"] == tag { - return value; - } - } - } - panic!("expected {tag}"); - } - - async fn chunk(ws: &mut TestSocket, id: &Value, values: Value) { - let value = json!({"_tag": "Chunk", "requestId": id, "values": values}); - ws.send(Message::Text(format!("{value}\n"))).await.unwrap(); - } - - async fn success(ws: &mut TestSocket, id: &Value, value: Value) { - let reply = json!({"_tag": "Exit", "requestId": id, - "exit": {"_tag": "Success", "value": value}}); - ws.send(Message::Text(format!("{reply}\n"))).await.unwrap(); - } - - #[tokio::test] - async fn live_events_do_not_skip_unread_log_or_suppress_completed_parts() { - tokio::time::timeout(Duration::from_secs(5), async { - let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap(); - let client = RpcClient::new(format!("ws://{}", listener.local_addr().unwrap())); - let server = tokio::spawn(async move { - let ended = json!({"id": "end", "type": "session.llm.ended", - "durable": {"aggregateId": "ses", "seq": 20, "version": 1}, - "data": {"sessionId": "ses", "messageId": "answer", "message": { - "parts": [{"type": "text", "text": "Recovered answer"}], - "usage": {"totalTokens": 3, "input": 1, "output": 2} - }}}); - for after in [10, 11] { - let (socket, _) = listener.accept().await.unwrap(); - let mut ws = tokio_tungstenite::accept_async(socket).await.unwrap(); - let sub = request(&mut ws, "event.subscribe").await; - chunk(&mut ws, &sub["id"], json!([{ "type": "server.connected" }])).await; - let log = request(&mut ws, "session.log").await; - assert_eq!(log["payload"]["after"], after); - if after == 10 { - // The live head arrives before the ordered replay catches up. - chunk(&mut ws, &sub["id"], json!([ended])).await; - chunk( - &mut ws, - &log["id"], - json!([{ - "type": "session.config.changed", - "durable": {"aggregateId": "ses", "seq": 11, "version": 1}, - "data": {"sessionId": "ses", "thinkingLevel": "low"} - }]), - ) - .await; - } else { - chunk( - &mut ws, - &log["id"], - json!([{ - "type": "session.config.changed", - "durable": {"aggregateId": "ses", "seq": 12, "version": 1}, - "data": {"sessionId": "ses", "thinkingLevel": "high"} - }, ended, {"type": "log.synced", "aggregateId": "ses", "seq": 20}]), - ) - .await; - } - ws.close(None).await.unwrap(); - } - }); - let (tx, mut rx) = mpsc::unbounded_channel(); - let mut cursor = Some(10); - let mut seen = std::collections::HashSet::new(); - for retry in [false, true] { - assert!(!client - .stream_session_once_with_cursor( - "ses", - "", - PromptDelivery::FollowUp, - "", - &mut true, - &mut cursor, - &mut false, - &mut true, - &mut seen, - retry, - true, - &tx - ) - .await - .unwrap()); - if !retry { - assert_eq!(cursor, Some(11)); - } - } - assert_eq!(cursor, Some(20)); - let mut events = Vec::new(); - while let Ok(event) = rx.try_recv() { - events.push(event); - } - assert_eq!( - events - .iter() - .filter(|e| matches!(e, StreamEvent::TextEnd { content, .. } - if content == "Recovered answer")) - .count(), - 1 - ); - assert_eq!( - events - .iter() - .filter(|e| matches!(e, StreamEvent::Usage(_))) - .count(), - 1 - ); - assert!(events.contains(&StreamEvent::ConfigChanged { - model: None, - thinking_level: Some("high".into()) - })); - server.await.unwrap(); - }) - .await - .expect("ordered replay recovery"); - } - - #[tokio::test] - async fn idle_reconciliation_drains_output_before_completing() { - // Exercise wait before initial replay, and wait after the initial replay marker. - for synced_first in [false, true] { - tokio::time::timeout(Duration::from_secs(5), async { - let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap(); - let client = RpcClient::new(format!("ws://{}", listener.local_addr().unwrap())); - let server = tokio::spawn(async move { - let (socket, _) = listener.accept().await.unwrap(); - let mut ws = tokio_tungstenite::accept_async(socket).await.unwrap(); - let sub = request(&mut ws, "event.subscribe").await; - chunk(&mut ws, &sub["id"], json!([{ "type": "server.connected" }])).await; - let check = request(&mut ws, "session.message").await; - let log = request(&mut ws, "session.log").await; - if synced_first { - chunk( - &mut ws, - &log["id"], - json!([{"type": "log.synced", "aggregateId": "ses", "seq": 1}]), - ) - .await; - } - success(&mut ws, &check["id"], json!({"found": true})).await; - let wait = request(&mut ws, "session.wait").await; - success(&mut ws, &wait["id"], Value::Null).await; - // Idle doesn't mean the independent log stream has delivered its tail. - let drain = request(&mut ws, "session.log").await; - assert_eq!(drain["payload"]["follow"], false); - assert_eq!(drain["payload"]["after"], 1); - chunk( - &mut ws, - &drain["id"], - json!([{ - "id": "end", "type": "session.llm.ended", - "durable": {"aggregateId": "ses", "seq": 2, "version": 1}, - "data": {"sessionId": "ses", "messageId": "answer", "message": { - "parts": [{"type": "text", "text": "Offline output"}]}} - }, {"type": "log.synced", "aggregateId": "ses", "seq": 2}]), - ) - .await; - success(&mut ws, &drain["id"], Value::Null).await; - }); - let (tx, mut rx) = mpsc::unbounded_channel(); - assert!(client - .stream_session_once_with_cursor( - "ses", - "prompt", - PromptDelivery::FollowUp, - "prompt", - &mut true, - &mut Some(1), - &mut true, - &mut false, - &mut std::collections::HashSet::new(), - true, - false, - &tx - ) - .await - .unwrap()); - let mut events = Vec::new(); - while let Ok(event) = rx.try_recv() { - events.push(event); - } - let output = events - .iter() - .position(|e| { - matches!(e, StreamEvent::TextEnd {content, ..} - if content == "Offline output") - }) - .expect("recovered output"); - let terminal = events - .iter() - .position(|e| *e == StreamEvent::Succeeded) - .expect("completion"); - assert!(output < terminal); - server.await.unwrap(); - }) - .await - .expect("completion replay barrier"); - } - } - - #[test] - fn parses_a_started_call_with_its_arguments() { - let data = json!({ - "sessionId": "ses_1", - "messageId": "msg_1", - "callID": "call_1", - "name": "bash", - "label": "bash", - "arguments": { "command": "npm test", "timeout": 30 }, - }); - match started_event(&data) { - StreamEvent::ToolStarted { - call_id, - name, - label, - arguments, - } => { - assert_eq!(call_id, "call_1"); - assert_eq!(name, "bash"); - assert_eq!(label.as_deref(), Some("bash")); - assert_eq!( - arguments.get("command").and_then(Value::as_str), - Some("npm test") - ); - } - other => panic!("expected ToolStarted, got {other:?}"), - } - } - - #[test] - fn parses_a_settled_call_with_its_result_details() { - let data = json!({ - "sessionId": "ses_1", - "messageId": "msg_1", - "callID": "call_1", - "part": { - "type": "toolCall", - "callID": "call_1", - "name": "edit", - "arguments": { "path": "src/a.ts", "edits": [] }, - "status": "completed", - "time": { "start": 1, "end": 2 }, - "result": { - "content": [{ "type": "text", "text": "edited" }], - "isError": false, - "details": { "patch": "--- src/a.ts", "path": "src/a.ts", "firstChangedLine": 3 }, - }, - }, - }); - match settled_event(&data) { - StreamEvent::ToolSettled { - call_id, - name, - is_error, - arguments, - output, - details, - } => { - assert_eq!(call_id, "call_1"); - assert_eq!(name.as_deref(), Some("edit")); - assert!(!is_error); - assert_eq!(output.as_deref(), Some("edited")); - // The arguments ride on the terminal part, so a settled call is titled - // from them even when no started event arrived. - assert_eq!( - arguments.get("path").and_then(Value::as_str), - Some("src/a.ts") - ); - let details = details.expect("details"); - assert_eq!( - details.get("patch").and_then(Value::as_str), - Some("--- src/a.ts") - ); - assert_eq!( - details.get("firstChangedLine").and_then(Value::as_u64), - Some(3) - ); - } - other => panic!("expected ToolSettled, got {other:?}"), - } - } - - #[test] - fn parses_an_error_settlement() { - let data = json!({ - "callID": "call_2", - "part": { - "name": "bash", - "arguments": { "command": "false" }, - "status": "error", - "result": { - "content": [{ "type": "text", "text": "boom" }], - "isError": true, - "details": { "output": "boom", "truncated": false, "exitCode": 1 }, - }, - }, - }); - match settled_event(&data) { - StreamEvent::ToolSettled { - is_error, details, .. - } => { - assert!(is_error); - assert_eq!( - details.and_then(|d| d.get("exitCode").and_then(Value::as_u64)), - Some(1) - ); - } - other => panic!("expected ToolSettled, got {other:?}"), - } - } - - #[test] - fn parses_a_bare_payload_without_arguments_or_details() { - // A plugin tool, or an older server: nothing to read, nothing to fail on. - match started_event(&json!({ "callID": "c", "name": "acme_echo" })) { - StreamEvent::ToolStarted { - arguments, label, .. - } => { - assert!(arguments.is_null()); - assert!(label.is_none()); - } - other => panic!("expected ToolStarted, got {other:?}"), - } - - let settled = json!({ - "callID": "c", - "part": { "name": "acme_echo", "status": "completed" }, - }); - match settled_event(&settled) { - StreamEvent::ToolSettled { - arguments, - output, - details, - is_error, - name, - .. - } => { - assert!(arguments.is_null()); - assert!(output.is_none()); - assert!(details.is_none()); - assert!(!is_error); - assert_eq!(name.as_deref(), Some("acme_echo")); - } - other => panic!("expected ToolSettled, got {other:?}"), - } - } - - #[test] - fn parses_full_session_info_metadata() { - let payload = json!({ - "id": "ses_abc", - "title": "Refactor TUI", - "directory": "/workspace/codework", - "hostDir": "/Users/prem/codework", - "updatedAt": 1_760_614_701_143u64, - "project": { - "id": "prj_1", - "name": "codework" - }, - "model": { - "provider": "anthropic", - "id": "claude-sonnet-4-5" - }, - "sandbox": { - "id": "sbx_1", - "driver": "memory", - "kind": "virtual", - "providerResourceId": null, - "ownership": "managed", - "status": "online", - "usage": "busy", - "refCount": 2, - "createdAt": "2026-10-16T11:00:00.000Z", - "updatedAt": "2026-10-16T11:30:00.000Z" - } - }); - - let info = parse_session_info(&payload).expect("valid SessionInfo"); - assert_eq!(info.id, "ses_abc"); - assert_eq!(info.title, "Refactor TUI"); - assert_eq!(info.directory, "/workspace/codework"); - assert_eq!(info.host_dir.as_deref(), Some("/Users/prem/codework")); - assert_eq!(info.updated_at, 1_760_614_701_143); - let project = info.project.expect("project"); - assert_eq!(project.id, "prj_1"); - assert_eq!(project.name, "codework"); - let model = info.model.expect("model"); - assert_eq!(model.provider, "anthropic"); - assert_eq!(model.id, "claude-sonnet-4-5"); - let sandbox = info.sandbox.expect("sandbox"); - assert_eq!(sandbox.id, "sbx_1"); - assert_eq!(sandbox.driver, "memory"); - assert_eq!(sandbox.kind, "virtual"); - assert_eq!(sandbox.provider_resource_id, None); - assert_eq!(sandbox.ownership, "managed"); - assert_eq!(sandbox.status, "online"); - assert_eq!(sandbox.usage, "busy"); - assert_eq!(sandbox.ref_count, 2); - } - - #[test] - fn parses_session_history_entries_and_parts() { - use crate::types::{Part, ToolResultContent, ToolTime}; - - let payload = json!({ - "entries": [ - { - "id": "msg_u1", - "seq": 1, - "role": "user", - "state": "committed", - "createdAt": 1_760_614_700_000u64, - "parts": [ - { "type": "text", "text": "Inspect Cargo.toml" }, - { "type": "image", "data": "aGVsbG8=", "mimeType": "image/png" } - ] - }, - { - "id": "msg_a1", - "seq": 2, - "role": "assistant", - "state": "committed", - "createdAt": 1_760_614_701_000u64, - "parts": [ - { "type": "thinking", "thinking": "Reading Cargo.toml first." }, - { - "type": "toolCall", - "callID": "call_read_1", - "name": "read", - "arguments": { "path": "packages/tui/Cargo.toml" }, - "status": "completed", - "result": { - "content": [{ "type": "text", "text": "[package]\nname = \"codework-tui\"" }], - "isError": false - }, - "time": { "start": 100, "end": 150 } - }, - { "type": "text", "text": "Here is the package manifest." } - ] - } - ] - }); - - let entries = parse_session_history(&payload).expect("valid history"); - assert_eq!(entries.len(), 2); - assert_eq!(entries[0].id, "msg_u1"); - assert_eq!(entries[0].role, "user"); - assert_eq!(entries[0].state, "committed"); - assert_eq!(entries[0].parts.len(), 2); - assert_eq!( - entries[0].parts[1], - Part::Image { - data: "aGVsbG8=".to_string(), - mime_type: "image/png".to_string(), - } - ); - - assert_eq!(entries[1].id, "msg_a1"); - assert_eq!(entries[1].role, "assistant"); - assert_eq!(entries[1].parts.len(), 3); - match &entries[1].parts[1] { - Part::ToolCall { - call_id, - name, - status, - result, - time, - .. - } => { - assert_eq!(call_id, "call_read_1"); - assert_eq!(name, "read"); - assert_eq!(status, "completed"); - assert_eq!( - time, - &Some(ToolTime { - start: 100, - end: 150 - }) - ); - let result = result.as_ref().expect("result"); - assert!(!result.is_error); - assert_eq!( - result.content, - vec![ToolResultContent::Text { - text: "[package]\nname = \"codework-tui\"".to_string(), - }] - ); - } - other => panic!("expected ToolCall part, got {other:?}"), - } - } - - #[tokio::test] - async fn session_history_round_trips_over_websocket() { - use tokio::net::TcpListener; - use tokio_tungstenite::accept_async; - - let listener = TcpListener::bind("127.0.0.1:0").await.expect("bind"); - let addr = listener.local_addr().expect("addr"); - - let server = tokio::spawn(async move { - let (stream, _) = listener.accept().await.expect("accept"); - let mut ws = accept_async(stream).await.expect("ws handshake"); - let Some(Ok(Message::Text(req_text))) = ws.next().await else { - panic!("expected text request"); - }; - let req: Value = serde_json::from_str(req_text.trim()).expect("json request"); - assert_eq!( - req.get("tag").and_then(Value::as_str), - Some("session.history") - ); - assert_eq!( - req.get("payload") - .and_then(|p| p.get("sessionId")) - .and_then(Value::as_str), - Some("ses_42") - ); - let req_id = req.get("id").cloned().unwrap_or(json!(1)); - let reply = json!({ - "_tag": "Exit", - "requestId": req_id, - "exit": { - "_tag": "Success", - "value": { - "entries": [ - { - "id": "msg_1", - "seq": 1, - "role": "user", - "state": "committed", - "createdAt": 1000, - "parts": [{ "type": "text", "text": "hello" }] - } - ] - } - } - }); - ws.send(Message::Text(format!("{reply}\n").into())) - .await - .expect("send reply"); - }); - - let client = RpcClient::new(format!("ws://{addr}/rpc/v1")); - let entries = client.session_history("ses_42").await.expect("history"); - assert_eq!(entries.len(), 1); - assert_eq!(entries[0].id, "msg_1"); - assert_eq!(entries[0].role, "user"); - server.await.expect("server task"); - } - - #[test] - fn parses_model_list_response() { - let payload = json!({ - "providers": [ - { - "id": "anthropic", - "name": "Anthropic", - "models": [ - { - "id": "claude-sonnet-4-5", - "name": "Claude Sonnet 4.5", - "thinkingLevels": ["off", "low", "medium", "high"] - } - ] - } - ], - "default": { - "provider": "openai", - "id": "gpt-5.6-luna", - "thinkingLevel": "medium", - "name": "GPT-5.6 Luna", - "providerName": "OpenAI" - } - }); - - let list = parse_model_list(&payload).expect("valid ModelList"); - assert_eq!(list.providers.len(), 1); - assert_eq!(list.providers[0].id, "anthropic"); - assert_eq!(list.providers[0].name, "Anthropic"); - assert_eq!(list.providers[0].models.len(), 1); - assert_eq!(list.providers[0].models[0].id, "claude-sonnet-4-5"); - assert_eq!(list.providers[0].models[0].name, "Claude Sonnet 4.5"); - assert_eq!( - list.providers[0].models[0].thinking_levels, - vec!["off", "low", "medium", "high"] - ); - assert_eq!(list.default.provider, "openai"); - assert_eq!(list.default.id, "gpt-5.6-luna"); - assert_eq!(list.default.thinking_level, "medium"); - assert_eq!(list.default.name.as_deref(), Some("GPT-5.6 Luna")); - assert_eq!(list.default.provider_name.as_deref(), Some("OpenAI")); - } - - #[tokio::test] - async fn model_list_round_trips_over_websocket() { - use tokio::net::TcpListener; - use tokio_tungstenite::accept_async; - - let listener = TcpListener::bind("127.0.0.1:0").await.expect("bind"); - let addr = listener.local_addr().expect("addr"); - - let server = tokio::spawn(async move { - for expected_dir in [Some("/Users/prem/codework"), None] { - let (stream, _) = listener.accept().await.expect("accept"); - let mut ws = accept_async(stream).await.expect("ws handshake"); - let Some(Ok(Message::Text(req_text))) = ws.next().await else { - panic!("expected text request"); - }; - let req: Value = serde_json::from_str(req_text.trim()).expect("json request"); - assert_eq!(req.get("tag").and_then(Value::as_str), Some("model.list")); - let payload = req.get("payload").expect("payload"); - assert_eq!(payload.get("hostDir").and_then(Value::as_str), expected_dir); - if expected_dir.is_none() { - assert!(payload.get("hostDir").is_none()); - } - let req_id = req.get("id").cloned().unwrap_or(json!(1)); - let reply = json!({ - "_tag": "Exit", - "requestId": req_id, - "exit": { - "_tag": "Success", - "value": { - "providers": [ - { - "id": "local", - "name": "Local", - "models": [ - { - "id": "qwen3-coder:30b", - "name": "Qwen3 Coder 30B", - "thinkingLevels": ["off"] - } - ] - } - ], - "default": { - "provider": "local", - "id": "qwen3-coder:30b", - "thinkingLevel": "medium", - "name": "Qwen3 Coder 30B", - "providerName": "Local" - } - } - } - }); - ws.send(Message::Text(format!("{reply}\n"))) - .await - .expect("send reply"); - } - }); - - let client = RpcClient::new(format!("ws://{addr}/rpc/v1")); - let anchored = client - .list_models(Some("/Users/prem/codework")) - .await - .expect("anchored models"); - assert_eq!(anchored.default.provider, "local"); - assert_eq!(anchored.default.id, "qwen3-coder:30b"); - - let unanchored = client.list_models(None).await.expect("unanchored models"); - assert_eq!(unanchored.providers.len(), 1); - assert_eq!(unanchored.providers[0].models[0].id, "qwen3-coder:30b"); - server.await.expect("server task"); - } - - #[test] - fn resolves_server_endpoint_from_env_or_service_json_or_default() { - let temp = std::env::temp_dir().join(format!( - "codework-tui-discovery-{}-{}", - std::process::id(), - SystemTime::now() - .duration_since(UNIX_EPOCH) - .unwrap_or_default() - .as_nanos() - )); - std::fs::create_dir_all(&temp).expect("temp dir"); - - // 1. No env, no service.json -> DEFAULT_SERVER_URL - let (url, reg) = resolve_server_endpoint(None, Some(&temp)); - assert_eq!(url, DEFAULT_SERVER_URL); - assert!(reg.is_none()); - - // 2. Write `/service.json` -> discovered when CODEWORK_RPC_SERVER is unset - let service_json = json!({ - "pid": 4242, - "version": "0.3.0", - "url": "ws://127.0.0.1:7533/rpc/v1", - "port": 7533 - }); - std::fs::write( - service_json_path(&temp), - serde_json::to_string(&service_json).expect("json"), - ) - .expect("write service.json"); - - let (url, reg) = resolve_server_endpoint(None, Some(&temp)); - assert_eq!(url, "ws://127.0.0.1:7533/rpc/v1"); - assert_eq!( - reg, - Some(ServiceRegistration { - pid: 4242, - version: "0.3.0".to_string(), - url: "ws://127.0.0.1:7533/rpc/v1".to_string(), - port: 7533, - }) - ); - - // 3. Explicit CODEWORK_RPC_SERVER matching service.json keeps the registration - let (url, reg) = resolve_server_endpoint(Some("ws://127.0.0.1:7533/rpc/v1"), Some(&temp)); - assert_eq!(url, "ws://127.0.0.1:7533/rpc/v1"); - assert!(reg.is_some()); - - // 4. Explicit CODEWORK_RPC_SERVER pointing elsewhere overrides service.json without - // pinning a mismatched local registration - let (url, reg) = resolve_server_endpoint(Some("ws://127.0.0.1:9999/rpc/v1"), Some(&temp)); - assert_eq!(url, "ws://127.0.0.1:9999/rpc/v1"); - assert!(reg.is_none()); - - // 5. Home resolution expands `~` and defaults to `/.codework` - assert_eq!( - resolve_codework_home(None, Some(Path::new("/Users/prem"))), - Some(PathBuf::from("/Users/prem/.codework")) - ); - assert_eq!( - resolve_codework_home(Some("~/custom-cw"), Some(Path::new("/Users/prem"))), - Some(PathBuf::from("/Users/prem/custom-cw")) - ); - - let _ = std::fs::remove_dir_all(&temp); - } - - #[tokio::test] - async fn server_info_and_verify_server_confirm_identity_and_reject_mismatches() { - use tokio::net::TcpListener; - use tokio_tungstenite::accept_async; - - let listener = TcpListener::bind("127.0.0.1:0").await.expect("bind"); - let addr = listener.local_addr().expect("addr"); - let url = format!("ws://{addr}/rpc/v1"); - - let server = tokio::spawn(async move { - let responses = [ - (4242u64, "0.3.0"), - (9999u64, "0.3.0"), - (4242u64, "0.2.0"), - (9999u64, "0.2.0"), - ]; - for (pid, version) in responses { - let (stream, _) = listener.accept().await.expect("accept"); - let mut ws = accept_async(stream).await.expect("ws handshake"); - let Some(Ok(Message::Text(req_text))) = ws.next().await else { - panic!("expected text request"); - }; - let req: Value = serde_json::from_str(req_text.trim()).expect("json request"); - assert_eq!(req.get("tag").and_then(Value::as_str), Some("server.info")); - let req_id = req.get("id").cloned().unwrap_or(json!(1)); - let reply = json!({ - "_tag": "Exit", - "requestId": req_id, - "exit": { - "_tag": "Success", - "value": { - "pid": pid, - "version": version - } - } - }); - ws.send(Message::Text(format!("{reply}\n").into())) - .await - .expect("send reply"); - } - }); - - let reg = ServiceRegistration { - pid: 4242, - version: "0.3.0".to_string(), - url: url.clone(), - port: addr.port(), - }; - let client = RpcClient::from_registration(reg); - - // 1. Matching pid and version succeeds - let info = client.verify_server().await.expect("matching server.info"); - assert_eq!( - info, - ServerInfo { - pid: 4242, - version: "0.3.0".to_string() - } - ); - - // 2. PID mismatch is surfaced clearly - let pid_err = client.verify_server().await.expect_err("pid mismatch"); - assert_eq!( - pid_err, - format!("Server at {url} reported pid 9999, expected pid 4242 from service.json") - ); - - // 3. Version mismatch is surfaced clearly - let ver_err = client.verify_server().await.expect_err("version mismatch"); - assert_eq!( - ver_err, - format!("Server at {url} runs version 0.2.0, expected 0.3.0 from service.json") - ); - - // 4. Both PID and version mismatch - let both_err = client.verify_server().await.expect_err("both mismatch"); - assert_eq!( - both_err, - format!( - "Server at {url} reported pid 9999 (version 0.2.0), expected pid 4242 (version 0.3.0) from service.json" - ) - ); - - server.await.expect("server task"); - } - #[test] fn formats_tagged_rpc_errors_and_effect_causes_for_humans() { // Effect 4 wire Cause array wrapping a tagged error @@ -3418,1226 +1459,4 @@ mod tests { "RPC request interrupted" ); } - - #[test] - fn decodes_prompt_admitted_and_promoted_events_with_delivery_and_parts() { - let admitted = decode_session_event( - "session.prompt.admitted", - &json!({ - "sessionId": "ses_1", - "timestamp": 1_700_000_000_000u64, - "messageId": "msg_steer_1", - "delivery": "steer", - "prompt": { - "parts": [ - { "type": "text", "text": "Keep public API intact" }, - { "type": "image", "data": "AAAA", "mimeType": "image/png" }, - { "type": "text", "text": "Also add tests" } - ] - } - }), - ); - assert_eq!( - admitted, - Some(StreamEvent::PromptAdmitted { - message_id: "msg_steer_1".to_string(), - prompt: "Keep public API intact\n\nAlso add tests".to_string(), - delivery: PromptDelivery::Steer, - }) - ); - - let promoted = decode_session_event( - "session.prompt.promoted", - &json!({ - "sessionId": "ses_1", - "timestamp": 1_700_000_000_100u64, - "messageId": "msg_follow_1", - "delivery": "followUp", - "prompt": { - "parts": [ - { "type": "text", "text": "Run cargo check next" } - ] - } - }), - ); - assert_eq!( - promoted, - Some(StreamEvent::PromptPromoted { - message_id: "msg_follow_1".to_string(), - prompt: "Run cargo check next".to_string(), - delivery: PromptDelivery::FollowUp, - }) - ); - } - - #[test] - fn decodes_retry_tool_progress_config_fork_turn_and_llm_part_events() { - assert_eq!( - decode_session_event( - "session.retry.scheduled", - &json!({ - "sessionId": "ses_1", - "attempt": 2, - "maxRetries": 3, - "delayMs": 2000, - "message": "openai/gpt-5.6-luna: rate limit exceeded" - }) - ), - Some(StreamEvent::RetryScheduled { - attempt: 2, - max_retries: 3, - delay_ms: 2000, - message: "openai/gpt-5.6-luna: rate limit exceeded".to_string(), - }) - ); - - assert_eq!( - decode_session_event( - "session.retry.finished", - &json!({ - "sessionId": "ses_1", - "attempt": 2, - "success": true - }) - ), - Some(StreamEvent::RetryFinished { - attempt: 2, - success: true, - message: None, - }) - ); - - assert_eq!( - decode_session_event( - "session.tool.progress", - &json!({ - "sessionId": "ses_1", - "messageId": "msg_a1", - "callID": "call_bash_1", - "partial": { - "content": [ - { "type": "text", "text": "Compiling crate v0.1.0\nRunning tests..." } - ], - "details": { "lines": 2 } - } - }) - ), - Some(StreamEvent::ToolProgress { - call_id: "call_bash_1".to_string(), - output: Some("Compiling crate v0.1.0\nRunning tests...".to_string()), - details: Some(json!({ "lines": 2 })), - }) - ); - - assert_eq!( - decode_session_event( - "session.config.changed", - &json!({ - "sessionId": "ses_1", - "model": { "provider": "anthropic", "id": "claude-sonnet-4-5" }, - "thinkingLevel": "high" - }) - ), - Some(StreamEvent::ConfigChanged { - model: Some(ModelRef { - provider: "anthropic".to_string(), - id: "claude-sonnet-4-5".to_string(), - }), - thinking_level: Some("high".to_string()), - }) - ); - - assert_eq!( - decode_session_event( - "session.next.forked", - &json!({ - "sessionId": "ses_fork_2", - "sourceSessionId": "ses_1", - "sourceEntryId": "entry_7", - "baseSeq": 14 - }) - ), - Some(StreamEvent::SessionForked { - session_id: "ses_fork_2".to_string(), - source_session_id: "ses_1".to_string(), - source_entry_id: "entry_7".to_string(), - base_seq: 14, - }) - ); - - assert_eq!( - decode_session_event("session.turn.started", &json!({ "sessionId": "ses_1" })), - Some(StreamEvent::TurnStarted) - ); - assert_eq!( - decode_session_event( - "session.turn.ended", - &json!({ "sessionId": "ses_1", "messageId": "msg_a1" }) - ), - Some(StreamEvent::TurnEnded { - message_id: "msg_a1".to_string(), - }) - ); - assert_eq!( - decode_session_event( - "session.turn.aborted", - &json!({ - "sessionId": "ses_1", - "cause": { "_tag": "error", "message": "provider stream dropped" } - }) - ), - Some(StreamEvent::TurnAborted { - reason: "error".to_string(), - message: Some("provider stream dropped".to_string()), - }) - ); - - assert_eq!( - decode_session_event( - "session.llm.started", - &json!({ - "sessionId": "ses_1", - "messageId": "msg_a1", - "message": { "model": "claude-sonnet-4-5" } - }) - ), - Some(StreamEvent::LlmStarted { - message_id: "msg_a1".to_string(), - model: Some("claude-sonnet-4-5".to_string()), - }) - ); - assert_eq!( - decode_session_event( - "session.llm.failed", - &json!({ - "sessionId": "ses_1", - "messageId": "msg_a1", - "reason": "error", - "message": { "errorMessage": "503 Service Unavailable" } - }) - ), - Some(StreamEvent::LlmFailed { - message_id: "msg_a1".to_string(), - reason: "error".to_string(), - error: Some("503 Service Unavailable".to_string()), - }) - ); - - assert_eq!( - decode_session_event( - "session.llm.text.start", - &json!({ "sessionId": "ses_1", "messageId": "msg_a1", "partIndex": 1 }) - ), - Some(StreamEvent::TextStart { - message_id: "msg_a1".to_string(), - part_index: 1, - }) - ); - assert_eq!( - decode_session_event( - "session.llm.text.delta", - &json!({ - "sessionId": "ses_1", - "messageId": "msg_a1", - "partIndex": 1, - "delta": "Hello" - }) - ), - Some(StreamEvent::TextDelta { - message_id: Some("msg_a1".to_string()), - part_index: Some(1), - delta: "Hello".to_string(), - }) - ); - assert_eq!( - decode_session_event( - "session.llm.text.end", - &json!({ - "sessionId": "ses_1", - "messageId": "msg_a1", - "partIndex": 1, - "content": "Hello world" - }) - ), - Some(StreamEvent::TextEnd { - message_id: "msg_a1".to_string(), - part_index: 1, - content: "Hello world".to_string(), - }) - ); - - assert_eq!( - decode_session_event( - "session.llm.thinking.start", - &json!({ "sessionId": "ses_1", "messageId": "msg_a1", "partIndex": 0 }) - ), - Some(StreamEvent::ThinkingStart { - message_id: "msg_a1".to_string(), - part_index: 0, - }) - ); - assert_eq!( - decode_session_event( - "session.llm.thinking.delta", - &json!({ - "sessionId": "ses_1", - "messageId": "msg_a1", - "partIndex": 0, - "delta": "Reasoning..." - }) - ), - Some(StreamEvent::ThinkingDelta { - message_id: Some("msg_a1".to_string()), - part_index: Some(0), - delta: "Reasoning...".to_string(), - }) - ); - assert_eq!( - decode_session_event( - "session.llm.thinking.end", - &json!({ - "sessionId": "ses_1", - "messageId": "msg_a1", - "partIndex": 0, - "content": "Reasoning complete." - }) - ), - Some(StreamEvent::ThinkingEnd { - message_id: "msg_a1".to_string(), - part_index: 0, - content: "Reasoning complete.".to_string(), - }) - ); - } - - #[tokio::test] - async fn watches_prompts_admitted_after_an_execution_terminal() { - use tokio::net::TcpListener; - use tokio_tungstenite::accept_async; - - tokio::time::timeout(Duration::from_secs(5), async { - let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); - let client = RpcClient::new(format!("ws://{}/rpc/v1", listener.local_addr().unwrap())); - let server = tokio::spawn(async move { - let (socket, _) = listener.accept().await.unwrap(); - let mut ws = accept_async(socket).await.unwrap(); - let Some(Ok(Message::Text(request))) = ws.next().await else { panic!("subscribe") }; - let request: Value = serde_json::from_str(request.trim()).unwrap(); - let sub_id = request["id"].clone(); - let connected = json!({"_tag": "Chunk", "requestId": sub_id, - "values": [{"type": "server.connected"}]}); - ws.send(Message::Text(format!("{connected}\n"))).await.unwrap(); - loop { - let Some(Ok(Message::Text(request))) = ws.next().await else { panic!("initial prompt") }; - let request: Value = serde_json::from_str(request.trim()).unwrap(); - if request["tag"] == "session.prompt" { break; } - } - let terminal = json!({"_tag": "Chunk", "requestId": sub_id, - "values": [{"type": "session.execution.succeeded", "data": {"sessionId": "ses_boundary"}}]}); - ws.send(Message::Text(format!("{terminal}\n"))).await.unwrap(); - - // The next prompt reaches the server after the previous execution ended. - let (socket, _) = listener.accept().await.unwrap(); - let mut dispatch = accept_async(socket).await.unwrap(); - let Some(Ok(Message::Text(request))) = dispatch.next().await else { panic!("next prompt") }; - let request: Value = serde_json::from_str(request.trim()).unwrap(); - assert_eq!(request["payload"]["id"], "next"); - let reply = json!({"_tag": "Exit", "requestId": request["id"], - "exit": {"_tag": "Success", "value": null}}); - dispatch.send(Message::Text(format!("{reply}\n"))).await.unwrap(); - let promoted = json!({"_tag": "Chunk", "requestId": sub_id, - "values": [ - {"type": "session.prompt.promoted", "data": {"sessionId": "ses_boundary", - "messageId": "next", "text": "next", "delivery": "followUp"}}, - {"type": "session.llm.text.delta", "data": {"sessionId": "ses_boundary", - "messageId": "answer", "partIndex": 0, "delta": "received"}}, - {"type": "session.execution.succeeded", "data": {"sessionId": "ses_boundary"}} - ]}); - ws.send(Message::Text(format!("{promoted}\n"))).await.unwrap(); - ws.close(None).await.unwrap(); - }); - let (tx, mut rx) = mpsc::unbounded_channel(); - let stream_client = RpcClient::new(client.url.clone()); - let stream = tokio::spawn(async move { - stream_client.stream_session_once("ses_boundary", "initial", PromptDelivery::FollowUp, - "initial", &mut false, false, true, &tx).await - }); - assert_eq!(rx.recv().await, Some(StreamEvent::Succeeded)); - client.send_prompt("ses_boundary", "next", PromptDelivery::FollowUp, "next").await.unwrap(); - assert_eq!(rx.recv().await, Some(StreamEvent::PromptPromoted { - message_id: "next".to_string(), prompt: "next".to_string(), delivery: PromptDelivery::FollowUp, - })); - assert!(matches!(rx.recv().await, Some(StreamEvent::TextDelta { delta, .. }) if delta == "received")); - assert_eq!(rx.recv().await, Some(StreamEvent::Succeeded)); - assert!(!stream.await.unwrap().unwrap()); - server.await.unwrap(); - }).await.expect("session stream must survive the first terminal"); - } - - #[tokio::test] - async fn send_prompt_and_live_stream_round_trip_over_websocket() { - use tokio::net::TcpListener; - use tokio_tungstenite::accept_async; - - let listener = TcpListener::bind("127.0.0.1:0").await.expect("bind"); - let addr = listener.local_addr().expect("addr"); - let url = format!("ws://{addr}/rpc/v1"); - - let server = tokio::spawn(async move { - // 1. First connection: `send_prompt` with `delivery: "steer"` - let (stream, _) = listener.accept().await.expect("accept send_prompt"); - let mut ws = accept_async(stream).await.expect("ws handshake"); - let Some(Ok(Message::Text(req_text))) = ws.next().await else { - panic!("expected text request"); - }; - let req: Value = serde_json::from_str(req_text.trim()).expect("json request"); - assert_eq!( - req.get("tag").and_then(Value::as_str), - Some("session.prompt") - ); - let payload = req.get("payload").expect("payload"); - assert_eq!( - payload.get("sessionId").and_then(Value::as_str), - Some("ses_stream") - ); - assert_eq!( - payload.get("text").and_then(Value::as_str), - Some("Steer this turn") - ); - assert_eq!( - payload.get("delivery").and_then(Value::as_str), - Some("steer") - ); - assert_eq!( - payload.get("id").and_then(Value::as_str), - Some("msg_steer_42") - ); - let req_id = req.get("id").cloned().unwrap_or(json!(1)); - let reply = json!({ - "_tag": "Exit", - "requestId": req_id, - "exit": { "_tag": "Success", "value": Value::Null } - }); - ws.send(Message::Text(format!("{reply}\n"))) - .await - .expect("send reply"); - - // 2. Second connection: `prompt_session_with` streaming live events - let (stream, _) = listener.accept().await.expect("accept stream"); - let mut ws = accept_async(stream).await.expect("ws handshake"); - let Some(Ok(Message::Text(sub_text))) = ws.next().await else { - panic!("expected event.subscribe request"); - }; - let sub_req: Value = serde_json::from_str(sub_text.trim()).expect("sub json"); - assert_eq!( - sub_req.get("tag").and_then(Value::as_str), - Some("event.subscribe") - ); - let sub_id = sub_req.get("id").cloned().unwrap_or(json!(1)); - - // Send `server.connected` chunk - let connected = json!({ - "_tag": "Chunk", - "requestId": sub_id, - "values": [{ "type": "server.connected" }] - }); - ws.send(Message::Text(format!("{connected}\n"))) - .await - .expect("send server.connected"); - - // Read Ack + `session.prompt` request - let mut saw_prompt = false; - while !saw_prompt { - let Some(Ok(Message::Text(txt))) = ws.next().await else { - panic!("expected client message"); - }; - for line in txt.lines() { - let msg: Value = serde_json::from_str(line.trim()).expect("client json"); - if msg.get("tag").and_then(Value::as_str) == Some("session.prompt") { - saw_prompt = true; - } - } - } - - // Stream a full sequence of live events including fork on sourceSessionId - let events_chunk = json!({ - "_tag": "Chunk", - "requestId": sub_id, - "values": [ - { - "type": "session.prompt.admitted", - "data": { - "sessionId": "ses_stream", - "messageId": "msg_init", - "delivery": "followUp", - "prompt": { "parts": [{ "type": "text", "text": "Hello" }] } - } - }, - { - "type": "session.prompt.promoted", - "data": { - "sessionId": "ses_stream", - "messageId": "msg_init", - "delivery": "followUp", - "prompt": { "parts": [{ "type": "text", "text": "Hello" }] } - } - }, - { - "type": "session.retry.scheduled", - "data": { - "sessionId": "ses_stream", - "attempt": 1, - "maxRetries": 2, - "delayMs": 500, - "message": "rate limited" - } - }, - { - "type": "session.tool.progress", - "data": { - "sessionId": "ses_stream", - "messageId": "msg_a1", - "callID": "call_1", - "partial": { - "content": [{ "type": "text", "text": "step 1/2" }] - } - } - }, - { - "type": "session.config.changed", - "data": { - "sessionId": "ses_stream", - "thinkingLevel": "high" - } - }, - { - "type": "session.next.forked", - "data": { - "sessionId": "ses_child", - "sourceSessionId": "ses_stream", - "sourceEntryId": "entry_1", - "baseSeq": 3 - } - }, - { - "type": "session.execution.succeeded", - "data": { "sessionId": "ses_stream" } - } - ] - }); - ws.send(Message::Text(format!("{events_chunk}\n"))) - .await - .expect("send events"); - - // 3. Third connection: trailing `session.info` refresh after `Ok(true)` - let (stream, _) = listener.accept().await.expect("accept session.info"); - let mut ws = accept_async(stream).await.expect("ws handshake"); - let Some(Ok(Message::Text(info_text))) = ws.next().await else { - panic!("expected session.info request"); - }; - let info_req: Value = serde_json::from_str(info_text.trim()).expect("info json"); - let info_id = info_req.get("id").cloned().unwrap_or(json!(1)); - let info_reply = json!({ - "_tag": "Exit", - "requestId": info_id, - "exit": { - "_tag": "Success", - "value": { - "id": "ses_stream", - "title": "Hello", - "directory": "/workspace", - "updatedAt": 2000, - "thinkingLevel": "high" - } - } - }); - ws.send(Message::Text(format!("{info_reply}\n"))) - .await - .expect("send session.info"); - }); - - let client = RpcClient::new(url); - client - .send_prompt( - "ses_stream", - "Steer this turn", - PromptDelivery::Steer, - "msg_steer_42", - ) - .await - .expect("send_prompt"); - - let (tx, mut rx) = mpsc::unbounded_channel(); - client - .prompt_session_with( - "ses_stream".to_string(), - "Hello".to_string(), - PromptDelivery::FollowUp, - "msg_init".to_string(), - tx, - ) - .await - .expect("prompt_session_with"); - - let mut received = Vec::new(); - while let Ok(evt) = rx.try_recv() { - received.push(evt); - } - assert!(received.contains(&StreamEvent::PromptAdmitted { - message_id: "msg_init".to_string(), - prompt: "Hello".to_string(), - delivery: PromptDelivery::FollowUp, - })); - assert!(received.contains(&StreamEvent::PromptPromoted { - message_id: "msg_init".to_string(), - prompt: "Hello".to_string(), - delivery: PromptDelivery::FollowUp, - })); - assert!(received.contains(&StreamEvent::RetryScheduled { - attempt: 1, - max_retries: 2, - delay_ms: 500, - message: "rate limited".to_string(), - })); - assert!(received.contains(&StreamEvent::ToolProgress { - call_id: "call_1".to_string(), - output: Some("step 1/2".to_string()), - details: None, - })); - assert!(received.contains(&StreamEvent::ConfigChanged { - model: None, - thinking_level: Some("high".to_string()), - })); - assert!(received.contains(&StreamEvent::SessionForked { - session_id: "ses_child".to_string(), - source_session_id: "ses_stream".to_string(), - source_entry_id: "entry_1".to_string(), - base_seq: 3, - })); - assert!(received.contains(&StreamEvent::Succeeded)); - - server.await.expect("server task"); - } - - #[tokio::test] - async fn reconnect_redispatches_prompt_when_session_message_reports_not_found() { - use tokio::net::TcpListener; - use tokio_tungstenite::accept_async; - - tokio::time::timeout(Duration::from_secs(5), async { - let listener = TcpListener::bind("127.0.0.1:0").await.expect("bind"); - let addr = listener.local_addr().expect("addr"); - let url = format!("ws://{addr}/rpc/v1"); - - let server = tokio::spawn(async move { - // 1. First connection: drops right after the client dispatches `session.prompt`. - let (socket, _) = listener.accept().await.expect("accept 1"); - let mut ws = accept_async(socket).await.expect("ws 1"); - let Some(Ok(Message::Text(sub_text))) = ws.next().await else { - panic!("expected event.subscribe"); - }; - let sub_req: Value = serde_json::from_str(sub_text.trim()).expect("sub json"); - let sub_id = sub_req.get("id").cloned().unwrap_or(json!(1)); - let connected = json!({ - "_tag": "Chunk", - "requestId": sub_id, - "values": [{ "type": "server.connected" }] - }); - ws.send(Message::Text(format!("{connected}\n"))) - .await - .expect("send connected 1"); - - let mut saw_first_prompt = false; - while !saw_first_prompt { - let Some(Ok(Message::Text(txt))) = ws.next().await else { - panic!("expected first session.prompt"); - }; - for line in txt.lines() { - let msg: Value = serde_json::from_str(line.trim()).expect("json"); - if msg.get("tag").and_then(Value::as_str) == Some("session.prompt") { - saw_first_prompt = true; - } - } - } - // Drop connection before admitting the prompt. - drop(ws); - - // 2. Reconnect: client checks `session.message`, receives `{ found: false }`, and - // re-dispatches `session.prompt` with the same `messageId`. - let (socket, _) = listener.accept().await.expect("accept 2"); - let mut ws = accept_async(socket).await.expect("ws 2"); - let Some(Ok(Message::Text(sub_text))) = ws.next().await else { - panic!("expected event.subscribe on retry"); - }; - let sub_req: Value = serde_json::from_str(sub_text.trim()).expect("sub json 2"); - let sub_id = sub_req.get("id").cloned().unwrap_or(json!(1)); - let connected = json!({ - "_tag": "Chunk", - "requestId": sub_id, - "values": [{ "type": "server.connected" }] - }); - ws.send(Message::Text(format!("{connected}\n"))) - .await - .expect("send connected 2"); - - let mut msg_check_id = None; - while msg_check_id.is_none() { - let Some(Ok(Message::Text(txt))) = ws.next().await else { - panic!("expected session.message request"); - }; - for line in txt.lines() { - let msg: Value = serde_json::from_str(line.trim()).expect("json"); - if msg.get("tag").and_then(Value::as_str) == Some("session.message") { - assert_eq!(msg["payload"]["sessionId"], "ses_retry"); - assert_eq!(msg["payload"]["messageId"], "msg_retry_1"); - msg_check_id = msg.get("id").cloned(); - } - } - } - - let log = request(&mut ws, "session.log").await; - chunk( - &mut ws, - &log["id"], - json!([{ - "type": "log.synced", "aggregateId": "ses_retry" - }]), - ) - .await; - - let not_found = json!({ - "_tag": "Exit", - "requestId": msg_check_id.unwrap(), - "exit": { "_tag": "Success", "value": { "found": false } } - }); - ws.send(Message::Text(format!("{not_found}\n"))) - .await - .expect("send found: false"); - - let mut redispatched_prompt_id = None; - while redispatched_prompt_id.is_none() { - let Some(Ok(Message::Text(txt))) = ws.next().await else { - panic!("expected re-dispatched session.prompt"); - }; - for line in txt.lines() { - let msg: Value = serde_json::from_str(line.trim()).expect("json"); - if msg.get("tag").and_then(Value::as_str) == Some("session.prompt") { - assert_eq!(msg["payload"]["sessionId"], "ses_retry"); - assert_eq!(msg["payload"]["id"], "msg_retry_1"); - assert_eq!(msg["payload"]["text"], "Retry me"); - redispatched_prompt_id = msg.get("id").cloned(); - } - } - } - - let prompt_ok = json!({ - "_tag": "Exit", - "requestId": redispatched_prompt_id.unwrap(), - "exit": { "_tag": "Success", "value": Value::Null } - }); - ws.send(Message::Text(format!("{prompt_ok}\n"))) - .await - .expect("send prompt ok"); - - let chunk = json!({ - "_tag": "Chunk", - "requestId": sub_id, - "values": [ - { - "type": "session.llm.text.delta", - "data": { - "sessionId": "ses_retry", - "messageId": "msg_a1", - "partIndex": 0, - "delta": "Recovered!" - } - }, - { - "type": "session.execution.succeeded", - "data": { "sessionId": "ses_retry" } - } - ] - }); - ws.send(Message::Text(format!("{chunk}\n"))) - .await - .expect("send completion chunk"); - }); - - let client = RpcClient::new(url); - let (tx, mut rx) = mpsc::unbounded_channel(); - let mut prompt_dispatched = false; - let mut log_cursor = None; - let mut turn_active = true; - let mut initial_settled = false; - let mut seen_seqs = std::collections::HashSet::new(); - - // Attempt 1 drops after dispatching `session.prompt`. - let first = client - .stream_session_once_with_cursor( - "ses_retry", - "Retry me", - PromptDelivery::FollowUp, - "msg_retry_1", - &mut prompt_dispatched, - &mut log_cursor, - &mut turn_active, - &mut initial_settled, - &mut seen_seqs, - false, - false, - &tx, - ) - .await - .expect("attempt 1"); - assert!(!first); - assert!(prompt_dispatched); - - // Attempt 2 reconciles via `session.message` (`found: false`) and re-dispatches. - let second = client - .stream_session_once_with_cursor( - "ses_retry", - "Retry me", - PromptDelivery::FollowUp, - "msg_retry_1", - &mut prompt_dispatched, - &mut log_cursor, - &mut turn_active, - &mut initial_settled, - &mut seen_seqs, - true, - false, - &tx, - ) - .await - .expect("attempt 2"); - assert!(second); - - let mut received = Vec::new(); - while let Ok(evt) = rx.try_recv() { - received.push(evt); - } - assert!(received.contains(&StreamEvent::Reconnected)); - assert!(received.contains(&StreamEvent::TextDelta { - message_id: Some("msg_a1".to_string()), - part_index: Some(0), - delta: "Recovered!".to_string(), - })); - assert!(received.contains(&StreamEvent::Succeeded)); - - server.await.expect("server task"); - }) - .await - .expect("reconnect redispatch test timed out"); - } - - #[tokio::test] - async fn reconnect_resolves_settled_turn_via_session_message_session_wait_and_session_log() { - use tokio::net::TcpListener; - use tokio_tungstenite::accept_async; - - tokio::time::timeout(Duration::from_secs(5), async { - let listener = TcpListener::bind("127.0.0.1:0").await.expect("bind"); - let addr = listener.local_addr().expect("addr"); - let url = format!("ws://{addr}/rpc/v1"); - - let server = tokio::spawn(async move { - let (socket, _) = listener.accept().await.expect("accept reconnect"); - let mut ws = accept_async(socket).await.expect("ws handshake"); - - let Some(Ok(Message::Text(sub_text))) = ws.next().await else { - panic!("expected event.subscribe"); - }; - let sub_req: Value = serde_json::from_str(sub_text.trim()).expect("sub json"); - let sub_id = sub_req.get("id").cloned().unwrap_or(json!(1)); - let connected = json!({ - "_tag": "Chunk", - "requestId": sub_id, - "values": [{ "type": "server.connected" }] - }); - ws.send(Message::Text(format!("{connected}\n"))) - .await - .expect("send connected"); - - let mut msg_check_id = None; - let mut log_id = None; - while msg_check_id.is_none() || log_id.is_none() { - let Some(Ok(Message::Text(txt))) = ws.next().await else { - panic!("expected session.message and session.log"); - }; - for line in txt.lines() { - let msg: Value = serde_json::from_str(line.trim()).expect("json"); - match msg.get("tag").and_then(Value::as_str) { - Some("session.message") => { - assert_eq!(msg["payload"]["sessionId"], "ses_settled"); - assert_eq!(msg["payload"]["messageId"], "msg_settled_1"); - msg_check_id = msg.get("id").cloned(); - } - Some("session.log") => { - assert_eq!(msg["payload"]["sessionId"], "ses_settled"); - assert_eq!(msg["payload"]["after"], 1); - assert_eq!(msg["payload"]["follow"], true); - log_id = msg.get("id").cloned(); - } - _ => {} - } - } - } - - // Replay the durable events that committed during the disconnect window + log.synced. - let log_chunk = json!({ - "_tag": "Chunk", - "requestId": log_id.unwrap(), - "values": [ - { - "id": "evt_2", - "type": "session.llm.started", - "durable": { "aggregateId": "ses_settled", "seq": 2, "version": 1 }, - "data": { - "sessionId": "ses_settled", - "messageId": "msg_a1", - "message": { "model": "gpt-5.6-luna" } - } - }, - { - "id": "evt_3", - "type": "session.llm.ended", - "durable": { "aggregateId": "ses_settled", "seq": 3, "version": 1 }, - "data": { - "sessionId": "ses_settled", - "messageId": "msg_a1", - "reason": "stop", - "message": { - "messageId": "msg_a1", - "role": "assistant", - "model": "gpt-5.6-luna", - "parts": [ - { "type": "thinking", "thinking": "Settled while offline." }, - { "type": "text", "text": "Completed during disconnect." } - ], - "usage": { - "totalTokens": 90, - "input": 60, - "output": 30, - "cost": { "total": 0.0015 } - } - } - } - }, - { - "id": "evt_4", - "type": "session.turn.ended", - "durable": { "aggregateId": "ses_settled", "seq": 4, "version": 1 }, - "data": { - "sessionId": "ses_settled", - "messageId": "msg_a1" - } - }, - { - "type": "log.synced", - "aggregateId": "ses_settled", - "seq": 6 - } - ] - }); - ws.send(Message::Text(format!("{log_chunk}\n"))) - .await - .expect("send log chunk"); - - // Report that `msg_settled_1` materialized into the conversation. - let found_reply = json!({ - "_tag": "Exit", - "requestId": msg_check_id.unwrap(), - "exit": { "_tag": "Success", "value": { "found": true } } - }); - ws.send(Message::Text(format!("{found_reply}\n"))) - .await - .expect("send found: true"); - - // Client must now send `session.wait` (and NOT re-send `session.prompt`). - let mut wait_id = None; - while wait_id.is_none() { - let Some(Ok(Message::Text(txt))) = ws.next().await else { - panic!("expected session.wait request"); - }; - for line in txt.lines() { - let msg: Value = serde_json::from_str(line.trim()).expect("json"); - assert_ne!( - msg.get("tag").and_then(Value::as_str), - Some("session.prompt"), - "must not re-dispatch already promoted prompt" - ); - if msg.get("tag").and_then(Value::as_str) == Some("session.wait") { - assert_eq!(msg["payload"]["sessionId"], "ses_settled"); - wait_id = msg.get("id").cloned(); - } - } - } - - // Session is already idle because the turn finished while disconnected. - let wait_reply = json!({ - "_tag": "Exit", - "requestId": wait_id.unwrap(), - "exit": { "_tag": "Success", "value": Value::Null } - }); - ws.send(Message::Text(format!("{wait_reply}\n"))) - .await - .expect("send wait reply"); - - let drain = request(&mut ws, "session.log").await; - assert_eq!(drain["payload"]["after"], 6); - assert_eq!(drain["payload"]["follow"], false); - chunk(&mut ws, &drain["id"], json!([{ - "type": "log.synced", "aggregateId": "ses_settled", "seq": 6 - }])).await; - success(&mut ws, &drain["id"], Value::Null).await; - }); - - let client = RpcClient::new(url); - let (tx, mut rx) = mpsc::unbounded_channel(); - let mut prompt_dispatched = true; - let mut log_cursor = Some(1); - let mut turn_active = true; - let mut initial_settled = false; - let mut seen_seqs = std::collections::HashSet::new(); - - let done = client - .stream_session_once_with_cursor( - "ses_settled", - "Hello", - PromptDelivery::FollowUp, - "msg_settled_1", - &mut prompt_dispatched, - &mut log_cursor, - &mut turn_active, - &mut initial_settled, - &mut seen_seqs, - true, - false, - &tx, - ) - .await - .expect("stream_session_once_with_cursor"); - assert!(done); - assert!(!turn_active); - assert!(initial_settled); - // Cursor advances to `max(last durable.seq (4), last log.synced.seq (6))` = 6. - assert_eq!(log_cursor, Some(6)); - - let mut received = Vec::new(); - while let Ok(evt) = rx.try_recv() { - received.push(evt); - } - assert!(received.contains(&StreamEvent::Reconnected)); - assert!(received.contains(&StreamEvent::ThinkingEnd { - message_id: "msg_a1".to_string(), - part_index: 0, - content: "Settled while offline.".to_string(), - })); - assert!(received.contains(&StreamEvent::TextEnd { - message_id: "msg_a1".to_string(), - part_index: 1, - content: "Completed during disconnect.".to_string(), - })); - assert!(received.contains(&StreamEvent::LogSynced { seq: Some(6) })); - assert!(received.contains(&StreamEvent::Succeeded)); - - server.await.expect("server task"); - }) - .await - .expect("reconnect settled turn test timed out"); - } - - #[tokio::test] - async fn session_log_tracks_max_cursor_across_replay_follow_and_reconnect() { - use tokio::net::TcpListener; - use tokio_tungstenite::accept_async; - - tokio::time::timeout(Duration::from_secs(5), async { - let listener = TcpListener::bind("127.0.0.1:0").await.expect("bind"); - let addr = listener.local_addr().expect("addr"); - let url = format!("ws://{addr}/rpc/v1"); - - let server = tokio::spawn(async move { - // 1. First connection: `after` is None; replays seq 0, sends `log.synced` at seq 3 - // (head past last event), then follows seq 4 before dropping. - let (socket, _) = listener.accept().await.expect("accept 1"); - let mut ws = accept_async(socket).await.expect("ws 1"); - let Some(Ok(Message::Text(req_text))) = ws.next().await else { - panic!("expected session.log 1"); - }; - let req: Value = serde_json::from_str(req_text.trim()).expect("json 1"); - assert_eq!(req["tag"], "session.log"); - assert_eq!(req["payload"]["sessionId"], "ses_log"); - assert!(req["payload"].get("after").is_none()); - assert_eq!(req["payload"]["follow"], true); - let log_id = req["id"].clone(); - - let chunk = json!({ - "_tag": "Chunk", - "requestId": log_id, - "values": [ - { - "id": "evt_0", - "type": "session.prompt.promoted", - "durable": { "aggregateId": "ses_log", "seq": 0, "version": 1 }, - "data": { - "sessionId": "ses_log", - "messageId": "msg_u0", - "delivery": "followUp", - "prompt": { "parts": [{ "type": "text", "text": "First prompt" }] } - } - }, - { - "type": "log.synced", - "aggregateId": "ses_log", - "seq": 3 - }, - { - "id": "evt_4", - "type": "session.turn.ended", - "durable": { "aggregateId": "ses_log", "seq": 4, "version": 1 }, - "data": { - "sessionId": "ses_log", - "messageId": "msg_a0" - } - } - ] - }); - ws.send(Message::Text(format!("{chunk}\n"))) - .await - .expect("send chunk 1"); - let _ = ws.next().await; - drop(ws); - - // 2. Second connection: resumes with `after: 4` (`max(durable.seq 4, synced.seq 3)`), - // receives `log.synced` with `seq: 7` (forked head above last event), then ends. - let (socket, _) = listener.accept().await.expect("accept 2"); - let mut ws = accept_async(socket).await.expect("ws 2"); - let Some(Ok(Message::Text(req_text))) = ws.next().await else { - panic!("expected session.log 2"); - }; - let req: Value = serde_json::from_str(req_text.trim()).expect("json 2"); - assert_eq!(req["tag"], "session.log"); - assert_eq!(req["payload"]["sessionId"], "ses_log"); - assert_eq!(req["payload"]["after"], 4); - assert_eq!(req["payload"]["follow"], false); - let log_id = req["id"].clone(); - - let chunk = json!({ - "_tag": "Chunk", - "requestId": log_id, - "values": [ - { - "type": "log.synced", - "aggregateId": "ses_log", - "seq": 7 - } - ] - }); - ws.send(Message::Text(format!("{chunk}\n"))) - .await - .expect("send chunk 2"); - let exit = json!({ - "_tag": "Exit", - "requestId": log_id, - "exit": { "_tag": "Success", "value": Value::Null } - }); - ws.send(Message::Text(format!("{exit}\n"))) - .await - .expect("send exit 2"); - }); - - let client = RpcClient::new(url); - let (tx, mut rx) = mpsc::unbounded_channel(); - let mut cursor = None; - let mut seen_seqs = std::collections::HashSet::new(); - - let finished_first = client - .stream_session_log_once("ses_log", true, &mut cursor, &mut seen_seqs, false, &tx) - .await - .expect("log 1"); - assert!(!finished_first); - assert_eq!(cursor, Some(4)); - - let finished_second = client - .stream_session_log_once("ses_log", false, &mut cursor, &mut seen_seqs, true, &tx) - .await - .expect("log 2"); - assert!(finished_second); - assert_eq!(cursor, Some(7)); - - let mut received = Vec::new(); - while let Ok(evt) = rx.try_recv() { - received.push(evt); - } - assert_eq!( - received, - vec![ - StreamEvent::PromptPromoted { - message_id: "msg_u0".to_string(), - prompt: "First prompt".to_string(), - delivery: PromptDelivery::FollowUp, - }, - StreamEvent::LogSynced { seq: Some(3) }, - StreamEvent::TurnEnded { - message_id: "msg_a0".to_string(), - }, - StreamEvent::Reconnected, - StreamEvent::LogSynced { seq: Some(7) }, - ] - ); - - server.await.expect("server task"); - }) - .await - .expect("session_log cursor test timed out"); - } - - #[tokio::test] - #[ignore] - async fn test_rpc_flow() { - let client = RpcClient::new(DEFAULT_SERVER_URL); - if !client.is_server_running().await { - println!("Server not running, skipping test"); - return; - } - - println!("Creating session..."); - let session = client - .create_session( - None, - Some(("google".to_string(), "gemini-2.5-flash".to_string())), - None, - ) - .await; - println!("Session result: {:?}", session); - let session = match session { - Ok(s) => s, - Err(e) => { - panic!("Failed to create session: {}", e); - } - }; - - println!("Prompting session {}...", session.id); - let (tx, mut rx) = mpsc::unbounded_channel(); - let c = RpcClient::new(DEFAULT_SERVER_URL); - let s_id = session.id.clone(); - tokio::spawn(async move { - let res = c.prompt_session(s_id, "hello".to_string(), tx).await; - println!("prompt_session finished: {:?}", res); - }); - - let mut events_count = 0; - while let Some(evt) = rx.recv().await { - println!("Got stream event: {:?}", evt); - events_count += 1; - if matches!( - evt, - StreamEvent::Succeeded | StreamEvent::Failed(_) | StreamEvent::Interrupted(_) - ) { - break; - } - } - println!("Total events received: {}", events_count); - } } diff --git a/packages/tui/src/rpc/protocol.rs b/packages/tui/src/rpc/protocol.rs index b5c94c87..0faaa7e9 100644 --- a/packages/tui/src/rpc/protocol.rs +++ b/packages/tui/src/rpc/protocol.rs @@ -1,7 +1,11 @@ use serde::{Deserialize, Serialize}; +use serde_json::Value; #[allow(unused_imports)] -pub use crate::types::{HistoryEntry, Part, ToolResult, ToolResultContent, ToolTime}; +pub use crate::types::{ + DeltaKind, HistoryEntry, InboxState, LiveDelta, Part, QueuedPrompt, ThreadInfo, ThreadItem, + ToolResult, ToolResultContent, ToolTime, +}; #[derive(Debug, Serialize)] pub struct RpcRequest { @@ -63,17 +67,16 @@ impl RpcInterrupt { pub enum ServerMessage { Exit { #[serde(rename = "requestId")] - request_id: serde_json::Value, + request_id: Value, exit: ExitPayload, }, Chunk { #[serde(rename = "requestId")] - request_id: serde_json::Value, - values: Vec, + request_id: Value, + values: Vec, }, Defect { - #[allow(dead_code)] - defect: Option, + defect: Option, }, #[serde(other)] Other, @@ -82,8 +85,8 @@ pub enum ServerMessage { #[derive(Debug, Deserialize)] #[serde(tag = "_tag")] pub enum ExitPayload { - Success { value: serde_json::Value }, - Failure { cause: Option }, + Success { value: Value }, + Failure { cause: Option }, } #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] @@ -95,57 +98,20 @@ pub struct DurableMeta { pub version: u64, } -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct LogSynced { - #[serde(rename = "aggregateId")] - pub aggregate_id: String, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub seq: Option, -} - -#[derive(Debug, Clone, Deserialize)] +#[derive(Debug, Clone, PartialEq, Deserialize)] pub struct EventEnvelope { pub id: Option, #[serde(rename = "type")] pub event_type: String, #[serde(default)] pub durable: Option, - #[serde(rename = "aggregateId", default)] - pub aggregate_id: Option, - #[serde(default)] - pub seq: Option, - pub data: Option, -} - -impl EventEnvelope { - #[allow(dead_code)] - pub fn as_log_synced(&self) -> Option { - if self.event_type == "log.synced" { - Some(LogSynced { - aggregate_id: self.aggregate_id.clone().unwrap_or_default(), - seq: self.seq, - }) - } else { - None - } - } - - pub fn durable_seq(&self) -> Option { - self.durable.as_ref().map(|d| d.seq) - } - - #[allow(dead_code)] - pub fn cursor_seq(&self) -> Option { - if self.event_type == "log.synced" { - self.seq - } else { - self.durable_seq() - } - } + pub data: Option, } #[derive(Debug, Serialize)] pub struct CreateSessionPayload { + #[serde(skip_serializing_if = "Option::is_none")] + pub directory: Option, #[serde(rename = "hostDir", skip_serializing_if = "Option::is_none")] pub host_dir: Option, #[serde(skip_serializing_if = "Option::is_none")] @@ -153,9 +119,25 @@ pub struct CreateSessionPayload { } #[derive(Debug, Serialize)] -pub struct ConfigureSessionPayload { +pub struct ListThreadsPayload<'a> { + #[serde(rename = "sessionId", skip_serializing_if = "Option::is_none")] + pub session_id: Option<&'a str>, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize)] +pub struct ThreadRefPayload { + #[serde(rename = "sessionId")] + pub session_id: String, + #[serde(rename = "threadId")] + pub thread_id: String, +} + +#[derive(Debug, Serialize)] +pub struct ConfigureThreadPayload { #[serde(rename = "sessionId")] pub session_id: String, + #[serde(rename = "threadId")] + pub thread_id: String, pub runtime: RuntimePayload, } @@ -174,36 +156,44 @@ pub struct ModelRefPayload { } #[derive(Debug, Serialize)] -pub struct PromptSessionPayload { +pub struct PromptThreadPayload { #[serde(rename = "sessionId")] pub session_id: String, + #[serde(rename = "threadId")] + pub thread_id: String, pub text: String, - pub delivery: &'static str, // "followUp" + pub delivery: &'static str, pub id: String, } #[derive(Debug, Clone, PartialEq, Eq, Serialize)] -pub struct SessionIdPayload { - #[serde(rename = "sessionId")] - pub session_id: String, -} - -#[derive(Debug, Clone, PartialEq, Eq, Serialize)] -pub struct SessionMessagePayload { +pub struct ThreadMessagePayload { #[serde(rename = "sessionId")] pub session_id: String, + #[serde(rename = "threadId")] + pub thread_id: String, #[serde(rename = "messageId")] pub message_id: String, } #[derive(Debug, Clone, PartialEq, Eq, Serialize)] -pub struct SessionLogPayload { +pub struct ThreadSyncPayload { #[serde(rename = "sessionId")] pub session_id: String, + #[serde(rename = "threadId")] + pub thread_id: String, #[serde(skip_serializing_if = "Option::is_none")] pub after: Option, #[serde(skip_serializing_if = "Option::is_none")] - pub follow: Option, + pub budget: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize)] +pub struct EventSubscribePayload { + #[serde(rename = "threadId", skip_serializing_if = "Option::is_none")] + pub thread_id: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub types: Option>, } #[derive(Debug, Serialize)] @@ -213,13 +203,72 @@ pub struct ListModelsPayload<'a> { } #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct SessionHistoryResponse { +pub struct ThreadHistoryResponse { #[serde(default)] pub entries: Vec, } +#[derive(Debug, Clone, PartialEq, Eq, Serialize)] +pub struct UpdatePromptPayload { + #[serde(flatten)] + pub address: ThreadRefPayload, + #[serde(rename = "messageId")] + pub message_id: String, + #[serde(skip_serializing_if = "Option::is_none")] + pub delivery: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub text: Option, +} + #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct SessionMessageResponse { +#[serde(rename_all = "lowercase")] +pub enum ForkMode { + At, + Before, +} + +#[derive(Debug, Serialize)] +pub struct ForkThreadPayload { + #[serde(flatten)] + pub address: ThreadRefPayload, + #[serde(rename = "entryId")] + pub entry_id: String, + pub mode: ForkMode, +} + +#[derive(Debug, Serialize)] +pub struct PageThreadPayload { + #[serde(flatten)] + pub address: ThreadRefPayload, + pub before: u64, + pub limit: u64, +} + +#[derive(Debug, Deserialize)] +pub struct CancelledResponse { + pub cancelled: bool, +} +#[derive(Debug, Deserialize)] +pub struct UpdatedResponse { + pub updated: bool, +} +#[derive(Debug, Clone, PartialEq, Deserialize)] +pub struct ForkResponse { + pub thread: ThreadInfo, #[serde(default)] - pub found: bool, + pub text: Option, +} + +#[derive(Debug, Serialize)] +pub struct GitDiffPayload<'a> { + pub plugin: &'static str, + #[serde(rename = "spaceId")] + pub space_id: &'a str, + pub method: &'static str, + pub input: GitDiffInput<'a>, +} +#[derive(Debug, Serialize)] +pub struct GitDiffInput<'a> { + pub files: [&'a str; 1], + pub context: u64, } diff --git a/packages/tui/src/tests.rs b/packages/tui/src/tests.rs new file mode 100644 index 00000000..140aa740 --- /dev/null +++ b/packages/tui/src/tests.rs @@ -0,0 +1,549 @@ +//! Protocol/UI regression coverage, written before the migration implementation. +//! Failure modes: a promoted prompt restored after a failed cancellation; lane/text edits +//! clobbering each other; late replies mutating a different thread; duplicate/overlapping +//! pages or a viewport jump; drafts offered as fork points; before-forks losing returned +//! text; stale checkpoints overwriting live Unicode deltas; folding losing intermediate notes. +//! These isolated checks exercise cancellation, concurrency and data integrity boundaries. + +use std::sync::Arc; +use std::time::Duration; + +use crossterm::event::{KeyCode, KeyEvent, KeyModifiers}; +use futures_util::{SinkExt, StreamExt}; +use ratatui::{backend::TestBackend, Terminal}; +use serde_json::{json, Value}; +use tokio::sync::{mpsc, Mutex}; +use tokio_tungstenite::{accept_async, tungstenite::Message}; + +use crate::app::{turns_from_history, App, Screen}; +use crate::event::AppEvent; +use crate::rpc::RpcClient; +use crate::types::{HistoryEntry, ThreadInfo, ThreadItem}; + +fn thread(id: &str) -> ThreadInfo { + serde_json::from_value(json!({ + "id": id, "session": {"id":"session", "spaceId":"space", "slug":"Conversation", + "directory":"/workspace", "mainThreadId":"main"}, "parked":true + })) + .unwrap() +} + +fn entry(id: &str, seq: u64, role: &str, parts: Value) -> HistoryEntry { + serde_json::from_value(json!({"id":id, "seq":seq, "threadId":"main", "role":role, + "state":"committed", "createdAt":1000, "updatedAt":62500, "parts":parts})) + .unwrap() +} + +fn key(app: &mut App, code: KeyCode, modifiers: KeyModifiers) { + app.update(AppEvent::Key(KeyEvent::new(code, modifiers))); +} + +async fn receive(app: &mut App, rx: &mut mpsc::UnboundedReceiver) { + let event = tokio::time::timeout(Duration::from_secs(3), rx.recv()) + .await + .unwrap() + .unwrap(); + app.update(event); +} + +struct Server { + url: String, + calls: Arc>>, + task: tokio::task::JoinHandle<()>, +} +impl Drop for Server { + fn drop(&mut self) { + self.task.abort(); + } +} + +async fn server() -> Server { + let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap(); + let url = format!("ws://{}", listener.local_addr().unwrap()); + let calls = Arc::new(Mutex::new(Vec::new())); + let recorded = calls.clone(); + let task = tokio::spawn(async move { + loop { + let (socket, _) = listener.accept().await.unwrap(); + let calls = recorded.clone(); + tokio::spawn(async move { + let mut ws = accept_async(socket).await.unwrap(); + while let Some(Ok(Message::Text(text))) = ws.next().await { + let request: Value = serde_json::from_str(text.trim()).unwrap(); + if request["_tag"] != "Request" { + continue; + } + calls.lock().await.push(request.clone()); + let payload = &request["payload"]; + let value = match request["tag"].as_str().unwrap() { + "event.subscribe" => continue, + "model.list" => json!({"providers":[]}), + "thread.info" => { + serde_json::to_value(thread(payload["threadId"].as_str().unwrap())) + .unwrap() + } + "thread.cancel" => json!({"cancelled": payload["messageId"] != "promoted"}), + "thread.update" => json!({"updated":true}), + "thread.fork" => json!({"thread":thread("fork"), "text": + if payload["mode"] == "before" {Some("edit me")} else {None}}), + "thread.page" => { + json!({"entries":[entry("old", 1, "user", json!([{"type":"text","text":"older prompt"}]))]}) + } + "thread.sync" => { + let item = + json!({"_tag":"Synced", "storeId":"store", "rev":4, "floor":1}); + ws.send(Message::Text( + json!({"_tag":"Chunk", "requestId":request["id"], "values":[item]}) + .to_string(), + )) + .await + .unwrap(); + continue; + } + other => panic!("unexpected RPC {other}"), + }; + ws.send(Message::Text( + json!({"_tag":"Exit", "requestId":request["id"], + "exit":{"_tag":"Success", "value":value}}) + .to_string(), + )) + .await + .unwrap(); + } + }); + } + }); + Server { url, calls, task } +} + +#[tokio::test] +async fn queue_keyboard_actions_obey_server_results_and_preserve_composer() { + let server = server().await; + let (tx, mut rx) = mpsc::unbounded_channel(); + let mut app = App::with_client(tx, RpcClient::new(&server.url)); + app.session = Some(thread("main")); + app.screen = Screen::Session; + app.prompt.insert_text("unsent draft"); + for id in ["queued", "promoted", "remove"] { + app.apply_item(ThreadItem::Inbox { + prompt: serde_json::from_value(json!({ + "id":id,"text":"edit me","delivery":"followUp"})) + .unwrap(), + state: crate::types::InboxState::Pending, + rev: 1, + }); + } + key(&mut app, KeyCode::Up, KeyModifiers::ALT); + key(&mut app, KeyCode::Char('l'), KeyModifiers::NONE); + receive(&mut app, &mut rx).await; + assert_eq!(server.calls.lock().await[0]["payload"]["delivery"], "steer"); + key(&mut app, KeyCode::Char('e'), KeyModifiers::NONE); + key(&mut app, KeyCode::Char('u'), KeyModifiers::CONTROL); + app.update(AppEvent::Paste("rewritten".into())); + key(&mut app, KeyCode::Enter, KeyModifiers::NONE); + receive(&mut app, &mut rx).await; + assert_eq!(server.calls.lock().await[1]["payload"]["text"], "rewritten"); + assert!(server.calls.lock().await[1]["payload"] + .get("delivery") + .is_none()); + assert_eq!(app.prompt.text(), "unsent draft"); + // A failed cancellation cannot put an already-promoted message into the composer. + key(&mut app, KeyCode::Down, KeyModifiers::NONE); + key(&mut app, KeyCode::Char('w'), KeyModifiers::NONE); + receive(&mut app, &mut rx).await; + assert_eq!(app.prompt.text(), "unsent draft"); + key(&mut app, KeyCode::Up, KeyModifiers::NONE); + key(&mut app, KeyCode::Char('w'), KeyModifiers::NONE); + receive(&mut app, &mut rx).await; + assert_eq!(app.prompt.text(), "rewritten\n\nunsent draft"); + assert_eq!(app.queued_prompts.len(), 2); + key(&mut app, KeyCode::Up, KeyModifiers::ALT); + key(&mut app, KeyCode::Down, KeyModifiers::NONE); + key(&mut app, KeyCode::Delete, KeyModifiers::NONE); + receive(&mut app, &mut rx).await; + assert_eq!(app.prompt.text(), "rewritten\n\nunsent draft"); + assert_eq!(app.queued_prompts.len(), 1); + assert_eq!(app.queued_prompts[0].message_id, "promoted"); + assert_eq!(server.calls.lock().await.len(), 5); + app.busy = true; + app.session.as_mut().unwrap().parked = false; + key(&mut app, KeyCode::Char('l'), KeyModifiers::NONE); + receive(&mut app, &mut rx).await; + assert_eq!( + app.queued_prompts[0].delivery, + crate::types::PromptDelivery::Steer + ); + key(&mut app, KeyCode::Char('l'), KeyModifiers::NONE); + receive(&mut app, &mut rx).await; + assert_eq!( + app.queued_prompts[0].delivery, + crate::types::PromptDelivery::FollowUp + ); +} + +#[tokio::test] +async fn fork_picker_transitions_at_and_before_and_subscribes() { + for mode in ["at", "before"] { + let server = server().await; + let (tx, mut rx) = mpsc::unbounded_channel(); + let mut app = App::with_client(tx, RpcClient::new(&server.url)); + app.session = Some(thread("main")); + app.entries = vec![entry( + "u", + 2, + "user", + json!([{"type":"text","text":"edit me"}]), + )]; + app.screen = Screen::Session; + app.open_fork(); + key( + &mut app, + if mode == "before" { + KeyCode::Char('b') + } else { + KeyCode::Enter + }, + KeyModifiers::NONE, + ); + receive(&mut app, &mut rx).await; + assert_eq!(app.session.as_ref().unwrap().id, "fork"); + assert_eq!( + app.prompt.text(), + if mode == "before" { "edit me" } else { "" } + ); + while app.floor.is_none() { + receive(&mut app, &mut rx).await; + } + let calls = server.calls.lock().await; + assert_eq!(calls[0]["tag"], "thread.fork"); + assert_eq!(calls[0]["payload"]["mode"], mode); + let sync = calls.iter().find(|c| c["tag"] == "thread.sync").unwrap(); + assert_eq!(sync["payload"]["threadId"], "fork"); + } +} + +#[tokio::test] +async fn scroll_pages_older_history_without_moving_held_content() { + let server = server().await; + let (tx, mut rx) = mpsc::unbounded_channel(); + let mut app = App::with_client(tx, RpcClient::new(&server.url)); + app.session = Some(thread("main")); + app.screen = Screen::Session; + app.apply_item(ThreadItem::Entry { + entry: entry("new", 8, "user", json!([{"type":"text","text":"newer"}])), + rev: 8, + }); + app.apply_item(ThreadItem::Synced { + store_id: "store".into(), + rev: 8, + floor: Some(8), + }); + app.max_scroll.set(20); + app.scroll = 19; + app.update(AppEvent::Scroll(3)); + app.update(AppEvent::Scroll(3)); // only one request in flight + receive(&mut app, &mut rx).await; + assert_eq!( + app.entries.iter().map(|e| e.seq).collect::>(), + vec![1, 8] + ); + assert_eq!(app.scroll, 20); // offset from bottom stays fixed on prepend + assert_eq!(app.floor, Some(1)); + let calls = server.calls.lock().await; + assert_eq!(calls.len(), 1); + assert_eq!( + calls[0]["payload"], + json!({"sessionId":"session","threadId":"main","before":8,"limit":60}) + ); +} + +#[test] +fn work_log_separates_final_answer_and_folds_on_phase_change() { + let mut entries = vec![ + entry("u", 1, "user", json!([{"type":"text","text":"Question"}])), + entry( + "a1", + 2, + "assistant", + json!([{"type":"thinking","thinking":"Reasoning"}, + {"type":"text","text":"Intermediate note"}, {"type":"toolCall","callID":"c","name":"read", + "status":"completed","time":{"start":1000,"end":63000}}]), + ), + entry( + "a2", + 3, + "assistant", + json!([{"type":"text","text":"Final answer"}]), + ), + ]; + let turns = turns_from_history(&entries); + assert_eq!(turns[0].text, "Final answer"); + assert_eq!(turns[0].notes, "Intermediate note"); + assert_eq!(turns[0].duration(), "1m 2s"); + assert!(!turns[0].work_expanded()); + entries.pop(); + entries[1].state = "draft".into(); + entries[1] + .parts + .retain(|p| !matches!(p, crate::types::Part::Text { .. })); + let mut turn = turns_from_history(&entries).remove(0); + assert!(turn.work_expanded()); + turn.work_open = Some(false); + assert!(!turn.work_expanded()); + for (ms, label) in [(0, "1s"), (59500, "1m"), (3600000, "1h 0m")] { + assert_eq!(crate::app::format_elapsed(ms), label); + } +} + +#[test] +fn streamed_deltas_and_stale_checkpoints_preserve_unicode_and_settled_entries() { + let mut app = App::default(); + let mut reply = entry("a", 2, "assistant", json!([{"type":"text","text":"Hi"}])); + reply.state = "draft".into(); + app.apply_item(ThreadItem::Entry { + entry: reply.clone(), + rev: 1, + }); + let delta = serde_json::from_value( + json!({"entryId":"a","partIndex":0,"kind":"text","offset":2,"delta":" 🦀"}), + ) + .unwrap(); + app.apply_item(ThreadItem::Delta { delta }); + app.apply_item(ThreadItem::Entry { + entry: reply.clone(), + rev: 1, + }); + assert_eq!(app.turns[0].text, "Hi 🦀"); + reply.state = "committed".into(); + app.apply_item(ThreadItem::Entry { + entry: reply.clone(), + rev: 2, + }); + reply.state = "draft".into(); + app.apply_item(ThreadItem::Entry { + entry: reply, + rev: 1, + }); + assert_eq!(app.entries[0].state, "committed"); +} + +#[test] +fn renders_repeatable_conversation_artifact_and_osc52() { + let mut app = App::default(); + app.session = Some(thread("main")); + app.screen = Screen::Session; + app.apply_item(ThreadItem::Entry { + entry: entry( + "u", + 1, + "user", + json!([{"type":"text","text":"Explain the change"}]), + ), + rev: 1, + }); + app.apply_item(ThreadItem::Entry { + entry: entry( + "a", + 2, + "assistant", + json!([{"type":"thinking","thinking":"Hidden reasoning"}, + {"type":"text","text":"The conversation is ready."}]), + ), + rev: 2, + }); + app.apply_item(ThreadItem::Inbox { + prompt: serde_json::from_value( + json!({"id":"q","text":"Next question","delivery":"followUp"}), + ) + .unwrap(), + state: crate::types::InboxState::Pending, + rev: 3, + }); + let mut terminal = Terminal::new(TestBackend::new(88, 18)).unwrap(); + terminal.draw(|frame| crate::ui::view(&app, frame)).unwrap(); + let buffer = terminal.backend().buffer(); + let rendered = (0..18) + .map(|y| { + (0..88) + .map(|x| buffer[(x, y)].symbol()) + .collect::() + .trim_end() + .to_string() + }) + .collect::>() + .join("\n"); + let mut rendered = rendered; + for (ms, normalized) in [(1000, "00:00"), (62500, "00:01")] { + let local = chrono::DateTime::from_timestamp_millis(ms) + .unwrap() + .with_timezone(&chrono::Local) + .format("%H:%M") + .to_string(); + rendered = rendered.replace(&local, normalized); + } + let path = + std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("__artifacts__/conversation.txt"); + if std::env::var_os("UPDATE_ARTIFACTS").is_some() { + std::fs::create_dir_all(path.parent().unwrap()).unwrap(); + std::fs::write(&path, &rendered).unwrap(); + } + assert_eq!( + rendered, + std::fs::read_to_string(path) + .expect("run UPDATE_ARTIFACTS=1 cargo test to create artifact") + ); + assert_eq!(crate::app::osc52("hello"), "\x1b]52;c;aGVsbG8=\x07"); + assert_eq!(crate::app::osc52("🦀"), "\x1b]52;c;8J+mgA==\x07"); +} + +#[test] +fn late_operations_cannot_mutate_a_different_thread_or_subscription() { + use crate::app::OperationResult; + use crate::event::RpcEvent; + use crate::rpc::protocol::ThreadRefPayload; + let mut app = App::default(); + app.session = Some(thread("main")); + let old = ThreadRefPayload { + session_id: "session".into(), + thread_id: "other".into(), + }; + let result = Ok(OperationResult::Cancel { + id: "q".into(), + restore: Some("stale".into()), + cancelled: true, + }); + app.update(AppEvent::rpc(RpcEvent::Operation { + address: old, + generation: 0, + result, + })); + assert!(app.prompt.text().is_empty()); + app.update(AppEvent::rpc(RpcEvent::Operation { + address: ThreadRefPayload { + session_id: "session".into(), + thread_id: "main".into(), + }, + generation: 99, + result: Ok(OperationResult::Fork(crate::rpc::protocol::ForkResponse { + thread: thread("wrong"), + text: Some("stale".into()), + })), + })); + assert_eq!(app.session.as_ref().unwrap().id, "main"); +} + +#[test] +fn work_log_manual_override_resets_when_final_answer_starts_streaming() { + let mut app = App::default(); + let mut reply = entry( + "a", + 2, + "assistant", + json!([{"type":"thinking","thinking":"Working"}]), + ); + reply.state = "draft".into(); + app.apply_item(ThreadItem::Entry { + entry: reply.clone(), + rev: 1, + }); + assert!(app.turns[0].work_expanded()); + key(&mut app, KeyCode::Char('o'), KeyModifiers::CONTROL); + assert!(!app.turns[0].work_expanded()); + key(&mut app, KeyCode::Char('o'), KeyModifiers::CONTROL); + assert!(app.turns[0].work_expanded()); + reply.parts.push(crate::types::Part::Text { + text: "Answer".into(), + }); + app.apply_item(ThreadItem::Entry { + entry: reply, + rev: 2, + }); + assert!(!app.turns[0].work_expanded()); +} + +#[test] +fn deltas_before_entries_and_utf16_offsets_are_reconciled() { + let mut app = App::default(); + for (offset, delta) in [(0, "🦀"), (2, " hello")] { + app.apply_item(ThreadItem::Delta { + delta: serde_json::from_value( + json!({"entryId":"a","partIndex":0,"kind":"text","offset":offset,"delta":delta}), + ) + .unwrap(), + }); + } + let mut reply = entry("a", 1, "assistant", json!([])); + reply.state = "draft".into(); + app.apply_item(ThreadItem::Entry { + entry: reply, + rev: 1, + }); + assert_eq!(app.turns[0].text, "🦀 hello"); +} + +#[test] +fn live_tool_progress_survives_a_checkpoint_and_resets_with_the_store() { + use crate::event::RpcEvent; + use crate::rpc::{protocol::ThreadRefPayload, StreamEvent}; + let mut app = App::default(); + app.session = Some(thread("main")); + let mut reply = entry( + "a", + 2, + "assistant", + json!([{"type":"toolCall","callID":"c","name":"bash","arguments":{"command":"ls"},"status":"running"}]), + ); + reply.state = "draft".into(); + app.apply_item(ThreadItem::Entry { + entry: reply.clone(), + rev: 1, + }); + let envelope=serde_json::from_value(json!({"type":"session.tool.progress","data":{"threadId":"main","callID":"c","partial":{"content":[{"type":"text","text":"live output"}]}}})).unwrap(); + let address = ThreadRefPayload { + session_id: "session".into(), + thread_id: "main".into(), + }; + app.update(AppEvent::rpc(RpcEvent::ThreadStream { + address: address.clone(), + generation: 0, + event: StreamEvent::Event(envelope), + })); + app.apply_item(ThreadItem::Entry { + entry: reply.clone(), + rev: 2, + }); + assert_eq!(app.turns[0].tools[0].output.as_deref(), Some("live output")); + app.update(AppEvent::rpc(RpcEvent::ThreadStream { + address, + generation: 0, + event: StreamEvent::Reset, + })); + assert!(app.entries.is_empty()); + app.apply_item(ThreadItem::Entry { + entry: reply, + rev: 1, + }); + assert_eq!(app.entries.len(), 1); + assert!(app.turns[0].tools[0].output.is_none()); +} + +#[test] +fn failed_queue_action_does_not_unlock_another_in_flight_action() { + use crate::{app::OperationResult, event::RpcEvent, rpc::protocol::ThreadRefPayload}; + let mut app = App::default(); + app.session = Some(thread("main")); + app.queue_pending.extend(["a".into(), "b".into()]); + app.update(AppEvent::rpc(RpcEvent::Operation { + address: ThreadRefPayload { + session_id: "session".into(), + thread_id: "main".into(), + }, + generation: 0, + result: Ok(OperationResult::QueueFailed { + id: "a".into(), + error: "failed".into(), + }), + })); + assert!(!app.queue_pending.contains("a")); + assert!(app.queue_pending.contains("b")); +} diff --git a/packages/tui/src/types.rs b/packages/tui/src/types.rs index a4540821..f2d825a4 100644 --- a/packages/tui/src/types.rs +++ b/packages/tui/src/types.rs @@ -1,10 +1,22 @@ +use std::collections::BTreeMap; + use serde::{Deserialize, Serialize}; use serde_json::Value; +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct ServerHost { + pub name: String, +} + #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] pub struct ServerInfo { pub pid: u64, pub version: String, + #[serde(rename = "storeId")] + pub store_id: String, + pub rev: u64, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub host: Option, } #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] @@ -82,11 +94,12 @@ pub struct DefaultModel { pub struct ModelList { #[serde(default)] pub providers: Vec, - pub default: DefaultModel, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub default: Option, } #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct ProjectInfo { +pub struct ProjectSummary { pub id: String, pub name: String, } @@ -116,14 +129,154 @@ pub struct SandboxInfo { #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] pub struct SessionInfo { pub id: String, - pub title: String, + #[serde(rename = "spaceId")] + pub space_id: String, + pub slug: String, pub directory: String, #[serde(rename = "hostDir", default, skip_serializing_if = "Option::is_none")] pub host_dir: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pub sandbox: Option, #[serde(default, skip_serializing_if = "Option::is_none")] - pub project: Option, + pub project: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub tag: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub metadata: Option>, + #[serde(rename = "createdAt", default)] + pub created_at: u64, + #[serde(rename = "updatedAt", default)] + pub updated_at: u64, + #[serde(rename = "mainThreadId")] + pub main_thread_id: String, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)] +#[serde(tag = "kind")] +pub enum ThreadOrigin { + #[serde(rename = "main")] + #[default] + Main, + #[serde(rename = "fork")] + Fork { + #[serde(rename = "threadId")] + thread_id: String, + #[serde(rename = "entryId")] + entry_id: String, + cut: u64, + }, + #[serde(rename = "subagent")] + Subagent { + #[serde(rename = "threadId")] + thread_id: String, + #[serde(rename = "callId")] + call_id: String, + #[serde(rename = "entryId", default, skip_serializing_if = "Option::is_none")] + entry_id: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + cut: Option, + }, +} + +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)] +pub struct ThreadUsage { + #[serde(default)] + pub cost: f64, + #[serde(default)] + pub input: u64, + #[serde(default)] + pub output: u64, + #[serde(rename = "cacheRead", default)] + pub cache_read: u64, + #[serde(rename = "cacheWrite", default)] + pub cache_write: u64, +} + +impl ThreadUsage { + pub fn total_tokens(&self) -> u64 { + self.input + self.output + self.cache_read + self.cache_write + } +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)] +#[serde(rename_all = "lowercase")] +pub enum RunState { + #[default] + Idle, + Starting, + Running, +} + +impl RunState { + pub fn is_busy(self) -> bool { + !matches!(self, Self::Idle) + } +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "lowercase")] +pub enum RunOutcome { + Succeeded, + Failed, + Interrupted, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct FailureDetail { + #[serde(rename = "type")] + pub kind: String, + pub message: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub status: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(tag = "_tag")] +pub enum RunError { + #[serde(rename = "failed")] + Failed { error: FailureDetail }, + #[serde(rename = "runFailed")] + RunFailed { reason: String, message: String }, + #[serde(rename = "interrupted")] + Interrupted { reason: String }, +} + +impl RunError { + pub fn message(&self) -> &str { + match self { + Self::Failed { error } => error.message.as_str(), + Self::RunFailed { message, .. } => message.as_str(), + Self::Interrupted { reason } => reason.as_str(), + } + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct ThreadRun { + #[serde(rename = "startedAt", default)] + pub started_at: u64, + #[serde(rename = "endedAt", default, skip_serializing_if = "Option::is_none")] + pub ended_at: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub outcome: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct ThreadPlacement { + #[serde(rename = "spaceId")] + pub space_id: String, + pub directory: String, +} + +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] +pub struct ThreadInfo { + pub id: String, + #[serde(default)] + pub origin: ThreadOrigin, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub title: Option, #[serde(rename = "updatedAt", default)] pub updated_at: u64, #[serde(default, skip_serializing_if = "Option::is_none")] @@ -134,11 +287,65 @@ pub struct SessionInfo { skip_serializing_if = "Option::is_none" )] pub thinking_level: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub foundation: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub placement: Option, + #[serde(default)] + pub usage: ThreadUsage, + #[serde(rename = "runState", default)] + pub run_state: RunState, + #[serde( + rename = "runStateAt", + default, + skip_serializing_if = "Option::is_none" + )] + pub run_state_at: Option, + #[serde(rename = "lastRun", default, skip_serializing_if = "Option::is_none")] + pub last_run: Option, + #[serde(default)] + pub parked: bool, + #[serde(default)] + pub restarts: u64, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub attempt: Option, + #[serde(rename = "createdSeq", default)] + pub created_seq: u64, + #[serde(rename = "createdAt", default)] + pub created_at: u64, + pub session: SessionInfo, +} + +impl ThreadInfo { + /// Display title for headers and menus: `thread.title` when non-empty, falling back to + /// `thread.session.slug`, and finally `thread.id`. + pub fn display_title(&self) -> &str { + self.title + .as_deref() + .map(str::trim) + .filter(|t| !t.is_empty()) + .or_else(|| { + let slug = self.session.slug.trim(); + (!slug.is_empty()).then_some(slug) + }) + .unwrap_or(self.id.as_str()) + } + + /// Host or workspace directory where this thread operates. + pub fn working_directory(&self) -> &str { + self.session + .host_dir + .as_deref() + .or_else(|| self.placement.as_ref().map(|p| p.directory.as_str())) + .unwrap_or(&self.session.directory) + } } #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] pub struct HistoryEntry { pub id: String, + #[serde(rename = "threadId", default)] + pub thread_id: String, #[serde(default)] pub seq: u64, pub role: String, @@ -146,14 +353,81 @@ pub struct HistoryEntry { pub state: String, #[serde(rename = "createdAt", default)] pub created_at: u64, + #[serde(rename = "updatedAt", default)] + pub updated_at: u64, #[serde(default)] pub parts: Vec, + #[serde(default)] + pub size: u64, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error: Option, } fn default_entry_state() -> String { "committed".to_string() } +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct QueuedPrompt { + pub id: String, + pub delivery: PromptDelivery, + pub text: String, + #[serde(rename = "admittedSeq", default)] + pub admitted_seq: u64, + #[serde(rename = "createdAt", default)] + pub created_at: u64, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "lowercase")] +pub enum InboxState { + Pending, + Promoted, + Cancelled, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "lowercase")] +pub enum DeltaKind { + Text, + Thinking, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct LiveDelta { + #[serde(rename = "entryId")] + pub entry_id: String, + #[serde(rename = "partIndex")] + pub part_index: usize, + pub kind: DeltaKind, + pub offset: usize, + pub delta: String, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(tag = "_tag")] +pub enum ThreadItem { + Entry { + entry: HistoryEntry, + rev: u64, + }, + Inbox { + prompt: QueuedPrompt, + state: InboxState, + rev: u64, + }, + Synced { + #[serde(rename = "storeId")] + store_id: String, + rev: u64, + #[serde(default, skip_serializing_if = "Option::is_none")] + floor: Option, + }, + Delta { + delta: LiveDelta, + }, +} + #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] #[serde(tag = "type")] pub enum Part { @@ -214,17 +488,3 @@ pub struct ToolTime { pub start: u64, pub end: u64, } - -#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)] -pub struct UsageReport { - #[serde(rename = "totalTokens", default)] - pub total_tokens: u64, - #[serde(rename = "inputTokens", alias = "input", default)] - pub input_tokens: u64, - #[serde(rename = "outputTokens", alias = "output", default)] - pub output_tokens: u64, - #[serde(default)] - pub cost: f64, - #[serde(skip_serializing_if = "Option::is_none")] - pub model: Option, -} diff --git a/packages/tui/src/ui.rs b/packages/tui/src/ui.rs index 02c5ae98..9d28c2c7 100644 --- a/packages/tui/src/ui.rs +++ b/packages/tui/src/ui.rs @@ -5,6 +5,7 @@ mod badge; mod field; +mod git; mod glyphs; mod input; mod markdown; @@ -26,12 +27,16 @@ const GAP: u16 = 2; /// The line under the prompt, for each thing that can have the keyboard. Only keys the app answers /// are listed, so nothing here promises something that does not happen. -const HINTS: &str = "←→ move · / commands · esc quit"; +const HINTS: &str = "enter send · shift+enter/ctrl+j newline · ctrl+p threads · / commands"; const COMMAND_HINTS: &str = "↑↓ move · enter choose · esc close"; const THEME_HINTS: &str = "↑↓ move · type to search · enter choose · esc close"; /// Draw the active screen. pub fn view(app: &App, frame: &mut Frame) { + if app.git.open { + git::draw(app, frame); + return; + } match app.screen { Screen::Welcome => view_welcome(app, frame), Screen::Session => session::draw(app, frame), @@ -57,14 +62,19 @@ fn view_welcome(app: &App, frame: &mut Frame) { // // On a frame too short for the whole column it is the wordmark that goes first: the line you // type into outranks the word above it. - let below = GAP + input::HEIGHT + GAP + 1; + let prompt_height = input::height( + &app.prompt, + area.width.min(input::WIDTH), + area.height.saturating_sub(GAP * 2 + 1), + ); + let below = GAP + prompt_height + GAP + 1; let art_rows = wordmark::rows(area.width) .unwrap_or(0) .min(area.height.saturating_sub(below)); let [art, _, prompt, _, mut hint] = Layout::vertical([ Constraint::Length(art_rows), Constraint::Length(GAP), - Constraint::Length(input::HEIGHT), + Constraint::Length(prompt_height), Constraint::Length(GAP), Constraint::Length(1), ]) @@ -94,7 +104,7 @@ fn view_welcome(app: &App, frame: &mut Frame) { let searchable = popup.search().is_some(); let wanted = menu::height(popup.menu(), searchable); let room = area.bottom().saturating_sub(prompt.bottom()); - let reserve = if room >= wanted + GAP + 1 { GAP + 1 } else { 2 }; + let reserve = if room > wanted + GAP { GAP + 1 } else { 2 }; let room_with_hint = room.saturating_sub(reserve); let min_rows = if searchable { 5 } else { 3 }; let max_height = if room_with_hint >= min_rows { @@ -129,7 +139,7 @@ fn view_welcome(app: &App, frame: &mut Frame) { // repainting the lattice behind the line in the hint's colour instead of the grid's. let hints = match (&app.notice, &app.popup) { (Some(notice), _) => notice.as_str(), - (None, Some(Popup::Commands(_) | Popup::Thinking(_))) => COMMAND_HINTS, + (None, Some(Popup::Commands(_) | Popup::Thinking(_) | Popup::Fork(_))) => COMMAND_HINTS, (None, Some(Popup::Themes { .. } | Popup::Models { .. } | Popup::Sessions { .. })) => { THEME_HINTS } diff --git a/packages/tui/src/ui/git.rs b/packages/tui/src/ui/git.rs new file mode 100644 index 00000000..cf6f7b9a --- /dev/null +++ b/packages/tui/src/ui/git.rs @@ -0,0 +1,263 @@ +//! Git review uses the same patch renderer as inline edit tools, with an independent viewport. +use super::text::{elide, width}; +use crate::{app::App, git::Git}; +use ratatui::{ + layout::{Constraint, Layout, Rect}, + style::Style, + text::{Line, Span}, + widgets::{Block, Paragraph, Wrap}, + Frame, +}; + +pub fn draw(app: &App, frame: &mut Frame) { + let area = frame.area(); + let palette = app.theme; + frame.render_widget( + Block::default().style(Style::default().bg(palette.bg)), + area, + ); + if area.width < 12 || area.height < 6 { + return; + } + let [heading, summary, body, notice, hints] = Layout::vertical([ + Constraint::Length(1), + Constraint::Length(1), + Constraint::Fill(1), + Constraint::Length(2), + Constraint::Length(1), + ]) + .areas(area); + let git = &app.git; + let mut title = "Git Changes".to_string(); + if let Some(status) = &git.status { + if status.available { + title.push_str(&format!( + " · {} · {}", + status + .branch + .as_deref() + .unwrap_or(if status.head.is_some() { + "detached HEAD" + } else { + "unborn branch" + }), + status + .head + .as_deref() + .map(|head| head.chars().take(8).collect::()) + .unwrap_or_else(|| "no commits".into()) + )); + } + } + frame.render_widget( + Paragraph::new(title).style(Style::default().fg(palette.brand)), + heading, + ); + let counts = git + .status + .as_ref() + .map(|status| { + format!( + "{} files · +{} -{} · working tree vs HEAD", + status.files.len(), + status.files.iter().map(|f| f.additions).sum::(), + status.files.iter().map(|f| f.deletions).sum::() + ) + }) + .unwrap_or_else(|| "Working-tree review".into()); + frame.render_widget( + Paragraph::new(counts).style(Style::default().fg(palette.text_muted)), + summary, + ); + if area.width >= 90 { + let [files, patch] = Layout::horizontal([ + Constraint::Length((area.width / 3).clamp(28, 42)), + Constraint::Fill(1), + ]) + .areas(body); + draw_files(git, frame, files, palette); + draw_patch(git, frame, patch, palette); + } else if git.patch_focus { + draw_patch(git, frame, body, palette); + } else { + draw_files(git, frame, body, palette); + } + let mut notes = Vec::new(); + if let Some(error) = &git.connection_error { + notes.push(format!("Git status disconnected: {error}")); + } + if let Some(diff) = &git.diff { + if diff.cached { + notes.push("cached · server snapshot; the space is not mounted".into()); + } + if diff.truncated { + notes.push("truncated · some patches or files were omitted by the server".into()); + } + } + frame.render_widget( + Paragraph::new(notes.join("\n")).style(Style::default().fg(palette.warning())), + notice, + ); + frame.render_widget( + Paragraph::new( + "↑↓ move/scroll · tab focus · [] files · n/p hunks · v view · r refresh · esc back", + ) + .style(Style::default().fg(palette.text_muted)), + hints, + ); +} + +fn message(frame: &mut Frame, area: Rect, text: &str, palette: &crate::theme::Palette) { + frame.render_widget( + Paragraph::new(text) + .wrap(Wrap { trim: false }) + .style(Style::default().fg(palette.text_secondary)), + area, + ); +} +fn draw_files(git: &Git, frame: &mut Frame, area: Rect, palette: &crate::theme::Palette) { + let block = Block::bordered() + .title(" Files ") + .border_style(Style::default().fg(if git.patch_focus { + palette.border_subtle + } else { + palette.brand + })); + let inner = block.inner(area); + frame.render_widget(block, area); + let Some(status) = &git.status else { + message(frame,inner,"Git status is not available yet. The server publishes it when the space is mounted by a run.",palette); + return; + }; + if !status.available { + let reason = status + .message + .as_deref() + .unwrap_or(match status.reason.as_deref() { + Some("not-a-repository") => "This directory is not a Git repository.", + Some("git-missing") => "Git is unavailable on the server.", + _ => "Git status could not be read.", + }); + message(frame, inner, reason, palette); + return; + } + if status.files.is_empty() { + message(frame, inner, "Working tree clean", palette); + return; + } + let selected = status + .files + .iter() + .position(|file| Some(&file.file) == git.selected.as_ref()) + .unwrap_or(0); + let start = selected.saturating_sub(inner.height as usize / 2); + for (row, file) in status + .files + .iter() + .skip(start) + .take(inner.height as usize) + .enumerate() + { + let active = Some(&file.file) == git.selected.as_ref(); + let counts = format!(" +{} -{}", file.additions, file.deletions); + let room = (inner.width as usize).saturating_sub(width(&counts) + 4); + let path = elide(&file.file, room); + let line = Line::from(vec![ + Span::styled( + if active { "❯ " } else { " " }, + Style::default().fg(palette.brand), + ), + Span::styled( + format!("{} ", file.status.label()), + Style::default().fg(palette.text_muted), + ), + Span::styled( + path, + Style::default().fg(if active { + palette.text + } else { + palette.text_secondary + }), + ), + Span::styled(counts, Style::default().fg(palette.text_muted)), + ]); + frame.render_widget( + Paragraph::new(line).style(Style::default().bg(if active { + palette.surface_2 + } else { + palette.bg + })), + Rect { + y: inner.y + row as u16, + height: 1, + ..inner + }, + ); + } +} +fn draw_patch(git: &Git, frame: &mut Frame, area: Rect, palette: &crate::theme::Palette) { + let title = format!( + " {} · {} ", + git.selected.as_deref().unwrap_or("Patch"), + git.view.label() + ); + let block = Block::bordered() + .title(elide(&title, area.width.saturating_sub(2) as usize)) + .border_style(Style::default().fg(if git.patch_focus { + palette.brand + } else { + palette.border_subtle + })); + let inner = block.inner(area); + frame.render_widget(block, area); + git.width.set(inner.width as usize); + if git.loading { + message(frame, inner, "Loading patch…", palette); + return; + } + if let Some(error) = &git.error { + message(frame, inner, error, palette); + return; + } + if git.selected.is_none() { + message( + frame, + inner, + "Select a changed file to review its patch.", + palette, + ); + return; + } + if git.diff.is_none() { + message(frame, inner, "Press r to load the selected patch.", palette); + return; + } + let rendered = git.rendered(inner.width as usize, palette); + git.max_scroll + .set(rendered.lines.len().saturating_sub(inner.height as usize)); + if rendered.lines.is_empty() { + message( + frame, + inner, + if git.diff.as_ref().is_some_and(|diff| diff.truncated) { + "Text patch unavailable; the server response is truncated." + } else { + "No text hunks available (binary, metadata-only, or omitted patch)." + }, + palette, + ); + return; + } + let start = git.scroll.min(git.max_scroll.get()); + frame.render_widget( + Paragraph::new( + rendered + .lines + .into_iter() + .skip(start) + .take(inner.height as usize) + .collect::>(), + ), + inner, + ); +} diff --git a/packages/tui/src/ui/input.rs b/packages/tui/src/ui/input.rs index 8fa19dc9..e3ec95c5 100644 --- a/packages/tui/src/ui/input.rs +++ b/packages/tui/src/ui/input.rs @@ -17,7 +17,7 @@ use ratatui::widgets::{Block, Widget}; use unicode_width::UnicodeWidthStr; use super::badge; -use super::text::{fitted, scrolled}; +use super::text::fitted; use crate::prompt::Prompt; use crate::theme::Palette; @@ -53,38 +53,59 @@ pub fn draw_in( prompt: &Prompt, palette: &Palette, ) -> Option<(u16, u16)> { - // Measured rather than assumed to be two cells: a terminal that draws `❯` wide would - // otherwise put the caret a column out. let marker = MARKER.width() as u16; - // Too narrow for a marker and a line, or too short for the border: the box is all or nothing. - if column.width < marker + 2 || column.height < HEIGHT { + if column.width < marker + 4 || column.height < HEIGHT { return None; } let block = Block::bordered().border_style(Style::default().fg(palette.border_strong)); let inner = block.inner(column); block.render(column, buffer); - - // The tag rides the top border, as the site's badge does. badge::draw(buffer, column, TAG, palette); - - for x in inner.x..inner.x + inner.width { - buffer[(x, inner.y)].set_char(' '); - } - - // One column stays free at the end of the line, because that is where a terminal puts the - // caret once the text fills the rest. - let text_x = inner.x + marker; let usable = inner.width.saturating_sub(marker + 1) as usize; + let layout = prompt.layout(usable); + let start = layout + .caret + .1 + .saturating_sub(inner.height.saturating_sub(1) as usize); + for row in 0..inner.height { + for x in inner.x..inner.right() { + buffer[(x, inner.y + row)].set_char(' '); + } + let at = start + row as usize; + if let Some(line) = layout.lines.get(at) { + buffer.set_string( + inner.x, + inner.y + row, + if at == 0 { MARKER } else { "· " }, + Style::default().fg(palette.brand), + ); + if prompt.text().is_empty() { + buffer.set_string( + inner.x + marker, + inner.y + row, + fitted(PLACEHOLDER, usable), + Style::default().fg(palette.text_muted), + ); + } else { + buffer.set_string( + inner.x + marker, + inner.y + row, + line, + Style::default().fg(palette.text), + ); + } + } + } + Some(( + inner.x + marker + layout.caret.0 as u16, + inner.y + (layout.caret.1 - start) as u16, + )) +} - buffer.set_string(inner.x, inner.y, MARKER, Style::default().fg(palette.brand)); - let (caret_x, text, ink) = if prompt.text().is_empty() { - (text_x, fitted(PLACEHOLDER, usable), palette.text_muted) - } else { - let (text, offset) = scrolled(prompt.text(), prompt.before_caret(), usable); - (text_x + offset, text, palette.text) - }; - buffer.set_string(text_x, inner.y, text, Style::default().fg(ink)); - Some((caret_x, inner.y)) +/// Grow to six visible text rows, then scroll the composer to keep its caret visible. +pub fn height(prompt: &Prompt, width: u16, available: u16) -> u16 { + let usable = width.saturating_sub(MARKER.width() as u16 + 3) as usize; + (prompt.layout(usable).lines.len().clamp(1, 6) as u16 + 2).min(available.max(HEIGHT)) } /// The box's own rect: [`WIDTH`] wide and centred in `area`, and no larger than it. @@ -97,6 +118,6 @@ pub fn centred(area: Rect) -> Rect { x: area.x + (area.width - width) / 2, y: area.y, width, - height: area.height.min(HEIGHT), + height: area.height, } } diff --git a/packages/tui/src/ui/session.rs b/packages/tui/src/ui/session.rs index cdb82569..d6417421 100644 --- a/packages/tui/src/ui/session.rs +++ b/packages/tui/src/ui/session.rs @@ -17,9 +17,9 @@ use crate::app::{App, Popup, TurnState}; use crate::diff::{self, DEFAULT_MAX_DIFF_LINES}; use crate::tool::{self, ToolRow, ToolStatus}; -const IDLE_HINTS: &str = "enter send · ↑↓/wheel scroll · / commands · esc quit"; +const IDLE_HINTS: &str = "enter send · ctrl+j newline · ctrl+p threads · alt+↑ queue · ctrl+o work"; const BUSY_HINTS: &str = - "enter steer · alt+enter follow-up · ↑↓/wheel scroll · / commands · esc interrupt"; + "enter steer · alt+enter follow-up · ctrl+j newline · ctrl+p threads · esc stop"; const COMMAND_HINTS: &str = "↑↓ move · enter choose · esc close"; const SEARCH_HINTS: &str = "↑↓ move · type to search · enter choose · esc close"; @@ -36,11 +36,20 @@ pub fn draw(app: &App, frame: &mut Frame) { return; } - let [header, rule, body, prompt, hint] = Layout::vertical([ + let tray_height = (app.queued_prompts.len() + usize::from(!app.queued_prompts.is_empty())) + .min(6) + .min(area.height.saturating_sub(7) as usize) as u16; + let [header, rule, body, tray, prompt, hint] = Layout::vertical([ Constraint::Length(1), Constraint::Length(1), Constraint::Fill(1), - Constraint::Length(input::HEIGHT), + Constraint::Length(tray_height), + Constraint::Length(input::height( + &app.prompt, + area.width + .saturating_sub(if area.width < 44 { 2 } else { 4 }), + area.height.saturating_sub(tray_height + 5), + )), Constraint::Length(1), ]) .areas(area); @@ -75,6 +84,15 @@ pub fn draw(app: &App, frame: &mut Frame) { }, ); + draw_queue( + app, + frame, + Rect { + x: column.x, + width: column.width, + ..tray + }, + ); let prompt_box = Rect { x: column.x, y: prompt.y, @@ -106,16 +124,24 @@ pub fn draw(app: &App, frame: &mut Frame) { ); } - if let Some(caret) = menu_caret.or(prompt_caret) { + if let Some(caret) = menu_caret + .or(prompt_caret) + .filter(|_| app.queue_edit.is_none()) + { frame.set_cursor_position(caret); } let hints = match (&app.notice, &app.popup) { (Some(notice), _) => notice.as_str(), + (None, Some(Popup::Fork(_))) => "↑↓ message · enter fork at · b before user · esc close", (None, Some(Popup::Commands(_) | Popup::Thinking(_))) => COMMAND_HINTS, (None, Some(Popup::Themes { .. } | Popup::Models { .. } | Popup::Sessions { .. })) => { SEARCH_HINTS } + (None, None) if app.queue_edit.is_some() => "enter save · esc cancel edit", + (None, None) if app.queue_focus.is_some() => { + "↑↓ move · l lane/send now · e edit · w withdraw · del remove · esc composer" + } (None, None) if app.busy => BUSY_HINTS, (None, None) => IDLE_HINTS, }; @@ -137,7 +163,7 @@ fn draw_header(app: &App, frame: &mut Frame, area: Rect) { let title = app .session .as_ref() - .map(|s| s.title.as_str()) + .map(|s| s.display_title()) .filter(|t| !t.is_empty()) .unwrap_or("session"); @@ -148,13 +174,25 @@ fn draw_header(app: &App, frame: &mut Frame, area: Rect) { meta.push_str(&thinking); } } - if app.usage.total_tokens > 0 { + if let Some(usage) = app + .session + .as_ref() + .map(|t| &t.usage) + .filter(|u| u.total_tokens() > 0) + { meta.push_str(&format!( " · {} tok · ${:.4}", - app.usage.total_tokens, app.usage.cost + usage.total_tokens(), + usage.cost )); } + if let Some(branch) = app.git.branch_label() { + meta = elide( + &format!("{branch} · {meta}"), + area.width.saturating_sub(12).min(area.width / 2) as usize, + ); + } let meta_width = text::width(&meta) as u16; let right_x = if meta_width + 6 <= area.width { let x = area.right() - meta_width; @@ -177,7 +215,7 @@ fn draw_header(app: &App, frame: &mut Frame, area: Rect) { // On wider terminals, show the session's working directory beside its title. if area.width >= 64 { if let Some(session) = &app.session { - let dir = session.host_dir.as_deref().unwrap_or(&session.directory); + let dir = session.working_directory(); let title_cols = text::width(fitted_title) as u16; let dir_x = area.x + 2 + title_cols + 2; if dir_x + 8 < right_x { @@ -224,163 +262,204 @@ fn draw_transcript(app: &App, frame: &mut Frame, area: Rect) { ])); } - // Reasoning / thinking - if !turn.thinking.is_empty() { - for (line_idx, chunk) in wrap(turn.thinking.trim(), wrap_width.saturating_sub(2)) - .into_iter() - .enumerate() - { - let prefix = if line_idx == 0 { " ◌ " } else { " " }; - lines.push(Line::from(vec![ - Span::styled(prefix, Style::default().fg(palette.text_muted)), - Span::styled(chunk, Style::default().fg(palette.text_muted)), - ])); - } + if turn.prompt_id.is_some() && turn.created_at > 0 { + lines.push(Line::from(Span::styled( + format!(" {}", clock_time(turn.created_at)), + Style::default().fg(palette.text_muted), + ))); + } + if turn.has_work() || turn.working() || turn.answer_present { + let icon = if turn.working() { + "●" + } else if turn.work_expanded() { + "▾" + } else { + "▸" + }; + let label = if turn.working() { + format!("{} working…", app.model_label()) + } else { + format!("{} worked for {}", app.model_label(), turn.duration()) + }; + let focused = if app.focused_turn == Some(idx) { + ">" + } else { + " " + }; + lines.push(Line::from(Span::styled( + format!("{focused} {icon} {label}"), + Style::default().fg(palette.text_muted), + ))); } + if turn.work_expanded() { + // Reasoning / thinking + if !turn.thinking.is_empty() { + for (line_idx, chunk) in wrap(turn.thinking.trim(), wrap_width.saturating_sub(2)) + .into_iter() + .enumerate() + { + let prefix = if line_idx == 0 { " ◌ " } else { " " }; + lines.push(Line::from(vec![ + Span::styled(prefix, Style::default().fg(palette.text_muted)), + Span::styled(chunk, Style::default().fg(palette.text_muted)), + ])); + } + } - // Tool calls (grouped when 3+ identical non-diff calls settle in a row) - for row in tool::group(&turn.tools) { - match row { - ToolRow::Single(tool) => { - if let Some(patch) = &tool.patch { - let counts = diff::counts(patch); - let path = tool - .target - .clone() - .or_else(|| diff::patch_path(patch)) - .unwrap_or_else(|| tool.name.clone()); - let spans = vec![ - Span::styled(" ← ", Style::default().fg(palette.brand)), - Span::styled("Edit ", Style::default().fg(palette.text)), - Span::styled(path, Style::default().fg(palette.text_secondary)), - Span::styled(" (", Style::default().fg(palette.text_muted)), - Span::styled( - format!("+{}", counts.added), - Style::default().fg(palette.success()), - ), - Span::raw(" "), - Span::styled( - format!("-{}", counts.removed), - Style::default().fg(palette.error()), - ), - Span::styled(")", Style::default().fg(palette.text_muted)), + if !turn.notes.is_empty() { + for mut line in markdown::render(&turn.notes, wrap_width.saturating_sub(2), palette) + { + line.spans.insert(0, Span::raw(" ")); + lines.push(line); + } + } + // Tool calls (grouped when 3+ identical non-diff calls settle in a row) + for row in tool::group(&turn.tools) { + match row { + ToolRow::Single(tool) => { + if let Some(patch) = &tool.patch { + let counts = diff::counts(patch); + let path = tool + .target + .clone() + .or_else(|| diff::patch_path(patch)) + .unwrap_or_else(|| tool.name.clone()); + let spans = vec![ + Span::styled(" ← ", Style::default().fg(palette.brand)), + Span::styled("Edit ", Style::default().fg(palette.text)), + Span::styled(path, Style::default().fg(palette.text_secondary)), + Span::styled(" (", Style::default().fg(palette.text_muted)), + Span::styled( + format!("+{}", counts.added), + Style::default().fg(palette.success()), + ), + Span::raw(" "), + Span::styled( + format!("-{}", counts.removed), + Style::default().fg(palette.error()), + ), + Span::styled(")", Style::default().fg(palette.text_muted)), + ]; + lines.push(Line::from(spans)); + + let diff_width = wrap_width.saturating_sub(4).max(16); + let (diff_lines, _) = diff::render_diff( + patch, + diff_width, + DEFAULT_MAX_DIFF_LINES, + palette, + ); + for mut dline in diff_lines { + dline.spans.insert(0, Span::raw(" ")); + lines.push(dline); + } + continue; + } + + let (icon, icon_color) = match tool.status { + ToolStatus::Running => (" ⚙ ", palette.brand), + ToolStatus::Completed => (" ✓ ", palette.success()), + ToolStatus::Failed => (" ✗ ", palette.error()), + }; + let mut spans = vec![ + Span::styled(icon, Style::default().fg(icon_color)), + Span::styled(tool.name.clone(), Style::default().fg(palette.text)), ]; + let mut used = 4 + text::width(&tool.name); + if let Some(target) = &tool.target { + let room = wrap_width.saturating_sub(used + 1); + if room > 4 { + let shown = elide(target, room); + used += 1 + text::width(&shown); + spans.push(Span::styled( + format!(" {shown}"), + Style::default().fg(palette.text_secondary), + )); + } + } + if let Some(summary) = &tool.summary { + let room = wrap_width.saturating_sub(used + 3); + if room > 4 { + let shown = elide(summary, room); + spans.push(Span::styled( + format!(" · {shown}"), + Style::default().fg(if tool.status == ToolStatus::Failed { + palette.error() + } else { + palette.text_muted + }), + )); + } + } lines.push(Line::from(spans)); - let diff_width = wrap_width.saturating_sub(4).max(16); - let (diff_lines, _) = - diff::render_diff(patch, diff_width, DEFAULT_MAX_DIFF_LINES, palette); - for mut dline in diff_lines { - dline.spans.insert(0, Span::raw(" ")); - lines.push(dline); + if tool.status == ToolStatus::Running { + if let Some(output) = &tool.output { + let mut preview: Vec<&str> = output + .lines() + .rev() + .filter(|line| !line.trim().is_empty()) + .take(3) + .collect(); + preview.reverse(); + for out_line in preview { + lines.push(Line::from(vec![ + Span::raw(" "), + Span::styled( + elide(out_line, wrap_width.saturating_sub(2)), + Style::default().fg(palette.text_muted), + ), + ])); + } + } + } else if tool.status == ToolStatus::Failed { + if let Some(output) = &tool.output { + for err_line in output.lines().take(3) { + lines.push(Line::from(vec![ + Span::raw(" "), + Span::styled( + elide(err_line, wrap_width.saturating_sub(2)), + Style::default().fg(palette.error()), + ), + ])); + } + } } - continue; } - - let (icon, icon_color) = match tool.status { - ToolStatus::Running => (" ⚙ ", palette.brand), - ToolStatus::Completed => (" ✓ ", palette.success()), - ToolStatus::Failed => (" ✗ ", palette.error()), - }; - let mut spans = vec![ - Span::styled(icon, Style::default().fg(icon_color)), - Span::styled(tool.name.clone(), Style::default().fg(palette.text)), - ]; - let mut used = 4 + text::width(&tool.name); - if let Some(target) = &tool.target { - let room = wrap_width.saturating_sub(used + 1); - if room > 4 { - let shown = elide(target, room); - used += 1 + text::width(&shown); + ToolRow::Run { + name, + members, + failed, + } => { + let (icon, icon_color) = if failed > 0 { + (" ✗ ", palette.error()) + } else { + (" ✓ ", palette.success()) + }; + let heading = format!("{name} ×{}", members.len()); + let targets = tool::run_targets(&members); + let room = wrap_width.saturating_sub(4 + text::width(&heading) + 3); + let mut spans = vec![ + Span::styled(icon, Style::default().fg(icon_color)), + Span::styled(heading, Style::default().fg(palette.text)), + ]; + if !targets.is_empty() && room > 4 { spans.push(Span::styled( - format!(" {shown}"), - Style::default().fg(palette.text_secondary), + format!(" · {}", elide(&targets, room)), + Style::default().fg(palette.text_muted), )); } - } - if let Some(summary) = &tool.summary { - let room = wrap_width.saturating_sub(used + 3); - if room > 4 { - let shown = elide(summary, room); + if failed > 0 { spans.push(Span::styled( - format!(" · {shown}"), - Style::default().fg(if tool.status == ToolStatus::Failed { - palette.error() - } else { - palette.text_muted - }), + format!(" · {failed} failed"), + Style::default().fg(palette.error()), )); } + lines.push(Line::from(spans)); } - lines.push(Line::from(spans)); - - if tool.status == ToolStatus::Running { - if let Some(output) = &tool.output { - let mut preview: Vec<&str> = output - .lines() - .rev() - .filter(|line| !line.trim().is_empty()) - .take(3) - .collect(); - preview.reverse(); - for out_line in preview { - lines.push(Line::from(vec![ - Span::raw(" "), - Span::styled( - elide(out_line, wrap_width.saturating_sub(2)), - Style::default().fg(palette.text_muted), - ), - ])); - } - } - } else if tool.status == ToolStatus::Failed { - if let Some(output) = &tool.output { - for err_line in output.lines().take(3) { - lines.push(Line::from(vec![ - Span::raw(" "), - Span::styled( - elide(err_line, wrap_width.saturating_sub(2)), - Style::default().fg(palette.error()), - ), - ])); - } - } - } - } - ToolRow::Run { - name, - members, - failed, - } => { - let (icon, icon_color) = if failed > 0 { - (" ✗ ", palette.error()) - } else { - (" ✓ ", palette.success()) - }; - let heading = format!("{name} ×{}", members.len()); - let targets = tool::run_targets(&members); - let room = wrap_width.saturating_sub(4 + text::width(&heading) + 3); - let mut spans = vec![ - Span::styled(icon, Style::default().fg(icon_color)), - Span::styled(heading, Style::default().fg(palette.text)), - ]; - if !targets.is_empty() && room > 4 { - spans.push(Span::styled( - format!(" · {}", elide(&targets, room)), - Style::default().fg(palette.text_muted), - )); - } - if failed > 0 { - spans.push(Span::styled( - format!(" · {failed} failed"), - Style::default().fg(palette.error()), - )); - } - lines.push(Line::from(spans)); } } } - // Plugin / runtime notices for notice in &turn.notices { for (line_idx, chunk) in wrap(notice, wrap_width.saturating_sub(2)) @@ -404,6 +483,12 @@ fn draw_transcript(app: &App, frame: &mut Frame, area: Rect) { } } + if turn.state != TurnState::Running && turn.updated_at > 0 { + lines.push(Line::from(Span::styled( + format!(" {} · /fork · ctrl+y copy", clock_time(turn.updated_at)), + Style::default().fg(palette.text_muted), + ))); + } // Retry backoff status (`session.retry.scheduled`) if let Some(retry) = &turn.retry { let delay = if retry.delay_ms >= 1_000 && retry.delay_ms % 1_000 == 0 { @@ -477,30 +562,6 @@ fn draw_transcript(app: &App, frame: &mut Frame, area: Rect) { } } - // Queued prompts (`session.prompt.admitted` / pending steer & follow-up inputs) - for queued in &app.queued_prompts { - if !lines.is_empty() { - lines.push(Line::default()); - } - let status = if queued.admitted { "queued" } else { "sending" }; - let badge = format!(" ↳ [{} · {status}] ", queued.delivery.label()); - let badge_width = text::width(&badge); - let first_width = wrap_width.saturating_sub(badge_width).max(8); - for (line_idx, chunk) in wrap(&queued.prompt, first_width).into_iter().enumerate() { - if line_idx == 0 { - lines.push(Line::from(vec![ - Span::styled(badge.clone(), Style::default().fg(palette.brand)), - Span::styled(chunk, Style::default().fg(palette.text_secondary)), - ])); - } else { - lines.push(Line::from(vec![ - Span::raw(" ".repeat(badge_width)), - Span::styled(chunk, Style::default().fg(palette.text_secondary)), - ])); - } - } - } - let total_lines = lines.len(); let visible = area.height as usize; let max_scroll = total_lines.saturating_sub(visible); @@ -539,11 +600,9 @@ fn draw_scrollbar( let thumb_h = ((visible * track_h) / total_lines).clamp(1, track_h); let max_start = total_lines.saturating_sub(visible); let max_thumb_top = track_h.saturating_sub(thumb_h); - let thumb_top = if max_start == 0 { - 0 - } else { - (start * max_thumb_top + (max_start / 2)) / max_start - }; + let thumb_top = (start * max_thumb_top + max_start / 2) + .checked_div(max_start) + .unwrap_or(0); let x = area.right().saturating_sub(1); let buffer = frame.buffer_mut(); @@ -559,3 +618,82 @@ fn draw_scrollbar( } } } + +fn clock_time(ms: u64) -> String { + chrono::DateTime::from_timestamp_millis(ms.min(i64::MAX as u64) as i64) + .map(|date| { + date.with_timezone(&chrono::Local) + .format("%H:%M") + .to_string() + }) + .unwrap_or_default() +} + +fn draw_queue(app: &App, frame: &mut Frame, area: Rect) { + if area.height == 0 { + return; + } + let parked = app.session.as_ref().is_some_and(|t| t.parked); + let heading = if parked { + "Queued · parked · l Send Now" + } else { + "Queued · alt+↑ to manage" + }; + frame.render_widget( + Paragraph::new(heading).style(Style::default().fg(app.theme.text_muted)), + Rect { height: 1, ..area }, + ); + let rows = area.height.saturating_sub(1) as usize; + let selected = app + .queue_focus + .as_ref() + .and_then(|id| app.queued_prompts.iter().position(|q| &q.message_id == id)) + .unwrap_or(0); + let start = selected.saturating_sub(rows.saturating_sub(1)); + for (row, q) in app.queued_prompts.iter().skip(start).take(rows).enumerate() { + let focused = app.queue_focus.as_ref() == Some(&q.message_id); + let prefix = format!( + "{} [{}{}] ", + if focused { "❯" } else { "↳" }, + q.delivery.label(), + if app.queue_pending.contains(&q.message_id) { + " · saving" + } else if !q.admitted { + " · sending" + } else { + "" + } + ); + let rect = Rect { + y: area.y + 1 + row as u16, + height: 1, + ..area + }; + if let Some(edit) = app.queue_edit.as_ref().filter(|e| e.id == q.message_id) { + let prefix_width = text::width(&prefix); + let usable = (rect.width as usize).saturating_sub(prefix_width + 1); + let (line, before) = edit.text.current_line(); + let (shown, offset) = text::scrolled(line, before, usable); + frame.render_widget( + Paragraph::new(format!("{prefix}{shown}")) + .style(Style::default().fg(app.theme.brand)), + rect, + ); + frame.set_cursor_position(( + rect.x + (prefix_width as u16 + offset).min(rect.width.saturating_sub(1)), + rect.y, + )); + } else { + frame.render_widget( + Paragraph::new(format!("{prefix}{}", q.prompt.replace('\n', " ↵ "))).style( + Style::default().fg(if focused { + app.theme.brand + } else { + app.theme.text_secondary + }), + ), + rect, + ); + } + } +} diff --git a/packages/tui/src/ui/wordmark.rs b/packages/tui/src/ui/wordmark.rs index bee2fdd3..df816898 100644 --- a/packages/tui/src/ui/wordmark.rs +++ b/packages/tui/src/ui/wordmark.rs @@ -63,12 +63,9 @@ fn cell(upper: bool, lower: bool) -> char { /// The glyph to draw in a frame this wide: the wordmark, else the mark, else nothing. fn glyph_for(width: usize) -> Option<&'static Glyph> { - for glyph in [&WORDMARK, &MARK] { - if glyph.width + MARGIN * 2 <= width { - return Some(glyph); - } - } - None + [&WORDMARK, &MARK] + .into_iter() + .find(|glyph| glyph.width + MARGIN * 2 <= width) } /// How many terminal rows the glyph for a frame this wide needs, or `None` when no glyph fits the diff --git a/packages/tui/tests/composer.rs b/packages/tui/tests/composer.rs new file mode 100644 index 00000000..7922ff84 --- /dev/null +++ b/packages/tui/tests/composer.rs @@ -0,0 +1,160 @@ +//! Real-binary PTY coverage of multiline sending, live browser updates and restart persistence. +#![cfg(unix)] +use futures_util::{SinkExt, StreamExt}; +use serde_json::{json, Value}; +use std::{ + process::{Command, Stdio}, + sync::Arc, + time::{Duration, SystemTime, UNIX_EPOCH}, +}; +use tokio::sync::{mpsc, Mutex}; +use tokio_tungstenite::{accept_async, tungstenite::Message}; + +#[tokio::test] +async fn multiline_drafts_and_live_browser_survive_a_real_restart() { + let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap(); + let url = format!("ws://{}", listener.local_addr().unwrap()); + let calls = Arc::new(Mutex::new(Vec::::new())); + let recorded = calls.clone(); + let renamed = Arc::new(std::sync::atomic::AtomicBool::new(false)); + let task = tokio::spawn(async move { + loop { + let (socket, _) = listener.accept().await.unwrap(); + let calls = recorded.clone(); + let renamed = renamed.clone(); + tokio::spawn(async move { + let (mut write, mut read) = accept_async(socket).await.unwrap().split(); + let (tx, mut rx) = mpsc::unbounded_channel::(); + loop { + tokio::select! { + Some(item)=rx.recv()=>{if write.send(Message::Text(item.to_string())).await.is_err(){break;}}, + message=read.next()=>{ + let Some(Ok(Message::Text(text)))=message else {break;}; + let request:Value=serde_json::from_str(text.trim()).unwrap();if request["_tag"]!="Request" {continue;} + let tag=request["tag"].as_str().unwrap();let id=&request["id"];let payload=&request["payload"]; + calls.lock().await.push(json!({"tag":tag,"payload":payload})); + let thread=|id:&str|json!({"id":id,"title":if id=="main" {if renamed.load(std::sync::atomic::Ordering::SeqCst) {"Updated conversation"} else {"Original conversation"}}else{"Fork conversation"},"createdAt":1,"session":{"id":"session","spaceId":"space","slug":"Chat","directory":"/workspace","mainThreadId":"main","project":{"id":"project","name":"CodeWork"}},"origin":if id=="main"{json!({"kind":"main"})}else{json!({"kind":"fork","threadId":"main","entryId":"u","cut":1})}}); + let value=match tag { + "server.info"=>json!({"pid":1,"version":"test","storeId":"store","rev":2}), + "model.list"=>json!({"providers":[]}), + "thread.list"=>json!([thread("main"),thread("fork")]), + "thread.info"=>thread(payload["threadId"].as_str().unwrap()), + "index.sync"=>{ + let id=id.clone();tx.send(json!({"_tag":"Chunk","requestId":id,"values":[{"_tag":"Synced","storeId":"store","rev":1}]})).unwrap(); + if !renamed.load(std::sync::atomic::Ordering::SeqCst) {let tx=tx.clone();let renamed=renamed.clone();tokio::spawn(async move {tokio::time::sleep(Duration::from_millis(700)).await;renamed.store(true,std::sync::atomic::Ordering::SeqCst);let _=tx.send(json!({"_tag":"Chunk","requestId":id,"values":[{"_tag":"Synced","storeId":"store","rev":2}]}));});} + continue; + }, + "thread.sync"=>{tx.send(json!({"_tag":"Chunk","requestId":id,"values":[{"_tag":"Synced","storeId":"store","rev":2,"floor":1}]})).unwrap();continue;}, + "event.subscribe"=>continue, + "thread.prompt"=>json!({"threadId":payload["threadId"]}), + other=>panic!("unexpected {other}"), + }; + let _=tx.send(json!({"_tag":"Exit","requestId":id,"exit":{"_tag":"Success","value":value}})); + } + } + } + }); + } + }); + let home = std::env::temp_dir().join(format!( + "codework-tui-composer-{}-{}", + std::process::id(), + SystemTime::now() + .duration_since(UNIX_EPOCH) + .unwrap() + .as_nanos() + )); + let test_home = home.clone(); + let script = r#" +import os, pty, select, subprocess, sys, time, fcntl, termios, struct +output=bytearray() +def start(): + global master, child, output + output=bytearray() + master,slave=pty.openpty() + fcntl.ioctl(slave,termios.TIOCSWINSZ,struct.pack('HHHH',28,110,0,0)) + child=subprocess.Popen([sys.argv[1]],stdin=slave,stdout=slave,stderr=slave,close_fds=True) + os.close(slave);wait(b'\x1b[?2026l') +def drain(seconds=.18): + end=time.monotonic()+seconds + while time.monotonic()= 4); + let sent: Vec<_> = calls + .iter() + .filter(|c| c["tag"] == "thread.prompt") + .collect(); + assert_eq!(sent.len(), 1, "{calls:?}"); + assert_eq!(sent[0]["payload"]["text"], "fn main() {\n 🦀\n}\ntail"); + assert_eq!(sent[0]["payload"]["threadId"], "main"); + let mut saved = Vec::::new(); + fn drafts(path: &std::path::Path, out: &mut Vec) { + for entry in std::fs::read_dir(path).unwrap() { + let path = entry.unwrap().path(); + if path.is_dir() { + drafts(&path, out); + } else if path.extension().is_some_and(|ext| ext == "json") { + out.push(serde_json::from_str(&std::fs::read_to_string(path).unwrap()).unwrap()); + } + } + } + drafts(&home.join("tui/drafts"), &mut saved); + assert!(saved.iter().any(|s| s["text"] == "fork draft")); + let artifact = json!({"sent":{"sessionId":"session","threadId":"main","text":sent[0]["payload"]["text"],"delivery":sent[0]["payload"]["delivery"]},"savedDrafts":saved}); + let rendered = serde_json::to_string_pretty(&artifact).unwrap() + "\n"; + let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("__artifacts__/composer.json"); + if std::env::var_os("UPDATE_ARTIFACTS").is_some() { + std::fs::write(&path, &rendered).unwrap(); + } + assert_eq!( + rendered, + std::fs::read_to_string(path).expect("run UPDATE_ARTIFACTS=1 cargo test") + ); + std::fs::remove_dir_all(home).unwrap(); +} diff --git a/packages/tui/tests/git.rs b/packages/tui/tests/git.rs new file mode 100644 index 00000000..be495736 --- /dev/null +++ b/packages/tui/tests/git.rs @@ -0,0 +1,189 @@ +//! Real CLI + PTY + real Git repo behind a deterministic RPC peer. +#![cfg(unix)] +use futures_util::{SinkExt, StreamExt}; +use serde_json::{json, Value}; +use std::{ + path::Path, + process::{Command, Stdio}, + sync::{ + atomic::{AtomicUsize, Ordering}, + Arc, + }, + time::{Duration, SystemTime, UNIX_EPOCH}, +}; +use tokio::sync::{mpsc, Mutex}; +use tokio_tungstenite::{accept_async, tungstenite::Message}; +fn git(root: &Path, args: &[&str]) -> String { + let result = Command::new("git") + .args(args) + .current_dir(root) + .output() + .unwrap(); + assert!( + result.status.success() || result.status.code() == Some(1), + "{}", + String::from_utf8_lossy(&result.stderr) + ); + String::from_utf8(result.stdout).unwrap() +} +#[tokio::test] +async fn reviews_real_git_changes_without_running_git_in_the_tui() { + let root = std::env::temp_dir().join(format!( + "codework-tui-git-{}-{}", + std::process::id(), + SystemTime::now() + .duration_since(UNIX_EPOCH) + .unwrap() + .as_nanos() + )); + let repo = root.join("repo"); + std::fs::create_dir_all(repo.join("src")).unwrap(); + git(&repo, &["init", "-q", "--initial-branch=main"]); + let original = (1..=25).map(|n| format!("line {n}\n")).collect::(); + std::fs::write(repo.join("src/main.rs"), &original).unwrap(); + std::fs::write(repo.join("obsolete.txt"), "remove me\n").unwrap(); + git(&repo, &["add", "."]); + git( + &repo, + &[ + "-c", + "user.name=TUI Test", + "-c", + "user.email=tui@example.test", + "-c", + "commit.gpgsign=false", + "commit", + "-qm", + "fixture", + ], + ); + std::fs::write( + repo.join("src/main.rs"), + original + .replace("line 2\n", "new value\n") + .replace("line 22\n", "last hunk\n"), + ) + .unwrap(); + std::fs::remove_file(repo.join("obsolete.txt")).unwrap(); + std::fs::write(repo.join("notes with spaces.txt"), "New notes\n").unwrap(); + let head = git(&repo, &["rev-parse", "HEAD"]).trim().to_string(); + let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap(); + let url = format!("ws://{}", listener.local_addr().unwrap()); + let calls = Arc::new(Mutex::new(Vec::::new())); + let recorded = calls.clone(); + let patch_reads = Arc::new(AtomicUsize::new(0)); + let thread = json!({"id":"main","session":{"id":"session","spaceId":"space","slug":"Git integration","directory":"/workspace","mainThreadId":"main"}}); + let status = json!({"spaceId":"space","observedAt":1,"available":true,"branch":"main","head":head,"files":[{"file":"notes with spaces.txt","status":"added","additions":1,"deletions":0},{"file":"obsolete.txt","status":"deleted","additions":0,"deletions":1},{"file":"src/main.rs","status":"modified","additions":2,"deletions":2}]}); + let task = tokio::spawn(async move { + loop { + let (socket, _) = listener.accept().await.unwrap(); + let calls = recorded.clone(); + let thread = thread.clone(); + let status = status.clone(); + let repo = repo.clone(); + let reads = patch_reads.clone(); + tokio::spawn(async move { + let (mut write, mut read) = accept_async(socket).await.unwrap().split(); + let (tx, mut rx) = mpsc::unbounded_channel::(); + loop { + tokio::select! { + Some(value)=rx.recv()=>{if write.send(Message::Text(value.to_string())).await.is_err(){break;}}, + message=read.next()=>{ + let Some(Ok(Message::Text(text)))=message else {break;};let request:Value=serde_json::from_str(text.trim()).unwrap();if request["_tag"]!="Request" {continue;} + let tag=request["tag"].as_str().unwrap();let id=&request["id"];let payload=&request["payload"];calls.lock().await.push(json!({"tag":tag,"payload":payload})); + let value=match tag { + "server.info"=>json!({"pid":1,"version":"test","storeId":"store","rev":1}),"model.list"=>json!({"providers":[]}),"thread.list"=>json!([thread]),"thread.info"=>thread.clone(), + "index.sync"|"thread.sync"=>{tx.send(json!({"_tag":"Chunk","requestId":id,"values":[{"_tag":"Synced","storeId":"store","rev":1,"floor":1}]})).unwrap();continue;}, + "event.subscribe"=>{ + if payload["types"].as_array().is_some_and(|types|types.iter().any(|t|t=="plugin.git.status")) { + assert!(payload.get("threadId").is_none()); + tx.send(json!({"_tag":"Chunk","requestId":id,"values":[{"type":"server.connected","data":{}},{"type":"plugin.git.status","data":status}]})).unwrap(); + }continue; + }, + "daemon.call"=>{ + assert_eq!(payload["plugin"],"git");assert_eq!(payload["method"],"diff");assert_eq!(payload["spaceId"],"space"); + let file=payload["input"]["files"][0].as_str().unwrap();let entry=status["files"].as_array().unwrap().iter().find(|s|s["file"]==file).unwrap(); + let patch=if entry["status"]=="added" {git(&repo,&["diff","--no-index","--","/dev/null",file])}else{git(&repo,&["diff","HEAD","--",file])}; + let count=reads.fetch_add(1,Ordering::SeqCst);json!({"cached":count>2,"truncated":count>2,"files":[{"file":file,"status":entry["status"],"additions":entry["additions"],"deletions":entry["deletions"],"patch":patch}]}) + },other=>panic!("unexpected {other}"), + }; + tx.send(json!({"_tag":"Exit","requestId":id,"exit":{"_tag":"Success","value":value}})).unwrap(); + } + } + } + }); + } + }); + let test_home = root.join("home"); + let script = r#" +import os,pty,select,subprocess,sys,time,fcntl,termios,struct,re +master,slave=pty.openpty();fcntl.ioctl(slave,termios.TIOCSWINSZ,struct.pack('HHHH',26,120,0,0)) +child=subprocess.Popen([sys.argv[1]],stdin=slave,stdout=slave,stderr=slave,close_fds=True);os.close(slave);output=bytearray() +def drain(seconds=.2): + end=time.monotonic()+seconds + while time.monotonic() = calls + .iter() + .filter(|c| c["tag"] == "daemon.call") + .map(|c| c["payload"].clone()) + .collect(); + assert!(reviewed + .iter() + .any(|p| p["input"]["files"][0] == "src/main.rs")); + assert!(reviewed + .iter() + .any(|p| p["input"]["files"][0] == "obsolete.txt")); + let rendered = serde_json::to_string_pretty(&reviewed).unwrap() + "\n"; + let artifact = Path::new(env!("CARGO_MANIFEST_DIR")).join("__artifacts__/git.json"); + if std::env::var_os("UPDATE_ARTIFACTS").is_some() { + std::fs::write(&artifact, &rendered).unwrap(); + } + assert_eq!( + rendered, + std::fs::read_to_string(artifact).expect("run UPDATE_ARTIFACTS=1 cargo test") + ); + std::fs::remove_dir_all(root).unwrap(); +} diff --git a/packages/tui/tests/terminal.rs b/packages/tui/tests/terminal.rs new file mode 100644 index 00000000..9c0a427a --- /dev/null +++ b/packages/tui/tests/terminal.rs @@ -0,0 +1,175 @@ +//! Spawn the real terminal binary against a deterministic wire peer. Verifies the +//! actual stdin → RPC → terminal rendering path, including OSC 52 over a PTY. +use futures_util::{SinkExt, StreamExt}; +use serde_json::{json, Value}; +use std::{ + process::{Command, Stdio}, + sync::Arc, + time::Duration, +}; +use tokio::sync::{mpsc, Mutex}; +use tokio_tungstenite::{accept_async, tungstenite::Message}; + +#[tokio::test] +async fn terminal_conversation_queue_fork_copy_and_page() { + let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap(); + let url = format!("ws://{}", listener.local_addr().unwrap()); + let calls = Arc::new(Mutex::new(Vec::::new())); + let thread = json!({"id":"main","session":{"id":"session","spaceId":"space","slug":"Terminal test","directory":"/workspace","mainThreadId":"main"},"parked":true}); + let entry = |id: &str, seq: u64, role: &str, text: &str| json!({"id":id,"threadId":"main","seq":seq,"role":role,"state":"committed","createdAt":1000,"updatedAt":2000,"parts":[{"type":"text","text":text}]}); + let user = entry("u", 8, "user", "Question"); + let answer = entry("a", 9, "assistant", "Terminal answer"); + let older = entry("old", 1, "user", "Older question"); + let queued = json!({"id":"q","text":"Queued question","delivery":"followUp"}); + let subscribers = Arc::new(Mutex::new(Vec::>::new())); + let recorded = calls.clone(); + let task = tokio::spawn(async move { + loop { + let (socket, _) = listener.accept().await.unwrap(); + let calls = recorded.clone(); + let thread = thread.clone(); + let user = user.clone(); + let answer = answer.clone(); + let older = older.clone(); + let queued = queued.clone(); + let subscribers = subscribers.clone(); + tokio::spawn(async move { + let (mut write, mut read) = accept_async(socket).await.unwrap().split(); + let (tx, mut rx) = mpsc::unbounded_channel::(); + loop { + tokio::select! { + Some(item)=rx.recv()=>{if write.send(Message::Text(item.to_string())).await.is_err() {break;}}, + message=read.next()=>{ + let Some(Ok(Message::Text(text)))=message else {break;}; + let request:Value=serde_json::from_str(text.trim()).unwrap(); + if request["_tag"]!="Request" {continue;} + calls.lock().await.push(json!({"tag":request["tag"],"payload":request["payload"]})); + let id=&request["id"];let payload=&request["payload"]; + let value=match request["tag"].as_str().unwrap() { + "server.info"=>json!({"pid":1,"version":"test","storeId":"store","rev":10}), + "model.list"=>json!({"providers":[]}), + "thread.list"=>json!([thread]), + "index.sync"=>{tx.send(json!({"_tag":"Chunk","requestId":id,"values":[{"_tag":"Synced","storeId":"store","rev":10}]})).unwrap();continue;}, + "thread.info"=>thread.clone(), + "thread.sync"=>{ + subscribers.lock().await.push(tx.clone()); + let items=if payload["threadId"]=="fork" {vec![json!({"_tag":"Synced","storeId":"store","rev":10,"floor":1})]} + else {vec![json!({"_tag":"Entry","entry":user,"rev":8}),json!({"_tag":"Entry","entry":answer,"rev":9}),json!({"_tag":"Inbox","prompt":queued,"state":"pending","rev":10}),json!({"_tag":"Synced","storeId":"store","rev":10,"floor":8})]}; + tx.send(json!({"_tag":"Chunk","requestId":id,"values":items})).unwrap();continue; + }, + "event.subscribe"=>continue, + "thread.cancel"=>json!({"cancelled":true}), + "thread.update"=>json!({"updated":true}), + "thread.page"=>json!({"entries":[older]}), + "thread.fork"=>{let mut fork=thread.clone();fork["id"]=json!("fork");json!({"thread":fork,"text":"Question"})}, + other=>panic!("unexpected RPC {other}"), + }; + tx.send(json!({"_tag":"Exit","requestId":id,"exit":{"_tag":"Success","value":value}})).unwrap(); + } + } + } + }); + } + }); + // Python's standard-library PTY keeps this test independent of a terminal emulator. + let script = r#" +import os, pty, select, subprocess, sys, time +master, slave = pty.openpty() +import fcntl, termios, struct +fcntl.ioctl(slave, termios.TIOCSWINSZ, struct.pack('HHHH', 24, 100, 0, 0)) +child = subprocess.Popen([sys.argv[1]], stdin=slave, stdout=slave, stderr=slave, close_fds=True) +os.close(slave) +output = bytearray() +def drain(seconds=.2): + end=time.monotonic()+seconds + while time.monotonic() = calls + .iter() + .filter(|c| { + matches!( + c["tag"].as_str(), + Some("thread.update" | "thread.cancel" | "thread.fork" | "thread.page") + ) + }) + .cloned() + .collect(); + let rendered = serde_json::to_string_pretty(&selected).unwrap() + "\n"; + let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("__artifacts__/terminal.json"); + if std::env::var_os("UPDATE_ARTIFACTS").is_some() { + std::fs::create_dir_all(path.parent().unwrap()).unwrap(); + std::fs::write(&path, &rendered).unwrap(); + } + assert_eq!( + rendered, + std::fs::read_to_string(path).expect("run UPDATE_ARTIFACTS=1 cargo test") + ); +}