1use super::command;
2use crate::{ExperimentComparison, SharedDevelopmentWorkspace};
3use glass_browser::browser::policy::PolicyPreset;
4use glass_browser::browser_workspace::{
5 BrowserConnectionPhase, BrowserWorkspaceAction, BrowserWorkspaceAdapterKind,
6 BrowserWorkspaceController, BrowserWorkspaceEntity, BrowserWorkspaceIntent,
7 BrowserWorkspaceLayout, BrowserWorkspaceTarget,
8};
9use glass_browser::cli::args::TuiLayout;
10use glass_browser::terminal_graphics::AnsiCanvas;
11use glass_browser::tui::live_view::AnsiPane;
12use serde::{Deserialize, Serialize};
13use std::path::Path;
14use std::sync::atomic::{AtomicU64, Ordering};
15
16static NEXT_BROWSER_TOOL: AtomicU64 = AtomicU64::new(1);
17
18pub struct PendingConfirmation {
19 pub call: crate::development::ToolCall,
20 pub context: crate::tools::DevelopmentToolContext,
21 pub summary: String,
22}
23
24#[derive(Debug, Clone)]
25pub struct PendingAgentApproval {
26 pub agent_id: String,
27 pub frame_id: String,
28 pub tool_name: String,
29 pub arguments: serde_json::Value,
30}
31
32#[derive(Debug, Clone, Copy, PartialEq, Eq)]
33pub enum ChatMessageState {
34 Sending,
35 Sent,
36 Failed,
37}
38
39#[derive(Debug, Clone, PartialEq, Eq)]
40pub struct PendingChatMessage {
41 pub text: String,
42 pub state: ChatMessageState,
43 pub job_id: Option<u64>,
44 pub error: Option<String>,
45}
46
47#[derive(Debug, Clone, PartialEq, Eq)]
49pub struct BrowserRecoveryOffer {
50 pub reason: String,
51 pub port: u16,
52 pub compatible_endpoint: bool,
54}
55
56impl BrowserRecoveryOffer {
57 pub fn from_error(error: &str, port: u16) -> Self {
58 let lower = error.to_ascii_lowercase();
59 Self {
60 reason: error.to_string(),
61 port,
62 compatible_endpoint: ["attach", "devtools", "page target", "multiple page targets"]
63 .iter()
64 .any(|marker| lower.contains(marker)),
65 }
66 }
67
68 pub fn actions(&self) -> &'static [(&'static str, &'static str)] {
69 if self.compatible_endpoint {
70 &[
71 ("1", "attach after checking the running browser"),
72 ("2", "launch an isolated browser on an automatic free port"),
73 ("3", "retry the preferred port"),
74 ("Esc", "dismiss"),
75 ]
76 } else {
77 &[
78 ("1", "launch an isolated browser on an automatic free port"),
79 ("2", "retry the preferred port"),
80 ("Esc", "dismiss"),
81 ]
82 }
83 }
84
85 pub fn guidance(&self) -> &'static str {
86 let lower = self.reason.to_ascii_lowercase();
87 if self.compatible_endpoint {
88 "A DevTools endpoint answered. Attach only when its page is the intended browser; otherwise launch an isolated session."
89 } else if lower.contains("occup") || lower.contains("address") || lower.contains("port") {
90 "The preferred endpoint is busy or unavailable. Glass keeps the project and agent alive while you retry or move to an automatic free port."
91 } else {
92 "The browser did not become usable. Check Chrome/Chromium availability, then retry; the workspace remains intact."
93 }
94 }
95}
96
97#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
98pub enum DevSurface {
99 Trust,
100 Agent,
101 Code,
102 App,
103 Terminal,
104 Tasks,
105 Git,
106 Debug,
107 More,
108}
109
110impl DevSurface {
111 pub const ALL: [Self; 8] = [
112 Self::Agent,
113 Self::Code,
114 Self::App,
115 Self::Terminal,
116 Self::Tasks,
117 Self::Git,
118 Self::Debug,
119 Self::More,
120 ];
121
122 pub const PRIMARY: [Self; 8] = [
123 Self::Agent,
124 Self::Code,
125 Self::App,
126 Self::Terminal,
127 Self::Tasks,
128 Self::Git,
129 Self::Debug,
130 Self::More,
131 ];
132
133 pub const PHONE: [Self; 5] = [Self::Agent, Self::Code, Self::App, Self::Tasks, Self::More];
134
135 pub fn label(self) -> &'static str {
136 match self {
137 Self::Trust => "Trust",
138 Self::Agent => "Agent",
139 Self::Code => "Code",
140 Self::App => "App",
141 Self::Terminal => "Terminal",
142 Self::Tasks => "Tasks",
143 Self::Git => "Git",
144 Self::Debug => "Debug",
145 Self::More => "More",
146 }
147 }
148}
149
150#[derive(Debug, Clone, Copy, PartialEq, Eq)]
151pub enum ResponsiveClass {
152 Desktop,
153 Compact,
154 Phone,
155}
156
157#[derive(Debug, Clone, Copy, PartialEq, Eq)]
158pub enum EditorExitPrompt {
159 Clean,
160 Unsaved,
161}
162
163#[derive(Debug, Clone, Copy, PartialEq, Eq)]
164pub enum ProductMode {
165 Build,
166 Agent,
167 RunApp,
168 Debug,
169}
170
171impl ProductMode {
172 pub fn label(self) -> &'static str {
173 match self {
174 Self::Build => "build",
175 Self::Agent => "agent",
176 Self::RunApp => "run",
177 Self::Debug => "debug",
178 }
179 }
180}
181
182pub struct DevTuiState {
183 pub workspace: SharedDevelopmentWorkspace,
184 pub surface: DevSurface,
185 pub layout: TuiLayout,
186 pub yolo_mode: bool,
188 pub quit_confirmation: bool,
189 pub quit: bool,
190 pub command_mode: bool,
191 pub command_input: String,
192 pub command_cursor: usize,
193 pub command_history: Vec<String>,
194 pub command_history_index: Option<usize>,
195 pub palette_error: Option<String>,
196 pub palette_scroll: u16,
197 pub palette_selection: usize,
199 pub menu_open: bool,
200 pub menu_selection: usize,
201 pub help_open: bool,
202 pub help_scroll: u16,
203 pub composer_mode: bool,
204 pub composer_input: String,
205 pub composer_cursor: usize,
206 pub composer_steer: bool,
207 pub pending_chat_messages: Vec<PendingChatMessage>,
208 pub agent_send_job: Option<u64>,
209 pub selected_agent: Option<crate::AgentId>,
210 pub pending_confirmation: Option<PendingConfirmation>,
211 pub pending_browser_navigation: Option<String>,
213 pub pending_agent_approval: Option<PendingAgentApproval>,
214 pub editor_exit_prompt: Option<EditorExitPrompt>,
215 pub queued_tool_request: Option<(
216 crate::development::ToolCall,
217 crate::tools::DevelopmentToolContext,
218 )>,
219 pub running_tool_job: Option<u64>,
220 pub surface_scroll: std::collections::BTreeMap<DevSurface, usize>,
221 pub terminal_width: u16,
222 pub terminal_height: u16,
223 pub status: String,
224 pub snapshot_root: String,
225 pub snapshot_trust_label: String,
226 pub snapshot_trust_inspection: Vec<crate::customization::CustomizationInspectionItem>,
227 pub snapshot_project_revision: u64,
228 pub snapshot_generation: u64,
229 pub snapshot_skills_count: usize,
230 pub snapshot_tools_count: usize,
231 pub refresh_latency_ms: u64,
233 pub conversation_cursor: u64,
235 pub editor_buffer_index: usize,
237 pub focused_editor_path: String,
238 pub focused_editor_content: String,
240 pub focused_editor_dirty: bool,
241 pub focused_editor_line: u32,
242 pub focused_editor_column: u32,
243 pub focused_editor_selection: Option<crate::development::TextSelection>,
244 pub editor_comments: Vec<crate::development::EditorComment>,
245 pub editor_proposals: Vec<crate::development::EditorProposal>,
246 pub editor_checkpoints: Vec<crate::development::EditorCheckpoint>,
247 pub agents: String,
248 pub agent_readiness: String,
249 pub harnesses: String,
250 pub agent_login_requested: bool,
253 pub harness_launch_requested: Option<String>,
256 pub agent_conversation: String,
257 pub tasks: String,
258 pub editor: String,
259 pub files: Vec<String>,
260 pub selected_file: usize,
261 pub code_edit_mode: bool,
262 pub editor_soft_wrap: bool,
263 pub editor_scroll_line: usize,
264 pub editor_scroll_column: usize,
265 pub lsp: String,
266 pub processes: String,
267 pub git: String,
268 pub git_entries: Vec<crate::git::GitStatusEntry>,
269 pub github: crate::github::GitHubStatus,
270 pub github_review: String,
271 pub selected_git_file: usize,
272 pub git_diff_path: Option<String>,
273 pub git_diff: String,
274 pub git_diff_open: bool,
275 pub git_diff_requested: bool,
276 pub tests: String,
277 pub kernels: String,
278 pub debugger: String,
279 pub replay: String,
280 pub browser: String,
281 pub browser_detail: String,
282 pub browser_workspace: BrowserWorkspaceController,
283 pub browser_recovery: Option<BrowserRecoveryOffer>,
284 pub browser_target_picker: bool,
285 pub browser_target_picker_requested: bool,
286 pub browser_target_query: String,
287 pub browser_target_selection: usize,
288 pub browser_visual_live: bool,
289 pub browser_observe_pending: bool,
290 pub browser_ansi: AnsiCanvas,
291 pub browser_pane: Option<AnsiPane>,
292 pub workflow: String,
293 pub workspace_status: String,
294 pub experiment_comparison: Option<ExperimentComparison>,
295 pub experiments: String,
296 pub cockpit_url: String,
297 pub private_cockpit: Option<crate::development::LocalCockpit>,
298}
299
300impl DevTuiState {
301 pub fn ws(&self) -> Result<std::sync::MutexGuard<'_, crate::DevelopmentWorkspace>, String> {
303 self.workspace.try_lock().map_err(|error| error.to_string())
304 }
305
306 pub fn ws_mut(&self) -> Result<std::sync::MutexGuard<'_, crate::DevelopmentWorkspace>, String> {
308 self.workspace.try_lock().map_err(|error| error.to_string())
309 }
310
311 fn locked<F, T>(&mut self, operation: F) -> Option<T>
314 where
315 F: FnOnce(&mut crate::DevelopmentWorkspace) -> T,
316 {
317 match self.workspace.try_lock() {
318 Ok(mut workspace) => Some(operation(&mut workspace)),
319 Err(error) => {
320 self.status = format!("Workspace lock failed: {error}");
321 None
322 }
323 }
324 }
325
326 pub fn product_mode(&self) -> ProductMode {
327 match self.surface {
328 DevSurface::Agent => ProductMode::Agent,
329 DevSurface::App => ProductMode::RunApp,
330 DevSurface::Debug => ProductMode::Debug,
331 _ => ProductMode::Build,
332 }
333 }
334 pub fn open(
335 root: impl AsRef<Path>,
336 layout: TuiLayout,
337 ) -> Result<Self, Box<dyn std::error::Error>> {
338 Self::open_internal(root, layout, true, false, PolicyPreset::Development)
339 }
340
341 pub fn open_for_tui(
345 root: impl AsRef<Path>,
346 layout: TuiLayout,
347 ) -> Result<Self, Box<dyn std::error::Error>> {
348 Self::open_internal(root, layout, false, false, PolicyPreset::Development)
349 }
350
351 pub fn open_for_tui_with_mode(
353 root: impl AsRef<Path>,
354 layout: TuiLayout,
355 yolo_mode: bool,
356 ) -> Result<Self, Box<dyn std::error::Error>> {
357 Self::open_for_tui_with_policy(root, layout, yolo_mode, PolicyPreset::Development)
358 }
359
360 pub fn open_for_tui_with_policy(
362 root: impl AsRef<Path>,
363 layout: TuiLayout,
364 yolo_mode: bool,
365 policy_preset: PolicyPreset,
366 ) -> Result<Self, Box<dyn std::error::Error>> {
367 Self::open_internal(root, layout, false, yolo_mode, policy_preset)
368 }
369
370 fn open_internal(
371 root: impl AsRef<Path>,
372 layout: TuiLayout,
373 initial_refresh: bool,
374 yolo_mode: bool,
375 policy_preset: PolicyPreset,
376 ) -> Result<Self, Box<dyn std::error::Error>> {
377 let workspace = SharedDevelopmentWorkspace::open_with_policy(root, policy_preset)?;
378 if yolo_mode {
379 let mut workspace = workspace.lock()?;
380 workspace.agents().set_default_unrestricted(true);
381 }
382 let locked = workspace.lock()?;
383 let trust = locked.trust();
384 let trust_inspection = locked.trust_inspection();
385 let snapshot_root = locked.root().display().to_string();
386 let snapshot_project_revision = locked.project().revision();
387 let snapshot_generation = locked.generation();
388 let snapshot_skills_count = locked.customization().skills().count();
389 let snapshot_tools_count = locked.customization().config().tools.len();
390 let trust_prompt = trust == crate::WorkspaceTrust::Untrusted
391 && trust_inspection.iter().any(|item| item.trust_required);
392 drop(locked);
393 let agent_readiness = crate::pi_runtime::pi_readiness()
394 .map(|readiness| format_pi_readiness(&readiness))
395 .unwrap_or_else(|error| format!("Agent unavailable · {error}"));
396 let initial_status = if trust_prompt {
397 "Trust required · I inspect · O untrusted · 1 once · T project".to_string()
398 } else if agent_readiness.starts_with("✓ Ready") {
399 "Ready · describe a coding task".to_string()
400 } else {
401 "Pi setup required · press :actions or Enter to continue".to_string()
402 };
403 let mut state = Self {
404 workspace,
405 surface: if trust_prompt {
406 DevSurface::Trust
407 } else {
408 DevSurface::Agent
409 },
410 layout,
411 yolo_mode,
412 quit: false,
413 quit_confirmation: false,
414 command_mode: false,
415 command_input: String::new(),
416 command_cursor: 0,
417 command_history: Vec::new(),
418 command_history_index: None,
419 palette_error: None,
420 palette_scroll: 0,
421 palette_selection: 0,
422 menu_open: false,
423 menu_selection: 0,
424 help_open: false,
425 help_scroll: 0,
426 composer_mode: false,
427 composer_input: String::new(),
428 composer_cursor: 0,
429 composer_steer: false,
430 pending_chat_messages: Vec::new(),
431 agent_send_job: None,
432 selected_agent: None,
433 pending_confirmation: None,
434 editor_exit_prompt: None,
435 pending_agent_approval: None,
436 pending_browser_navigation: None,
437 queued_tool_request: None,
438 running_tool_job: None,
439 surface_scroll: std::collections::BTreeMap::new(),
440 terminal_width: 80,
441 terminal_height: 24,
442 snapshot_root,
443 snapshot_trust_label: trust.label().into(),
444 snapshot_trust_inspection: trust_inspection,
445 snapshot_project_revision,
446 snapshot_generation,
447 snapshot_skills_count,
448 snapshot_tools_count,
449 refresh_latency_ms: 0,
450 conversation_cursor: 0,
451 editor_buffer_index: 0,
452 focused_editor_path: String::new(),
453 focused_editor_content: String::new(),
454 focused_editor_dirty: false,
455 focused_editor_line: 0,
456 focused_editor_column: 0,
457 focused_editor_selection: None,
458 editor_comments: Vec::new(),
459 editor_proposals: Vec::new(),
460 editor_checkpoints: Vec::new(),
461 status: initial_status,
462 agents: String::new(),
463 agent_readiness,
464 harnesses: crate::harness::summary(),
465 agent_login_requested: false,
466 harness_launch_requested: None,
467 agent_conversation:
468 "No conversation yet. Press Enter or start typing to compose a message.".into(),
469 tasks: String::new(),
470 editor: String::new(),
471 files: Vec::new(),
472 selected_file: 0,
473 code_edit_mode: false,
474 editor_soft_wrap: false,
475 editor_scroll_line: 0,
476 editor_scroll_column: 0,
477 lsp: String::new(),
478 processes: String::new(),
479 git: String::new(),
480 git_entries: Vec::new(),
481 github: crate::github::GitHubStatus::default(),
482 github_review: "No GitHub review yet".into(),
483 selected_git_file: 0,
484 git_diff_path: None,
485 git_diff: String::new(),
486 git_diff_open: false,
487 git_diff_requested: false,
488 tests: String::new(),
489 kernels: String::new(),
490 debugger: String::new(),
491 replay: String::new(),
492 browser: String::new(),
493 browser_detail: "No browser observation yet".into(),
494 browser_workspace: BrowserWorkspaceController::for_adapter(
495 match layout {
496 TuiLayout::Mobile => BrowserWorkspaceLayout::Phone,
497 TuiLayout::Compact => BrowserWorkspaceLayout::Compact,
498 TuiLayout::Auto | TuiLayout::Desktop => BrowserWorkspaceLayout::Desktop,
499 },
500 BrowserWorkspaceAdapterKind::EmbeddedDevelopment,
501 ),
502 browser_recovery: None,
503 browser_target_picker: false,
504 browser_target_picker_requested: false,
505 browser_target_query: String::new(),
506 browser_target_selection: 0,
507 browser_visual_live: false,
508 browser_observe_pending: false,
509 browser_ansi: AnsiCanvas::default(),
510 browser_pane: None,
511 workflow: "No workflow evidence yet".into(),
512 workspace_status: String::new(),
513 experiment_comparison: None,
514 experiments: "No experiments. :experiment create ID BRANCH [PORT]".into(),
515 cockpit_url: String::new(),
516 private_cockpit: None,
517 };
518 if initial_refresh {
519 state.refresh();
520 }
521 Ok(state)
522 }
523
524 pub fn responsive_class(&self, width: u16, height: u16) -> ResponsiveClass {
525 match self.layout {
526 TuiLayout::Desktop => ResponsiveClass::Desktop,
527 TuiLayout::Compact => ResponsiveClass::Compact,
528 TuiLayout::Mobile => ResponsiveClass::Phone,
529 TuiLayout::Auto if width < 72 || height < 22 => ResponsiveClass::Phone,
530 TuiLayout::Auto if width < 118 || height < 32 => ResponsiveClass::Compact,
531 TuiLayout::Auto => ResponsiveClass::Desktop,
532 }
533 }
534
535 pub fn request_quit(&mut self) {
536 if self.quit {
537 return;
538 }
539 self.quit_confirmation = true;
540 self.status = "Quit confirmation · Enter exits · Esc stays".into();
541 }
542
543 pub fn confirm_quit(&mut self) {
544 self.quit_confirmation = false;
545 self.quit = true;
546 self.status = "Closing Glass Dev".into();
547 }
548
549 pub fn cancel_quit(&mut self) {
550 self.quit_confirmation = false;
551 self.status = "Quit dismissed · workspace remains open".into();
552 }
553
554 pub fn quit_menu_index(&self) -> usize {
555 self.surface_actions().len() + 1
556 }
557
558 pub fn surface_actions(&self) -> &'static [command::SurfaceAction] {
560 command::surface_actions(self.surface)
561 }
562
563 pub fn toggle_help(&mut self) {
564 self.help_open = !self.help_open;
565 self.help_scroll = 0;
566 self.status = if self.help_open {
567 "Help · j/k scroll · ? or Esc closes".into()
568 } else {
569 "Help closed".into()
570 };
571 }
572
573 pub fn scroll_help(&mut self, delta: i32) {
574 self.help_scroll = (self.help_scroll as i32 + delta).max(0) as u16;
575 }
576
577 pub fn open_menu(&mut self) {
578 self.menu_open = true;
579 self.menu_selection = 0;
580 self.status = format!("Command center · {}", self.surface.label());
581 }
582
583 pub fn close_menu(&mut self) {
584 self.menu_open = false;
585 }
586
587 pub fn start_private_cockpit(&mut self) -> Result<String, String> {
588 if let Some(cockpit) = self.private_cockpit.as_ref() {
589 return Ok(cockpit.local_url());
590 }
591 let cockpit = crate::development::LocalCockpit::start(self.workspace.clone())
592 .map_err(|error| error.to_string())?;
593 let url = cockpit.local_url();
594 self.cockpit_url = url.clone();
595 self.private_cockpit = Some(cockpit);
596 self.status = format!("Private cockpit ready · {url}");
597 Ok(url)
598 }
599
600 pub fn stop_private_cockpit(&mut self) {
601 if self.private_cockpit.take().is_some() {
602 self.cockpit_url.clear();
603 self.status = "Private cockpit stopped".into();
604 } else {
605 self.status = "Private cockpit is not running".into();
606 }
607 }
608
609 pub fn private_cockpit_status(&self) -> String {
610 self.private_cockpit
611 .as_ref()
612 .map(|cockpit| format!("running · {}", cockpit.local_url()))
613 .unwrap_or_else(|| "not running · use `cockpit start`".into())
614 }
615
616 pub fn run_menu_action(&mut self) {
620 let search_index = self.surface_actions().len();
621 let quit_index = self.quit_menu_index();
622 if self.menu_selection == search_index {
623 self.menu_open = false;
624 self.open_palette();
625 return;
626 }
627 if self.menu_selection == quit_index {
628 self.menu_open = false;
629 self.request_quit();
630 return;
631 }
632 let Some(action) = self.surface_actions().get(self.menu_selection).copied() else {
633 return;
634 };
635 self.menu_open = false;
636 let name = action.label;
637 let hint = action.command;
638 if hint == "browser view" {
639 self.surface = DevSurface::App;
640 self.browser_visual_live = !self.browser_visual_live;
641 self.status = if self.browser_visual_live {
642 "Live view starting · command palette can stop it".into()
643 } else {
644 "Live view off · semantic inspection remains available".into()
645 };
646 return;
647 }
648 if hint == "process start dev" {
649 self.request_detected_dev();
650 return;
651 }
652 if hint == "git diff" && self.surface == DevSurface::Git {
653 self.git_diff_requested = true;
654 self.status = "Git diff queued · loading off-thread".into();
655 return;
656 }
657 if self.surface == DevSurface::Trust && matches!(hint, "I" | "O" | "1" | "T") {
658 self.handle_printable(hint.chars().next().expect("trust action hint is non-empty"));
659 return;
660 }
661 let prefix = action.key;
662 if prefix == ":" {
663 let prefill = hint
667 .split_whitespace()
668 .take_while(|token| {
669 !token
670 .chars()
671 .all(|character| character.is_ascii_uppercase() || character == '_')
672 })
673 .collect::<Vec<_>>()
674 .join(" ");
675 if prefill.is_empty() || prefill == hint {
676 self.open_palette_with(hint);
677 } else {
678 self.open_palette_with(&format!("{prefill} "));
679 }
680 } else if hint == "i" {
681 if self.surface == DevSurface::Agent {
682 self.open_composer();
683 } else {
684 self.enter_code_edit();
685 }
686 } else if hint == "Enter" {
687 if self.surface == DevSurface::Code {
688 self.open_selected_file();
689 }
690 } else if hint == "Ctrl-S" && self.surface == DevSurface::Code {
691 self.edit_code_key(
692 crossterm::event::KeyCode::Char('s'),
693 crossterm::event::KeyModifiers::CONTROL,
694 );
695 } else {
696 self.status = format!("{name} is available from this surface");
697 }
698 }
699
700 pub fn move_menu_selection(&mut self, delta: i32) {
701 let count = self.surface_actions().len() as i32 + 2;
702 self.menu_selection =
703 (self.menu_selection as i32 + delta).rem_euclid(count.max(1)) as usize;
704 }
705
706 pub fn open_palette(&mut self) {
707 self.command_mode = true;
708 self.command_input.clear();
709 self.command_cursor = 0;
710 self.command_history_index = None;
711 self.palette_error = None;
712 self.palette_scroll = 0;
713 self.palette_selection = 0;
714 self.status = format!(
715 "Command search · {} actions · ↑↓ select · Enter run",
716 self.surface.label()
717 );
718 }
719
720 pub fn close_palette(&mut self) {
721 self.command_mode = false;
722 self.command_input.clear();
723 self.command_cursor = 0;
724 self.command_history_index = None;
725 self.palette_error = None;
726 self.palette_scroll = 0;
727 self.palette_selection = 0;
728 self.status = "Command palette closed · press : for guided launchers".into();
729 }
730
731 pub fn palette_action_indices(&self) -> Vec<usize> {
732 let query = self.command_input.trim();
733 self.surface_actions()
734 .iter()
735 .enumerate()
736 .filter_map(|(index, action)| {
737 let haystack =
738 format!("{} {} {}", action.label, action.command, action.description);
739 fuzzy_contains(&haystack, query).then_some(index)
740 })
741 .collect()
742 }
743
744 pub fn selected_palette_action(&self) -> Option<command::SurfaceAction> {
745 let indices = self.palette_action_indices();
746 indices
747 .get(self.palette_selection)
748 .and_then(|index| self.surface_actions().get(*index))
749 .copied()
750 }
751
752 pub fn move_palette_selection(&mut self, delta: i32) {
753 let count = self.palette_action_indices().len();
754 if count == 0 {
755 return;
756 }
757 self.palette_selection =
758 (self.palette_selection as i32 + delta).rem_euclid(count as i32) as usize;
759 self.palette_error = None;
760 self.palette_scroll = 0;
761 if let Some(action) = self.selected_palette_action() {
762 self.status = format!("{} · Enter runs", action.label);
763 }
764 }
765
766 pub fn submit_palette(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
767 let typed = self.command_input.trim().to_string();
768 let command = match (typed.as_str(), self.selected_palette_action()) {
769 ("a" | "actions" | "help" | "?" | "q" | "quit", _) => {
770 self.command_mode = false;
771 self.command_input.clear();
772 self.command_cursor = 0;
773 self.command_history_index = None;
774 self.palette_scroll = 0;
775 self.palette_selection = 0;
776 Some(typed)
777 }
778 (_, Some(action)) => self.prepare_palette_action(action),
779 (_, None) if typed.is_empty() => {
780 self.status = "No matching palette action · Esc closes".into();
781 return;
782 }
783 (_, None) => {
784 self.command_mode = false;
785 self.command_input.clear();
786 self.command_cursor = 0;
787 self.command_history_index = None;
788 self.palette_scroll = 0;
789 self.palette_selection = 0;
790 Some(typed)
791 }
792 };
793
794 let Some(input) = command else {
795 if !self.command_mode {
796 self.submit_queued_tool(worker);
797 worker.request_refresh();
798 }
799 return;
800 };
801
802 if self.command_history.last() != Some(&input) {
803 self.command_history.push(input.clone());
804 if self.command_history.len() > 32 {
805 self.command_history.remove(0);
806 }
807 }
808 match command::execute(self, &input) {
809 Ok(message) => {
810 self.palette_error = None;
811 self.status = message;
812 }
813 Err(error) => {
814 self.palette_error = Some(error.clone());
815 self.status = format!("Error: {error}");
816 }
817 }
818 self.submit_queued_tool(worker);
819 worker.request_refresh();
820 }
821
822 fn prepare_palette_action(&mut self, action: command::SurfaceAction) -> Option<String> {
823 self.palette_error = None;
824 match action.command {
825 "i" => {
826 self.command_mode = false;
827 if self.surface == DevSurface::Agent {
828 self.open_composer();
829 } else {
830 self.enter_code_edit();
831 }
832 None
833 }
834 "Enter" => {
835 self.command_mode = false;
836 if self.surface == DevSurface::Code {
837 self.open_selected_file();
838 }
839 None
840 }
841 "browser navigate URL" => {
842 self.surface = DevSurface::App;
843 self.open_palette_with("browser navigate ");
844 self.status =
845 "Navigate · type a URL or domain (https:// optional), then press Enter".into();
846 None
847 }
848 "browser type TARGET TEXT" => {
849 self.surface = DevSurface::App;
850 self.open_palette_with("browser type ");
851 self.status = "Type · enter the target and text, then press Enter".into();
852 None
853 }
854 "browser view" => {
855 self.command_mode = false;
856 self.browser_visual_live = !self.browser_visual_live;
857 self.status = if self.browser_visual_live {
858 "Live view starting · command palette can stop it".into()
859 } else {
860 "Live view off · semantic inspection remains available".into()
861 };
862 None
863 }
864 "process start dev"
865 if matches!(self.surface, DevSurface::Terminal | DevSurface::More) =>
866 {
867 self.command_mode = false;
868 self.request_detected_dev();
869 None
870 }
871 "git diff" if self.surface == DevSurface::Git => {
872 self.command_mode = false;
873 self.git_diff_requested = true;
874 self.status = "Git diff queued · loading off-thread".into();
875 None
876 }
877 "1" | "T" | "I" | "O" => {
878 self.command_mode = false;
879 self.handle_printable(action.command.chars().next().unwrap());
880 None
881 }
882 "Ctrl-S" if self.surface == DevSurface::Code => {
883 self.command_mode = false;
884 self.edit_code_key(
885 crossterm::event::KeyCode::Char('s'),
886 crossterm::event::KeyModifiers::CONTROL,
887 );
888 None
889 }
890 command => {
891 let prefill = command
892 .split_whitespace()
893 .take_while(|token| {
894 !token
895 .chars()
896 .all(|character| character.is_ascii_uppercase() || character == '_')
897 })
898 .collect::<Vec<_>>()
899 .join(" ");
900 if prefill != command {
901 self.open_palette_with(&format!("{prefill} "));
902 self.status = format!(
903 "{} · enter only the required value(s), then press Enter",
904 action.label
905 );
906 None
907 } else {
908 self.command_mode = false;
909 self.command_input.clear();
910 self.command_cursor = 0;
911 self.command_history_index = None;
912 self.palette_scroll = 0;
913 self.palette_selection = 0;
914 Some(command.into())
915 }
916 }
917 }
918 }
919
920 pub fn insert_palette_char(&mut self, character: char) {
921 self.command_input.insert(self.command_cursor, character);
922 self.command_cursor += character.len_utf8();
923 self.palette_error = None;
924 self.command_history_index = None;
925 self.palette_scroll = 0;
926 self.palette_selection = 0;
927 }
928
929 pub fn insert_palette_text(&mut self, text: &str) {
930 for character in text.replace(['\r', '\n'], " ").chars().take(8_192) {
931 self.insert_palette_char(character);
932 }
933 }
934
935 pub fn palette_backspace(&mut self) {
936 if self.command_cursor == 0 {
937 return;
938 }
939 let previous = self.command_input[..self.command_cursor]
940 .char_indices()
941 .next_back()
942 .map(|(index, _)| index)
943 .unwrap_or(0);
944 self.command_input.drain(previous..self.command_cursor);
945 self.command_cursor = previous;
946 self.command_history_index = None;
947 self.palette_scroll = 0;
948 self.palette_selection = 0;
949 }
950
951 fn palette_history_indices(&self) -> Vec<usize> {
952 let visible = command::palette_order(self.surface);
953 self.command_history
954 .iter()
955 .enumerate()
956 .filter_map(|(index, input)| {
957 let root = input.split_whitespace().next()?;
958 let root = match root {
959 "?" => "help",
960 "q" => "quit",
961 "gh" => "github",
962 "tasks" => "task",
963 "tests" => "test",
964 "experiments" => "experiment",
965 "knowledge" => "memory",
966 "surfaces" | "backend" => "surface",
967 "tools" => "tool",
968 _ => root,
969 };
970 visible.contains(&root).then_some(index)
971 })
972 .collect()
973 }
974
975 pub fn navigate_palette_history(&mut self, older: bool) {
976 let history = self.palette_history_indices();
977 if history.is_empty() {
978 return;
979 }
980 let position = self
981 .command_history_index
982 .and_then(|index| history.iter().position(|candidate| *candidate == index));
983 let next_position = match (position, older) {
984 (None, true) => history.len() - 1,
985 (None, false) => return,
986 (Some(position), true) => position.saturating_sub(1),
987 (Some(position), false) if position + 1 < history.len() => position + 1,
988 (Some(_), false) => {
989 self.command_history_index = None;
990 self.command_input.clear();
991 self.command_cursor = 0;
992 self.palette_scroll = 0;
993 self.palette_selection = 0;
994 return;
995 }
996 };
997 let index = history[next_position];
998 self.command_history_index = Some(index);
999 self.command_input.clone_from(&self.command_history[index]);
1000 self.command_cursor = self.command_input.len();
1001 self.palette_scroll = 0;
1002 self.palette_selection = 0;
1003 }
1004
1005 pub fn complete_palette(&mut self) {
1006 let Some(completion) = self.palette_matches().first().copied() else {
1007 return;
1008 };
1009 let suffix = self
1010 .command_input
1011 .find(char::is_whitespace)
1012 .map(|index| self.command_input[index..].to_string())
1013 .unwrap_or_default();
1014 self.command_input = format!("{completion}{suffix}");
1015 self.command_cursor = self.command_input.len();
1016 self.command_history_index = None;
1017 self.palette_scroll = 0;
1018 self.palette_selection = 0;
1019 self.status = format!("Completed `{completion}` · Enter runs · Ctrl-P/N history");
1020 }
1021
1022 pub fn open_palette_with(&mut self, prefix: &str) {
1023 self.open_palette();
1024 self.command_input = prefix.into();
1025 self.command_cursor = self.command_input.len();
1026 }
1027
1028 pub fn move_palette_cursor(&mut self, right: bool) {
1029 if right {
1030 self.command_cursor = self.command_input[self.command_cursor..]
1031 .char_indices()
1032 .nth(1)
1033 .map(|(offset, _)| self.command_cursor + offset)
1034 .unwrap_or(self.command_input.len());
1035 } else if self.command_cursor > 0 {
1036 self.command_cursor = self.command_input[..self.command_cursor]
1037 .char_indices()
1038 .next_back()
1039 .map(|(index, _)| index)
1040 .unwrap_or(0);
1041 }
1042 }
1043
1044 pub fn scroll_palette(&mut self, delta: i32) {
1045 self.move_palette_selection(delta.saturating_mul(5));
1046 }
1047
1048 pub fn palette_matches(&self) -> Vec<&'static str> {
1049 let query = self
1050 .command_input
1051 .split_whitespace()
1052 .next()
1053 .unwrap_or_default();
1054 command::palette_order(self.surface)
1055 .into_iter()
1056 .filter(|candidate| fuzzy_contains(candidate, query))
1057 .take(6)
1058 .collect()
1059 }
1060
1061 pub fn background_action_running(&self) -> bool {
1062 self.pending_confirmation.is_some()
1063 || self.pending_agent_approval.is_some()
1064 || self.running_tool_job.is_some()
1065 || self.queued_tool_request.is_some()
1066 || self.agent_send_job.is_some()
1067 }
1068
1069 pub fn agent_browser_context(&self) -> serde_json::Value {
1070 let semantic_summary = self.browser_workspace_summary();
1071 let state = self.browser_workspace.state();
1072 let selected_entity = state.selected().map(|entity| {
1073 serde_json::json!({
1074 "reference": entity.reference,
1075 "role": entity.role,
1076 "name": entity.name,
1077 "actionable": entity.actionable,
1078 "revision": entity.revision,
1079 })
1080 });
1081 let selected_target = state
1082 .targets
1083 .iter()
1084 .find(|target| target.selected)
1085 .map(|target| {
1086 serde_json::json!({
1087 "id": target.id,
1088 "title": target.title,
1089 "url": safe_browser_url(&target.url),
1090 })
1091 });
1092 serde_json::json!({
1093 "schemaVersion": "glass.agent-context.v1",
1094 "browser": {
1095 "attached": state.connection == glass_browser::browser_workspace::BrowserConnectionPhase::Connected,
1096 "connection": serde_json::to_value(state.connection).unwrap_or(serde_json::Value::Null),
1097 "targetId": selected_target.as_ref().and_then(|target| target.get("id")).cloned(),
1098 "origin": page_origin(&state.url),
1099 "url": safe_browser_url(&state.url),
1100 "title": state.title,
1101 "browserRevision": state.browser_revision,
1102 "semanticSummary": semantic_summary,
1103 "selectedEntity": selected_entity,
1104 "workflowState": state.workflow,
1105 "inputOwner": serde_json::to_value(state.input_owner).unwrap_or(serde_json::Value::Null),
1106 "freshness": if state.semantic_invalidated { "stale" } else { "current" },
1107 "target": selected_target,
1108 "bootstrap": if state.connection == glass_browser::browser_workspace::BrowserConnectionPhase::Connected {
1109 "attached; observe before acting"
1110 } else {
1111 "detached; call glass.browser.start, then navigate and observe the requested URL"
1112 },
1113 },
1114 "authority": {
1115 "source": "Glass browser workspace",
1116 "mutationLeaseRequired": selected_entity.as_ref().is_some_and(|entity| {
1117 entity.get("actionable").and_then(serde_json::Value::as_bool).unwrap_or(false)
1118 }),
1119 },
1120 "project": {
1121 "root": self.snapshot_root,
1122 },
1123 })
1124 }
1125 pub fn agent_editor_context(&self) -> serde_json::Value {
1131 let buffer = self.focused_buffer();
1132 let focused = buffer.as_ref().map(|buffer| {
1133 let (content, truncated) = bounded_editor_content(&buffer.content);
1134 serde_json::json!({
1135 "path": buffer.path,
1136 "cursor": {
1137 "line": buffer.cursor_line,
1138 "column": buffer.cursor_column,
1139 },
1140 "selection": buffer.selection,
1141 "dirty": buffer.dirty,
1142 "actor": buffer.actor,
1143 "content": content,
1144 "contentTruncated": truncated,
1145 })
1146 });
1147 let project_revision = self
1148 .workspace
1149 .try_lock()
1150 .ok()
1151 .map(|workspace| workspace.project().revision());
1152 let comments = self
1153 .editor_comments
1154 .iter()
1155 .filter(|comment| {
1156 self.focused_editor_path.is_empty() || comment.path == self.focused_editor_path
1157 })
1158 .cloned()
1159 .collect::<Vec<_>>();
1160 let proposals = self
1161 .editor_proposals
1162 .iter()
1163 .filter(|proposal| {
1164 self.focused_editor_path.is_empty() || proposal.path == self.focused_editor_path
1165 })
1166 .cloned()
1167 .collect::<Vec<_>>();
1168 serde_json::json!({
1169 "focusedPath": self.focused_editor_path,
1170 "cursor": {
1171 "line": self.focused_editor_line,
1172 "column": self.focused_editor_column,
1173 },
1174 "dirty": self.focused_editor_dirty,
1175 "projectRevision": project_revision,
1176 "focusedBuffer": focused,
1177 "comments": comments,
1178 "proposals": proposals,
1179 })
1180 }
1181
1182 pub fn browser_chat_header(&self) -> String {
1183 let browser = self.browser_workspace.state();
1184 let page = if browser.url.is_empty() {
1185 "no page".to_string()
1186 } else {
1187 safe_browser_url(&browser.url).unwrap_or_else(|| "no page".into())
1188 };
1189 let title = browser.title.trim();
1190 let include_title = !title.is_empty() && !title.eq_ignore_ascii_case(&page);
1191 let revision = browser
1192 .browser_revision
1193 .map_or_else(|| "—".to_string(), |revision| revision.to_string());
1194 let bootstrap = if browser.connection
1195 == glass_browser::browser_workspace::BrowserConnectionPhase::Connected
1196 {
1197 "observe before acting"
1198 } else {
1199 "ask `open <url>` to attach"
1200 };
1201 let mut header = format!("APP · {}", browser.connection_label());
1202 if include_title {
1203 header.push_str(" · ");
1204 header.push_str(title);
1205 }
1206 header.push_str(&format!(" · {} · rev {} · {}", page, revision, bootstrap));
1207 if let Some(entity) = browser.selected() {
1208 header.push_str(" · selected ");
1209 header.push_str(&entity.name);
1210 }
1211 header
1212 }
1213
1214 pub fn conversation_view(&self) -> String {
1215 let mut conversation = if self.agent_conversation.starts_with("No conversation yet.")
1216 && !self.pending_chat_messages.is_empty()
1217 {
1218 String::new()
1219 } else {
1220 self.agent_conversation.clone()
1221 };
1222 let mut observed = std::collections::BTreeMap::<String, usize>::new();
1223 for message in &self.pending_chat_messages {
1224 if message.state != ChatMessageState::Failed {
1225 let marker = format!("YOU\n{}", message.text);
1226 let seen = observed.entry(message.text.clone()).or_default();
1227 if *seen < conversation.matches(&marker).count() {
1228 *seen += 1;
1229 continue;
1230 }
1231 }
1232 if !conversation.is_empty() {
1233 conversation.push_str("\n\n");
1234 }
1235 conversation.push_str("YOU\n");
1236 conversation.push_str(&message.text);
1237 conversation.push('\n');
1238 match message.state {
1239 ChatMessageState::Sending => conversation.push_str("· sending…"),
1240 ChatMessageState::Sent => {
1241 conversation.push_str("· sent · Glass Agent is thinking…")
1242 }
1243 ChatMessageState::Failed => {
1244 conversation.push_str("× send failed");
1245 if let Some(error) = message.error.as_deref() {
1246 conversation.push_str(": ");
1247 conversation.push_str(error);
1248 }
1249 conversation.push_str(" · press Enter to retry");
1250 }
1251 }
1252 }
1253 conversation
1254 }
1255
1256 fn reconcile_pending_chat(&mut self) {
1257 let conversation = self.agent_conversation.clone();
1258 let mut confirmed = std::collections::BTreeMap::<String, usize>::new();
1259 self.pending_chat_messages.retain(|message| {
1260 if message.state == ChatMessageState::Failed {
1261 return true;
1262 }
1263 let marker = format!("YOU\n{}", message.text);
1264 let observed = conversation.matches(&marker).count();
1265 let seen = confirmed.entry(message.text.clone()).or_default();
1266 if *seen < observed {
1267 *seen += 1;
1268 false
1269 } else {
1270 true
1271 }
1272 });
1273 }
1274 pub fn start_agent_interaction(&mut self) {
1276 if self.snapshot_trust_label == "untrusted" {
1277 self.surface = DevSurface::Trust;
1278 self.status = "Trust this workspace before starting the Glass Agent · T or 1".into();
1279 return;
1280 }
1281 match crate::pi_runtime::pi_readiness() {
1282 Ok(readiness) if readiness.ready => self.open_composer(),
1283 Ok(readiness)
1284 if readiness.node.state != crate::pi_runtime::PiReadinessState::Ready
1285 || readiness.sdk.state != crate::pi_runtime::PiReadinessState::Ready =>
1286 {
1287 self.request_agent_setup();
1288 }
1289 Ok(_) => {
1290 let _ = self.request_agent_login();
1291 }
1292 Err(error) => {
1293 self.status = format!("Pi readiness unavailable · use :agent setup: {error}");
1294 }
1295 }
1296 }
1297
1298 pub fn cycle_agent_selection(&mut self, delta: i32) {
1302 let agents = match self.workspace.try_lock() {
1303 Ok(mut workspace) => match workspace.agents().list() {
1304 Ok(agents) => agents,
1305 Err(error) => {
1306 self.status = format!("Agent list unavailable: {error}");
1307 return;
1308 }
1309 },
1310 Err(error) => {
1311 self.status = format!("Agent list unavailable: {error}");
1312 return;
1313 }
1314 };
1315 if agents.is_empty() {
1316 self.selected_agent = None;
1317 self.status = "No resident agents · Enter starts the Glass Agent".into();
1318 return;
1319 }
1320 let current = self
1321 .selected_agent
1322 .as_ref()
1323 .and_then(|selected| agents.iter().position(|agent| &agent.id == selected))
1324 .unwrap_or(0);
1325 let next = if delta.is_negative() {
1326 (current + agents.len() - (delta.unsigned_abs() as usize % agents.len())) % agents.len()
1327 } else {
1328 (current + (delta as usize % agents.len())) % agents.len()
1329 };
1330 let selected = agents[next].id.clone();
1331 self.selected_agent = Some(selected.clone());
1332 self.status = format!(
1333 "Selected {} · Enter chats · ]/[ switches agent",
1334 selected.as_str()
1335 );
1336 }
1337
1338 pub fn open_composer(&mut self) {
1339 self.composer_mode = true;
1340 self.composer_cursor = self.composer_input.len();
1341 self.status = "Agent composer · Enter sends · draft stays open · Esc cancels".into();
1342 }
1343 pub fn prepare_editor_agent_prompt(&mut self) {
1346 let Some(buffer) = self.focused_buffer() else {
1347 self.status = "No open buffer · open a file before asking Pi".into();
1348 return;
1349 };
1350 let line = buffer
1351 .content
1352 .lines()
1353 .nth(buffer.cursor_line.saturating_sub(1) as usize)
1354 .unwrap_or_default()
1355 .trim();
1356 let line_preview = line.chars().take(240).collect::<String>();
1357 self.composer_input = format!(
1358 "Help me with {}:{}:{}.\nInspect the attached editor buffer and explain the safest minimal change. Current line: `{line_preview}`. Do not edit files until I approve a concrete proposal.",
1359 buffer.path, buffer.cursor_line, buffer.cursor_column
1360 );
1361 self.composer_cursor = self.composer_input.len();
1362 self.composer_steer = false;
1363 self.code_edit_mode = false;
1364 self.editor_exit_prompt = None;
1365 self.surface = DevSurface::Agent;
1366 self.open_composer();
1367 self.status = format!(
1368 "Editor context attached · {}:{} · review the prompt, then press Enter",
1369 buffer.path, buffer.cursor_line
1370 );
1371 }
1372
1373 pub fn prepare_review_prompt(&mut self) {
1375 self.composer_input = "Review the current workspace changes. Inspect the Git diff, changed files, diagnostics, and latest test results. Report concrete correctness, security, regression, and missing-test risks. Do not edit files until I approve a fix.".into();
1376 self.composer_cursor = self.composer_input.len();
1377 self.composer_steer = false;
1378 self.open_composer();
1379 self.status =
1380 "Review prompt ready · edit it, then press Enter to ask the Glass Agent".into();
1381 }
1382
1383 pub fn toggle_composer_steer(&mut self) {
1384 self.composer_steer = !self.composer_steer;
1385 self.status = if self.composer_steer {
1386 "Steer mode · Enter interrupts the running agent".into()
1387 } else {
1388 "Follow-up mode · Enter sends during or after the current turn".into()
1389 };
1390 }
1391
1392 pub fn request_agent_setup(&mut self) {
1395 self.request_agent_setup_mode(false);
1396 }
1397
1398 pub fn request_agent_update(&mut self) {
1400 self.request_agent_setup_mode(true);
1401 }
1402
1403 fn request_agent_setup_mode(&mut self, update: bool) {
1404 if self.background_action_running() {
1405 self.status = "Another background action is still running".into();
1406 return;
1407 }
1408 let (call, context) = match self.tool_request(
1409 "glass.agent.setup",
1410 serde_json::json!({"login": false, "update": update}),
1411 true,
1412 ) {
1413 Ok(request) => request,
1414 Err(error) => {
1415 self.status = if update {
1416 format!("Pi update unavailable: {error}")
1417 } else {
1418 format!("Pi setup unavailable: {error}")
1419 };
1420 return;
1421 }
1422 };
1423 let summary = if update {
1424 "Refresh the pinned managed Pi SDK"
1425 } else {
1426 "Install or repair the pinned managed Pi SDK"
1427 };
1428 let queued = match self.queue_or_confirm(call, context, summary.into()) {
1429 Ok(queued) => queued,
1430 Err(error) => {
1431 self.status = format!("Could not queue Pi setup: {error}");
1432 return;
1433 }
1434 };
1435 self.surface = DevSurface::Agent;
1436 if !queued {
1437 self.status = if update {
1438 "Pi update ready · Enter approves once · Esc cancels".into()
1439 } else {
1440 "Pi setup ready · Enter approves once · Esc cancels".into()
1441 };
1442 }
1443 }
1444
1445 pub fn request_agent_login(&mut self) -> Result<(), String> {
1448 if self.background_action_running() {
1449 let error = "Finish the current background action before signing in".to_string();
1450 self.status = error.clone();
1451 return Err(error);
1452 }
1453 self.agent_login_requested = true;
1454 self.surface = DevSurface::Agent;
1455 self.status = "Pi login will open in this terminal · exit Pi to return".into();
1456 Ok(())
1457 }
1458
1459 pub fn close_composer(&mut self) {
1460 self.composer_mode = false;
1461 self.composer_steer = false;
1462 self.status = "Composer closed".into();
1463 }
1464
1465 pub fn move_composer_cursor(&mut self, right: bool) {
1466 if right {
1467 self.composer_cursor = self.composer_input[self.composer_cursor..]
1468 .char_indices()
1469 .nth(1)
1470 .map(|(offset, _)| self.composer_cursor + offset)
1471 .unwrap_or(self.composer_input.len());
1472 } else if self.composer_cursor > 0 {
1473 self.composer_cursor = self.composer_input[..self.composer_cursor]
1474 .char_indices()
1475 .next_back()
1476 .map(|(index, _)| index)
1477 .unwrap_or(0);
1478 }
1479 }
1480
1481 pub fn delete_composer_word(&mut self) {
1482 let before = self.composer_input[..self.composer_cursor].trim_end();
1483 let start = before.len();
1484 let target = before[..start]
1485 .trim_end_matches(|c: char| c.is_whitespace())
1486 .char_indices()
1487 .rev()
1488 .find_map(|(index, character)| character.is_whitespace().then_some(index))
1489 .map(|index| before[..index].trim_end().len())
1490 .unwrap_or(0);
1491 self.composer_input.drain(target..self.composer_cursor);
1492 self.composer_cursor = target;
1493 }
1494
1495 pub fn abort_selected_agent(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
1496 let Some(agent) = self.selected_agent.clone() else {
1497 self.status = "No active agent to abort".into();
1498 return;
1499 };
1500 let (call, context) = match self.tool_request(
1501 "glass.agent.abort",
1502 serde_json::json!({"agentId": agent.as_str()}),
1503 true,
1504 ) {
1505 Ok(request) => request,
1506 Err(error) => {
1507 self.status = format!("Abort unavailable: {error}");
1508 return;
1509 }
1510 };
1511 match worker.submit_tool(call, context) {
1512 Ok(id) => {
1513 self.running_tool_job = Some(id);
1514 self.status = format!("Stopping {} in background…", agent.as_str());
1515 }
1516 Err(error) => self.status = format!("Abort unavailable: {error}"),
1517 }
1518 }
1519
1520 pub fn insert_composer_text(&mut self, text: &str) {
1521 for character in text.chars().take(16_384) {
1522 self.composer_input.insert(self.composer_cursor, character);
1523 self.composer_cursor += character.len_utf8();
1524 }
1525 }
1526
1527 pub fn composer_backspace(&mut self) {
1528 if self.composer_cursor == 0 {
1529 return;
1530 }
1531 let previous = self.composer_input[..self.composer_cursor]
1532 .char_indices()
1533 .next_back()
1534 .map(|(index, _)| index)
1535 .unwrap_or(0);
1536 self.composer_input.drain(previous..self.composer_cursor);
1537 self.composer_cursor = previous;
1538 }
1539
1540 pub fn submit_composer(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
1541 if self.background_action_running() {
1542 self.status = if self.agent_send_job.is_some() {
1543 "Sending the previous message · keep typing, then press Enter again".into()
1544 } else {
1545 "Background operation running · message kept in composer".into()
1546 };
1547 return;
1548 }
1549 if self.snapshot_trust_label == "untrusted" {
1550 self.composer_mode = false;
1551 self.surface = DevSurface::Trust;
1552 self.status = "Trust this workspace before starting the Glass Agent · T or 1".into();
1553 return;
1554 }
1555 if !self.agent_readiness.starts_with("✓ Ready") {
1556 self.status = "Pi is not ready · use :agent setup or :agent setup login".into();
1557 return;
1558 }
1559 if self.composer_input.trim().is_empty() {
1560 self.status = "Message is empty · type a prompt, then press Enter".into();
1561 return;
1562 }
1563 let display_text = self.composer_input.clone();
1564 let text = std::mem::take(&mut self.composer_input);
1565 let steer = self.composer_steer;
1566 self.composer_cursor = 0;
1567 self.composer_steer = false;
1568 self.composer_mode = true;
1569 let mut context = self.agent_browser_context();
1570 context["editor"] = self.agent_editor_context();
1571 if context["browser"]["selectedEntity"].is_object() {
1572 self.browser_workspace.state_mut().input_owner =
1573 glass_browser::browser_workspace::BrowserInputOwner::Agent;
1574 }
1575 let mut arguments = serde_json::json!({
1576 "text": text,
1577 "mode": if steer { "steer" } else { "follow-up" },
1578 "context": context,
1579 });
1580 if let Some(agent) = self.selected_agent.as_ref() {
1581 arguments["agentId"] = serde_json::Value::String(agent.as_str().to_string());
1582 }
1583 let (call, context) = match self.tool_request("glass.agent.send", arguments, true) {
1584 Ok(request) => request,
1585 Err(error) => {
1586 self.composer_input = display_text;
1587 self.composer_cursor = self.composer_input.len();
1588 self.status = format!("Message unavailable · edit and retry: {error}");
1589 return;
1590 }
1591 };
1592 match worker.submit_tool(call, context) {
1593 Ok(id) => {
1594 self.agent_send_job = Some(id);
1595 self.pending_chat_messages.push(PendingChatMessage {
1596 text: display_text,
1597 state: ChatMessageState::Sending,
1598 job_id: Some(id),
1599 error: None,
1600 });
1601 self.status = if steer {
1602 "Sent · steering Glass Agent…".into()
1603 } else {
1604 "Sent · Glass Agent is thinking…".into()
1605 };
1606 worker.request_conversation();
1607 }
1608 Err(error) => {
1609 self.composer_input = display_text;
1610 self.composer_cursor = self.composer_input.len();
1611 self.status = format!("Message unavailable · edit and retry: {error}");
1612 }
1613 }
1614 }
1615
1616 pub fn approve_confirmation_async(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
1617 let Some(pending) = self.pending_confirmation.take() else {
1618 return;
1619 };
1620 match worker.submit_tool(pending.call, pending.context) {
1621 Ok(id) => {
1622 self.running_tool_job = Some(id);
1623 self.status = format!(
1624 "Running {} · Esc keeps the workspace responsive",
1625 pending.summary
1626 );
1627 }
1628 Err(error) => self.status = format!("Could not queue mutation: {error}"),
1629 }
1630 }
1631
1632 pub fn resolve_agent_approval(
1633 &mut self,
1634 approved: bool,
1635 worker: &mut super::snapshot::SnapshotWorker,
1636 ) {
1637 let Some(pending) = self.pending_agent_approval.take() else {
1638 return;
1639 };
1640 let arguments = serde_json::json!({
1641 "agentId": pending.agent_id,
1642 "frameId": pending.frame_id,
1643 "approved": approved,
1644 });
1645 let (call, context) = match self.tool_request("glass.agent.approve", arguments, true) {
1646 Ok(request) => request,
1647 Err(error) => {
1648 self.pending_agent_approval = Some(pending);
1649 self.status = format!("Agent approval unavailable: {error}");
1650 return;
1651 }
1652 };
1653 match worker.submit_tool(call, context) {
1654 Ok(id) => {
1655 self.running_tool_job = Some(id);
1656 self.status = if approved {
1657 format!("Approved {} · Glass Agent continues…", pending.tool_name)
1658 } else {
1659 format!("Denied {} · Glass Agent continues…", pending.tool_name)
1660 };
1661 }
1662 Err(error) => {
1663 self.pending_agent_approval = Some(pending);
1664 self.status = format!("Could not queue agent approval: {error}");
1665 }
1666 }
1667 }
1668
1669 pub fn apply_visual_job_result(&mut self, result: super::snapshot::VisualJobResult) {
1670 self.apply_visual_job_result_with_fit(
1671 result,
1672 glass_browser::terminal_graphics::FrameFit::Contain,
1673 );
1674 }
1675
1676 pub fn apply_visual_job_result_with_fit(
1677 &mut self,
1678 result: super::snapshot::VisualJobResult,
1679 fit: glass_browser::terminal_graphics::FrameFit,
1680 ) {
1681 let png = match result.result {
1682 Ok(value) => {
1683 let Some(encoded) = value.get("base64").and_then(serde_json::Value::as_str) else {
1684 self.browser_visual_live = false;
1685 self.browser_workspace.state_mut().presentation_reason =
1686 Some("screenshot payload did not contain base64 PNG data".into());
1687 self.status = "Live view unavailable · screenshot payload was empty".into();
1688 return;
1689 };
1690 use base64::Engine as _;
1691 match base64::engine::general_purpose::STANDARD.decode(encoded) {
1692 Ok(png) => png,
1693 Err(error) => {
1694 self.browser_visual_live = false;
1695 self.browser_workspace.state_mut().presentation_reason =
1696 Some(format!("screenshot payload was not valid base64: {error}"));
1697 self.status = "Live view unavailable · invalid screenshot payload".into();
1698 return;
1699 }
1700 }
1701 }
1702 Err(error) => {
1703 self.browser_visual_live = false;
1704 self.browser_workspace.state_mut().presentation_reason =
1705 Some(format!("browser screenshot failed: {error}"));
1706 self.status = format!("Live view unavailable · {error}");
1707 return;
1708 }
1709 };
1710 match AnsiPane::from_png(
1711 &mut self.browser_ansi,
1712 &png,
1713 result.columns.clamp(8, 80),
1714 result.rows.clamp(4, 40),
1715 fit,
1716 ) {
1717 Ok(pane) => {
1718 self.browser_pane = Some(pane);
1719 let browser = self.browser_workspace.state_mut();
1720 browser.presentation =
1721 glass_browser::browser_workspace::BrowserPresentationPath::Ansi;
1722 browser.frame_revision = browser.browser_revision;
1723 browser.presentation_reason = Some(
1724 "bounded ANSI half-block frame · semantic controls remain authoritative".into(),
1725 );
1726 self.status = "Live view updated · ANSI half-block".into();
1727 }
1728 Err(error) => {
1729 self.browser_visual_live = false;
1730 self.browser_workspace.state_mut().presentation_reason = Some(error.to_string());
1731 self.status = format!("Live view unavailable: {error}");
1732 }
1733 }
1734 }
1735
1736 pub fn queue_tool_request(
1737 &mut self,
1738 call: crate::development::ToolCall,
1739 context: crate::tools::DevelopmentToolContext,
1740 ) -> Result<(), String> {
1741 if self.background_action_running() {
1742 return Err("another background tool is already running".into());
1743 }
1744 self.queued_tool_request = Some((call, context));
1745 Ok(())
1746 }
1747 pub(super) fn queue_or_confirm(
1748 &mut self,
1749 call: crate::development::ToolCall,
1750 context: crate::tools::DevelopmentToolContext,
1751 summary: String,
1752 ) -> Result<bool, String> {
1753 if self.yolo_mode {
1754 self.queue_tool_request(call, context)?;
1755 self.status = format!("YOLO · {summary} queued");
1756 Ok(true)
1757 } else {
1758 self.pending_confirmation = Some(PendingConfirmation {
1759 call,
1760 context,
1761 summary,
1762 });
1763 Ok(false)
1764 }
1765 }
1766
1767 pub fn submit_queued_tool(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
1768 let Some((call, context)) = self.queued_tool_request.take() else {
1769 return;
1770 };
1771 match worker.submit_tool(call, context) {
1772 Ok(id) => {
1773 self.running_tool_job = Some(id);
1774 self.status.push_str(" · running in background");
1775 }
1776 Err(error) => self.status = format!("Could not queue tool: {error}"),
1777 }
1778 }
1779
1780 pub fn apply_tool_job_result(&mut self, result: super::snapshot::ToolJobResult) {
1781 if result.tool == "glass.agent.send" && self.agent_send_job == Some(result.id) {
1782 self.agent_send_job = None;
1783 match result.result {
1784 Ok(value) => {
1785 let agent = value
1786 .get("agentId")
1787 .and_then(serde_json::Value::as_str)
1788 .and_then(|value| crate::AgentId::parse(value).ok());
1789 let restarted = value
1790 .get("restarted")
1791 .and_then(serde_json::Value::as_bool)
1792 .unwrap_or(false);
1793 if let Some(agent_id) = agent {
1794 self.selected_agent = Some(agent_id.clone());
1795 self.status = if restarted {
1796 format!("Restarted {} · Glass Agent is thinking…", agent_id.as_str())
1797 } else {
1798 format!("Sent to {} · Glass Agent is thinking…", agent_id.as_str())
1799 };
1800 } else {
1801 self.status = if restarted {
1802 "Restarted Glass Agent · thinking…".into()
1803 } else {
1804 "Sent · Glass Agent is thinking…".into()
1805 };
1806 }
1807 if let Some(message) = self
1808 .pending_chat_messages
1809 .iter_mut()
1810 .find(|message| message.job_id == Some(result.id))
1811 {
1812 message.state = ChatMessageState::Sent;
1813 message.job_id = None;
1814 }
1815 }
1816 Err(error) => {
1817 let failed_text = self
1818 .pending_chat_messages
1819 .iter_mut()
1820 .find(|message| message.job_id == Some(result.id))
1821 .map(|message| {
1822 message.state = ChatMessageState::Failed;
1823 message.job_id = None;
1824 message.error = Some(error.clone());
1825 message.text.clone()
1826 });
1827 if self.composer_input.is_empty()
1828 && let Some(text) = failed_text
1829 {
1830 self.composer_input = text;
1831 self.composer_cursor = self.composer_input.len();
1832 }
1833 self.composer_mode = true;
1834 self.status = format!("Could not send message · edit and retry: {error}");
1835 }
1836 }
1837 return;
1838 }
1839
1840 if self.running_tool_job != Some(result.id) {
1841 return;
1842 }
1843 self.running_tool_job = None;
1844 match result.result {
1845 Ok(value) => {
1846 if result.tool.starts_with("glass.browser") {
1847 self.apply_browser_result(&result.tool, &value);
1848 self.browser_detail = super::projection::browser_result(&result.tool, &value);
1849 if result.tool == "glass.browser.act" || result.tool == "glass.browser.navigate"
1850 {
1851 self.browser_observe_pending = true;
1852 }
1853 } else if result.tool == "glass.git.diff" {
1854 let empty = value.as_str().is_none_or(|diff| diff.trim().is_empty());
1855 self.git_diff = if empty {
1856 self.git_diff_path
1857 .as_deref()
1858 .map(|path| format!("{path}\n\nNo tracked diff for this file."))
1859 .unwrap_or_else(|| "Working tree clean · no diff to show".into())
1860 } else {
1861 value.as_str().unwrap_or_default().to_string()
1862 };
1863 self.git_diff_open = true;
1864 self.status = self
1865 .git_diff_path
1866 .as_deref()
1867 .map(|path| format!("Git diff · {path} · PgUp/PgDn scroll · Esc closes"))
1868 .unwrap_or_else(|| "Git diff · PgUp/PgDn scroll · Esc closes".into());
1869 } else if result.tool == "glass.agent.setup" {
1870 match self.refresh_agent_readiness() {
1871 Ok(true) => {
1872 self.open_composer();
1873 self.status =
1874 "Pi runtime ready · type a prompt, then press Enter".into();
1875 }
1876 Ok(false) => {
1877 self.status =
1878 "Pi runtime installed · use :agent setup login, then Enter to chat"
1879 .into();
1880 }
1881 Err(error) => self.status = format!("Pi readiness check failed: {error}"),
1882 }
1883 } else if result.tool == "glass.agent.send" {
1884 if let Some(agent_id) = value
1885 .get("agentId")
1886 .and_then(serde_json::Value::as_str)
1887 .and_then(|value| crate::AgentId::parse(value).ok())
1888 {
1889 self.selected_agent = Some(agent_id.clone());
1890 self.status =
1891 format!("Sent to {} · Glass Agent is thinking…", agent_id.as_str());
1892 } else {
1893 self.status = "Sent · Glass Agent is thinking…".into();
1894 }
1895 } else if result.tool == "glass.agent.delegate" {
1896 self.surface = DevSurface::Agent;
1897 let harness = value
1898 .get("harness")
1899 .and_then(serde_json::Value::as_str)
1900 .unwrap_or("external harness");
1901 let outcome = if value.get("success").and_then(serde_json::Value::as_bool)
1902 == Some(true)
1903 {
1904 "completed"
1905 } else if value.get("timedOut").and_then(serde_json::Value::as_bool)
1906 == Some(true)
1907 {
1908 "timed out"
1909 } else {
1910 "failed"
1911 };
1912 let detail = super::projection::external_agent_output(&value);
1913 self.status = format!("Temporary {harness} {outcome} · {detail}");
1914 } else if result.tool == "glass.github.review" {
1915 match serde_json::from_value::<crate::github::GitHubReview>(value) {
1916 Ok(review) => {
1917 self.github = crate::github::GitHubStatus {
1918 repository: review.repository.clone(),
1919 availability: review.availability,
1920 };
1921 self.github_review = review.display();
1922 self.surface = DevSurface::Git;
1923 self.status = "GitHub review refreshed".into();
1924 }
1925 Err(error) => {
1926 self.status = format!("GitHub review response invalid: {error}");
1927 }
1928 }
1929 } else if result.tool == "glass.github.ship" {
1930 self.surface = DevSurface::Git;
1931 self.status = value
1932 .get("url")
1933 .and_then(serde_json::Value::as_str)
1934 .map(|url| format!("Pull request created · {url}"))
1935 .unwrap_or_else(|| "Pull request created · review GitHub status".into());
1936 } else if result.tool.starts_with("glass.lsp") {
1937 self.editor = if result.tool == "glass.lsp.diagnostics" {
1938 super::projection::lsp(Some(&value))
1939 } else {
1940 super::projection::first_meaningful(&value)
1941 };
1942 }
1943 if !matches!(
1944 result.tool.as_str(),
1945 "glass.agent.send"
1946 | "glass.agent.setup"
1947 | "glass.agent.delegate"
1948 | "glass.git.diff"
1949 | "glass.github.review"
1950 | "glass.github.ship"
1951 ) {
1952 self.status = format!("Completed {} · workspace refreshed", result.tool);
1953 }
1954 }
1955 Err(error) => {
1956 if result.tool.starts_with("glass.browser") {
1957 self.note_browser_failure(&result.tool, &error);
1958 }
1959 if result.tool == "glass.git.diff" {
1960 self.git_diff = format!("Git diff unavailable: {error}");
1961 self.git_diff_open = true;
1962 }
1963 self.status = format!("{} failed: {error}", result.tool);
1964 }
1965 }
1966 }
1967
1968 pub fn deny_confirmation(&mut self) {
1969 self.pending_browser_navigation = None;
1970 if let Some(pending) = self.pending_confirmation.take() {
1971 self.status = format!("Denied · {}", pending.summary);
1972 }
1973 }
1974
1975 pub fn prepare_browser_navigation(&mut self, url: &str) -> Result<String, String> {
1977 if self.background_action_running() {
1978 return Err("another browser action is already awaiting or running".into());
1979 }
1980 if self.browser_workspace.state().connection == BrowserConnectionPhase::Connected {
1981 let (call, context) =
1982 self.tool_request("glass.browser.observe", serde_json::json!({}), false)?;
1983 self.pending_browser_navigation = Some(url.to_string());
1984 self.queued_tool_request = Some((call, context));
1985 self.surface = DevSurface::App;
1986 return Ok("Browser connected · refreshing page before navigation".into());
1987 }
1988 let (call, context) =
1989 self.tool_request("glass.browser.start", serde_json::json!({}), true)?;
1990 self.pending_browser_navigation = Some(url.to_string());
1991 let queued = self.queue_or_confirm(
1992 call,
1993 context,
1994 format!("Start browser before navigating to {url}"),
1995 )?;
1996 self.surface = DevSurface::App;
1997 Ok(if queued {
1998 "Browser detached · launching; navigation continues automatically".into()
1999 } else {
2000 "Browser detached · Enter approves launch; navigation continues automatically".into()
2001 })
2002 }
2003
2004 pub fn handle_printable(&mut self, character: char) {
2005 if character == ':' {
2006 self.open_palette();
2007 return;
2008 }
2009 if character == 'a' && self.surface != DevSurface::Agent {
2010 self.open_menu();
2011 return;
2012 }
2013 if self.surface == DevSurface::Trust {
2014 let decision = match character {
2015 'i' | 'I' => {
2016 self.status = "Inspecting exact repository configuration".into();
2017 return;
2018 }
2019 'o' | 'O' => Some(crate::LocalTrustDecision::OpenUntrusted),
2020 '1' => Some(crate::LocalTrustDecision::TrustOnce),
2021 'T' => Some(crate::LocalTrustDecision::TrustProject),
2022 _ => None,
2023 };
2024 if let Some(decision) = decision {
2025 match self
2026 .workspace
2027 .try_lock()
2028 .and_then(|mut workspace| workspace.apply_local_trust_decision(decision))
2029 {
2030 Ok(trust) => {
2031 self.surface = DevSurface::Agent;
2032 self.snapshot_trust_label = trust.label().into();
2033 self.status = format!("Workspace opened with {} authority", trust.label());
2034 }
2035 Err(error) => self.status = format!("Trust decision failed: {error}"),
2036 }
2037 return;
2038 }
2039 }
2040 if self.surface == DevSurface::Agent && self.snapshot_trust_label == "untrusted" {
2041 let decision = match character {
2042 't' => Some(crate::LocalTrustDecision::TrustOnce),
2043 'T' => Some(crate::LocalTrustDecision::TrustProject),
2044 _ => None,
2045 };
2046 if let Some(decision) = decision {
2047 match self
2048 .workspace
2049 .try_lock()
2050 .and_then(|mut workspace| workspace.apply_local_trust_decision(decision))
2051 {
2052 Ok(trust) => {
2053 self.snapshot_trust_label = trust.label().into();
2054 self.status = format!("Workspace opened with {} authority", trust.label());
2055 }
2056 Err(error) => self.status = format!("Trust decision failed: {error}"),
2057 }
2058 return;
2059 }
2060 }
2061
2062 if self.surface == DevSurface::Agent
2065 && self.snapshot_trust_label != "untrusted"
2066 && !character.is_ascii_digit()
2067 {
2068 if self.agent_readiness.starts_with("✓ Ready") {
2069 self.open_composer();
2070 } else {
2071 self.start_agent_interaction();
2072 }
2073 if self.composer_mode {
2074 self.insert_composer_text(&character.to_string());
2075 }
2076 return;
2077 }
2078
2079 if self.surface == DevSurface::Code && character == 'i' {
2080 self.enter_code_edit();
2081 return;
2082 }
2083 if self.responsive_class(self.terminal_width, self.terminal_height)
2084 == ResponsiveClass::Phone
2085 {
2086 let surface = match character {
2087 '1' => Some(DevSurface::Agent),
2088 '2' => Some(DevSurface::Code),
2089 '3' => Some(DevSurface::App),
2090 '4' => Some(DevSurface::Tasks),
2091 '5' => Some(DevSurface::More),
2092 _ => None,
2093 };
2094 if let Some(surface) = surface {
2095 self.surface = surface;
2096 self.status = format!("{} selected", surface.label());
2097 return;
2098 }
2099 }
2100 let surface = match character {
2101 '1' => Some(DevSurface::Agent),
2102 '2' | 'c' => Some(DevSurface::Code),
2103 '3' | 'v' => Some(DevSurface::App),
2104 '4' => Some(DevSurface::Terminal),
2105 '5' | 'w' => Some(DevSurface::Tasks),
2106 '6' | 'g' => Some(DevSurface::Git),
2107 '7' | 'd' => Some(DevSurface::Debug),
2108 '8' | 'm' => Some(DevSurface::More),
2109 _ => None,
2110 };
2111 if let Some(surface) = surface {
2112 self.surface = surface;
2113 self.status = format!("{} selected", surface.label());
2114 } else if self.surface == DevSurface::Agent && self.snapshot_trust_label != "untrusted" {
2115 self.open_composer();
2116 self.insert_composer_text(&character.to_string());
2117 }
2118 }
2119 pub fn request_detected_dev(&mut self) {
2122 if self.background_action_running() {
2123 self.status = "Another background action is still running".into();
2124 return;
2125 }
2126 let command_result = {
2127 match self.ws() {
2128 Ok(workspace) => workspace
2129 .project()
2130 .detection()
2131 .dev_command
2132 .clone()
2133 .ok_or_else(|| "no detected dev command".to_string()),
2134 Err(error) => Err(error),
2135 }
2136 };
2137 let command = match command_result {
2138 Ok(command) => command,
2139 Err(error) if error == "no detected dev command" => {
2140 self.status =
2141 "No development command detected · use :process start NAME COMMAND".into();
2142 return;
2143 }
2144 Err(error) => {
2145 self.status = if error.to_string().contains("workspace busy") {
2146 "Development suite unavailable: workspace refresh is still running · use :s again"
2147 .into()
2148 } else {
2149 format!("Development command unavailable: {error}")
2150 };
2151 return;
2152 }
2153 };
2154 let (call, context) = match self.tool_request(
2155 "glass.process.start",
2156 serde_json::json!({"name": "dev", "command": command}),
2157 true,
2158 ) {
2159 Ok(request) => request,
2160 Err(error) => {
2161 self.status = format!("Development suite unavailable: {error}");
2162 return;
2163 }
2164 };
2165 let queued = match self.queue_or_confirm(
2166 call,
2167 context,
2168 "Start the detected development suite".into(),
2169 ) {
2170 Ok(queued) => queued,
2171 Err(error) => {
2172 self.status = format!("Development suite unavailable: {error}");
2173 return;
2174 }
2175 };
2176 self.surface = DevSurface::Terminal;
2177 if !queued {
2178 self.status = "Development suite ready · Enter approves once · Esc cancels".into();
2179 }
2180 }
2181
2182 pub fn next_surface(&mut self) {
2183 let surfaces: &[DevSurface] = if self
2184 .responsive_class(self.terminal_width, self.terminal_height)
2185 == ResponsiveClass::Phone
2186 {
2187 &DevSurface::PHONE
2188 } else {
2189 &DevSurface::PRIMARY
2190 };
2191 let index = surfaces
2192 .iter()
2193 .position(|surface| *surface == self.surface)
2194 .unwrap_or(0);
2195 self.surface = surfaces[(index + 1) % surfaces.len()];
2196 self.status = format!("{} selected", self.surface.label());
2197 }
2198
2199 pub fn scroll_surface(&mut self, delta: i32) {
2200 let scroll = self.surface_scroll.entry(self.surface).or_default();
2201 *scroll = (*scroll as i64 + i64::from(delta)).max(0) as usize;
2202 }
2203
2204 pub fn scroll_home(&mut self) {
2205 self.surface_scroll.insert(self.surface, 0);
2206 }
2207
2208 pub fn scroll_end(&mut self) {
2209 let end = self.surface_content_height().saturating_sub(1);
2210 self.surface_scroll.insert(self.surface, end);
2211 }
2212
2213 fn surface_content_height(&self) -> usize {
2215 if self.surface == DevSurface::Agent {
2216 return self.conversation_view().lines().count().max(1);
2217 }
2218 let content = match self.surface {
2219 DevSurface::Code => &self.editor,
2220 DevSurface::App => &self.browser,
2221 DevSurface::Terminal => &self.processes,
2222 DevSurface::Tasks => &self.tasks,
2223 DevSurface::Git => &self.git,
2224 DevSurface::Debug => &self.debugger,
2225 DevSurface::More | DevSurface::Trust => &self.workspace_status,
2226 DevSurface::Agent => unreachable!("agent content handled above"),
2227 };
2228 content.lines().count().max(1)
2229 }
2230
2231 pub fn current_scroll(&self) -> u16 {
2232 self.surface_scroll
2233 .get(&self.surface)
2234 .copied()
2235 .unwrap_or(0)
2236 .min(u16::MAX as usize) as u16
2237 }
2238
2239 pub fn move_file_selection(&mut self, delta: i32) {
2240 if self.files.is_empty() {
2241 self.selected_file = 0;
2242 return;
2243 }
2244 self.selected_file = (self.selected_file as i32 + delta)
2245 .clamp(0, self.files.len().saturating_sub(1) as i32)
2246 as usize;
2247 }
2248 pub fn move_git_selection(&mut self, delta: i32) {
2249 if self.git_entries.is_empty() {
2250 self.selected_git_file = 0;
2251 self.status = "No changed files selected".into();
2252 return;
2253 }
2254 self.selected_git_file = (self.selected_git_file as i32 + delta)
2255 .clamp(0, self.git_entries.len().saturating_sub(1) as i32)
2256 as usize;
2257 if let Some(entry) = self.git_entries.get(self.selected_git_file) {
2258 self.status = format!("{} · Enter diff", entry.path);
2259 }
2260 }
2261
2262 pub fn selected_git_entry(&self) -> Option<&crate::git::GitStatusEntry> {
2263 self.git_entries.get(self.selected_git_file)
2264 }
2265
2266 pub fn open_selected_file(&mut self) {
2267 let Some(path) = self.files.get(self.selected_file).cloned() else {
2268 self.status = "No project file selected".into();
2269 return;
2270 };
2271 let already_open = self
2272 .workspace
2273 .try_lock()
2274 .map(|workspace| workspace.project().buffer(&path).is_some())
2275 .unwrap_or(false);
2276 let result = if already_open {
2277 Ok(())
2278 } else {
2279 self.workspace.try_lock().and_then(|mut workspace| {
2280 workspace
2281 .project_mut()
2282 .open_buffer(&path, crate::development::Actor::local())
2283 .map(|_| ())
2284 })
2285 };
2286 match result {
2287 Ok(()) => {
2288 self.editor_buffer_index = self
2289 .workspace
2290 .try_lock()
2291 .ok()
2292 .and_then(|workspace| {
2293 workspace
2294 .project()
2295 .buffers()
2296 .position(|buffer| buffer.path == path)
2297 })
2298 .unwrap_or(0);
2299 self.refresh_editor_projection();
2300 self.status = if already_open {
2301 format!("Selected {path} · Enter opens the full-screen editor")
2302 } else {
2303 format!("Opened {path} · Enter opens the full-screen editor")
2304 };
2305 }
2306 Err(error) => self.status = format!("Open failed: {error}"),
2307 }
2308 }
2309
2310 pub fn open_selected_file_for_edit(&mut self) {
2311 let selected_path = self.files.get(self.selected_file).cloned();
2312 self.open_selected_file();
2313 if selected_path.as_deref() == Some(self.focused_editor_path.as_str()) {
2314 self.surface = DevSurface::Code;
2315 self.enter_code_edit();
2316 }
2317 }
2318
2319 pub fn queue_git_diff(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
2321 if self.background_action_running() {
2322 self.status = "Git diff waits for the current background operation".into();
2323 return;
2324 }
2325 let selected = self.selected_git_entry().map(|entry| {
2326 (
2327 entry.path.clone(),
2328 entry.untracked,
2329 entry.index_status,
2330 entry.worktree_status,
2331 )
2332 });
2333 if let Some((path, true, _, _)) = selected.as_ref() {
2334 self.git_diff_path = Some(path.clone());
2335 self.git_diff = format!(
2336 "{path}\n\nUntracked file · Git has no tracked diff yet.\nUse Enter on Code to inspect the file."
2337 );
2338 self.git_diff_open = true;
2339 self.surface_scroll.insert(DevSurface::Git, 0);
2340 self.status = format!("{path} is untracked · no Git diff to show");
2341 return;
2342 }
2343 let staged = selected
2344 .as_ref()
2345 .is_some_and(|(_, _, index, worktree)| *index != ' ' && *worktree == ' ');
2346 let mut arguments = serde_json::json!({"staged": staged});
2347 if let Some((path, _, _, _)) = selected.as_ref() {
2348 arguments["path"] = serde_json::Value::String(path.clone());
2349 }
2350 let (call, context) = match self.tool_request("glass.git.diff", arguments, false) {
2351 Ok(request) => request,
2352 Err(error) => {
2353 self.status = format!("Git diff unavailable: {error}");
2354 return;
2355 }
2356 };
2357 match worker.submit_tool(call, context) {
2358 Ok(id) => {
2359 self.running_tool_job = Some(id);
2360 self.git_diff_path = selected.map(|(path, _, _, _)| path);
2361 self.git_diff_open = true;
2362 self.surface_scroll.insert(DevSurface::Git, 0);
2363 self.git_diff = "Loading Git diff…".into();
2364 self.status = self
2365 .git_diff_path
2366 .as_deref()
2367 .map(|path| format!("Loading diff for {path} in background…"))
2368 .unwrap_or_else(|| "Loading full worktree diff in background…".into());
2369 }
2370 Err(error) => self.status = format!("Git diff unavailable: {error}"),
2371 }
2372 }
2373
2374 pub fn open_git_diff(&mut self) {
2376 let diff = self.workspace.try_lock().and_then(|workspace| {
2377 workspace
2378 .git()
2379 .ok_or_else(|| {
2380 crate::development::DevelopmentError::NotFound("not a Git repository".into())
2381 })?
2382 .diff(false, None)
2383 .map_err(|error| crate::development::DevelopmentError::Process(error.to_string()))
2384 });
2385 self.git_diff_path = None;
2386 match diff {
2387 Ok(diff) if diff.trim().is_empty() => {
2388 self.git_diff = "Working tree clean · no diff to show".into();
2389 self.git_diff_open = true;
2390 self.surface_scroll.insert(DevSurface::Git, 0);
2391 self.status = "Git diff · no changes".into();
2392 }
2393 Ok(diff) => {
2394 self.git_diff = diff;
2395 self.git_diff_open = true;
2396 self.surface_scroll.insert(DevSurface::Git, 0);
2397 self.status = "Git diff · PgUp/PgDn scroll · Esc closes".into();
2398 }
2399 Err(error) => self.status = format!("Git diff unavailable: {error}"),
2400 }
2401 }
2402
2403 pub fn close_git_diff(&mut self) {
2404 self.git_diff_open = false;
2405 self.git_diff_requested = false;
2406 self.git_diff_path = None;
2407 self.surface_scroll.insert(DevSurface::Git, 0);
2408 self.status = "Git status · select a file with ↑/↓".into();
2409 }
2410
2411 pub fn focused_buffer(&self) -> Option<crate::development::EditorBuffer> {
2412 self.workspace.try_lock().ok().and_then(|workspace| {
2413 workspace
2414 .project()
2415 .buffers()
2416 .nth(self.editor_buffer_index)
2417 .cloned()
2418 })
2419 }
2420
2421 pub fn refresh_editor_projection(&mut self) {
2422 let (buffers, comments, proposals, checkpoints) = self
2423 .workspace
2424 .lock()
2425 .map(|workspace| {
2426 (
2427 workspace.project().buffers().cloned().collect::<Vec<_>>(),
2428 workspace.project().editor_comments(None),
2429 workspace.project().editor_proposals(),
2430 workspace.project().editor_checkpoints(),
2431 )
2432 })
2433 .unwrap_or_default();
2434 self.editor_comments = comments;
2435 self.editor_proposals = proposals;
2436 self.editor_checkpoints = checkpoints;
2437 if let Some(buffer) = buffers.get(self.editor_buffer_index) {
2438 self.focused_editor_path = buffer.path.clone();
2439 self.focused_editor_content = buffer.content.clone();
2440 self.focused_editor_dirty = buffer.dirty;
2441 self.focused_editor_line = buffer.cursor_line;
2442 self.focused_editor_column = buffer.cursor_column;
2443 self.focused_editor_selection = buffer.selection.clone();
2444 self.ensure_editor_cursor_visible();
2445 } else {
2446 self.focused_editor_path.clear();
2447 self.focused_editor_content.clear();
2448 self.focused_editor_dirty = false;
2449 self.focused_editor_line = 0;
2450 self.focused_editor_column = 0;
2451 self.focused_editor_selection = None;
2452 self.editor_scroll_line = 0;
2453 self.editor_scroll_column = 0;
2454 }
2455 self.editor = format_editor_buffers(&buffers);
2456 }
2457
2458 pub fn editor_collaboration_summary(&self) -> String {
2459 let open_comments = self
2460 .editor_comments
2461 .iter()
2462 .filter(|comment| comment.state == crate::development::EditorCommentState::Open)
2463 .count();
2464 let pending = self
2465 .editor_proposals
2466 .iter()
2467 .filter(|proposal| proposal.state == crate::development::EditorProposalState::Pending)
2468 .count();
2469 format!(
2470 "comments {} open · proposals {} pending · checkpoints {}",
2471 open_comments,
2472 pending,
2473 self.editor_checkpoints.len()
2474 )
2475 }
2476
2477 pub fn cycle_editor_buffer(&mut self, delta: i32) {
2478 let count = self
2479 .workspace
2480 .lock()
2481 .map(|workspace| workspace.project().buffers().count())
2482 .unwrap_or(0);
2483 if count == 0 {
2484 self.status = "No open buffers · open a file from the list".into();
2485 return;
2486 }
2487 let index = self.editor_buffer_index as i32 + delta;
2488 self.editor_buffer_index = index.rem_euclid(count as i32) as usize;
2489 let name = self
2490 .workspace
2491 .lock()
2492 .ok()
2493 .and_then(|workspace| {
2494 workspace
2495 .project()
2496 .buffers()
2497 .nth(self.editor_buffer_index)
2498 .map(|buffer| buffer.path.clone())
2499 })
2500 .unwrap_or_default();
2501 self.refresh_editor_projection();
2502 self.status = format!("Buffer {}/{} · {name}", self.editor_buffer_index + 1, count);
2503 }
2504
2505 pub fn enter_code_edit(&mut self) {
2506 let has_buffer = self.focused_buffer().is_some();
2507 if !has_buffer {
2508 self.open_selected_file();
2509 }
2510 if self.focused_buffer().is_some() {
2511 self.surface = DevSurface::Code;
2512 self.code_edit_mode = true;
2513 self.editor_exit_prompt = None;
2514 self.ensure_editor_cursor_visible();
2515 self.status =
2516 "EDITING · arrows move · Shift+arrows select · Ctrl-S save · Alt-A ask Pi · Esc exit"
2517 .into();
2518 }
2519 }
2520
2521 pub fn close_code_edit(&mut self) {
2522 self.code_edit_mode = false;
2523 self.editor_exit_prompt = None;
2524 self.surface = DevSurface::Code;
2525 self.status = "Code navigation · select a file and press Enter to edit".into();
2526 }
2527
2528 pub fn request_editor_exit(&mut self) {
2529 if !self.code_edit_mode {
2530 return;
2531 }
2532 self.refresh_editor_projection();
2533 let prompt = if self.focused_editor_dirty {
2534 EditorExitPrompt::Unsaved
2535 } else {
2536 EditorExitPrompt::Clean
2537 };
2538 self.editor_exit_prompt = Some(prompt);
2539 self.status = match prompt {
2540 EditorExitPrompt::Clean => "Exit editor? Enter leaves · Esc stays".into(),
2541 EditorExitPrompt::Unsaved => {
2542 "Unsaved changes · S save · D discard · Q discard and quit · Esc stays".into()
2543 }
2544 };
2545 }
2546
2547 pub fn cancel_editor_exit(&mut self) {
2548 self.editor_exit_prompt = None;
2549 self.status = "Still editing · Esc opens exit choices".into();
2550 }
2551
2552 pub fn handle_editor_exit_key(&mut self, code: crossterm::event::KeyCode) {
2553 let Some(prompt) = self.editor_exit_prompt else {
2554 return;
2555 };
2556 match prompt {
2557 EditorExitPrompt::Clean => match code {
2558 crossterm::event::KeyCode::Enter
2559 | crossterm::event::KeyCode::Char('q' | 'Q' | 'y' | 'Y') => {
2560 self.close_code_edit();
2561 }
2562 crossterm::event::KeyCode::Esc | crossterm::event::KeyCode::Char('n' | 'N') => {
2563 self.cancel_editor_exit()
2564 }
2565 _ => {}
2566 },
2567 EditorExitPrompt::Unsaved => match code {
2568 crossterm::event::KeyCode::Char('s' | 'S') => match self.save_editor_buffer() {
2569 Ok(()) => {
2570 let path = self.focused_editor_path.clone();
2571 self.refresh_editor_projection();
2572 self.close_code_edit();
2573 self.status = format!("Saved {path} · editor closed");
2574 }
2575 Err(error) => {
2576 self.status =
2577 format!("Save failed: {error} · S retry · D discard · Q quit");
2578 }
2579 },
2580 crossterm::event::KeyCode::Char('d' | 'D') => match self.discard_editor_buffer() {
2581 Ok(()) => {
2582 let path = self.focused_editor_path.clone();
2583 self.refresh_editor_projection();
2584 self.close_code_edit();
2585 self.status = format!("Discarded changes in {path} · editor closed");
2586 }
2587 Err(error) => {
2588 self.status =
2589 format!("Discard failed: {error} · S save · D retry · Q quit");
2590 }
2591 },
2592 crossterm::event::KeyCode::Char('q' | 'Q') => match self.discard_editor_buffer() {
2593 Ok(()) => {
2594 self.code_edit_mode = false;
2595 self.editor_exit_prompt = None;
2596 self.surface = DevSurface::Code;
2597 self.quit = true;
2598 self.status = "Changes discarded · closing Glass Dev".into();
2599 }
2600 Err(error) => {
2601 self.status =
2602 format!("Discard failed: {error} · S save · D retry · Q quit");
2603 }
2604 },
2605 crossterm::event::KeyCode::Esc => self.cancel_editor_exit(),
2606 _ => {}
2607 },
2608 }
2609 }
2610
2611 fn save_editor_buffer(&mut self) -> Result<(), String> {
2612 let path = self.focused_editor_path.clone();
2613 self.workspace
2614 .try_lock()
2615 .map_err(|error| error.to_string())?
2616 .project_mut()
2617 .save_buffer(&path)
2618 .map(|_| ())
2619 .map_err(|error| error.to_string())
2620 }
2621
2622 fn discard_editor_buffer(&mut self) -> Result<(), String> {
2623 let path = self.focused_editor_path.clone();
2624 self.workspace
2625 .try_lock()
2626 .map_err(|error| error.to_string())?
2627 .project_mut()
2628 .open_buffer(&path, crate::development::Actor::local())
2629 .map(|_| ())
2630 .map_err(|error| error.to_string())
2631 }
2632
2633 fn ensure_editor_cursor_visible(&mut self) {
2634 if self.focused_editor_path.is_empty() {
2635 return;
2636 }
2637 let viewport_height = usize::from(self.terminal_height.saturating_sub(8).max(1));
2638 if self.editor_soft_wrap {
2639 let wrapped = super::file_view::render_editable_source_wrapped(
2640 &self.focused_editor_path,
2641 &self.focused_editor_content,
2642 self.focused_editor_line,
2643 self.focused_editor_column,
2644 self.focused_editor_selection.as_ref(),
2645 self.terminal_width.saturating_sub(4).max(1),
2646 );
2647 let Some(cursor) = wrapped.cursor else {
2648 return;
2649 };
2650 self.editor_scroll_column = 0;
2651 if cursor.row < self.editor_scroll_line {
2652 self.editor_scroll_line = cursor.row;
2653 } else if cursor.row >= self.editor_scroll_line + viewport_height {
2654 self.editor_scroll_line = cursor.row + 1 - viewport_height;
2655 }
2656 return;
2657 }
2658 let lines = self.focused_editor_content.split('\n').collect::<Vec<_>>();
2659 let cursor_line = self.focused_editor_line.saturating_sub(1) as usize;
2660 if cursor_line < self.editor_scroll_line {
2661 self.editor_scroll_line = cursor_line;
2662 } else if cursor_line >= self.editor_scroll_line + viewport_height {
2663 self.editor_scroll_line = cursor_line + 1 - viewport_height;
2664 }
2665 let gutter_width = lines.len().max(1).to_string().len().max(3);
2666 let viewport_width = usize::from(
2667 self.terminal_width
2668 .saturating_sub((gutter_width + 8).min(u16::MAX as usize) as u16)
2669 .max(1),
2670 );
2671 let cursor_column = self.focused_editor_column.saturating_sub(1) as usize;
2672 if cursor_column < self.editor_scroll_column {
2673 self.editor_scroll_column = cursor_column;
2674 } else if cursor_column >= self.editor_scroll_column + viewport_width {
2675 self.editor_scroll_column = cursor_column + 1 - viewport_width;
2676 }
2677 }
2678
2679 pub fn toggle_editor_soft_wrap(&mut self) {
2680 self.editor_soft_wrap = !self.editor_soft_wrap;
2681 self.editor_scroll_line = 0;
2682 self.editor_scroll_column = 0;
2683 self.ensure_editor_cursor_visible();
2684 self.status = if self.editor_soft_wrap {
2685 "Soft wrap ON · source lines reflow to the editor width".into()
2686 } else {
2687 "Soft wrap OFF · horizontal scrolling follows source columns".into()
2688 };
2689 }
2690
2691 pub fn edit_code_key(
2692 &mut self,
2693 code: crossterm::event::KeyCode,
2694 modifiers: crossterm::event::KeyModifiers,
2695 ) {
2696 if code == crossterm::event::KeyCode::Char('w')
2697 && modifiers.contains(crossterm::event::KeyModifiers::ALT)
2698 {
2699 self.toggle_editor_soft_wrap();
2700 return;
2701 }
2702 let Some(buffer) = self.focused_buffer() else {
2703 self.status = "No open buffer".into();
2704 return;
2705 };
2706 let path = buffer.path.clone();
2707 let result = match (code, modifiers) {
2708 (crossterm::event::KeyCode::Char('a'), value)
2709 if value.contains(crossterm::event::KeyModifiers::ALT) =>
2710 {
2711 self.prepare_editor_agent_prompt();
2712 Ok(())
2713 }
2714 (crossterm::event::KeyCode::Char('s'), value)
2715 if value.contains(crossterm::event::KeyModifiers::CONTROL) =>
2716 {
2717 self.locked(|workspace| workspace.project_mut().save_buffer(&path).map(|_| ()))
2718 .unwrap_or_else(|| {
2719 Err(crate::development::DevelopmentError::Conflict(
2720 "workspace lock failed".into(),
2721 ))
2722 })
2723 }
2724 (crossterm::event::KeyCode::Char('z'), value)
2725 if value.contains(crossterm::event::KeyModifiers::CONTROL) =>
2726 {
2727 self.locked(|workspace| workspace.project_mut().undo_buffer(&path).map(|_| ()))
2728 .unwrap_or_else(|| {
2729 Err(crate::development::DevelopmentError::Conflict(
2730 "workspace lock failed".into(),
2731 ))
2732 })
2733 }
2734 (crossterm::event::KeyCode::Char('y'), value)
2735 if value.contains(crossterm::event::KeyModifiers::CONTROL) =>
2736 {
2737 self.locked(|workspace| workspace.project_mut().redo_buffer(&path).map(|_| ()))
2738 .unwrap_or_else(|| {
2739 Err(crate::development::DevelopmentError::Conflict(
2740 "workspace lock failed".into(),
2741 ))
2742 })
2743 }
2744 (crossterm::event::KeyCode::Left, value) => self.move_editor_cursor(
2745 &path,
2746 0,
2747 -1,
2748 value.contains(crossterm::event::KeyModifiers::SHIFT),
2749 ),
2750 (crossterm::event::KeyCode::Right, value) => self.move_editor_cursor(
2751 &path,
2752 0,
2753 1,
2754 value.contains(crossterm::event::KeyModifiers::SHIFT),
2755 ),
2756 (crossterm::event::KeyCode::Up, value) => self.move_editor_cursor(
2757 &path,
2758 -1,
2759 0,
2760 value.contains(crossterm::event::KeyModifiers::SHIFT),
2761 ),
2762 (crossterm::event::KeyCode::Down, value) => self.move_editor_cursor(
2763 &path,
2764 1,
2765 0,
2766 value.contains(crossterm::event::KeyModifiers::SHIFT),
2767 ),
2768 (crossterm::event::KeyCode::Enter, _) => self.insert_editor_text(&path, "\n"),
2769 (crossterm::event::KeyCode::Backspace, _) => self.backspace_editor(&path),
2770 (crossterm::event::KeyCode::Char(character), _) => {
2771 self.insert_editor_text(&path, &character.to_string())
2772 }
2773 _ => Ok(()),
2774 };
2775 if let Err(error) = result {
2776 self.status = format!("Editor action failed: {error}");
2777 }
2778 self.refresh_editor_projection();
2779 }
2780
2781 fn move_editor_cursor(
2782 &mut self,
2783 path: &str,
2784 line_delta: i32,
2785 column_delta: i32,
2786 extend_selection: bool,
2787 ) -> crate::development::DevelopmentResult<()> {
2788 let buffer = self
2789 .workspace
2790 .try_lock()?
2791 .project()
2792 .buffer(path)
2793 .cloned()
2794 .ok_or_else(|| {
2795 crate::development::DevelopmentError::NotFound(format!("buffer {path}"))
2796 })?;
2797 let lines = buffer.content.split('\n').collect::<Vec<_>>();
2798 let line =
2799 (buffer.cursor_line as i32 + line_delta).clamp(1, lines.len().max(1) as i32) as u32;
2800 let max_column = lines
2801 .get(line.saturating_sub(1) as usize)
2802 .map(|line| line.chars().count() + 1)
2803 .unwrap_or(1) as u32;
2804 let column = if line_delta != 0 {
2805 buffer.cursor_column.min(max_column)
2806 } else {
2807 (buffer.cursor_column as i32 + column_delta).clamp(1, max_column as i32) as u32
2808 };
2809 let anchor = if extend_selection {
2810 buffer
2811 .selection
2812 .map(|selection| selection.anchor)
2813 .unwrap_or(crate::development::TextPosition {
2814 line: buffer.cursor_line,
2815 column: buffer.cursor_column,
2816 })
2817 } else {
2818 crate::development::TextPosition { line, column }
2819 };
2820 let mut workspace = self.workspace.try_lock()?;
2821 workspace
2822 .project_mut()
2823 .set_buffer_cursor(path, line, column)?;
2824 workspace.project_mut().set_buffer_selection(
2825 path,
2826 extend_selection.then_some(crate::development::TextSelection {
2827 anchor,
2828 active: crate::development::TextPosition { line, column },
2829 }),
2830 crate::development::Actor::local(),
2831 )?;
2832 Ok(())
2833 }
2834
2835 fn insert_editor_text(
2836 &mut self,
2837 path: &str,
2838 text: &str,
2839 ) -> crate::development::DevelopmentResult<()> {
2840 let mut workspace = self.workspace.try_lock()?;
2841 let project = workspace.project_mut();
2842 let buffer = project.buffer(path).cloned().ok_or_else(|| {
2843 crate::development::DevelopmentError::NotFound(format!("buffer {path}"))
2844 })?;
2845 if buffer
2846 .selection
2847 .as_ref()
2848 .is_some_and(|selection| !selection.is_empty())
2849 {
2850 project.replace_buffer_selection(
2851 path,
2852 text.to_string(),
2853 crate::development::Actor::local(),
2854 )?;
2855 return Ok(());
2856 }
2857 let offset = editor_offset(&buffer.content, buffer.cursor_line, buffer.cursor_column);
2858 let mut content = buffer.content;
2859 content.insert_str(offset, text);
2860 let cursor =
2861 crate::development::editor::text_position_at_offset(&content, offset + text.len())
2862 .ok_or_else(|| {
2863 crate::development::DevelopmentError::InvalidInput(
2864 "inserted text ended at an invalid UTF-8 boundary".into(),
2865 )
2866 })?;
2867 let actor = crate::development::Actor::local();
2868 project.edit_buffer(path, content, actor.clone())?;
2869 project.set_buffer_cursor(path, cursor.line, cursor.column)?;
2870 project.set_buffer_selection(path, None, actor)?;
2871 Ok(())
2872 }
2873
2874 fn backspace_editor(&mut self, path: &str) -> crate::development::DevelopmentResult<()> {
2875 let mut workspace = self.workspace.try_lock()?;
2876 let project = workspace.project_mut();
2877 let buffer = project.buffer(path).cloned().ok_or_else(|| {
2878 crate::development::DevelopmentError::NotFound(format!("buffer {path}"))
2879 })?;
2880 if buffer
2881 .selection
2882 .as_ref()
2883 .is_some_and(|selection| !selection.is_empty())
2884 {
2885 project.replace_buffer_selection(
2886 path,
2887 String::new(),
2888 crate::development::Actor::local(),
2889 )?;
2890 return Ok(());
2891 }
2892 let offset = editor_offset(&buffer.content, buffer.cursor_line, buffer.cursor_column);
2893 if offset == 0 {
2894 return Ok(());
2895 }
2896 let previous = buffer.content[..offset]
2897 .char_indices()
2898 .next_back()
2899 .map(|(index, _)| index)
2900 .unwrap_or(0);
2901 let mut content = buffer.content;
2902 content.drain(previous..offset);
2903 let cursor = crate::development::editor::text_position_at_offset(&content, previous)
2904 .ok_or_else(|| {
2905 crate::development::DevelopmentError::InvalidInput(
2906 "backspace ended at an invalid UTF-8 boundary".into(),
2907 )
2908 })?;
2909 let actor = crate::development::Actor::local();
2910 project.edit_buffer(path, content, actor.clone())?;
2911 project.set_buffer_cursor(path, cursor.line, cursor.column)?;
2912 project.set_buffer_selection(path, None, actor)?;
2913 Ok(())
2914 }
2915
2916 pub fn previous_surface(&mut self) {
2917 let surfaces: &[DevSurface] = if self
2918 .responsive_class(self.terminal_width, self.terminal_height)
2919 == ResponsiveClass::Phone
2920 {
2921 &DevSurface::PHONE
2922 } else {
2923 &DevSurface::PRIMARY
2924 };
2925 let index = surfaces
2926 .iter()
2927 .position(|surface| *surface == self.surface)
2928 .unwrap_or(0);
2929 self.surface = surfaces[(index + surfaces.len() - 1) % surfaces.len()];
2930 self.status = format!("{} selected", self.surface.label());
2931 }
2932
2933 pub fn apply_snapshot(&mut self, snapshot: &super::snapshot::DisplaySnapshot) {
2935 self.refresh_latency_ms = snapshot.duration.as_millis() as u64;
2936 let selected_agent_status = self.selected_agent.as_ref().and_then(|selected| {
2937 snapshot
2938 .agent_states
2939 .iter()
2940 .find(|(id, _)| id == selected)
2941 .map(|(_, status)| *status)
2942 });
2943 if let super::snapshot::BrowserHealth::Crashed {
2944 last_process_id,
2945 last_revision,
2946 } = &snapshot.browser_health
2947 && self.browser_recovery.is_none()
2948 {
2949 let pid_label = last_process_id
2950 .map(|pid| pid.to_string())
2951 .unwrap_or_else(|| "unknown".into());
2952 let revision_label = last_revision
2953 .map(|revision| revision.to_string())
2954 .unwrap_or_else(|| "none".into());
2955 self.surface = DevSurface::App;
2956 self.browser_recovery = Some(BrowserRecoveryOffer::from_error(
2957 &format!(
2958 "browser endpoint crashed unexpectedly (pid {pid_label}, last revision {revision_label})"
2959 ),
2960 9222,
2961 ));
2962 self.browser_workspace
2963 .disconnected("browser endpoint crashed".to_string(), true);
2964 self.status = "Browser endpoint crashed · recovery choices below".into();
2965 }
2966 self.harnesses = snapshot.harnesses.clone();
2967 self.agents = snapshot.agents.clone();
2968 self.agent_conversation = snapshot.agent_conversation.clone();
2969 self.reconcile_pending_chat();
2970 if self.agent_send_job.is_none()
2971 && self.pending_chat_messages.is_empty()
2972 && self.status.contains("Glass Agent is thinking")
2973 {
2974 match selected_agent_status {
2975 Some(crate::AgentStatus::Idle) => {
2976 self.status = "Glass Agent ready · response received".into();
2977 }
2978 Some(crate::AgentStatus::Failed) => {
2979 self.status = "Glass Agent failed · press Enter to retry".into();
2980 }
2981 Some(crate::AgentStatus::Cancelled) => {
2982 self.status = "Glass Agent stopped · press Enter to retry".into();
2983 }
2984 Some(crate::AgentStatus::Waiting) => {
2985 self.status = "Glass Agent waiting for approval".into();
2986 }
2987 _ => {}
2988 }
2989 }
2990 self.tasks = snapshot.tasks.clone();
2991 if !snapshot.editor.is_empty() {
2992 self.editor = snapshot.editor.clone();
2993 }
2994 self.lsp = snapshot.lsp.clone();
2995 self.processes = snapshot.processes.clone();
2996 self.git = snapshot.git.clone();
2997 self.git_entries = snapshot.git_entries.clone();
2998 self.github = snapshot.github.clone();
2999 self.github_review = snapshot.github_review.clone();
3000 if self.git_entries.is_empty() {
3001 self.selected_git_file = 0;
3002 } else {
3003 self.selected_git_file = self
3004 .selected_git_file
3005 .min(self.git_entries.len().saturating_sub(1));
3006 }
3007 self.tests = snapshot.tests.clone();
3008 self.kernels = snapshot.kernels.clone();
3009 self.debugger = snapshot.debugger.clone();
3010 self.replay = snapshot.replay.clone();
3011 self.workflow = snapshot.workflow.clone();
3012 self.workspace_status = snapshot.workspace_status.clone();
3013 self.browser = snapshot.browser.clone();
3014 self.snapshot_root = snapshot.root.clone();
3015 self.snapshot_trust_label = snapshot.trust_label.clone();
3016 self.snapshot_trust_inspection = snapshot.trust_inspection.clone();
3017 self.snapshot_project_revision = snapshot.project_revision;
3018 self.snapshot_generation = snapshot.generation;
3019 self.snapshot_skills_count = snapshot.skills_count;
3020 self.snapshot_tools_count = snapshot.tools_count;
3021 self.experiments = snapshot.experiments.clone();
3022 if !snapshot.files.is_empty() {
3023 self.files = snapshot.files.clone();
3024 if !self.files.is_empty() {
3025 self.selected_file = self.selected_file.min(self.files.len() - 1);
3026 }
3027 }
3028 }
3029
3030 pub fn set_terminal_size(&mut self, width: u16, height: u16) {
3031 self.terminal_width = width;
3032 self.terminal_height = height;
3033 self.ensure_editor_cursor_visible();
3034 }
3035
3036 pub fn refresh(&mut self) {
3037 self.harnesses = crate::harness::summary();
3038 let Ok(mut workspace) = self.workspace.try_lock() else {
3039 self.status = "Workspace lock failed".into();
3040 return;
3041 };
3042 self.files = workspace
3043 .project()
3044 .list_files()
3045 .map(|entries| {
3046 entries
3047 .into_iter()
3048 .filter(|entry| matches!(entry.kind, crate::development::FileKind::File))
3049 .map(|entry| entry.path)
3050 .take(512)
3051 .collect()
3052 })
3053 .unwrap_or_default();
3054 if !self.files.is_empty() {
3055 self.selected_file = self.selected_file.min(self.files.len() - 1);
3056 }
3057 let agent_snapshots = workspace.agents().list();
3058 self.pending_agent_approval = pending_agent_approval(agent_snapshots.as_ref().ok());
3059 self.agents = match agent_snapshots {
3060 Ok(agents) if agents.is_empty() => "No agents. :agent spawn ROLE TASK".into(),
3061 Ok(agents) => agents
3062 .iter()
3063 .map(|agent| {
3064 format!(
3065 "{} {} {} · {}\n target {} · model {} · thinking {} · events {} · dropped {}{}\n evidence {}",
3066 agent.id.as_str(),
3067 agent.status.label(),
3068 agent.role,
3069 agent.task,
3070 agent.worktree.display(),
3071 agent.model.as_deref().unwrap_or("default"),
3072 agent.thinking.as_deref().unwrap_or("default"),
3073 agent.event_count,
3074 agent.dropped_event_count,
3075 agent
3076 .last_error
3077 .as_deref()
3078 .map(|error| format!(" · {error}"))
3079 .unwrap_or_default(),
3080 agent
3081 .evidence
3082 .iter()
3083 .rev()
3084 .take(3)
3085 .map(|evidence| evidence.to_string())
3086 .collect::<Vec<_>>()
3087 .join(" · ")
3088 )
3089 })
3090 .collect::<Vec<_>>()
3091 .join("\n\n"),
3092 Err(error) => format!("Agent registry failed: {error}"),
3093 };
3094 self.agent_conversation = match workspace.agents().history(0) {
3095 Ok(events) if events.is_empty() => {
3096 "No conversation yet. Press Enter or start typing to compose a message.".into()
3097 }
3098 Ok(events) => super::projection::conversation(
3099 &events
3100 .iter()
3101 .rev()
3102 .take(40)
3103 .rev()
3104 .cloned()
3105 .collect::<Vec<_>>(),
3106 ),
3107 Err(error) => format!("Conversation unavailable · {error}"),
3108 };
3109 self.tasks = match workspace.tasks() {
3110 Ok(tasks) if tasks.is_empty() => {
3111 "No tasks. :task create TITLE PROMPT creates an autonomous task".into()
3112 }
3113 Ok(tasks) => tasks
3114 .iter()
3115 .map(|task| {
3116 let glyph = match task.state {
3117 crate::TaskState::Succeeded
3118 if task.verification == crate::VerificationRequirement::Settled => "◇",
3119 crate::TaskState::Succeeded => "✓",
3120 crate::TaskState::Failed | crate::TaskState::Cancelled => "×",
3121 crate::TaskState::Blocked => "!",
3122 crate::TaskState::Running | crate::TaskState::Verifying => "●",
3123 _ => "○",
3124 };
3125 format!(
3126 "{} {} {} {}\n goal {}\n agent {} · attempt {} · model {} · thinking {}\n depends {}\n verification {}{}\n evidence {}",
3127 glyph,
3128 task.id.as_str(),
3129 task.state.label(),
3130 task.title,
3131 task.goal,
3132 task.assigned_agent
3133 .as_ref()
3134 .map(|agent| agent.as_str())
3135 .unwrap_or("unassigned"),
3136 task.attempt,
3137 task.model.as_deref().unwrap_or("default"),
3138 task.thinking.as_deref().unwrap_or("default"),
3139 task.dependencies
3140 .iter()
3141 .map(|dependency| dependency.as_str())
3142 .collect::<Vec<_>>()
3143 .join(", "),
3144 serde_json::to_string(&task.verification).unwrap_or_default(),
3145 task.last_error
3146 .as_deref()
3147 .map(|error| format!(" · {error}"))
3148 .unwrap_or_default(),
3149 task.evidence
3150 .iter()
3151 .rev()
3152 .take(3)
3153 .map(|evidence| {
3154 format!(
3155 "{}={}",
3156 evidence.kind,
3157 evidence.passed.map_or("?".into(), |passed| passed.to_string())
3158 )
3159 })
3160 .collect::<Vec<_>>()
3161 .join(" · ")
3162 )
3163 })
3164 .collect::<Vec<_>>()
3165 .join("\n\n"),
3166 Err(error) => format!("Task scheduler failed: {error}"),
3167 };
3168 self.processes = workspace
3169 .project_mut()
3170 .processes()
3171 .list_checked()
3172 .map(|items| {
3173 if items.is_empty() {
3174 "No managed terminals. Start the detected development command from More.".into()
3175 } else {
3176 items
3177 .into_iter()
3178 .map(|item| {
3179 format!(
3180 "{} {} · health {} · pid {} · {}\n {}",
3181 if matches!(item.health, crate::development::ProcessHealth::Healthy)
3182 {
3183 "●"
3184 } else {
3185 "○"
3186 },
3187 item.name,
3188 item.health.label(),
3189 item.pid.map_or_else(|| "—".into(), |pid| pid.to_string()),
3190 if item.pty { "PTY" } else { "pipes" },
3191 item.detected_urls
3192 .first()
3193 .map_or(item.command.as_str(), String::as_str),
3194 )
3195 })
3196 .collect::<Vec<_>>()
3197 .join("\n\n")
3198 }
3199 })
3200 .unwrap_or_else(|error| format!("Process state failed: {error}"));
3201 let buffers = workspace.project().buffers().cloned().collect::<Vec<_>>();
3202 self.editor = if buffers.is_empty() {
3203 "No file open. Select a file below and press Enter to open the full-screen editor."
3204 .into()
3205 } else {
3206 buffers
3207 .iter()
3208 .map(|buffer| {
3209 let lines: Vec<&str> = buffer.content.lines().collect();
3211 let cursor = buffer.cursor_line as usize;
3212 let viewport_rows = 16;
3213 let start = cursor
3214 .saturating_sub(viewport_rows / 2)
3215 .min(lines.len().saturating_sub(viewport_rows.min(lines.len())));
3216 let end = (start + viewport_rows).min(lines.len());
3217 let gutter_width = lines.len().to_string().len().max(3);
3218 let viewport = lines[start..end]
3219 .iter()
3220 .enumerate()
3221 .map(|(index, line)| {
3222 let number = start + index + 1;
3223 let marker = if number == cursor { "▶" } else { " " };
3224 format!(
3225 "{marker}{:>gutter_width$} │ {line}",
3226 number,
3227 gutter_width = gutter_width
3228 )
3229 })
3230 .collect::<Vec<_>>()
3231 .join("\n");
3232 format!(
3233 "{}{} · cursor {}:{} · actor {} · {} lines\n{}",
3234 if buffer.dirty { "● " } else { "○ " },
3235 buffer.path,
3236 buffer.cursor_line,
3237 buffer.cursor_column,
3238 buffer.actor.id,
3239 lines.len(),
3240 viewport
3241 )
3242 })
3243 .collect::<Vec<_>>()
3244 .join("\n\n")
3245 };
3246 self.editor_comments = workspace.project().editor_comments(None);
3247 self.editor_proposals = workspace.project().editor_proposals();
3248 self.editor_checkpoints = workspace.project().editor_checkpoints();
3249 if let Some(buffer) = buffers.get(self.editor_buffer_index) {
3250 self.focused_editor_path = buffer.path.clone();
3251 self.focused_editor_dirty = buffer.dirty;
3252 self.focused_editor_line = buffer.cursor_line;
3253 self.focused_editor_column = buffer.cursor_column;
3254 self.focused_editor_selection = buffer.selection.clone();
3255 }
3256 self.lsp = {
3257 let language = workspace.language();
3258 let servers = language.names().collect::<Vec<_>>();
3259 let event_count = language.events(0).len();
3260 if servers.is_empty() {
3261 "No language server active · diagnostics unavailable".into()
3262 } else {
3263 format!("● {} · {} recent events", servers.join(" · "), event_count)
3264 }
3265 };
3266 let git_status = workspace.git().map(|git| git.status());
3267 self.git = match git_status {
3268 Some(Ok(status)) => {
3269 self.git_entries = status.entries.clone();
3270 let header = format!(
3271 "branch {} · ↑{} ↓{} · upstream {}",
3272 status.branch.as_deref().unwrap_or("detached"),
3273 status.ahead,
3274 status.behind,
3275 status.upstream.as_deref().unwrap_or("none")
3276 );
3277 let entries = status
3278 .entries
3279 .iter()
3280 .map(|entry| {
3281 format!(
3282 "{}{} {}{}",
3283 if entry.untracked { "?" } else { "●" },
3284 if status.conflicts.contains(&entry.path) {
3285 "!"
3286 } else {
3287 " "
3288 },
3289 entry.index_status,
3290 entry.path
3291 )
3292 })
3293 .collect::<Vec<_>>();
3294 if entries.is_empty() {
3295 format!("{header}\n✓ working tree clean")
3296 } else {
3297 format!("{header}\n{}", entries.join("\n"))
3298 }
3299 }
3300 Some(Err(error)) => {
3301 self.git_entries.clear();
3302 format!("Git state failed: {error}")
3303 }
3304 None => {
3305 self.git_entries.clear();
3306 "Not a Git repository".into()
3307 }
3308 };
3309 if self.git_entries.is_empty() {
3310 self.selected_git_file = 0;
3311 } else {
3312 self.selected_git_file = self
3313 .selected_git_file
3314 .min(self.git_entries.len().saturating_sub(1));
3315 }
3316 let _ = workspace.tests_mut().poll();
3317 let test_runs = workspace
3318 .tests()
3319 .results()
3320 .rev()
3321 .take(32)
3322 .collect::<Vec<_>>();
3323 self.tests = if test_runs.is_empty() {
3324 "No test runs".into()
3325 } else {
3326 test_runs
3327 .iter()
3328 .map(|run| {
3329 format!(
3330 "{} {} · {} · {} ms · {} cases",
3331 if run.exit_code == Some(0) {
3332 "✓"
3333 } else {
3334 "×"
3335 },
3336 run.suite_id,
3337 run.state.label(),
3338 run.duration_ms.unwrap_or_default(),
3339 run.cases.len()
3340 )
3341 })
3342 .collect::<Vec<_>>()
3343 .join("\n")
3344 };
3345 let kernels = workspace.kernels().snapshots().collect::<Vec<_>>();
3346 self.kernels = if kernels.is_empty() {
3347 "No persistent kernels".into()
3348 } else {
3349 kernels
3350 .iter()
3351 .map(|kernel| {
3352 format!(
3353 "{} {} · {} · {} executions · rev {}",
3354 if matches!(kernel.state, crate::kernels::KernelState::Ready) {
3355 "●"
3356 } else {
3357 "○"
3358 },
3359 kernel.name,
3360 kernel.kind.label(),
3361 kernel.executions,
3362 kernel.workspace_revision
3363 )
3364 })
3365 .collect::<Vec<_>>()
3366 .join("\n")
3367 };
3368 let debugger_names = workspace
3369 .debugger_names()
3370 .map(str::to_string)
3371 .collect::<Vec<_>>();
3372 self.debugger = if debugger_names.is_empty() {
3373 "No debugger sessions. :debug start NAME COMMAND [ARGS...]".into()
3374 } else {
3375 let snapshots: Result<Vec<_>, _> = debugger_names
3376 .iter()
3377 .map(|name| {
3378 workspace
3379 .debugger_mut(name)
3380 .and_then(|debugger| debugger.snapshot())
3381 .map(|snapshot| (name.to_string(), snapshot))
3382 })
3383 .collect();
3384 match snapshots {
3385 Ok(snapshots) => snapshots
3386 .iter()
3387 .map(|(name, snapshot)| {
3388 format!(
3389 "● {} · {} · pid {} · {} breakpoints · {} watches · {} threads/processes",
3390 name,
3391 match snapshot.state {
3392 crate::debugger::DebugSessionState::Starting => "starting",
3393 crate::debugger::DebugSessionState::Initialized => "initialized",
3394 crate::debugger::DebugSessionState::Running => "running",
3395 crate::debugger::DebugSessionState::Stopped => "stopped",
3396 crate::debugger::DebugSessionState::Terminated => "terminated",
3397 crate::debugger::DebugSessionState::Failed => "failed",
3398 },
3399 snapshot.adapter_process_id,
3400 snapshot.breakpoints.values().map(Vec::len).sum::<usize>(),
3401 snapshot.watches.len(),
3402 snapshot.debuggee_processes.len()
3403 )
3404 })
3405 .collect::<Vec<_>>()
3406 .join("\n"),
3407 Err(error) => format!("Debugger state failed: {error}"),
3408 }
3409 };
3410 self.replay = workspace
3411 .intelligence()
3412 .replay(0, 128)
3413 .map(|events| {
3414 if events.is_empty() {
3415 "No observable replay events".into()
3416 } else {
3417 events
3418 .iter()
3419 .rev()
3420 .take(24)
3421 .rev()
3422 .map(|event| {
3423 format!(
3424 "{} {} · {} · {} · rev {}",
3425 event.sequence,
3426 event.actor,
3427 event.subsystem,
3428 event.kind,
3429 event.workspace_revision
3430 )
3431 })
3432 .collect::<Vec<_>>()
3433 .join("\n")
3434 }
3435 })
3436 .unwrap_or_else(|error| format!("Replay failed: {error}"));
3437 self.browser = match workspace.browser().state() {
3438 Ok(state) => {
3439 let connected = state
3440 .get("connected")
3441 .and_then(serde_json::Value::as_bool)
3442 .unwrap_or(false);
3443 let revision = state
3444 .get("browserRevision")
3445 .and_then(serde_json::Value::as_u64);
3446 if connected {
3447 if self.browser_workspace.state().connection
3448 != BrowserConnectionPhase::Connected
3449 {
3450 self.browser_workspace.connected(true, None, revision);
3451 } else if let Some(revision) = revision {
3452 self.browser_workspace.state_mut().browser_revision = Some(revision);
3453 }
3454 } else {
3455 self.browser_workspace.state_mut().connection =
3456 BrowserConnectionPhase::Detached;
3457 }
3458 self.browser_workspace_summary()
3459 }
3460 Err(error) => format!("Browser state failed: {error}"),
3461 };
3462 self.workflow = workspace
3463 .browser()
3464 .list_workflows()
3465 .map(|state| super::projection::workflow(Some(&state)))
3466 .unwrap_or_else(|error| format!("Workflow state failed: {error}"));
3467 let root = workspace.root().display().to_string();
3468 let generation = workspace.generation();
3469 let project_revision = workspace.project().revision();
3470 let agent_count = workspace
3471 .agents()
3472 .list()
3473 .map(|items| items.len())
3474 .unwrap_or(0);
3475 let task_count = workspace.tasks().map(|items| items.len()).unwrap_or(0);
3476 let kernel_count = workspace.kernels().snapshots().count();
3477 let debugger_count = workspace.debugger_names().count();
3478 let detection = workspace.project().detection().clone();
3479 let trust = workspace.trust();
3480 let trust_ready = trust.permits_project_execution();
3481 let dev_hint = detection
3482 .dev_command
3483 .as_deref()
3484 .map(|command| format!("● run `{command}`"))
3485 .unwrap_or_else(|| "○ configure a dev command".into());
3486 let app_hint = detection
3487 .browser_url
3488 .as_deref()
3489 .map(|url| format!("● open App {url}"))
3490 .unwrap_or_else(|| "○ start App after a URL is detected".into());
3491 let project_line = if detection.languages.is_empty() {
3492 "○ project type unknown".to_string()
3493 } else {
3494 format!("✓ {} project", detection.languages.join("/"))
3495 };
3496 let workspace_line = format!("✓ workspace {}", trust.label());
3497 let agent_hint = if self.agent_readiness.starts_with("✓ Ready") {
3498 ":agent ready · type a message or press Enter to chat"
3499 } else {
3500 "○ Pi onboarding · use :agent setup or :agent setup login"
3501 };
3502 self.workspace_status = format!(
3503 "WELCOME · {}\n{}\n\n{}\n{}\n\nNEXT ACTIONS\n◆ :actions guided launchers · per-surface flows\n◆ type a message or press Enter to talk to Glass Agent\n◆ :process start dev · 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",
3504 detection.git_branch.as_deref().unwrap_or("no branch"),
3505 project_line,
3506 agent_hint,
3507 workspace_line,
3508 dev_hint,
3509 app_hint,
3510 root,
3511 generation,
3512 project_revision,
3513 trust_ready,
3514 agent_count,
3515 task_count,
3516 kernel_count,
3517 debugger_count,
3518 );
3519 if workspace.trust().permits_project_execution()
3520 && let Ok(experiments) = workspace.experiments()
3521 {
3522 let snapshots = experiments.snapshots();
3523 self.experiments = if snapshots.is_empty() {
3524 "No experiments".into()
3525 } else {
3526 snapshots
3527 .iter()
3528 .map(|experiment| {
3529 format!(
3530 "{} {} · {} · port {} · agent {}",
3531 if experiment.evidence.tests_failed == 0
3532 && experiment.evidence.tests_passed > 0
3533 {
3534 "✓"
3535 } else {
3536 "○"
3537 },
3538 experiment.id,
3539 experiment.state.label(),
3540 experiment
3541 .port
3542 .map_or_else(|| "—".into(), |port| port.to_string()),
3543 experiment
3544 .agent_id
3545 .as_ref()
3546 .map(|id| id.as_str())
3547 .unwrap_or("none")
3548 )
3549 })
3550 .collect::<Vec<_>>()
3551 .join("\n")
3552 };
3553 self.experiment_comparison = Some(experiments.compare());
3554 }
3555 drop(workspace);
3556 self.reconcile_pending_chat();
3557 }
3558
3559 pub fn apply_browser_result(&mut self, tool: &str, result: &serde_json::Value) {
3560 match tool {
3561 "glass.browser.observe" => {
3562 let revision = result
3563 .pointer("/accessibility/revision")
3564 .and_then(serde_json::Value::as_u64);
3565 let title = result
3566 .pointer("/page/title")
3567 .and_then(serde_json::Value::as_str)
3568 .unwrap_or("Untitled");
3569 let url = result
3570 .pointer("/page/url")
3571 .and_then(serde_json::Value::as_str)
3572 .unwrap_or_default();
3573 let loading = result
3574 .pointer("/page/loading")
3575 .and_then(serde_json::Value::as_bool)
3576 .unwrap_or(false);
3577 if let Some(revision) = revision {
3578 self.browser_workspace
3579 .update_page(title, url, loading, Some(revision));
3580 let entities = result
3581 .pointer("/accessibility/interactive")
3582 .and_then(serde_json::Value::as_array)
3583 .into_iter()
3584 .flatten()
3585 .filter_map(|entity| {
3586 Some(BrowserWorkspaceEntity {
3587 reference: entity.get("reference")?.as_str()?.into(),
3588 role: entity
3589 .get("role")
3590 .and_then(serde_json::Value::as_str)
3591 .unwrap_or("unknown")
3592 .into(),
3593 name: entity
3594 .get("name")
3595 .and_then(serde_json::Value::as_str)
3596 .unwrap_or("unnamed")
3597 .into(),
3598 actionable: entity
3599 .get("actionable")
3600 .and_then(serde_json::Value::as_bool)
3601 .unwrap_or(true),
3602 revision,
3603 })
3604 })
3605 .collect();
3606 self.browser_workspace.replace_entities(revision, entities);
3607 }
3608 }
3609 "glass.browser.targets" => {
3610 let values = result
3611 .get("targets")
3612 .and_then(serde_json::Value::as_array)
3613 .or_else(|| result.as_array());
3614 let targets = values
3615 .into_iter()
3616 .flatten()
3617 .filter_map(|target| {
3618 Some(BrowserWorkspaceTarget {
3619 id: target.get("id")?.as_str()?.into(),
3620 title: target
3621 .get("title")
3622 .and_then(serde_json::Value::as_str)
3623 .unwrap_or("Untitled")
3624 .into(),
3625 url: target
3626 .get("url")
3627 .and_then(serde_json::Value::as_str)
3628 .unwrap_or_default()
3629 .into(),
3630 selected: target
3631 .get("active")
3632 .and_then(serde_json::Value::as_bool)
3633 .unwrap_or(false),
3634 })
3635 })
3636 .collect();
3637 self.browser_workspace.replace_targets(targets);
3638 if self.browser_target_picker_requested {
3639 self.browser_target_picker_requested = false;
3640 self.browser_target_picker = true;
3641 self.browser_target_selection = 0;
3642 self.status = if self.browser_workspace.state().targets.is_empty() {
3643 "No page targets found · Esc closes".into()
3644 } else {
3645 "Target picker · type to filter · j/k select · Enter choose · Esc close"
3646 .into()
3647 };
3648 }
3649 }
3650 "glass.browser.target.select" => {
3651 if let Some(target_id) = result
3652 .pointer("/target/id")
3653 .and_then(serde_json::Value::as_str)
3654 {
3655 let mut targets = self.browser_workspace.state().targets.clone();
3656 for target in &mut targets {
3657 target.selected = target.id == target_id;
3658 }
3659 self.browser_workspace.replace_targets(targets);
3660 }
3661 if let Some(observation) = result.get("observation") {
3662 self.apply_browser_result("glass.browser.observe", observation);
3663 }
3664 }
3665 "glass.browser.start" => {
3666 let connected = result
3667 .get("connected")
3668 .and_then(serde_json::Value::as_bool)
3669 .unwrap_or(true);
3670 let revision = result
3671 .get("browserRevision")
3672 .and_then(serde_json::Value::as_u64);
3673 if connected {
3674 self.browser_workspace.connected(true, None, revision);
3675 self.browser_recovery = None;
3676 }
3677 }
3678 "glass.browser.stop" => {
3679 self.browser_workspace.state_mut().connection = BrowserConnectionPhase::Detached;
3680 }
3681 _ => {}
3682 }
3683 self.browser = self.browser_workspace_summary();
3684 }
3685
3686 pub fn browser_workspace_summary(&self) -> String {
3687 let browser = self.browser_workspace.state();
3688 let entities = if browser.entities.is_empty() {
3689 "No current semantic entities".into()
3690 } else {
3691 browser
3692 .entities
3693 .iter()
3694 .enumerate()
3695 .skip(browser.semantic_scroll)
3696 .take(24)
3697 .map(|(index, entity)| {
3698 format!(
3699 "{} {} · {} · {}",
3700 if Some(index) == browser.selected_entity {
3701 "◆"
3702 } else {
3703 "○"
3704 },
3705 entity.name,
3706 entity.role,
3707 entity.reference
3708 )
3709 })
3710 .collect::<Vec<_>>()
3711 .join("\n")
3712 };
3713 let targets = if browser.targets.is_empty() {
3714 "No page targets loaded · use `browser targets`".into()
3715 } else {
3716 browser
3717 .targets
3718 .iter()
3719 .take(8)
3720 .map(|target| {
3721 format!(
3722 "{} {} · {}",
3723 if target.selected { "◆" } else { "○" },
3724 target.title,
3725 safe_browser_url(&target.url).unwrap_or_else(|| "no URL".into())
3726 )
3727 })
3728 .collect::<Vec<_>>()
3729 .join("\n")
3730 };
3731 format!(
3732 "{} · rev {} · {} · owner {}\n{}\n{}\n\nTARGETS\n{}\n\nUNDERSTANDING\n{}\n\nWORKFLOW\n{}",
3733 browser.connection_label(),
3734 browser
3735 .browser_revision
3736 .map_or_else(|| "—".into(), |revision| revision.to_string()),
3737 browser.presentation_label(),
3738 browser.input_owner_label(),
3739 browser.title,
3740 safe_browser_url(&browser.url).unwrap_or_else(|| "no page".into()),
3741 targets,
3742 entities,
3743 browser.workflow
3744 )
3745 }
3746
3747 pub fn queue_browser_targets(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
3748 if self.background_action_running() {
3749 self.status = "Target picker waits for the current background operation".into();
3750 return;
3751 }
3752 if let Err(error) = self.request_browser_target_picker("") {
3753 self.status = format!("Could not load browser targets: {error}");
3754 return;
3755 }
3756 let Some((call, context)) = self.queued_tool_request.take() else {
3757 return;
3758 };
3759 match worker.submit_tool(call, context) {
3760 Ok(id) => {
3761 self.running_tool_job = Some(id);
3762 self.status = "Loading browser targets…".into();
3763 }
3764 Err(error) => {
3765 self.browser_target_picker_requested = false;
3766 self.status = format!("Could not load browser targets: {error}");
3767 }
3768 }
3769 }
3770
3771 pub fn request_browser_target_picker(
3772 &mut self,
3773 query: impl Into<String>,
3774 ) -> Result<(), String> {
3775 if self.background_action_running() {
3776 return Err("Target picker waits for the current background operation".into());
3777 }
3778 self.browser_target_query = query.into();
3779 self.browser_target_selection = 0;
3780 self.browser_target_picker = false;
3781 self.browser_target_picker_requested = true;
3782 let (call, context) =
3783 match self.tool_request("glass.browser.targets", serde_json::json!({}), false) {
3784 Ok(request) => request,
3785 Err(error) => {
3786 self.browser_target_picker_requested = false;
3787 return Err(error);
3788 }
3789 };
3790 self.queued_tool_request = Some((call, context));
3791 self.status = "Loading browser targets…".into();
3792 Ok(())
3793 }
3794
3795 pub fn close_browser_target_picker(&mut self) {
3796 self.browser_target_picker = false;
3797 self.browser_target_picker_requested = false;
3798 self.status = "Target picker closed".into();
3799 }
3800
3801 pub fn browser_target_matches(&self) -> Vec<usize> {
3802 let query = self.browser_target_query.to_ascii_lowercase();
3803 let terms = query.split_whitespace().collect::<Vec<_>>();
3804 self.browser_workspace
3805 .state()
3806 .targets
3807 .iter()
3808 .enumerate()
3809 .filter(|(_, target)| {
3810 terms.iter().all(|term| {
3811 target.id.to_ascii_lowercase().contains(term)
3812 || target.title.to_ascii_lowercase().contains(term)
3813 || target.url.to_ascii_lowercase().contains(term)
3814 })
3815 })
3816 .map(|(index, _)| index)
3817 .collect()
3818 }
3819
3820 pub fn insert_browser_target_query(&mut self, character: char) {
3821 if self.browser_target_query.len() < 512 {
3822 self.browser_target_query.push(character);
3823 self.browser_target_selection = 0;
3824 }
3825 }
3826
3827 pub fn browser_target_backspace(&mut self) {
3828 self.browser_target_query.pop();
3829 self.browser_target_selection = 0;
3830 }
3831
3832 pub fn clear_browser_target_query(&mut self) {
3833 self.browser_target_query.clear();
3834 self.browser_target_selection = 0;
3835 }
3836
3837 pub fn move_browser_target_selection(&mut self, delta: i32) {
3838 let count = self.browser_target_matches().len();
3839 if count == 0 {
3840 self.browser_target_selection = 0;
3841 return;
3842 }
3843 self.browser_target_selection =
3844 (self.browser_target_selection as i32 + delta).rem_euclid(count as i32) as usize;
3845 }
3846
3847 pub fn select_browser_target(&mut self) {
3848 if self.background_action_running() {
3849 self.status = "Finish the current browser operation before selecting a target".into();
3850 return;
3851 }
3852 let matches = self.browser_target_matches();
3853 let Some(index) = matches.get(self.browser_target_selection).copied() else {
3854 self.status = "No matching browser target".into();
3855 return;
3856 };
3857 let Some(target) = self.browser_workspace.state().targets.get(index).cloned() else {
3858 self.status = "Selected browser target disappeared".into();
3859 return;
3860 };
3861 let (call, context) = match self.tool_request(
3862 "glass.browser.target.select",
3863 serde_json::json!({"targetId": target.id}),
3864 true,
3865 ) {
3866 Ok(request) => request,
3867 Err(error) => {
3868 self.status = format!("Target selection unavailable: {error}");
3869 return;
3870 }
3871 };
3872 self.browser_target_picker = false;
3873 let queued = match self.queue_or_confirm(
3874 call,
3875 context,
3876 format!("Select browser target · {}", target.title),
3877 ) {
3878 Ok(queued) => queued,
3879 Err(error) => {
3880 self.status = format!("Target selection unavailable: {error}");
3881 return;
3882 }
3883 };
3884 if !queued {
3885 self.status = "Target selection ready · Enter approves once · Esc cancels".into();
3886 }
3887 }
3888
3889 pub fn browser_target_picker_view(&self) -> String {
3890 let matches = self.browser_target_matches();
3891 let mut lines = vec![
3892 format!(
3893 "FILTER {}",
3894 if self.browser_target_query.is_empty() {
3895 "all pages"
3896 } else {
3897 self.browser_target_query.as_str()
3898 }
3899 ),
3900 String::new(),
3901 ];
3902 if matches.is_empty() {
3903 lines.push("No matching page targets.".into());
3904 } else {
3905 for (position, index) in matches.iter().take(16).enumerate() {
3906 let Some(target) = self.browser_workspace.state().targets.get(*index) else {
3907 continue;
3908 };
3909 let marker = if position == self.browser_target_selection {
3910 "›"
3911 } else {
3912 " "
3913 };
3914 let url = safe_browser_url(&target.url).unwrap_or_else(|| "no URL".into());
3915 lines.push(format!(
3916 "{marker} {} · {} · {}",
3917 target.title, url, target.id
3918 ));
3919 }
3920 }
3921 lines.push(String::new());
3922 lines.push("Type filters · Backspace edits · Ctrl-U clears".into());
3923 lines.push("j/k or ↑/↓ selects · Enter chooses · Esc closes".into());
3924 lines.join("\n")
3925 }
3926
3927 pub fn queue_browser_observe(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
3928 if !self.browser_observe_pending || self.background_action_running() {
3929 return;
3930 }
3931 self.browser_observe_pending = false;
3932 let (call, context) =
3933 match self.tool_request("glass.browser.observe", serde_json::json!({}), false) {
3934 Ok(request) => request,
3935 Err(error) => {
3936 self.status = format!("Could not refresh browser evidence: {error}");
3937 return;
3938 }
3939 };
3940 match worker.submit_tool(call, context) {
3941 Ok(id) => {
3942 self.running_tool_job = Some(id);
3943 self.status = "Refreshing semantic browser evidence…".into();
3944 }
3945 Err(error) => self.status = format!("Could not refresh browser evidence: {error}"),
3946 }
3947 }
3948
3949 pub fn continue_pending_browser_navigation(
3951 &mut self,
3952 worker: &mut super::snapshot::SnapshotWorker,
3953 ) {
3954 let Some(url) = self.pending_browser_navigation.as_deref() else {
3955 return;
3956 };
3957 let (call, context) =
3958 match self.tool_request("glass.browser.observe", serde_json::json!({}), false) {
3959 Ok(request) => request,
3960 Err(error) => {
3961 let url = self.pending_browser_navigation.take().unwrap_or_default();
3962 self.open_palette_with(&format!("browser navigate {url}"));
3963 self.status = format!("Browser ready · navigation retry required: {error}");
3964 return;
3965 }
3966 };
3967 match worker.submit_tool(call, context) {
3968 Ok(id) => {
3969 self.running_tool_job = Some(id);
3970 self.status = format!("Browser ready · preparing navigation to {url}…");
3971 }
3972 Err(error) => {
3973 let url = self.pending_browser_navigation.take().unwrap_or_default();
3974 self.open_palette_with(&format!("browser navigate {url}"));
3975 self.status = format!("Browser ready · navigation retry required: {error}");
3976 }
3977 }
3978 }
3979
3980 pub fn submit_pending_browser_navigation(
3982 &mut self,
3983 worker: &mut super::snapshot::SnapshotWorker,
3984 ) {
3985 let Some(url) = self.pending_browser_navigation.take() else {
3986 return;
3987 };
3988 let Some(revision) = self.browser_workspace.state().browser_revision else {
3989 self.open_palette_with(&format!("browser navigate {url}"));
3990 self.status = "Browser launch completed without a usable revision".into();
3991 return;
3992 };
3993 let (call, context) = match self.tool_request(
3994 "glass.browser.navigate",
3995 serde_json::json!({"url": url, "browserRevision": revision}),
3996 true,
3997 ) {
3998 Ok(request) => request,
3999 Err(error) => {
4000 self.open_palette_with(&format!("browser navigate {url}"));
4001 self.status = format!("Browser ready · navigation retry required: {error}");
4002 return;
4003 }
4004 };
4005 match worker.submit_tool(call, context) {
4006 Ok(id) => {
4007 self.running_tool_job = Some(id);
4008 self.status = format!("Browser ready · navigating to {url}…");
4009 }
4010 Err(error) => {
4011 self.open_palette_with(&format!("browser navigate {url}"));
4012 self.status = format!("Browser ready · navigation retry required: {error}");
4013 }
4014 }
4015 }
4016
4017 pub fn queue_browser_intent(&mut self, intent: BrowserWorkspaceIntent) {
4018 if self.background_action_running() {
4019 self.status = "Browser action waits for the current background operation".into();
4020 return;
4021 }
4022 let action = match self.browser_workspace.reduce(intent) {
4023 Ok(Some(action)) => action,
4024 Ok(None) => return,
4025 Err(error) => {
4026 self.status = format!("App action unavailable: {error}");
4027 return;
4028 }
4029 };
4030 let (tool, arguments) = match action {
4031 BrowserWorkspaceAction::Navigate {
4032 url,
4033 expected_revision,
4034 } => (
4035 "glass.browser.navigate",
4036 serde_json::json!({"url": url, "browserRevision": expected_revision}),
4037 ),
4038 BrowserWorkspaceAction::Back { expected_revision }
4039 | BrowserWorkspaceAction::Forward { expected_revision }
4040 | BrowserWorkspaceAction::Reload { expected_revision }
4041 | BrowserWorkspaceAction::StopLoading { expected_revision } => {
4042 let action = match action {
4043 BrowserWorkspaceAction::Back { .. } => "back",
4044 BrowserWorkspaceAction::Forward { .. } => "forward",
4045 BrowserWorkspaceAction::Reload { .. } => "reload",
4046 BrowserWorkspaceAction::StopLoading { .. } => "stopLoading",
4047 _ => unreachable!(),
4048 };
4049 (
4050 "glass.browser.act",
4051 serde_json::json!({"action": action, "browserRevision": expected_revision}),
4052 )
4053 }
4054 BrowserWorkspaceAction::Click {
4055 target,
4056 expected_revision,
4057 } => (
4058 "glass.browser.act",
4059 serde_json::json!({"action":"click", "target": target, "browserRevision": expected_revision}),
4060 ),
4061 BrowserWorkspaceAction::Type {
4062 target,
4063 text,
4064 expected_revision,
4065 } => (
4066 "glass.browser.act",
4067 serde_json::json!({"action":"type", "target": target, "text": text, "browserRevision": expected_revision}),
4068 ),
4069 BrowserWorkspaceAction::Scroll {
4070 dx,
4071 dy,
4072 expected_revision,
4073 } => (
4074 "glass.browser.act",
4075 serde_json::json!({"action":"scroll", "dx": dx, "dy": dy, "browserRevision": expected_revision}),
4076 ),
4077 _ => return,
4078 };
4079 let (call, context) = match self.tool_request(tool, arguments, true) {
4080 Ok(request) => request,
4081 Err(error) => {
4082 self.status = format!("App action unavailable: {error}");
4083 return;
4084 }
4085 };
4086 let queued = match self.queue_or_confirm(
4087 call,
4088 context,
4089 format!("{tool} · browser revision guarded"),
4090 ) {
4091 Ok(queued) => queued,
4092 Err(error) => {
4093 self.status = format!("App action unavailable: {error}");
4094 return;
4095 }
4096 };
4097 if !queued {
4098 self.status = "Browser mutation ready · Enter approves once · Esc cancels".into();
4099 }
4100 }
4101
4102 pub(super) fn tool_request(
4103 &self,
4104 name: &str,
4105 arguments: serde_json::Value,
4106 mutating: bool,
4107 ) -> Result<
4108 (
4109 crate::development::ToolCall,
4110 crate::tools::DevelopmentToolContext,
4111 ),
4112 String,
4113 > {
4114 let expected_generation = self.snapshot_generation;
4118 let expected_project_revision = self.snapshot_project_revision;
4119 Ok((
4120 crate::development::ToolCall {
4121 id: format!(
4122 "tui-browser-{}",
4123 NEXT_BROWSER_TOOL.fetch_add(1, Ordering::Relaxed)
4124 ),
4125 name: name.into(),
4126 arguments,
4127 },
4128 crate::tools::DevelopmentToolContext {
4129 authorization: crate::development::ToolAuthorization {
4130 actor: crate::development::Actor::local(),
4131 allow_mutation: mutating,
4132 confirmed: mutating,
4133 },
4134 initiator: None,
4135 expected_generation,
4136 expected_project_revision,
4137 },
4138 ))
4139 }
4140
4141 pub fn note_browser_failure(&mut self, tool: &str, error: &str) {
4144 let lower = error.to_ascii_lowercase();
4145 if tool.contains("browser")
4146 && (lower.contains("occupied")
4147 || lower.contains("attach")
4148 || lower.contains("connect")
4149 || lower.contains("launch")
4150 || lower.contains("timeout")
4151 || lower.contains("devtools"))
4152 {
4153 self.browser_target_picker = false;
4154 self.browser_target_picker_requested = false;
4155 self.surface = DevSurface::App;
4156 self.browser_recovery = Some(BrowserRecoveryOffer::from_error(
4157 error,
4158 self.browser_recovery
4159 .as_ref()
4160 .map_or(9222, |offer| offer.port),
4161 ));
4162 self.browser_workspace.disconnected(error.to_string(), true);
4163 }
4164 }
4165
4166 pub fn accept_browser_recovery(
4168 &mut self,
4169 choice: usize,
4170 worker: &mut super::snapshot::SnapshotWorker,
4171 ) {
4172 let Some(offer) = self.browser_recovery.take() else {
4173 return;
4174 };
4175 let (port, attach) = match (offer.compatible_endpoint, choice) {
4176 (true, 0) => (offer.port, true),
4177 (true, 1) | (false, 0) => (free_local_port().unwrap_or(0), false),
4178 (true, 2) | (false, 1) => (offer.port, false),
4179 _ => {
4180 self.status = "Recovery dismissed · project and agent remain available".into();
4181 return;
4182 }
4183 };
4184 if port == 0 {
4185 self.status =
4186 "No free local port was available · retry or use an existing browser".into();
4187 return;
4188 }
4189 let (call, context) = match self.tool_request(
4190 "glass.browser.start",
4191 browser_recovery_arguments(port, attach),
4192 true,
4193 ) {
4194 Ok(request) => request,
4195 Err(error) => {
4196 self.status = format!("Could not queue recovery: {error}");
4197 return;
4198 }
4199 };
4200 match worker.submit_tool(call, context) {
4201 Ok(id) => {
4202 self.running_tool_job = Some(id);
4203 self.status = if attach {
4204 format!("Attaching to browser on port {port} in background…")
4205 } else {
4206 format!("Recovering browser on port {port} in background…")
4207 };
4208 }
4209 Err(error) => self.status = format!("Could not queue recovery: {error}"),
4210 }
4211 }
4212
4213 pub fn refresh_agent_readiness(&mut self) -> Result<bool, String> {
4214 let readiness = crate::pi_runtime::pi_readiness().map_err(|error| error.to_string())?;
4215 let ready = readiness.ready;
4216 self.agent_readiness = format_pi_readiness(&readiness);
4217 Ok(ready)
4218 }
4219}
4220
4221fn format_editor_buffers(buffers: &[crate::development::EditorBuffer]) -> String {
4222 if buffers.is_empty() {
4223 return "No file open. Select a file below and press Enter to open the full-screen editor."
4224 .into();
4225 }
4226 buffers
4227 .iter()
4228 .map(|buffer| {
4229 let lines: Vec<&str> = buffer.content.lines().collect();
4230 let cursor = buffer.cursor_line as usize;
4231 let viewport_rows = 16;
4232 let start = cursor
4233 .saturating_sub(viewport_rows / 2)
4234 .min(lines.len().saturating_sub(viewport_rows.min(lines.len())));
4235 let end = (start + viewport_rows).min(lines.len());
4236 let gutter_width = lines.len().to_string().len().max(3);
4237 let viewport = lines[start..end]
4238 .iter()
4239 .enumerate()
4240 .map(|(index, line)| {
4241 let number = start + index + 1;
4242 let marker = if number == cursor { "▶" } else { " " };
4243 format!(
4244 "{marker}{:>gutter_width$} │ {line}",
4245 number,
4246 gutter_width = gutter_width
4247 )
4248 })
4249 .collect::<Vec<_>>()
4250 .join("\n");
4251 format!(
4252 "{}{} · cursor {}:{} · actor {} · {} lines\n{}",
4253 if buffer.dirty { "● " } else { "○ " },
4254 buffer.path,
4255 buffer.cursor_line,
4256 buffer.cursor_column,
4257 buffer.actor.id,
4258 lines.len(),
4259 viewport
4260 )
4261 })
4262 .collect::<Vec<_>>()
4263 .join("\n\n")
4264}
4265
4266fn format_pi_readiness(readiness: &crate::PiReadiness) -> String {
4267 let provider = readiness.provider.as_deref().unwrap_or("not selected");
4268 let session = readiness.session.as_deref().unwrap_or("new session");
4269 let remediation = readiness
4270 .remediation
4271 .first()
4272 .map(|item| format!(" · next: {item}"))
4273 .unwrap_or_default();
4274 let state_line = format!(
4275 "{} · Node {} · SDK {} · auth {}",
4276 if readiness.ready {
4277 "✓ Ready"
4278 } else {
4279 "○ Needs setup"
4280 },
4281 component_label(&readiness.node),
4282 readiness.sdk.version.as_deref().unwrap_or("missing"),
4283 component_label(&readiness.authentication),
4284 );
4285 if readiness.ready {
4286 format!("{state_line}\nprovider {provider} · {session}")
4287 } else {
4288 format!(
4289 "{state_line}\nprovider {provider} · {session}{remediation}\n\nUse `:agent setup` to repair the pinned runtime · `:agent update` to refresh it · `:agent setup login` to open Pi `/login`"
4290 )
4291 }
4292}
4293
4294fn component_label(component: &crate::pi_runtime::PiReadinessComponent) -> String {
4295 match component.state {
4296 crate::pi_runtime::PiReadinessState::Ready => "✓".into(),
4297 crate::pi_runtime::PiReadinessState::Missing => "× missing".into(),
4298 crate::pi_runtime::PiReadinessState::Incompatible => "! incompatible".into(),
4299 crate::pi_runtime::PiReadinessState::Expired => "! expired".into(),
4300 crate::pi_runtime::PiReadinessState::Unknown => "? unknown".into(),
4301 }
4302}
4303
4304fn safe_browser_url(url: &str) -> Option<String> {
4305 let url = url.trim();
4306 if url.is_empty() {
4307 return None;
4308 }
4309 let sanitized = url
4310 .split(['?', '#'])
4311 .next()
4312 .unwrap_or(url)
4313 .chars()
4314 .take(2_048)
4315 .collect::<String>();
4316 (!sanitized.is_empty()).then_some(sanitized)
4317}
4318
4319fn page_origin(url: &str) -> Option<String> {
4320 let url = safe_browser_url(url)?;
4321 let scheme_end = url.find("://")?;
4322 let authority_start = scheme_end + 3;
4323 let authority_end = url[authority_start..]
4324 .find('/')
4325 .map(|offset| authority_start + offset)
4326 .unwrap_or(url.len());
4327 Some(url[..authority_end].to_string())
4328}
4329fn bounded_editor_content(content: &str) -> (String, bool) {
4330 const MAX_CONTEXT_BYTES: usize = 64 * 1024;
4331 if content.len() <= MAX_CONTEXT_BYTES {
4332 return (content.to_string(), false);
4333 }
4334 let mut end = MAX_CONTEXT_BYTES;
4335 while end > 0 && !content.is_char_boundary(end) {
4336 end -= 1;
4337 }
4338 (content[..end].to_string(), true)
4339}
4340
4341fn pending_agent_approval(
4342 agents: Option<&Vec<crate::AgentSnapshot>>,
4343) -> Option<PendingAgentApproval> {
4344 let agents = agents?;
4345 for agent in agents {
4346 let mut pending = None;
4347 for event in &agent.evidence {
4348 match event.get("type").and_then(serde_json::Value::as_str) {
4349 Some("glass_tool_approval_request") => {
4350 let Some(frame_id) = event.get("frameId").and_then(serde_json::Value::as_str)
4351 else {
4352 continue;
4353 };
4354 pending = Some(PendingAgentApproval {
4355 agent_id: agent.id.as_str().to_string(),
4356 frame_id: frame_id.to_string(),
4357 tool_name: event
4358 .get("toolName")
4359 .and_then(serde_json::Value::as_str)
4360 .unwrap_or("unknown tool")
4361 .to_string(),
4362 arguments: event.get("arguments").cloned().unwrap_or_default(),
4363 });
4364 }
4365 Some("glass_tool_approval_resolved") => {
4366 let frame_id = event.get("frameId").and_then(serde_json::Value::as_str);
4367 if pending
4368 .as_ref()
4369 .is_some_and(|approval| Some(approval.frame_id.as_str()) == frame_id)
4370 {
4371 pending = None;
4372 }
4373 }
4374 _ => {}
4375 }
4376 }
4377 if pending.is_some() {
4378 return pending;
4379 }
4380 }
4381 None
4382}
4383
4384fn fuzzy_contains(candidate: &str, query: &str) -> bool {
4385 if query.is_empty() {
4386 return true;
4387 }
4388 let mut query = query
4389 .chars()
4390 .map(|character| character.to_ascii_lowercase());
4391 let mut expected = query.next();
4392 for character in candidate
4393 .chars()
4394 .map(|character| character.to_ascii_lowercase())
4395 {
4396 if Some(character) == expected {
4397 expected = query.next();
4398 if expected.is_none() {
4399 return true;
4400 }
4401 }
4402 }
4403 false
4404}
4405
4406fn browser_recovery_arguments(port: u16, attach: bool) -> serde_json::Value {
4407 serde_json::json!({
4408 "port": port,
4409 "attach": attach,
4410 "incognito": !attach,
4411 })
4412}
4413
4414fn free_local_port() -> Option<u16> {
4416 std::net::TcpListener::bind((std::net::Ipv4Addr::LOCALHOST, 0))
4417 .ok()
4418 .and_then(|listener| listener.local_addr().ok())
4419 .map(|address| address.port())
4420}
4421
4422fn editor_offset(content: &str, line: u32, column: u32) -> usize {
4423 let mut offset = 0;
4424 for (index, value) in content.split_inclusive('\n').enumerate() {
4425 if index + 1 == line as usize {
4426 let column_bytes = value
4427 .trim_end_matches('\n')
4428 .char_indices()
4429 .nth(column.saturating_sub(1) as usize)
4430 .map(|(offset, _)| offset)
4431 .unwrap_or_else(|| value.trim_end_matches('\n').len());
4432 return offset + column_bytes;
4433 }
4434 offset += value.len();
4435 }
4436 content.len()
4437}
4438
4439#[cfg(test)]
4440mod tests {
4441 use super::*;
4442
4443 #[test]
4444 fn quit_confirmation_requires_explicit_follow_through() {
4445 let root = std::env::temp_dir().join(format!("glass-tui-quit-{}", std::process::id()));
4446 std::fs::create_dir_all(&root).expect("create temporary workspace");
4447 let mut state =
4448 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
4449
4450 state.request_quit();
4451 assert!(state.quit_confirmation);
4452 assert!(!state.quit);
4453 assert_eq!(state.status, "Quit confirmation · Enter exits · Esc stays");
4454
4455 state.cancel_quit();
4456 assert!(!state.quit_confirmation);
4457 assert!(!state.quit);
4458
4459 state.request_quit();
4460 state.confirm_quit();
4461 assert!(!state.quit_confirmation);
4462 assert!(state.quit);
4463 assert_eq!(state.status, "Closing Glass Dev");
4464
4465 std::fs::remove_dir_all(root).expect("remove temporary workspace");
4466 }
4467 #[test]
4468 fn trust_action_menu_dispatches_keyboard_hints() {
4469 let root = std::env::temp_dir().join(format!("glass-trust-menu-{}", std::process::id()));
4470 std::fs::create_dir_all(&root).expect("create temporary workspace");
4471 let mut state =
4472 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
4473 state.surface = DevSurface::Trust;
4474
4475 state.open_menu();
4476 state.menu_selection = 0;
4477 state.run_menu_action();
4478 assert!(!state.menu_open);
4479 assert!(
4480 state
4481 .status
4482 .contains("Inspecting exact repository configuration")
4483 );
4484
4485 state.open_menu();
4486 state.menu_selection = 1;
4487 state.run_menu_action();
4488 assert_eq!(state.surface, DevSurface::Agent);
4489 assert!(
4490 state
4491 .status
4492 .contains("Workspace opened with untrusted authority")
4493 );
4494
4495 std::fs::remove_dir_all(root).expect("remove temporary workspace");
4496 }
4497
4498 #[test]
4499 fn browser_context_url_redaction_preserves_path_only() {
4500 assert_eq!(
4501 safe_browser_url("https://example.test/orders/7?token=secret#receipt"),
4502 Some("https://example.test/orders/7".into())
4503 );
4504 assert_eq!(
4505 page_origin("https://example.test/orders/7?token=secret"),
4506 Some("https://example.test".into())
4507 );
4508 assert_eq!(safe_browser_url(""), None);
4509 }
4510
4511 #[test]
4512 fn browser_recovery_offer_explains_port_collision_choices() {
4513 let offer = BrowserRecoveryOffer::from_error("address already in use on port 9222", 9222);
4514 assert!(!offer.compatible_endpoint);
4515 assert_eq!(offer.actions().len(), 3);
4516 assert!(offer.guidance().contains("preferred endpoint"));
4517
4518 let attach =
4519 BrowserRecoveryOffer::from_error("DevTools page target is available for attach", 9222);
4520 assert!(attach.compatible_endpoint);
4521 assert_eq!(attach.actions().len(), 4);
4522 assert!(attach.guidance().contains("Attach"));
4523 }
4524
4525 #[test]
4526 fn browser_recovery_attach_disables_incognito() {
4527 assert_eq!(
4528 browser_recovery_arguments(9222, true),
4529 serde_json::json!({
4530 "port": 9222,
4531 "attach": true,
4532 "incognito": false,
4533 })
4534 );
4535 assert_eq!(
4536 browser_recovery_arguments(42123, false),
4537 serde_json::json!({
4538 "port": 42123,
4539 "attach": false,
4540 "incognito": true,
4541 })
4542 );
4543 }
4544
4545 #[test]
4546 fn browser_target_picker_filters_and_redacts_urls() {
4547 let root = std::env::temp_dir().join(format!("glass-target-picker-{}", std::process::id()));
4548 std::fs::create_dir_all(&root).expect("create temporary workspace");
4549 let mut state =
4550 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
4551 state.browser_workspace.replace_targets(vec![
4552 BrowserWorkspaceTarget {
4553 id: "page-docs".into(),
4554 title: "Project docs".into(),
4555 url: "https://example.test/docs?token=secret".into(),
4556 selected: false,
4557 },
4558 BrowserWorkspaceTarget {
4559 id: "page-app".into(),
4560 title: "Application".into(),
4561 url: "http://localhost:3000".into(),
4562 selected: false,
4563 },
4564 ]);
4565 state
4566 .request_browser_target_picker("docs")
4567 .expect("queue target picker");
4568 state.queued_tool_request = None;
4569 let matches = state.browser_target_matches();
4570 assert_eq!(matches, vec![0]);
4571 let view = state.browser_target_picker_view();
4572 assert!(view.contains("Project docs"));
4573 assert!(view.contains("https://example.test/docs"));
4574 assert!(!view.contains("token=secret"));
4575 std::fs::remove_dir_all(root).expect("remove temporary workspace");
4576 }
4577 #[test]
4578 fn agent_typing_opens_composer_before_surface_aliases() {
4579 let root = std::env::temp_dir().join(format!("glass-agent-compose-{}", std::process::id()));
4580 std::fs::create_dir_all(&root).expect("create temporary workspace");
4581 let mut state =
4582 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
4583 state.surface = DevSurface::Agent;
4584 state.snapshot_trust_label = "trusted".into();
4585 state.agent_readiness = "✓ Ready · Node ✓ · SDK 0.84.3 · auth ✓".into();
4586
4587 state.handle_printable('c');
4588
4589 assert_eq!(state.surface, DevSurface::Agent);
4590 assert!(state.composer_mode);
4591 assert_eq!(state.composer_input, "c");
4592 std::fs::remove_dir_all(root).expect("remove temporary workspace");
4593 }
4594
4595 #[test]
4596 fn leading_agent_message_characters_are_not_commands() {
4597 for character in ['a', 'q', 's', 'u', 'l', 'i', 'n'] {
4598 let root = std::env::temp_dir().join(format!(
4599 "glass-agent-leading-{character}-{}",
4600 std::process::id()
4601 ));
4602 std::fs::create_dir_all(&root).expect("create temporary workspace");
4603 let mut state = DevTuiState::open_for_tui(&root, TuiLayout::Desktop)
4604 .expect("open temporary workspace");
4605 state.surface = DevSurface::Agent;
4606 state.snapshot_trust_label = "trusted".into();
4607 state.agent_readiness = "✓ Ready · Node ✓ · SDK 0.84.3 · auth ✓".into();
4608
4609 state.handle_printable(character);
4610
4611 assert!(
4612 state.composer_mode,
4613 "character {character:?} did not open composer"
4614 );
4615 assert_eq!(state.composer_input, character.to_string());
4616 std::fs::remove_dir_all(root).expect("remove temporary workspace");
4617 }
4618 }
4619 #[test]
4620 fn action_shortcut_opens_menu_without_stealing_ready_agent_text() {
4621 let root =
4622 std::env::temp_dir().join(format!("glass-action-shortcut-{}", std::process::id()));
4623 std::fs::create_dir_all(&root).expect("create temporary workspace");
4624 let mut state =
4625 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
4626
4627 state.surface = DevSurface::Terminal;
4628 state.handle_printable('a');
4629 assert!(state.menu_open);
4630 state.close_menu();
4631
4632 state.surface = DevSurface::Agent;
4633 state.snapshot_trust_label = "trusted".into();
4634 state.agent_readiness = "✓ Ready · Node ✓ · SDK 0.84.3 · auth ✓".into();
4635 state.handle_printable('a');
4636 assert!(state.composer_mode);
4637 assert_eq!(state.composer_input, "a");
4638
4639 std::fs::remove_dir_all(root).expect("remove temporary workspace");
4640 }
4641
4642 #[test]
4643 fn colon_opens_palette_from_every_surface() {
4644 for surface in DevSurface::ALL {
4645 let root = std::env::temp_dir().join(format!(
4646 "glass-palette-surface-{}-{}",
4647 surface.label(),
4648 std::process::id()
4649 ));
4650 std::fs::create_dir_all(&root).expect("create temporary workspace");
4651 let mut state = DevTuiState::open_for_tui(&root, TuiLayout::Desktop)
4652 .expect("open temporary workspace");
4653 state.surface = surface;
4654
4655 state.handle_printable(':');
4656
4657 assert!(
4658 state.command_mode,
4659 "colon did not open palette on {surface:?}"
4660 );
4661 assert!(!state.composer_mode);
4662 std::fs::remove_dir_all(root).expect("remove temporary workspace");
4663 }
4664 }
4665 #[test]
4666 fn external_delegate_result_is_visible_in_tui_status() {
4667 let root =
4668 std::env::temp_dir().join(format!("glass-delegate-status-{}", std::process::id()));
4669 std::fs::create_dir_all(&root).expect("create temporary workspace");
4670 let mut state =
4671 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
4672 state.running_tool_job = Some(7);
4673 state.apply_tool_job_result(super::super::snapshot::ToolJobResult {
4674 id: 7,
4675 tool: "glass.agent.delegate".into(),
4676 result: Ok(serde_json::json!({
4677 "harness": "codex",
4678 "success": true,
4679 "timedOut": false,
4680 "output": "REAL_RESULT\nsecond line\n",
4681 "stderr": "",
4682 })),
4683 });
4684 assert!(state.status.contains("Temporary codex completed"));
4685 assert!(state.status.contains("REAL_RESULT"));
4686 assert_eq!(state.surface, DevSurface::Agent);
4687 assert!(state.running_tool_job.is_none());
4688 std::fs::remove_dir_all(root).expect("remove temporary workspace");
4689 }
4690
4691 #[test]
4692 fn agent_editor_context_attaches_unsaved_buffer_and_inline_prompt() {
4693 let root =
4694 std::env::temp_dir().join(format!("glass-editor-agent-context-{}", std::process::id()));
4695 std::fs::create_dir_all(root.join("src")).expect("create source directory");
4696 std::fs::write(root.join("src/main.rs"), "fn main() {}\n").expect("write source");
4697 let mut state =
4698 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
4699 state
4700 .ws_mut()
4701 .expect("workspace lock")
4702 .project_mut()
4703 .open_buffer("src/main.rs", crate::development::Actor::local())
4704 .expect("open editor buffer");
4705 state
4706 .ws_mut()
4707 .expect("workspace lock")
4708 .project_mut()
4709 .edit_buffer(
4710 "src/main.rs",
4711 "fn main() {\n println!(\"unsaved\");\n}\n".into(),
4712 crate::development::Actor::local(),
4713 )
4714 .expect("edit buffer");
4715 state.refresh_editor_projection();
4716
4717 let context = state.agent_editor_context();
4718 assert_eq!(context["focusedPath"], "src/main.rs");
4719 assert_eq!(
4720 context["focusedBuffer"]["content"],
4721 "fn main() {\n println!(\"unsaved\");\n}\n"
4722 );
4723 assert_eq!(context["focusedBuffer"]["dirty"], true);
4724
4725 state.enter_code_edit();
4726 state.edit_code_key(
4727 crossterm::event::KeyCode::Char('a'),
4728 crossterm::event::KeyModifiers::ALT,
4729 );
4730 assert_eq!(state.surface, DevSurface::Agent);
4731 assert!(state.composer_mode);
4732 assert!(!state.code_edit_mode);
4733 assert!(state.composer_input.contains("src/main.rs:1:1"));
4734 assert!(state.composer_input.contains("Do not edit files"));
4735
4736 std::fs::remove_dir_all(root).expect("remove temporary workspace");
4737 }
4738
4739 #[test]
4740 fn editor_soft_wrap_toggle_scrolls_visual_rows_and_resets_horizontal_scroll() {
4741 let root =
4742 std::env::temp_dir().join(format!("glass-editor-soft-wrap-{}", std::process::id()));
4743 std::fs::create_dir_all(root.join("src")).expect("create source directory");
4744 let content = format!("{}\n", "word ".repeat(80));
4745 std::fs::write(root.join("src/main.rs"), content).expect("write source");
4746 let mut state =
4747 DevTuiState::open_for_tui(&root, TuiLayout::Mobile).expect("open temporary workspace");
4748 state
4749 .ws_mut()
4750 .expect("workspace lock")
4751 .project_mut()
4752 .open_buffer("src/main.rs", crate::development::Actor::local())
4753 .expect("open editor buffer");
4754 state
4755 .ws_mut()
4756 .expect("workspace lock")
4757 .project_mut()
4758 .set_buffer_cursor("src/main.rs", 1, 180)
4759 .expect("set editor cursor");
4760 state.refresh_editor_projection();
4761 state.set_terminal_size(32, 16);
4762 state.enter_code_edit();
4763 state.edit_code_key(
4764 crossterm::event::KeyCode::Char('w'),
4765 crossterm::event::KeyModifiers::ALT,
4766 );
4767
4768 assert!(state.editor_soft_wrap);
4769 assert!(state.editor_scroll_line > 0);
4770 assert_eq!(state.editor_scroll_column, 0);
4771 assert!(state.status.contains("Soft wrap ON"));
4772
4773 state.edit_code_key(
4774 crossterm::event::KeyCode::Char('w'),
4775 crossterm::event::KeyModifiers::ALT,
4776 );
4777 assert!(!state.editor_soft_wrap);
4778 assert!(state.editor_scroll_column > 0);
4779 assert!(state.status.contains("Soft wrap OFF"));
4780 std::fs::remove_dir_all(root).expect("remove temporary workspace");
4781 }
4782
4783 #[test]
4784 fn editor_cursor_scroll_matches_fullscreen_source_height() {
4785 let root =
4786 std::env::temp_dir().join(format!("glass-editor-viewport-{}", std::process::id()));
4787 std::fs::create_dir_all(root.join("src")).expect("create source directory");
4788 let content = (1..=30)
4789 .map(|line| format!("line {line}\n"))
4790 .collect::<String>();
4791 std::fs::write(root.join("src/main.rs"), content).expect("write source");
4792 let mut state =
4793 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
4794 state
4795 .ws_mut()
4796 .expect("workspace lock")
4797 .project_mut()
4798 .open_buffer("src/main.rs", crate::development::Actor::local())
4799 .expect("open editor buffer");
4800 state
4801 .ws_mut()
4802 .expect("workspace lock")
4803 .project_mut()
4804 .set_buffer_cursor("src/main.rs", 23, 1)
4805 .expect("set editor cursor");
4806 state.refresh_editor_projection();
4807 state.editor_scroll_line = 0;
4808 state.set_terminal_size(100, 30);
4809
4810 assert_eq!(state.focused_editor_line, 23);
4811 assert_eq!(
4812 state.editor_scroll_line, 1,
4813 "line 23 must scroll into the 22-row source viewport"
4814 );
4815 std::fs::remove_dir_all(root).expect("remove temporary workspace");
4816 }
4817
4818 #[test]
4819 fn editor_shift_selection_replaces_text_and_clears_anchor() {
4820 let root =
4821 std::env::temp_dir().join(format!("glass-editor-selection-{}", std::process::id()));
4822 std::fs::create_dir_all(root.join("src")).expect("create source directory");
4823 std::fs::write(root.join("src/main.rs"), "alpha\nbeta\n").expect("write source");
4824 let mut state =
4825 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
4826 state
4827 .ws_mut()
4828 .expect("workspace lock")
4829 .project_mut()
4830 .open_buffer("src/main.rs", crate::development::Actor::local())
4831 .expect("open editor buffer");
4832 state.refresh_editor_projection();
4833 state.enter_code_edit();
4834 for _ in 0..5 {
4835 state.edit_code_key(
4836 crossterm::event::KeyCode::Right,
4837 crossterm::event::KeyModifiers::SHIFT,
4838 );
4839 }
4840 assert!(
4841 state
4842 .focused_editor_selection
4843 .as_ref()
4844 .is_some_and(|selection| !selection.is_empty())
4845 );
4846 state.edit_code_key(
4847 crossterm::event::KeyCode::Char('X'),
4848 crossterm::event::KeyModifiers::empty(),
4849 );
4850 let buffer = state.focused_buffer().expect("focused editor buffer");
4851 assert_eq!(buffer.content, "X\nbeta\n");
4852 assert_eq!((buffer.cursor_line, buffer.cursor_column), (1, 2));
4853 assert!(buffer.selection.is_none());
4854 std::fs::remove_dir_all(root).expect("remove temporary workspace");
4855 }
4856
4857 #[test]
4858 fn editor_exit_prompts_save_discard_and_discard_quit() {
4859 let root = std::env::temp_dir().join(format!("glass-editor-exit-{}", std::process::id()));
4860 std::fs::create_dir_all(root.join("src")).expect("create source directory");
4861 let original = "fn main() {}\n";
4862 std::fs::write(root.join("src/main.rs"), original).expect("write source");
4863 let mut state =
4864 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
4865 state
4866 .ws_mut()
4867 .expect("workspace lock")
4868 .project_mut()
4869 .open_buffer("src/main.rs", crate::development::Actor::local())
4870 .expect("open editor buffer");
4871 state.refresh_editor_projection();
4872 state.enter_code_edit();
4873 state.edit_code_key(
4874 crossterm::event::KeyCode::Char('#'),
4875 crossterm::event::KeyModifiers::NONE,
4876 );
4877 state.request_editor_exit();
4878 assert_eq!(state.editor_exit_prompt, Some(EditorExitPrompt::Unsaved));
4879 state.handle_editor_exit_key(crossterm::event::KeyCode::Char('d'));
4880 assert!(!state.code_edit_mode);
4881 assert_eq!(
4882 std::fs::read_to_string(root.join("src/main.rs")).expect("read source"),
4883 original
4884 );
4885
4886 state.enter_code_edit();
4887 state.edit_code_key(
4888 crossterm::event::KeyCode::Char('#'),
4889 crossterm::event::KeyModifiers::NONE,
4890 );
4891 state.request_editor_exit();
4892 state.handle_editor_exit_key(crossterm::event::KeyCode::Char('s'));
4893 assert!(!state.code_edit_mode);
4894 assert!(
4895 std::fs::read_to_string(root.join("src/main.rs"))
4896 .expect("read saved source")
4897 .starts_with('#')
4898 );
4899 let saved = std::fs::read_to_string(root.join("src/main.rs")).expect("read saved source");
4900
4901 state.enter_code_edit();
4902 state.edit_code_key(
4903 crossterm::event::KeyCode::Char('!'),
4904 crossterm::event::KeyModifiers::NONE,
4905 );
4906 state.request_editor_exit();
4907 state.handle_editor_exit_key(crossterm::event::KeyCode::Char('q'));
4908 assert!(state.quit);
4909 assert_eq!(
4910 std::fs::read_to_string(root.join("src/main.rs")).expect("read discarded source"),
4911 saved
4912 );
4913 std::fs::remove_dir_all(root).expect("remove temporary workspace");
4914 }
4915
4916 #[test]
4917 fn conversation_view_does_not_echo_pending_message_after_snapshot() {
4918 let root = std::env::temp_dir().join(format!("glass-chat-merge-{}", std::process::id()));
4919 std::fs::create_dir_all(&root).expect("create temporary workspace");
4920 let mut state =
4921 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
4922 state.agent_conversation = "YOU\ninspect the failing test\n\nGLASS AGENT\nworking".into();
4923 state.pending_chat_messages.push(PendingChatMessage {
4924 text: "inspect the failing test".into(),
4925 state: ChatMessageState::Sent,
4926 job_id: None,
4927 error: None,
4928 });
4929
4930 let view = state.conversation_view();
4931 assert_eq!(view.matches("YOU\ninspect the failing test").count(), 1);
4932 assert!(!view.contains("Glass Agent is thinking"));
4933
4934 std::fs::remove_dir_all(root).expect("remove temporary workspace");
4935 }
4936
4937 #[test]
4938 fn palette_filters_actions_and_prefills_selected_arguments() {
4939 let root =
4940 std::env::temp_dir().join(format!("glass-palette-actions-{}", std::process::id()));
4941 std::fs::create_dir_all(&root).expect("create temporary workspace");
4942 let mut state =
4943 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
4944 state.surface = DevSurface::Agent;
4945 state.open_palette();
4946 state.insert_palette_text("agent setup");
4947 assert_eq!(
4948 state.selected_palette_action().map(|action| action.label),
4949 Some("Setup Pi runtime")
4950 );
4951 state.move_palette_selection(1);
4952 assert_eq!(
4953 state.selected_palette_action().map(|action| action.label),
4954 Some("Authenticate")
4955 );
4956
4957 state.open_palette_with("agent rewind ENTRY_ID");
4958 let action = state.selected_palette_action().expect("rewind action");
4959 assert_eq!(action.label, "Rewind Pi session");
4960 assert!(state.prepare_palette_action(action).is_none());
4961 assert!(state.command_mode);
4962 assert_eq!(state.command_input, "agent rewind ");
4963 assert!(state.status.contains("required value"));
4964
4965 std::fs::remove_dir_all(root).expect("remove temporary workspace");
4966 }
4967
4968 #[test]
4969 fn arrow_surface_cycle_matches_layout_order() {
4970 let root =
4971 std::env::temp_dir().join(format!("glass-surface-arrows-{}", std::process::id()));
4972 std::fs::create_dir_all(&root).expect("create temporary workspace");
4973 let mut desktop =
4974 DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open desktop workspace");
4975 desktop.surface = DevSurface::Agent;
4976 desktop.next_surface();
4977 assert_eq!(desktop.surface, DevSurface::Code);
4978 assert_eq!(desktop.status, "Code selected");
4979 desktop.previous_surface();
4980 assert_eq!(desktop.surface, DevSurface::Agent);
4981 desktop.surface = DevSurface::Debug;
4982 desktop.next_surface();
4983 assert_eq!(desktop.surface, DevSurface::More);
4984 desktop.next_surface();
4985 assert_eq!(desktop.surface, DevSurface::Agent);
4986
4987 let mut phone =
4988 DevTuiState::open_for_tui(&root, TuiLayout::Mobile).expect("open phone workspace");
4989 phone.surface = DevSurface::Agent;
4990 phone.previous_surface();
4991 assert_eq!(phone.surface, DevSurface::More);
4992 assert_eq!(phone.status, "More selected");
4993 phone.next_surface();
4994 assert_eq!(phone.surface, DevSurface::Agent);
4995
4996 std::fs::remove_dir_all(root).expect("remove temporary workspace");
4997 }
4998}