From bbbc8a212740f9d3d391c6d035151513ec473307 Mon Sep 17 00:00:00 2001 From: prem315 Date: Sat, 14 Nov 2026 17:15:14 +0530 Subject: [PATCH 1/4] feat: metrics page backed by a durable usage rollup (#165) --- packages/tui/src/event.rs | 20 +-- packages/tui/src/rpc/mod.rs | 2 +- packages/tui/src/rpc/protocol.rs | 114 ++++++------ packages/tui/src/types.rs | 296 +++++++++++++++++++++++++++++-- 4 files changed, 340 insertions(+), 92 deletions(-) diff --git a/packages/tui/src/event.rs b/packages/tui/src/event.rs index e60f00ea..b49d5bde 100644 --- a/packages/tui/src/event.rs +++ b/packages/tui/src/event.rs @@ -10,32 +10,30 @@ 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 { + ThreadStream { session_id: String, + thread_id: String, event: StreamEvent, }, ServerInfoLoaded(Result), ModelsLoaded(Result), - SessionsLoaded(Result, String>), - SessionHistoryRefresh { + ThreadsLoaded(Result, String>), + ThreadInfoLoaded { session_id: String, + thread_id: String, + result: Result, }, - SessionHistoryLoaded { - session_id: String, - request_id: u64, - revision: u64, - result: Result, String>, - }, - SessionConfigured(Result), + ThreadConfigured(Result), PluginsReloaded(Result<(u64, Option), String>), PromptDispatched { session_id: String, + thread_id: String, message_id: String, result: Result<(), String>, }, diff --git a/packages/tui/src/rpc/mod.rs b/packages/tui/src/rpc/mod.rs index 141bc5e3..cbe4761b 100644 --- a/packages/tui/src/rpc/mod.rs +++ b/packages/tui/src/rpc/mod.rs @@ -1,4 +1,4 @@ pub mod client; pub mod protocol; -pub use client::{RpcClient, StreamEvent}; +pub use client::{RpcClient, StreamEvent, SyncCursor}; diff --git a/packages/tui/src/rpc/protocol.rs b/packages/tui/src/rpc/protocol.rs index b5c94c87..9667d12a 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,14 +98,6 @@ 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)] pub struct EventEnvelope { pub id: Option, @@ -110,42 +105,13 @@ pub struct EventEnvelope { 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,13 @@ 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, Deserialize)] -pub struct SessionMessageResponse { +pub struct ThreadMessageResponse { #[serde(default)] pub found: bool, } 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, -} From 821931be1de52be3831e73bfd82911c56f29aa1b Mon Sep 17 00:00:00 2001 From: prem315 Date: Sat, 14 Nov 2026 17:44:39 +0530 Subject: [PATCH 2/4] feat(tui): reach protocol parity for thread interactions - Add live thread sync, queue management, forking, paging, and work-log controls - Add model/thinking/session pickers and OSC 52 clipboard copying - Add terminal integration coverage and update TUI documentation --- packages/tui/Cargo.lock | 7 + packages/tui/Cargo.toml | 2 + packages/tui/README.md | 58 +- packages/tui/__artifacts__/conversation.txt | 18 + packages/tui/__artifacts__/terminal.json | 46 + packages/tui/src/app.rs | 4075 ++++++------------ packages/tui/src/event.rs | 54 +- packages/tui/src/main.rs | 2 + packages/tui/src/rpc/client.rs | 4230 ++----------------- packages/tui/src/rpc/mod.rs | 2 +- packages/tui/src/rpc/protocol.rs | 51 +- packages/tui/src/tests.rs | 549 +++ packages/tui/src/ui.rs | 4 +- packages/tui/src/ui/session.rs | 482 ++- packages/tui/src/ui/wordmark.rs | 9 +- packages/tui/tests/terminal.rs | 163 + 16 files changed, 2929 insertions(+), 6823 deletions(-) create mode 100644 packages/tui/__artifacts__/conversation.txt create mode 100644 packages/tui/__artifacts__/terminal.json create mode 100644 packages/tui/src/tests.rs create mode 100644 packages/tui/tests/terminal.rs 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..9d98ddb7 100644 --- a/packages/tui/README.md +++ b/packages/tui/README.md @@ -2,12 +2,9 @@ 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 model and thinking selection, queued prompt management, +collapsible work logs, conversation forks, clipboard copying, and older history on demand. --- @@ -81,20 +78,41 @@ 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 | +| `Alt+Enter` | Queue a follow-up | +| `↑` / `↓`, mouse wheel, `PageUp` / `PageDown` | Scroll (arrows when composer is empty); fetch older history at the top | +| `/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 restore to composer when cancellation succeeds | +| `Delete` / `d` in queue | Cancel without restoring | +| `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 | + +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). + +## 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. +It 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__/conversation.txt b/packages/tui/__artifacts__/conversation.txt new file mode 100644 index 00000000..d3552fde --- /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 · alt+↑ queue · ctrl+o work · ctrl+y copy · / commands \ No newline at end of file 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..70c63c3b 100644 --- a/packages/tui/src/app.rs +++ b/packages/tui/src/app.rs @@ -1,42 +1,39 @@ -//! 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::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("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 +44,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 +56,247 @@ 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 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 working(&self) -> bool { + self.state == TurnState::Running + && (!self.last_draft + || !self.answer_present + || self.tools.iter().any(|t| t.status == ToolStatus::Running)) } - - 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, +} 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, + 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(); } } - impl App { - pub fn new(tx: mpsc::UnboundedSender) -> Self { - let app = Self { + pub fn with_client(tx: mpsc::UnboundedSender, client: RpcClient) -> Self { + Self { screen: Screen::Welcome, theme: theme::default_palette(), prompt: Prompt::default(), @@ -389,1215 +307,419 @@ 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(), + 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(); + } + } + pub fn new(tx: mpsc::UnboundedSender) -> Self { + let app = Self::with_client(tx, RpcClient::default()); + 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 } - - 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}") - } - - /// 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.rebuild(); + } + pub fn switch_thread(&mut self, info: ThreadInfo) { + 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.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 { 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.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::Rpc(event) => self.handle_rpc(*event), } } - - 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); - } - if self.screen == Screen::Session { - return self.scroll_by(delta); - } - 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 let Some(edit) = &mut self.queue_edit { + return edit.text.insert_text(text); } - let changed = self.prompt.insert_text(text); - if changed { - self.notice = None; - self.sync_commands(); + match &mut self.popup { + Some( + Popup::Models { search, .. } + | Popup::Sessions { search, .. } + | Popup::Themes { search, .. }, + ) => { + search.insert_text(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 self.queue_edit.is_some() { + if key.code == KeyCode::Esc { + self.queue_edit = None; + 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)); + } + return true; + } + return self.queue_edit.as_mut().unwrap().text.edit(key); + } if key.code == KeyCode::Esc { - return self.escape(); + if let Some(popup) = self.popup.take() { + match popup { + Popup::Themes { initial, .. } => self.theme = initial, + Popup::Commands(_) => self.prompt.clear(), + _ => {} + } + return true; + } + if self.queue_focus.take().is_some() || self.focused_turn.take().is_some() { + return true; + } + if self.busy { + self.spawn_operation(|client, address| async move { + client.interrupt_thread(address).await?; + Ok(OperationResult::Notice("interrupt requested".into())) + }); + } else if !self.prompt.text().is_empty() { + self.prompt.clear(); + } else { + self.should_quit = true; + } + return true; } - if self.popup.is_some() { - if self.menu_key(key) { - return true; + if key.code == KeyCode::Char('b') && matches!(self.popup, Some(Popup::Fork(_))) { + return self.fork_selected(ForkMode::Before); + } + match key.code { + KeyCode::Up => return self.step_menu(-1), + KeyCode::Down => return self.step_menu(1), + KeyCode::Enter => return self.choose(), + _ => {} } match &mut self.popup { - Some(Popup::Themes { - search, - menu, - initial, - }) => { - if !search.edit(key) { - return false; - } - self.theme = filter_themes(search.text(), menu, *initial); + Some( + Popup::Models { search, .. } + | Popup::Sessions { search, .. } + | Popup::Themes { search, .. }, + ) => { + search.edit(key); + self.filter_popup(); return true; } - Some(Popup::Models { search, menu }) => { - if !search.edit(key) { - return false; + Some(Popup::Thinking(_) | Popup::Fork(_)) => return false, + _ => {} + } + } + 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; + } + 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()); } - let selected = menu.selected().map(|e| e.id.to_string()); - *menu = filter_models(search.text(), self.models.as_ref(), selected.as_deref()); return true; } - Some(Popup::Sessions { - search, - menu, - sessions, - }) => { - if !search.edit(key) { - return false; + 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) + }); } - *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 => {} - } - } - - 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); + KeyCode::Char('y') => { + self.copy_reply(); + return true; } _ => {} } } - - 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(); + 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; + } } - 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); - } - _ => {} - } - 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 - } - RpcEvent::SessionConfigured(Err(err)) => { - self.notice = Some(err); - true - } - RpcEvent::PluginsReloaded(Ok((count, failure))) => { - self.notice = Some(match failure { - Some(err) => format!("plugin reload failed: {err}"), - None => format!("reloaded {count} plugin(s)"), - }); - true - } - RpcEvent::PluginsReloaded(Err(err)) => { - self.notice = Some(err); - true - } - 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 - } - 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 - } - } - } - } - - 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); - } - _ => {} - } - } - - 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; + 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::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); - } - } + KeyCode::Down + if self.prompt.text().is_empty() || key.modifiers.contains(KeyModifiers::SHIFT) => + { + return self.scroll_by(-1) } - 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() + KeyCode::Enter => { + self.submit_prompt( + if key + .modifiers + .intersects(KeyModifiers::ALT | KeyModifiers::CONTROL) { - 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)); - } - } - } - if let Some(level) = thinking_level { - self.thinking = Some(level.clone()); - if let Some(session) = &mut self.session { - session.thinking_level = Some(level); - } - } - 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); - } - } - } - 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())); - } - } - StreamEvent::TurnEnded { message_id: _ } => { - if let Some(turn) = self.turns.last_mut() { - turn.retry = None; - } - } - 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()), - ); - } 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); - } - } - 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); - } - } - StreamEvent::ThinkingEnd { - message_id, - part_index, - content, - } => { - if let Some(turn) = self.turns.last_mut() { - turn.end_thinking_part(&message_id, part_index, content); - } - } - 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); - } - } - } - 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); - } - } - } - 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, - ); + PromptDelivery::FollowUp } else { - turn.tools.push(ToolCall::settled( - call_id, - name, - &arguments, - output, - details.as_ref(), - is_error, - )); - } - } - } - StreamEvent::Notice(notice) => { - if let Some(turn) = self.turns.last_mut() { - turn.notices.push(notice); - } - } - 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; - } - } - 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); - } - } - } - 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); - } - } - } - 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(); - } - 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; - } - StreamEvent::Interrupted(reason) => { - if let Some(turn) = self.turns.last_mut() { - turn.retry = None; - turn.state = TurnState::Interrupted(reason); - } - self.busy = false; - self.reconnecting = false; - } - } - 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; - } - - 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; - } - } - self.initial_prompt_id = Some(message_id.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(); - - 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; - } + PromptDelivery::Steer }, - }; - - 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()); - } - - true - } - - fn spawn_follow_session( - &mut self, - session_id: String, - after: Option, - initially_busy: bool, - ) { - let tx = self.tx.clone(); - 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()); - } - } - - 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 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(), - )); + return true; } + _ => {} } - for (text, delivery, message_id) in to_send { - self.spawn_send_prompt(session_id.to_string(), text, delivery, message_id); - } - for (text, delivery, message_id) in to_reconcile { - self.spawn_reconcile_prompt(session_id.to_string(), text, delivery, message_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 stop_prompt_stream(&mut self) { - if let Some(task) = self.prompt_stream.take() { - task.abort(); - } - self.initial_prompt_id = None; - } - - fn spawn_session_refresh(&self) { - let Some(session_id) = self.session.as_ref().map(|s| s.id.clone()) 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 self.prompt.edit(key) { + self.notice = None; + self.sync_commands(); + return true; } + false } - - /// 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(_))) { @@ -1606,373 +728,853 @@ impl App { return; }; let query = query.to_ascii_lowercase(); - let mut menu = match self.popup.take() { - Some(Popup::Commands(menu)) => menu, - _ => Menu::new(COMMANDS.to_vec()), + 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)) }; - menu.filter(|entry| entry.name.starts_with(&query)); - if !menu.entries().is_empty() { - self.popup = Some(Popup::Commands(menu)); - } } - - /// 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) + 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, .. }) => { + let needle = search.text().to_lowercase(); + menu.filter(|e| { + e.name.to_lowercase().contains(&needle) + || e.detail.to_lowercase().contains(&needle) + }); + } + _ => {} + } } - fn step_menu(&mut self, step: isize) -> bool { - let Some(popup) = &mut self.popup 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 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; + } } } true } - - /// Take the entry the cursor is on. 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(|popup| popup.menu().selected()) + .and_then(|p| p.menu().selected()) .cloned() else { return false; }; - let Some(popup) = self.popup.take() else { - return false; - }; - match popup { + match self.popup.take().unwrap() { 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(); - } - } - "session" => { - self.notice = Some("loading sessions...".to_string()); - self.spawn_list_sessions(); - } - "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(); - } - "reload" => { - self.notice = Some("reloading plugins...".to_string()); - self.spawn_reload_plugins(); - } - "theme" => { - self.popup = Some(Popup::Themes { - search: Prompt::default(), - menu: themes(self.theme.name), - initial: self.theme, - }); - } - "exit" => self.should_quit = true, - _ => {} - } + self.command(&chosen.id); } 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)); - } - self.notice = Some(format!("model set to {provider}/{id}")); - self.spawn_configure_session(); + if let Some(model) = parse_model(&chosen.id) { + self.model = Some(model); + self.configure(); } } 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(); + self.thinking = Some(chosen.id.to_string()); + self.configure(); } - 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); + Popup::Themes { .. } => { + if let Some(theme) = theme_named(&chosen.name) { + self.theme = theme; } } - Popup::Themes { .. } => { - if let Some(palette) = theme_named(&chosen.name) { - self.theme = palette; + Popup::Sessions { sessions, .. } => { + if let Some(info) = sessions.into_iter().find(|t| t.id == chosen.id.as_ref()) { + self.switch_thread(info); } } + Popup::Fork(_) => {} } 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 { .. } => {} + 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())), + }) } - return true; + "thinking" => { + self.popup = Some(Popup::Thinking(Menu::at( + self.thinking_entries(), + &self.thinking_label().unwrap_or_default(), + ))) + } + "theme" => { + self.popup = Some(Popup::Themes { + search: Prompt::default(), + menu: themes(self.theme.name), + initial: self.theme, + }) + } + "queue" => self.focus_queue(-1), + "fork" => self.open_fork(), + "copy" => self.copy_reply(), + "session" => { + let tx = self.tx.clone(); + let client = self.client.clone(); + if let Ok(handle) = tokio::runtime::Handle::try_current() { + handle.spawn(async move { + let _ = tx.send(AppEvent::rpc(RpcEvent::ThreadsLoaded( + client.list_threads().await, + ))); + }); + } + } + "new" => { + self.stop_stream(); + 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.screen = Screen::Welcome; + } + "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, + _ => {} } - if self.busy { - self.spawn_interrupt(); - self.notice = Some("interrupting turn...".to_string()); - return 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; } - if !self.prompt.text().is_empty() { - self.prompt.clear(); - return true; + 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); } - 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 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 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 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 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))); - }); + 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 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, - })); - }); - } + fn selected_queue(&self) -> Option<&QueuedPrompt> { + self.queued_prompts + .iter() + .find(|q| Some(&q.message_id) == self.queue_focus.as_ref()) } - - fn spawn_configure_session(&self) { - let Some(session) = &self.session else { + fn queue_cancel(&mut self, restore: bool) { + let Some(q) = self.selected_queue().cloned() 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))); - }); + 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, + }) + }); + } + 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; } + 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, + }) + }); } - - 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))); - }); + 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 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 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 spawn_interrupt(&self) { - let Some(session) = &self.session else { + 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 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; - }); } + 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}"), + }, + ); } - 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 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(result) => match result { + Ok(mut sessions) => { + sessions.sort_by_key(|a| std::cmp::Reverse(a.updated_at)); + let entries = sessions + .iter() + .map(|t| { + Entry::owned(t.id.clone(), t.display_title(), t.working_directory()) + }) + .collect(); + self.popup = Some(Popup::Sessions { + search: Prompt::default(), + menu: Menu::new(entries), + sessions, + }); + } + Err(error) => self.notice = Some(error), + }, + 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); + } } } - - if idx + 1 == total_next - && last_entry_is_user - && existing.state == TurnState::Running - && self.busy - { - turn.state = TurnState::Running; + 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); + } + } } - - if turn.state == TurnState::Running { - if turn.retry.is_none() { - turn.retry = existing.retry.clone(); + 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 { + self.prompt.clear(); + self.prompt.insert_text(&text); + 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 + } + 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; + } + 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()); + } + } + pub fn apply_item(&mut self, item: ThreadItem) { + match item { + ThreadItem::Synced { floor, .. } => { + if let Some(floor) = floor { + self.floor = Some(floor); } - 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(); + 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); } - 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(); + 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, + ); } - turn.sync_thinking(); - turn.sync_text(); - } - - if matches!( - existing.state, - TurnState::Failed(_) | TurnState::Interrupted(_) - ) || (existing.state == TurnState::Succeeded && turn.state == TurnState::Running) - { - turn.state = existing.state.clone(); - turn.retry = None; } - - for existing_tool in &existing.tools { + } + self.reconcile_focus(); + self.rebuild(); + } + fn apply_event(&mut self, envelope: crate::rpc::protocol::EventEnvelope) { + let Some(data) = envelope.data else { + return; + }; + if data.get("threadId").and_then(serde_json::Value::as_str) + != self.session.as_ref().map(|t| t.id.as_str()) + { + return; + } + let Some(turn) = self.turns.last_mut() else { + return; + }; + 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 == existing_tool.call_id) + .find(|t| t.call_id == id && t.status == ToolStatus::Running) { - 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(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")); } - } else if turn.state == TurnState::Running { - turn.tools.push(existing_tool.clone()); } } + "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 rebuild(&mut self) { + let mut turns = turns_from_history(&self.entries); 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()); + if let Some(last) = turns.last_mut() { + if matches!(last.state, TurnState::Succeeded) { + last.state = TurnState::Running; + } + } + } + if !self.busy { + if let Some((last, run)) = turns + .last_mut() + .zip(self.session.as_ref().and_then(|t| t.last_run.as_ref())) + { + 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()), + }; + } + } + } + } + for turn in &mut turns { + 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(); + } + } } } + if previous.working() == turn.working() { + turn.work_open = previous.work_open; + } } } + self.turns = turns; + } +} - self.turns = next_turns; +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()); + } + } +} +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 +1666,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 +1685,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 +1744,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 +1759,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 +1776,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 +1881,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 +1900,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/event.rs b/packages/tui/src/event.rs index b49d5bde..e1a072b8 100644 --- a/packages/tui/src/event.rs +++ b/packages/tui/src/event.rs @@ -15,27 +15,24 @@ use crate::types::{ModelList, ServerInfo, ThreadInfo}; /// Asynchronous results arriving from the RPC server. #[derive(Debug, Clone, PartialEq)] pub enum RpcEvent { - Stream(StreamEvent), - ThreadStream { - session_id: String, - thread_id: String, - event: StreamEvent, - }, ServerInfoLoaded(Result), ModelsLoaded(Result), ThreadsLoaded(Result, String>), - ThreadInfoLoaded { - session_id: String, - thread_id: String, + Created { result: Result, + text: String, + delivery: crate::types::PromptDelivery, + id: String, }, - ThreadConfigured(Result), - PluginsReloaded(Result<(u64, Option), String>), - PromptDispatched { - session_id: String, - thread_id: String, - message_id: String, - result: Result<(), String>, + ThreadStream { + address: crate::rpc::protocol::ThreadRefPayload, + generation: u64, + event: StreamEvent, + }, + Operation { + address: crate::rpc::protocol::ThreadRefPayload, + generation: u64, + result: Result, }, } @@ -57,7 +54,13 @@ pub enum AppEvent { /// stale copy in state would be one more thing to keep in sync. Resize, /// 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 { @@ -75,17 +78,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/main.rs b/packages/tui/src/main.rs index 69ee3b49..8333040a 100644 --- a/packages/tui/src/main.rs +++ b/packages/tui/src/main.rs @@ -5,6 +5,8 @@ mod event; mod menu; mod prompt; mod rpc; +#[cfg(test)] +mod tests; mod theme; mod tool; mod tui; diff --git a/packages/tui/src/rpc/client.rs b/packages/tui/src/rpc/client.rs index 024d624e..15180872 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,1180 +249,443 @@ 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) - } - - /// 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) + 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) + } - 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(()); + /// 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, + 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; } - let _ = event_tx.send(StreamEvent::Disconnected); - sleep(RECONNECT_DELAY).await; - } - Err(message) => { - let _ = event_tx.send(StreamEvent::Failed(message)); - return Ok(()); } } } } - /// 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 sync_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), + address: &ThreadRefPayload, + tx: &mpsc::UnboundedSender, + generation: u64, + cursor: &mut SyncCursor, + ) -> Result<(), String> { + 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()) }; - - 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 }); + // 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 + .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 + .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), + }, + }, + )); + } + }); } - 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); + 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))?; } - - 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(&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()) } - } - - for stream_event in - decode_durable_session_events(env.event_type.as_str(), data) - { - let _ = event_tx.send(stream_event); } } + 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) - } - - /// 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( - &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 - } - - /// Keep observing the session across busy periods, until the caller cancels the task. - #[allow(dead_code)] - pub async fn watch_session_with( - &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, - true, - ) - .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, - ) - .await + Err("Thread connection closed".into()) } +} - /// 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 - } +fn as_request_id(value: &Value) -> Option { + value.as_u64().or_else(|| value.as_str()?.parse().ok()) +} - #[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; +fn str_field<'a>(value: &'a Value, key: &str) -> Option<&'a str> { + value + .get(key) + .and_then(Value::as_str) + .map(str::trim) + .filter(|s| !s.is_empty()) +} - 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(()); +pub fn format_cause(cause: Option<&Value>) -> String { + let Some(cause) = cause else { + return "RPC request failed".to_string(); + }; + match cause { + Value::Null => "RPC request failed".to_string(), + Value::String(s) => { + let trimmed = s.trim(); + if trimmed.is_empty() { + "RPC request failed".to_string() + } else { + trimmed.to_string() + } + } + Value::Array(items) => { + for item in items { + let formatted = format_cause(Some(item)); + if !formatted.is_empty() && formatted != "RPC request failed" { + return formatted; } - 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(()); + } + "RPC request failed".to_string() + } + Value::Object(_) => { + if let Some(tag) = str_field(cause, "_tag") { + match tag { + "Fail" => { + if let Some(inner) = cause.get("error").or_else(|| cause.get("failure")) { + return format_cause(Some(inner)); + } + return "RPC request failed".to_string(); } - let _ = event_tx.send(StreamEvent::Disconnected); - - sleep(RECONNECT_DELAY).await; - } - Err(message) => { - let _ = event_tx.send(StreamEvent::Failed(message)); - return Ok(()); - } - } - } - } - - /// 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) - } -} - -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, - } -} - -fn str_field<'a>(value: &'a Value, key: &str) -> Option<&'a str> { - value - .get(key) - .and_then(Value::as_str) - .map(str::trim) - .filter(|s| !s.is_empty()) -} - -pub fn format_cause(cause: Option<&Value>) -> String { - let Some(cause) = cause else { - return "RPC request failed".to_string(); - }; - match cause { - Value::Null => "RPC request failed".to_string(), - Value::String(s) => { - let trimmed = s.trim(); - if trimmed.is_empty() { - "RPC request failed".to_string() - } else { - trimmed.to_string() - } - } - Value::Array(items) => { - for item in items { - let formatted = format_cause(Some(item)); - if !formatted.is_empty() && formatted != "RPC request failed" { - return formatted; - } - } - "RPC request failed".to_string() - } - Value::Object(_) => { - if let Some(tag) = str_field(cause, "_tag") { - match tag { - "Fail" => { - if let Some(inner) = cause.get("error").or_else(|| cause.get("failure")) { - return format_cause(Some(inner)); - } - return "RPC request failed".to_string(); - } - "Die" => { - if let Some(inner) = cause.get("defect") { - return format_cause(Some(inner)); - } - return "RPC server defect".to_string(); - } - "Interrupt" => { - return "RPC request interrupted".to_string(); - } - _ => return format_tagged_error(tag, cause), + "Die" => { + if let Some(inner) = cause.get("defect") { + return format_cause(Some(inner)); + } + return "RPC server defect".to_string(); + } + "Interrupt" => { + return "RPC request interrupted".to_string(); + } + _ => return format_tagged_error(tag, cause), } } if let Some(msg) = str_field(cause, "message") { @@ -1840,1263 +966,52 @@ 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 } -} - -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 } -} - -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, - } -} - -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, - } -} - -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)); @@ -3115,99 +1030,12 @@ mod tests { 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" - ) + resolve_codework_home(Some("~/custom-cw"), Some(Path::new("/Users/prem"))), + Some(PathBuf::from("/Users/prem/custom-cw")) ); - server.await.expect("server task"); + let _ = std::fs::remove_dir_all(&temp); } - #[test] fn formats_tagged_rpc_errors_and_effect_causes_for_humans() { // Effect 4 wire Cause array wrapping a tagged error @@ -3418,1226 +1246,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/mod.rs b/packages/tui/src/rpc/mod.rs index cbe4761b..141bc5e3 100644 --- a/packages/tui/src/rpc/mod.rs +++ b/packages/tui/src/rpc/mod.rs @@ -1,4 +1,4 @@ pub mod client; pub mod protocol; -pub use client::{RpcClient, StreamEvent, SyncCursor}; +pub use client::{RpcClient, StreamEvent}; diff --git a/packages/tui/src/rpc/protocol.rs b/packages/tui/src/rpc/protocol.rs index 9667d12a..d622f42d 100644 --- a/packages/tui/src/rpc/protocol.rs +++ b/packages/tui/src/rpc/protocol.rs @@ -98,7 +98,7 @@ pub struct DurableMeta { pub version: u64, } -#[derive(Debug, Clone, Deserialize)] +#[derive(Debug, Clone, PartialEq, Deserialize)] pub struct EventEnvelope { pub id: Option, #[serde(rename = "type")] @@ -208,8 +208,53 @@ pub struct ThreadHistoryResponse { 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 ThreadMessageResponse { +#[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, } diff --git a/packages/tui/src/tests.rs b/packages/tui/src/tests.rs new file mode 100644 index 00000000..a54f9017 --- /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"); + 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"); + 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/ui.rs b/packages/tui/src/ui.rs index 02c5ae98..fde5ec1d 100644 --- a/packages/tui/src/ui.rs +++ b/packages/tui/src/ui.rs @@ -94,7 +94,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 +129,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/session.rs b/packages/tui/src/ui/session.rs index cdb82569..8dfb6b17 100644 --- a/packages/tui/src/ui/session.rs +++ b/packages/tui/src/ui/session.rs @@ -17,9 +17,8 @@ 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 BUSY_HINTS: &str = - "enter steer · alt+enter follow-up · ↑↓/wheel scroll · / commands · esc interrupt"; +const IDLE_HINTS: &str = "enter send · alt+↑ queue · ctrl+o work · ctrl+y copy · / commands"; +const BUSY_HINTS: &str = "enter steer · alt+enter follow-up · alt+↑ queue · ctrl+o work · esc stop"; const COMMAND_HINTS: &str = "↑↓ move · enter choose · esc close"; const SEARCH_HINTS: &str = "↑↓ move · type to search · enter choose · esc close"; @@ -36,10 +35,14 @@ 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(tray_height), Constraint::Length(input::HEIGHT), Constraint::Length(1), ]) @@ -75,6 +78,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 +118,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 +157,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,10 +168,16 @@ 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 )); } @@ -177,7 +203,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 +250,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 +471,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 +550,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 +588,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 +606,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 (shown, offset) = + text::scrolled(edit.text.text(), edit.text.before_caret(), 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)).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/terminal.rs b/packages/tui/tests/terminal.rs new file mode 100644 index 00000000..2dc36a71 --- /dev/null +++ b/packages/tui/tests/terminal.rs @@ -0,0 +1,163 @@ +//! 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]), + "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") + ); +} From d36e531f0641568a8549578b869951ce07131353 Mon Sep 17 00:00:00 2001 From: prem315 Date: Sat, 14 Nov 2026 18:12:49 +0530 Subject: [PATCH 3/4] Add multiline composer, drafts, and live thread browser - Preserve multiline prompts, Unicode navigation, and per-thread drafts - Add live searchable thread browser with session state and refresh handling - Expand TUI integration coverage and documented keyboard shortcuts --- packages/tui/README.md | 27 +- packages/tui/__artifacts__/composer.json | 14 ++ packages/tui/__artifacts__/conversation.txt | 2 +- packages/tui/src/app.rs | 264 +++++++++++++++++--- packages/tui/src/browser.rs | 69 +++++ packages/tui/src/conversation.rs | 200 +++++++++++++++ packages/tui/src/draft.rs | 94 +++++++ packages/tui/src/event.rs | 8 +- packages/tui/src/main.rs | 4 + packages/tui/src/menu.rs | 4 +- packages/tui/src/prompt.rs | 162 +++++++++++- packages/tui/src/rpc/client.rs | 87 +++++++ packages/tui/src/tests.rs | 4 +- packages/tui/src/ui.rs | 11 +- packages/tui/src/ui/input.rs | 71 ++++-- packages/tui/src/ui/session.rs | 24 +- packages/tui/tests/composer.rs | 160 ++++++++++++ packages/tui/tests/terminal.rs | 14 +- 18 files changed, 1122 insertions(+), 97 deletions(-) create mode 100644 packages/tui/__artifacts__/composer.json create mode 100644 packages/tui/src/browser.rs create mode 100644 packages/tui/src/conversation.rs create mode 100644 packages/tui/src/draft.rs create mode 100644 packages/tui/tests/composer.rs diff --git a/packages/tui/README.md b/packages/tui/README.md index 9d98ddb7..2955f54d 100644 --- a/packages/tui/README.md +++ b/packages/tui/README.md @@ -3,7 +3,8 @@ A fast and lightweight terminal interface for [CodeWork](https://www.codework.sh), written in **Rust**. The TUI connects to the CodeWork server to send prompts and follow conversations through -`thread.sync`. It supports model and thinking selection, queued prompt management, +`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, clipboard copying, and older history on demand. --- @@ -81,12 +82,17 @@ pnpm start | 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 | -| `↑` / `↓`, mouse wheel, `PageUp` / `PageDown` | Scroll (arrows when composer is empty); fetch older history at the top | +| `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 restore to composer when cancellation succeeds | +| `w` in queue | Cancel and prepend to the composer when cancellation succeeds, preserving the existing draft | | `Delete` / `d` in queue | Cancel without restoring | | `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 | @@ -97,6 +103,16 @@ pnpm start | `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). @@ -110,7 +126,10 @@ 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. -It records the queue, fork, and paging RPCs in `__artifacts__/terminal.json` and checks +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 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 index d3552fde..863a224f 100644 --- a/packages/tui/__artifacts__/conversation.txt +++ b/packages/tui/__artifacts__/conversation.txt @@ -15,4 +15,4 @@ ┌────────────────────────────────────────────────────────────────────────── alpha ─┐ │❯ build me flappy bird │ └──────────────────────────────────────────────────────────────────────────────────┘ - enter send · alt+↑ queue · ctrl+o work · ctrl+y copy · / commands \ No newline at end of file + enter send · ctrl+j newline · ctrl+p threads · alt+↑ queue · ctrl+o work \ No newline at end of file diff --git a/packages/tui/src/app.rs b/packages/tui/src/app.rs index 70c63c3b..13aaa4be 100644 --- a/packages/tui/src/app.rs +++ b/packages/tui/src/app.rs @@ -1,6 +1,7 @@ //! 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; @@ -247,6 +248,11 @@ pub struct QueueEdit { pub id: String, pub text: Prompt, } +struct Remembered { + prompt: Prompt, + scroll: usize, + work: BTreeMap, +} pub struct App { pub screen: Screen, pub theme: &'static Palette, @@ -271,6 +277,13 @@ pub struct App { pub queue_edit: Option, pub focused_turn: Option, pub queue_pending: BTreeSet, + 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, @@ -292,11 +305,23 @@ impl Default for App { impl Drop for App { fn drop(&mut self) { self.stop_stream(); + self.stop_browser(); + if let Some(timer) = self.draft_timer.take() { + timer.abort(); + } + let _ = self.drafts.save(&self.draft_key(), &self.prompt); } } impl App { pub fn with_client(tx: mpsc::UnboundedSender, client: RpcClient) -> Self { - 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(), @@ -320,6 +345,13 @@ impl App { queue_edit: None, focused_turn: None, queue_pending: BTreeSet::new(), + 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, @@ -331,10 +363,16 @@ impl App { keymap: Keymap::new(), client: Arc::new(client), tx, - } + }; + app.restore_draft(); + app } pub fn new(tx: mpsc::UnboundedSender) -> Self { - let app = Self::with_client(tx, RpcClient::default()); + 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 { @@ -467,6 +505,9 @@ impl App { self.rebuild(); } pub fn switch_thread(&mut self, info: ThreadInfo) { + self.remember(); + self.stop_browser(); + self.popup = None; self.stop_stream(); self.generation += 1; self.entries.clear(); @@ -486,6 +527,7 @@ impl App { self.screen = Screen::Session; self.reconnecting = false; self.apply_info(info); + self.restore_draft(); self.follow(); self.spawn_list_models(); } @@ -513,7 +555,8 @@ impl App { } 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) => { if self.popup.is_some() { @@ -524,7 +567,112 @@ impl App { } AppEvent::Paste(text) => self.paste(&text), AppEvent::Resize => true, + 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 schedule_draft(&mut self) { + self.draft_revision += 1; + if let Some(timer) = self.draft_timer.take() { + timer.abort(); + } + 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(), + ); } } fn scroll_by(&mut self, delta: isize) -> bool { @@ -558,7 +706,7 @@ impl App { | Popup::Sessions { search, .. } | Popup::Themes { search, .. }, ) => { - search.insert_text(text); + search.insert_inline(text); self.filter_popup(); } Some(Popup::Thinking(_) | Popup::Fork(_)) => return false, @@ -578,6 +726,20 @@ impl App { Resolution::Consumed => return false, Resolution::Unbound => {} } + 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; @@ -595,6 +757,9 @@ impl App { } if key.code == KeyCode::Esc { if let Some(popup) = self.popup.take() { + if matches!(popup, Popup::Sessions { .. }) { + self.stop_browser(); + } match popup { Popup::Themes { initial, .. } => self.theme = initial, Popup::Commands(_) => self.prompt.clear(), @@ -746,12 +911,16 @@ impl App { menu, initial, }) => self.theme = filter_themes(search.text(), menu, initial), - Some(Popup::Sessions { search, menu, .. }) => { - let needle = search.text().to_lowercase(); - menu.filter(|e| { - e.name.to_lowercase().contains(&needle) - || e.detail.to_lowercase().contains(&needle) - }); + Some(Popup::Sessions { + search, + menu, + sessions, + }) => { + *menu = crate::browser::menu( + sessions, + search.text(), + menu.selected().map(|e| e.id.as_ref()), + ); } _ => {} } @@ -832,18 +1001,10 @@ impl App { "queue" => self.focus_queue(-1), "fork" => self.open_fork(), "copy" => self.copy_reply(), - "session" => { - let tx = self.tx.clone(); - let client = self.client.clone(); - if let Ok(handle) = tokio::runtime::Handle::try_current() { - handle.spawn(async move { - let _ = tx.send(AppEvent::rpc(RpcEvent::ThreadsLoaded( - client.list_threads().await, - ))); - }); - } - } + "session" => self.open_browser(), "new" => { + self.remember(); + self.stop_browser(); self.stop_stream(); self.generation += 1; self.session = None; @@ -860,6 +1021,7 @@ impl App { self.scroll = 0; self.busy = false; self.screen = Screen::Welcome; + self.restore_draft(); } "reload" => self.spawn_operation(|client, _| async move { let (count, error) = client.reload_plugins().await?; @@ -1122,23 +1284,33 @@ impl App { Ok(models) => self.models = Some(models), Err(error) => self.notice = Some(error), }, - RpcEvent::ThreadsLoaded(result) => match result { - Ok(mut sessions) => { - sessions.sort_by_key(|a| std::cmp::Reverse(a.updated_at)); - let entries = sessions - .iter() - .map(|t| { - Entry::owned(t.id.clone(), t.display_title(), t.working_directory()) - }) - .collect(); - self.popup = Some(Popup::Sessions { - search: Prompt::default(), - menu: Menu::new(entries), - sessions, - }); + RpcEvent::ThreadsLoaded { generation, result } => { + if generation != self.browser_generation + || !matches!(self.popup, Some(Popup::Sessions { .. })) + { + return false; } - Err(error) => self.notice = Some(error), - }, + 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; + } + Err(error) => self.notice = Some(error), + } + } RpcEvent::Created { result, text, @@ -1222,8 +1394,13 @@ impl App { if cancelled { self.queued_prompts.retain(|q| q.message_id != id); if let Some(text) = restore { - self.prompt.clear(); - self.prompt.insert_text(&text); + 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 { @@ -1485,6 +1662,13 @@ impl App { } } for turn in &mut turns { + if let Some(open) = turn + .prompt_id + .as_ref() + .and_then(|id| self.work_restore.remove(id)) + { + turn.work_open = Some(open); + } if let Some(previous) = self .turns .iter() 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/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 e1a072b8..56b196ee 100644 --- a/packages/tui/src/event.rs +++ b/packages/tui/src/event.rs @@ -17,7 +17,10 @@ use crate::types::{ModelList, ServerInfo, ThreadInfo}; pub enum RpcEvent { ServerInfoLoaded(Result), ModelsLoaded(Result), - ThreadsLoaded(Result, String>), + ThreadsLoaded { + generation: u64, + result: Result, String>, + }, Created { result: Result, text: String, @@ -53,6 +56,9 @@ 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(Box), } diff --git a/packages/tui/src/main.rs b/packages/tui/src/main.rs index 8333040a..aa758049 100644 --- a/packages/tui/src/main.rs +++ b/packages/tui/src/main.rs @@ -1,6 +1,10 @@ mod action; mod app; +mod browser; +#[cfg(test)] +mod conversation; mod diff; +mod draft; mod event; mod menu; mod prompt; 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 15180872..e496eddc 100644 --- a/packages/tui/src/rpc/client.rs +++ b/packages/tui/src/rpc/client.rs @@ -297,6 +297,93 @@ impl RpcClient { .await } + /// 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()) + } + pub async fn list_models(&self, host_dir: Option<&str>) -> Result { self.request("model.list", ListModelsPayload { host_dir }) .await diff --git a/packages/tui/src/tests.rs b/packages/tui/src/tests.rs index a54f9017..140aa740 100644 --- a/packages/tui/src/tests.rs +++ b/packages/tui/src/tests.rs @@ -155,13 +155,13 @@ async fn queue_keyboard_actions_obey_server_results_and_preserve_composer() { 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"); + 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"); + 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); diff --git a/packages/tui/src/ui.rs b/packages/tui/src/ui.rs index fde5ec1d..8da9e364 100644 --- a/packages/tui/src/ui.rs +++ b/packages/tui/src/ui.rs @@ -26,7 +26,7 @@ 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"; @@ -57,14 +57,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), ]) 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 8dfb6b17..80d04fdd 100644 --- a/packages/tui/src/ui/session.rs +++ b/packages/tui/src/ui/session.rs @@ -17,8 +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 · alt+↑ queue · ctrl+o work · ctrl+y copy · / commands"; -const BUSY_HINTS: &str = "enter steer · alt+enter follow-up · alt+↑ queue · ctrl+o work · esc stop"; +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 · 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"; @@ -43,7 +44,12 @@ pub fn draw(app: &App, frame: &mut Frame) { Constraint::Length(1), Constraint::Fill(1), Constraint::Length(tray_height), - Constraint::Length(input::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); @@ -660,8 +666,8 @@ fn draw_queue(app: &App, frame: &mut Frame, area: Rect) { 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 (shown, offset) = - text::scrolled(edit.text.text(), edit.text.before_caret(), usable); + 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)), @@ -673,13 +679,13 @@ fn draw_queue(app: &App, frame: &mut Frame, area: Rect) { )); } else { frame.render_widget( - Paragraph::new(format!("{prefix}{}", q.prompt)).style(Style::default().fg( - if focused { + 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/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/terminal.rs b/packages/tui/tests/terminal.rs index 2dc36a71..9c0a427a 100644 --- a/packages/tui/tests/terminal.rs +++ b/packages/tui/tests/terminal.rs @@ -49,6 +49,7 @@ async fn terminal_conversation_queue_fork_copy_and_page() { "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()); @@ -92,7 +93,7 @@ def wait(text): while text not in output and time.monotonic() Date: Sat, 14 Nov 2026 18:35:53 +0530 Subject: [PATCH 4/4] Add Git review support to the TUI - Add Git status and on-demand diff RPC integration - Add interactive file, patch, hunk, and view navigation - Add Git review rendering, artifacts, and end-to-end coverage --- packages/tui/README.md | 37 +++- packages/tui/__artifacts__/git.json | 46 +++++ packages/tui/__artifacts__/git.txt | 18 ++ packages/tui/src/app.rs | 226 +++++++++++++++++++++++- packages/tui/src/diff.rs | 87 ++++++++- packages/tui/src/event.rs | 12 ++ packages/tui/src/git.rs | 197 +++++++++++++++++++++ packages/tui/src/git/tests.rs | 184 +++++++++++++++++++ packages/tui/src/main.rs | 1 + packages/tui/src/rpc/client.rs | 126 +++++++++++++ packages/tui/src/rpc/protocol.rs | 14 ++ packages/tui/src/ui.rs | 5 + packages/tui/src/ui/git.rs | 263 ++++++++++++++++++++++++++++ packages/tui/src/ui/session.rs | 6 + packages/tui/tests/git.rs | 189 ++++++++++++++++++++ 15 files changed, 1406 insertions(+), 5 deletions(-) create mode 100644 packages/tui/__artifacts__/git.json create mode 100644 packages/tui/__artifacts__/git.txt create mode 100644 packages/tui/src/git.rs create mode 100644 packages/tui/src/git/tests.rs create mode 100644 packages/tui/src/ui/git.rs create mode 100644 packages/tui/tests/git.rs diff --git a/packages/tui/README.md b/packages/tui/README.md index 2955f54d..90d204bd 100644 --- a/packages/tui/README.md +++ b/packages/tui/README.md @@ -5,7 +5,7 @@ A fast and lightweight terminal interface for [CodeWork](https://www.codework.sh 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, clipboard copying, and older history on demand. +collapsible work logs, conversation forks, Git review, clipboard copying, and older history on demand. --- @@ -94,6 +94,7 @@ pnpm start | `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 | @@ -116,6 +117,36 @@ without losing the current filter or selection. Closing it stops the subscriptio 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 @@ -129,6 +160,10 @@ against a deterministic local WebSocket peer; it does not need provider credenti 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__/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/src/app.rs b/packages/tui/src/app.rs index 13aaa4be..141173b4 100644 --- a/packages/tui/src/app.rs +++ b/packages/tui/src/app.rs @@ -31,6 +31,8 @@ const COMMANDS: &[Entry] = &[ 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"), @@ -277,6 +279,10 @@ pub struct App { 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, @@ -306,6 +312,7 @@ impl Drop for App { fn drop(&mut self) { self.stop_stream(); self.stop_browser(); + self.stop_git(); if let Some(timer) = self.draft_timer.take() { timer.abort(); } @@ -345,6 +352,10 @@ impl App { 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(), @@ -502,12 +513,15 @@ impl App { .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(); @@ -559,7 +573,14 @@ impl App { let redraw = match event { AppEvent::Key(key) => self.handle_key(key), AppEvent::Scroll(delta) => { - if self.popup.is_some() { + 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) @@ -697,6 +718,9 @@ impl App { true } fn paste(&mut self, text: &str) -> bool { + if self.git.open { + return false; + } if let Some(edit) = &mut self.queue_edit { return edit.text.insert_text(text); } @@ -726,6 +750,17 @@ impl App { Resolution::Consumed => return false, Resolution::Unbound => {} } + 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.git.open { + return self.git_key(key); + } if key.code == KeyCode::Char('p') && key.modifiers == KeyModifiers::CONTROL { self.open_browser(); return true; @@ -1002,10 +1037,13 @@ impl App { "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(); @@ -1033,6 +1071,144 @@ impl App { _ => {} } } + fn stop_git(&mut self) { + if let Some(task) = self.git_stream.take() { + task.abort(); + } + if let Some(task) = self.git_patch.take() { + task.abort(); + } + } + 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 generation = self.git_generation; + if let Ok(handle) = tokio::runtime::Handle::try_current() { + self.git_stream = Some( + handle + .spawn(async move { + client.watch_git(space, tx, generation).await; + }) + .abort_handle(), + ); + } + } + 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() { + 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 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 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 + }, + ); + } + _ => {} + } + true + } fn configure(&self) { let model = self.model.clone(); let thinking = self.thinking_label(); @@ -1311,6 +1487,54 @@ impl App { 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) + } + crate::git::GitEvent::Status(status) => { + if self.git.apply_status(status) && self.git.open { + self.load_git_diff(); + } + } + } + } + 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; + } + Err(error) => { + self.git.diff = None; + self.git.error = Some(error); + } + } + } RpcEvent::Created { result, text, 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/event.rs b/packages/tui/src/event.rs index 56b196ee..13065991 100644 --- a/packages/tui/src/event.rs +++ b/packages/tui/src/event.rs @@ -21,6 +21,18 @@ pub enum RpcEvent { generation: u64, result: Result, String>, }, + Git { + space_id: String, + generation: u64, + event: crate::git::GitEvent, + }, + GitDiff { + space_id: String, + generation: u64, + request_id: u64, + file: String, + result: Result, + }, Created { result: Result, text: String, 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 aa758049..f88ac618 100644 --- a/packages/tui/src/main.rs +++ b/packages/tui/src/main.rs @@ -6,6 +6,7 @@ mod conversation; mod diff; mod draft; mod event; +mod git; mod menu; mod prompt; mod rpc; diff --git a/packages/tui/src/rpc/client.rs b/packages/tui/src/rpc/client.rs index e496eddc..1bf00c4b 100644 --- a/packages/tui/src/rpc/client.rs +++ b/packages/tui/src/rpc/client.rs @@ -521,6 +521,132 @@ impl RpcClient { 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 + } + + /// 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; + } + } + } + async fn git_events_once( + &self, + 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()]), + }; + 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))?; + } + } + } + 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())) + } + _ => {} + } + } + } + Message::Ping(bytes) => ws + .send(Message::Pong(bytes)) + .await + .map_err(|e| e.to_string())?, + Message::Close(_) => break, + _ => {} + } + } + Err("Git status connection closed".into()) + } + /// 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( diff --git a/packages/tui/src/rpc/protocol.rs b/packages/tui/src/rpc/protocol.rs index d622f42d..0faaa7e9 100644 --- a/packages/tui/src/rpc/protocol.rs +++ b/packages/tui/src/rpc/protocol.rs @@ -258,3 +258,17 @@ pub struct ForkResponse { #[serde(default)] 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/ui.rs b/packages/tui/src/ui.rs index 8da9e364..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; @@ -32,6 +33,10 @@ const THEME_HINTS: &str = "↑↓ move · type to search · enter choose · esc /// 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), 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/session.rs b/packages/tui/src/ui/session.rs index 80d04fdd..d6417421 100644 --- a/packages/tui/src/ui/session.rs +++ b/packages/tui/src/ui/session.rs @@ -187,6 +187,12 @@ fn draw_header(app: &App, frame: &mut Frame, area: Rect) { )); } + 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; 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(); +}