feat(tui): copy log lines from the log viewer

[johntmyers]

Problem Statement

Users need to copy log content out of the TUI log viewer — for pasting into bug reports, Slack messages, scripts, or further analysis. Currently there is no clipboard integration at all; the only option is native terminal mouse selection, which is cumbersome when mouse capture is active (for scroll support) and impossible for copying filtered/structured data cleanly.

Technical Context

The TUI log viewer (crates/navigator-tui/src/ui/sandbox_logs.rs) renders structured log lines with timestamp, source, level, message, and key=value fields. It supports vim-style scrolling (j/k/g/G), autoscroll/follow mode, source filtering, and a detail popup for individual lines. The viewer already tracks a cursor position (log_cursor) and scroll offset (sandbox_log_scroll) over a filtered view of Vec<LogLine>. No clipboard or selection code exists today.

Affected Components

Component	Key Files	Role
App state	crates/navigator-tui/src/app.rs	LogLine struct (L51-59), log state fields (L347-359), key handler handle_logs_key (L887-962)
Log renderer	crates/navigator-tui/src/ui/sandbox_logs.rs	draw() (L11-104), render_log_line() (L215-250), detail popup (L110-188)
Event system	crates/navigator-tui/src/event.rs	Event enum (L12-35) — may need new variant for copy feedback
Nav bar / chrome	crates/navigator-tui/src/ui/mod.rs	Key hints for SandboxLogs focus (L226-264)
Main loop	crates/navigator-tui/src/lib.rs	Mouse event handling (L224-230), log stream management

Technical Investigation

Current Log Viewer Architecture

Data model: Vec<LogLine> stored on App, filtered by LogSourceFilter via filtered_log_lines() (app.rs:472-481). Each LogLine has: timestamp_ms, level, source, target, message, fields: HashMap<String, String>.

Viewport model: sandbox_log_scroll (first visible line index in filtered list) + log_cursor (offset from scroll position). Absolute selected index = scroll + cursor. log_viewport_height is set each frame by the draw pass (area.height - 2 for borders).

Rendering: Each line is rendered as styled spans: HH:MM:SS {source:7} {level:5} {message} {key=value ...}, truncated to viewport width with …. The detail popup shows the full untruncated content.

Key bindings in use: j/k (navigate), g/G (top/bottom), f (follow), s (source filter), Enter (detail popup), Esc (back), q (quit), r (rules), p (policy). Available keys: y, v, Y, c, C, Shift+arrows, Ctrl+O, Ctrl+S are all unbound.

Clipboard Mechanism: Manual OSC 52

Write \x1b]52;c;{base64}\x07 directly to stdout. The terminal emulator intercepts this and copies to the system clipboard.

• Works over SSH/tmux/mosh — the escape sequence forwards through the connection to the local terminal
• Zero new dependencies — only needs base64 encoding
• Supported by: iTerm2, Alacritty, Kitty, WezTerm, Windows Terminal, Konsole, foot, xterm
• Limitation: Write-only (no paste), fire-and-forget (no success/failure feedback), some terminals disable by default
• Decision: Manual implementation (~5 lines), not upgrading crossterm from 0.28 to 0.29 for built-in support

Decisions Made

Decision	Resolution
Clipboard format	Match display format as-is: HH:MM:SS {source:7} {level:5} {message} {key=value ...}
Copy feedback	No feedback toast/status message — silent fire-and-forget
crossterm upgrade	Manual OSC 52 implementation, stay on crossterm 0.28

Copy UX Features

Feature 1: Copy Current Line (y)

Single keypress copies the line at the cursor.

• Key: y (vim yank convention)
• What's copied: Plain text rendering of the log line matching display format, ANSI codes stripped
• Implementation: Read filtered_log_lines()[scroll + cursor], format as plain text, write via OSC 52
• Complexity: Low — ~30 lines of new code

Feature 2: Copy Viewport (Y)

Copy all lines currently visible in the viewport.

• Key: Y (capital Y — "yank all visible")
• What's copied: All visible lines joined with newlines, plain text
• Implementation: Slice filtered_log_lines()[scroll..scroll+viewport_height], format each, join with \n
• Complexity: Low — reuses the single-line formatter

