1use super::command;
2use crate::{ExperimentComparison, SharedDevelopmentWorkspace};
3use glass_browser::browser_workspace::{
4 BrowserConnectionPhase, BrowserWorkspaceAction, BrowserWorkspaceAdapterKind,
5 BrowserWorkspaceController, BrowserWorkspaceEntity, BrowserWorkspaceIntent,
6 BrowserWorkspaceLayout, BrowserWorkspaceTarget,
7};
8use glass_browser::cli::args::TuiLayout;
9use glass_browser::terminal_graphics::AnsiCanvas;
10use glass_browser::tui::live_view::AnsiPane;
11use serde::{Deserialize, Serialize};
12use std::path::Path;
13use std::sync::atomic::{AtomicU64, Ordering};
14
15static NEXT_BROWSER_TOOL: AtomicU64 = AtomicU64::new(1);
16
17pub struct PendingConfirmation {
18 pub call: crate::development::ToolCall,
19 pub context: crate::tools::DevelopmentToolContext,
20 pub summary: String,
21}
22
23#[derive(Debug, Clone)]
24pub struct PendingAgentApproval {
25 pub agent_id: String,
26 pub frame_id: String,
27 pub tool_name: String,
28 pub arguments: serde_json::Value,
29}
30
31#[derive(Debug, Clone, Copy, PartialEq, Eq)]
32pub enum ChatMessageState {
33 Sending,
34 Sent,
35 Failed,
36}
37
38#[derive(Debug, Clone, PartialEq, Eq)]
39pub struct PendingChatMessage {
40 pub text: String,
41 pub state: ChatMessageState,
42 pub job_id: Option<u64>,
43 pub error: Option<String>,
44}
45
46#[derive(Debug, Clone, PartialEq, Eq)]
48pub struct BrowserRecoveryOffer {
49 pub reason: String,
50 pub port: u16,
51 pub compatible_endpoint: bool,
53}
54
55impl BrowserRecoveryOffer {
56 pub fn from_error(error: &str, port: u16) -> Self {
57 let lower = error.to_ascii_lowercase();
58 Self {
59 reason: error.to_string(),
60 port,
61 compatible_endpoint: ["attach", "devtools", "page target", "multiple page targets"]
62 .iter()
63 .any(|marker| lower.contains(marker)),
64 }
65 }
66
67 pub fn actions(&self) -> &'static [(&'static str, &'static str)] {
68 if self.compatible_endpoint {
69 &[
70 ("1", "attach after checking the running browser"),
71 ("2", "launch an isolated browser on an automatic free port"),
72 ("3", "retry the preferred port"),
73 ("Esc", "dismiss"),
74 ]
75 } else {
76 &[
77 ("1", "launch an isolated browser on an automatic free port"),
78 ("2", "retry the preferred port"),
79 ("Esc", "dismiss"),
80 ]
81 }
82 }
83
84 pub fn guidance(&self) -> &'static str {
85 let lower = self.reason.to_ascii_lowercase();
86 if self.compatible_endpoint {
87 "A DevTools endpoint answered. Attach only when its page is the intended browser; otherwise launch an isolated session."
88 } else if lower.contains("occup") || lower.contains("address") || lower.contains("port") {
89 "The preferred endpoint is busy or unavailable. Glass keeps the project and agent alive while you retry or move to an automatic free port."
90 } else {
91 "The browser did not become usable. Check Chrome/Chromium availability, then retry; the workspace remains intact."
92 }
93 }
94}
95
96#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
97pub enum DevSurface {
98 Trust,
99 Agent,
100 Code,
101 App,
102 Terminal,
103 Tasks,
104 Git,
105 Debug,
106 More,
107}
108
109impl DevSurface {
110 pub const ALL: [Self; 8] = [
111 Self::Agent,
112 Self::Code,
113 Self::App,
114 Self::Terminal,
115 Self::Tasks,
116 Self::Git,
117 Self::Debug,
118 Self::More,
119 ];
120
121 pub const PRIMARY: [Self; 7] = [
122 Self::Agent,
123 Self::Code,
124 Self::App,
125 Self::Terminal,
126 Self::Tasks,
127 Self::Git,
128 Self::Debug,
129 ];
130
131 pub const PHONE: [Self; 5] = [Self::Agent, Self::Code, Self::App, Self::Tasks, Self::More];
132
133 pub fn label(self) -> &'static str {
134 match self {
135 Self::Trust => "Trust",
136 Self::Agent => "Agent",
137 Self::Code => "Code",
138 Self::App => "App",
139 Self::Terminal => "Terminal",
140 Self::Tasks => "Tasks",
141 Self::Git => "Git",
142 Self::Debug => "Debug",
143 Self::More => "More",
144 }
145 }
146}
147
148#[derive(Debug, Clone, Copy, PartialEq, Eq)]
149pub enum ResponsiveClass {
150 Desktop,
151 Compact,
152 Phone,
153}
154
155#[derive(Debug, Clone, Copy, PartialEq, Eq)]
156pub enum ProductMode {
157 Build,
158 Agent,
159 RunApp,
160 Debug,
161}
162
163impl ProductMode {
164 pub fn label(self) -> &'static str {
165 match self {
166 Self::Build => "build",
167 Self::Agent => "agent",
168 Self::RunApp => "run",
169 Self::Debug => "debug",
170 }
171 }
172}
173
174pub struct DevTuiState {
175 pub workspace: SharedDevelopmentWorkspace,
176 pub surface: DevSurface,
177 pub layout: TuiLayout,
178 pub quit: bool,
179 pub quit_confirmation: bool,
180 pub command_mode: bool,
181 pub command_input: String,
182 pub command_cursor: usize,
183 pub command_history: Vec<String>,
184 pub command_history_index: Option<usize>,
185 pub palette_error: Option<String>,
186 pub menu_open: bool,
187 pub menu_selection: usize,
188 pub help_open: bool,
189 pub help_scroll: u16,
190 pub composer_mode: bool,
191 pub composer_input: String,
192 pub composer_cursor: usize,
193 pub composer_steer: bool,
194 pub pending_chat_messages: Vec<PendingChatMessage>,
195 pub agent_send_job: Option<u64>,
196 pub selected_agent: Option<crate::AgentId>,
197 pub pending_confirmation: Option<PendingConfirmation>,
198 pub pending_agent_approval: Option<PendingAgentApproval>,
199 pub queued_tool_request: Option<(
200 crate::development::ToolCall,
201 crate::tools::DevelopmentToolContext,
202 )>,
203 pub running_tool_job: Option<u64>,
204 pub surface_scroll: std::collections::BTreeMap<DevSurface, usize>,
205 pub terminal_width: u16,
206 pub terminal_height: u16,
207 pub status: String,
208 pub snapshot_root: String,
209 pub snapshot_trust_label: String,
210 pub snapshot_trust_inspection: Vec<crate::customization::CustomizationInspectionItem>,
211 pub snapshot_project_revision: u64,
212 pub snapshot_generation: u64,
213 pub snapshot_skills_count: usize,
214 pub snapshot_tools_count: usize,
215 pub refresh_latency_ms: u64,
217 pub conversation_cursor: u64,
219 pub editor_buffer_index: usize,
221 pub focused_editor_path: String,
222 pub focused_editor_dirty: bool,
223 pub focused_editor_line: u32,
224 pub agents: String,
225 pub agent_readiness: String,
226 pub agent_login_requested: bool,
229 pub agent_conversation: String,
230 pub tasks: String,
231 pub editor: String,
232 pub files: Vec<String>,
233 pub selected_file: usize,
234 pub code_edit_mode: bool,
235 pub lsp: String,
236 pub processes: String,
237 pub git: String,
238 pub git_diff: String,
239 pub git_diff_open: bool,
240 pub git_diff_requested: bool,
241 pub tests: String,
242 pub kernels: String,
243 pub debugger: String,
244 pub replay: String,
245 pub browser: String,
246 pub browser_detail: String,
247 pub browser_workspace: BrowserWorkspaceController,
248 pub browser_recovery: Option<BrowserRecoveryOffer>,
249 pub browser_target_picker: bool,
250 pub browser_target_picker_requested: bool,
251 pub browser_target_query: String,
252 pub browser_target_selection: usize,
253 pub browser_visual_live: bool,
254 pub browser_observe_pending: bool,
255 pub browser_ansi: AnsiCanvas,
256 pub browser_pane: Option<AnsiPane>,
257 pub workflow: String,
258 pub workspace_status: String,
259 pub experiment_comparison: Option<ExperimentComparison>,
260 pub experiments: String,
261}
262
263impl DevTuiState {
264 pub fn ws(&self) -> Result<std::sync::MutexGuard<'_, crate::DevelopmentWorkspace>, String> {
266 self.workspace.try_lock().map_err(|error| error.to_string())
267 }
268
269 pub fn ws_mut(&self) -> Result<std::sync::MutexGuard<'_, crate::DevelopmentWorkspace>, String> {
271 self.workspace.try_lock().map_err(|error| error.to_string())
272 }
273
274 fn locked<F, T>(&mut self, operation: F) -> Option<T>
277 where
278 F: FnOnce(&mut crate::DevelopmentWorkspace) -> T,
279 {
280 match self.workspace.try_lock() {
281 Ok(mut workspace) => Some(operation(&mut workspace)),
282 Err(error) => {
283 self.status = format!("Workspace lock failed: {error}");
284 None
285 }
286 }
287 }
288
289 pub fn product_mode(&self) -> ProductMode {
290 match self.surface {
291 DevSurface::Agent => ProductMode::Agent,
292 DevSurface::App => ProductMode::RunApp,
293 DevSurface::Debug => ProductMode::Debug,
294 _ => ProductMode::Build,
295 }
296 }
297 pub fn open(
298 root: impl AsRef<Path>,
299 layout: TuiLayout,
300 ) -> Result<Self, Box<dyn std::error::Error>> {
301 Self::open_internal(root, layout, true)
302 }
303
304 pub fn open_for_tui(
308 root: impl AsRef<Path>,
309 layout: TuiLayout,
310 ) -> Result<Self, Box<dyn std::error::Error>> {
311 Self::open_internal(root, layout, false)
312 }
313
314 fn open_internal(
315 root: impl AsRef<Path>,
316 layout: TuiLayout,
317 initial_refresh: bool,
318 ) -> Result<Self, Box<dyn std::error::Error>> {
319 let workspace = SharedDevelopmentWorkspace::open(root)?;
320 let locked = workspace.lock()?;
321 let trust = locked.trust();
322 let trust_inspection = locked.trust_inspection();
323 let snapshot_root = locked.root().display().to_string();
324 let snapshot_project_revision = locked.project().revision();
325 let snapshot_generation = locked.generation();
326 let snapshot_skills_count = locked.customization().skills().count();
327 let snapshot_tools_count = locked.customization().config().tools.len();
328 let trust_prompt = trust == crate::WorkspaceTrust::Untrusted
329 && trust_inspection.iter().any(|item| item.trust_required);
330 drop(locked);
331 let mut state = Self {
332 workspace,
333 surface: if trust_prompt {
334 DevSurface::Trust
335 } else {
336 DevSurface::Agent
337 },
338 layout,
339 quit: false,
340 quit_confirmation: false,
341 command_mode: false,
342 command_input: String::new(),
343 command_cursor: 0,
344 command_history: Vec::new(),
345 command_history_index: None,
346 palette_error: None,
347 menu_open: false,
348 menu_selection: 0,
349 help_open: false,
350 help_scroll: 0,
351 composer_mode: false,
352 composer_input: String::new(),
353 composer_cursor: 0,
354 composer_steer: false,
355 pending_chat_messages: Vec::new(),
356 agent_send_job: None,
357 selected_agent: None,
358 pending_confirmation: None,
359 pending_agent_approval: None,
360 queued_tool_request: None,
361 running_tool_job: None,
362 surface_scroll: std::collections::BTreeMap::new(),
363 terminal_width: 80,
364 terminal_height: 24,
365 snapshot_root,
366 snapshot_trust_label: trust.label().into(),
367 snapshot_trust_inspection: trust_inspection,
368 snapshot_project_revision,
369 snapshot_generation,
370 snapshot_skills_count,
371 snapshot_tools_count,
372 refresh_latency_ms: 0,
373 conversation_cursor: 0,
374 editor_buffer_index: 0,
375 focused_editor_path: String::new(),
376 focused_editor_dirty: false,
377 focused_editor_line: 0,
378 status: if trust_prompt {
379 "Trust required · I inspect · O untrusted · 1 once · T project".into()
380 } else {
381 "Ready · a launch · : routes · ? help".into()
382 },
383 agents: String::new(),
384 agent_readiness: crate::pi_runtime::pi_readiness()
385 .map(|readiness| format_pi_readiness(&readiness))
386 .unwrap_or_else(|error| format!("Agent unavailable · {error}")),
387 agent_login_requested: false,
388 agent_conversation: "No conversation yet. Press i to compose a message.".into(),
389 tasks: String::new(),
390 editor: String::new(),
391 files: Vec::new(),
392 selected_file: 0,
393 code_edit_mode: false,
394 lsp: String::new(),
395 processes: String::new(),
396 git: String::new(),
397 git_diff: String::new(),
398 git_diff_open: false,
399 git_diff_requested: false,
400 tests: String::new(),
401 kernels: String::new(),
402 debugger: String::new(),
403 replay: String::new(),
404 browser: String::new(),
405 browser_detail: "No browser observation yet".into(),
406 browser_workspace: BrowserWorkspaceController::for_adapter(
407 match layout {
408 TuiLayout::Mobile => BrowserWorkspaceLayout::Phone,
409 TuiLayout::Compact => BrowserWorkspaceLayout::Compact,
410 TuiLayout::Auto | TuiLayout::Desktop => BrowserWorkspaceLayout::Desktop,
411 },
412 BrowserWorkspaceAdapterKind::EmbeddedDevelopment,
413 ),
414 browser_recovery: None,
415 browser_target_picker: false,
416 browser_target_picker_requested: false,
417 browser_target_query: String::new(),
418 browser_target_selection: 0,
419 browser_visual_live: false,
420 browser_observe_pending: false,
421 browser_ansi: AnsiCanvas::default(),
422 browser_pane: None,
423 workflow: "No workflow evidence yet".into(),
424 workspace_status: String::new(),
425 experiment_comparison: None,
426 experiments: "No experiments. :experiment create ID BRANCH [PORT]".into(),
427 };
428 if initial_refresh {
429 state.refresh();
430 }
431 Ok(state)
432 }
433
434 pub fn responsive_class(&self, width: u16, height: u16) -> ResponsiveClass {
435 match self.layout {
436 TuiLayout::Desktop => ResponsiveClass::Desktop,
437 TuiLayout::Compact => ResponsiveClass::Compact,
438 TuiLayout::Mobile => ResponsiveClass::Phone,
439 TuiLayout::Auto if width < 72 || height < 22 => ResponsiveClass::Phone,
440 TuiLayout::Auto if width < 118 || height < 32 => ResponsiveClass::Compact,
441 TuiLayout::Auto => ResponsiveClass::Desktop,
442 }
443 }
444
445 pub fn request_quit(&mut self) {
446 if self.quit {
447 return;
448 }
449 self.quit_confirmation = true;
450 self.status = "Quit confirmation · Enter exits · Esc stays".into();
451 }
452
453 pub fn confirm_quit(&mut self) {
454 self.quit_confirmation = false;
455 self.quit = true;
456 self.status = "Closing Glass Dev".into();
457 }
458
459 pub fn cancel_quit(&mut self) {
460 self.quit_confirmation = false;
461 self.status = "Quit dismissed · workspace remains open".into();
462 }
463
464 pub fn quit_menu_index(&self) -> usize {
465 self.surface_actions().len() + 1
466 }
467
468 pub fn surface_actions(&self) -> &'static [command::SurfaceAction] {
470 command::surface_actions(self.surface)
471 }
472
473 pub fn toggle_help(&mut self) {
474 self.help_open = !self.help_open;
475 self.help_scroll = 0;
476 self.status = if self.help_open {
477 "Help · j/k scroll · ? or Esc closes".into()
478 } else {
479 "Help closed".into()
480 };
481 }
482
483 pub fn scroll_help(&mut self, delta: i32) {
484 self.help_scroll = (self.help_scroll as i32 + delta).max(0) as u16;
485 }
486
487 pub fn open_menu(&mut self) {
488 self.menu_open = true;
489 self.menu_selection = 0;
490 self.status = format!(
491 "Command center · {} launchers first · : searches all routes · Enter runs",
492 self.surface.label()
493 );
494 }
495
496 pub fn close_menu(&mut self) {
497 self.menu_open = false;
498 }
499
500 pub fn run_menu_action(&mut self) {
504 let search_index = self.surface_actions().len();
505 let quit_index = self.quit_menu_index();
506 if self.menu_selection == search_index {
507 self.menu_open = false;
508 self.open_palette();
509 return;
510 }
511 if self.menu_selection == quit_index {
512 self.menu_open = false;
513 self.request_quit();
514 return;
515 }
516 let Some(action) = self.surface_actions().get(self.menu_selection).copied() else {
517 return;
518 };
519 self.menu_open = false;
520 let name = action.label;
521 let hint = action.command;
522 let prefix = action.key;
523 if prefix == ":" {
524 let prefill = hint
528 .split_whitespace()
529 .take_while(|token| {
530 !token
531 .chars()
532 .all(|character| character.is_ascii_uppercase() || character == '_')
533 })
534 .collect::<Vec<_>>()
535 .join(" ");
536 if prefill.is_empty() || prefill == hint {
537 self.open_palette_with(hint);
538 } else {
539 self.open_palette_with(&format!("{prefill} "));
540 }
541 } else if hint == "i" {
542 if self.surface == DevSurface::Agent {
543 self.open_composer();
544 } else {
545 self.enter_code_edit();
546 }
547 } else if hint == "Enter" {
548 if self.surface == DevSurface::Code {
549 self.open_selected_file();
550 }
551 } else if hint == "d" && self.surface == DevSurface::Git {
552 self.git_diff_requested = true;
553 self.status = "Git diff queued · loading off-thread".into();
554 }
555 else {
559 match hint {
560 "n" => {
561 self.surface = DevSurface::App;
562 self.open_palette_with("browser navigate ");
563 }
564 "t" => {
565 self.surface = DevSurface::App;
566 self.open_palette_with("browser type ");
567 }
568 "v" => {
569 self.surface = DevSurface::App;
570 self.browser_visual_live = true;
571 self.status = "Live view starting · v stops".into();
572 }
573 "agent update" if self.surface == DevSurface::Agent => {
574 self.request_agent_update();
575 }
576 "s" if matches!(self.surface, DevSurface::Terminal | DevSurface::More) => {
577 self.request_detected_dev();
578 }
579 "1" | "T" | "I" | "O" => self.handle_printable(hint.chars().next().unwrap()),
580 "Ctrl-S" if self.surface == DevSurface::Code => self.edit_code_key(
581 crossterm::event::KeyCode::Char('s'),
582 crossterm::event::KeyModifiers::CONTROL,
583 ),
584 _ => self.status = format!("{name} is available from this surface"),
585 }
586 }
587 }
588
589 pub fn move_menu_selection(&mut self, delta: i32) {
590 let count = self.surface_actions().len() as i32 + 2;
591 self.menu_selection =
592 (self.menu_selection as i32 + delta).rem_euclid(count.max(1)) as usize;
593 }
594
595 pub fn open_palette(&mut self) {
596 self.command_mode = true;
597 self.command_input.clear();
598 self.command_cursor = 0;
599 self.command_history_index = None;
600 self.palette_error = None;
601 let group = command::command_group_for(self.surface);
602 self.status = format!(
603 "Command search · {} routes first · Tab completes · Esc closes",
604 group.label
605 );
606 }
607
608 pub fn close_palette(&mut self) {
609 self.command_mode = false;
610 self.command_input.clear();
611 self.command_cursor = 0;
612 self.command_history_index = None;
613 self.palette_error = None;
614 self.status = "Command search cancelled · press a for guided launchers".into();
615 }
616
617 pub fn submit_palette(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
618 let input = std::mem::take(&mut self.command_input);
619 self.command_cursor = 0;
620 self.command_history_index = None;
621 self.command_mode = false;
622 if !input.trim().is_empty() && self.command_history.last() != Some(&input) {
623 self.command_history.push(input.clone());
624 if self.command_history.len() > 32 {
625 self.command_history.remove(0);
626 }
627 }
628 match command::execute(self, &input) {
629 Ok(message) => {
630 self.palette_error = None;
631 self.status = message;
632 }
633 Err(error) => {
634 self.palette_error = Some(error.clone());
635 self.status = format!("Error: {error}");
636 }
637 }
638 if let Some((call, context)) = self.queued_tool_request.take() {
639 match worker.submit_tool(call, context) {
640 Ok(id) => {
641 self.running_tool_job = Some(id);
642 self.status.push_str(" · running in background");
643 }
644 Err(error) => self.status = format!("Could not queue tool: {error}"),
645 }
646 }
647 worker.request_refresh();
648 }
649
650 pub fn insert_palette_char(&mut self, character: char) {
651 self.command_input.insert(self.command_cursor, character);
652 self.command_cursor += character.len_utf8();
653 self.palette_error = None;
654 self.command_history_index = None;
655 }
656
657 pub fn insert_palette_text(&mut self, text: &str) {
658 for character in text.replace(['\r', '\n'], " ").chars().take(8_192) {
659 self.insert_palette_char(character);
660 }
661 }
662
663 pub fn palette_backspace(&mut self) {
664 if self.command_cursor == 0 {
665 return;
666 }
667 let previous = self.command_input[..self.command_cursor]
668 .char_indices()
669 .next_back()
670 .map(|(index, _)| index)
671 .unwrap_or(0);
672 self.command_input.drain(previous..self.command_cursor);
673 self.command_cursor = previous;
674 self.command_history_index = None;
675 }
676
677 pub fn navigate_palette_history(&mut self, older: bool) {
678 if self.command_history.is_empty() {
679 return;
680 }
681 let last = self.command_history.len() - 1;
682 let index = match (self.command_history_index, older) {
683 (None, true) => last,
684 (None, false) => return,
685 (Some(index), true) => index.saturating_sub(1),
686 (Some(index), false) if index < last => index + 1,
687 (Some(_), false) => {
688 self.command_history_index = None;
689 self.command_input.clear();
690 self.command_cursor = 0;
691 return;
692 }
693 };
694 self.command_history_index = Some(index);
695 self.command_input.clone_from(&self.command_history[index]);
696 self.command_cursor = self.command_input.len();
697 }
698
699 pub fn complete_palette(&mut self) {
700 let Some(completion) = self.palette_matches().first().copied() else {
701 return;
702 };
703 let suffix = self
704 .command_input
705 .find(char::is_whitespace)
706 .map(|index| self.command_input[index..].to_string())
707 .unwrap_or_default();
708 self.command_input = format!("{completion}{suffix}");
709 self.command_cursor = self.command_input.len();
710 self.command_history_index = None;
711 self.status = format!("Completed `{completion}` · Enter runs · ↑/↓ history");
712 }
713
714 pub fn open_palette_with(&mut self, prefix: &str) {
715 self.open_palette();
716 self.command_input = prefix.into();
717 self.command_cursor = self.command_input.len();
718 }
719
720 pub fn move_palette_cursor(&mut self, right: bool) {
721 if right {
722 self.command_cursor = self.command_input[self.command_cursor..]
723 .char_indices()
724 .nth(1)
725 .map(|(offset, _)| self.command_cursor + offset)
726 .unwrap_or(self.command_input.len());
727 } else if self.command_cursor > 0 {
728 self.command_cursor = self.command_input[..self.command_cursor]
729 .char_indices()
730 .next_back()
731 .map(|(index, _)| index)
732 .unwrap_or(0);
733 }
734 }
735
736 pub fn palette_matches(&self) -> Vec<&'static str> {
737 let query = self
738 .command_input
739 .split_whitespace()
740 .next()
741 .unwrap_or_default();
742 command::palette_order(self.surface)
743 .into_iter()
744 .filter(|candidate| fuzzy_contains(candidate, query))
745 .take(6)
746 .collect()
747 }
748
749 pub fn background_action_running(&self) -> bool {
750 self.pending_confirmation.is_some()
751 || self.pending_agent_approval.is_some()
752 || self.running_tool_job.is_some()
753 || self.queued_tool_request.is_some()
754 || self.agent_send_job.is_some()
755 }
756
757 pub fn agent_browser_context(&self) -> serde_json::Value {
758 let semantic_summary = self.browser_workspace_summary();
759 let state = self.browser_workspace.state();
760 let selected_entity = state.selected().map(|entity| {
761 serde_json::json!({
762 "reference": entity.reference,
763 "role": entity.role,
764 "name": entity.name,
765 "actionable": entity.actionable,
766 "revision": entity.revision,
767 })
768 });
769 let selected_target = state
770 .targets
771 .iter()
772 .find(|target| target.selected)
773 .map(|target| {
774 serde_json::json!({
775 "id": target.id,
776 "title": target.title,
777 "url": safe_browser_url(&target.url),
778 })
779 });
780 serde_json::json!({
781 "schemaVersion": "glass.agent-context.v1",
782 "browser": {
783 "attached": state.connection == glass_browser::browser_workspace::BrowserConnectionPhase::Connected,
784 "connection": serde_json::to_value(state.connection).unwrap_or(serde_json::Value::Null),
785 "targetId": selected_target.as_ref().and_then(|target| target.get("id")).cloned(),
786 "origin": page_origin(&state.url),
787 "url": safe_browser_url(&state.url),
788 "title": state.title,
789 "browserRevision": state.browser_revision,
790 "semanticSummary": semantic_summary,
791 "selectedEntity": selected_entity,
792 "workflowState": state.workflow,
793 "inputOwner": serde_json::to_value(state.input_owner).unwrap_or(serde_json::Value::Null),
794 "freshness": if state.semantic_invalidated { "stale" } else { "current" },
795 "target": selected_target,
796 "bootstrap": if state.connection == glass_browser::browser_workspace::BrowserConnectionPhase::Connected {
797 "attached; observe before acting"
798 } else {
799 "detached; call glass.browser.start, then navigate and observe the requested URL"
800 },
801 },
802 "authority": {
803 "source": "Glass browser workspace",
804 "mutationLeaseRequired": selected_entity.as_ref().is_some_and(|entity| {
805 entity.get("actionable").and_then(serde_json::Value::as_bool).unwrap_or(false)
806 }),
807 },
808 "project": {
809 "root": self.snapshot_root,
810 },
811 })
812 }
813
814 pub fn browser_chat_header(&self) -> String {
815 let browser = self.browser_workspace.state();
816 let page = if browser.url.is_empty() {
817 "no page".to_string()
818 } else {
819 safe_browser_url(&browser.url).unwrap_or_else(|| "no page".into())
820 };
821 let title = browser.title.trim();
822 let include_title = !title.is_empty() && !title.eq_ignore_ascii_case(&page);
823 let revision = browser
824 .browser_revision
825 .map_or_else(|| "—".to_string(), |revision| revision.to_string());
826 let bootstrap = if browser.connection
827 == glass_browser::browser_workspace::BrowserConnectionPhase::Connected
828 {
829 "observe before acting"
830 } else {
831 "ask `open <url>` to attach"
832 };
833 let mut header = format!("APP · {}", browser.connection_label());
834 if include_title {
835 header.push_str(" · ");
836 header.push_str(title);
837 }
838 header.push_str(&format!(" · {} · rev {} · {}", page, revision, bootstrap));
839 if let Some(entity) = browser.selected() {
840 header.push_str(" · selected ");
841 header.push_str(&entity.name);
842 }
843 header
844 }
845
846 pub fn conversation_view(&self) -> String {
847 let mut conversation = if self.agent_conversation.starts_with("No conversation yet.")
848 && !self.pending_chat_messages.is_empty()
849 {
850 String::new()
851 } else {
852 self.agent_conversation.clone()
853 };
854 for message in &self.pending_chat_messages {
855 if !conversation.is_empty() {
856 conversation.push_str("\n\n");
857 }
858 conversation.push_str("YOU\n");
859 conversation.push_str(&message.text);
860 conversation.push('\n');
861 match message.state {
862 ChatMessageState::Sending => conversation.push_str("· sending…"),
863 ChatMessageState::Sent => {
864 conversation.push_str("· sent · Glass Agent is thinking…")
865 }
866 ChatMessageState::Failed => {
867 conversation.push_str("× send failed");
868 if let Some(error) = message.error.as_deref() {
869 conversation.push_str(": ");
870 conversation.push_str(error);
871 }
872 conversation.push_str(" · press Enter to retry");
873 }
874 }
875 }
876 conversation
877 }
878
879 fn reconcile_pending_chat(&mut self) {
880 let conversation = self.agent_conversation.clone();
881 let mut confirmed = std::collections::BTreeMap::<String, usize>::new();
882 self.pending_chat_messages.retain(|message| {
883 if message.state == ChatMessageState::Failed {
884 return true;
885 }
886 let marker = format!("YOU\n{}", message.text);
887 let observed = conversation.matches(&marker).count();
888 let seen = confirmed.entry(message.text.clone()).or_default();
889 if *seen < observed {
890 *seen += 1;
891 false
892 } else {
893 true
894 }
895 });
896 }
897
898 pub fn open_composer(&mut self) {
899 self.composer_mode = true;
900 self.composer_cursor = self.composer_input.len();
901 self.status = "Agent composer · Enter sends · draft stays open · Esc cancels".into();
902 }
903
904 pub fn toggle_composer_steer(&mut self) {
905 self.composer_steer = !self.composer_steer;
906 self.status = if self.composer_steer {
907 "Steer mode · Enter interrupts the running agent".into()
908 } else {
909 "Follow-up mode · Enter sends during or after the current turn".into()
910 };
911 }
912
913 pub fn request_agent_setup(&mut self) {
916 self.request_agent_setup_mode(false);
917 }
918
919 pub fn request_agent_update(&mut self) {
921 self.request_agent_setup_mode(true);
922 }
923
924 fn request_agent_setup_mode(&mut self, update: bool) {
925 if self.background_action_running() {
926 self.status = "Another background action is still running".into();
927 return;
928 }
929 let (call, context) = match self.tool_request(
930 "glass.agent.setup",
931 serde_json::json!({"login": false, "update": update}),
932 true,
933 ) {
934 Ok(request) => request,
935 Err(error) => {
936 self.status = if update {
937 format!("Pi update unavailable: {error}")
938 } else {
939 format!("Pi setup unavailable: {error}")
940 };
941 return;
942 }
943 };
944 self.pending_confirmation = Some(PendingConfirmation {
945 call,
946 context,
947 summary: if update {
948 "Refresh the pinned managed Pi SDK".into()
949 } else {
950 "Install or repair the pinned managed Pi SDK".into()
951 },
952 });
953 self.surface = DevSurface::Agent;
954 self.status = if update {
955 "Pi update ready · Enter approves once · Esc cancels".into()
956 } else {
957 "Pi setup ready · Enter approves once · Esc cancels".into()
958 };
959 }
960
961 pub fn request_agent_login(&mut self) -> Result<(), String> {
964 if self.background_action_running() {
965 let error = "Finish the current background action before signing in".to_string();
966 self.status = error.clone();
967 return Err(error);
968 }
969 self.agent_login_requested = true;
970 self.surface = DevSurface::Agent;
971 self.status = "Pi login will open in this terminal · exit Pi to return".into();
972 Ok(())
973 }
974
975 pub fn close_composer(&mut self) {
976 self.composer_mode = false;
977 self.composer_steer = false;
978 self.status = "Composer closed".into();
979 }
980
981 pub fn move_composer_cursor(&mut self, right: bool) {
982 if right {
983 self.composer_cursor = self.composer_input[self.composer_cursor..]
984 .char_indices()
985 .nth(1)
986 .map(|(offset, _)| self.composer_cursor + offset)
987 .unwrap_or(self.composer_input.len());
988 } else if self.composer_cursor > 0 {
989 self.composer_cursor = self.composer_input[..self.composer_cursor]
990 .char_indices()
991 .next_back()
992 .map(|(index, _)| index)
993 .unwrap_or(0);
994 }
995 }
996
997 pub fn delete_composer_word(&mut self) {
998 let before = self.composer_input[..self.composer_cursor].trim_end();
999 let start = before.len();
1000 let target = before[..start]
1001 .trim_end_matches(|c: char| c.is_whitespace())
1002 .char_indices()
1003 .rev()
1004 .find_map(|(index, character)| character.is_whitespace().then_some(index))
1005 .map(|index| before[..index].trim_end().len())
1006 .unwrap_or(0);
1007 self.composer_input.drain(target..self.composer_cursor);
1008 self.composer_cursor = target;
1009 }
1010
1011 pub fn abort_selected_agent(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
1012 let Some(agent) = self.selected_agent.clone() else {
1013 self.status = "No active agent to abort".into();
1014 return;
1015 };
1016 let (call, context) = match self.tool_request(
1017 "glass.agent.abort",
1018 serde_json::json!({"agentId": agent.as_str()}),
1019 true,
1020 ) {
1021 Ok(request) => request,
1022 Err(error) => {
1023 self.status = format!("Abort unavailable: {error}");
1024 return;
1025 }
1026 };
1027 match worker.submit_tool(call, context) {
1028 Ok(id) => {
1029 self.running_tool_job = Some(id);
1030 self.status = format!("Stopping {} in background…", agent.as_str());
1031 }
1032 Err(error) => self.status = format!("Abort unavailable: {error}"),
1033 }
1034 }
1035
1036 pub fn insert_composer_text(&mut self, text: &str) {
1037 for character in text.chars().take(16_384) {
1038 self.composer_input.insert(self.composer_cursor, character);
1039 self.composer_cursor += character.len_utf8();
1040 }
1041 }
1042
1043 pub fn composer_backspace(&mut self) {
1044 if self.composer_cursor == 0 {
1045 return;
1046 }
1047 let previous = self.composer_input[..self.composer_cursor]
1048 .char_indices()
1049 .next_back()
1050 .map(|(index, _)| index)
1051 .unwrap_or(0);
1052 self.composer_input.drain(previous..self.composer_cursor);
1053 self.composer_cursor = previous;
1054 }
1055
1056 pub fn submit_composer(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
1057 if self.background_action_running() {
1058 self.status = if self.agent_send_job.is_some() {
1059 "Sending the previous message · keep typing, then press Enter again".into()
1060 } else {
1061 "Background operation running · message kept in composer".into()
1062 };
1063 return;
1064 }
1065 if self.snapshot_trust_label == "untrusted" {
1066 self.composer_mode = false;
1067 self.surface = DevSurface::Trust;
1068 self.status = "Trust this workspace before starting the Glass Agent · T or 1".into();
1069 return;
1070 }
1071 if !self.agent_readiness.starts_with("✓ Ready") {
1072 self.status = "Pi is not ready · press Esc, then s to install or l to sign in".into();
1073 return;
1074 }
1075 if self.composer_input.trim().is_empty() {
1076 self.status = "Message is empty · type a prompt, then press Enter".into();
1077 return;
1078 }
1079 let display_text = self.composer_input.clone();
1080 let text = std::mem::take(&mut self.composer_input);
1081 let steer = self.composer_steer;
1082 self.composer_cursor = 0;
1083 self.composer_steer = false;
1084 self.composer_mode = true;
1085 let context = self.agent_browser_context();
1086 if context["browser"]["selectedEntity"].is_object() {
1087 self.browser_workspace.state_mut().input_owner =
1088 glass_browser::browser_workspace::BrowserInputOwner::Agent;
1089 }
1090 let mut arguments = serde_json::json!({
1091 "text": text,
1092 "mode": if steer { "steer" } else { "follow-up" },
1093 "context": context,
1094 });
1095 if let Some(agent) = self.selected_agent.as_ref() {
1096 arguments["agentId"] = serde_json::Value::String(agent.as_str().to_string());
1097 }
1098 let (call, context) = match self.tool_request("glass.agent.send", arguments, true) {
1099 Ok(request) => request,
1100 Err(error) => {
1101 self.composer_input = display_text;
1102 self.composer_cursor = self.composer_input.len();
1103 self.status = format!("Message unavailable · edit and retry: {error}");
1104 return;
1105 }
1106 };
1107 match worker.submit_tool(call, context) {
1108 Ok(id) => {
1109 self.agent_send_job = Some(id);
1110 self.pending_chat_messages.push(PendingChatMessage {
1111 text: display_text,
1112 state: ChatMessageState::Sending,
1113 job_id: Some(id),
1114 error: None,
1115 });
1116 self.status = if steer {
1117 "Sent · steering Glass Agent…".into()
1118 } else {
1119 "Sent · Glass Agent is thinking…".into()
1120 };
1121 worker.request_conversation();
1122 }
1123 Err(error) => {
1124 self.composer_input = display_text;
1125 self.composer_cursor = self.composer_input.len();
1126 self.status = format!("Message unavailable · edit and retry: {error}");
1127 }
1128 }
1129 }
1130
1131 pub fn approve_confirmation_async(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
1132 let Some(pending) = self.pending_confirmation.take() else {
1133 return;
1134 };
1135 match worker.submit_tool(pending.call, pending.context) {
1136 Ok(id) => {
1137 self.running_tool_job = Some(id);
1138 self.status = format!(
1139 "Running {} · Esc keeps the workspace responsive",
1140 pending.summary
1141 );
1142 }
1143 Err(error) => self.status = format!("Could not queue mutation: {error}"),
1144 }
1145 }
1146
1147 pub fn resolve_agent_approval(
1148 &mut self,
1149 approved: bool,
1150 worker: &mut super::snapshot::SnapshotWorker,
1151 ) {
1152 let Some(pending) = self.pending_agent_approval.take() else {
1153 return;
1154 };
1155 let arguments = serde_json::json!({
1156 "agentId": pending.agent_id,
1157 "frameId": pending.frame_id,
1158 "approved": approved,
1159 });
1160 let (call, context) = match self.tool_request("glass.agent.approve", arguments, true) {
1161 Ok(request) => request,
1162 Err(error) => {
1163 self.pending_agent_approval = Some(pending);
1164 self.status = format!("Agent approval unavailable: {error}");
1165 return;
1166 }
1167 };
1168 match worker.submit_tool(call, context) {
1169 Ok(id) => {
1170 self.running_tool_job = Some(id);
1171 self.status = if approved {
1172 format!("Approved {} · Glass Agent continues…", pending.tool_name)
1173 } else {
1174 format!("Denied {} · Glass Agent continues…", pending.tool_name)
1175 };
1176 }
1177 Err(error) => {
1178 self.pending_agent_approval = Some(pending);
1179 self.status = format!("Could not queue agent approval: {error}");
1180 }
1181 }
1182 }
1183
1184 pub fn apply_visual_job_result(&mut self, result: super::snapshot::VisualJobResult) {
1185 self.apply_visual_job_result_with_fit(
1186 result,
1187 glass_browser::terminal_graphics::FrameFit::Contain,
1188 );
1189 }
1190
1191 pub fn apply_visual_job_result_with_fit(
1192 &mut self,
1193 result: super::snapshot::VisualJobResult,
1194 fit: glass_browser::terminal_graphics::FrameFit,
1195 ) {
1196 let png = match result.result {
1197 Ok(value) => {
1198 let Some(encoded) = value.get("base64").and_then(serde_json::Value::as_str) else {
1199 self.browser_visual_live = false;
1200 self.browser_workspace.state_mut().presentation_reason =
1201 Some("screenshot payload did not contain base64 PNG data".into());
1202 self.status = "Live view unavailable · screenshot payload was empty".into();
1203 return;
1204 };
1205 use base64::Engine as _;
1206 match base64::engine::general_purpose::STANDARD.decode(encoded) {
1207 Ok(png) => png,
1208 Err(error) => {
1209 self.browser_visual_live = false;
1210 self.browser_workspace.state_mut().presentation_reason =
1211 Some(format!("screenshot payload was not valid base64: {error}"));
1212 self.status = "Live view unavailable · invalid screenshot payload".into();
1213 return;
1214 }
1215 }
1216 }
1217 Err(error) => {
1218 self.browser_visual_live = false;
1219 self.browser_workspace.state_mut().presentation_reason =
1220 Some(format!("browser screenshot failed: {error}"));
1221 self.status = format!("Live view unavailable · {error}");
1222 return;
1223 }
1224 };
1225 match AnsiPane::from_png(
1226 &mut self.browser_ansi,
1227 &png,
1228 result.columns.clamp(8, 80),
1229 result.rows.clamp(4, 40),
1230 fit,
1231 ) {
1232 Ok(pane) => {
1233 self.browser_pane = Some(pane);
1234 let browser = self.browser_workspace.state_mut();
1235 browser.presentation =
1236 glass_browser::browser_workspace::BrowserPresentationPath::Ansi;
1237 browser.frame_revision = browser.browser_revision;
1238 browser.presentation_reason = Some(
1239 "bounded ANSI half-block frame · semantic controls remain authoritative".into(),
1240 );
1241 self.status = "Live view updated · ANSI half-block".into();
1242 }
1243 Err(error) => {
1244 self.browser_visual_live = false;
1245 self.browser_workspace.state_mut().presentation_reason = Some(error.to_string());
1246 self.status = format!("Live view unavailable: {error}");
1247 }
1248 }
1249 }
1250
1251 pub fn queue_tool_request(
1252 &mut self,
1253 call: crate::development::ToolCall,
1254 context: crate::tools::DevelopmentToolContext,
1255 ) -> Result<(), String> {
1256 if self.background_action_running() {
1257 return Err("another background tool is already running".into());
1258 }
1259 self.queued_tool_request = Some((call, context));
1260 Ok(())
1261 }
1262
1263 pub fn apply_tool_job_result(&mut self, result: super::snapshot::ToolJobResult) {
1264 if result.tool == "glass.agent.send" && self.agent_send_job == Some(result.id) {
1265 self.agent_send_job = None;
1266 match result.result {
1267 Ok(value) => {
1268 let agent = value
1269 .get("agentId")
1270 .and_then(serde_json::Value::as_str)
1271 .and_then(|value| crate::AgentId::parse(value).ok());
1272 let restarted = value
1273 .get("restarted")
1274 .and_then(serde_json::Value::as_bool)
1275 .unwrap_or(false);
1276 if let Some(agent_id) = agent {
1277 self.selected_agent = Some(agent_id.clone());
1278 self.status = if restarted {
1279 format!("Restarted {} · Glass Agent is thinking…", agent_id.as_str())
1280 } else {
1281 format!("Sent to {} · Glass Agent is thinking…", agent_id.as_str())
1282 };
1283 } else {
1284 self.status = if restarted {
1285 "Restarted Glass Agent · thinking…".into()
1286 } else {
1287 "Sent · Glass Agent is thinking…".into()
1288 };
1289 }
1290 if let Some(message) = self
1291 .pending_chat_messages
1292 .iter_mut()
1293 .find(|message| message.job_id == Some(result.id))
1294 {
1295 message.state = ChatMessageState::Sent;
1296 message.job_id = None;
1297 }
1298 }
1299 Err(error) => {
1300 let failed_text = self
1301 .pending_chat_messages
1302 .iter_mut()
1303 .find(|message| message.job_id == Some(result.id))
1304 .map(|message| {
1305 message.state = ChatMessageState::Failed;
1306 message.job_id = None;
1307 message.error = Some(error.clone());
1308 message.text.clone()
1309 });
1310 if self.composer_input.is_empty()
1311 && let Some(text) = failed_text
1312 {
1313 self.composer_input = text;
1314 self.composer_cursor = self.composer_input.len();
1315 }
1316 self.composer_mode = true;
1317 self.status = format!("Could not send message · edit and retry: {error}");
1318 }
1319 }
1320 return;
1321 }
1322
1323 if self.running_tool_job != Some(result.id) {
1324 return;
1325 }
1326 self.running_tool_job = None;
1327 match result.result {
1328 Ok(value) => {
1329 if result.tool.starts_with("glass.browser") {
1330 self.apply_browser_result(&result.tool, &value);
1331 self.browser_detail = super::projection::browser_result(&result.tool, &value);
1332 if result.tool == "glass.browser.act" || result.tool == "glass.browser.navigate"
1333 {
1334 self.browser_observe_pending = true;
1335 }
1336 } else if result.tool == "glass.git.diff" {
1337 self.git_diff = value
1338 .as_str()
1339 .filter(|diff| !diff.trim().is_empty())
1340 .unwrap_or("Working tree clean · no diff to show")
1341 .to_string();
1342 self.git_diff_open = true;
1343 self.status = "Git diff · PgUp/PgDn scroll · Esc closes".into();
1344 } else if result.tool == "glass.agent.setup" {
1345 match self.refresh_agent_readiness() {
1346 Ok(true) => {
1347 self.status =
1348 "Pi runtime ready · press l to sign in if no provider is selected"
1349 .into();
1350 }
1351 Ok(false) => {
1352 self.status =
1353 "Pi runtime installed · press l to sign in, then i to chat".into();
1354 }
1355 Err(error) => self.status = format!("Pi readiness check failed: {error}"),
1356 }
1357 } else if result.tool == "glass.agent.send" {
1358 if let Some(agent_id) = value
1359 .get("agentId")
1360 .and_then(serde_json::Value::as_str)
1361 .and_then(|value| crate::AgentId::parse(value).ok())
1362 {
1363 self.selected_agent = Some(agent_id.clone());
1364 self.status =
1365 format!("Sent to {} · Glass Agent is thinking…", agent_id.as_str());
1366 } else {
1367 self.status = "Sent · Glass Agent is thinking…".into();
1368 }
1369 } else if result.tool.starts_with("glass.lsp") {
1370 self.editor = if result.tool == "glass.lsp.diagnostics" {
1371 super::projection::lsp(Some(&value))
1372 } else {
1373 super::projection::first_meaningful(&value)
1374 };
1375 }
1376 if !matches!(
1377 result.tool.as_str(),
1378 "glass.agent.send" | "glass.agent.setup" | "glass.git.diff"
1379 ) {
1380 self.status = format!("Completed {} · workspace refreshed", result.tool);
1381 }
1382 }
1383 Err(error) => {
1384 if result.tool.starts_with("glass.browser") {
1385 self.note_browser_failure(&result.tool, &error);
1386 }
1387 if result.tool == "glass.git.diff" {
1388 self.git_diff = format!("Git diff unavailable: {error}");
1389 self.git_diff_open = true;
1390 }
1391 self.status = format!("{} failed: {error}", result.tool);
1392 }
1393 }
1394 }
1395
1396 pub fn deny_confirmation(&mut self) {
1397 if let Some(pending) = self.pending_confirmation.take() {
1398 self.status = format!("Denied · {}", pending.summary);
1399 }
1400 }
1401
1402 pub fn handle_printable(&mut self, character: char) {
1403 if self.surface == DevSurface::Trust {
1404 let decision = match character {
1405 'i' | 'I' => {
1406 self.status = "Inspecting exact repository configuration".into();
1407 return;
1408 }
1409 'o' | 'O' => Some(crate::LocalTrustDecision::OpenUntrusted),
1410 '1' => Some(crate::LocalTrustDecision::TrustOnce),
1411 'T' => Some(crate::LocalTrustDecision::TrustProject),
1412 _ => None,
1413 };
1414 if let Some(decision) = decision {
1415 match self
1416 .workspace
1417 .try_lock()
1418 .and_then(|mut workspace| workspace.apply_local_trust_decision(decision))
1419 {
1420 Ok(trust) => {
1421 self.surface = DevSurface::Agent;
1422 self.snapshot_trust_label = trust.label().into();
1423 self.status = format!("Workspace opened with {} authority", trust.label());
1424 }
1425 Err(error) => self.status = format!("Trust decision failed: {error}"),
1426 }
1427 return;
1428 }
1429 }
1430 if self.surface == DevSurface::Agent && self.snapshot_trust_label == "untrusted" {
1431 let decision = match character {
1432 't' => Some(crate::LocalTrustDecision::TrustOnce),
1433 'T' => Some(crate::LocalTrustDecision::TrustProject),
1434 _ => None,
1435 };
1436 if let Some(decision) = decision {
1437 match self
1438 .workspace
1439 .try_lock()
1440 .and_then(|mut workspace| workspace.apply_local_trust_decision(decision))
1441 {
1442 Ok(trust) => {
1443 self.snapshot_trust_label = trust.label().into();
1444 self.status = format!("Workspace opened with {} authority", trust.label());
1445 }
1446 Err(error) => self.status = format!("Trust decision failed: {error}"),
1447 }
1448 return;
1449 }
1450 }
1451
1452 if self.responsive_class(self.terminal_width, self.terminal_height)
1453 == ResponsiveClass::Phone
1454 {
1455 let surface = match character {
1456 '1' => Some(DevSurface::Agent),
1457 '2' => Some(DevSurface::Code),
1458 '3' => Some(DevSurface::App),
1459 '4' => Some(DevSurface::Tasks),
1460 '5' => Some(DevSurface::More),
1461 _ => None,
1462 };
1463 if let Some(surface) = surface {
1464 self.surface = surface;
1465 self.status = format!("{} · a launcher · : routes", surface.label());
1466 return;
1467 }
1468 }
1469 let surface = match character {
1470 '1' => Some(DevSurface::Agent),
1471 '2' | 'c' => Some(DevSurface::Code),
1472 '3' | 'v' => Some(DevSurface::App),
1473 '4' => Some(DevSurface::Terminal),
1474 '5' | 'w' => Some(DevSurface::Tasks),
1475 '6' | 'g' => Some(DevSurface::Git),
1476 '7' | 'd' => Some(DevSurface::Debug),
1477 '8' | 'm' => Some(DevSurface::More),
1478 _ => None,
1479 };
1480 if let Some(surface) = surface {
1481 self.surface = surface;
1482 self.status = format!("{} · a launcher · : routes", surface.label());
1483 }
1484 }
1485 pub fn request_detected_dev(&mut self) {
1488 if self.background_action_running() {
1489 self.status = "Another background action is still running".into();
1490 return;
1491 }
1492 let command_result = {
1493 match self.ws() {
1494 Ok(workspace) => workspace
1495 .project()
1496 .detection()
1497 .dev_command
1498 .clone()
1499 .ok_or_else(|| "no detected dev command".to_string()),
1500 Err(error) => Err(error),
1501 }
1502 };
1503 let command = match command_result {
1504 Ok(command) => command,
1505 Err(error) if error == "no detected dev command" => {
1506 self.status =
1507 "No development command detected · use :process start NAME COMMAND".into();
1508 return;
1509 }
1510 Err(error) => {
1511 self.status = format!("Development command unavailable: {error}");
1512 return;
1513 }
1514 };
1515 let (call, context) = match self.tool_request(
1516 "glass.process.start",
1517 serde_json::json!({"name": "dev", "command": command}),
1518 true,
1519 ) {
1520 Ok(request) => request,
1521 Err(error) => {
1522 self.status = format!("Development suite unavailable: {error}");
1523 return;
1524 }
1525 };
1526 self.pending_confirmation = Some(PendingConfirmation {
1527 call,
1528 context,
1529 summary: "Start the detected development suite".into(),
1530 });
1531 self.surface = DevSurface::Terminal;
1532 self.status = "Development suite ready · Enter approves once · Esc cancels".into();
1533 }
1534
1535 pub fn next_surface(&mut self) {
1536 let surfaces: &[DevSurface] = if self
1537 .responsive_class(self.terminal_width, self.terminal_height)
1538 == ResponsiveClass::Phone
1539 {
1540 &DevSurface::PHONE
1541 } else {
1542 &DevSurface::PRIMARY
1543 };
1544 let index = surfaces
1545 .iter()
1546 .position(|surface| *surface == self.surface)
1547 .unwrap_or(0);
1548 self.surface = surfaces[(index + 1) % surfaces.len()];
1549 }
1550
1551 pub fn scroll_surface(&mut self, delta: i32) {
1552 let scroll = self.surface_scroll.entry(self.surface).or_default();
1553 *scroll = (*scroll as i64 + i64::from(delta)).max(0) as usize;
1554 }
1555
1556 pub fn scroll_home(&mut self) {
1557 self.surface_scroll.insert(self.surface, 0);
1558 }
1559
1560 pub fn scroll_end(&mut self) {
1561 let end = self.surface_content_height().saturating_sub(1);
1562 self.surface_scroll.insert(self.surface, end);
1563 }
1564
1565 fn surface_content_height(&self) -> usize {
1567 if self.surface == DevSurface::Agent {
1568 return self.conversation_view().lines().count().max(1);
1569 }
1570 let content = match self.surface {
1571 DevSurface::Code => &self.editor,
1572 DevSurface::App => &self.browser,
1573 DevSurface::Terminal => &self.processes,
1574 DevSurface::Tasks => &self.tasks,
1575 DevSurface::Git => &self.git,
1576 DevSurface::Debug => &self.debugger,
1577 DevSurface::More | DevSurface::Trust => &self.workspace_status,
1578 DevSurface::Agent => unreachable!("agent content handled above"),
1579 };
1580 content.lines().count().max(1)
1581 }
1582
1583 pub fn current_scroll(&self) -> u16 {
1584 self.surface_scroll
1585 .get(&self.surface)
1586 .copied()
1587 .unwrap_or(0)
1588 .min(u16::MAX as usize) as u16
1589 }
1590
1591 pub fn move_file_selection(&mut self, delta: i32) {
1592 if self.files.is_empty() {
1593 self.selected_file = 0;
1594 return;
1595 }
1596 self.selected_file = (self.selected_file as i32 + delta)
1597 .clamp(0, self.files.len().saturating_sub(1) as i32)
1598 as usize;
1599 }
1600
1601 pub fn open_selected_file(&mut self) {
1602 let Some(path) = self.files.get(self.selected_file).cloned() else {
1603 self.status = "No project file selected".into();
1604 return;
1605 };
1606 match self.workspace.try_lock().and_then(|mut workspace| {
1607 workspace
1608 .project_mut()
1609 .open_buffer(&path, crate::development::Actor::local())
1610 }) {
1611 Ok(_) => {
1612 self.status = format!("Opened {path} · press i to edit");
1613 self.refresh_editor_projection();
1614 }
1615 Err(error) => self.status = format!("Open failed: {error}"),
1616 }
1617 }
1618
1619 pub fn queue_git_diff(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
1621 if self.background_action_running() {
1622 self.status = "Git diff waits for the current background operation".into();
1623 return;
1624 }
1625 let (call, context) =
1626 match self.tool_request("glass.git.diff", serde_json::json!({}), false) {
1627 Ok(request) => request,
1628 Err(error) => {
1629 self.status = format!("Git diff unavailable: {error}");
1630 return;
1631 }
1632 };
1633 match worker.submit_tool(call, context) {
1634 Ok(id) => {
1635 self.running_tool_job = Some(id);
1636 self.git_diff_open = true;
1637 self.git_diff = "Loading Git diff…".into();
1638 self.status = "Loading Git diff in background…".into();
1639 }
1640 Err(error) => self.status = format!("Git diff unavailable: {error}"),
1641 }
1642 }
1643
1644 pub fn open_git_diff(&mut self) {
1646 let diff = self.workspace.try_lock().and_then(|workspace| {
1647 workspace
1648 .git()
1649 .ok_or_else(|| {
1650 crate::development::DevelopmentError::NotFound("not a Git repository".into())
1651 })?
1652 .diff(false, None)
1653 .map_err(|error| crate::development::DevelopmentError::Process(error.to_string()))
1654 });
1655 match diff {
1656 Ok(diff) if diff.trim().is_empty() => {
1657 self.git_diff = "Working tree clean · no diff to show".into();
1658 self.git_diff_open = true;
1659 }
1660 Ok(diff) => {
1661 self.git_diff = diff;
1662 self.git_diff_open = true;
1663 self.status = "Git diff · PgUp/PgDn scroll · Esc closes".into();
1664 }
1665 Err(error) => self.status = format!("Git diff unavailable: {error}"),
1666 }
1667 }
1668
1669 pub fn close_git_diff(&mut self) {
1670 self.git_diff_open = false;
1671 self.git_diff_requested = false;
1672 self.status = "Git status".into();
1673 }
1674
1675 pub fn focused_buffer(&self) -> Option<crate::development::EditorBuffer> {
1676 self.workspace.try_lock().ok().and_then(|workspace| {
1677 workspace
1678 .project()
1679 .buffers()
1680 .nth(self.editor_buffer_index)
1681 .cloned()
1682 })
1683 }
1684
1685 pub fn refresh_editor_projection(&mut self) {
1686 let buffers = self
1687 .workspace
1688 .lock()
1689 .map(|workspace| workspace.project().buffers().cloned().collect::<Vec<_>>())
1690 .unwrap_or_default();
1691 if let Some(buffer) = buffers.get(self.editor_buffer_index) {
1692 self.focused_editor_path = buffer.path.clone();
1693 self.focused_editor_dirty = buffer.dirty;
1694 self.focused_editor_line = buffer.cursor_line;
1695 }
1696 self.editor = format_editor_buffers(&buffers);
1697 }
1698
1699 pub fn cycle_editor_buffer(&mut self, delta: i32) {
1700 let count = self
1701 .workspace
1702 .lock()
1703 .map(|workspace| workspace.project().buffers().count())
1704 .unwrap_or(0);
1705 if count == 0 {
1706 self.status = "No open buffers · open a file from the list".into();
1707 return;
1708 }
1709 let index = self.editor_buffer_index as i32 + delta;
1710 self.editor_buffer_index = index.rem_euclid(count as i32) as usize;
1711 let name = self
1712 .workspace
1713 .lock()
1714 .ok()
1715 .and_then(|workspace| {
1716 workspace
1717 .project()
1718 .buffers()
1719 .nth(self.editor_buffer_index)
1720 .map(|buffer| buffer.path.clone())
1721 })
1722 .unwrap_or_default();
1723 self.refresh_editor_projection();
1724 self.status = format!("Buffer {}/{} · {name}", self.editor_buffer_index + 1, count);
1725 }
1726
1727 pub fn enter_code_edit(&mut self) {
1728 let has_buffer = self.focused_buffer().is_some();
1729 if !has_buffer {
1730 self.open_selected_file();
1731 }
1732 let has_buffer = self.focused_buffer().is_some();
1733 if has_buffer {
1734 self.code_edit_mode = true;
1735 self.status =
1736 "EDIT · arrows move · Ctrl-S save · Ctrl-Z/Y undo/redo · Esc close".into();
1737 }
1738 }
1739
1740 pub fn close_code_edit(&mut self) {
1741 self.code_edit_mode = false;
1742 self.status = "Code navigation".into();
1743 }
1744
1745 pub fn edit_code_key(
1746 &mut self,
1747 code: crossterm::event::KeyCode,
1748 modifiers: crossterm::event::KeyModifiers,
1749 ) {
1750 let Some(buffer) = self.focused_buffer() else {
1751 self.status = "No open buffer".into();
1752 return;
1753 };
1754 let path = buffer.path.clone();
1755 let result = match (code, modifiers) {
1756 (crossterm::event::KeyCode::Char('s'), value)
1757 if value.contains(crossterm::event::KeyModifiers::CONTROL) =>
1758 {
1759 self.locked(|workspace| workspace.project_mut().save_buffer(&path).map(|_| ()))
1760 .unwrap_or_else(|| {
1761 Err(crate::development::DevelopmentError::Conflict(
1762 "workspace lock failed".into(),
1763 ))
1764 })
1765 }
1766 (crossterm::event::KeyCode::Char('z'), value)
1767 if value.contains(crossterm::event::KeyModifiers::CONTROL) =>
1768 {
1769 self.locked(|workspace| workspace.project_mut().undo_buffer(&path).map(|_| ()))
1770 .unwrap_or_else(|| {
1771 Err(crate::development::DevelopmentError::Conflict(
1772 "workspace lock failed".into(),
1773 ))
1774 })
1775 }
1776 (crossterm::event::KeyCode::Char('y'), value)
1777 if value.contains(crossterm::event::KeyModifiers::CONTROL) =>
1778 {
1779 self.locked(|workspace| workspace.project_mut().redo_buffer(&path).map(|_| ()))
1780 .unwrap_or_else(|| {
1781 Err(crate::development::DevelopmentError::Conflict(
1782 "workspace lock failed".into(),
1783 ))
1784 })
1785 }
1786 (crossterm::event::KeyCode::Left, _) => self.move_editor_cursor(&path, 0, -1),
1787 (crossterm::event::KeyCode::Right, _) => self.move_editor_cursor(&path, 0, 1),
1788 (crossterm::event::KeyCode::Up, _) => self.move_editor_cursor(&path, -1, 0),
1789 (crossterm::event::KeyCode::Down, _) => self.move_editor_cursor(&path, 1, 0),
1790 (crossterm::event::KeyCode::Enter, _) => self.insert_editor_text(&path, "\n"),
1791 (crossterm::event::KeyCode::Backspace, _) => self.backspace_editor(&path),
1792 (crossterm::event::KeyCode::Char(character), _) => {
1793 self.insert_editor_text(&path, &character.to_string())
1794 }
1795 _ => Ok(()),
1796 };
1797 if let Err(error) = result {
1798 self.status = format!("Editor action failed: {error}");
1799 }
1800 self.refresh_editor_projection();
1801 }
1802
1803 fn move_editor_cursor(
1804 &mut self,
1805 path: &str,
1806 line_delta: i32,
1807 column_delta: i32,
1808 ) -> crate::development::DevelopmentResult<()> {
1809 let buffer = self
1810 .workspace
1811 .try_lock()?
1812 .project()
1813 .buffer(path)
1814 .cloned()
1815 .ok_or_else(|| {
1816 crate::development::DevelopmentError::NotFound(format!("buffer {path}"))
1817 })?;
1818 let lines = buffer.content.split('\n').collect::<Vec<_>>();
1819 let line =
1820 (buffer.cursor_line as i32 + line_delta).clamp(1, lines.len().max(1) as i32) as u32;
1821 let max_column = lines
1822 .get(line.saturating_sub(1) as usize)
1823 .map(|line| line.chars().count() + 1)
1824 .unwrap_or(1) as u32;
1825 let column = if line_delta != 0 {
1826 buffer.cursor_column.min(max_column)
1827 } else {
1828 (buffer.cursor_column as i32 + column_delta).clamp(1, max_column as i32) as u32
1829 };
1830 self.workspace
1831 .try_lock()?
1832 .project_mut()
1833 .set_buffer_cursor(path, line, column)
1834 }
1835
1836 fn insert_editor_text(
1837 &mut self,
1838 path: &str,
1839 text: &str,
1840 ) -> crate::development::DevelopmentResult<()> {
1841 let buffer = self
1842 .workspace
1843 .try_lock()?
1844 .project()
1845 .buffer(path)
1846 .cloned()
1847 .ok_or_else(|| {
1848 crate::development::DevelopmentError::NotFound(format!("buffer {path}"))
1849 })?;
1850 let offset = editor_offset(&buffer.content, buffer.cursor_line, buffer.cursor_column);
1851 let mut content = buffer.content.clone();
1852 content.insert_str(offset, text);
1853 self.workspace.try_lock()?.project_mut().edit_buffer(
1854 path,
1855 content,
1856 crate::development::Actor::local(),
1857 )?;
1858 let (line, column) = if text == "\n" {
1859 (buffer.cursor_line + 1, 1)
1860 } else {
1861 (
1862 buffer.cursor_line,
1863 buffer.cursor_column + text.chars().count() as u32,
1864 )
1865 };
1866 self.workspace
1867 .try_lock()?
1868 .project_mut()
1869 .set_buffer_cursor(path, line, column)
1870 }
1871
1872 fn backspace_editor(&mut self, path: &str) -> crate::development::DevelopmentResult<()> {
1873 let buffer = self
1874 .workspace
1875 .lock()?
1876 .project()
1877 .buffer(path)
1878 .cloned()
1879 .ok_or_else(|| {
1880 crate::development::DevelopmentError::NotFound(format!("buffer {path}"))
1881 })?;
1882 let offset = editor_offset(&buffer.content, buffer.cursor_line, buffer.cursor_column);
1883 if offset == 0 {
1884 return Ok(());
1885 }
1886 let previous = buffer.content[..offset]
1887 .char_indices()
1888 .next_back()
1889 .map(|(index, _)| index)
1890 .unwrap_or(0);
1891 let removed_newline = &buffer.content[previous..offset] == "\n";
1892 let mut content = buffer.content.clone();
1893 content.drain(previous..offset);
1894 self.workspace.try_lock()?.project_mut().edit_buffer(
1895 path,
1896 content.clone(),
1897 crate::development::Actor::local(),
1898 )?;
1899 let (line, column) = if removed_newline {
1900 let line = buffer.cursor_line.saturating_sub(1).max(1);
1901 let column = content
1902 .split('\n')
1903 .nth(line.saturating_sub(1) as usize)
1904 .map(|line| line.chars().count() + 1)
1905 .unwrap_or(1) as u32;
1906 (line, column)
1907 } else {
1908 (
1909 buffer.cursor_line,
1910 buffer.cursor_column.saturating_sub(1).max(1),
1911 )
1912 };
1913 self.workspace
1914 .try_lock()?
1915 .project_mut()
1916 .set_buffer_cursor(path, line, column)
1917 }
1918
1919 pub fn previous_surface(&mut self) {
1920 let surfaces: &[DevSurface] = if self
1921 .responsive_class(self.terminal_width, self.terminal_height)
1922 == ResponsiveClass::Phone
1923 {
1924 &DevSurface::PHONE
1925 } else {
1926 &DevSurface::PRIMARY
1927 };
1928 let index = surfaces
1929 .iter()
1930 .position(|surface| *surface == self.surface)
1931 .unwrap_or(0);
1932 self.surface = surfaces[(index + surfaces.len() - 1) % surfaces.len()];
1933 }
1934
1935 pub fn apply_snapshot(&mut self, snapshot: &super::snapshot::DisplaySnapshot) {
1937 self.refresh_latency_ms = snapshot.duration.as_millis() as u64;
1938 if let super::snapshot::BrowserHealth::Crashed {
1939 last_process_id,
1940 last_revision,
1941 } = &snapshot.browser_health
1942 && self.browser_recovery.is_none()
1943 {
1944 let pid_label = last_process_id
1945 .map(|pid| pid.to_string())
1946 .unwrap_or_else(|| "unknown".into());
1947 let revision_label = last_revision
1948 .map(|revision| revision.to_string())
1949 .unwrap_or_else(|| "none".into());
1950 self.surface = DevSurface::App;
1951 self.browser_recovery = Some(BrowserRecoveryOffer::from_error(
1952 &format!(
1953 "browser endpoint crashed unexpectedly (pid {pid_label}, last revision {revision_label})"
1954 ),
1955 9222,
1956 ));
1957 self.browser_workspace
1958 .disconnected("browser endpoint crashed".to_string(), true);
1959 self.status = "Browser endpoint crashed · recovery choices below".into();
1960 }
1961 self.agents = snapshot.agents.clone();
1962 self.agent_conversation = snapshot.agent_conversation.clone();
1963 self.reconcile_pending_chat();
1964 self.tasks = snapshot.tasks.clone();
1965 self.editor = snapshot.editor.clone();
1966 self.lsp = snapshot.lsp.clone();
1967 self.processes = snapshot.processes.clone();
1968 self.git = snapshot.git.clone();
1969 self.tests = snapshot.tests.clone();
1970 self.kernels = snapshot.kernels.clone();
1971 self.debugger = snapshot.debugger.clone();
1972 self.replay = snapshot.replay.clone();
1973 self.workflow = snapshot.workflow.clone();
1974 self.workspace_status = snapshot.workspace_status.clone();
1975 self.browser = snapshot.browser.clone();
1976 self.snapshot_root = snapshot.root.clone();
1977 self.snapshot_trust_label = snapshot.trust_label.clone();
1978 self.snapshot_trust_inspection = snapshot.trust_inspection.clone();
1979 self.snapshot_project_revision = snapshot.project_revision;
1980 self.snapshot_generation = snapshot.generation;
1981 self.snapshot_skills_count = snapshot.skills_count;
1982 self.snapshot_tools_count = snapshot.tools_count;
1983 self.experiments = snapshot.experiments.clone();
1984 if !snapshot.files.is_empty() {
1985 self.files = snapshot.files.clone();
1986 if !self.files.is_empty() {
1987 self.selected_file = self.selected_file.min(self.files.len() - 1);
1988 }
1989 }
1990 }
1991
1992 pub fn set_terminal_size(&mut self, width: u16, height: u16) {
1993 self.terminal_width = width;
1994 self.terminal_height = height;
1995 }
1996
1997 pub fn refresh(&mut self) {
1998 let Ok(mut workspace) = self.workspace.try_lock() else {
1999 self.status = "Workspace lock failed".into();
2000 return;
2001 };
2002 self.files = workspace
2003 .project()
2004 .list_files()
2005 .map(|entries| {
2006 entries
2007 .into_iter()
2008 .filter(|entry| matches!(entry.kind, crate::development::FileKind::File))
2009 .map(|entry| entry.path)
2010 .take(512)
2011 .collect()
2012 })
2013 .unwrap_or_default();
2014 if !self.files.is_empty() {
2015 self.selected_file = self.selected_file.min(self.files.len() - 1);
2016 }
2017 let agent_snapshots = workspace.agents().list();
2018 self.pending_agent_approval = pending_agent_approval(agent_snapshots.as_ref().ok());
2019 self.agents = match agent_snapshots {
2020 Ok(agents) if agents.is_empty() => "No agents. :agent spawn ROLE TASK".into(),
2021 Ok(agents) => agents
2022 .iter()
2023 .map(|agent| {
2024 format!(
2025 "{} {} {} · {}\n target {} · model {} · thinking {} · events {} · dropped {}{}\n evidence {}",
2026 agent.id.as_str(),
2027 agent.status.label(),
2028 agent.role,
2029 agent.task,
2030 agent.worktree.display(),
2031 agent.model.as_deref().unwrap_or("default"),
2032 agent.thinking.as_deref().unwrap_or("default"),
2033 agent.event_count,
2034 agent.dropped_event_count,
2035 agent
2036 .last_error
2037 .as_deref()
2038 .map(|error| format!(" · {error}"))
2039 .unwrap_or_default(),
2040 agent
2041 .evidence
2042 .iter()
2043 .rev()
2044 .take(3)
2045 .map(|evidence| evidence.to_string())
2046 .collect::<Vec<_>>()
2047 .join(" · ")
2048 )
2049 })
2050 .collect::<Vec<_>>()
2051 .join("\n\n"),
2052 Err(error) => format!("Agent registry failed: {error}"),
2053 };
2054 self.agent_conversation = match workspace.agents().history(0) {
2055 Ok(events) if events.is_empty() => {
2056 "No conversation yet. Press i to compose a message.".into()
2057 }
2058 Ok(events) => super::projection::conversation(
2059 &events
2060 .iter()
2061 .rev()
2062 .take(40)
2063 .rev()
2064 .cloned()
2065 .collect::<Vec<_>>(),
2066 ),
2067 Err(error) => format!("Conversation unavailable · {error}"),
2068 };
2069 self.tasks = match workspace.tasks() {
2070 Ok(tasks) if tasks.is_empty() => {
2071 "No tasks. :task create TITLE PROMPT creates an autonomous task".into()
2072 }
2073 Ok(tasks) => tasks
2074 .iter()
2075 .map(|task| {
2076 let glyph = match task.state {
2077 crate::TaskState::Succeeded
2078 if task.verification == crate::VerificationRequirement::Settled => "◇",
2079 crate::TaskState::Succeeded => "✓",
2080 crate::TaskState::Failed | crate::TaskState::Cancelled => "×",
2081 crate::TaskState::Blocked => "!",
2082 crate::TaskState::Running | crate::TaskState::Verifying => "●",
2083 _ => "○",
2084 };
2085 format!(
2086 "{} {} {} {}\n goal {}\n agent {} · attempt {} · model {} · thinking {}\n depends {}\n verification {}{}\n evidence {}",
2087 glyph,
2088 task.id.as_str(),
2089 task.state.label(),
2090 task.title,
2091 task.goal,
2092 task.assigned_agent
2093 .as_ref()
2094 .map(|agent| agent.as_str())
2095 .unwrap_or("unassigned"),
2096 task.attempt,
2097 task.model.as_deref().unwrap_or("default"),
2098 task.thinking.as_deref().unwrap_or("default"),
2099 task.dependencies
2100 .iter()
2101 .map(|dependency| dependency.as_str())
2102 .collect::<Vec<_>>()
2103 .join(", "),
2104 serde_json::to_string(&task.verification).unwrap_or_default(),
2105 task.last_error
2106 .as_deref()
2107 .map(|error| format!(" · {error}"))
2108 .unwrap_or_default(),
2109 task.evidence
2110 .iter()
2111 .rev()
2112 .take(3)
2113 .map(|evidence| {
2114 format!(
2115 "{}={}",
2116 evidence.kind,
2117 evidence.passed.map_or("?".into(), |passed| passed.to_string())
2118 )
2119 })
2120 .collect::<Vec<_>>()
2121 .join(" · ")
2122 )
2123 })
2124 .collect::<Vec<_>>()
2125 .join("\n\n"),
2126 Err(error) => format!("Task scheduler failed: {error}"),
2127 };
2128 self.processes = workspace
2129 .project_mut()
2130 .processes()
2131 .list_checked()
2132 .map(|items| {
2133 if items.is_empty() {
2134 "No managed terminals. Start the detected development command from More.".into()
2135 } else {
2136 items
2137 .into_iter()
2138 .map(|item| {
2139 format!(
2140 "{} {} · health {} · pid {} · {}\n {}",
2141 if matches!(item.health, crate::development::ProcessHealth::Healthy)
2142 {
2143 "●"
2144 } else {
2145 "○"
2146 },
2147 item.name,
2148 item.health.label(),
2149 item.pid.map_or_else(|| "—".into(), |pid| pid.to_string()),
2150 if item.pty { "PTY" } else { "pipes" },
2151 item.detected_urls
2152 .first()
2153 .map_or(item.command.as_str(), String::as_str),
2154 )
2155 })
2156 .collect::<Vec<_>>()
2157 .join("\n\n")
2158 }
2159 })
2160 .unwrap_or_else(|error| format!("Process state failed: {error}"));
2161 let buffers = workspace.project().buffers().cloned().collect::<Vec<_>>();
2162 self.editor = if buffers.is_empty() {
2163 "No file open. Select a file below and press Enter, then i to edit.".into()
2164 } else {
2165 buffers
2166 .iter()
2167 .map(|buffer| {
2168 let lines: Vec<&str> = buffer.content.lines().collect();
2170 let cursor = buffer.cursor_line as usize;
2171 let viewport_rows = 16;
2172 let start = cursor
2173 .saturating_sub(viewport_rows / 2)
2174 .min(lines.len().saturating_sub(viewport_rows.min(lines.len())));
2175 let end = (start + viewport_rows).min(lines.len());
2176 let gutter_width = lines.len().to_string().len().max(3);
2177 let viewport = lines[start..end]
2178 .iter()
2179 .enumerate()
2180 .map(|(index, line)| {
2181 let number = start + index + 1;
2182 let marker = if number == cursor { "▶" } else { " " };
2183 format!(
2184 "{marker}{:>gutter_width$} │ {line}",
2185 number,
2186 gutter_width = gutter_width
2187 )
2188 })
2189 .collect::<Vec<_>>()
2190 .join("\n");
2191 format!(
2192 "{}{} · cursor {}:{} · actor {} · {} lines\n{}",
2193 if buffer.dirty { "● " } else { "○ " },
2194 buffer.path,
2195 buffer.cursor_line,
2196 buffer.cursor_column,
2197 buffer.actor.id,
2198 lines.len(),
2199 viewport
2200 )
2201 })
2202 .collect::<Vec<_>>()
2203 .join("\n\n")
2204 };
2205 self.lsp = {
2206 let language = workspace.language();
2207 let servers = language.names().collect::<Vec<_>>();
2208 let event_count = language.events(0).len();
2209 if servers.is_empty() {
2210 "No language server active · diagnostics unavailable".into()
2211 } else {
2212 format!("● {} · {} recent events", servers.join(" · "), event_count)
2213 }
2214 };
2215 self.git = workspace
2216 .git()
2217 .map(|git| match git.status() {
2218 Ok(status) => {
2219 let header = format!(
2220 "branch {} · ↑{} ↓{} · upstream {}",
2221 status.branch.as_deref().unwrap_or("detached"),
2222 status.ahead,
2223 status.behind,
2224 status.upstream.as_deref().unwrap_or("none")
2225 );
2226 let entries = status
2227 .entries
2228 .iter()
2229 .map(|entry| {
2230 format!(
2231 "{}{} {}{}",
2232 if entry.untracked { "?" } else { "●" },
2233 if status.conflicts.contains(&entry.path) {
2234 "!"
2235 } else {
2236 " "
2237 },
2238 entry.index_status,
2239 entry.path
2240 )
2241 })
2242 .collect::<Vec<_>>();
2243 if entries.is_empty() {
2244 format!("{header}\n✓ working tree clean")
2245 } else {
2246 format!("{header}\n{}", entries.join("\n"))
2247 }
2248 }
2249 Err(error) => format!("Git state failed: {error}"),
2250 })
2251 .unwrap_or_else(|| "Not a Git repository".into());
2252 let _ = workspace.tests_mut().poll();
2253 let test_runs = workspace
2254 .tests()
2255 .results()
2256 .rev()
2257 .take(32)
2258 .collect::<Vec<_>>();
2259 self.tests = if test_runs.is_empty() {
2260 "No test runs".into()
2261 } else {
2262 test_runs
2263 .iter()
2264 .map(|run| {
2265 format!(
2266 "{} {} · {} · {} ms · {} cases",
2267 if run.exit_code == Some(0) {
2268 "✓"
2269 } else {
2270 "×"
2271 },
2272 run.suite_id,
2273 run.state.label(),
2274 run.duration_ms.unwrap_or_default(),
2275 run.cases.len()
2276 )
2277 })
2278 .collect::<Vec<_>>()
2279 .join("\n")
2280 };
2281 let kernels = workspace.kernels().snapshots().collect::<Vec<_>>();
2282 self.kernels = if kernels.is_empty() {
2283 "No persistent kernels".into()
2284 } else {
2285 kernels
2286 .iter()
2287 .map(|kernel| {
2288 format!(
2289 "{} {} · {} · {} executions · rev {}",
2290 if matches!(kernel.state, crate::kernels::KernelState::Ready) {
2291 "●"
2292 } else {
2293 "○"
2294 },
2295 kernel.name,
2296 kernel.kind.label(),
2297 kernel.executions,
2298 kernel.workspace_revision
2299 )
2300 })
2301 .collect::<Vec<_>>()
2302 .join("\n")
2303 };
2304 let debugger_names = workspace
2305 .debugger_names()
2306 .map(str::to_string)
2307 .collect::<Vec<_>>();
2308 self.debugger = if debugger_names.is_empty() {
2309 "No debugger sessions. :debug start NAME COMMAND [ARGS...]".into()
2310 } else {
2311 let snapshots: Result<Vec<_>, _> = debugger_names
2312 .iter()
2313 .map(|name| {
2314 workspace
2315 .debugger_mut(name)
2316 .and_then(|debugger| debugger.snapshot())
2317 .map(|snapshot| (name.to_string(), snapshot))
2318 })
2319 .collect();
2320 match snapshots {
2321 Ok(snapshots) => snapshots
2322 .iter()
2323 .map(|(name, snapshot)| {
2324 format!(
2325 "● {} · {} · pid {} · {} breakpoints · {} watches · {} threads/processes",
2326 name,
2327 match snapshot.state {
2328 crate::debugger::DebugSessionState::Starting => "starting",
2329 crate::debugger::DebugSessionState::Initialized => "initialized",
2330 crate::debugger::DebugSessionState::Running => "running",
2331 crate::debugger::DebugSessionState::Stopped => "stopped",
2332 crate::debugger::DebugSessionState::Terminated => "terminated",
2333 crate::debugger::DebugSessionState::Failed => "failed",
2334 },
2335 snapshot.adapter_process_id,
2336 snapshot.breakpoints.values().map(Vec::len).sum::<usize>(),
2337 snapshot.watches.len(),
2338 snapshot.debuggee_processes.len()
2339 )
2340 })
2341 .collect::<Vec<_>>()
2342 .join("\n"),
2343 Err(error) => format!("Debugger state failed: {error}"),
2344 }
2345 };
2346 self.replay = workspace
2347 .intelligence()
2348 .replay(0, 128)
2349 .map(|events| {
2350 if events.is_empty() {
2351 "No observable replay events".into()
2352 } else {
2353 events
2354 .iter()
2355 .rev()
2356 .take(24)
2357 .rev()
2358 .map(|event| {
2359 format!(
2360 "{} {} · {} · {} · rev {}",
2361 event.sequence,
2362 event.actor,
2363 event.subsystem,
2364 event.kind,
2365 event.workspace_revision
2366 )
2367 })
2368 .collect::<Vec<_>>()
2369 .join("\n")
2370 }
2371 })
2372 .unwrap_or_else(|error| format!("Replay failed: {error}"));
2373 self.browser = match workspace.browser().state() {
2374 Ok(state) => {
2375 let connected = state
2376 .get("connected")
2377 .and_then(serde_json::Value::as_bool)
2378 .unwrap_or(false);
2379 let revision = state
2380 .get("browserRevision")
2381 .and_then(serde_json::Value::as_u64);
2382 if connected {
2383 if self.browser_workspace.state().connection
2384 != BrowserConnectionPhase::Connected
2385 {
2386 self.browser_workspace.connected(true, None, revision);
2387 } else if let Some(revision) = revision {
2388 self.browser_workspace.state_mut().browser_revision = Some(revision);
2389 }
2390 } else {
2391 self.browser_workspace.state_mut().connection =
2392 BrowserConnectionPhase::Detached;
2393 }
2394 self.browser_workspace_summary()
2395 }
2396 Err(error) => format!("Browser state failed: {error}"),
2397 };
2398 self.workflow = workspace
2399 .browser()
2400 .list_workflows()
2401 .map(|state| super::projection::workflow(Some(&state)))
2402 .unwrap_or_else(|error| format!("Workflow state failed: {error}"));
2403 let root = workspace.root().display().to_string();
2404 let generation = workspace.generation();
2405 let project_revision = workspace.project().revision();
2406 let agent_count = workspace
2407 .agents()
2408 .list()
2409 .map(|items| items.len())
2410 .unwrap_or(0);
2411 let task_count = workspace.tasks().map(|items| items.len()).unwrap_or(0);
2412 let kernel_count = workspace.kernels().snapshots().count();
2413 let debugger_count = workspace.debugger_names().count();
2414 let detection = workspace.project().detection().clone();
2415 let trust = workspace.trust();
2416 let trust_ready = trust.permits_project_execution();
2417 let dev_hint = detection
2418 .dev_command
2419 .as_deref()
2420 .map(|command| format!("● run `{command}`"))
2421 .unwrap_or_else(|| "○ configure a dev command".into());
2422 let app_hint = detection
2423 .browser_url
2424 .as_deref()
2425 .map(|url| format!("● open App {url}"))
2426 .unwrap_or_else(|| "○ start App after a URL is detected".into());
2427 let project_line = if detection.languages.is_empty() {
2428 "○ project type unknown".to_string()
2429 } else {
2430 format!("✓ {} project", detection.languages.join("/"))
2431 };
2432 let workspace_line = format!("✓ workspace {}", trust.label());
2433 let agent_hint = if self.agent_readiness.starts_with("✓ Ready") {
2434 "✓ Glass Agent ready · [i] chat"
2435 } else {
2436 "○ Pi onboarding · [s] install · [l] sign in"
2437 };
2438 self.workspace_status = format!(
2439 "WELCOME · {}\n{}\n\n{}\n{}\n\nNEXT ACTIONS\n◆ [a] actions menu · per-surface flows\n◆ [i] talk to Glass Agent\n◆ [4] terminal · [s] start the detected dev suite\n◆ [Enter] open the selected file\n{}\n{}\n\nSTATE\nroot {}\ngeneration {} · project revision {} · trust {}\nresident: {} agents · {} tasks · {} kernels · {} debuggers",
2440 detection.git_branch.as_deref().unwrap_or("no branch"),
2441 project_line,
2442 agent_hint,
2443 workspace_line,
2444 dev_hint,
2445 app_hint,
2446 root,
2447 generation,
2448 project_revision,
2449 trust_ready,
2450 agent_count,
2451 task_count,
2452 kernel_count,
2453 debugger_count,
2454 );
2455 if workspace.trust().permits_project_execution()
2456 && let Ok(experiments) = workspace.experiments()
2457 {
2458 let snapshots = experiments.snapshots();
2459 self.experiments = if snapshots.is_empty() {
2460 "No experiments".into()
2461 } else {
2462 snapshots
2463 .iter()
2464 .map(|experiment| {
2465 format!(
2466 "{} {} · {} · port {} · agent {}",
2467 if experiment.evidence.tests_failed == 0
2468 && experiment.evidence.tests_passed > 0
2469 {
2470 "✓"
2471 } else {
2472 "○"
2473 },
2474 experiment.id,
2475 experiment.state.label(),
2476 experiment
2477 .port
2478 .map_or_else(|| "—".into(), |port| port.to_string()),
2479 experiment
2480 .agent_id
2481 .as_ref()
2482 .map(|id| id.as_str())
2483 .unwrap_or("none")
2484 )
2485 })
2486 .collect::<Vec<_>>()
2487 .join("\n")
2488 };
2489 self.experiment_comparison = Some(experiments.compare());
2490 }
2491 drop(workspace);
2492 self.reconcile_pending_chat();
2493 }
2494
2495 pub fn apply_browser_result(&mut self, tool: &str, result: &serde_json::Value) {
2496 match tool {
2497 "glass.browser.observe" => {
2498 let revision = result
2499 .pointer("/accessibility/revision")
2500 .and_then(serde_json::Value::as_u64);
2501 let title = result
2502 .pointer("/page/title")
2503 .and_then(serde_json::Value::as_str)
2504 .unwrap_or("Untitled");
2505 let url = result
2506 .pointer("/page/url")
2507 .and_then(serde_json::Value::as_str)
2508 .unwrap_or_default();
2509 let loading = result
2510 .pointer("/page/loading")
2511 .and_then(serde_json::Value::as_bool)
2512 .unwrap_or(false);
2513 if let Some(revision) = revision {
2514 self.browser_workspace
2515 .update_page(title, url, loading, Some(revision));
2516 let entities = result
2517 .pointer("/accessibility/interactive")
2518 .and_then(serde_json::Value::as_array)
2519 .into_iter()
2520 .flatten()
2521 .filter_map(|entity| {
2522 Some(BrowserWorkspaceEntity {
2523 reference: entity.get("reference")?.as_str()?.into(),
2524 role: entity
2525 .get("role")
2526 .and_then(serde_json::Value::as_str)
2527 .unwrap_or("unknown")
2528 .into(),
2529 name: entity
2530 .get("name")
2531 .and_then(serde_json::Value::as_str)
2532 .unwrap_or("unnamed")
2533 .into(),
2534 actionable: entity
2535 .get("actionable")
2536 .and_then(serde_json::Value::as_bool)
2537 .unwrap_or(true),
2538 revision,
2539 })
2540 })
2541 .collect();
2542 self.browser_workspace.replace_entities(revision, entities);
2543 }
2544 }
2545 "glass.browser.targets" => {
2546 let values = result
2547 .get("targets")
2548 .and_then(serde_json::Value::as_array)
2549 .or_else(|| result.as_array());
2550 let targets = values
2551 .into_iter()
2552 .flatten()
2553 .filter_map(|target| {
2554 Some(BrowserWorkspaceTarget {
2555 id: target.get("id")?.as_str()?.into(),
2556 title: target
2557 .get("title")
2558 .and_then(serde_json::Value::as_str)
2559 .unwrap_or("Untitled")
2560 .into(),
2561 url: target
2562 .get("url")
2563 .and_then(serde_json::Value::as_str)
2564 .unwrap_or_default()
2565 .into(),
2566 selected: target
2567 .get("active")
2568 .and_then(serde_json::Value::as_bool)
2569 .unwrap_or(false),
2570 })
2571 })
2572 .collect();
2573 self.browser_workspace.replace_targets(targets);
2574 if self.browser_target_picker_requested {
2575 self.browser_target_picker_requested = false;
2576 self.browser_target_picker = true;
2577 self.browser_target_selection = 0;
2578 self.status = if self.browser_workspace.state().targets.is_empty() {
2579 "No page targets found · Esc closes".into()
2580 } else {
2581 "Target picker · type to filter · j/k select · Enter choose · Esc close"
2582 .into()
2583 };
2584 }
2585 }
2586 "glass.browser.target.select" => {
2587 if let Some(target_id) = result
2588 .pointer("/target/id")
2589 .and_then(serde_json::Value::as_str)
2590 {
2591 let mut targets = self.browser_workspace.state().targets.clone();
2592 for target in &mut targets {
2593 target.selected = target.id == target_id;
2594 }
2595 self.browser_workspace.replace_targets(targets);
2596 }
2597 if let Some(observation) = result.get("observation") {
2598 self.apply_browser_result("glass.browser.observe", observation);
2599 }
2600 }
2601 "glass.browser.start" => {
2602 let connected = result
2603 .get("connected")
2604 .and_then(serde_json::Value::as_bool)
2605 .unwrap_or(true);
2606 let revision = result
2607 .get("browserRevision")
2608 .and_then(serde_json::Value::as_u64);
2609 if connected {
2610 self.browser_workspace.connected(true, None, revision);
2611 self.browser_recovery = None;
2612 }
2613 }
2614 "glass.browser.stop" => {
2615 self.browser_workspace.state_mut().connection = BrowserConnectionPhase::Detached;
2616 }
2617 _ => {}
2618 }
2619 self.browser = self.browser_workspace_summary();
2620 }
2621
2622 pub fn browser_workspace_summary(&self) -> String {
2623 let browser = self.browser_workspace.state();
2624 let entities = if browser.entities.is_empty() {
2625 "No current semantic entities".into()
2626 } else {
2627 browser
2628 .entities
2629 .iter()
2630 .enumerate()
2631 .skip(browser.semantic_scroll)
2632 .take(24)
2633 .map(|(index, entity)| {
2634 format!(
2635 "{} {} · {} · {}",
2636 if Some(index) == browser.selected_entity {
2637 "◆"
2638 } else {
2639 "○"
2640 },
2641 entity.name,
2642 entity.role,
2643 entity.reference
2644 )
2645 })
2646 .collect::<Vec<_>>()
2647 .join("\n")
2648 };
2649 let targets = if browser.targets.is_empty() {
2650 "No page targets loaded · use `browser targets`".into()
2651 } else {
2652 browser
2653 .targets
2654 .iter()
2655 .take(8)
2656 .map(|target| {
2657 format!(
2658 "{} {} · {}",
2659 if target.selected { "◆" } else { "○" },
2660 target.title,
2661 safe_browser_url(&target.url).unwrap_or_else(|| "no URL".into())
2662 )
2663 })
2664 .collect::<Vec<_>>()
2665 .join("\n")
2666 };
2667 format!(
2668 "{} · rev {} · {} · owner {}\n{}\n{}\n\nTARGETS\n{}\n\nUNDERSTANDING\n{}\n\nWORKFLOW\n{}",
2669 browser.connection_label(),
2670 browser
2671 .browser_revision
2672 .map_or_else(|| "—".into(), |revision| revision.to_string()),
2673 browser.presentation_label(),
2674 browser.input_owner_label(),
2675 browser.title,
2676 safe_browser_url(&browser.url).unwrap_or_else(|| "no page".into()),
2677 targets,
2678 entities,
2679 browser.workflow
2680 )
2681 }
2682
2683 pub fn queue_browser_targets(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
2684 if self.background_action_running() {
2685 self.status = "Target picker waits for the current background operation".into();
2686 return;
2687 }
2688 if let Err(error) = self.request_browser_target_picker("") {
2689 self.status = format!("Could not load browser targets: {error}");
2690 return;
2691 }
2692 let Some((call, context)) = self.queued_tool_request.take() else {
2693 return;
2694 };
2695 match worker.submit_tool(call, context) {
2696 Ok(id) => {
2697 self.running_tool_job = Some(id);
2698 self.status = "Loading browser targets…".into();
2699 }
2700 Err(error) => {
2701 self.browser_target_picker_requested = false;
2702 self.status = format!("Could not load browser targets: {error}");
2703 }
2704 }
2705 }
2706
2707 pub fn request_browser_target_picker(
2708 &mut self,
2709 query: impl Into<String>,
2710 ) -> Result<(), String> {
2711 if self.background_action_running() {
2712 return Err("Target picker waits for the current background operation".into());
2713 }
2714 self.browser_target_query = query.into();
2715 self.browser_target_selection = 0;
2716 self.browser_target_picker = false;
2717 self.browser_target_picker_requested = true;
2718 let (call, context) =
2719 match self.tool_request("glass.browser.targets", serde_json::json!({}), false) {
2720 Ok(request) => request,
2721 Err(error) => {
2722 self.browser_target_picker_requested = false;
2723 return Err(error);
2724 }
2725 };
2726 self.queued_tool_request = Some((call, context));
2727 self.status = "Loading browser targets…".into();
2728 Ok(())
2729 }
2730
2731 pub fn close_browser_target_picker(&mut self) {
2732 self.browser_target_picker = false;
2733 self.browser_target_picker_requested = false;
2734 self.status = "Target picker closed".into();
2735 }
2736
2737 pub fn browser_target_matches(&self) -> Vec<usize> {
2738 let query = self.browser_target_query.to_ascii_lowercase();
2739 let terms = query.split_whitespace().collect::<Vec<_>>();
2740 self.browser_workspace
2741 .state()
2742 .targets
2743 .iter()
2744 .enumerate()
2745 .filter(|(_, target)| {
2746 terms.iter().all(|term| {
2747 target.id.to_ascii_lowercase().contains(term)
2748 || target.title.to_ascii_lowercase().contains(term)
2749 || target.url.to_ascii_lowercase().contains(term)
2750 })
2751 })
2752 .map(|(index, _)| index)
2753 .collect()
2754 }
2755
2756 pub fn insert_browser_target_query(&mut self, character: char) {
2757 if self.browser_target_query.len() < 512 {
2758 self.browser_target_query.push(character);
2759 self.browser_target_selection = 0;
2760 }
2761 }
2762
2763 pub fn browser_target_backspace(&mut self) {
2764 self.browser_target_query.pop();
2765 self.browser_target_selection = 0;
2766 }
2767
2768 pub fn clear_browser_target_query(&mut self) {
2769 self.browser_target_query.clear();
2770 self.browser_target_selection = 0;
2771 }
2772
2773 pub fn move_browser_target_selection(&mut self, delta: i32) {
2774 let count = self.browser_target_matches().len();
2775 if count == 0 {
2776 self.browser_target_selection = 0;
2777 return;
2778 }
2779 self.browser_target_selection =
2780 (self.browser_target_selection as i32 + delta).rem_euclid(count as i32) as usize;
2781 }
2782
2783 pub fn select_browser_target(&mut self) {
2784 if self.background_action_running() {
2785 self.status = "Finish the current browser operation before selecting a target".into();
2786 return;
2787 }
2788 let matches = self.browser_target_matches();
2789 let Some(index) = matches.get(self.browser_target_selection).copied() else {
2790 self.status = "No matching browser target".into();
2791 return;
2792 };
2793 let Some(target) = self.browser_workspace.state().targets.get(index).cloned() else {
2794 self.status = "Selected browser target disappeared".into();
2795 return;
2796 };
2797 let (call, context) = match self.tool_request(
2798 "glass.browser.target.select",
2799 serde_json::json!({"targetId": target.id}),
2800 true,
2801 ) {
2802 Ok(request) => request,
2803 Err(error) => {
2804 self.status = format!("Target selection unavailable: {error}");
2805 return;
2806 }
2807 };
2808 self.browser_target_picker = false;
2809 self.pending_confirmation = Some(PendingConfirmation {
2810 call,
2811 context,
2812 summary: format!("Select browser target · {}", target.title),
2813 });
2814 self.status = "Target selection ready · Enter approves once · Esc cancels".into();
2815 }
2816
2817 pub fn browser_target_picker_view(&self) -> String {
2818 let matches = self.browser_target_matches();
2819 let mut lines = vec![
2820 format!(
2821 "FILTER {}",
2822 if self.browser_target_query.is_empty() {
2823 "all pages"
2824 } else {
2825 self.browser_target_query.as_str()
2826 }
2827 ),
2828 String::new(),
2829 ];
2830 if matches.is_empty() {
2831 lines.push("No matching page targets.".into());
2832 } else {
2833 for (position, index) in matches.iter().take(16).enumerate() {
2834 let Some(target) = self.browser_workspace.state().targets.get(*index) else {
2835 continue;
2836 };
2837 let marker = if position == self.browser_target_selection {
2838 "›"
2839 } else {
2840 " "
2841 };
2842 let url = safe_browser_url(&target.url).unwrap_or_else(|| "no URL".into());
2843 lines.push(format!(
2844 "{marker} {} · {} · {}",
2845 target.title, url, target.id
2846 ));
2847 }
2848 }
2849 lines.push(String::new());
2850 lines.push("Type filters · Backspace edits · Ctrl-U clears".into());
2851 lines.push("j/k or ↑/↓ selects · Enter chooses · Esc closes".into());
2852 lines.join("\n")
2853 }
2854
2855 pub fn queue_browser_observe(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
2856 if !self.browser_observe_pending || self.background_action_running() {
2857 return;
2858 }
2859 self.browser_observe_pending = false;
2860 let (call, context) =
2861 match self.tool_request("glass.browser.observe", serde_json::json!({}), false) {
2862 Ok(request) => request,
2863 Err(error) => {
2864 self.status = format!("Could not refresh browser evidence: {error}");
2865 return;
2866 }
2867 };
2868 match worker.submit_tool(call, context) {
2869 Ok(id) => {
2870 self.running_tool_job = Some(id);
2871 self.status = "Refreshing semantic browser evidence…".into();
2872 }
2873 Err(error) => self.status = format!("Could not refresh browser evidence: {error}"),
2874 }
2875 }
2876
2877 pub fn queue_browser_intent(&mut self, intent: BrowserWorkspaceIntent) {
2878 if self.background_action_running() {
2879 self.status = "Browser action waits for the current background operation".into();
2880 return;
2881 }
2882 let action = match self.browser_workspace.reduce(intent) {
2883 Ok(Some(action)) => action,
2884 Ok(None) => return,
2885 Err(error) => {
2886 self.status = format!("App action unavailable: {error}");
2887 return;
2888 }
2889 };
2890 let (tool, arguments) = match action {
2891 BrowserWorkspaceAction::Navigate {
2892 url,
2893 expected_revision,
2894 } => (
2895 "glass.browser.navigate",
2896 serde_json::json!({"url": url, "browserRevision": expected_revision}),
2897 ),
2898 BrowserWorkspaceAction::Back { expected_revision }
2899 | BrowserWorkspaceAction::Forward { expected_revision }
2900 | BrowserWorkspaceAction::Reload { expected_revision }
2901 | BrowserWorkspaceAction::StopLoading { expected_revision } => {
2902 let action = match action {
2903 BrowserWorkspaceAction::Back { .. } => "back",
2904 BrowserWorkspaceAction::Forward { .. } => "forward",
2905 BrowserWorkspaceAction::Reload { .. } => "reload",
2906 BrowserWorkspaceAction::StopLoading { .. } => "stopLoading",
2907 _ => unreachable!(),
2908 };
2909 (
2910 "glass.browser.act",
2911 serde_json::json!({"action": action, "browserRevision": expected_revision}),
2912 )
2913 }
2914 BrowserWorkspaceAction::Click {
2915 target,
2916 expected_revision,
2917 } => (
2918 "glass.browser.act",
2919 serde_json::json!({"action":"click", "target": target, "browserRevision": expected_revision}),
2920 ),
2921 BrowserWorkspaceAction::Type {
2922 target,
2923 text,
2924 expected_revision,
2925 } => (
2926 "glass.browser.act",
2927 serde_json::json!({"action":"type", "target": target, "text": text, "browserRevision": expected_revision}),
2928 ),
2929 BrowserWorkspaceAction::Scroll {
2930 dx,
2931 dy,
2932 expected_revision,
2933 } => (
2934 "glass.browser.act",
2935 serde_json::json!({"action":"scroll", "dx": dx, "dy": dy, "browserRevision": expected_revision}),
2936 ),
2937 _ => return,
2938 };
2939 let (call, context) = match self.tool_request(tool, arguments, true) {
2940 Ok(request) => request,
2941 Err(error) => {
2942 self.status = format!("App action unavailable: {error}");
2943 return;
2944 }
2945 };
2946 self.pending_confirmation = Some(PendingConfirmation {
2947 summary: format!("{tool} · browser revision guarded"),
2948 call,
2949 context,
2950 });
2951 self.status = "Browser mutation ready · Enter approves once · Esc cancels".into();
2952 }
2953
2954 pub(super) fn tool_request(
2955 &self,
2956 name: &str,
2957 arguments: serde_json::Value,
2958 mutating: bool,
2959 ) -> Result<
2960 (
2961 crate::development::ToolCall,
2962 crate::tools::DevelopmentToolContext,
2963 ),
2964 String,
2965 > {
2966 let expected_generation = self.snapshot_generation;
2970 let expected_project_revision = self.snapshot_project_revision;
2971 Ok((
2972 crate::development::ToolCall {
2973 id: format!(
2974 "tui-browser-{}",
2975 NEXT_BROWSER_TOOL.fetch_add(1, Ordering::Relaxed)
2976 ),
2977 name: name.into(),
2978 arguments,
2979 },
2980 crate::tools::DevelopmentToolContext {
2981 authorization: crate::development::ToolAuthorization {
2982 actor: crate::development::Actor::local(),
2983 allow_mutation: mutating,
2984 confirmed: mutating,
2985 },
2986 initiator: None,
2987 expected_generation,
2988 expected_project_revision,
2989 },
2990 ))
2991 }
2992
2993 pub fn note_browser_failure(&mut self, tool: &str, error: &str) {
2996 let lower = error.to_ascii_lowercase();
2997 if tool.contains("browser")
2998 && (lower.contains("occupied")
2999 || lower.contains("attach")
3000 || lower.contains("connect")
3001 || lower.contains("launch")
3002 || lower.contains("timeout")
3003 || lower.contains("devtools"))
3004 {
3005 self.browser_target_picker = false;
3006 self.browser_target_picker_requested = false;
3007 self.surface = DevSurface::App;
3008 self.browser_recovery = Some(BrowserRecoveryOffer::from_error(
3009 error,
3010 self.browser_recovery
3011 .as_ref()
3012 .map_or(9222, |offer| offer.port),
3013 ));
3014 self.browser_workspace.disconnected(error.to_string(), true);
3015 }
3016 }
3017
3018 pub fn accept_browser_recovery(
3020 &mut self,
3021 choice: usize,
3022 worker: &mut super::snapshot::SnapshotWorker,
3023 ) {
3024 let Some(offer) = self.browser_recovery.take() else {
3025 return;
3026 };
3027 let (port, attach) = match (offer.compatible_endpoint, choice) {
3028 (true, 0) => (offer.port, true),
3029 (true, 1) | (false, 0) => (free_local_port().unwrap_or(0), false),
3030 (true, 2) | (false, 1) => (offer.port, false),
3031 _ => {
3032 self.status = "Recovery dismissed · project and agent remain available".into();
3033 return;
3034 }
3035 };
3036 if port == 0 {
3037 self.status =
3038 "No free local port was available · retry or use an existing browser".into();
3039 return;
3040 }
3041 let (call, context) = match self.tool_request(
3042 "glass.browser.start",
3043 browser_recovery_arguments(port, attach),
3044 true,
3045 ) {
3046 Ok(request) => request,
3047 Err(error) => {
3048 self.status = format!("Could not queue recovery: {error}");
3049 return;
3050 }
3051 };
3052 match worker.submit_tool(call, context) {
3053 Ok(id) => {
3054 self.running_tool_job = Some(id);
3055 self.status = if attach {
3056 format!("Attaching to browser on port {port} in background…")
3057 } else {
3058 format!("Recovering browser on port {port} in background…")
3059 };
3060 }
3061 Err(error) => self.status = format!("Could not queue recovery: {error}"),
3062 }
3063 }
3064
3065 pub fn refresh_agent_readiness(&mut self) -> Result<bool, String> {
3066 let readiness = crate::pi_runtime::pi_readiness().map_err(|error| error.to_string())?;
3067 let ready = readiness.ready;
3068 self.agent_readiness = format_pi_readiness(&readiness);
3069 Ok(ready)
3070 }
3071}
3072
3073fn format_editor_buffers(buffers: &[crate::development::EditorBuffer]) -> String {
3074 if buffers.is_empty() {
3075 return "No file open. Select a file below and press Enter, then i to edit.".into();
3076 }
3077 buffers
3078 .iter()
3079 .map(|buffer| {
3080 let lines: Vec<&str> = buffer.content.lines().collect();
3081 let cursor = buffer.cursor_line as usize;
3082 let viewport_rows = 16;
3083 let start = cursor
3084 .saturating_sub(viewport_rows / 2)
3085 .min(lines.len().saturating_sub(viewport_rows.min(lines.len())));
3086 let end = (start + viewport_rows).min(lines.len());
3087 let gutter_width = lines.len().to_string().len().max(3);
3088 let viewport = lines[start..end]
3089 .iter()
3090 .enumerate()
3091 .map(|(index, line)| {
3092 let number = start + index + 1;
3093 let marker = if number == cursor { "▶" } else { " " };
3094 format!(
3095 "{marker}{:>gutter_width$} │ {line}",
3096 number,
3097 gutter_width = gutter_width
3098 )
3099 })
3100 .collect::<Vec<_>>()
3101 .join("\n");
3102 format!(
3103 "{}{} · cursor {}:{} · actor {} · {} lines\n{}",
3104 if buffer.dirty { "● " } else { "○ " },
3105 buffer.path,
3106 buffer.cursor_line,
3107 buffer.cursor_column,
3108 buffer.actor.id,
3109 lines.len(),
3110 viewport
3111 )
3112 })
3113 .collect::<Vec<_>>()
3114 .join("\n\n")
3115}
3116
3117fn format_pi_readiness(readiness: &crate::PiReadiness) -> String {
3118 let provider = readiness.provider.as_deref().unwrap_or("not selected");
3119 let session = readiness.session.as_deref().unwrap_or("new session");
3120 let remediation = readiness
3121 .remediation
3122 .first()
3123 .map(|item| format!(" · next: {item}"))
3124 .unwrap_or_default();
3125 let state_line = format!(
3126 "{} · Node {} · SDK {} · auth {}",
3127 if readiness.ready {
3128 "✓ Ready"
3129 } else {
3130 "○ Needs setup"
3131 },
3132 component_label(&readiness.node),
3133 readiness.sdk.version.as_deref().unwrap_or("missing"),
3134 component_label(&readiness.authentication),
3135 );
3136 if readiness.ready {
3137 format!("{state_line}\nprovider {provider} · {session}")
3138 } else {
3139 format!(
3140 "{state_line}\nprovider {provider} · {session}{remediation}\n\n[s] `agent setup` repairs the pinned runtime · [u] `agent update` refreshes it · [l] opens Pi `/login`"
3141 )
3142 }
3143}
3144
3145fn component_label(component: &crate::pi_runtime::PiReadinessComponent) -> String {
3146 match component.state {
3147 crate::pi_runtime::PiReadinessState::Ready => "✓".into(),
3148 crate::pi_runtime::PiReadinessState::Missing => "× missing".into(),
3149 crate::pi_runtime::PiReadinessState::Incompatible => "! incompatible".into(),
3150 crate::pi_runtime::PiReadinessState::Expired => "! expired".into(),
3151 crate::pi_runtime::PiReadinessState::Unknown => "? unknown".into(),
3152 }
3153}
3154
3155fn safe_browser_url(url: &str) -> Option<String> {
3156 let url = url.trim();
3157 if url.is_empty() {
3158 return None;
3159 }
3160 let sanitized = url
3161 .split(['?', '#'])
3162 .next()
3163 .unwrap_or(url)
3164 .chars()
3165 .take(2_048)
3166 .collect::<String>();
3167 (!sanitized.is_empty()).then_some(sanitized)
3168}
3169
3170fn page_origin(url: &str) -> Option<String> {
3171 let url = safe_browser_url(url)?;
3172 let scheme_end = url.find("://")?;
3173 let authority_start = scheme_end + 3;
3174 let authority_end = url[authority_start..]
3175 .find('/')
3176 .map(|offset| authority_start + offset)
3177 .unwrap_or(url.len());
3178 Some(url[..authority_end].to_string())
3179}
3180
3181fn pending_agent_approval(
3182 agents: Option<&Vec<crate::AgentSnapshot>>,
3183) -> Option<PendingAgentApproval> {
3184 let agents = agents?;
3185 for agent in agents {
3186 let mut pending = None;
3187 for event in &agent.evidence {
3188 match event.get("type").and_then(serde_json::Value::as_str) {
3189 Some("glass_tool_approval_request") => {
3190 let Some(frame_id) = event.get("frameId").and_then(serde_json::Value::as_str)
3191 else {
3192 continue;
3193 };
3194 pending = Some(PendingAgentApproval {
3195 agent_id: agent.id.as_str().to_string(),
3196 frame_id: frame_id.to_string(),
3197 tool_name: event
3198 .get("toolName")
3199 .and_then(serde_json::Value::as_str)
3200 .unwrap_or("unknown tool")
3201 .to_string(),
3202 arguments: event.get("arguments").cloned().unwrap_or_default(),
3203 });
3204 }
3205 Some("glass_tool_approval_resolved") => {
3206 let frame_id = event.get("frameId").and_then(serde_json::Value::as_str);
3207 if pending
3208 .as_ref()
3209 .is_some_and(|approval| Some(approval.frame_id.as_str()) == frame_id)
3210 {
3211 pending = None;
3212 }
3213 }
3214 _ => {}
3215 }
3216 }
3217 if pending.is_some() {
3218 return pending;
3219 }
3220 }
3221 None
3222}
3223
3224fn fuzzy_contains(candidate: &str, query: &str) -> bool {
3225 if query.is_empty() {
3226 return true;
3227 }
3228 let mut query = query
3229 .chars()
3230 .map(|character| character.to_ascii_lowercase());
3231 let mut expected = query.next();
3232 for character in candidate
3233 .chars()
3234 .map(|character| character.to_ascii_lowercase())
3235 {
3236 if Some(character) == expected {
3237 expected = query.next();
3238 if expected.is_none() {
3239 return true;
3240 }
3241 }
3242 }
3243 false
3244}
3245
3246fn browser_recovery_arguments(port: u16, attach: bool) -> serde_json::Value {
3247 serde_json::json!({
3248 "port": port,
3249 "attach": attach,
3250 "incognito": !attach,
3251 })
3252}
3253
3254fn free_local_port() -> Option<u16> {
3256 std::net::TcpListener::bind((std::net::Ipv4Addr::LOCALHOST, 0))
3257 .ok()
3258 .and_then(|listener| listener.local_addr().ok())
3259 .map(|address| address.port())
3260}
3261
3262fn editor_offset(content: &str, line: u32, column: u32) -> usize {
3263 let mut offset = 0;
3264 for (index, value) in content.split_inclusive('\n').enumerate() {
3265 if index + 1 == line as usize {
3266 let column_bytes = value
3267 .trim_end_matches('\n')
3268 .char_indices()
3269 .nth(column.saturating_sub(1) as usize)
3270 .map(|(offset, _)| offset)
3271 .unwrap_or_else(|| value.trim_end_matches('\n').len());
3272 return offset + column_bytes;
3273 }
3274 offset += value.len();
3275 }
3276 content.len()
3277}
3278
3279#[cfg(test)]
3280mod tests {
3281 use super::*;
3282
3283 #[test]
3284 fn quit_confirmation_requires_explicit_follow_through() {
3285 let root = std::env::temp_dir().join(format!("glass-tui-quit-{}", std::process::id()));
3286 std::fs::create_dir_all(&root).expect("create temporary workspace");
3287 let mut state =
3288 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
3289
3290 state.request_quit();
3291 assert!(state.quit_confirmation);
3292 assert!(!state.quit);
3293 assert_eq!(state.status, "Quit confirmation · Enter exits · Esc stays");
3294
3295 state.cancel_quit();
3296 assert!(!state.quit_confirmation);
3297 assert!(!state.quit);
3298
3299 state.request_quit();
3300 state.confirm_quit();
3301 assert!(!state.quit_confirmation);
3302 assert!(state.quit);
3303 assert_eq!(state.status, "Closing Glass Dev");
3304
3305 std::fs::remove_dir_all(root).expect("remove temporary workspace");
3306 }
3307
3308 #[test]
3309 fn browser_context_url_redaction_preserves_path_only() {
3310 assert_eq!(
3311 safe_browser_url("https://example.test/orders/7?token=secret#receipt"),
3312 Some("https://example.test/orders/7".into())
3313 );
3314 assert_eq!(
3315 page_origin("https://example.test/orders/7?token=secret"),
3316 Some("https://example.test".into())
3317 );
3318 assert_eq!(safe_browser_url(""), None);
3319 }
3320
3321 #[test]
3322 fn browser_recovery_offer_explains_port_collision_choices() {
3323 let offer = BrowserRecoveryOffer::from_error("address already in use on port 9222", 9222);
3324 assert!(!offer.compatible_endpoint);
3325 assert_eq!(offer.actions().len(), 3);
3326 assert!(offer.guidance().contains("preferred endpoint"));
3327
3328 let attach =
3329 BrowserRecoveryOffer::from_error("DevTools page target is available for attach", 9222);
3330 assert!(attach.compatible_endpoint);
3331 assert_eq!(attach.actions().len(), 4);
3332 assert!(attach.guidance().contains("Attach"));
3333 }
3334
3335 #[test]
3336 fn browser_recovery_attach_disables_incognito() {
3337 assert_eq!(
3338 browser_recovery_arguments(9222, true),
3339 serde_json::json!({
3340 "port": 9222,
3341 "attach": true,
3342 "incognito": false,
3343 })
3344 );
3345 assert_eq!(
3346 browser_recovery_arguments(42123, false),
3347 serde_json::json!({
3348 "port": 42123,
3349 "attach": false,
3350 "incognito": true,
3351 })
3352 );
3353 }
3354
3355 #[test]
3356 fn browser_target_picker_filters_and_redacts_urls() {
3357 let root = std::env::temp_dir().join(format!("glass-target-picker-{}", std::process::id()));
3358 std::fs::create_dir_all(&root).expect("create temporary workspace");
3359 let mut state =
3360 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
3361 state.browser_workspace.replace_targets(vec![
3362 BrowserWorkspaceTarget {
3363 id: "page-docs".into(),
3364 title: "Project docs".into(),
3365 url: "https://example.test/docs?token=secret".into(),
3366 selected: false,
3367 },
3368 BrowserWorkspaceTarget {
3369 id: "page-app".into(),
3370 title: "Application".into(),
3371 url: "http://localhost:3000".into(),
3372 selected: false,
3373 },
3374 ]);
3375 state
3376 .request_browser_target_picker("docs")
3377 .expect("queue target picker");
3378 state.queued_tool_request = None;
3379 let matches = state.browser_target_matches();
3380 assert_eq!(matches, vec![0]);
3381 let view = state.browser_target_picker_view();
3382 assert!(view.contains("Project docs"));
3383 assert!(view.contains("https://example.test/docs"));
3384 assert!(!view.contains("token=secret"));
3385 std::fs::remove_dir_all(root).expect("remove temporary workspace");
3386 }
3387}