@@ -1,287 +1,124 @@
1−//! The Crux `App`: model, events, effects, update logic and view.
2−//!
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.
10−
11−use base64::Engine;
121use crux_core::{
13− macros::effect,
14− render::{render, RenderOperation},
152 App, Command,
3+ macros::effect,
4+ render::{RenderOperation, render},
165};
17−use crux_http::command::{Http, RequestBuilder};
186use crux_http::protocol::HttpRequest;
7+use facet::Facet;
198use serde::{Deserialize, Serialize};
209
21−use crate::protocol::{self, ServerEvent, WireMessageEnvelope, WirePart};
22−
23−/// Result of an HTTP effect handed back to the core.
24−pub type HttpResult = Result<crux_http::Response<String>, crux_http::HttpError>;
25−
26−// ─── Events ──────────────────────────────────────────────────────────────────
10+// ─── Events ────────────────────────────────────────────────────────────────
2711
12+#[derive(Facet, Serialize, Deserialize, Clone, Debug)]
13+#[repr(C)]
2814pub enum Event {
29− // Lifecycle / connect
15+ // Lifecycle
3016 Start,
3117 ServerUrlChanged(String),
32− UsernameChanged(String),
33− PasswordChanged(String),
3418 Connect,
3519
36− // Sessions
20+ // Session list
3721 LoadSessions,
22+ // events local to the core
23+ #[serde(skip)]
24+ #[facet(skip)]
25+ SessionsLoaded(#[facet(opaque)] HttpResult<String>),
3826 SelectSession(String),
3927 CreateSession,
40− DeleteSession(String),
28+ SessionCreated(#[facet(opaque)] HttpResult<String>),
4129
4230 // Chat
4331 LoadMessages(String),
44− DraftChanged(String),
32+ MessagesLoaded(#[facet(opaque)] HttpResult<String>),
4533 SendMessage(String),
46− CancelGeneration,
34+ MessageSent(#[facet(opaque)] HttpResult<String>),
4735
48− // A raw event line from the shell's `/event` SSE subscription.
49− ServerEvent(String),
36+ // SSE event received
37+ EventReceived(String),
5038
51− // Navigation / misc
39+ // Navigation
40+ NavigateToChat(String),
5241 NavigateToSessions,
53− NavigateToConnect,
54− DismissError,
5542
56− // ── Internal: results of HTTP effects (never sent by the shell) ──────────
57− HealthProbed(HttpResult),
58− SessionsLoaded(HttpResult),
59− SessionCreated(HttpResult),
60− MessagesLoaded(String, HttpResult),
61− PromptSent(HttpResult),
62− SessionDeleted(HttpResult),
63− Aborted(HttpResult),
43+ // Errors
44+ DismissError,
6445}
6546
66−// ─── Effects ─────────────────────────────────────────────────────────────────
47+// ─── Effects ───────────────────────────────────────────────────────────────
6748
68−#[effect]
49+#[effect(facet_typegen)]
6950#[derive(Debug)]
7051pub enum Effect {
7152 Render(RenderOperation),
7253 Http(HttpRequest),
7354}
7455
75−// ─── Model ───────────────────────────────────────────────────────────────────
56+// ─── HTTP result wrapper (opaque, not type-generated) ──────────────────────
57+
58+pub type HttpResult<T> = Result<crux_http::Response<T>, crux_http::HttpError>;
59+
60+// ─── Model ─────────────────────────────────────────────────────────────────
7661
7762#[derive(Default)]
7863pub struct Model {
7964 server_url: String,
80− username: String,
81− password: String,
82− /// The server answered 401 to an unauthenticated probe — show credentials.
83− auth_required: bool,
84− /// Credentials were accepted; attach the auth header to every request.
85− authed: bool,
8665 connected: bool,
8766 loading: bool,
8867 error: Option<String>,
89− screen: Screen,
90−
91− sessions: Vec<SessionView>,
68+ sessions: Vec<SessionSummary>,
9269 current_session_id: Option<String>,
93− current_session_title: String,
94−
95− messages: Vec<MsgState>,
96− draft: String,
97− generating: bool,
98−
99− /// Monotonic counter for optimistic (client-side) user-message ids.
100− local_seq: u64,
70+ messages: Vec<MessageView>,
71+ draft_message: String,
10172}
10273
103−impl Model {
104− fn message_mut(&mut self, id: &str) -> Option<&mut MsgState> {
105− self.messages.iter_mut().find(|m| m.id == id)
106− }
107−
108− fn has_credentials(&self) -> bool {
109− !self.username.is_empty() || !self.password.is_empty()
110− }
111−
112− fn is_current(&self, session_id: &str) -> bool {
113− self.current_session_id.as_deref() == Some(session_id)
114− }
115−}
116−
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.
119−struct MsgState {
120− id: String,
121− role: String,
122− time: u64,
123− status: MessageStatus,
124− streaming: bool,
125− text_parts: Vec<(String, String)>,
126− reasoning_parts: Vec<(String, String)>,
127− tool_parts: Vec<(String, ToolView)>,
128−}
129−
130−impl MsgState {
131− fn new(id: String, role: String, time: u64) -> Self {
132− Self {
133− id,
134− role,
135− time,
136− status: MessageStatus::Sent,
137− streaming: false,
138− text_parts: Vec::new(),
139− reasoning_parts: Vec::new(),
140− tool_parts: Vec::new(),
141− }
142− }
143−
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) {
146− slot.1 = text;
147− } else {
148− parts.push((id.to_string(), text));
149− }
150− }
151−
152− fn upsert_tool(&mut self, id: &str, view: ToolView) {
153− if let Some(slot) = self.tool_parts.iter_mut().find(|(pid, _)| pid == id) {
154− slot.1 = view;
155− } else {
156− self.tool_parts.push((id.to_string(), view));
157− }
158− }
159−
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);
164− }
165−
166− fn to_view(&self) -> MessageView {
167− let join = |parts: &[(String, String)]| {
168− parts.iter().map(|(_, t)| t.as_str()).collect::<String>()
169− };
170− let reasoning = join(&self.reasoning_parts);
171− MessageView {
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(),
177− time: self.time,
178− status: self.status.clone(),
179− streaming: self.streaming,
180− }
181− }
182−}
183−
184−// ─── View model ──────────────────────────────────────────────────────────────
185−
186−#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, Eq)]
187−pub enum Screen {
188− #[default]
189− Connect,
190− Sessions,
191− Chat,
192−}
193−
194−#[derive(Serialize, Deserialize, Clone, Debug, Default)]
195−pub struct SessionView {
74+#[derive(Clone, Debug, Default)]
75+pub struct SessionSummary {
19676 pub id: String,
19777 pub title: String,
19878}
19979
200−#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, Eq)]
201−pub enum MessageStatus {
202− #[default]
203− Sent,
204− Pending,
205− Failed,
206−}
207−
208−#[derive(Serialize, Deserialize, Clone, Debug, Default)]
209−pub struct ToolView {
210− pub name: String,
211− pub status: String,
212− pub title: Option<String>,
213−}
214−
215−#[derive(Serialize, Deserialize, Clone, Debug, Default)]
80+#[derive(Facet, Serialize, Deserialize, Clone, Debug, Default)]
21681pub struct MessageView {
21782 pub id: String,
21883 pub role: String,
21984 pub text: String,
220− pub reasoning: Option<String>,
221− pub tools: Vec<ToolView>,
22285 pub time: u64,
223− pub status: MessageStatus,
224− pub streaming: bool,
22586}
22687
227−#[derive(Serialize, Deserialize, Clone, Debug, Default)]
88+// ─── ViewModel ─────────────────────────────────────────────────────────────
89+
90+#[derive(Facet, Serialize, Deserialize, Clone, Debug, Default)]
22891pub struct ViewModel {
22992 pub screen: Screen,
23093 pub server_url: String,
231− pub username: String,
232− pub password: String,
233− pub auth_required: bool,
23494 pub connected: bool,
23595 pub loading: bool,
23696 pub error: Option<String>,
23797 pub sessions: Vec<SessionView>,
23898 pub current_session_id: Option<String>,
239− pub current_session_title: String,
24099 pub messages: Vec<MessageView>,
241− pub draft: String,
242− pub generating: bool,
100+ pub draft_message: String,
243101}
244102
245−// ─── App ─────────────────────────────────────────────────────────────────────
246−
247−#[derive(Default)]
248−pub struct OpencodeApp;
249−
250−impl OpencodeApp {
251− fn get(&self, model: &Model, path: &str) -> RequestBuilder<Effect, Event, String> {
252− let url = format!("{}{path}", model.server_url);
253− self.with_auth(Http::get(&url).expect_string(), model)
254− }
103+#[derive(Facet, Serialize, Deserialize, Clone, Debug, Default, PartialEq, Eq)]
104+#[repr(C)]
105+pub enum Screen {
106+ #[default]
107+ Connect,
108+ Sessions,
109+ Chat,
110+}
255111
256− fn post_json(&self, model: &Model, path: &str, body: &serde_json::Value) -> RequestBuilder<Effect, Event, String> {
257− let url = format!("{}{path}", model.server_url);
258− let bytes = serde_json::to_vec(body).unwrap_or_default();
259− let req = Http::post(&url)
260− .expect_string()
261− .header("Content-Type", "application/json")
262− .body_bytes(bytes);
263− self.with_auth(req, model)
264− }
112+#[derive(Facet, Serialize, Deserialize, Clone, Debug, Default)]
113+pub struct SessionView {
114+ pub id: String,
115+ pub title: String,
116+}
265117
266− fn delete(&self, model: &Model, path: &str) -> RequestBuilder<Effect, Event, String> {
267− let url = format!("{}{path}", model.server_url);
268− self.with_auth(Http::delete(&url).expect_string(), model)
269− }
118+// ─── App ───────────────────────────────────────────────────────────────────
270119
271− /// Attach an RFC 7617 Basic-Auth header when the model carries credentials.
272− fn with_auth<E>(&self, req: RequestBuilder<Effect, Event, E>, model: &Model) -> RequestBuilder<Effect, Event, E>
273− where
274− E: 'static,
275− {
276− if model.has_credentials() {
277− let creds = format!("{}:{}", model.username, model.password);
278− let encoded = base64::engine::general_purpose::STANDARD.encode(creds.as_bytes());
279− req.header("Authorization", format!("Basic {encoded}"))
280− } else {
281− req
282− }
283− }
284−}
120+#[derive(Default)]
121+pub struct OpencodeApp;
285122
286123impl App for OpencodeApp {
287124 type Event = Event;
@@ -291,246 +128,150 @@ impl App for OpencodeApp {
291128
292129 fn update(&self, event: Event, model: &mut Model) -> Command<Effect, Event> {
293130 match event {
294− // ── Lifecycle / connect ─────────────────────────────────────────
295− Event::Start => render(),
131+ Event::Start => {
132+ model.server_url = "http://localhost:4096".to_string();
133+ render()
134+ }
296135
297− // Store the field verbatim while typing; normalizing here would fight
298− // the user's edits (e.g. eat the "://" as they type it). The URL is
299− // normalized once, on Connect.
300− // Clear any prior error as soon as the user edits a field, so a stale
301− // message (e.g. "Invalid credentials") doesn't linger while they correct it.
302136 Event::ServerUrlChanged(url) => {
303137 model.server_url = url;
304− if model.error.is_some() {
305− model.error = None;
306− }
307− render()
308− }
309− Event::UsernameChanged(u) => {
310− model.username = u;
311− if model.error.is_some() {
312− model.error = None;
313− }
314− render()
315− }
316− Event::PasswordChanged(p) => {
317− model.password = p;
318− if model.error.is_some() {
319− model.error = None;
320− }
321138 render()
322139 }
323140
324141 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());
328− return render();
329− }
330142 model.loading = true;
331143 model.error = None;
332− model.auth_required = false;
333− render().and(self.get(model, "/global/health").build().then_send(Event::HealthProbed))
144+ let url = format!("{}/global/health", model.server_url);
145+ Http::get(&url).expect_string().build().then_send(|_| Event::LoadSessions)
334146 }
335147
336− Event::HealthProbed(result) => self.on_health_probed(model, result),
337−
338− // ── Sessions ────────────────────────────────────────────────────
339148 Event::LoadSessions => {
340149 model.loading = true;
341− render().and(self.get(model, "/session").build().then_send(Event::SessionsLoaded))
150+ let url = format!("{}/session", model.server_url);
151+ Http::get(&url).expect_string().build().then_send(Event::SessionsLoaded)
342152 }
343153
344154 Event::SessionsLoaded(result) => {
345155 model.loading = false;
346− match ok_body(result) {
347− Ok(body) => {
348− model.sessions = protocol::parse_sessions(&body)
349− .into_iter()
350− .map(|s| SessionView {
351− id: s.id,
352− title: display_title(&s.title),
353− })
354− .collect();
355− // Impose a stable alphabetical order so the list doesn't shuffle
356− // with whatever order the server happens to return sessions in.
357− model.sessions.sort_by_key(|s| s.title.to_lowercase());
156+ match result {
157+ Ok(mut response) => {
158+ let body = response.take_body().unwrap_or_default();
159+ model.sessions = parse_sessions(&body);
160+ model.connected = true;
161+ render()
162+ }
163+ Err(e) => {
164+ model.error = Some(format!("Failed to load sessions: {e}"));
165+ render()
358166 }
359− Err(e) => model.error = Some(e),
360167 }
361− render()
362168 }
363169
364170 Event::SelectSession(id) => {
365− model.current_session_title = model
366− .sessions
367− .iter()
368− .find(|s| s.id == id)
369− .map(|s| s.title.clone())
370− .unwrap_or_default();
171+ model.current_session_id = Some(id.clone());
172+ Command::event(Event::NavigateToChat(id))
173+ }
174+
175+ Event::NavigateToChat(id) => {
371176 model.current_session_id = Some(id.clone());
372177 model.messages.clear();
373− model.screen = Screen::Chat;
374− model.loading = true;
375− model.error = None;
376178 render().and(Command::event(Event::LoadMessages(id)))
377179 }
378180
181+ Event::NavigateToSessions => {
182+ model.current_session_id = None;
183+ model.messages.clear();
184+ render()
185+ }
186+
379187 Event::CreateSession => {
380188 model.loading = true;
381− render().and(
382− self.post_json(model, "/session", &serde_json::json!({}))
383− .build()
384− .then_send(Event::SessionCreated),
385− )
189+ let url = format!("{}/session", model.server_url);
190+ Http::post(&url).expect_string().build().then_send(Event::SessionCreated)
386191 }
387192
388193 Event::SessionCreated(result) => {
389194 model.loading = false;
390− match ok_body(result) {
391− Ok(body) => {
392− if let Some(s) = protocol::parse_session(&body) {
393− let view = SessionView {
394− id: s.id.clone(),
395− title: display_title(&s.title),
396− };
397− if !model.sessions.iter().any(|e| e.id == view.id) {
398− model.sessions.insert(0, view);
399− }
400− return render().and(Command::event(Event::SelectSession(s.id)));
401− }
402− model.error = Some("Malformed session response".to_string());
195+ match result {
196+ Ok(mut response) => {
197+ let body = response.take_body().unwrap_or_default();
198+ let id = parse_session_id(&body);
199+ Command::event(Event::NavigateToChat(id))
200+ }
201+ Err(e) => {
202+ model.error = Some(format!("Failed to create session: {e}"));
203+ render()
403204 }
404− Err(e) => model.error = Some(e),
405− }
406− render()
407− }
408−
409− Event::DeleteSession(id) => {
410− model.sessions.retain(|s| s.id != id);
411− let mut cmd = self.delete(model, &format!("/session/{id}")).build().then_send(Event::SessionDeleted);
412− if model.is_current(&id) {
413− model.current_session_id = None;
414− model.messages.clear();
415− model.screen = Screen::Sessions;
416− }
417− cmd = render().and(cmd);
418− cmd
419− }
420−
421− Event::SessionDeleted(result) => {
422− if let Err(e) = ok_body(result) {
423− model.error = Some(e);
424205 }
425− render()
426206 }
427207
428− // ── Chat ────────────────────────────────────────────────────────
429− Event::LoadMessages(id) => {
430− render().and(
431− self.get(model, &format!("/session/{id}/message"))
432− .build()
433− .then_send(move |result| Event::MessagesLoaded(id.clone(), result)),
434− )
208+ Event::LoadMessages(session_id) => {
209+ model.loading = true;
210+ let url = format!("{}/session/{}/message", model.server_url, session_id);
211+ Http::get(&url).expect_string().build().then_send(Event::MessagesLoaded)
435212 }
436213
437− Event::MessagesLoaded(session_id, result) => {
438− if !model.is_current(&session_id) {
439− return render();
440− }
214+ Event::MessagesLoaded(result) => {
441215 model.loading = false;
442− match ok_body(result) {
443− Ok(body) => {
444− model.messages = protocol::parse_messages(&body).iter().map(message_from_wire).collect();
445− model.generating = model.messages.iter().any(|m| m.streaming);
216+ match result {
217+ Ok(mut response) => {
218+ let body = response.take_body().unwrap_or_default();
219+ model.messages = parse_messages(&body);
220+ render()
221+ }
222+ Err(e) => {
223+ model.error = Some(format!("Failed to load messages: {e}"));
224+ render()
446225 }
447− Err(e) => model.error = Some(e),
448226 }
449− render()
450− }
451−
452− Event::DraftChanged(text) => {
453− model.draft = text;
454− render()
455227 }
456228
457229 Event::SendMessage(text) => {
458− let text = text.trim().to_string();
459− let Some(session_id) = model.current_session_id.clone() else {
460− return render();
230+ let session_id = match &model.current_session_id {
231+ Some(id) => id.clone(),
232+ None => return render(),
461233 };
462− if text.is_empty() {
463− return render();
464− }
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;
472− model.error = None;
473−
474− let body = serde_json::json!({ "parts": [{ "type": "text", "text": text }] });
475− render().and(
476− self.post_json(model, &format!("/session/{session_id}/prompt_async"), &body)
477− .build()
478− .then_send(Event::PromptSent),
479− )
480− }
481−
482− Event::PromptSent(result) => {
483− match ok_body(result) {
484− Ok(_) => set_last_pending(model, MessageStatus::Sent),
234+ model.draft_message.clear();
235+ let url = format!(
236+ "{}/session/{}/prompt_async",
237+ model.server_url, session_id
238+ );
239+ let body = format!(
240+ r#"{{"sessionID":"{}","parts":[{{"type":"text","text":"{}"}}]}}"#,
241+ session_id, text
242+ );
243+ Http::post(&url)
244+ .header("Content-Type", "application/json")
245+ .body_bytes(body.into_bytes())
246+ .expect_string()
247+ .build()
248+ .then_send(Event::MessageSent)
249+ }
250+
251+ Event::MessageSent(result) => {
252+ match result {
253+ Ok(_) => {
254+ // Reload messages to get the response
255+ match &model.current_session_id {
256+ Some(id) => Command::event(Event::LoadMessages(id.clone())),
257+ None => render(),
258+ }
259+ }
485260 Err(e) => {
486− set_last_pending(model, MessageStatus::Failed);
487− model.generating = false;
488− model.error = Some(e);
261+ model.error = Some(format!("Failed to send message: {e}"));
262+ render()
489263 }
490264 }
491− render()
492265 }
493266
494− Event::CancelGeneration => {
495− model.generating = false;
496− match model.current_session_id.clone() {
497− Some(id) => render().and(
498− self.post_json(model, &format!("/session/{id}/abort"), &serde_json::json!({}))
499− .build()
500− .then_send(Event::Aborted),
501− ),
267+ Event::EventReceived(_data) => {
268+ // SSE event — reload messages to show updates
269+ match &model.current_session_id {
270+ Some(id) => Command::event(Event::LoadMessages(id.clone())),
502271 None => render(),
503272 }
504273 }
505274
506− Event::Aborted(_) => render(),
507−
508− // ── SSE ─────────────────────────────────────────────────────────
509− Event::ServerEvent(json) => {
510− if let Some(event) = protocol::parse_event(&json) {
511− apply_server_event(model, event);
512− }
513− render()
514− }
515−
516− // ── Navigation / misc ───────────────────────────────────────────
517− Event::NavigateToSessions => {
518− model.screen = Screen::Sessions;
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))
523− }
524−
525− Event::NavigateToConnect => {
526− model.screen = Screen::Connect;
527− model.connected = false;
528− model.sessions.clear();
529− model.messages.clear();
530− model.current_session_id = None;
531− render()
532− }
533−
534275 Event::DismissError => {
535276 model.error = None;
536277 render()
@@ -540,512 +281,214 @@ impl App for OpencodeApp {
540281
541282 fn view(&self, model: &Model) -> ViewModel {
542283 ViewModel {
543− screen: model.screen.clone(),
284+ screen: if model.current_session_id.is_some() {
285+ Screen::Chat
286+ } else if model.connected {
287+ Screen::Sessions
288+ } else {
289+ Screen::Connect
290+ },
544291 server_url: model.server_url.clone(),
545− username: model.username.clone(),
546− password: model.password.clone(),
547− auth_required: model.auth_required,
548292 connected: model.connected,
549293 loading: model.loading,
550294 error: model.error.clone(),
551− sessions: model.sessions.clone(),
295+ sessions: model
296+ .sessions
297+ .iter()
298+ .map(|s| SessionView {
299+ id: s.id.clone(),
300+ title: s.title.clone(),
301+ })
302+ .collect(),
552303 current_session_id: model.current_session_id.clone(),
553− current_session_title: model.current_session_title.clone(),
554− messages: model.messages.iter().map(MsgState::to_view).collect(),
555− draft: model.draft.clone(),
556− generating: model.generating,
557− }
558− }
559−}
560−
561−impl OpencodeApp {
562− fn on_health_probed(&self, model: &mut Model, result: HttpResult) -> Command<Effect, Event> {
563− let has_creds = model.has_credentials();
564− match result {
565− Ok(response) => {
566− let status = response.status().as_u16();
567− if status == 401 {
568− model.loading = false;
569− if has_creds {
570− model.error = Some("Invalid credentials".to_string());
571− } else {
572− model.auth_required = true;
573− }
574− return render();
575− }
576− if (200..300).contains(&status) {
577− if has_creds {
578− model.authed = true;
579− }
580− model.connected = true;
581− model.auth_required = false;
582− model.error = None;
583− model.screen = Screen::Sessions;
584− model.loading = true;
585− return render().and(self.get(model, "/session").build().then_send(Event::SessionsLoaded));
586− }
587− model.loading = false;
588− model.error = Some(format!("Server returned status {status}"));
589− render()
590− }
591− Err(e) => {
592− model.loading = false;
593− model.error = Some(format!("Connection failed: {e}"));
594− render()
595− }
304+ messages: model.messages.clone(),
305+ draft_message: model.draft_message.clone(),
596306 }
597307 }
598308}
599309
600−// ─── SSE application ─────────────────────────────────────────────────────────
601−
602−fn apply_server_event(model: &mut Model, event: ServerEvent) {
603− match event {
604− // Only assistant messages are created from the stream — the user's own
605− // message is already shown optimistically, so ignoring the server's copy
606− // avoids a duplicate bubble.
607− ServerEvent::MessageUpdated { properties } => {
608− let info = properties.info;
609− if info.role != "assistant" || !model.is_current(&info.session_id) {
610− return;
611− }
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;
615− if msg.time == 0 {
616− msg.time = info.time.created;
617− }
618− } else {
619− let mut msg = MsgState::new(info.id.clone(), "assistant".to_string(), info.time.created);
620− msg.streaming = streaming;
621− model.messages.push(msg);
622− }
623− if let Some(err) = info.error {
624− model.error = Some(err.message());
625− model.generating = false;
626− }
627− }
628−
629− // Apply only to a message we already track (an assistant message from the
630− // event above). Parts for unknown ids are ignored — see module docs.
631− ServerEvent::MessagePartUpdated { properties } => {
632− let part = properties.part;
633− let delta = properties.delta;
634− let msg_id = part.message_id().to_string();
635− let Some(msg) = model.message_mut(&msg_id) else {
636− return;
637− };
638− match part {
639− WirePart::Text { id, text, synthetic, .. } => {
640− if synthetic {
641− return;
310+// ─── JSON parsing helpers (naive — the core stays pure) ────────────────────
311+
312+fn parse_sessions(json: &str) -> Vec<SessionSummary> {
313+ let mut sessions = Vec::new();
314+ let mut depth = 0;
315+ let mut start = 0;
316+ let bytes = json.as_bytes();
317+
318+ let mut i = 0;
319+ while i < bytes.len() {
320+ match bytes[i] {
321+ b'{' if depth == 0 => {
322+ depth = 1;
323+ start = i;
324+ }
325+ b'{' => depth += 1,
326+ b'}' => {
327+ depth -= 1;
328+ if depth == 0 {
329+ let obj = &json[start..=i];
330+ let id = extract_string(obj, "id").unwrap_or_default();
331+ let title = extract_string(obj, "title").unwrap_or_default();
332+ if !id.is_empty() {
333+ sessions.push(SessionSummary { id, title });
642334 }
643− let value = pick_text(text, &delta, &msg.text_parts, &id);
644− MsgState::upsert_part(&mut msg.text_parts, &id, value);
645− }
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);
649− }
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 });
653− }
654− WirePart::Other => {}
655− }
656− }
657−
658− ServerEvent::MessagePartRemoved { properties } => {
659− if let Some(msg) = model.message_mut(&properties.message_id) {
660− msg.remove_part(&properties.part_id);
661− }
662− }
663−
664− ServerEvent::MessageRemoved { properties } => {
665− model.messages.retain(|m| m.id != properties.message_id);
666− }
667−
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;
673− }
674− }
675− }
676−
677− ServerEvent::SessionError { properties } => {
678− let scoped = properties.session_id.as_deref().map_or(true, |s| model.is_current(s));
679− if scoped {
680− if let Some(err) = properties.error {
681− model.error = Some(err.message());
682− }
683− model.generating = false;
684− }
685− }
686−
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();
692− } else {
693− model.sessions.insert(0, view);
694− }
695− if model.is_current(&s.id) {
696− model.current_session_title = display_title(&s.title);
697− }
698− }
699−
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;
708335 }
709336 }
337+ _ => {}
710338 }
711−
712− ServerEvent::Other => {}
339+ i += 1;
713340 }
341+ sessions
714342}
715343
716−// ─── Helpers ─────────────────────────────────────────────────────────────────
717−
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() {
722− return text;
723− }
724− let prior = existing.iter().find(|(pid, _)| pid == part_id).map(|(_, t)| t.clone()).unwrap_or_default();
725− match delta {
726− Some(d) => format!("{prior}{d}"),
727− None => prior,
728− }
344+fn parse_session_id(json: &str) -> String {
345+ extract_string(json, "id").unwrap_or_default()
729346}
730347
731−fn message_from_wire(env: &WireMessageEnvelope) -> MsgState {
732− let info = &env.info;
733− let mut msg = MsgState::new(info.id.clone(), info.role.clone(), info.time.created);
734− msg.streaming = info.role == "assistant" && info.time.completed.is_none() && info.error.is_none();
735− for part in &env.parts {
736− match part {
737− WirePart::Text { id, text, synthetic, .. } => {
738− if !synthetic {
739− MsgState::upsert_part(&mut msg.text_parts, id, text.clone());
348+fn parse_messages(json: &str) -> Vec<MessageView> {
349+ let mut messages = Vec::new();
350+ let mut depth = 0;
351+ let mut start = 0;
352+ let bytes = json.as_bytes();
353+
354+ let mut i = 0;
355+ while i < bytes.len() {
356+ match bytes[i] {
357+ b'{' if depth == 0 => {
358+ depth = 1;
359+ start = i;
360+ }
361+ b'{' => depth += 1,
362+ b'}' => {
363+ depth -= 1;
364+ if depth == 0 {
365+ let obj = &json[start..=i];
366+ let id = extract_string(obj, "id").unwrap_or_default();
367+ let role = extract_string(obj, "role").unwrap_or_default();
368+ let time = extract_number(obj, "created").unwrap_or(0);
369+ if !id.is_empty() && !role.is_empty() {
370+ messages.push(MessageView {
371+ id,
372+ role,
373+ text: String::new(),
374+ time,
375+ });
376+ }
740377 }
741378 }
742− WirePart::Reasoning { id, text, .. } => {
743− MsgState::upsert_part(&mut msg.reasoning_parts, id, text.clone());
744− }
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 });
748− }
749− WirePart::Other => {}
379+ _ => {}
750380 }
381+ i += 1;
751382 }
752− msg
753−}
754−
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;
758− }
383+ messages
759384}
760385
761−/// Trim whitespace and any trailing `/` so paths concatenate cleanly, and
762−/// default to an `http://` scheme when the user didn't type one (e.g.
763−/// "192.168.1.10:4096") — otherwise the shell's URL parser rejects it.
764−fn normalize_url(url: &str) -> String {
765− let trimmed = url.trim().trim_end_matches('/');
766− if trimmed.is_empty() {
767− String::new()
768− } else if trimmed.contains("://") {
769− trimmed.to_string()
770− } else {
771− format!("http://{trimmed}")
772− }
386+fn extract_string(json: &str, key: &str) -> Option<String> {
387+ let pattern = format!("\"{key}\"");
388+ let idx = json.find(&pattern)?;
389+ let rest = &json[idx + pattern.len()..];
390+ let colon = rest.find(':')?;
391+ let rest = &rest[colon + 1..];
392+ let quote = rest.find('"')?;
393+ let rest = &rest[quote + 1..];
394+ let end = rest.find('"')?;
395+ Some(rest[..end].to_string())
773396}
774397
775−fn display_title(title: &str) -> String {
776− let t = title.trim();
777− if t.is_empty() {
778− "Untitled".to_string()
779− } else {
780− t.to_string()
781− }
398+fn extract_number(json: &str, key: &str) -> Option<u64> {
399+ let pattern = format!("\"{key}\"");
400+ let idx = json.find(&pattern)?;
401+ let rest = &json[idx + pattern.len()..];
402+ let colon = rest.find(':')?;
403+ let rest = rest[colon + 1..].trim_start();
404+ let end = rest
405+ .find(|c: char| !c.is_ascii_digit())
406+ .unwrap_or(rest.len());
407+ rest[..end].parse().ok()
782408}
783409
784−/// Reduce an [`HttpResult`] to `Ok(body)` for 2xx, or `Err(message)` otherwise.
785−fn ok_body(result: HttpResult) -> Result<String, String> {
786− match result {
787− Ok(mut response) => {
788− let status = response.status().as_u16();
789− if (200..300).contains(&status) {
790− Ok(response.take_body().unwrap_or_default())
791− } else {
792− Err(format!("Server returned status {status}"))
793− }
794− }
795− Err(e) => Err(format!("Request failed: {e}")),
796− }
797−}
410+// ─── HTTP type alias for the command builder ───────────────────────────────
798411
799−// ─── Tests ───────────────────────────────────────────────────────────────────
412+use crux_http::command::Http;
800413
801414#[cfg(test)]
802−mod tests {
415+mod test {
803416 use super::*;
804417
805− fn app() -> OpencodeApp {
806− OpencodeApp::default()
807− }
808−
809− /// Put the model into a connected Chat view for the given session.
810− fn in_chat(session_id: &str) -> Model {
811− let mut model = Model::default();
812− model.server_url = "http://localhost:4096".to_string();
813− model.connected = true;
814− model.screen = Screen::Chat;
815− model.current_session_id = Some(session_id.to_string());
816− model
817− }
818−
819− fn feed(app: &OpencodeApp, model: &mut Model, json: serde_json::Value) {
820− let _ = app.update(Event::ServerEvent(json.to_string()), model);
821− }
822−
823418 #[test]
824− fn server_url_is_kept_raw_while_typing() {
825− let app = app();
419+ fn start_sets_default_server_url() {
420+ let app = OpencodeApp;
826421 let mut model = Model::default();
827− // Mid-scheme input must survive verbatim — normalizing per keystroke
828− // would eat the "://" the user is typing and make the field unusable.
829− let _ = app.update(Event::ServerUrlChanged("http:/".into()), &mut model);
830− assert_eq!(app.view(&model).server_url, "http:/");
422+ app.update(Event::Start, &mut model).expect_only_render();
423+ assert_eq!(model.server_url, "http://localhost:4096");
831424 }
832425
833426 #[test]
834− fn connect_normalizes_scheme_less_url() {
835− let app = app();
427+ fn server_url_change_updates_model() {
428+ let app = OpencodeApp;
836429 let mut model = Model::default();
837− // A scheme-less host (what a user often types) must gain http:// on
838− // connect, or the shell's URL parser throws and the attempt crashes.
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);
842− assert_eq!(app.view(&model).server_url, "http://192.168.1.10:4096");
430+ app.update(Event::Start, &mut model);
431+ app.update(
432+ Event::ServerUrlChanged("http://10.0.0.1:4096".to_string()),
433+ &mut model,
434+ )
435+ .expect_only_render();
436+ assert_eq!(model.server_url, "http://10.0.0.1:4096");
843437 }
844438
845439 #[test]
846− fn connect_trims_and_keeps_explicit_scheme() {
847− let app = app();
440+ fn connect_emits_http_effect() {
441+ let app = OpencodeApp;
848442 let mut model = Model::default();
849− let _ = app.update(Event::ServerUrlChanged(" https://host:4096/ ".into()), &mut model);
850− let _ = app.update(Event::Connect, &mut model);
851− assert_eq!(app.view(&model).server_url, "https://host:4096");
443+ app.update(Event::Start, &mut model);
444+ let mut cmd = app.update(Event::Connect, &mut model);
445+ assert!(cmd.effects().any(|e| matches!(e, Effect::Http(_))));
446+ assert!(model.loading);
852447 }
853448
854449 #[test]
855− fn connect_requires_a_url() {
856− let app = app();
857− let mut model = Model::default();
858− let _ = app.update(Event::Connect, &mut model);
859− assert_eq!(app.view(&model).error.as_deref(), Some("Enter a server URL"));
860− }
861−
862− #[test]
863− fn sending_adds_optimistic_user_message_and_sets_generating() {
864− let app = app();
865− let mut model = in_chat("ses_1");
866− let _ = app.update(Event::DraftChanged("hello there".into()), &mut model);
867− let _ = app.update(Event::SendMessage("hello there".into()), &mut model);
868−
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);
876− }
877−
878− #[test]
879− fn empty_send_is_ignored() {
880− let app = app();
881− let mut model = in_chat("ses_1");
882− let _ = app.update(Event::SendMessage(" ".into()), &mut model);
883− assert!(app.view(&model).messages.is_empty());
884− assert!(!app.view(&model).generating);
885− }
886−
887− #[test]
888− fn assistant_reply_streams_in_from_sse() {
889− let app = app();
890− let mut model = in_chat("ses_1");
891−
892− // Assistant message shell arrives first.
893− feed(&app, &mut model, serde_json::json!({
894− "type": "message.updated",
895− "properties": { "info": {
896− "id": "msg_a", "role": "assistant", "sessionID": "ses_1",
897− "time": { "created": 100 }
898− }}
899− }));
900− assert_eq!(app.view(&model).messages.len(), 1);
901− assert!(app.view(&model).messages[0].streaming);
902−
903− // Two text deltas for the same part accumulate into full text.
904− feed(&app, &mut model, serde_json::json!({
905− "type": "message.part.updated",
906− "properties": { "part": {
907− "id": "prt_1", "messageID": "msg_a", "sessionID": "ses_1",
908− "type": "text", "text": "Hello"
909− }}
910− }));
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"
916− }}
917− }));
918−
919− let view = app.view(&model);
920− assert_eq!(view.messages[0].role, "assistant");
921− assert_eq!(view.messages[0].text, "Hello, world");
922− }
923−
924− #[test]
925− fn text_delta_accumulates_when_full_text_absent() {
926− let app = app();
927− let mut model = in_chat("ses_1");
928− feed(&app, &mut model, serde_json::json!({
929− "type": "message.updated",
930− "properties": { "info": { "id": "msg_a", "role": "assistant", "sessionID": "ses_1", "time": {"created": 1}}}
931− }));
932− for delta in ["Wor", "ld"] {
933− feed(&app, &mut model, serde_json::json!({
934− "type": "message.part.updated",
935− "properties": {
936− "part": { "id": "p", "messageID": "msg_a", "sessionID": "ses_1", "type": "text", "text": "" },
937− "delta": delta
938− }
939− }));
940− }
941− assert_eq!(app.view(&model).messages[0].text, "World");
450+ fn parse_sessions_extracts_id_and_title() {
451+ let json = r#"[{"id":"abc123","title":"My Session"},{"id":"def456","title":"Test"}]"#;
452+ let sessions = parse_sessions(json);
453+ assert_eq!(sessions.len(), 2);
454+ assert_eq!(sessions[0].id, "abc123");
455+ assert_eq!(sessions[0].title, "My Session");
456+ assert_eq!(sessions[1].id, "def456");
942457 }
943458
944459 #[test]
945− fn user_message_from_sse_is_not_duplicated() {
946− let app = app();
947− let mut model = in_chat("ses_1");
948− let _ = app.update(Event::SendMessage("hi".into()), &mut model);
949− // Server echoes the user message on the stream — must be ignored.
950− feed(&app, &mut model, serde_json::json!({
951− "type": "message.updated",
952− "properties": { "info": { "id": "msg_user", "role": "user", "sessionID": "ses_1", "time": {"created": 5}}}
953− }));
954− let users = app.view(&model).messages.iter().filter(|m| m.role == "user").count();
955− assert_eq!(users, 1);
460+ fn parse_session_id_extracts_id() {
461+ let json = r#"{"id":"xyz789","title":"New"}"#;
462+ let id = parse_session_id(json);
463+ assert_eq!(id, "xyz789");
956464 }
957465
958466 #[test]
959− fn session_idle_clears_generating() {
960− let app = app();
961− let mut model = in_chat("ses_1");
962− let _ = app.update(Event::SendMessage("hi".into()), &mut model);
963− assert!(app.view(&model).generating);
964− feed(&app, &mut model, serde_json::json!({
965− "type": "session.idle", "properties": { "sessionID": "ses_1" }
966− }));
967− assert!(!app.view(&model).generating);
467+ fn extract_string_finds_nested_keys() {
468+ let json = r#"{"a":"b","id":"target","c":"d"}"#;
469+ assert_eq!(extract_string(json, "id"), Some("target".to_string()));
470+ assert_eq!(extract_string(json, "missing"), None);
968471 }
969472
970473 #[test]
971− fn idle_for_other_session_is_ignored() {
972− let app = app();
973− let mut model = in_chat("ses_1");
974− let _ = app.update(Event::SendMessage("hi".into()), &mut model);
975− feed(&app, &mut model, serde_json::json!({
976− "type": "session.idle", "properties": { "sessionID": "ses_other" }
977− }));
978− assert!(app.view(&model).generating);
474+ fn extract_number_parses_values() {
475+ let json = r#"{"created":1234567890}"#;
476+ assert_eq!(extract_number(json, "created"), Some(1234567890));
979477 }
980478
981479 #[test]
982− fn reasoning_and_tool_parts_are_surfaced() {
983− let app = app();
984− let mut model = in_chat("ses_1");
985− feed(&app, &mut model, serde_json::json!({
986− "type": "message.updated",
987− "properties": { "info": { "id": "m", "role": "assistant", "sessionID": "ses_1", "time": {"created": 1}}}
988− }));
989− feed(&app, &mut model, serde_json::json!({
990− "type": "message.part.updated",
991− "properties": { "part": { "id": "r", "messageID": "m", "type": "reasoning", "text": "thinking..." }}
992− }));
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" }
998− }}
999− }));
1000− let msg = &app.view(&model).messages[0];
1001− assert_eq!(msg.reasoning.as_deref(), Some("thinking..."));
1002− assert_eq!(msg.tools.len(), 1);
1003− assert_eq!(msg.tools[0].name, "bash");
1004− assert_eq!(msg.tools[0].status, "completed");
1005− assert_eq!(msg.tools[0].title.as_deref(), Some("ls -la"));
1006− }
1007−
1008− #[test]
1009− fn session_created_event_updates_list() {
1010− let app = app();
1011− let mut model = in_chat("ses_1");
1012− feed(&app, &mut model, serde_json::json!({
1013− "type": "session.created",
1014− "properties": { "info": { "id": "ses_new", "title": "Fresh" }}
1015− }));
1016− assert!(app.view(&model).sessions.iter().any(|s| s.id == "ses_new" && s.title == "Fresh"));
1017− }
1018−
1019− #[test]
1020− fn unknown_event_types_are_ignored() {
1021− let app = app();
1022− let mut model = in_chat("ses_1");
1023− feed(&app, &mut model, serde_json::json!({
1024− "type": "pty.created", "properties": { "whatever": true }
1025− }));
1026− feed(&app, &mut model, serde_json::json!({ "type": "totally.new.event" }));
1027− // No panic, no state change.
1028− assert!(app.view(&model).messages.is_empty());
1029− }
1030−
1031− #[test]
1032− fn messages_loaded_parses_info_and_parts() {
1033− let app = app();
1034− let mut model = in_chat("ses_1");
1035− let body = serde_json::json!([
1036− { "info": { "id": "m1", "role": "user", "sessionID": "ses_1", "time": {"created": 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." }] }
1040− ]).to_string();
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);
1043−
1044− let view = app.view(&model);
1045− assert_eq!(view.messages.len(), 2);
1046− assert_eq!(view.messages[0].text, "Question?");
1047− assert_eq!(view.messages[1].text, "Answer.");
1048− assert!(!view.messages[1].streaming);
1049− assert!(!view.generating);
480+ fn navigate_to_sessions_clears_state() {
481+ let app = OpencodeApp;
482+ let mut model = Model::default();
483+ model.current_session_id = Some("test".to_string());
484+ model.messages.push(MessageView {
485+ id: "m1".to_string(),
486+ role: "user".to_string(),
487+ text: "hello".to_string(),
488+ time: 0,
489+ });
490+ app.update(Event::NavigateToSessions, &mut model);
491+ assert!(model.current_session_id.is_none());
492+ assert!(model.messages.is_empty());
1050493 }
1051494}