Feature 3: Visual Selection Mode (v + j/k + y)

Vim-style visual mode for selecting a range of lines.

• Enter: v to enter visual/selection mode
• Extend: j/k/Up/Down/g/G move the cursor while anchor stays fixed
• Copy: y yanks the selected range
• Cancel: Esc exits visual mode without copying
• Visual indicator: Selected lines get a distinct background highlight (new Theme field, e.g., selection style)
• Status bar: Show "VISUAL" mode indicator plus line count "3 lines selected"

State model additions:

selection_mode: bool
selection_anchor: Option<usize>  // absolute index in filtered list where 'v' was pressed

Selected range = min(anchor, cursor)..=max(anchor, cursor) in the filtered log lines.

• Complexity: Medium — new mode, modified key dispatch, selection rendering, ~100-150 lines

Feature 4: Shift+Arrow Range Select (Alternative to v-mode)

• Key: Shift+Up / Shift+Down extends selection from current cursor
• Copy: y yanks, Esc clears selection
• Note: Some terminals don't distinguish Shift+Up from Up — less reliable than v-mode
• Complexity: Low incremental if v-mode exists — additional entry point into selection state

Feature 5: Export to File (Ctrl+S / :export)

For large log volumes where clipboard is impractical.

• Key: Ctrl+S (k9s screendump convention) or :export command
• What's exported: All filtered log lines to a timestamped file
• Path: $TMPDIR/openshell-logs-{sandbox}-{timestamp}.log
• Complexity: Low-Medium — file I/O, path formatting, ~50 lines

Code References

Location	Description
app.rs:51-59	LogLine struct — needs a to_plain_text() or Display impl for clipboard formatting
app.rs:347-359	Log state fields — needs selection_mode, selection_anchor additions
app.rs:887-962	handle_logs_key() — add y/Y/v key arms, modify j/k to extend selection in visual mode
sandbox_logs.rs:60-76	Line rendering loop — needs selection highlight logic (distinct from cursor highlight)
sandbox_logs.rs:79-97	Status bar — needs mode indicator ("VISUAL") and selection count
sandbox_logs.rs:215-250	render_log_line() — reuse for plain-text clipboard formatting (strip styles)
ui/mod.rs:226-264	Nav bar hints — add [y] Copy [v] Select [Y] Copy View hints
theme.rs	Need a selection style for highlighted selected lines (distinct from log_cursor)

Patterns to Follow

• k9s autoscroll pattern is already implemented — selection mode should auto-pause autoscroll
• Detail popup pattern (Enter to open, Esc to close) — copy could work from within the popup too
• Nav bar key hints are context-sensitive — selection mode should show different hints
• InputMode enum already exists for command mode — visual/selection mode is analogous
• Status feedback pattern: status_text on App is used for transient messages

Proposed Approach

Implement in phases: (1) y to copy current line and Y to copy viewport using manual OSC 52 — covers the most common use case with minimal code. (2) v-mode visual selection with j/k to extend and y to yank — covers multi-line selection. (3) Optionally Shift+Up/Down as alternative selection entry and Ctrl+S / :export for file export. Clipboard format matches the display rendering. No new crate dependencies. No copy feedback UI.

Scope Assessment

• Complexity: Medium (Phase 1 is Low, Phase 2 is Medium)
• Confidence: High — clear path, well-understood patterns, no architectural unknowns
• Estimated files to change: 5 (app.rs, sandbox_logs.rs, ui/mod.rs, theme.rs, event.rs)
• Issue type: feat

Risks & Open Questions

• OSC 52 terminal coverage: Not all terminals support it (notably older macOS Terminal.app versions, some Linux TTYs). Silent failure — the sequence is just ignored. Users on unsupported terminals still have native Shift+click selection as fallback.
• Large clipboard payloads: Some terminals truncate OSC 52 payloads (e.g., xterm limits to ~100KB base64). File export (Ctrl+S) is the right mechanism for large volumes.
• Mouse capture interaction: When mouse capture is on, native terminal selection is blocked. Adding v-mode is the right answer. Shift+click bypasses mouse capture in most terminals as a fallback.
• Selection mode + autoscroll conflict: Visual selection mode must auto-pause autoscroll to prevent the selection from shifting under the user.
• Shift+arrow reliability: Some terminals don't report Shift+Up distinctly from Up. v-mode is the primary mechanism; shift+arrow is best-effort.

