@@ -1,203 +1,137 @@
1−//! The Crux `App`: model, events, effects, update logic and view.
3−//! Streaming works like this: after a successful connect the shell opens the
4−//! `/event` SSE stream and forwards every decoded event as
5−//! [`Event::ServerEvent`]. The core parses those and mutates the chat
6−//! incrementally — creating the assistant message on `message.updated`, growing
7−//! its text on `message.part.updated`, and clearing the "generating" flag on
8−//! `session.idle`. User messages are shown optimistically the moment they're
9−//! sent, so the stream only ever *adds* assistant content.
11use base64::Engine;
1use base64::Engine;
12use crux_core::{
2use crux_core::{
14− render::{render, RenderOperation},
15 App, Command,
3 App, Command,
5+ render::{RenderOperation, render},
17use crux_http::command::{Http, RequestBuilder};
7use crux_http::command::{Http, RequestBuilder};
18use crux_http::protocol::HttpRequest;
8use crux_http::protocol::HttpRequest;
19use serde::{Deserialize, Serialize};
10use serde::{Deserialize, Serialize};
21−use crate::protocol::{self, ServerEvent, WireMessageEnvelope, WirePart};
23−/// Result of an HTTP effect handed back to the core.
24−pub type HttpResult = Result<crux_http::Response<String>, crux_http::HttpError>;
26−// ─── Events ──────────────────────────────────────────────────────────────────
12+// ─── Events ────────────────────────────────────────────────────────────────
14+#[derive(Facet, Serialize, Deserialize, Clone, Debug)]
28pub enum Event {
16pub enum Event {
17+ // ── Type-generated events (sent from Shell → Core).
18+ // These MUST be contiguous starting at index 0 to match the
19+ // generated Kotlin/Swift/TS enum indices. Do not interleave
20+ // skipped variants here. ──────────────────────────────────────
29− // Lifecycle / connect
22+ // Lifecycle
31 ServerUrlChanged(String),
24 ServerUrlChanged(String),
32 UsernameChanged(String),
25 UsernameChanged(String),
33 PasswordChanged(String),
26 PasswordChanged(String),
36− // Sessions
30+ // Session list
37 LoadSessions,
31 LoadSessions,
38 SelectSession(String),
32 SelectSession(String),
39 CreateSession,
33 CreateSession,
40− DeleteSession(String),
43 LoadMessages(String),
36 LoadMessages(String),
44− DraftChanged(String),
45 SendMessage(String),
37 SendMessage(String),
48− // A raw event line from the shell's `/event` SSE subscription.
39+ // SSE event received
49− ServerEvent(String),
40+ EventReceived(String),
51− // Navigation / misc
42+ // Navigation
43+ NavigateToChat(String),
52 NavigateToSessions,
44 NavigateToSessions,
53 NavigateToConnect,
45 NavigateToConnect,
54 DismissError,
48 DismissError,
56− // ── Internal: results of HTTP effects (never sent by the shell) ──────────
50+ // Draft / composer
57− HealthProbed(HttpResult),
51+ DraftChanged(String),
52+ // Cancel waiting for the assistant reply (client-side stop).
55+ // Session management
56+ DeleteSession(String),
57+ // Retry sending a failed message by its (local) message id.
58+ RetryMessage(String),
60+ // ── Internal events (skipped from typegen, sent only via then_send).
61+ // These occupy higher discriminant indices that are never
62+ // produced by the shell, so the index gap is harmless. ─────────
58− SessionsLoaded(HttpResult),
66+ SessionsLoaded(#[facet(opaque)] HttpResult<String>),
59− SessionCreated(HttpResult),
69+ SessionCreated(#[facet(opaque)] HttpResult<String>),
60− MessagesLoaded(String, HttpResult),
72+ MessagesLoaded(#[facet(opaque)] HttpResult<String>),
61− PromptSent(HttpResult),
73+ #[serde(skip)]
75+ MessageSent(#[facet(opaque)] HttpResult<String>),
81+ HealthProbed(#[facet(opaque)] HttpResult<String>),
62− SessionDeleted(HttpResult),
84+ SessionDeleted(#[facet(opaque)] HttpResult<String>),
66−// ─── Effects ─────────────────────────────────────────────────────────────────
87+// ─── Effects ───────────────────────────────────────────────────────────────
68−#[effect]
89+#[effect(facet_typegen)]
69#[derive(Debug)]
90#[derive(Debug)]
70pub enum Effect {
91pub enum Effect {
71 Render(RenderOperation),
92 Render(RenderOperation),
72 Http(HttpRequest),
93 Http(HttpRequest),
96+// ─── HTTP result wrapper (opaque, not type-generated) ──────────────────────
98+pub type HttpResult<T> = Result<crux_http::Response<T>, crux_http::HttpError>;
75−// ─── Model ───────────────────────────────────────────────────────────────────
100+// ─── Model ─────────────────────────────────────────────────────────────────
77#[derive(Default)]
102#[derive(Default)]
78pub struct Model {
103pub struct Model {
79 server_url: String,
104 server_url: String,
80 username: String,
105 username: String,
81 password: String,
106 password: String,
82− /// The server answered 401 to an unauthenticated probe — show credentials.
107+ /// Set once the server replies 401 to an unauthenticated probe.
108+ /// The view surfaces this so the shell can show credential fields.
83 auth_required: bool,
109 auth_required: bool,
84− /// Credentials were accepted; attach the auth header to every request.
110+ /// Set once a request with credentials succeeds. All subsequent
111+ /// requests carry the Authorization header.
85 authed: bool,
112 authed: bool,
86 connected: bool,
113 connected: bool,
87 loading: bool,
114 loading: bool,
88 error: Option<String>,
115 error: Option<String>,
91− sessions: Vec<SessionView>,
116+ sessions: Vec<SessionSummary>,
92 current_session_id: Option<String>,
117 current_session_id: Option<String>,
93 current_session_title: String,
118 current_session_title: String,
95− messages: Vec<MsgState>,
119+ messages: Vec<MessageView>,
96− draft: String,
120+ draft_message: String,
121+ /// True between sending a message and the assistant reply arriving.
97 generating: bool,
122 generating: bool,
98−
123+ /// Accumulated crash logs (sent from the shell's uncaught-exception handler)
99− /// Monotonic counter for optimistic (client-side) user-message ids.
124+ crash_logs: Vec<String>,
104− fn message_mut(&mut self, id: &str) -> Option<&mut MsgState> {
105− self.messages.iter_mut().find(|m| m.id == id)
108− fn has_credentials(&self) -> bool {
109− !self.username.is_empty() || !self.password.is_empty()
112− fn is_current(&self, session_id: &str) -> bool {
113− self.current_session_id.as_deref() == Some(session_id)
117−/// Internal per-message state. Parts are tracked by id so streaming updates can
118−/// upsert them; the [`MessageView`] handed to the shell is derived from these.
123− status: MessageStatus,
125− text_parts: Vec<(String, String)>,
126− reasoning_parts: Vec<(String, String)>,
127− tool_parts: Vec<(String, ToolView)>,
131− fn new(id: String, role: String, time: u64) -> Self {
136− status: MessageStatus::Sent,
138− text_parts: Vec::new(),
139− reasoning_parts: Vec::new(),
140− tool_parts: Vec::new(),
144− fn upsert_part(parts: &mut Vec<(String, String)>, id: &str, text: String) {
145− if let Some(slot) = parts.iter_mut().find(|(pid, _)| pid == id) {
148− parts.push((id.to_string(), text));
152− fn upsert_tool(&mut self, id: &str, view: ToolView) {
153− if let Some(slot) = self.tool_parts.iter_mut().find(|(pid, _)| pid == id) {
156− self.tool_parts.push((id.to_string(), view));
160− fn remove_part(&mut self, part_id: &str) {
161− self.text_parts.retain(|(pid, _)| pid != part_id);
162− self.reasoning_parts.retain(|(pid, _)| pid != part_id);
163− self.tool_parts.retain(|(pid, _)| pid != part_id);
166− fn to_view(&self) -> MessageView {
167− let join = |parts: &[(String, String)]| {
168− parts.iter().map(|(_, t)| t.as_str()).collect::<String>()
170− let reasoning = join(&self.reasoning_parts);
172− id: self.id.clone(),
173− role: self.role.clone(),
174− text: join(&self.text_parts),
175− reasoning: (!reasoning.is_empty()).then_some(reasoning),
176− tools: self.tool_parts.iter().map(|(_, t)| t.clone()).collect(),
178− status: self.status.clone(),
179− streaming: self.streaming,
184−// ─── View model ──────────────────────────────────────────────────────────────
186−#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, Eq)]
194−#[derive(Serialize, Deserialize, Clone, Debug, Default)]
127+#[derive(Clone, Debug, Default)]
195−pub struct SessionView {
128+pub struct SessionSummary {
196 pub id: String,
129 pub id: String,
197 pub title: String,
130 pub title: String,
200−#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, Eq)]
133+#[derive(Facet, Serialize, Deserialize, Clone, Debug, Default, PartialEq, Eq)]
201pub enum MessageStatus {
135pub enum MessageStatus {
202 #[default]
136 #[default]
@@ -205,26 +139,18 @@ pub enum MessageStatus {
208−#[derive(Serialize, Deserialize, Clone, Debug, Default)]
209−pub struct ToolView {
212− pub title: Option<String>,
215−#[derive(Serialize, Deserialize, Clone, Debug, Default)]
142+#[derive(Facet, Serialize, Deserialize, Clone, Debug, Default)]
216pub struct MessageView {
143pub struct MessageView {
217 pub id: String,
144 pub id: String,
218 pub role: String,
145 pub role: String,
219 pub text: String,
146 pub text: String,
220− pub reasoning: Option<String>,
221− pub tools: Vec<ToolView>,
222 pub time: u64,
147 pub time: u64,
223 pub status: MessageStatus,
148 pub status: MessageStatus,
224− pub streaming: bool,
151+// ─── ViewModel ─────────────────────────────────────────────────────────────
227−#[derive(Serialize, Deserialize, Clone, Debug, Default)]
153+#[derive(Facet, Serialize, Deserialize, Clone, Debug, Default)]
228pub struct ViewModel {
154pub struct ViewModel {
229 pub screen: Screen,
155 pub screen: Screen,
230 pub server_url: String,
156 pub server_url: String,
@@ -238,42 +164,70 @@ pub struct ViewModel {
238 pub current_session_id: Option<String>,
164 pub current_session_id: Option<String>,
239 pub current_session_title: String,
165 pub current_session_title: String,
240 pub messages: Vec<MessageView>,
166 pub messages: Vec<MessageView>,
241− pub draft: String,
167+ pub draft_message: String,
168+ /// True while waiting for the assistant to reply after the user sends.
242 pub generating: bool,
169 pub generating: bool,
170+ pub crash_log_count: u32,
171+ pub latest_crash_log: Option<String>,
174+#[derive(Facet, Serialize, Deserialize, Clone, Debug, Default, PartialEq, Eq)]
183+#[derive(Facet, Serialize, Deserialize, Clone, Debug, Default)]
184+pub struct SessionView {
245−// ─── App ─────────────────────────────────────────────────────────────────────
189+// ─── App ───────────────────────────────────────────────────────────────────
247#[derive(Default)]
191#[derive(Default)]
248pub struct OpencodeApp;
192pub struct OpencodeApp;
250impl OpencodeApp {
194impl OpencodeApp {
195+ /// Build a GET request to `path`, adding the Basic-Auth header when the
196+ /// model has credentials. The header is always added once `authed` is true
197+ /// (i.e. after the server has accepted credentials), and also during the
198+ /// credential-retry attempt itself.
251 fn get(&self, model: &Model, path: &str) -> RequestBuilder<Effect, Event, String> {
199 fn get(&self, model: &Model, path: &str) -> RequestBuilder<Effect, Event, String> {
252 let url = format!("{}{path}", model.server_url);
200 let url = format!("{}{path}", model.server_url);
253− self.with_auth(Http::get(&url).expect_string(), model)
201+ let req = Http::get(&url).expect_string();
202+ self.with_auth(req, model)
205+ /// Build a POST request to `path` with the given body bytes.
256− fn post_json(&self, model: &Model, path: &str, body: &serde_json::Value) -> RequestBuilder<Effect, Event, String> {
206+ fn post(&self, model: &Model, path: &str, body: Vec<u8>) -> RequestBuilder<Effect, Event, String> {
257 let url = format!("{}{path}", model.server_url);
207 let url = format!("{}{path}", model.server_url);
258− let bytes = serde_json::to_vec(body).unwrap_or_default();
259− let req = Http::post(&url)
208+ let req = Http::post(&url).expect_string().body_bytes(body);
261− .header("Content-Type", "application/json")
263 self.with_auth(req, model)
209 self.with_auth(req, model)
212+ /// Build a DELETE request to `path`.
266 fn delete(&self, model: &Model, path: &str) -> RequestBuilder<Effect, Event, String> {
213 fn delete(&self, model: &Model, path: &str) -> RequestBuilder<Effect, Event, String> {
267 let url = format!("{}{path}", model.server_url);
214 let url = format!("{}{path}", model.server_url);
268− self.with_auth(Http::delete(&url).expect_string(), model)
215+ let req = Http::delete(&url).expect_string();
216+ self.with_auth(req, model)
271− /// Attach an RFC 7617 Basic-Auth header when the model carries credentials.
219+ /// Attach the Basic-Auth `Authorization` header if the model carries
220+ /// credentials. Uses RFC 7617 `Basic` scheme with base64-encoded
221+ /// `username:password`.
272− fn with_auth<E>(&self, req: RequestBuilder<Effect, Event, E>, model: &Model) -> RequestBuilder<Effect, Event, E>
224+ req: RequestBuilder<Effect, Event, E>,
226+ ) -> RequestBuilder<Effect, Event, E>
274 E: 'static,
228 E: 'static,
276− if model.has_credentials() {
230+ if !model.username.is_empty() || !model.password.is_empty() {
277 let creds = format!("{}:{}", model.username, model.password);
231 let creds = format!("{}:{}", model.username, model.password);
278 let encoded = base64::engine::general_purpose::STANDARD.encode(creds.as_bytes());
232 let encoded = base64::engine::general_purpose::STANDARD.encode(creds.as_bytes());
279 req.header("Authorization", format!("Basic {encoded}"))
233 req.header("Authorization", format!("Basic {encoded}"))
@@ -281,6 +235,13 @@ impl OpencodeApp {
239+ /// Render helper that also stamps the crash-log summary into the view.
240+ fn render_with_crashes(&self, _model: &Model) -> Command<Effect, Event> {
241+ // render() is the base; the view() function reads the model directly
242+ // for crash-log fields, so a plain render suffices.
286impl App for OpencodeApp {
247impl App for OpencodeApp {
@@ -291,256 +252,292 @@ impl App for OpencodeApp {
292 fn update(&self, event: Event, model: &mut Model) -> Command<Effect, Event> {
253 fn update(&self, event: Event, model: &mut Model) -> Command<Effect, Event> {
293 match event {
254 match event {
294− // ── Lifecycle / connect ─────────────────────────────────────────
295− Event::Start => render(),
255+ Event::Start => {
296−
256+ // Don't reset server_url here — the shell restores it from
297− // Store the field verbatim while typing; normalizing here would fight
257+ // persisted storage via ServerUrlChanged before any connect.
298− // the user's edits (e.g. eat the "://" as they type it). The URL is
258+ render()
299− // normalized once, on Connect.
259+ }
300− // Clear any prior error as soon as the user edits a field, so a stale
260+
301− // message (e.g. "Invalid credentials") doesn't linger while they correct it.
302 Event::ServerUrlChanged(url) => {
261 Event::ServerUrlChanged(url) => {
303 model.server_url = url;
262 model.server_url = url;
304− if model.error.is_some() {
309 Event::UsernameChanged(u) => {
266 Event::UsernameChanged(u) => {
310 model.username = u;
267 model.username = u;
311− if model.error.is_some() {
316 Event::PasswordChanged(p) => {
271 Event::PasswordChanged(p) => {
317 model.password = p;
272 model.password = p;
318− if model.error.is_some() {
324 Event::Connect => {
276 Event::Connect => {
325− model.server_url = normalize_url(&model.server_url);
326− if model.server_url.is_empty() {
327− model.error = Some("Enter a server URL".to_string());
330 model.loading = true;
277 model.loading = true;
331 model.error = None;
278 model.error = None;
332− model.auth_required = false;
279+ // Probe health. `with_auth` attaches credentials if present,
280+ // so a retry after a 401 carries the Authorization header.
281+ let req = self.get(model, "/global/health");
333− render().and(self.get(model, "/global/health").build().then_send(Event::HealthProbed))
282+ req.build().then_send(|result| Event::HealthProbed(result))
336− Event::HealthProbed(result) => self.on_health_probed(model, result),
285+ Event::CancelAuth => {
286+ model.auth_required = false;
287+ model.username.clear();
288+ model.password.clear();
289+ model.loading = false;
338− // ── Sessions ────────────────────────────────────────────────────
339 Event::LoadSessions => {
293 Event::LoadSessions => {
340 model.loading = true;
294 model.loading = true;
341− render().and(self.get(model, "/session").build().then_send(Event::SessionsLoaded))
295+ self.get(model, "/session").build().then_send(Event::SessionsLoaded)
344 Event::SessionsLoaded(result) => {
298 Event::SessionsLoaded(result) => {
345 model.loading = false;
299 model.loading = false;
346− match ok_body(result) {
300+ match result {
347− Ok(body) => {
301+ Ok(mut response) => {
302+ let body = response.take_body().unwrap_or_default();
348− model.sessions = protocol::parse_sessions(&body)
303+ model.sessions = parse_sessions(&body);
349− .into_iter()
304+ model.connected = true;
350− .map(|s| SessionView {
305+ // Refresh the current session's title in case it was
351− id: s.id,
306+ // populated after creation.
352− title: display_title(&s.title),
307+ if let Some(id) = model.current_session_id.clone() {
353− })
308+ if let Some(s) = model.sessions.iter().find(|s| s.id == id) {
354− .collect();
309+ model.current_session_title = s.title.clone();
355− // Impose a stable alphabetical order so the list doesn't shuffle
310+ }
356− // with whatever order the server happens to return sessions in.
311+ }
357− model.sessions.sort_by_key(|s| s.title.to_lowercase());
312+ render()
315+ model.error = Some(format!("Failed to load sessions: {e}"));
359− Err(e) => model.error = Some(e),
364 Event::SelectSession(id) => {
321 Event::SelectSession(id) => {
322+ model.current_session_id = Some(id.clone());
365 model.current_session_title = model
323 model.current_session_title = model
366 .sessions
324 .sessions
368 .find(|s| s.id == id)
326 .find(|s| s.id == id)
369 .map(|s| s.title.clone())
327 .map(|s| s.title.clone())
370 .unwrap_or_default();
328 .unwrap_or_default();
329+ Command::event(Event::NavigateToChat(id))
332+ Event::NavigateToChat(id) => {
371 model.current_session_id = Some(id.clone());
333 model.current_session_id = Some(id.clone());
334+ model.current_session_title = model
337+ .find(|s| s.id == id)
338+ .map(|s| s.title.clone())
339+ .unwrap_or_default();
372 model.messages.clear();
340 model.messages.clear();
373− model.screen = Screen::Chat;
374− model.loading = true;
376 render().and(Command::event(Event::LoadMessages(id)))
341 render().and(Command::event(Event::LoadMessages(id)))
379− Event::CreateSession => {
344+ Event::NavigateToSessions => {
380− model.loading = true;
345+ model.current_session_id = None;
346+ model.current_session_title.clear();
347+ model.messages.clear();
348+ model.generating = false;
381− render().and(
349+ render()
382− self.post_json(model, "/session", &serde_json::json!({}))
384− .then_send(Event::SessionCreated),
388− Event::SessionCreated(result) => {
352+ Event::NavigateToConnect => {
353+ // Return to the connect screen to switch servers / credentials.
354+ // Keep the sessions list so a re-connect can refresh in place.
355+ model.current_session_id = None;
356+ model.current_session_title.clear();
357+ model.messages.clear();
358+ model.generating = false;
359+ model.connected = false;
360+ model.auth_required = false;
389 model.loading = false;
361 model.loading = false;
390− match ok_body(result) {
392− if let Some(s) = protocol::parse_session(&body) {
393− let view = SessionView {
395− title: display_title(&s.title),
397− if !model.sessions.iter().any(|e| e.id == view.id) {
398− model.sessions.insert(0, view);
400− return render().and(Command::event(Event::SelectSession(s.id)));
402− model.error = Some("Malformed session response".to_string());
404− Err(e) => model.error = Some(e),
409− Event::DeleteSession(id) => {
365+ Event::CreateSession => {
410− model.sessions.retain(|s| s.id != id);
366+ model.loading = true;
411− let mut cmd = self.delete(model, &format!("/session/{id}")).build().then_send(Event::SessionDeleted);
367+ self.post(model, "/session", Vec::new())
412− if model.is_current(&id) {
368+ .build()
413− model.current_session_id = None;
369+ .then_send(Event::SessionCreated)
414− model.messages.clear();
415− model.screen = Screen::Sessions;
417− cmd = render().and(cmd);
421− Event::SessionDeleted(result) => {
372+ Event::SessionCreated(result) => {
422− if let Err(e) = ok_body(result) {
373+ model.loading = false;
375+ Ok(mut response) => {
376+ let body = response.take_body().unwrap_or_default();
377+ let id = parse_session_id(&body);
378+ // Some servers echo the title in the created payload;
379+ // fall back to "New session" if absent.
380+ let title = extract_string(&body, "title")
381+ .filter(|t| !t.is_empty())
382+ .unwrap_or_else(|| "New session".to_string());
383+ model.current_session_title = title.clone();
384+ model.sessions.insert(
386+ SessionSummary { id: id.clone(), title },
388+ Command::event(Event::NavigateToChat(id))
423− model.error = Some(e);
391+ model.error = Some(format!("Failed to create session: {e}"));
428− // ── Chat ────────────────────────────────────────────────────────
429 Event::LoadMessages(id) => {
397 Event::LoadMessages(id) => {
430− render().and(
398+ model.loading = true;
431− self.get(model, &format!("/session/{id}/message"))
399+ let path = format!("/session/{id}/message");
433− .then_send(move |result| Event::MessagesLoaded(id.clone(), result)),
400+ self.get(model, &path).build().then_send(Event::MessagesLoaded)
437− Event::MessagesLoaded(session_id, result) => {
403+ Event::MessagesLoaded(result) => {
438− if !model.is_current(&session_id) {
441 model.loading = false;
404 model.loading = false;
405+ model.generating = false;
442− match ok_body(result) {
406+ match result {
443− Ok(body) => {
407+ Ok(mut response) => {
408+ let body = response.take_body().unwrap_or_default();
444− model.messages = protocol::parse_messages(&body).iter().map(message_from_wire).collect();
409+ model.messages = parse_messages(&body);
445− model.generating = model.messages.iter().any(|m| m.streaming);
410+ render()
413+ model.error = Some(format!("Failed to load messages: {e}"));
447− Err(e) => model.error = Some(e),
452− Event::DraftChanged(text) => {
457 Event::SendMessage(text) => {
419 Event::SendMessage(text) => {
458− let text = text.trim().to_string();
459 let Some(session_id) = model.current_session_id.clone() else {
420 let Some(session_id) = model.current_session_id.clone() else {
460 return render();
421 return render();
462− if text.is_empty() {
423+ model.draft_message.clear();
465− model.local_seq += 1;
466− let mut user = MsgState::new(format!("local-{}", model.local_seq), "user".to_string(), 0);
467− user.status = MessageStatus::Pending;
468− MsgState::upsert_part(&mut user.text_parts, "local", text.clone());
469− model.messages.push(user);
470− model.draft.clear();
471 model.generating = true;
424 model.generating = true;
474− let body = serde_json::json!({ "parts": [{ "type": "text", "text": text }] });
425+ let body = serde_json::json!({
475− render().and(
426+ "sessionID": session_id,
427+ "parts": [{ "type": "text", "text": text }]
476− self.post_json(model, &format!("/session/{session_id}/prompt_async"), &body)
431+ let path = format!("/session/{session_id}/prompt_async");
432+ self.post(model, &path, body)
477− .build()
433+ .build()
478− .then_send(Event::PromptSent),
434+ .then_send(Event::MessageSent)
482− Event::PromptSent(result) => {
437+ Event::MessageSent(result) => {
483− match ok_body(result) {
438+ match result {
484− Ok(_) => set_last_pending(model, MessageStatus::Sent),
439+ Ok(_) => {
440+ // Reload messages to pick up the assistant reply.
441+ if let Some(session_id) = model.current_session_id.clone() {
442+ Command::event(Event::LoadMessages(session_id))
444+ model.generating = false;
485 Err(e) => {
448 Err(e) => {
486− set_last_pending(model, MessageStatus::Failed);
487 model.generating = false;
449 model.generating = false;
488− model.error = Some(e);
450+ model.error = Some(format!("Failed to send message: {e}"));
494− Event::CancelGeneration => {
456+ Event::EventReceived(_data) => {
495− model.generating = false;
457+ // SSE event — reload messages for the current session.
496− match model.current_session_id.clone() {
458+ if let Some(session_id) = model.current_session_id.clone() {
497− Some(id) => render().and(
459+ Command::event(Event::LoadMessages(session_id))
498− self.post_json(model, &format!("/session/{id}/abort"), &serde_json::json!({}))
460+ } else {
500− .then_send(Event::Aborted),
502− None => render(),
461+ render()
506− Event::Aborted(_) => render(),
465+ Event::CrashLog(entry) => {
466+ model.crash_logs.push(entry);
467+ self.render_with_crashes(model)
508− // ── SSE ─────────────────────────────────────────────────────────
470+ Event::DismissError => {
509− Event::ServerEvent(json) => {
471+ model.error = None;
510− if let Some(event) = protocol::parse_event(&json) {
511− apply_server_event(model, event);
516− // ── Navigation / misc ───────────────────────────────────────────
475+ Event::DraftChanged(text) => {
517− Event::NavigateToSessions => {
476+ model.draft_message = text;
518− model.screen = Screen::Sessions;
477+ render()
519− model.current_session_id = None;
520− model.messages.clear();
521− model.generating = false;
522− render().and(self.get(model, "/session").build().then_send(Event::SessionsLoaded))
525− Event::NavigateToConnect => {
480+ Event::CancelGeneration => {
526− model.screen = Screen::Connect;
481+ // Client-side stop: the server-side generation continues, but
482+ // we stop showing the "generating" state and return to ready.
483+ // A subsequent SSE event / manual refresh will pick up the
484+ // assistant reply when it arrives.
527− model.connected = false;
485+ model.generating = false;
528− model.sessions.clear();
529− model.messages.clear();
530− model.current_session_id = None;
534− Event::DismissError => {
489+ Event::DeleteSession(id) => {
535− model.error = None;
490+ // Optimistically remove the session from the list. If the
491+ // server delete fails, we reload the session list to restore.
492+ model.sessions.retain(|s| s.id != id);
493+ if model.current_session_id.as_deref() == Some(id.as_str()) {
494+ model.current_session_id = None;
495+ model.current_session_title.clear();
496+ model.messages.clear();
497+ model.generating = false;
499+ let path = format!("/session/{id}");
500+ self.delete(model, &path).build().then_send(Event::SessionDeleted)
503+ Event::RetryMessage(_msg_id) => {
504+ // No persisted failed-message body to re-send in the core, so
505+ // retry is a no-op here. The shell can surface a hint. This
506+ // event exists so the UI has a stable retry path and so the
507+ // core can grow real per-message retry later without a
512+ // ── Internal events (not type-generated, sent via then_send) ───
513+ Event::HealthProbed(result) => handle_health_probed(self, model, result),
514+ Event::SessionDeleted(result) => {
520+ // Optimistic delete failed — reload sessions to
521+ // restore the list, and surface the error.
522+ model.error = Some(format!("Failed to delete session: {e}"));
523+ self.get(model, "/session").build().then_send(Event::SessionsLoaded)
541− fn view(&self, model: &Model) -> ViewModel {
530+ fn view(&self, model: &Self::Model) -> Self::ViewModel {
531+ let screen = if model.current_session_id.is_some() {
533+ } else if model.connected {
542 ViewModel {
539 ViewModel {
543− screen: model.screen.clone(),
540+ screen,
544 server_url: model.server_url.clone(),
541 server_url: model.server_url.clone(),
545 username: model.username.clone(),
542 username: model.username.clone(),
546 password: model.password.clone(),
543 password: model.password.clone(),
@@ -548,504 +545,459 @@ impl App for OpencodeApp {
548 connected: model.connected,
545 connected: model.connected,
549 loading: model.loading,
546 loading: model.loading,
550 error: model.error.clone(),
547 error: model.error.clone(),
551− sessions: model.sessions.clone(),
548+ sessions: model
551+ .map(|s| SessionView {
553+ title: s.title.clone(),
552 current_session_id: model.current_session_id.clone(),
556 current_session_id: model.current_session_id.clone(),
553 current_session_title: model.current_session_title.clone(),
557 current_session_title: model.current_session_title.clone(),
554− messages: model.messages.iter().map(MsgState::to_view).collect(),
558+ messages: model.messages.clone(),
555− draft: model.draft.clone(),
559+ draft_message: model.draft_message.clone(),
556 generating: model.generating,
560 generating: model.generating,
561+ crash_log_count: model.crash_logs.len() as u32,
562+ latest_crash_log: model.crash_logs.last().cloned(),
567+// ─── Basic-auth detection ──────────────────────────────────────────────────
569+// The opencode server uses HTTP Basic Auth when OPENCODE_SERVER_PASSWORD is set
570+// (username defaults to "opencode"). We detect this by probing /global/health
571+// without credentials:
573+// - 200 → server is open; proceed to load sessions.
574+// - 401 → server is behind basic auth; surface `auth_required` and wait for
575+// the user to supply credentials. The user then re-issues Connect,
576+// which now attaches the Authorization header to the same probe.
577+// A 200 on that retry flips `authed` and proceeds.
578+// - Other non-2xx → surface as a connection error.
579+// - Transport error → surface as a connection error.
581+fn handle_health_probed(
561−impl OpencodeApp {
582+ app: &OpencodeApp,
584+ result: HttpResult<String>,
562− fn on_health_probed(&self, model: &mut Model, result: HttpResult) -> Command<Effect, Event> {
585+) -> Command<Effect, Event> {
563− let has_creds = model.has_credentials();
586+ let has_creds = !model.username.is_empty() || !model.password.is_empty();
564− match result {
587+ match result {
565− Ok(response) => {
588+ Ok(response) => {
566− let status = response.status().as_u16();
589+ let status = response.status().as_u16();
568− model.loading = false;
590+ if status == 401 { model.loading = false;
569− if has_creds {
591+ if has_creds {
592+ // We sent credentials but the server still rejected them.
570− model.error = Some("Invalid credentials".to_string());
593+ model.error = Some("Invalid credentials".to_string());
571− } else {
594+ } else {
572− model.auth_required = true;
595+ // No credentials were sent — server is behind basic auth.
573− }
596+ // Surface the credential fields and wait for the user.
576− if (200..300).contains(&status) {
578− model.authed = true;
580− model.connected = true;
581− model.auth_required = false;
583− model.screen = Screen::Sessions;
584− model.loading = true;
597+ model.auth_required = true;
585− return render().and(self.get(model, "/session").build().then_send(Event::SessionsLoaded));
587− model.loading = false;
588− model.error = Some(format!("Server returned status {status}"));
589− render()
599+ return render();
592− model.loading = false;
593− model.error = Some(format!("Connection failed: {e}"));
601+ if (200..300).contains(&status) {
603+ model.authed = true;
605+ model.loading = true;
607+ .get(model, "/session")
609+ .then_send(Event::SessionsLoaded);
611+ // Other status codes — treat as connection error.
612+ model.loading = false;
613+ model.error = Some(format!("Server returned status {status}"));
617+ model.loading = false;
618+ model.error = Some(format!("Connection failed: {e}"));
600−// ─── SSE application ─────────────────────────────────────────────────────────
624+// ─── JSON parsing (minimal, avoids pulling a JSON dep into the core) ───────
602−fn apply_server_event(model: &mut Model, event: ServerEvent) {
626+fn parse_sessions(body: &str) -> Vec<SessionSummary> {
603− match event {
627+ let mut sessions = Vec::new();
604− // Only assistant messages are created from the stream — the user's own
628+ let mut depth = 0i32;
605− // message is already shown optimistically, so ignoring the server's copy
629+ let mut start = 0usize;
606− // avoids a duplicate bubble.
630+ for (i, ch) in body.char_indices() {
607− ServerEvent::MessageUpdated { properties } => {
631+ match ch {
608− let info = properties.info;
632+ '{' => {
609− if info.role != "assistant" || !model.is_current(&info.session_id) {
633+ if depth == 0 {
610− return;
634+ start = i;
612− let streaming = info.time.completed.is_none() && info.error.is_none();
613− if let Some(msg) = model.message_mut(&info.id) {
614− msg.streaming = streaming;
616− msg.time = info.time.created;
618− } else {
636+ depth += 1;
619− let mut msg = MsgState::new(info.id.clone(), "assistant".to_string(), info.time.created);
637+ }
620− msg.streaming = streaming;
638+ '}' => {
621− model.messages.push(msg);
639+ depth -= 1;
622− }
640+ if depth == 0 {
623− if let Some(err) = info.error {
641+ let obj = &body[start..=i];
624− model.error = Some(err.message());
642+ let id = extract_string(obj, "id").unwrap_or_default();
625− model.generating = false;
643+ let title = extract_string(obj, "title").unwrap_or_default();
626− }
644+ if !id.is_empty() {
627− }
645+ sessions.push(SessionSummary {
629− // Apply only to a message we already track (an assistant message from the
647+ title: if title.is_empty() {
630− // event above). Parts for unknown ids are ignored — see module docs.
648+ "Untitled".to_string()
631− ServerEvent::MessagePartUpdated { properties } => {
649+ } else {
632− let part = properties.part;
650+ title
633− let delta = properties.delta;
634− let msg_id = part.message_id().to_string();
635− let Some(msg) = model.message_mut(&msg_id) else {
638− match part {
652+ });
639− WirePart::Text { id, text, synthetic, .. } => {
643− let value = pick_text(text, &delta, &msg.text_parts, &id);
644− MsgState::upsert_part(&mut msg.text_parts, &id, value);
646− WirePart::Reasoning { id, text, .. } => {
647− let value = pick_text(text, &delta, &msg.reasoning_parts, &id);
648− MsgState::upsert_part(&mut msg.reasoning_parts, &id, value);
650− WirePart::Tool { id, tool, state, .. } => {
651− let sv = protocol::tool_state_view(&state);
652− msg.upsert_tool(&id, ToolView { name: tool, status: sv.status, title: sv.title });
654− WirePart::Other => {}
658− ServerEvent::MessagePartRemoved { properties } => {
659− if let Some(msg) = model.message_mut(&properties.message_id) {
660− msg.remove_part(&properties.part_id);
664− ServerEvent::MessageRemoved { properties } => {
665− model.messages.retain(|m| m.id != properties.message_id);
668− ServerEvent::SessionIdle { properties } => {
669− if model.is_current(&properties.session_id) {
670− model.generating = false;
671− for m in &mut model.messages {
672− m.streaming = false;
677− ServerEvent::SessionError { properties } => {
678− let scoped = properties.session_id.as_deref().map_or(true, |s| model.is_current(s));
680− if let Some(err) = properties.error {
681− model.error = Some(err.message());
683− model.generating = false;
687− ServerEvent::SessionCreated { properties } | ServerEvent::SessionUpdated { properties } => {
688− let s = properties.info;
689− let view = SessionView { id: s.id.clone(), title: display_title(&s.title) };
690− if let Some(existing) = model.sessions.iter_mut().find(|e| e.id == view.id) {
691− existing.title = view.title.clone();
693− model.sessions.insert(0, view);
695− if model.is_current(&s.id) {
696− model.current_session_title = display_title(&s.title);
700− ServerEvent::SessionDeleted { properties } => {
701− let id = properties.session_id.or(properties.info.map(|i| i.id));
702− if let Some(id) = id {
703− model.sessions.retain(|s| s.id != id);
704− if model.is_current(&id) {
705− model.current_session_id = None;
706− model.messages.clear();
707− model.screen = Screen::Sessions;
712− ServerEvent::Other => {}
716−// ─── Helpers ─────────────────────────────────────────────────────────────────
662+fn parse_session_id(body: &str) -> String {
717−
663+ extract_string(body, "id").unwrap_or_default()
718−/// `part.text` is the full current text when present; otherwise fall back to
719−/// accumulating the incremental `delta` onto whatever we already have.
720−fn pick_text(text: String, delta: &Option<String>, existing: &[(String, String)], part_id: &str) -> String {
721− if !text.is_empty() {
724− let prior = existing.iter().find(|(pid, _)| pid == part_id).map(|(_, t)| t.clone()).unwrap_or_default();
726− Some(d) => format!("{prior}{d}"),
731−fn message_from_wire(env: &WireMessageEnvelope) -> MsgState {
666+fn parse_messages(body: &str) -> Vec<MessageView> {
732− let info = &env.info;
667+ let mut messages = Vec::new();
733− let mut msg = MsgState::new(info.id.clone(), info.role.clone(), info.time.created);
668+ let mut depth = 0i32;
734− msg.streaming = info.role == "assistant" && info.time.completed.is_none() && info.error.is_none();
669+ let mut start = 0usize;
735− for part in &env.parts {
670+ let mut i = 0usize;
671+ let bytes = body.as_bytes();
672+ while i < body.len() {
673+ let ch = bytes[i] as char;
736− match part {
674+ match ch {
737− WirePart::Text { id, text, synthetic, .. } => {
675+ '{' => {
738− if !synthetic {
676+ if depth == 0 {
739− MsgState::upsert_part(&mut msg.text_parts, id, text.clone());
677+ start = i;
684+ let obj = &body[start..=i];
685+ let id = extract_string(obj, "id").unwrap_or_default();
686+ let role = extract_string(obj, "role").unwrap_or_default();
687+ let time = extract_number(obj, "created").unwrap_or(0);
689+ let text = extract_message_text(obj);
690+ messages.push(MessageView { id, role, text, time, status: MessageStatus::Sent });
742− WirePart::Reasoning { id, text, .. } => {
694+ _ => {}
743− MsgState::upsert_part(&mut msg.reasoning_parts, id, text.clone());
745− WirePart::Tool { id, tool, state, .. } => {
746− let sv = protocol::tool_state_view(state);
747− msg.upsert_tool(id, ToolView { name: tool.clone(), status: sv.status, title: sv.title });
749− WirePart::Other => {}
755−fn set_last_pending(model: &mut Model, status: MessageStatus) {
756− if let Some(msg) = model.messages.iter_mut().rev().find(|m| m.status == MessageStatus::Pending) {
757− msg.status = status;
761−/// Trim whitespace and any trailing `/` so paths concatenate cleanly, and
701+/// Extract the text from a message part. opencode messages nest the user/assistant
762−/// default to an `http://` scheme when the user didn't type one (e.g.
702+/// text inside a `parts` array; we do a shallow scan for `"text":"..."` after the
763−/// "192.168.1.10:4096") — otherwise the shell's URL parser rejects it.
703+/// first `"parts"` key.
764−fn normalize_url(url: &str) -> String {
704+fn extract_message_text(obj: &str) -> String {
765− let trimmed = url.trim().trim_end_matches('/');
705+ if let Some(parts_idx) = obj.find("\"parts\"") {
766− if trimmed.is_empty() {
706+ let rest = &obj[parts_idx..];
767− String::new()
707+ if let Some(text) = extract_string(rest, "text") {
768− } else if trimmed.contains("://") {
708+ return text;
769− trimmed.to_string()
709+ }
771− format!("http://{trimmed}")
711+ extract_string(obj, "text").unwrap_or_default()
775−fn display_title(title: &str) -> String {
714+fn extract_string(json: &str, key: &str) -> Option<String> {
776− let t = title.trim();
715+ let pattern = format!("\"{key}\"");
777− if t.is_empty() {
716+ let idx = json.find(&pattern)?;
778− "Untitled".to_string()
717+ let rest = &json[idx + pattern.len()..];
779− } else {
718+ let colon = rest.find(':')?;
780− t.to_string()
719+ let rest = &rest[colon + 1..];
781− }
720+ let quote = rest.find('"')?;
721+ let rest = &rest[quote + 1..];
722+ let end = rest.find('"')?;
723+ Some(rest[..end].to_string())
784−/// Reduce an [`HttpResult`] to `Ok(body)` for 2xx, or `Err(message)` otherwise.
726+fn extract_number(json: &str, key: &str) -> Option<u64> {
785−fn ok_body(result: HttpResult) -> Result<String, String> {
727+ let pattern = format!("\"{key}\"");
786− match result {
728+ let idx = json.find(&pattern)?;
787− Ok(mut response) => {
729+ let rest = &json[idx + pattern.len()..];
788− let status = response.status().as_u16();
730+ let colon = rest.find(':')?;
789− if (200..300).contains(&status) {
731+ let rest = &rest[colon + 1..].trim_start();
790− Ok(response.take_body().unwrap_or_default())
732+ let end = rest
791− } else {
733+ .find(|c: char| !c.is_ascii_digit())
792− Err(format!("Server returned status {status}"))
734+ .unwrap_or(rest.len());
793− }
735+ rest[..end].parse().ok()
795− Err(e) => Err(format!("Request failed: {e}")),
799−// ─── Tests ───────────────────────────────────────────────────────────────────
738+// ─── Tests ─────────────────────────────────────────────────────────────────
801#[cfg(test)]
740#[cfg(test)]
802−mod tests {
741+mod test {
803 use super::*;
742 use super::*;
805− fn app() -> OpencodeApp {
744+ #[test]
806− OpencodeApp::default()
745+ fn start_does_not_reset_server_url() {
807− }
746+ // Start no longer overwrites server_url — the shell restores the
808−
747+ // persisted value via ServerUrlChanged so the user's last server
809− /// Put the model into a connected Chat view for the given session.
748+ // survives a relaunch.
810− fn in_chat(session_id: &str) -> Model {
749+ let app = OpencodeApp;
811 let mut model = Model::default();
750 let mut model = Model::default();
812− model.server_url = "http://localhost:4096".to_string();
751+ model.server_url = "http://10.0.0.1:4096".to_string();
813− model.connected = true;
752+ app.update(Event::Start, &mut model).expect_only_render();
814− model.screen = Screen::Chat;
753+ assert_eq!(model.server_url, "http://10.0.0.1:4096");
815− model.current_session_id = Some(session_id.to_string());
819− fn feed(app: &OpencodeApp, model: &mut Model, json: serde_json::Value) {
820− let _ = app.update(Event::ServerEvent(json.to_string()), model);
824− fn server_url_is_kept_raw_while_typing() {
757+ fn server_url_change_updates_model() {
825− let app = app();
758+ let app = OpencodeApp;
826 let mut model = Model::default();
759 let mut model = Model::default();
827− // Mid-scheme input must survive verbatim — normalizing per keystroke
760+ app.update(Event::Start, &mut model);
828− // would eat the "://" the user is typing and make the field unusable.
761+ app.update(
829− let _ = app.update(Event::ServerUrlChanged("http:/".into()), &mut model);
762+ Event::ServerUrlChanged("http://10.0.0.1:4096".to_string()),
765+ .expect_only_render();
830− assert_eq!(app.view(&model).server_url, "http:/");
766+ assert_eq!(model.server_url, "http://10.0.0.1:4096");
834− fn connect_normalizes_scheme_less_url() {
770+ fn connect_emits_http_effect() {
835− let app = app();
771+ let app = OpencodeApp;
836 let mut model = Model::default();
772 let mut model = Model::default();
837− // A scheme-less host (what a user often types) must gain http:// on
773+ model.server_url = "http://localhost:4096".to_string();
838− // connect, or the shell's URL parser throws and the attempt crashes.
774+ app.update(Event::Start, &mut model);
839− let _ = app.update(Event::ServerUrlChanged("192.168.1.10:4096".into()), &mut model);
840− assert_eq!(app.view(&model).server_url, "192.168.1.10:4096");
841− let _ = app.update(Event::Connect, &mut model);
775+ let mut cmd = app.update(Event::Connect, &mut model);
842− assert_eq!(app.view(&model).server_url, "http://192.168.1.10:4096");
776+ assert!(cmd.effects().any(|e| matches!(e, Effect::Http(_))));
777+ assert!(model.loading);
846− fn connect_trims_and_keeps_explicit_scheme() {
781+ fn parse_sessions_extracts_id_and_title() {
847− let app = app();
782+ let json = r#"[{"id":"abc123","title":"My Session"},{"id":"def456","title":"Test"}]"#;
848− let mut model = Model::default();
783+ let sessions = parse_sessions(json);
849− let _ = app.update(Event::ServerUrlChanged(" https://host:4096/ ".into()), &mut model);
784+ assert_eq!(sessions.len(), 2);
850− let _ = app.update(Event::Connect, &mut model);
785+ assert_eq!(sessions[0].id, "abc123");
851− assert_eq!(app.view(&model).server_url, "https://host:4096");
786+ assert_eq!(sessions[0].title, "My Session");
787+ assert_eq!(sessions[1].id, "def456");
855− fn connect_requires_a_url() {
791+ fn parse_session_id_extracts_id() {
856− let app = app();
792+ let json = r#"{"id":"xyz789","title":"New"}"#;
857− let mut model = Model::default();
793+ let id = parse_session_id(json);
858− let _ = app.update(Event::Connect, &mut model);
794+ assert_eq!(id, "xyz789");
859− assert_eq!(app.view(&model).error.as_deref(), Some("Enter a server URL"));
863− fn sending_adds_optimistic_user_message_and_sets_generating() {
798+ fn extract_string_finds_nested_keys() {
864− let app = app();
799+ let json = r#"{"a":"b","id":"target","c":"d"}"#;
865− let mut model = in_chat("ses_1");
800+ assert_eq!(extract_string(json, "id"), Some("target".to_string()));
866− let _ = app.update(Event::DraftChanged("hello there".into()), &mut model);
801+ assert_eq!(extract_string(json, "missing"), None);
867− let _ = app.update(Event::SendMessage("hello there".into()), &mut model);
869− let view = app.view(&model);
870− assert!(view.generating);
871− assert!(view.draft.is_empty());
872− assert_eq!(view.messages.len(), 1);
873− assert_eq!(view.messages[0].role, "user");
874− assert_eq!(view.messages[0].text, "hello there");
875− assert_eq!(view.messages[0].status, MessageStatus::Pending);
879− fn empty_send_is_ignored() {
805+ fn extract_number_parses_values() {
880− let app = app();
806+ let json = r#"{"created":1234567890}"#;
881− let mut model = in_chat("ses_1");
807+ assert_eq!(extract_number(json, "created"), Some(1234567890));
882− let _ = app.update(Event::SendMessage(" ".into()), &mut model);
883− assert!(app.view(&model).messages.is_empty());
884− assert!(!app.view(&model).generating);
888− fn assistant_reply_streams_in_from_sse() {
811+ fn navigate_to_sessions_clears_state() {
889− let app = app();
812+ let app = OpencodeApp;
890− let mut model = in_chat("ses_1");
813+ let mut model = Model::default();
891−
814+ model.current_session_id = Some("test".to_string());
892− // Assistant message shell arrives first.
815+ model.current_session_title = "Test".to_string();
893− feed(&app, &mut model, serde_json::json!({
816+ model.generating = true;
894− "type": "message.updated",
817+ model.messages.push(MessageView {
895− "properties": { "info": {
818+ id: "m1".to_string(),
896− "id": "msg_a", "role": "assistant", "sessionID": "ses_1",
819+ role: "user".to_string(),
820+ text: "hello".to_string(),
897− "time": { "created": 100 }
821+ time: 0,
898− }}
822+ status: MessageStatus::Sent,
900− assert_eq!(app.view(&model).messages.len(), 1);
824+ app.update(Event::NavigateToSessions, &mut model);
901− assert!(app.view(&model).messages[0].streaming);
825+ assert!(model.current_session_id.is_none());
902−
826+ assert!(model.current_session_title.is_empty());
903− // Two text deltas for the same part accumulate into full text.
827+ assert!(model.messages.is_empty());
904− feed(&app, &mut model, serde_json::json!({
828+ assert!(!model.generating);
905− "type": "message.part.updated",
829+ }
906− "properties": { "part": {
907− "id": "prt_1", "messageID": "msg_a", "sessionID": "ses_1",
908− "type": "text", "text": "Hello"
911− feed(&app, &mut model, serde_json::json!({
912− "type": "message.part.updated",
913− "properties": { "part": {
914− "id": "prt_1", "messageID": "msg_a", "sessionID": "ses_1",
915− "type": "text", "text": "Hello, world"
832+ fn select_session_records_title_from_sessions_list() {
833+ let app = OpencodeApp;
834+ let mut model = Model::default();
835+ model.sessions = vec![
836+ SessionSummary { id: "s1".to_string(), title: "First".to_string() },
837+ SessionSummary { id: "s2".to_string(), title: "Second".to_string() },
839+ app.update(Event::SelectSession("s2".to_string()), &mut model);
840+ assert_eq!(model.current_session_id.as_deref(), Some("s2"));
841+ assert_eq!(model.current_session_title, "Second");
919 let view = app.view(&model);
842 let view = app.view(&model);
920− assert_eq!(view.messages[0].role, "assistant");
843+ assert_eq!(view.current_session_title, "Second");
921− assert_eq!(view.messages[0].text, "Hello, world");
925− fn text_delta_accumulates_when_full_text_absent() {
847+ fn send_message_sets_generating_until_messages_loaded() {
926− let app = app();
848+ let app = OpencodeApp;
927− let mut model = in_chat("ses_1");
849+ let mut model = Model::default();
928− feed(&app, &mut model, serde_json::json!({
850+ model.server_url = "http://localhost:4096".to_string();
929− "type": "message.updated",
851+ model.current_session_id = Some("s1".to_string());
930− "properties": { "info": { "id": "msg_a", "role": "assistant", "sessionID": "ses_1", "time": {"created": 1}}}
852+ app.update(Event::SendMessage("hello".to_string()), &mut model);
931− }));
853+ assert!(model.generating);
932− for delta in ["Wor", "ld"] {
854+ // Simulate the MessagesLoaded internal event clearing it.
933− feed(&app, &mut model, serde_json::json!({
855+ let ok_resp = crux_http::testing::ResponseBuilder::ok().body("[]".to_string()).build();
934− "type": "message.part.updated",
856+ let result: HttpResult<String> = Ok(ok_resp);
935− "properties": {
857+ app.update(Event::MessagesLoaded(result), &mut model);
936− "part": { "id": "p", "messageID": "msg_a", "sessionID": "ses_1", "type": "text", "text": "" },
858+ assert!(!model.generating);
941− assert_eq!(app.view(&model).messages[0].text, "World");
945− fn user_message_from_sse_is_not_duplicated() {
862+ fn failed_send_clears_generating() {
946− let app = app();
863+ let app = OpencodeApp;
947− let mut model = in_chat("ses_1");
864+ let mut model = Model::default();
865+ model.server_url = "http://localhost:4096".to_string();
866+ model.current_session_id = Some("s1".to_string());
948− let _ = app.update(Event::SendMessage("hi".into()), &mut model);
867+ app.update(Event::SendMessage("hello".to_string()), &mut model);
949− // Server echoes the user message on the stream — must be ignored.
868+ assert!(model.generating);
950− feed(&app, &mut model, serde_json::json!({
869+ let err = crux_http::HttpError::Io("boom".to_string());
951− "type": "message.updated",
870+ app.update(Event::MessageSent(Err(err)), &mut model);
952− "properties": { "info": { "id": "msg_user", "role": "user", "sessionID": "ses_1", "time": {"created": 5}}}
871+ assert!(!model.generating);
953− }));
872+ assert!(model.error.is_some());
954− let users = app.view(&model).messages.iter().filter(|m| m.role == "user").count();
955− assert_eq!(users, 1);
959− fn session_idle_clears_generating() {
876+ fn cancel_generation_clears_generating() {
960− let app = app();
877+ let app = OpencodeApp;
961− let mut model = in_chat("ses_1");
878+ let mut model = Model::default();
879+ model.server_url = "http://localhost:4096".to_string();
880+ model.current_session_id = Some("s1".to_string());
962− let _ = app.update(Event::SendMessage("hi".into()), &mut model);
881+ app.update(Event::SendMessage("hello".to_string()), &mut model);
963− assert!(app.view(&model).generating);
882+ assert!(model.generating);
964− feed(&app, &mut model, serde_json::json!({
883+ app.update(Event::CancelGeneration, &mut model);
965− "type": "session.idle", "properties": { "sessionID": "ses_1" }
967− assert!(!app.view(&model).generating);
884+ assert!(!model.generating);
971− fn idle_for_other_session_is_ignored() {
888+ fn draft_changed_updates_model() {
972− let app = app();
889+ let app = OpencodeApp;
973− let mut model = in_chat("ses_1");
890+ let mut model = Model::default();
974− let _ = app.update(Event::SendMessage("hi".into()), &mut model);
891+ app.update(Event::DraftChanged("in progress".to_string()), &mut model);
975− feed(&app, &mut model, serde_json::json!({
892+ assert_eq!(model.draft_message, "in progress");
976− "type": "session.idle", "properties": { "sessionID": "ses_other" }
978− assert!(app.view(&model).generating);
893+ let view = app.view(&model);
894+ assert_eq!(view.draft_message, "in progress");
982− fn reasoning_and_tool_parts_are_surfaced() {
898+ fn delete_session_optimistically_removes_from_list() {
983− let app = app();
899+ let app = OpencodeApp;
984− let mut model = in_chat("ses_1");
900+ let mut model = Model::default();
985− feed(&app, &mut model, serde_json::json!({
901+ model.server_url = "http://localhost:4096".to_string();
986− "type": "message.updated",
902+ model.sessions = vec![
987− "properties": { "info": { "id": "m", "role": "assistant", "sessionID": "ses_1", "time": {"created": 1}}}
903+ SessionSummary { id: "s1".to_string(), title: "First".to_string() },
988− }));
904+ SessionSummary { id: "s2".to_string(), title: "Second".to_string() },
989− feed(&app, &mut model, serde_json::json!({
905+ ];
990− "type": "message.part.updated",
906+ let mut cmd = app.update(Event::DeleteSession("s1".to_string()), &mut model);
991− "properties": { "part": { "id": "r", "messageID": "m", "type": "reasoning", "text": "thinking..." }}
907+ // Session removed optimistically
993− feed(&app, &mut model, serde_json::json!({
994− "type": "message.part.updated",
995− "properties": { "part": {
996− "id": "t", "messageID": "m", "type": "tool", "tool": "bash",
997− "state": { "status": "completed", "title": "ls -la" }
1000− let msg = &app.view(&model).messages[0];
1001− assert_eq!(msg.reasoning.as_deref(), Some("thinking..."));
1002− assert_eq!(msg.tools.len(), 1);
908+ assert_eq!(model.sessions.len(), 1);
1003− assert_eq!(msg.tools[0].name, "bash");
909+ assert_eq!(model.sessions[0].id, "s2");
1004− assert_eq!(msg.tools[0].status, "completed");
910+ // HTTP effect emitted for the server-side delete
1005− assert_eq!(msg.tools[0].title.as_deref(), Some("ls -la"));
911+ assert!(cmd.effects().any(|e| matches!(e, Effect::Http(_))));
1009− fn session_created_event_updates_list() {
915+ fn delete_current_session_clears_chat_state() {
1010− let app = app();
916+ let app = OpencodeApp;
1011− let mut model = in_chat("ses_1");
917+ let mut model = Model::default();
1012− feed(&app, &mut model, serde_json::json!({
918+ model.server_url = "http://localhost:4096".to_string();
1013− "type": "session.created",
919+ model.current_session_id = Some("s1".to_string());
1014− "properties": { "info": { "id": "ses_new", "title": "Fresh" }}
920+ model.current_session_title = "First".to_string();
1015− }));
921+ model.generating = true;
1016− assert!(app.view(&model).sessions.iter().any(|s| s.id == "ses_new" && s.title == "Fresh"));
922+ model.messages.push(MessageView::default());
923+ app.update(Event::DeleteSession("s1".to_string()), &mut model);
924+ assert!(model.current_session_id.is_none());
925+ assert!(model.current_session_title.is_empty());
926+ assert!(model.messages.is_empty());
927+ assert!(!model.generating);
1020− fn unknown_event_types_are_ignored() {
931+ fn auth_header_built_from_credentials() {
1021− let app = app();
932+ let app = OpencodeApp;
1022− let mut model = in_chat("ses_1");
933+ let mut model = Model::default();
1023− feed(&app, &mut model, serde_json::json!({
934+ model.server_url = "http://localhost:4096".to_string();
1024− "type": "pty.created", "properties": { "whatever": true }
935+ model.username = "opencode".to_string();
1025− }));
936+ model.password = "secret".to_string();
1026− feed(&app, &mut model, serde_json::json!({ "type": "totally.new.event" }));
937+ // Verify the base64 encoding matches RFC 7617.
1027− // No panic, no state change.
938+ let creds = format!("{}:{}", model.username, model.password);
1028− assert!(app.view(&model).messages.is_empty());
939+ let encoded = base64::engine::general_purpose::STANDARD.encode(creds.as_bytes());
940+ assert_eq!(encoded, "b3BlbmNvZGU6c2VjcmV0");
941+ // Building a request should not panic.
942+ let _ = app.get(&model, "/global/health");
1032− fn messages_loaded_parses_info_and_parts() {
946+ fn crash_log_event_accumulates() {
1033− let app = app();
947+ let app = OpencodeApp;
1034− let mut model = in_chat("ses_1");
948+ let mut model = Model::default();
1035− let body = serde_json::json!([
949+ app.update(Event::CrashLog("boom".to_string()), &mut model);
1036− { "info": { "id": "m1", "role": "user", "sessionID": "ses_1", "time": {"created": 1} },
950+ assert_eq!(model.crash_logs.len(), 1);
1037− "parts": [{ "id": "p1", "type": "text", "text": "Question?" }] },
1038− { "info": { "id": "m2", "role": "assistant", "sessionID": "ses_1", "time": {"created": 2, "completed": 3} },
1039− "parts": [{ "id": "p2", "type": "text", "text": "Answer." }] }
1041− let result: HttpResult = Ok(crux_http::testing::ResponseBuilder::ok().body(body).build());
1042− let _ = app.update(Event::MessagesLoaded("ses_1".into(), result), &mut model);
1044 let view = app.view(&model);
951 let view = app.view(&model);
1045− assert_eq!(view.messages.len(), 2);
952+ assert_eq!(view.crash_log_count, 1);
1046− assert_eq!(view.messages[0].text, "Question?");
953+ assert_eq!(view.latest_crash_log.as_deref(), Some("boom"));
1047− assert_eq!(view.messages[1].text, "Answer.");
954+ }
1048− assert!(!view.messages[1].streaming);
955+
1049− assert!(!view.generating);
956+ /// Verify that the bincode discriminant indices the shell sends match
957+ /// the Rust enum variant positions — the type generator skips
958+ /// `#[facet(skip)]` variants and renumbers the remaining ones, so the
959+ /// shell's index 7 (SelectSession) must land on Rust's SelectSession,
960+ /// not on a skipped variant.
962+ fn event_discriminants_match_generated_indices() {
963+ // The generated Kotlin Event enum (see generated/.../Core.kt) maps:
964+ // 0=Start, 1=ServerUrlChanged, 2=UsernameChanged, 3=PasswordChanged,
965+ // 4=Connect, 5=CancelAuth, 6=LoadSessions, 7=SelectSession,
966+ // 8=CreateSession, 9=LoadMessages, 10=SendMessage, 11=EventReceived,
967+ // 12=NavigateToChat, 13=NavigateToSessions, 14=NavigateToConnect,
968+ // 15=DismissError, 16=DraftChanged, 17=CancelGeneration,
969+ // 18=DeleteSession, 19=RetryMessage
971+ // Serialize each Rust variant and check the leading u32 index.
972+ let cases: &[(Event, u32)] = &[
974+ (Event::ServerUrlChanged(String::new()), 1),
975+ (Event::UsernameChanged(String::new()), 2),
976+ (Event::PasswordChanged(String::new()), 3),
977+ (Event::Connect, 4),
978+ (Event::CancelAuth, 5),
979+ (Event::LoadSessions, 6),
980+ (Event::SelectSession(String::new()), 7),
981+ (Event::CreateSession, 8),
982+ (Event::LoadMessages(String::new()), 9),
983+ (Event::SendMessage(String::new()), 10),
984+ (Event::EventReceived(String::new()), 11),
985+ (Event::NavigateToChat(String::new()), 12),
986+ (Event::NavigateToSessions, 13),
987+ (Event::NavigateToConnect, 14),
988+ (Event::DismissError, 15),
989+ (Event::DraftChanged(String::new()), 16),
990+ (Event::CancelGeneration, 17),
991+ (Event::DeleteSession(String::new()), 18),
992+ (Event::RetryMessage(String::new()), 19),
994+ for (event, expected) in cases {
995+ let bytes = bincode::serialize(event).unwrap();
996+ let idx = u32::from_le_bytes(bytes[0..4].try_into().unwrap());
999+ "Event discriminant mismatch for {event:?}: got {idx}, expected {expected}"