railmux 0.4.1.dev4__tar.gz → 0.4.1.dev6__tar.gz

{railmux-0.4.1.dev4/src/railmux.egg-info → railmux-0.4.1.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.4.1.dev4
+Version: 0.4.1.dev6
 Summary: Terminal UI to navigate, resume, and start Claude Code and Codex sessions
 Author-email: Rightglow <zhang.taian@foxmail.com>
 License-Expression: MIT

railmux-0.4.1.dev6/src/railmux/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.4.1.dev6"

{railmux-0.4.1.dev4 → railmux-0.4.1.dev6}/src/railmux/fast_display_input.py

@@ -22,6 +22,9 @@ from railmux.fast_display_protocol import (
 
 _SGR_MOUSE_PREFIX = b"\x1b[<"
 _SGR_STYLE_RE = re.compile(rb"\x1b\[[0-9;]*m")
+_OSC8_LINK_RE = re.compile(
+    rb"\x1b\]8;[^;\x07\x1b]*;([^\x07\x1b]*)(?:\x07|\x1b\\)"
+)
 _PAGE_UP = b"\x1b[5~"
 _PAGE_DOWN = b"\x1b[6~"
 _BRACKETED_PASTE_BEGIN = b"\x1b[200~"
@@ -505,27 +508,62 @@ def _display_width(character: str) -> int:
     return max(0, pyte.screens.wcwidth(character))
 
 
-def _plain_display_cells(line: bytes, width: int) -> tuple[str | None, ...]:
-    """Decode one server-rendered SGR row into bounded display cells."""
-    plain = _SGR_STYLE_RE.sub(b"", line).decode("utf-8", errors="replace")
+def _validated_osc8_url(value: bytes) -> str | None:
+    if not value or len(value) > 8192:
+        return None
+    try:
+        decoded = value.decode("utf-8")
+        parsed = urlsplit(decoded)
+        hostname = parsed.hostname
+    except (UnicodeDecodeError, ValueError):
+        return None
+    if (
+        parsed.scheme.lower() not in ("http", "https")
+        or hostname is None
+        or any(ord(character) < 0x20 or character == "\x7f" for character in decoded)
+    ):
+        return None
+    return decoded
+
+
+def _plain_display_row(
+    line: bytes,
+    width: int,
+) -> tuple[tuple[str | None, ...], tuple[str | None, ...]]:
+    """Decode one rendered row and retain bounded OSC 8 targets per cell."""
     cells: list[str | None] = [" "] * width
+    hyperlinks: list[str | None] = [None] * width
     column = 0
-    for character in plain:
-        cell_width = _display_width(character)
-        if cell_width == 0:
-            previous = column - 1
-            while previous >= 0 and cells[previous] is None:
-                previous -= 1
-            if previous >= 0:
-                cells[previous] = (cells[previous] or "") + character
-            continue
-        if column >= width or column + cell_width > width:
-            break
-        cells[column] = character
-        for continuation in range(1, cell_width):
-            cells[column + continuation] = None
-        column += cell_width
-    return tuple(cells)
+    active_hyperlink: str | None = None
+
+    def append_visible(data: bytes) -> None:
+        nonlocal column
+        plain = _SGR_STYLE_RE.sub(b"", data).decode("utf-8", errors="replace")
+        for character in plain:
+            cell_width = _display_width(character)
+            if cell_width == 0:
+                previous = column - 1
+                while previous >= 0 and cells[previous] is None:
+                    previous -= 1
+                if previous >= 0:
+                    cells[previous] = (cells[previous] or "") + character
+                continue
+            if column >= width or column + cell_width > width:
+                return
+            cells[column] = character
+            hyperlinks[column] = active_hyperlink
+            for continuation in range(1, cell_width):
+                cells[column + continuation] = None
+                hyperlinks[column + continuation] = active_hyperlink
+            column += cell_width
+
+    offset = 0
+    for match in _OSC8_LINK_RE.finditer(line):
+        append_visible(line[offset : match.start()])
+        active_hyperlink = _validated_osc8_url(match.group(1))
+        offset = match.end()
+    append_visible(line[offset:])
+    return tuple(cells), tuple(hyperlinks)
 
 
 _CLICK_TOKEN_RE = re.compile(r"""[^\s<>"'`]+""")
@@ -719,23 +757,97 @@ def click_target_at(
     return None
 
 
-def _pane_cells(
+def _pane_rows(
     source: SelectionSource,
     *,
     start: int = 0,
     end: int | None = None,
-) -> tuple[tuple[str | None, ...], ...]:
-    """Decode pane-local cells from either full-screen or history rows."""
+) -> tuple[
+    tuple[tuple[str | None, ...], ...],
+    tuple[tuple[str | None, ...], ...],
+]:
+    """Decode pane-local cells and OSC 8 targets in one bounded pass."""
     route = source.route
     if end is None:
         end = route.height
     decode_width = source.row_x_offset + route.width
-    decoded: list[tuple[str | None, ...]] = []
+    decoded_cells: list[tuple[str | None, ...]] = []
+    decoded_hyperlinks: list[tuple[str | None, ...]] = []
     for index in range(start, min(end, route.height)):
         line = source.rows[index] if index < len(source.rows) else b""
-        cells = _plain_display_cells(line, decode_width)
-        decoded.append(cells[source.row_x_offset : source.row_x_offset + route.width])
-    return tuple(decoded)
+        cells, hyperlinks = _plain_display_row(line, decode_width)
+        span = slice(source.row_x_offset, source.row_x_offset + route.width)
+        decoded_cells.append(cells[span])
+        decoded_hyperlinks.append(hyperlinks[span])
+    return tuple(decoded_cells), tuple(decoded_hyperlinks)
+
+
+def _pane_cells(
+    source: SelectionSource,
+    *,
+    start: int = 0,
+    end: int | None = None,
+) -> tuple[tuple[str | None, ...], ...]:
+    """Decode pane-local cells from either full-screen or history rows."""
+    return _pane_rows(source, start=start, end=end)[0]
+
+
+def _osc8_target(
+    rows: tuple[tuple[str | None, ...], ...],
+    hyperlinks: tuple[tuple[str | None, ...], ...],
+    row: int,
+    column: int,
+    *,
+    route: HistorySnapshot,
+) -> ClickTarget | None:
+    """Resolve one exact OSC 8 target without reconstructing its label."""
+    if not (0 <= row < len(rows) and 0 <= row < len(hyperlinks)):
+        return None
+    if not 0 <= column < len(hyperlinks[row]):
+        return None
+    value = hyperlinks[row][column]
+    if value is None:
+        return None
+
+    segments: list[SelectionSegment] = []
+    first = row
+    while first > 0 and value in hyperlinks[first - 1]:
+        first -= 1
+    last = row
+    while last + 1 < len(hyperlinks) and value in hyperlinks[last + 1]:
+        last += 1
+    for row_index in range(first, last + 1):
+        link_row = hyperlinks[row_index]
+        cell_row = rows[row_index]
+        run_start: int | None = None
+        for cell_index in range(len(link_row) + 1):
+            linked = cell_index < len(link_row) and link_row[cell_index] == value
+            if linked and run_start is None:
+                run_start = cell_index
+            if not linked and run_start is not None:
+                text = "".join(
+                    cell or "" for cell in cell_row[run_start:cell_index]
+                ).encode("utf-8")
+                if text:
+                    segments.append(
+                        (
+                            route.y + row_index,
+                            route.x + run_start,
+                            text,
+                        )
+                    )
+                run_start = None
+    if not segments:
+        return None
+    return ClickTarget(
+        "url",
+        value,
+        route.pane_id or "",
+        highlight_row=segments[0][0],
+        highlight_column=segments[0][1],
+        highlight_text=segments[0][2],
+        highlight_segments=tuple(segments),
+    )
 
 
 def _rows_are_wrapped(
@@ -1124,10 +1236,14 @@ def _target_in_rows(
     column: int,
     *,
     route: HistorySnapshot,
+    hyperlinks: tuple[tuple[str | None, ...], ...] = (),
 ) -> ClickTarget | None:
     """Resolve a semantic target across one bounded visual-wrap chain."""
     if not 0 <= row < len(rows) or route.width <= 0:
         return None
+    exact = _osc8_target(rows, hyperlinks, row, column, route=route)
+    if exact is not None:
+        return exact
     decorated = _decorated_tool_target(
         rows,
         row,
@@ -1200,6 +1316,7 @@ class LocalTextSelection:
         self._press: SgrMouseEvent | None = None
         self._route: HistorySnapshot | None = None
         self._rows: tuple[tuple[str | None, ...], ...] = ()
+        self._hyperlinks: tuple[tuple[str | None, ...], ...] = ()
         self._anchor: tuple[int, int] | None = None
         self._head: tuple[int, int] | None = None
         self._active = False
@@ -1221,6 +1338,7 @@ class LocalTextSelection:
         self._press = None
         self._route = None
         self._rows = ()
+        self._hyperlinks = ()
         self._anchor = None
         self._head = None
         self._active = False
@@ -1240,8 +1358,9 @@ class LocalTextSelection:
             return None
         start = max(0, row - 7)
         end = min(source.route.height, row + 8)
+        rows, hyperlinks = _pane_rows(source, start=start, end=end)
         return _target_in_rows(
-            _pane_cells(source, start=start, end=end),
+            rows,
             row - start,
             column,
             route=replace(
@@ -1249,6 +1368,7 @@ class LocalTextSelection:
                 y=source.route.y + start,
                 height=end - start,
             ),
+            hyperlinks=hyperlinks,
         )
 
     def hover(
@@ -1352,7 +1472,7 @@ class LocalTextSelection:
         route = source.route
         self._press = event
         self._route = route
-        self._rows = _pane_cells(source)
+        self._rows, self._hyperlinks = _pane_rows(source)
         self._anchor = self._point(event, route)
         self._head = self._anchor
         self._active = False
@@ -1385,6 +1505,7 @@ class LocalTextSelection:
                             self._anchor[1],
                             self._anchor[0],
                             route=self._route,
+                            hyperlinks=self._hyperlinks,
                         )
                         if (
                             self._semantic_open

{railmux-0.4.1.dev4 → railmux-0.4.1.dev6}/src/railmux/fast_display_server.py

@@ -80,6 +80,7 @@ from railmux.fast_display_protocol import (
 )
 from railmux.fast_display_history import HistoryCaptureJob, HistoryCaptureWorker
 from railmux.terminal_screen import (
+    HyperlinkTrackingStream,
     Osc52ClipboardDecoder as _Osc52ClipboardDecoder,
     ScreenState as _ScreenState,
     build_screen_update,
@@ -1226,7 +1227,7 @@ def _render_history_lines(
     result independently paintable for the local history overlay.
     """
     screen = pyte.Screen(width, 1)
-    stream = pyte.ByteStream(screen)
+    stream = HyperlinkTrackingStream(screen, pyte.ByteStream(screen))
     rendered: list[bytes] = []
     for line in lines:
         screen.buffer[0].clear()
@@ -2206,7 +2207,7 @@ def _serve_attached(
     master_fd: int,
 ) -> int:
     screen = pyte.DiffScreen(width, height)
-    stream = pyte.ByteStream(screen)
+    stream = HyperlinkTrackingStream(screen, pyte.ByteStream(screen))
     input_decoder = InputFrameDecoder()
     stdin_fd = sys.stdin.buffer.fileno()
     stdout_fd = sys.stdout.buffer.fileno()

{railmux-0.4.1.dev4 → railmux-0.4.1.dev6}/src/railmux/terminal_screen.py

@@ -14,6 +14,8 @@ import re
 from dataclasses import dataclass
 from functools import lru_cache
 from types import SimpleNamespace
+from typing import NamedTuple
+from urllib.parse import urlsplit
 
 from railmux.fast_display_protocol import (
     MAX_CLIPBOARD_BYTES,
@@ -65,6 +67,121 @@ _ANSI_BG = {
 }
 _OSC52_PREFIX = b"\033]52;"
 _OSC52_MAX_ENCODED = ((MAX_CLIPBOARD_BYTES + 2) // 3) * 4
+_OSC8_PREFIX = b"\033]8;"
+_OSC8_MAX_BYTES = 16 * 1024
+_MAX_SCREEN_HYPERLINKS = 256
+
+
+class _HyperlinkChar(NamedTuple):
+    """A pyte-compatible cell with one bounded OSC 8 target."""
+
+    data: str
+    fg: str = "default"
+    bg: str = "default"
+    bold: bool = False
+    italics: bool = False
+    underscore: bool = False
+    strikethrough: bool = False
+    reverse: bool = False
+    blink: bool = False
+    hyperlink: str | None = None
+
+
+def _hyperlink_char(char: object, hyperlink: str | None) -> _HyperlinkChar:
+    return _HyperlinkChar(
+        data=char.data,
+        fg=char.fg,
+        bg=char.bg,
+        bold=char.bold,
+        italics=char.italics,
+        underscore=char.underscore,
+        strikethrough=char.strikethrough,
+        reverse=char.reverse,
+        blink=char.blink,
+        hyperlink=hyperlink,
+    )
+
+
+def _safe_hyperlink(value: bytes) -> str | None:
+    if not value or len(value) > 8192:
+        return None
+    try:
+        decoded = value.decode("utf-8")
+    except UnicodeDecodeError:
+        return None
+    if any(ord(character) < 0x20 or character == "\x7f" for character in decoded):
+        return None
+    try:
+        parsed = urlsplit(decoded)
+        hostname = parsed.hostname
+    except ValueError:
+        return None
+    if parsed.scheme.lower() not in ("http", "https") or hostname is None:
+        return None
+    return decoded
+
+
+class HyperlinkTrackingStream:
+    """Preserve bounded HTTP(S) OSC 8 targets in pyte screen cells.
+
+    pyte intentionally ignores OSC 8.  Railmux needs the target independently
+    from its often-wrapped display label, so this wrapper consumes only OSC 8,
+    updates the extended screen's cell attribute, and passes every other byte
+    through unchanged.  The parser is incremental and bounded because PTY
+    reads may split either terminator.
+    """
+
+    def __init__(self, screen: object, stream: object) -> None:
+        self.screen = screen
+        self.stream = stream
+        self._buffer = bytearray()
+
+    def _feed_visible(self, data: bytes) -> None:
+        if data:
+            self.stream.feed(data)
+
+    def feed(self, data: bytes) -> None:
+        if not data:
+            return
+        self._buffer.extend(data)
+        while self._buffer:
+            start = self._buffer.find(_OSC8_PREFIX)
+            if start < 0:
+                keep = 0
+                maximum = min(len(self._buffer), len(_OSC8_PREFIX) - 1)
+                for length in range(maximum, 0, -1):
+                    if _OSC8_PREFIX.startswith(self._buffer[-length:]):
+                        keep = length
+                        break
+                visible_end = len(self._buffer) - keep
+                self._feed_visible(bytes(self._buffer[:visible_end]))
+                del self._buffer[:visible_end]
+                return
+            if start:
+                self._feed_visible(bytes(self._buffer[:start]))
+                del self._buffer[:start]
+            bel = self._buffer.find(b"\007", len(_OSC8_PREFIX))
+            st = self._buffer.find(b"\033\\", len(_OSC8_PREFIX))
+            endings = tuple(
+                (position, length)
+                for position, length in ((bel, 1), (st, 2))
+                if position >= 0
+            )
+            if not endings:
+                if len(self._buffer) <= _OSC8_MAX_BYTES:
+                    return
+                # An unterminated lookalike is ordinary terminal output. Feed
+                # one byte and resume scanning without retaining an unbounded
+                # attacker-controlled prefix.
+                self._feed_visible(bytes(self._buffer[:1]))
+                del self._buffer[:1]
+                continue
+            end, terminator_length = min(endings)
+            body = bytes(self._buffer[len(_OSC8_PREFIX) : end])
+            del self._buffer[: end + terminator_length]
+            _params, separator, target = body.partition(b";")
+            hyperlink = _safe_hyperlink(target) if separator else None
+            self.screen.set_hyperlink(hyperlink)
 
 
 class Osc52ClipboardDecoder:
@@ -123,9 +240,29 @@ class _ExtendedScreenMixin:
     _last_graphic_character = ""
     _character_width = staticmethod(lambda _character: 1)
 
+    @property
+    def default_char(self) -> _HyperlinkChar:
+        return _hyperlink_char(super().default_char, None)
+
     def reset(self) -> None:
         self._last_graphic_character = ""
+        self._active_hyperlink: str | None = None
+        self._known_hyperlinks: dict[str, str] = {}
         super().reset()
+        self.cursor.attrs = _hyperlink_char(self.cursor.attrs, None)
+
+    def set_hyperlink(self, hyperlink: str | None) -> None:
+        if hyperlink is not None:
+            known = self._known_hyperlinks.get(hyperlink)
+            if known is None:
+                if len(self._known_hyperlinks) >= _MAX_SCREEN_HYPERLINKS:
+                    hyperlink = None
+                else:
+                    self._known_hyperlinks[hyperlink] = hyperlink
+            else:
+                hyperlink = known
+        self._active_hyperlink = hyperlink
+        self.cursor.attrs = _hyperlink_char(self.cursor.attrs, hyperlink)
 
     def draw(self, data: str) -> None:
         super().draw(data)
@@ -174,6 +311,10 @@ class _ExtendedScreenMixin:
     def select_graphic_rendition(self, *attrs: int) -> None:
         """Retain 256-colour indices instead of baking in pyte's palette."""
         super().select_graphic_rendition(*attrs)
+        self.cursor.attrs = _hyperlink_char(
+            self.cursor.attrs,
+            self._active_hyperlink,
+        )
         values = list(attrs)
         indexed: dict[str, int] = {}
         index = 0
@@ -209,6 +350,14 @@ class _ExtendedScreenMixin:
                 **{key: f"ansi256:{colour}" for key, colour in indexed.items()}
             )
 
+    def restore_cursor(self) -> None:
+        super().restore_cursor()
+        # OSC 8 state is not part of DECSC/DECRC cursor attributes.
+        self.cursor.attrs = _hyperlink_char(
+            self.cursor.attrs,
+            self._active_hyperlink,
+        )
+
 
 @lru_cache(maxsize=4)
 def _build_extended_pyte(pyte: object) -> object:
@@ -333,6 +482,7 @@ def render_rows(screen: object) -> tuple[bytes, ...]:
     for row_index in range(screen.lines):
         rendered = [b"\033[0m"]
         previous_style: tuple[object, ...] | None = None
+        previous_hyperlink: str | None = None
         row = screen.buffer[row_index]
         rendered_columns = _last_rendered_column(row, screen.columns)
         continuation_cells = 0
@@ -346,6 +496,17 @@ def render_rows(screen: object) -> tuple[bytes, ...]:
                 continuation_cells = 0
                 continuation_data = ""
             char = row[column]
+            hyperlink = getattr(char, "hyperlink", None)
+            if hyperlink != previous_hyperlink:
+                if previous_hyperlink is not None:
+                    rendered.append(b"\033]8;;\033\\")
+                if hyperlink is not None:
+                    rendered.append(
+                        b"\033]8;;"
+                        + hyperlink.encode("utf-8", errors="strict")
+                        + b"\033\\"
+                    )
+                previous_hyperlink = hyperlink
             style = _style_key(char)
             if style != previous_style:
                 rendered.append(_style(char))
@@ -366,6 +527,8 @@ def render_rows(screen: object) -> tuple[bytes, ...]:
                 )
                 continuation_cells = max(0, cell_width - 1)
                 continuation_data = char.data
+        if previous_hyperlink is not None:
+            rendered.append(b"\033]8;;\033\\")
         rendered.append(b"\033[0m")
         rendered_rows.append(b"".join(rendered))
     return tuple(rendered_rows)
@@ -465,7 +628,10 @@ class ScreenProducer:
         self.width = width
         self.height = height
         self.screen = self.pyte.DiffScreen(width, height)
-        self.stream = self.pyte.ByteStream(self.screen)
+        self.stream = HyperlinkTrackingStream(
+            self.screen,
+            self.pyte.ByteStream(self.screen),
+        )
         self._clipboard = Osc52ClipboardDecoder()
         self._clipboard_ready: list[bytes] = []
         self.delivered: ScreenState | None = None

{railmux-0.4.1.dev4 → railmux-0.4.1.dev6}/src/railmux/tmux_ctl.py

@@ -2046,6 +2046,9 @@ _ROOT_TERMUX_TAP_MARKER = "railmux-termux-tap-v1"
 STATUS_ACTION_MODE = "railmux-mode"
 STATUS_ACTION_LAYOUT = "railmux-layout"
 STATUS_ACTION_COPY = "railmux-copy"
+STATUS_ACTION_PAGE_SIDEBAR = "railmux-page-r"
+STATUS_ACTION_PAGE_PRIMARY = "railmux-page-1"
+STATUS_ACTION_PAGE_SECONDARY = "railmux-page-2"
 _ROOT_STATUS_ACTION_KEYS = {
     STATUS_ACTION_MODE: "MouseDown1Control0",
     STATUS_ACTION_LAYOUT: "MouseDown1Control1",
@@ -2059,6 +2062,9 @@ _STATUS_ACTIONS = frozenset({
     STATUS_ACTION_MODE,
     STATUS_ACTION_LAYOUT,
     STATUS_ACTION_COPY,
+    STATUS_ACTION_PAGE_SIDEBAR,
+    STATUS_ACTION_PAGE_PRIMARY,
+    STATUS_ACTION_PAGE_SECONDARY,
 })
 _PREFIX_TARGET_KEY = "Tab"
 _PREFIX_TARGET_MARKER = "railmux-target-toggle-v1"
@@ -2085,6 +2091,15 @@ RAILMUX_HISTORY_RESTORE_KEYS = {
     "primary": ("F23", "\x1b[42~"),
     "secondary": ("F24", "\x1b[43~"),
 }
+# Compact status clicks must reach the controller before pane focus changes so
+# it can park the visible provider, switch the zoomed page, and resume the new
+# provider as one transaction.  tmux names keys only through F12, therefore
+# these private routes use canonical xterm sequences in literal mode.
+RAILMUX_COMPACT_PAGE_KEYS = {
+    STATUS_ACTION_PAGE_SIDEBAR: ("F13", "\x1b[25~"),
+    STATUS_ACTION_PAGE_PRIMARY: ("F14", "\x1b[26~"),
+    STATUS_ACTION_PAGE_SECONDARY: ("F15", "\x1b[28~"),
+}
 RAILMUX_SELECTION_KEY_OPTION = "@railmux_selection_key"
 RAILMUX_SELECTION_PEER_OPTION = "@railmux_selection_peer"
 RAILMUX_SELECTION_FROZEN_OPTION = "@railmux_selection_frozen_by"
@@ -2124,7 +2139,9 @@ def status_pane_range(pane_id: str, content: str) -> str:
     # A pane range sets ``mouse_status_range`` to only the literal ``pane``;
     # ``=`` still resolves to the pane geometrically below the status cell,
     # not to X. A user range preserves the strict pane ID as its argument, so
-    # the managed binding can select the intended compact page explicitly.
+    # the managed binding can select a pane-targeted status control explicitly.
+    # Compact page navigation uses controller actions instead so parking,
+    # resuming, and zooming remain one ordered transaction.
     #
     # Status strings also pass through tmux's strftime expansion.  Escape the
     # pane-ID percent sign so IDs such as ``%76`` are not parsed as padding
@@ -2149,8 +2166,8 @@ def status_action_range(action: str, content: str) -> str:
     # keys avoids routing fixed actions through the generic user-range
     # dispatcher and provides deterministic bindings on the 3.7b version
     # bundled by the managed Windows runtime.
-    if tmux_version() >= (3, 7):
-        key = _ROOT_STATUS_ACTION_KEYS[action]
+    key = _ROOT_STATUS_ACTION_KEYS.get(action)
+    if tmux_version() >= (3, 7) and key is not None:
         index = key.removeprefix("MouseDown1Control")
         return f"#[range=control|{index}]{content}#[norange]"
     return f"#[range=user|{action}]{content}#[norange]"
@@ -3079,7 +3096,7 @@ def set_root_status_click_forwarding(
     marker = f"{_ROOT_STATUS_CLICK_MARKER}-{token}"
     condition = (
         "#{&&:"
-        "#{m/r:^(%[0-9]+|railmux-(mode|layout|copy))$,"
+        "#{m/r:^(%[0-9]+|railmux-(mode|layout|copy|page-[r12]))$,"
         "#{mouse_status_range}},"
         "#{!=:#{@railmux_controller_pane},},"
         f"#{{==:{marker},{marker}}}}}"
@@ -3097,6 +3114,18 @@ def set_root_status_click_forwarding(
             f'\'#{{{RAILMUX_CONTROLLER_OPTION}}}\' F7 ;; '
             f'{STATUS_ACTION_COPY}) {_tmux_shell_executable()} send-keys -t '
             f'\'#{{{RAILMUX_CONTROLLER_OPTION}}}\' F6 ;; '
+            f'{STATUS_ACTION_PAGE_SIDEBAR}) '
+            f'{_tmux_shell_executable()} send-keys -l -t '
+            f'\'#{{{RAILMUX_CONTROLLER_OPTION}}}\' -- '
+            f'{shlex.quote(RAILMUX_COMPACT_PAGE_KEYS[STATUS_ACTION_PAGE_SIDEBAR][1])} ;; '
+            f'{STATUS_ACTION_PAGE_PRIMARY}) '
+            f'{_tmux_shell_executable()} send-keys -l -t '
+            f'\'#{{{RAILMUX_CONTROLLER_OPTION}}}\' -- '
+            f'{shlex.quote(RAILMUX_COMPACT_PAGE_KEYS[STATUS_ACTION_PAGE_PRIMARY][1])} ;; '
+            f'{STATUS_ACTION_PAGE_SECONDARY}) '
+            f'{_tmux_shell_executable()} send-keys -l -t '
+            f'\'#{{{RAILMUX_CONTROLLER_OPTION}}}\' -- '
+            f'{shlex.quote(RAILMUX_COMPACT_PAGE_KEYS[STATUS_ACTION_PAGE_SECONDARY][1])} ;; '
             'esac"'
         )
         subprocess.check_call(