railmux 0.4.0.dev20__tar.gz → 0.4.0.dev21__tar.gz

{railmux-0.4.0.dev20/src/railmux.egg-info → railmux-0.4.0.dev21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.4.0.dev20
+Version: 0.4.0.dev21
 Summary: Terminal UI to navigate, resume, and start Claude Code and Codex sessions
 Author-email: Rightglow <zhang.taian@foxmail.com>
 License-Expression: MIT
@@ -446,7 +446,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.4.0.dev20 → railmux-0.4.0.dev21}/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.4.0.dev21/src/railmux/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.4.0.dev21"

{railmux-0.4.0.dev20 → railmux-0.4.0.dev21}/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.4.0.dev20 → railmux-0.4.0.dev21}/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.4.0.dev20 → railmux-0.4.0.dev21}/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.4.0.dev20 → railmux-0.4.0.dev21/src/railmux.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.4.0.dev20
+Version: 0.4.0.dev21
 Summary: Terminal UI to navigate, resume, and start Claude Code and Codex sessions
 Author-email: Rightglow <zhang.taian@foxmail.com>
 License-Expression: MIT
@@ -446,7 +446,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.4.0.dev20 → railmux-0.4.0.dev21}/tests/test_fast_full_window.py

@@ -95,7 +95,6 @@ from railmux.fast_display_history import (
     HistoryAction,
     LocalHistoryView,
     PeriodicPrefetchGate,
-    claim_batched_wheel,
     input_may_change_routes,
 )
 from railmux.fast_display_input import (
@@ -4197,7 +4196,7 @@ def test_history_content_cache_keeps_only_recent_pane_lifetimes():
     assert tuple(view.content_cache) == tuple(pane_ids[-8:])
 
 
-def test_local_history_wheel_burst_is_bounded_before_it_moves_viewport():
+def test_local_history_wheel_batch_preserves_distance_with_one_paint():
     view = LocalHistoryView()
     prefetch = InputFrameDecoder().feed(view.begin_prefetch(1.0))[0]
     request_id, _limit = decode_history_prefetch(prefetch.data)
@@ -4208,26 +4207,100 @@ def test_local_history_wheel_burst_is_bounded_before_it_moves_viewport():
         0,
         30,
         3,
-        tuple(f"line-{index}".encode() for index in range(10)),
+        tuple(f"line-{index}".encode() for index in range(20)),
+    )
+    view.accept_prefetch(HistoryBatch(request_id, (route,)))
+    batch = fast_display_client._LocalInputBatch()
+    events = TerminalInputDecoder().feed(b"\x1b[<64;5;2M" * 8)
+    assert len(events) == 8
+    for event in events:
+        assert isinstance(event, SgrMouseEvent)
+        action, deferred_paint = batch.prepare(event, view.pointer_event(event))
+        assert action is not None
+        assert deferred_paint is not None
+        deferred_paint.defer(action)
+
+    assert view.viewports["%8"].offset == 8
+    surface = MagicMock(spec=TerminalSurface)
+    screen = MagicMock(spec=AppliedScreen)
+    overlays = view.overlays()
+
+    batch.flush(surface, screen, overlays, ())
+
+    surface.paint_overlays.assert_called_once_with(screen, overlays, ())
+    surface.paint.assert_not_called()
+
+
+def test_local_history_wheel_batch_restores_live_once_at_bottom():
+    view = LocalHistoryView()
+    prefetch = InputFrameDecoder().feed(view.begin_prefetch(1.0))[0]
+    request_id, _limit = decode_history_prefetch(prefetch.data)
+    route = HistorySnapshot(
+        request_id,
+        "%8",
+        0,
+        0,
+        30,
+        3,
+        tuple(f"line-{index}".encode() for index in range(20)),
     )
     view.accept_prefetch(HistoryBatch(request_id, (route,)))
     up = SgrMouseEvent(b"up", 64, 5, 2, True)
+    for _ in range(3):
+        view.pointer_event(up)
+    assert view.viewports["%8"].offset == 3
+
+    batch = fast_display_client._LocalInputBatch()
     down = SgrMouseEvent(b"down", 65, 5, 2, True)
     for _ in range(5):
-        view.wheel(up)
-    assert view.viewports["%8"].offset == 5
+        action, deferred_paint = batch.prepare(down, view.pointer_event(down))
+        assert action is not None
+        assert deferred_paint is not None
+        deferred_paint.defer(action)
+    assert not view.active
+
+    screen = ScreenModel().apply(
+        ClientScreenUpdateDecoder().feed(
+            encode_update(_keyframe(width=30, height=3))
+        )[0],
+        os.terminal_size((30, 3)),
+    )
+    assert screen is not None
+    surface = MagicMock(spec=TerminalSurface)
+    batch.flush(surface, screen, view.overlays(), ())
+
+    surface.paint.assert_called_once()
+    surface.paint_overlays.assert_not_called()
+
+
+def test_forwarded_wheel_batch_remains_bounded_without_local_paint():
+    batch = fast_display_client._LocalInputBatch()
+    down = SgrMouseEvent(b"down", 65, 5, 2, True)
+    up = SgrMouseEvent(b"up", 64, 5, 2, True)
+    admitted = []
 
-    handled: set[int] = set()
     for _ in range(8):
-        if claim_batched_wheel(down, handled):
-            view.wheel(down)
+        action, deferred_paint = batch.prepare(
+            down,
+            HistoryAction(forwarded_input=down.raw),
+        )
+        if action is not None:
+            admitted.append(action.forwarded_input)
+        assert deferred_paint is None
+    action, deferred_paint = batch.prepare(
+        up,
+        HistoryAction(forwarded_input=up.raw),
+    )
+    assert action is not None
+    admitted.append(action.forwarded_input)
+    assert deferred_paint is None
 
-    # Eight packets accumulated in one read still move only one row.
-    assert view.viewports["%8"].offset == 4
-    # The opposite direction remains responsive in the same terminal read.
-    assert claim_batched_wheel(up, handled) is True
-    # A new os.read() owns a fresh set and therefore admits the next tick.
-    assert claim_batched_wheel(down, set()) is True
+    surface = MagicMock(spec=TerminalSurface)
+    batch.flush(surface, MagicMock(spec=AppliedScreen), (), ())
+
+    assert admitted == [b"down", b"up"]
+    surface.paint.assert_not_called()
+    surface.paint_overlays.assert_not_called()
 
 
 def test_only_bounded_layout_and_modal_keys_invalidate_live_routes():

{railmux-0.4.0.dev20 → railmux-0.4.0.dev21}/tests/test_modals.py

@@ -148,7 +148,9 @@ def test_modal_action_legends_use_high_contrast_attribute(tmp_path):
     ]
 
     for modal in modals:
-        assert "modal_key" in _rendered_attrs(modal), type(modal).__name__
+        assert {"modal_key", "btn_key"} & _rendered_attrs(modal), (
+            type(modal).__name__
+        )
 
 
 def test_quit_confirm_wraps_all_choices_in_narrow_sidebar():
@@ -163,11 +165,27 @@ def test_quit_confirm_wraps_all_choices_in_narrow_sidebar():
     text = " ".join(
         _rendered_text(modal, size=(22, height)).replace("│", " ").split())
 
-    assert "quit and kill all sessions" in text
+    assert "hard quit (requires final confirmation)" in text
     assert "soft quit (keep sessions alive)" in text
     assert "n / Esc = cancel" in text
 
 
+def test_quit_confirm_choices_have_filled_button_styling():
+    modal = QuitConfirmModal(
+        on_confirm=lambda: None,
+        on_soft_quit=lambda: None,
+        on_cancel=lambda: None,
+        running_count=2,
+    )
+
+    attrs = _rendered_attrs(
+        modal, size=(48, modal.preferred_height(48))
+    )
+
+    assert "btn_key" in attrs
+    assert "btn_label" in attrs
+
+
 def test_quit_confirm_warns_when_ui_is_shared_by_multiple_clients():
     modal = QuitConfirmModal(
         on_confirm=lambda: None,
@@ -185,7 +203,7 @@ def test_quit_confirm_warns_when_ui_is_shared_by_multiple_clients():
     assert "quitting closes this UI in all of them" in text
 
 
-def test_quit_confirm_mouse_clicks_soft_quit_and_cancel_but_not_hard_quit():
+def test_quit_confirm_mouse_clicks_hard_soft_quit_and_cancel():
     called: list[str] = []
     modal = QuitConfirmModal(
         on_confirm=lambda: called.append("hard"),
@@ -206,17 +224,11 @@ def test_quit_confirm_mouse_clicks_soft_quit_and_cancel_but_not_hard_quit():
             size, "mouse press", 1, size[0] // 2, row, True
         )
 
+    click_row("hard quit")
     click_row("soft quit")
     click_row("cancel")
-    hard_canvas = modal.render(size, focus=True)
-    hard_row = next(
-        index
-        for index, line in enumerate(hard_canvas.text)
-        if b"quit and kill all sessions" in line
-    )
-    modal.mouse_event(size, "mouse press", 1, size[0] // 2, hard_row, True)
 
-    assert called == ["soft", "cancel"]
+    assert called == ["hard", "soft", "cancel"]
 
 
 def test_hard_quit_confirm_preserves_enter_and_requires_a_second_action():

railmux-0.4.0.dev20/src/railmux/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.4.0.dev20"