Test Considerations

• Unit tests for plain text formatting: Test LogLine::to_plain_text() output for various line shapes (with/without fields, long messages, special characters)
• Unit tests for selection range math: Test selection_anchor + cursor → range calculation, edge cases (anchor == cursor, anchor > cursor, empty log list)
• Integration: Manual testing is primary — clipboard operations are inherently side-effectful. Test across iTerm2, Alacritty, and at least one Linux terminal. Test over SSH.
• No existing test infrastructure for the TUI crate — tests would be the first in this crate

---

Created by spike investigation. Use build-from-issue to plan and implement.

[johntmyers]

🏗️ build-plan

Implementation Plan

Issue type: feat
Complexity: Medium
Confidence: High — all insertion points identified, no architectural unknowns

Summary

Add clipboard copy support to the TUI log viewer using OSC 52 escape sequences. Phase 1 adds y (copy current line) and Y (copy viewport). Phase 2 adds v-mode visual selection with j/k navigation and y to yank the selected range. No new crate dependencies beyond base64 for OSC 52 encoding. No copy feedback UI — silent fire-and-forget per decision.

Scope

• Cargo.toml (root): add base64 = "0.22" to [workspace.dependencies]
• crates/navigator-tui/Cargo.toml: add base64 = { workspace = true }
• crates/navigator-tui/src/clipboard.rs (new): small module (~15 lines) with copy_to_clipboard(text) using OSC 52 escape sequence
• crates/navigator-tui/src/app.rs: add log_selection_anchor: Option<usize> field, add y/Y/v key handling in handle_logs_key(), clear selection state in reset_sandbox_state()
• crates/navigator-tui/src/ui/sandbox_logs.rs: make format_short_time() and ordered_fields() pub(crate), add pub(crate) fn format_log_line_plain(), add selection highlight rendering in draw(), update status bar for VISUAL mode indicator
• crates/navigator-tui/src/ui/mod.rs: update nav bar hints for [y] Copy [Y] Copy All [v] Select in normal mode, and [y] Yank [Esc] Cancel in visual mode
• crates/navigator-tui/src/theme.rs: add log_selection: Style field for visual-select line highlight
• crates/navigator-tui/src/lib.rs: add mod clipboard; declaration

Implementation Steps

Phase 1 — Copy current line / viewport

1. Add base64 dependency. Add base64 = "0.22" to workspace [workspace.dependencies] in root Cargo.toml. Add base64 = { workspace = true } to crates/navigator-tui/Cargo.toml.

2. Create clipboard.rs module. New file crates/navigator-tui/src/clipboard.rs with a single pub fn copy_to_clipboard(text: &str) that writes \x1b]52;c;{base64}\x07 to stdout via std::io::Write. Add mod clipboard; in lib.rs.

3. Expose formatting helpers. In sandbox_logs.rs, change fn format_short_time → pub(crate) fn format_short_time and fn ordered_fields → pub(crate) fn ordered_fields. Add a new pub(crate) fn format_log_line_plain(log: &LogLine) -> String that produces the same format as render_log_line() but as a plain String without styles or truncation: "HH:MM:SS {source:<7} {level:<5} {message} [key=value ...]".

4. Add y and Y keybindings. In app.rs handle_logs_key(), add two new match arms before _ => {}:

   • KeyCode::Char('y'): if filtered_len > 0, get the line at scroll + cursor, call format_log_line_plain(), call clipboard::copy_to_clipboard().
   • KeyCode::Char('Y'): get the visible slice filtered[scroll..scroll+vh], format each with format_log_line_plain(), join with \n, call clipboard::copy_to_clipboard().

5. Update nav bar hints. In ui/mod.rs draw_nav_bar(), in the Focus::SandboxLogs arm, add [y] Copy [Y] Copy All spans after [s] Source: ... and before the | separator.

Phase 2 — Visual selection mode

6. Add log_selection style to Theme. In theme.rs, add pub log_selection: Style field after log_cursor (line 73). In dark(): log_selection: Style::new().bg(Color::Rgb(30, 60, 45)) (slightly lighter than EVERGLADE). In light(): log_selection: Style::new().bg(Color::Rgb(215, 235, 200)) (pale green, distinct from cursor). Update the two theme tests.

