railmux 0.4.0.dev1__tar.gz → 0.4.0.dev2__tar.gz

{railmux-0.4.0.dev1/src/railmux.egg-info → railmux-0.4.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.4.0.dev1
+Version: 0.4.0.dev2
 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.0.dev2/src/railmux/__init__.py

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

{railmux-0.4.0.dev1 → railmux-0.4.0.dev2}/src/railmux/mux/__init__.py

@@ -1,5 +1,7 @@
 """Typed multiplexer boundary shared by tmux and native Windows."""
-from railmux.mux.backend import Capabilities, LaunchSpec, MuxBackend
+from railmux.mux.backend import Capabilities, LaunchSpec, MuxBackend, StatusChrome
 from railmux.mux.tmux_backend import TmuxBackend
 
-__all__ = ["Capabilities", "LaunchSpec", "MuxBackend", "TmuxBackend"]
+__all__ = [
+    "Capabilities", "LaunchSpec", "MuxBackend", "StatusChrome", "TmuxBackend",
+]

{railmux-0.4.0.dev1 → railmux-0.4.0.dev2}/src/railmux/mux/backend.py

@@ -32,6 +32,20 @@ class LaunchSpec:
     login_shell: bool = False
 
 
+@dataclass(frozen=True)
+class StatusChrome:
+    """Platform-neutral state for Railmux's persistent bottom chrome.
+
+    POSIX projects this into tmux's status line; native Windows draws it in
+    the daemon compositor.  The transient status message is intentionally a
+    separate value so it cannot replace the Mode/Layout controls.
+    """
+
+    mode_label: str
+    layout_indicator: str | None
+    error: bool = False
+
+
 class MuxBackend(Protocol):
     """Core topology/lifecycle surface consumed by the shared UI.
 
@@ -57,3 +71,5 @@ class MuxBackend(Protocol):
     def detach_client(self) -> bool: ...
     def kill_pane(self, pane_id: str) -> bool: ...
     def kill_session(self, name: str) -> bool: ...
+    def set_status_text(self, text: str, level: str) -> None: ...
+    def set_status_chrome(self, chrome: StatusChrome) -> None: ...

{railmux-0.4.0.dev1 → railmux-0.4.0.dev2}/src/railmux/mux/tmux_backend.py

@@ -6,7 +6,7 @@ from types import ModuleType
 from pathlib import Path
 
 from railmux import tmux_ctl
-from railmux.mux.backend import Capabilities
+from railmux.mux.backend import Capabilities, StatusChrome
 
 
 class TmuxBackend:
@@ -128,6 +128,10 @@ class TmuxBackend:
         # tmux option formatting; native rendering uses this backend hook.
         pass
 
+    def set_status_chrome(self, _chrome: StatusChrome) -> None:
+        # App retains the established tmux option formatting and leases.
+        pass
+
     def prepare_launch(
         self,
         argv: list[str],

{railmux-0.4.0.dev1 → railmux-0.4.0.dev2}/src/railmux/ui/app.py

@@ -56,7 +56,7 @@ from railmux.modes import (
     ProjectSource,
 )
 from railmux.models import AttentionState, Project, SessionMeta
-from railmux.mux import MuxBackend, TmuxBackend
+from railmux.mux import MuxBackend, StatusChrome, TmuxBackend
 from railmux.tmux_binding_manager import SharedTmuxBindingManager
 from railmux.mouse_manager import RootWheelForwardingManager
 from railmux.renames import Renames
@@ -2028,8 +2028,9 @@ class App:
                 return False
             slot.agent_tmux_name = None
             slot.mode_key = self._current_mode_key()
-            self.mux.select_pane(slot.pane_id)
-            self._set_railmux_focus(False, force_border=True)
+            # A preview is the single-click/Space action.  Keep keyboard focus
+            # in the sidebar; only double-click/Enter is allowed to transfer
+            # focus to the displayed surface (P06).
             return True
 
         import shlex
@@ -10033,6 +10034,21 @@ class App:
         initial paint, from _render_status_to_tmux on the normal↔error
         transition, and from mode cycling so the mode indicator repaints.
         Best-effort — a tmux hiccup must not raise into the UI."""
+        # Publish the semantic chrome even when tmux is not the renderer.
+        # Native Windows consumes this hook; POSIX keeps its established tmux
+        # formatting below.  Test doubles and older third-party backends remain
+        # best-effort compatible.
+        mux = getattr(self, "mux", None)
+        publish = getattr(mux, "set_status_chrome", None)
+        if callable(publish):
+            try:
+                publish(StatusChrome(
+                    mode_label=self._active_mode().label,
+                    layout_indicator=self._status_layout_indicator(),
+                    error=error,
+                ))
+            except (AttributeError, KeyError, TypeError, ValueError):
+                pass
         if not self._tmux_status_enabled or not self._tmux_status_session:
             return
         bar = _TMUX_BAR_STYLE_ERROR if error else _TMUX_BAR_STYLE_NORMAL

railmux-0.4.0.dev2/src/railmux/ui/status_chrome.py

@@ -0,0 +1,149 @@
+"""Semantic bottom-chrome projection shared by non-tmux frontends."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from urwid.str_util import calc_width
+
+from railmux.ui.workspace import WorkspacePage
+
+
+ACTION_MODE = "mode"
+ACTION_LAYOUT = "layout"
+ACTION_COPY = "copy"
+
+
+@dataclass(frozen=True)
+class StatusHit:
+    """One clickable half-open cell range in the bottom status row."""
+
+    start: int
+    end: int
+    action: str
+
+
+@dataclass(frozen=True)
+class StatusProjection:
+    """Plain terminal text plus semantic hit targets for one status row."""
+
+    text: str
+    hits: tuple[StatusHit, ...]
+    error: bool
+
+
+def project_status_chrome(
+    *,
+    width: int,
+    mode_label: str,
+    layout_indicator: str | None,
+    status_text: str,
+    status_level: str,
+    compact: bool,
+    active_page: WorkspacePage,
+    page_targets: tuple[str | None, str | None, str | None],
+) -> StatusProjection:
+    """Build the platform-neutral visible controls for a full-width bar.
+
+    Renderers remain free to choose colours, but labels and click authority
+    live here so a native frontend cannot accidentally expose only status-right.
+    """
+    width = max(1, width)
+    parts: list[str] = []
+    hits: list[StatusHit] = []
+    cells = 0
+
+    def append(value: str, action: str | None = None) -> None:
+        nonlocal cells
+        value = _safe_text(value)
+        bounded = _fit_cells(value, max(0, width - cells))
+        if not bounded:
+            return
+        start = cells
+        parts.append(bounded)
+        cells += _cells(bounded)
+        if action is not None and cells > start:
+            hits.append(StatusHit(start, cells, action))
+
+    if compact:
+        if width < 52:
+            labels = ("R", "1", "2")
+            visible_mode = (
+                "Cx" if mode_label == "Codex" else
+                "CC" if mode_label == "Claude Code" else mode_label[:2]
+            )
+        elif width < 80:
+            labels = ("Railmux", "A1", "A2")
+            visible_mode = (
+                "Codex" if mode_label == "Codex" else
+                "CC" if mode_label == "Claude Code" else mode_label[:8]
+            )
+        else:
+            labels = ("Railmux", "Agent 1", "Agent 2")
+            visible_mode = mode_label
+        pages = (
+            WorkspacePage.SIDEBAR,
+            WorkspacePage.PRIMARY,
+            WorkspacePage.SECONDARY,
+        )
+        for page, target, label in zip(pages, page_targets, labels):
+            # Native terminals do not all expose tmux's per-range style
+            # channel.  Keep the selected page visible in plain text too.
+            marker = f"<{label}>" if page is active_page else f"[{label}]"
+            append(marker, f"page:{target}" if target is not None else None)
+        append(" ")
+        append(visible_mode, ACTION_MODE)
+    else:
+        append(" Railmux · ")
+        append(mode_label, ACTION_MODE)
+
+    if layout_indicator:
+        append(" · ")
+        append(layout_indicator, ACTION_LAYOUT)
+    append(" ")
+
+    safe_status = _safe_text(status_text)
+    available = max(0, width - cells)
+    if safe_status and available:
+        visible_status = _fit_cells(safe_status, available)
+        status_cells = _cells(visible_status)
+        padding = max(0, available - status_cells)
+        if padding:
+            parts.append(" " * padding)
+            cells += padding
+        start = cells
+        parts.append(visible_status)
+        cells += status_cells
+        if cells > start:
+            hits.append(StatusHit(start, cells, ACTION_COPY))
+
+    return StatusProjection(
+        text="".join(parts),
+        hits=tuple(hits),
+        error=status_level == "error",
+    )
+
+
+def _safe_text(value: str) -> str:
+    return "".join(
+        " " if ord(character) < 32 or 0x7F <= ord(character) <= 0x9F
+        else character
+        for character in value
+    )
+
+
+def _cells(value: str) -> int:
+    return calc_width(value, 0, len(value))
+
+
+def _fit_cells(value: str, available: int) -> str:
+    if available <= 0:
+        return ""
+    result: list[str] = []
+    used = 0
+    for character in value:
+        width = _cells(character)
+        if used + width > available:
+            break
+        result.append(character)
+        used += width
+    return "".join(result)

{railmux-0.4.0.dev1 → railmux-0.4.0.dev2}/src/railmux/winlocal/backend.py

@@ -14,10 +14,22 @@ from typing import Callable
 
 from railmux import tmux_ctl
 from railmux.fast_display_input import SgrMouseEvent, TerminalInputDecoder
-from railmux.mux.backend import Capabilities, LaunchSpec
+from railmux.mux.backend import Capabilities, LaunchSpec, StatusChrome
 from railmux.platform.process import provider_argv
 from railmux.restart_state import OuterTmuxIdentity
-from railmux.ui.workspace import DisplayTransportKind, WorkspaceLayout
+from railmux.ui.status_chrome import (
+    ACTION_COPY,
+    ACTION_LAYOUT,
+    ACTION_MODE,
+    StatusHit,
+    project_status_chrome,
+)
+from railmux.ui.workspace import (
+    DisplayTransportKind,
+    WorkspaceLayout,
+    WorkspacePage,
+    WorkspacePresentation,
+)
 from railmux.winlocal.compositor import Compositor, Region, TerminalPane
 from railmux.winlocal.conpty import ConPtyProcess, PyWinPtyProcess
 from railmux.winlocal.history_viewer import HistoryViewer
@@ -78,9 +90,21 @@ class WinMuxBackend:
         self._last_input_source: object | None = None
         self._client_count: Callable[[], int] | None = None
         self._workspace = None
-        self._screen = VirtualScreen(max(20, width * 3 // 10), max(1, height - 1))
+        self._sidebar_width: int | None = None
+        # Divider positions are axis-specific.  Keeping one value here makes
+        # a column width turn into a row height (and vice versa) when the user
+        # cycles between side-by-side and stacked layouts.
+        self._primary_width: int | None = None
+        self._primary_height: int | None = None
+        # The sidebar starts as the only surface and therefore owns the full
+        # viewport.  Opening the first display pane narrows it through the same
+        # geometry synchronization path used by later layout changes.
+        self._screen = VirtualScreen(width, max(1, height - 1))
         self._compositor = Compositor(width, height)
-        self._status = b"railmux"
+        self._status_text = ""
+        self._status_level = "tip"
+        self._status_chrome = StatusChrome("Claude Code", None)
+        self._status_hits: tuple[StatusHit, ...] = ()
         self._lock = threading.RLock()
         self._input_decoder = TerminalInputDecoder()
 
@@ -150,7 +174,13 @@ class WinMuxBackend:
 
     def set_status_text(self, text: str, level: str) -> None:
         prefix = {"error": "ERROR: ", "warn": "WARNING: "}.get(level, "")
-        self._status = (prefix + text).encode("utf-8", errors="replace")
+        with self._lock:
+            self._status_text = prefix + text
+            self._status_level = level
+
+    def set_status_chrome(self, chrome: StatusChrome) -> None:
+        with self._lock:
+            self._status_chrome = chrome
 
     def create_display_pane(self, key: str) -> str:
         with self._lock:
@@ -329,7 +359,17 @@ class WinMuxBackend:
         with self._lock:
             if not self.pane_alive(pane_id):
                 return False
+            if pane_id == self._active_pane:
+                return True
             self._last_pane, self._active_pane = self._active_pane, pane_id
+            # tmux status-page selection inside a zoomed window displays the
+            # newly selected pane.  Preserve that semantic in the native
+            # compositor instead of leaving zoom ownership on an invisible
+            # previous page.
+            if self._zoomed_pane is not None:
+                self._zoomed_pane = pane_id
+                self._sync_display_sizes()
+                self.request_keyframe()
             return True
 
     def active_pane_id(self, _target: str | None = None) -> str:
@@ -340,7 +380,10 @@ class WinMuxBackend:
 
     def pane_size(self, pane_id: str):
         with self._lock:
-            regions = self._display_regions()
+            # tmux preserves the logical sizes of panes hidden by zoom.  App
+            # uses those sizes to retain/reflow layout profiles, so report the
+            # same unzoomed geometry rather than the full-window projection.
+            regions = self._layout_regions()
             if pane_id == "%controller":
                 region = regions.get("sidebar")
                 return (region.width, region.height) if region else None
@@ -364,17 +407,43 @@ class WinMuxBackend:
     def window_size(self, _pane_id: str):
         return (self.width, self.height)
 
-    def resize_pane_width(self, _pane_id: str, _width: int) -> bool:
-        return True
+    def resize_pane_width(self, pane_id: str, width: int) -> bool:
+        with self._lock:
+            workspace = self._workspace
+            if pane_id == "%controller":
+                self._sidebar_width = width
+            elif (
+                workspace is not None
+                and pane_id == workspace.primary.pane_id
+                and workspace.layout is WorkspaceLayout.SIDE_BY_SIDE
+            ):
+                self._primary_width = width
+            else:
+                return False
+            self._sync_display_sizes()
+            self.request_keyframe()
+            return True
 
-    def resize_pane_height(self, _pane_id: str, _height: int) -> bool:
-        return True
+    def resize_pane_height(self, pane_id: str, height: int) -> bool:
+        with self._lock:
+            workspace = self._workspace
+            if (
+                workspace is None
+                or pane_id != workspace.primary.pane_id
+                or workspace.layout is not WorkspaceLayout.STACKED
+            ):
+                return False
+            self._primary_height = height
+            self._sync_display_sizes()
+            self.request_keyframe()
+            return True
 
     def toggle_pane_zoom(self, _pane_id: str) -> bool:
         with self._lock:
             if not self.pane_alive(_pane_id):
                 return False
             self._zoomed_pane = None if self._zoomed_pane == _pane_id else _pane_id
+            self._sync_display_sizes()
             self.request_keyframe()
             return True
 
@@ -562,6 +631,8 @@ class WinMuxBackend:
     def screen_update(self):
         with self._lock:
             self._sync_display_sizes()
+            status = self._project_status()
+            self._status_hits = status.hits
             workspace = self._workspace
             primary = secondary = None
             stacked = False
@@ -577,7 +648,9 @@ class WinMuxBackend:
                 )
                 if zoomed is not None:
                     return self._compositor.compose_full(
-                        zoomed, status=self._status
+                        zoomed,
+                        status=status.text.encode("utf-8", errors="replace"),
+                        status_error=status.error,
                     )
             focus = "sidebar"
             if workspace is not None and self._active_pane == workspace.primary.pane_id:
@@ -586,7 +659,22 @@ class WinMuxBackend:
                 focus = "secondary"
             return self._compositor.compose(
                 self._screen.pane, primary, secondary, stacked=stacked,
-                status=self._status, focus=focus,
+                status=status.text.encode("utf-8", errors="replace"),
+                status_error=status.error,
+                focus=focus,
+                show_primary=bool(
+                    workspace is not None and workspace.primary.pane_id
+                ),
+                show_secondary=bool(
+                    workspace is not None
+                    and workspace.secondary.pane_id
+                    and workspace.layout is not WorkspaceLayout.SINGLE
+                ),
+                layout=workspace.layout if workspace is not None else None,
+                sidebar_width=self._sidebar_width,
+                primary_size=(
+                    self._primary_height if stacked else self._primary_width
+                ),
             )
 
     def request_keyframe(self) -> None:
@@ -600,23 +688,7 @@ class WinMuxBackend:
         with self._lock:
             self.width, self.height = width, height
             self._compositor.resize(width, height)
-            regions = self._display_regions()
-            sidebar = regions["sidebar"]
-            self._screen.resize(sidebar.width, sidebar.height)
-            for name in ("primary", "secondary"):
-                region = regions.get(name)
-                pane_id = self._pane_for_region(name)
-                preview = self._previews.get(pane_id or "")
-                if region is not None and preview is not None:
-                    preview.resize(region.width, region.height)
-                session = self._session_for_region(name)
-                if region is None or session is None:
-                    continue
-                if session.terminal is not None:
-                    session.terminal.resize(region.width, region.height)
-                if session.process is not None and session.process.is_alive():
-                    session.process.resize(region.width, region.height)
-                    session.process_size = (region.width, region.height)
+            self._sync_display_sizes()
 
     def route_input(self, data: bytes, *, source: object | None = None) -> None:
         """Route keyboard and SGR mouse reports to the focused surface."""
@@ -634,10 +706,29 @@ class WinMuxBackend:
                 self._write_active(data)
 
     def _sync_display_sizes(self) -> None:
-        """Apply authoritative compositor regions to every displayed ConPTY."""
+        """Apply compositor geometry to Urwid, previews, and every ConPTY.
+
+        A topology change can narrow the sidebar without an outer terminal
+        resize.  Urwid must receive that viewport change too; otherwise it
+        keeps drawing its old wide canvas into a narrow terminal emulator and
+        wrapped fragments appear as duplicated rows.
+        """
         regions = self._display_regions()
+        sidebar = regions.get("sidebar")
+        if (
+            sidebar is not None
+            and self._screen.get_cols_rows() != (sidebar.width, sidebar.height)
+        ):
+            self._screen.resize(sidebar.width, sidebar.height)
         for name in ("primary", "secondary"):
             region = regions.get(name)
+            pane_id = self._pane_for_region(name)
+            preview = self._previews.get(pane_id or "")
+            if region is not None and preview is not None:
+                if (preview.width, preview.height) != (
+                    region.width, region.height
+                ):
+                    preview.resize(region.width, region.height)
             session = self._session_for_region(name)
             if region is None or session is None:
                 continue
@@ -670,10 +761,24 @@ class WinMuxBackend:
                 session = self._session_for_pane(self._active_pane)
             if session is not None and session.process is not None:
                 session.process.write(data)
+                return
+            # An empty display slot is not an input sink.  This can occur
+            # briefly after resetting/reaping a slot while focus still points
+            # at its stable pane identity.
+            self.select_pane("%controller")
+            self._screen.inject(data)
 
     def _route_mouse(self, event: SgrMouseEvent) -> None:
         x, y = event.x - 1, event.y - 1
         with self._lock:
+            if y == self.height - 1:
+                if (
+                    event.pressed
+                    and not event.button & (32 | 64)
+                    and event.button & 3 == 0
+                ):
+                    self._route_status_click(x)
+                return
             for name, region in self._display_regions().items():
                 if not (
                     region.x <= x < region.x + region.width
@@ -720,20 +825,79 @@ class WinMuxBackend:
             return {
                 name: Region(0, 0, self.width, max(1, self.height - 1))
             }
-        primary_pane = self._pane_for_region("primary")
-        secondary_pane = self._pane_for_region("secondary")
-        primary = self._terminal_for_display(primary_pane)
-        secondary = self._terminal_for_display(secondary_pane)
+        return self._layout_regions()
+
+    def _layout_regions(self):
+        """Return persistent pane geometry without applying zoom projection."""
         workspace = self._workspace
+        stacked = bool(
+            workspace is not None
+            and workspace.layout is WorkspaceLayout.STACKED
+        )
         return self._compositor.regions(
-            has_primary=primary is not None,
-            has_secondary=secondary is not None,
-            stacked=bool(
+            has_primary=bool(
+                workspace is not None and workspace.primary.pane_id
+            ),
+            has_secondary=bool(
                 workspace is not None
-                and workspace.layout is WorkspaceLayout.STACKED
+                and workspace.secondary.pane_id
+                and workspace.layout is not WorkspaceLayout.SINGLE
+            ),
+            stacked=stacked,
+            layout=workspace.layout if workspace is not None else None,
+            sidebar_width=self._sidebar_width,
+            primary_size=(
+                self._primary_height if stacked else self._primary_width
             ),
         )
 
+    def _project_status(self):
+        workspace = self._workspace
+        compact = bool(
+            workspace is not None
+            and workspace.presentation is WorkspacePresentation.COMPACT
+        )
+        page = (
+            workspace.compact_page
+            if workspace is not None else WorkspacePage.SIDEBAR
+        )
+        targets = (
+            "%controller",
+            workspace.primary.pane_id if workspace is not None else None,
+            workspace.secondary.pane_id if workspace is not None else None,
+        )
+        return project_status_chrome(
+            width=self.width,
+            mode_label=self._status_chrome.mode_label,
+            layout_indicator=self._status_chrome.layout_indicator,
+            status_text=self._status_text,
+            status_level=(
+                "error" if self._status_chrome.error else self._status_level
+            ),
+            compact=compact,
+            active_page=page,
+            page_targets=targets,
+        )
+
+    def _route_status_click(self, column: int) -> None:
+        hit = next(
+            (candidate for candidate in self._status_hits
+             if candidate.start <= column < candidate.end),
+            None,
+        )
+        if hit is None:
+            return
+        if hit.action == ACTION_MODE:
+            self._screen.inject(b"\x1b[15~")  # F5
+        elif hit.action == ACTION_LAYOUT:
+            self._screen.inject(b"\x1b[18~")  # F7
+        elif hit.action == ACTION_COPY:
+            self._screen.inject(b"\x1b[17~")  # F6
+        elif hit.action.startswith("page:"):
+            pane_id = hit.action[5:]
+            if self.pane_alive(pane_id):
+                self.select_pane(pane_id)
+
     def _pane_for_region(self, name: str) -> str | None:
         workspace = self._workspace
         if workspace is None:
@@ -826,12 +990,16 @@ class WinDisplayTransport:
     def create_primary(self, **_kwargs) -> bool:
         if self.workspace.primary.pane_id is None:
             self.workspace.primary.pane_id = self.backend.create_display_pane("primary")
+            with self.backend._lock:
+                self.backend._sync_display_sizes()
         return True
 
     def create_secondary(self, _layout) -> bool:
         self.create_primary()
         if self.workspace.secondary.pane_id is None:
             self.workspace.secondary.pane_id = self.backend.create_display_pane("secondary")
+            with self.backend._lock:
+                self.backend._sync_display_sizes()
         return True
 
     def create_dual(self, layout, **_kwargs) -> bool:
@@ -845,6 +1013,7 @@ class WinDisplayTransport:
         if slot.pane_id is None:
             slot.pane_id = self.backend.create_display_pane(slot.key)
         with self.backend._lock:
+            self.backend._previews.pop(slot.pane_id, None)
             self.backend._displayed[slot.pane_id] = agent_tmux_name
             slot.agent_tmux_name = agent_tmux_name
             slot.transport_kind = DisplayTransportKind.SWAP
@@ -864,6 +1033,7 @@ class WinDisplayTransport:
             if slot.pane_id:
                 self.backend._displayed.pop(slot.pane_id, None)
                 self.backend._previews.pop(slot.pane_id, None)
+            self.backend._sync_display_sizes()
         return True
 
     def prepare_preview(self, slot) -> bool:
@@ -873,7 +1043,9 @@ class WinDisplayTransport:
         with self.backend._lock:
             if slot.pane_id:
                 self.backend._displayed.pop(slot.pane_id, None)
+                self.backend._previews.pop(slot.pane_id, None)
             slot.clear_content()
+            self.backend._sync_display_sizes()
         return True
 
     def prepare_kill(self, _name):
@@ -884,6 +1056,8 @@ class WinDisplayTransport:
         if slot.pane_id:
             self.backend.kill_pane(slot.pane_id)
         slot.clear_display()
+        with self.backend._lock:
+            self.backend._sync_display_sizes()
         return True
 
     def close_all(self) -> bool: