railmux 0.3.6.dev3__tar.gz → 0.3.6.dev5__tar.gz

{railmux-0.3.6.dev3/src/railmux.egg-info → railmux-0.3.6.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.3.6.dev3
+Version: 0.3.6.dev5
 Summary: Terminal UI to navigate, resume, and start Claude Code and Codex sessions
 Author-email: Rightglow <zhang.taian@foxmail.com>
 License-Expression: MIT
@@ -445,7 +445,9 @@ not interrupt it. To leave agents running when you quit Railmux, press `s` for
 soft quit in the confirmation popup; restarting the same Railmux instance then
 restores the usable workspace when those sessions are still available. A normal
 quit ends all running sessions instead and therefore requires a second
-confirmation; `y` and Enter keep their existing confirm meaning in both steps.
+confirmation. The first chooser has visible mouse buttons, but the final
+destructive confirmation remains keyboard-only; `y` and Enter keep their
+existing confirm meaning in both steps.
 
 All terminals attached to one managed Railmux window view the same UI process.
 Soft Quit therefore closes that shared UI for every attached view, although it

{railmux-0.3.6.dev3 → railmux-0.3.6.dev5}/README.md

@@ -403,7 +403,9 @@ not interrupt it. To leave agents running when you quit Railmux, press `s` for
 soft quit in the confirmation popup; restarting the same Railmux instance then
 restores the usable workspace when those sessions are still available. A normal
 quit ends all running sessions instead and therefore requires a second
-confirmation; `y` and Enter keep their existing confirm meaning in both steps.
+confirmation. The first chooser has visible mouse buttons, but the final
+destructive confirmation remains keyboard-only; `y` and Enter keep their
+existing confirm meaning in both steps.
 
 All terminals attached to one managed Railmux window view the same UI process.
 Soft Quit therefore closes that shared UI for every attached view, although it

railmux-0.3.6.dev5/src/railmux/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.3.6.dev5"

{railmux-0.3.6.dev3 → railmux-0.3.6.dev5}/src/railmux/fast_display_client.py

@@ -39,7 +39,7 @@ from railmux.fast_display_history import (
     HistoryAction,
     LocalHistoryView,
     PeriodicPrefetchGate,
-    claim_batched_wheel,
+    claim_batched_forwarded_wheel,
     input_may_change_routes,
 )
 from railmux.fast_display_input import (
@@ -1423,6 +1423,73 @@ class TerminalSurface:
         self.interaction_active = False
 
 
+@dataclass
+class _DeferredHistoryPaint:
+    """Collapse one local-input batch into its final history viewport paint."""
+
+    render_history: bool = False
+    restore_live: bool = False
+
+    def defer(self, action: HistoryAction) -> None:
+        self.render_history = self.render_history or action.render_history
+        self.restore_live = self.restore_live or action.restore_live
+
+    def flush(
+        self,
+        surface: TerminalSurface,
+        screen: AppliedScreen | None,
+        overlays: tuple[tuple[HistorySnapshot, tuple[bytes, ...]], ...],
+        selection: tuple[SelectionSegment, ...],
+    ) -> None:
+        if screen is not None:
+            if self.restore_live:
+                # A viewport may have reached the live bottom and another may
+                # still be frozen. Restore the authoritative frame and compose
+                # only the final overlays in one terminal write.
+                surface.paint(full_repaint(screen), overlays, selection)
+            elif self.render_history:
+                surface.paint_overlays(screen, overlays, selection)
+        self.render_history = False
+        self.restore_live = False
+
+
+class _LocalInputBatch:
+    """Preserve local wheel distance while bounding forwarded wheel bursts."""
+
+    def __init__(self) -> None:
+        self._forwarded_wheel_directions: set[int] = set()
+        self._history_paint = _DeferredHistoryPaint()
+
+    def prepare(
+        self,
+        event: SgrMouseEvent,
+        action: HistoryAction,
+    ) -> tuple[HistoryAction | None, _DeferredHistoryPaint | None]:
+        if event.wheel_direction == 0:
+            return action, None
+        if action.forwarded_input:
+            if not claim_batched_forwarded_wheel(
+                event,
+                self._forwarded_wheel_directions,
+            ):
+                return None, None
+            return action, None
+        # Every locally owned history tick has already advanced the viewport.
+        # Defer only its terminal paint so a Windows/RDP read containing
+        # several SGR packets preserves the complete distance without issuing
+        # one synchronous pane repaint per packet.
+        return action, self._history_paint
+
+    def flush(
+        self,
+        surface: TerminalSurface,
+        screen: AppliedScreen | None,
+        overlays: tuple[tuple[HistorySnapshot, tuple[bytes, ...]], ...],
+        selection: tuple[SelectionSegment, ...],
+    ) -> None:
+        self._history_paint.flush(surface, screen, overlays, selection)
+
+
 def _remote_server_args(
     *,
     session: str,
@@ -2605,22 +2672,28 @@ def run(args: argparse.Namespace) -> int:
         if frame is not None:
             send_protocol_frame(frame)
 
-    def apply_history_action(action: HistoryAction) -> None:
+    def apply_history_action(
+        action: HistoryAction,
+        deferred_paint: _DeferredHistoryPaint | None = None,
+    ) -> None:
         nonlocal route_refresh_needed
         nonlocal history_info_until, claude_history_prompt_input
         overlays = history.overlays()
-        if action.restore_live and latest_screen is not None:
-            surface.paint(
-                full_repaint(latest_screen),
-                overlays,
-                selection.segments(),
-            )
-        elif action.render_history and latest_screen is not None:
-            surface.paint_overlays(
-                latest_screen,
-                overlays,
-                selection.segments(),
-            )
+        if deferred_paint is not None:
+            deferred_paint.defer(action)
+        else:
+            if action.restore_live and latest_screen is not None:
+                surface.paint(
+                    full_repaint(latest_screen),
+                    overlays,
+                    selection.segments(),
+                )
+            elif action.render_history and latest_screen is not None:
+                surface.paint_overlays(
+                    latest_screen,
+                    overlays,
+                    selection.segments(),
+                )
         if action.protocol_frame:
             send_protocol_frame(action.protocol_frame)
         if action.forwarded_input:
@@ -2637,7 +2710,7 @@ def run(args: argparse.Namespace) -> int:
 
     def handle_terminal_part(
         part: bytes | SgrMouseEvent,
-        handled_wheels: set[int],
+        input_batch: _LocalInputBatch,
     ) -> None:
         nonlocal route_refresh_needed
         nonlocal claude_history_prompt_input, claude_history_pending_choice
@@ -2900,15 +2973,18 @@ def run(args: argparse.Namespace) -> int:
                     selection_changed_rows(selection_before, selection_after),
                 )
             for replay_event in selection_action.replay_events:
-                if not claim_batched_wheel(replay_event, handled_wheels):
-                    continue
                 replay_action = history.pointer_event(
                     replay_event,
                     focused_pane_id,
                     status_row=status_row,
                     now=time.monotonic(),
                 )
-                apply_history_action(replay_action)
+                replay_action, deferred_paint = input_batch.prepare(
+                    replay_event,
+                    replay_action,
+                )
+                if replay_action is not None:
+                    apply_history_action(replay_action, deferred_paint)
             if selection_action.copy_data is not None:
                 surface.copy_to_clipboard(selection_action.copy_data)
                 character_count = len(
@@ -2944,15 +3020,15 @@ def run(args: argparse.Namespace) -> int:
                     begin_path_open(target)
             if selection_action.handled:
                 return
-            if not claim_batched_wheel(part, handled_wheels):
-                return
             action = history.pointer_event(
                 part,
                 focused_pane_id,
                 status_row=status_row,
                 now=time.monotonic(),
             )
-            apply_history_action(action)
+            action, deferred_paint = input_batch.prepare(part, action)
+            if action is not None:
+                apply_history_action(action, deferred_paint)
             return
         if not part:
             return
@@ -3327,19 +3403,32 @@ def run(args: argparse.Namespace) -> int:
                         data, emergency_exit = split_local_escape(data)
                         if emergency_exit:
                             local_exit = True
-                        handled_wheels: set[int] = set()
+                        input_batch = _LocalInputBatch()
                         for part in terminal_input.feed(data):
                             if isinstance(part, bytes):
                                 for key_part in split_page_key_input(part):
-                                    handle_terminal_part(key_part, handled_wheels)
+                                    handle_terminal_part(key_part, input_batch)
                             else:
-                                handle_terminal_part(part, handled_wheels)
+                                handle_terminal_part(part, input_batch)
+                        input_batch.flush(
+                            surface,
+                            latest_screen,
+                            history.overlays(),
+                            selection.segments(),
+                        )
                         if local_exit:
                             break
                 if not local_exit:
                     for part in terminal_input.flush_pending():
+                        input_batch = _LocalInputBatch()
                         for key_part in split_page_key_input(part):
-                            handle_terminal_part(key_part, set())
+                            handle_terminal_part(key_part, input_batch)
+                        input_batch.flush(
+                            surface,
+                            latest_screen,
+                            history.overlays(),
+                            selection.segments(),
+                        )
                 now = time.monotonic()
                 keyboard_projected = touch_keyboard.keyboard_projected
                 if touch_keyboard.expire(now):

{railmux-0.3.6.dev3 → railmux-0.3.6.dev5}/src/railmux/fast_display_history.py

@@ -1021,18 +1021,15 @@ class LocalHistoryView:
         return was_active
 
 
-def claim_batched_wheel(
+def claim_batched_forwarded_wheel(
     event: SgrMouseEvent,
     handled_directions: set[int],
 ) -> bool:
-    """Admit at most one wheel tick per direction from one terminal read.
-
-    Trackpads commonly report several identical SGR wheel packets together.
-    If painting is briefly busy with fresh agent output, those packets can
-    accumulate in stdin and then move a frozen local-history viewport many
-    lines at once.  Bounding each read preserves the established one-line
-    local scroll feel without using a timing heuristic; a later read remains
-    immediately eligible.
+    """Admit at most one forwarded wheel tick per direction in one read.
+
+    Remote sidebar/modal owners need one bounded event rather than a stale
+    backlog. Locally owned agent history must not use this helper: it retains
+    the complete reported distance and coalesces only its terminal paint.
     """
     direction = event.wheel_direction
     if direction == 0:

{railmux-0.3.6.dev3 → railmux-0.3.6.dev5}/src/railmux/fast_display_server.py

@@ -1171,12 +1171,35 @@ def apply_path_open_request(
     )
 
 
-def _render_history_line(pyte: object, line: bytes, width: int) -> bytes:
-    """Parse one physical tmux line and emit only allowlisted SGR styling."""
+def _render_history_lines(
+    pyte: object,
+    lines: Sequence[bytes],
+    width: int,
+) -> tuple[bytes, ...]:
+    """Render physical tmux rows while retaining cross-row terminal style.
+
+    ``tmux capture-pane -e`` is a terminal stream, not a collection of
+    independently styled strings. In particular, tmux omits an SGR prefix
+    when a row inherits the previous row's foreground, background, or text
+    attributes. Keep one decoder alive for the ordered capture, but clear its
+    one-row cell buffer between rows. :func:`render_rows` then makes every
+    result independently paintable for the local history overlay.
+    """
     screen = pyte.Screen(width, 1)
     stream = pyte.ByteStream(screen)
-    stream.feed(line)
-    return render_rows(screen)[0]
+    rendered: list[bytes] = []
+    for line in lines:
+        screen.buffer[0].clear()
+        screen.cursor.x = 0
+        screen.cursor.y = 0
+        stream.feed(line)
+        rendered.append(render_rows(screen)[0])
+    return tuple(rendered)
+
+
+def _render_history_line(pyte: object, line: bytes, width: int) -> bytes:
+    """Render one self-contained physical row with allowlisted SGR styling."""
+    return _render_history_lines(pyte, (line,), width)[0]
 
 
 def _read_transcript_tail(fd: int) -> tuple[str, bool]:
@@ -1352,7 +1375,8 @@ def _capture_pane_history(
     # Retain the newest suffix when the styled representation reaches its byte
     # budget. Iterate backwards so an oversized response never sacrifices the
     # pane's current viewport merely to retain older scrollback.
-    current_raw = raw_lines[-pane.height :]
+    rendered_raw = _render_history_lines(pyte, raw_lines, pane.width)
+    current_raw = rendered_raw[-pane.height :]
     transcript_entry = None
     # ``None`` is retained only for old/test geometry that predates the
     # provider field; every validated live marker carries an explicit value.
@@ -1383,21 +1407,14 @@ def _capture_pane_history(
         transcript_lines = transcript_entry.rows
         history_count = max(0, max_lines - pane.height)
         source_lines = (
-            tuple((line, True) for line in transcript_lines[-history_count:])
-            if history_count
-            else ()
-        ) + tuple((line, False) for line in current_raw)
+            transcript_lines[-history_count:] if history_count else ()
+        ) + current_raw
     else:
-        source_lines = tuple((line, False) for line in raw_lines)
+        source_lines = rendered_raw
     newest_first: list[bytes] = []
     packed_size = 2  # history line-count prefix
     budget_truncated = False
-    for raw_line, rendered_already in reversed(source_lines[-max_lines:]):
-        rendered = (
-            raw_line
-            if rendered_already
-            else _render_history_line(pyte, raw_line, pane.width)
-        )
+    for rendered in reversed(source_lines[-max_lines:]):
         line_size = 4 + len(rendered)
         if packed_size + line_size > _HISTORY_SNAPSHOT_RAW_BUDGET:
             budget_truncated = True

{railmux-0.3.6.dev3 → railmux-0.3.6.dev5}/src/railmux/ui/modals.py

@@ -44,6 +44,29 @@ def _action_legend(
     return urwid.Text(markup, align=align, wrap=wrap)
 
 
+def _action_button(
+    keys: str,
+    description: str,
+    *,
+    on_click: Callable[[], None],
+    click_key: str,
+) -> ClickableRow:
+    """Render a terminal-safe filled action button with a mouse target."""
+    label = urwid.Text(
+        [
+            ("btn_key", keys),
+            ("btn_label", f" = {description}"),
+        ],
+        align="center",
+        wrap="space",
+    )
+    return ClickableRow(
+        urwid.AttrMap(label, "btn_label"),
+        on_click=on_click,
+        click_key=click_key,
+    )
+
+
 def _attention_lines(attention: AttentionState | None) -> list:
     """Compact, generic rendering for known and future attention categories."""
     if attention is None:
@@ -141,38 +164,37 @@ class QuitConfirmModal(urwid.WidgetWrap):
             summary = "No running sessions."
 
         action_rows: list[urwid.Widget] = [
-            _action_legend(
-                [("y / ↵", "quit and kill all sessions")],
-                align="center",
-                wrap="space",
+            _action_button(
+                "y / ↵",
+                "hard quit (requires final confirmation)",
+                on_click=on_confirm,
+                click_key="quit:hard",
             ),
         ]
         if on_soft_quit is not None:
-            action_rows.append(
-                ClickableRow(
-                    _action_legend(
-                        [("s", "soft quit (keep sessions alive)")],
-                        align="center",
-                        wrap="space",
-                    ),
+            action_rows.extend([
+                urwid.Divider(),
+                _action_button(
+                    "s",
+                    "soft quit (keep sessions alive)",
                     on_click=on_soft_quit,
                     click_key="quit:soft",
-                )
-            )
-        cancel_row = _action_legend(
-            [("n / Esc", "cancel")],
-            align="center",
-            wrap="space",
-        )
-        action_rows.append(
-            ClickableRow(
-                cancel_row,
+                ),
+            ])
+        action_rows.append(urwid.Divider())
+        if on_cancel is not None:
+            action_rows.append(_action_button(
+                "n / Esc",
+                "cancel",
                 on_click=on_cancel,
                 click_key="quit:cancel",
-            )
-            if on_cancel is not None
-            else cancel_row
-        )
+            ))
+        else:
+            action_rows.append(_action_legend(
+                [("n / Esc", "cancel")],
+                align="center",
+                wrap="space",
+            ))
         self._title = urwid.Text("Quit railmux?", align="center")
         self._summary = urwid.Text(("live", summary), align="center")
         self._shared_notice = (

{railmux-0.3.6.dev3 → railmux-0.3.6.dev5/src/railmux.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.3.6.dev3
+Version: 0.3.6.dev5
 Summary: Terminal UI to navigate, resume, and start Claude Code and Codex sessions
 Author-email: Rightglow <zhang.taian@foxmail.com>
 License-Expression: MIT
@@ -445,7 +445,9 @@ not interrupt it. To leave agents running when you quit Railmux, press `s` for
 soft quit in the confirmation popup; restarting the same Railmux instance then
 restores the usable workspace when those sessions are still available. A normal
 quit ends all running sessions instead and therefore requires a second
-confirmation; `y` and Enter keep their existing confirm meaning in both steps.
+confirmation. The first chooser has visible mouse buttons, but the final
+destructive confirmation remains keyboard-only; `y` and Enter keep their
+existing confirm meaning in both steps.
 
 All terminals attached to one managed Railmux window view the same UI process.
 Soft Quit therefore closes that shared UI for every attached view, although it