7. Add selection state to App. In app.rs, add pub log_selection_anchor: Option<usize> field after log_detail_index (~line 357). Initialize to None in App::new(). Clear to None in reset_sandbox_state().

8. Add v-mode key handling. In handle_logs_key():

   • KeyCode::Char('v'): if log_selection_anchor.is_some() → clear it (toggle off). Otherwise → set log_selection_anchor = Some(scroll + cursor), set log_autoscroll = false.
   • Modify KeyCode::Char('y') arm: if log_selection_anchor.is_some(), compute range min(anchor, scroll+cursor)..=max(anchor, scroll+cursor), format all lines in range, copy, then clear anchor. Otherwise, copy single line as in Phase 1.
   • KeyCode::Esc: if log_selection_anchor.is_some() → clear it and return (don't navigate away). Otherwise existing behavior.

9. Add selection highlighting in draw(). In sandbox_logs.rs draw(), in the line rendering loop (lines 60-76): if app.log_selection_anchor is Some(anchor), compute the selected range. For each visible line, check if its absolute index falls within min(anchor, abs_cursor)..=max(anchor, abs_cursor). If so, apply t.log_selection style instead of the default. The cursor line still gets t.log_cursor on top (it's both selected and the cursor).

10. Update status bar for VISUAL mode. In sandbox_logs.rs draw(), in the status bar section (lines 87-97): if app.log_selection_anchor.is_some(), show " VISUAL " indicator (using t.status_warn for yellow) and a line count like "3 lines". Replace the FOLLOWING/PAUSED indicator when in visual mode.

11. Update nav bar for visual mode. In ui/mod.rs draw_nav_bar(), in the Focus::SandboxLogs arm: check app.log_selection_anchor.is_some(). If true, show a different hint set: [j/k] Extend [y] Yank [Esc] Cancel. If false, show the normal hints (with [y] Copy [Y] Copy All [v] Select from step 5).

Test Plan

• Unit tests: Add tests in sandbox_logs.rs for format_log_line_plain() — basic line, line with fields, line with empty fields, CONNECT field ordering, L7 field ordering, empty message. Add tests in app.rs for selection range computation (anchor == cursor → 1 line, anchor < cursor, anchor > cursor, empty log list).
• Integration tests: N/A — clipboard writes are side-effectful (OSC 52 to stdout), not testable in CI.
• E2E tests: N/A — TUI interaction tests are manual.

Risks & Open Questions

• format_short_time and ordered_fields are currently private; making them pub(crate) is a minor visibility expansion but clean since they stay crate-internal.
• OSC 52 base64 payload size: some terminals cap around 100KB. For Y (copy viewport), this is ~50 lines max, well under the limit. Visual selection could theoretically select thousands of lines; no mitigation needed for the viewport-constrained case, but worth noting.
• Esc is overloaded: in visual mode it cancels selection, in normal mode it navigates back. The plan handles this by checking log_selection_anchor first in the Esc handler.

Documentation Impact

• None expected — this is a UI feature addition with no architectural changes.

---

Revision 1 — initial plan, scoped to Phase 1 (y/Y copy) and Phase 2 (v-mode visual selection)

[johntmyers]

Implementation Complete

PR #276 implements Phase 1 and Phase 2 from the build plan:

Phase 1 — Single-line & viewport copy:

• y copies the current (highlighted) log line to clipboard
• Y copies all visible log lines in the viewport

Phase 2 — Visual selection mode:

• v toggles visual selection mode (anchors at current line)
• j/k extends the selection range
• y yanks the selected lines and exits visual mode
• Esc cancels selection

Technical details:

• Clipboard via OSC 52 escape sequences — works over SSH, tmux, modern terminals
• Zero new crate deps beyond base64
• Theme-aware selection highlighting (dark: Rgb(30,60,45), light: Rgb(215,235,200))
• Status bar shows VISUAL (N lines) during selection
• Nav bar hints context-switch between normal and visual mode
• 7 unit tests for plain-text log formatting
• All pre-commit checks pass (tests, fmt, clippy, lint)