Lightweight coding agent that runs in your terminal
Rust
Show a hand pointer over transcript links in Ghostty and Kitty (#48827)
Benjamin Carlsson6af89155d040
diff --git a/codex-rs/tui/src/app.rs b/codex-rs/tui/src/app.rsindex 69dd396284..de47e41f7b 100644--- a/codex-rs/tui/src/app.rs+++ b/codex-rs/tui/src/app.rs@@ -225,6 +225,7 @@ mod file_change_approvals;mod history_pagination;mod history_ui;mod input;+mod link_hover;mod loaded_threads;mod managed_worktree_creation;mod misalignment_policy;@@ -834,6 +835,8 @@ impl App {app_server: &mut AppServerSession,event: TuiEvent,) -> Result<AppRunControl> {+ tui.link_hover.observe(&event);+ self.refresh_link_hover(tui)?;self.invalidate_right_click_paste(&event);self.finish_clipboard(tui);let event = self.finish_right_click_paste(tui, event);diff --git a/codex-rs/tui/src/app/link_hover.rs b/codex-rs/tui/src/app/link_hover.rsnew file mode 100644index 0000000000..ded238824e--- /dev/null+++ b/codex-rs/tui/src/app/link_hover.rs@@ -0,0 +1,26 @@+//! Match transcript hover to the links Codex opens while terminal mouse input is captured.+//! Recheck after painting so scrolling and live output cannot leave a hand over stale content.++use crossterm::event::KeyModifiers;++use super::App;+use crate::tui::Tui;++impl App {+ pub(super) fn refresh_link_hover(&self, tui: &mut Tui) -> std::io::Result<()> {+ let over_link = tui.is_owned_screen()+ && self.overlay.is_none()+ && self.chat_widget.no_modal_or_popup_active()+ && tui.link_hover.mouse.is_some_and(|mouse| {+ (mouse.modifiers.is_empty()+ || mouse+ .modifiers+ .intersects(KeyModifiers::CONTROL | KeyModifiers::SUPER))+ && self+ .transcript_view+ .link_at(mouse.column, mouse.row)+ .is_some()+ });+ tui.set_link_pointer(over_link)+ }+}diff --git a/codex-rs/tui/src/app/owned_transcript.rs b/codex-rs/tui/src/app/owned_transcript.rsindex f8fd7db1e1..2e07262b2c 100644--- a/codex-rs/tui/src/app/owned_transcript.rs+++ b/codex-rs/tui/src/app/owned_transcript.rs@@ -280,6 +280,7 @@ impl App {tui.frame_requester().schedule_frame_in(Duration::from_millis(/*millis*/ 50));}+ self.refresh_link_hover(tui)?;Ok(bottom_area)}diff --git a/codex-rs/tui/src/transcript_view/input.rs b/codex-rs/tui/src/transcript_view/input.rsindex f92a319bb7..83c7cc052d 100644--- a/codex-rs/tui/src/transcript_view/input.rs+++ b/codex-rs/tui/src/transcript_view/input.rs@@ -80,6 +80,15 @@ impl JumpTarget {}impl TranscriptView {+ /// Resolve links in the last rendered transcript, sharing geometry with click activation.+ pub(crate) fn link_at(&self, column: u16, row: u16) -> Option<String> {+ if !self.area.contains(ScreenPosition::new(column, row)) {+ return None;+ }+ let visible = self.visible.get(usize::from(row - self.area.y))?;+ visible.layout.link_at(visible.row, column - self.area.x)+ }+pub(crate) fn navigate_pager(&mut self,key: KeyEvent,@@ -243,15 +252,7 @@ impl TranscriptView {.flatten()});let link = link.filter(|destination| {- self.visible- .get(usize::from(event.row - self.area.y))- .and_then(|visible| {- visible- .layout- .link_at(visible.row, event.column - self.area.x)- })- .as_ref()- == Some(destination)+ self.link_at(event.column, event.row).as_ref() == Some(destination)});if self.selection@@ -358,9 +359,8 @@ impl TranscriptView {.modifiers.intersects(KeyModifiers::CONTROL | KeyModifiers::SUPER){- return visible- .layout- .link_at(visible.row, event.column.saturating_sub(self.area.x))+ return self+ .link_at(event.column, event.row).map(ViewAction::OpenLink);}if event.modifiers == KeyModifiers::SHIFT && self.has_selection_range() {@@ -383,11 +383,7 @@ impl TranscriptView {return None;}let link = (clicks == 1 && event.modifiers.is_empty())- .then(|| {- visible- .layout- .link_at(visible.row, event.column.saturating_sub(self.area.x))- })+ .then(|| self.link_at(event.column, event.row)).flatten();self.begin_selection(cells, event.column, event.row, clicks);if let Some(selection) = &mut self.selection {diff --git a/codex-rs/tui/src/transcript_view/input_tests.rs b/codex-rs/tui/src/transcript_view/input_tests.rsindex 92e0719ce2..45f408cce4 100644--- a/codex-rs/tui/src/transcript_view/input_tests.rs+++ b/codex-rs/tui/src/transcript_view/input_tests.rs@@ -24,6 +24,50 @@ fn mouse(kind: MouseEventKind, column: u16, row: u16) -> MouseEvent {}}+#[test]+fn hover_links_match_wrapped_click_targets_and_refresh_after_scrolling() {+ let (mut view, cells) = transcript(+ "before [wide 界 wrapped label](https://example.com) after\n\nplain\n\nmore\n\nlast",+ /*width*/ 12,+ );+ let area = view.area;+ view.jump_to_beginning(&cells);+ view.render(area, &mut Buffer::empty(area), &cells);+ let mut targets = Vec::new();+ for row in area.y..area.bottom() {+ for column in area.x..area.right() {+ if let Some(url) = view.link_at(column, row) {+ targets.push((column, row, url));+ }+ }+ }+ assert!(!targets.is_empty());+ assert!(targets.iter().any(|(_, row, _)| *row != targets[0].1));+ for (column, row, url) in &targets {+ let action = view.handle_mouse(+ MouseEvent {+ modifiers: KeyModifiers::CONTROL,+ ..mouse(MouseEventKind::Down(MouseButton::Left), *column, *row)+ },+ &cells,+ );+ let actual = match action {+ Some(ViewAction::OpenLink(url)) => Some(url),+ _ => None,+ };+ assert_eq!(actual.as_ref(), Some(url));+ }+ assert_eq!(view.link_at(area.x - 1, area.y), None);+ assert_eq!(view.link_at(area.right(), area.y), None);+ view.scroll(&cells, /*rows*/ 20);+ view.render(area, &mut Buffer::empty(area), &cells);+ assert!(+ targets+ .iter()+ .any(|(column, row, _)| view.link_at(*column, *row).is_none())+ );+}+#[test]fn shift_click_extends_a_double_clicked_word_in_both_directions() {let (mut view, cells) = transcript("alpha beta gamma", /*width*/ 24);diff --git a/codex-rs/tui/src/tui.rs b/codex-rs/tui/src/tui.rsindex 27b1950d0a..50b4e80e76 100644--- a/codex-rs/tui/src/tui.rs+++ b/codex-rs/tui/src/tui.rs@@ -70,6 +70,7 @@ mod input_boundary;#[cfg(unix)]mod job_control;mod keyboard_modes;+mod link_pointer;#[cfg(test)]#[path = "tui/owned_screen_tests.rs"]mod owned_screen_tests;@@ -651,6 +652,7 @@ impl OverlayInput {}pub struct Tui {+ pub(crate) link_hover: link_pointer::LinkHover,frame_requester: FrameRequester,draw_tx: broadcast::Sender<()>,event_broker: Arc<EventBroker>,@@ -727,6 +729,7 @@ impl Tui {);Self {+ link_hover: link_pointer::LinkHover::default(),frame_requester,draw_tx,event_broker: Arc::new(event_broker),@@ -855,6 +858,7 @@ impl Tui {// Drop crossterm EventStream to avoid stdin conflicts with other processes.pub fn pause_events(&mut self) {+ self.link_hover.mouse = None;self.event_broker.pause_events();}diff --git a/codex-rs/tui/src/tui/alternate_screen.rs b/codex-rs/tui/src/tui/alternate_screen.rsindex 2d5e94f083..2313da69df 100644--- a/codex-rs/tui/src/tui/alternate_screen.rs+++ b/codex-rs/tui/src/tui/alternate_screen.rs@@ -33,10 +33,12 @@ pub(super) static ALTERNATE_SCREEN: AlternateScreen = AlternateScreen {mouse_capture_disabled: AtomicBool::new(/*v*/ false),input_configured: AtomicBool::new(/*v*/ false),keyboard_active: AtomicBool::new(/*v*/ false),+ link_pointer: super::link_pointer::LinkPointer::new(),};#[derive(Default)]pub(super) struct AlternateScreen {+ link_pointer: super::link_pointer::LinkPointer,active: AtomicBool,mouse_active: AtomicBool,// Refresh alongside keyboard modes whenever this screen is entered or restored.@@ -67,6 +69,15 @@ impl Command for EnablePointerCapture {}impl AlternateScreen {+ pub(super) fn set_link_pointer(&self, writer: &mut impl Write, over_link: bool) -> Result<()> {+ if self.mouse_active.load(Ordering::Relaxed) {+ self.link_pointer.update(writer, over_link)+ } else {+ self.link_pointer+ .restore(writer, codex_terminal_detection::terminal_info().name)+ }+ }+pub(super) fn is_active(&self) -> bool {self.active.load(Ordering::Relaxed)}@@ -116,6 +127,9 @@ impl AlternateScreen {}fn disable_mouse(&self, writer: &mut impl Write) -> Result<()> {+ let pointer_result = self+ .link_pointer+ .restore(writer, codex_terminal_detection::terminal_info().name);if self.mouse_active.load(Ordering::Relaxed) {let result = execute!(writer, DisableMouseCapture);#[cfg(windows)]@@ -144,7 +158,7 @@ impl AlternateScreen {self.mouse_active.store(/*val*/ false, Ordering::Relaxed);}- Ok(())+ pointer_result}/// Release input modes without changing the screen, so an editor can take it over.diff --git a/codex-rs/tui/src/tui/link_pointer.rs b/codex-rs/tui/src/tui/link_pointer.rsnew file mode 100644index 0000000000..b10ee5b87f--- /dev/null+++ b/codex-rs/tui/src/tui/link_pointer.rs@@ -0,0 +1,110 @@+//! Link hover owns the mouse shape only while Codex captures pointer input.+//! Remember motion across repaints, but discard coordinates across focus and geometry changes.+//! Cleanup is independent of Tui so panic, suspend, and editor handoffs also restore the shape.+//! Kitty releases its override; Ghostty retains its existing text-cursor fallback.++use std::io::Write;+use std::sync::atomic::AtomicU8;+use std::sync::atomic::Ordering;++use codex_terminal_detection::TerminalName;+use crossterm::event::MouseEvent;+use crossterm::event::MouseEventKind;++use super::Tui;+use super::TuiEvent;++#[derive(Default)]+pub(crate) struct LinkHover {+ pub(crate) mouse: Option<MouseEvent>,+}++impl LinkHover {+ pub(crate) fn observe(&mut self, event: &TuiEvent) {+ match event {+ TuiEvent::Mouse(mouse) => {+ self.mouse = (!matches!(+ mouse.kind,+ MouseEventKind::Down(_) | MouseEventKind::Drag(_)+ ))+ .then_some(*mouse);+ }+ TuiEvent::Key(key) => {+ if let Some(mouse) = &mut self.mouse {+ mouse.modifiers = key.modifiers;+ }+ }+ TuiEvent::FocusLost | TuiEvent::Resize(_) | TuiEvent::Resume => self.mouse = None,+ _ => {}+ }+ }+}++// 0: untouched/restored, 1: captured arrow, 2: link hand, 3: uncertain after a write failure.+// Keep cleanup armed until flush succeeds.+#[derive(Default)]+pub(super) struct LinkPointer(AtomicU8);++impl LinkPointer {+ pub(super) const fn new() -> Self {+ Self(AtomicU8::new(/*v*/ 0))+ }++ pub(super) fn update(&self, writer: &mut impl Write, over_link: bool) -> std::io::Result<()> {+ let previous = self.0.load(Ordering::Relaxed);+ let next = if over_link { 2 } else { 1 };+ if previous == next || (previous == 0 && !over_link) {+ return Ok(());+ }+ self.0.store(next, Ordering::Relaxed);+ let result = writer+ .write_all(if over_link {+ b"\x1b]22;pointer\x1b\\"+ } else {+ b"\x1b]22;default\x1b\\"+ })+ .and_then(|()| writer.flush());+ if result.is_err() {+ self.0.store(/*val*/ 3, Ordering::Relaxed);+ }+ result+ }++ pub(super) fn restore(+ &self,+ writer: &mut impl Write,+ terminal: TerminalName,+ ) -> std::io::Result<()> {+ if self.0.load(Ordering::Relaxed) != 0 {+ // In Kitty, a named shape persists across mouse capture and screen changes.+ // An empty OSC 22 releases that override back to the terminal's default policy.+ writer.write_all(if terminal == TerminalName::Kitty {+ b"\x1b]22;\x1b\\"+ } else {+ b"\x1b]22;text\x1b\\"+ })?;+ writer.flush()?;+ self.0.store(/*val*/ 0, Ordering::Relaxed);+ }+ Ok(())+ }+}++impl Tui {+ pub(crate) fn set_link_pointer(&mut self, over_link: bool) -> std::io::Result<()> {+ // OSC 22 names differ between terminals. Restrict CSS names to known implementations;+ // multiplexers may consume OSC 22 and do not promise pointer-shape passthrough.+ let info = codex_terminal_detection::terminal_info();+ if info.multiplexer.is_none()+ && matches!(info.name, TerminalName::Ghostty | TerminalName::Kitty)+ {+ super::alternate_screen::ALTERNATE_SCREEN+ .set_link_pointer(self.terminal.backend_mut(), over_link)?;+ }+ Ok(())+ }+}++#[cfg(test)]+#[path = "link_pointer_tests.rs"]+mod tests;diff --git a/codex-rs/tui/src/tui/link_pointer_tests.rs b/codex-rs/tui/src/tui/link_pointer_tests.rsnew file mode 100644index 0000000000..2529747cf0--- /dev/null+++ b/codex-rs/tui/src/tui/link_pointer_tests.rs@@ -0,0 +1,129 @@+use super::*;+use crossterm::event::KeyModifiers;+use crossterm::event::MouseButton;+use pretty_assertions::assert_eq;++#[test]+fn hover_transitions_are_deduplicated_and_restore_after_leaving_a_link() {+ let mut frames = Vec::new();+ for terminal in [TerminalName::Ghostty, TerminalName::Kitty] {+ let pointer = LinkPointer::default();+ let mut output = Vec::new();+ for over_link in [false, true, true, false, false, true] {+ pointer.update(&mut output, over_link).unwrap();+ frames.push(String::from_utf8(std::mem::take(&mut output)).unwrap());+ }+ pointer.restore(&mut output, terminal).unwrap();+ frames.push(String::from_utf8(std::mem::take(&mut output)).unwrap());+ pointer.restore(&mut output, terminal).unwrap();+ // Re-entering capture off a link must preserve the restored terminal policy.+ pointer.update(&mut output, /*over_link*/ false).unwrap();+ assert_eq!(output, Vec::<u8>::new());+ pointer.update(&mut output, /*over_link*/ true).unwrap();+ frames.push(String::from_utf8(output).unwrap());+ }+ insta::assert_debug_snapshot!(frames, @r#"+ [+ "",+ "\u{1b}]22;pointer\u{1b}\\",+ "",+ "\u{1b}]22;default\u{1b}\\",+ "",+ "\u{1b}]22;pointer\u{1b}\\",+ "\u{1b}]22;text\u{1b}\\",+ "\u{1b}]22;pointer\u{1b}\\",+ "",+ "\u{1b}]22;pointer\u{1b}\\",+ "",+ "\u{1b}]22;default\u{1b}\\",+ "",+ "\u{1b}]22;pointer\u{1b}\\",+ "\u{1b}]22;\u{1b}\\",+ "\u{1b}]22;pointer\u{1b}\\",+ ]+ "#);+}++#[test]+#[cfg(unix)]+fn capture_release_restores_pointer_even_after_moving_off_link() {+ for over_link in [true, false] {+ let screen = super::super::alternate_screen::AlternateScreen::default();+ let mut output = Vec::new();+ screen+ .configure_input(&mut output, /*capture_mouse*/ true)+ .unwrap();+ screen+ .set_link_pointer(&mut output, /*over_link*/ true)+ .unwrap();+ screen.set_link_pointer(&mut output, over_link).unwrap();+ output.clear();+ screen.release_input(&mut output).unwrap();+ let expected = if codex_terminal_detection::terminal_info().name == TerminalName::Kitty {+ b"\x1b]22;\x1b\\".as_slice()+ } else {+ b"\x1b]22;text\x1b\\".as_slice()+ };+ assert!(output.starts_with(expected));+ output.clear();+ screen+ .set_link_pointer(&mut output, /*over_link*/ true)+ .unwrap();+ assert_eq!(output, Vec::<u8>::new());+ }+}++#[test]+fn failed_write_is_retried_and_cleanup_remains_armed() {+ struct Fails;+ impl Write for Fails {+ fn write(&mut self, _: &[u8]) -> std::io::Result<usize> {+ Err(std::io::Error::other("write failed"))+ }+ fn flush(&mut self) -> std::io::Result<()> {+ Ok(())+ }+ }+ for (terminal, expected) in [+ (TerminalName::Ghostty, b"\x1b]22;text\x1b\\".as_slice()),+ (TerminalName::Kitty, b"\x1b]22;\x1b\\".as_slice()),+ ] {+ let pointer = LinkPointer::default();+ assert!(pointer.update(&mut Fails, /*over_link*/ true).is_err());+ let mut output = Vec::new();+ pointer.update(&mut output, /*over_link*/ true).unwrap();+ assert_eq!(output, b"\x1b]22;pointer\x1b\\");+ assert!(pointer.restore(&mut Fails, terminal).is_err());+ output.clear();+ pointer.restore(&mut output, terminal).unwrap();+ assert_eq!(output, expected);+ }+}++#[test]+fn motion_survives_repaint_but_not_drag_focus_loss_resize_or_resume() {+ let mouse = MouseEvent {+ kind: MouseEventKind::Moved,+ column: 8,+ row: 3,+ modifiers: KeyModifiers::NONE,+ };+ for event in [+ TuiEvent::Mouse(MouseEvent {+ kind: MouseEventKind::Drag(MouseButton::Left),+ ..mouse+ }),+ TuiEvent::FocusLost,+ TuiEvent::Resize(ratatui::layout::Size::new(+ /*width*/ 80, /*height*/ 24,+ )),+ TuiEvent::Resume,+ ] {+ let mut hover = LinkHover::default();+ hover.observe(&TuiEvent::Mouse(mouse));+ hover.observe(&TuiEvent::Draw);+ assert_eq!(hover.mouse, Some(mouse));+ hover.observe(&event);+ assert_eq!(hover.mouse, None);+ }+}