railmux 0.3.2.dev5__tar.gz → 0.4.0.dev1__tar.gz

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

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

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

{railmux-0.3.2.dev5 → railmux-0.4.0.dev1}/src/railmux/tmux_ctl.py

@@ -2125,7 +2125,9 @@ def _root_wheel_bindings_are_defaults(
         return False
     return (
         "mouse_any_flag" in body
-        and "send-keys -M" in body
+        # tmux 3.2 serializes its stock command with the accepted ``send``
+        # alias, while newer releases print the canonical ``send-keys`` name.
+        and re.search(r"\bsend(?:-keys)?\s+-M\b", body) is not None
         and "copy-mode -e" in body
         and _ROOT_WHEEL_MARKER not in body
     )

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

@@ -304,12 +304,26 @@ class WinMuxBackend:
         )
 
     def server_snapshot(self):
-        live = [session for session in self._sessions.values() if self.session_exists(session.name)]
-        return tmux_ctl.ServerSnapshot(
-            frozenset(session.name for session in live),
-            frozenset(session.pane_id for session in live),
-            tuple((session.name, session.process.pid) for session in live if session.process),
-        )
+        with self._lock:
+            live = [
+                session
+                for session in self._sessions.values()
+                if self.session_exists(session.name)
+            ]
+            panes = frozenset(
+                pane_id
+                for pane_id in self._panes
+                if self.pane_alive(pane_id)
+            )
+            return tmux_ctl.ServerSnapshot(
+                frozenset(session.name for session in live),
+                panes,
+                tuple(
+                    (session.name, session.process.pid)
+                    for session in live
+                    if session.process
+                ),
+            )
 
     def select_pane(self, pane_id: str) -> bool:
         with self._lock:
@@ -891,7 +905,10 @@ class WinDisplayTransport:
         return None
 
     def fallback_for_external_client(self, *_args, **_kwargs):
-        return True
+        # Native Windows has no external tmux client or nested-display
+        # fallback. ``App`` treats ``None`` as not applicable and otherwise
+        # requires an AttachOutcome-compatible object.
+        return None
 
     def outer_session_lost(self) -> bool:
         return False

{railmux-0.3.2.dev5 → railmux-0.4.0.dev1}/src/railmux/winlocal/client.py

@@ -28,7 +28,13 @@ from railmux.fast_display_protocol import (
     encode_resize,
 )
 from railmux.platform.console import RawConsole
-from railmux.winlocal.daemon import AUTH_OK, AUTH_PREFIX, endpoint_path
+from railmux.winlocal.daemon import (
+    AUTH_OK,
+    AUTH_PREFIX,
+    NATIVE_UI_FAILED,
+    endpoint_path,
+    ui_error_path,
+)
 from railmux.winlocal.ipc import Endpoint, read_endpoint, receive_message, send_message
 
 
@@ -38,6 +44,10 @@ _MAX_COLUMNS = 1000
 _MAX_LINES = 500
 
 
+class NativeUIError(RuntimeError):
+    """The daemon's shared UI failed while provider ConPTYs stayed alive."""
+
+
 def connect_endpoint(endpoint: Endpoint, *, timeout: float = 2.0) -> socket.socket:
     sock = socket.create_connection(("127.0.0.1", endpoint.port), timeout=timeout)
     try:
@@ -160,6 +170,8 @@ class NativeClient:
                         kind, payload = self._events.get(timeout=0.1)
                     except queue.Empty:
                         kind, payload = "tick", None
+                    if kind == "ui_error":
+                        raise NativeUIError
                     if kind == "closed":
                         return 2
                     if kind == "input":
@@ -203,6 +215,15 @@ class NativeClient:
         except ValueError as exc:
             print(f"error: {exc}", file=sys.stderr)
             return 2
+        except NativeUIError:
+            # Leave the alternate screen before printing actionable feedback.
+            surface.close()
+            print(
+                "error: native Railmux UI stopped unexpectedly; provider "
+                f"sessions are still running. Retry railmux; details: {ui_error_path()}",
+                file=sys.stderr,
+            )
+            return 2
         except (ConnectionError, OSError):
             return 2
         finally:
@@ -219,6 +240,9 @@ class NativeClient:
                 packet = receive_message(self.sock)
                 if packet is None:
                     break
+                if packet == NATIVE_UI_FAILED:
+                    self._events.put(("ui_error", None))
+                    return
                 self._events.put(("server", packet))
         except (ConnectionError, OSError, ValueError):
             pass

{railmux-0.3.2.dev5 → railmux-0.4.0.dev1}/src/railmux/winlocal/daemon.py

@@ -7,10 +7,12 @@ import socket
 import struct
 import threading
 import time
+import traceback
 import uuid
 from pathlib import Path
 from typing import Callable
 
+from railmux.atomic_file import atomic_write_text
 from railmux.config import Config, ConfigError, load_config
 from railmux.fast_display_protocol import (
     InputFrameDecoder,
@@ -33,6 +35,8 @@ from railmux.winlocal.session_store import SessionStore
 AUTH_PREFIX = b"AUTH "
 AUTH_OK = b"OK"
 AUTH_FAILED = b"ERROR authentication failed"
+NATIVE_UI_FAILED = b"RAILMUX-NATIVE/1 UI_FAILED"
+_UI_ERROR_LIMIT = 64 * 1024
 
 
 def native_runtime_dir() -> Path:
@@ -47,6 +51,10 @@ def session_store_path() -> Path:
     return native_runtime_dir() / "sessions.json"
 
 
+def ui_error_path() -> Path:
+    return native_runtime_dir() / "native-ui-error.log"
+
+
 class DaemonServer:
     """Authenticated loopback server around one daemon-owned backend."""
 
@@ -60,6 +68,7 @@ class DaemonServer:
         fps: float = 20.0,
         idle_timeout: float = 300.0,
         app_factory: Callable[[], object] | None = None,
+        ui_error_file: Path | None = None,
     ) -> None:
         self.backend = backend
         self.endpoint_file = endpoint_file
@@ -69,6 +78,7 @@ class DaemonServer:
         self.idle_timeout = max(1.0, idle_timeout)
         self._last_nonidle = time.monotonic()
         self.app_factory = app_factory
+        self.ui_error_file = ui_error_file or endpoint_file.parent / ui_error_path().name
         self._listener: socket.socket | None = None
         self._clients: set[socket.socket] = set()
         self._clients_lock = threading.RLock()
@@ -194,14 +204,17 @@ class DaemonServer:
             self._app_thread.start()
 
     def _run_app(self) -> None:
+        failed = False
         try:
             assert self.app_factory is not None
             app = self.app_factory()
             run = getattr(app, "run")
             run()
-        except Exception:
+        except Exception as exc:
+            failed = True
             # Keep the daemon/ConPTY authority alive so a later attachment can
             # retry the UI without converting a display fault into session loss.
+            self._record_ui_failure(exc)
             self.backend.set_status_text(
                 "Native UI stopped unexpectedly; reconnect to retry",
                 "error",
@@ -210,7 +223,28 @@ class DaemonServer:
             # Urwid returning means hard quit, soft quit, or a failed UI. The
             # daemon and any surviving ConPTYs remain authoritative, but every
             # frontend must leave instead of displaying a frozen last frame.
-            self._detach_all_clients()
+            self._detach_all_clients(
+                final_message=NATIVE_UI_FAILED if failed else None
+            )
+
+    def _record_ui_failure(self, exc: BaseException) -> None:
+        """Persist one bounded private traceback for the local user."""
+        detail = "".join(
+            traceback.format_exception(type(exc), exc, exc.__traceback__)
+        )
+        if len(detail) > _UI_ERROR_LIMIT:
+            detail = "[traceback truncated]\n" + detail[-_UI_ERROR_LIMIT:]
+        payload = (
+            "Railmux native UI failure\n"
+            f"recorded_at={int(time.time())}\n"
+            f"daemon_id={self.daemon_id}\n"
+            f"{detail}"
+        )
+        try:
+            ensure_private_dir(self.ui_error_file.parent)
+            atomic_write_text(self.ui_error_file, payload)
+        except OSError:
+            pass
 
     def _render_loop(self) -> None:
         interval = 1.0 / self.fps
@@ -249,11 +283,16 @@ class DaemonServer:
         with self._clients_lock:
             return len(self._clients)
 
-    def _detach_all_clients(self) -> None:
+    def _detach_all_clients(self, *, final_message: bytes | None = None) -> None:
         with self._clients_lock:
             clients = tuple(self._clients)
             self._clients.clear()
         for client in clients:
+            if final_message is not None:
+                try:
+                    send_message(client, final_message)
+                except (ConnectionError, OSError, ValueError):
+                    pass
             try:
                 client.shutdown(socket.SHUT_RDWR)
             except OSError:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.3.2.dev5
+Version: 0.4.0.dev1
 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.3.2.dev5 → railmux-0.4.0.dev1}/tests/test_release_workflow.py

@@ -50,3 +50,17 @@ def test_development_tag_creates_a_github_prerelease():
     assert 'if [[ "$GITHUB_REF_NAME" == *.dev* ]]' in release
     assert "prerelease+=(--prerelease)" in release
     assert '"${prerelease[@]}"' in release
+
+
+def test_release_tags_are_fenced_to_their_product_branches():
+    release = (ROOT / ".github/workflows/release.yml").read_text()
+
+    assert "fetch-depth: 0" in release
+    assert "origin/main" in release
+    assert "origin/windows-preview" in release
+    assert "POSIX/WSL development release from main" in release
+    assert "native-Windows development release from windows-preview" in release
+    assert "main development releases must use the 0.3.x.devN series" in release
+    assert "native-Windows releases must use the 0.4.0.devN series" in release
+    assert "development releases must come from main or windows-preview" in release
+    assert "final releases must come from main" in release

{railmux-0.3.2.dev5 → railmux-0.4.0.dev1}/tests/test_tmux_ctl.py

@@ -514,6 +514,15 @@ def test_root_wheel_forwarding_requires_stock_bindings_and_tmux_27():
                return_value=backup):
         assert tmux_ctl.prepare_root_wheel_bindings() == backup
 
+    tmux_32_backup = dict(
+        backup,
+        WheelUpPane=backup["WheelUpPane"].replace("send-keys -M", "send -M"),
+    )
+    with patch("railmux.tmux_ctl.tmux_version", return_value=(3, 2)), \
+         patch("railmux.tmux_ctl.read_root_wheel_bindings",
+               return_value=tmux_32_backup):
+        assert tmux_ctl.prepare_root_wheel_bindings() == tmux_32_backup
+
     custom = dict(backup, WheelDownPane=(
         "bind-key -T root WheelDownPane display-message custom"))
     with patch("railmux.tmux_ctl.tmux_version", return_value=(3, 4)), \

{railmux-0.3.2.dev5 → railmux-0.4.0.dev1}/tests/test_tmux_integration.py

@@ -1522,6 +1522,12 @@ def test_real_soft_quit_disconnects_shared_clients_and_agents_survive(
     for directory in (socket_root, home, runtime, claude_home):
         directory.mkdir(parents=True, exist_ok=True)
         directory.chmod(0o700)
+    config_dir = home / ".config" / "railmux"
+    config_dir.mkdir(parents=True)
+    (config_dir / "config.toml").write_text(
+        '[updates]\nauto_update = "never"\n',
+        encoding="utf-8",
+    )
 
     label = f"rx-soft-quit-{os.getpid()}"
     monkeypatch.setenv("TMUX_TMPDIR", str(socket_root))
@@ -2617,15 +2623,9 @@ def test_real_tmux_binding_manager_round_trip_and_user_reload(
     client_name = ""
 
     def send_client_key(key: str) -> None:
-        if tmux_ctl.tmux_version() >= (3, 0):
-            subprocess.run(
-                ["tmux", "send-keys", "-K", "-c", client_name, key],
-                check=True,
-            )
-            return
-        # tmux 2.7 predates send-keys -K. Feed the corresponding xterm bytes
-        # to the same attached client so the binding still executes through
-        # the real terminal input path.
+        # Feed xterm bytes to the attached client on every supported version.
+        # ``send-keys -K`` is absent from tmux 3.2 even though later releases
+        # provide it; the raw path also exercises the real terminal decoder.
         sequence = {"F8": b"\x1b[19~", "C-b": b"\x02", "Tab": b"\t"}[key]
         assert client_process.stdin is not None
         client_process.stdin.write(sequence)

{railmux-0.3.2.dev5 → railmux-0.4.0.dev1}/tests/test_winlocal_backend.py

@@ -59,6 +59,48 @@ def test_windows_backend_starts_typed_provider_and_composes_display():
     assert update.width == 120 and update.height == 30
 
 
+def test_windows_snapshot_keeps_attached_display_pane_alive():
+    backend = WinMuxBackend(process_factory=_factory)
+    launch = backend.prepare_launch(["codex", "resume", "abc"], Path("C:/repo"))
+    assert backend.new_detached_session("codex-abc", launch) == (True, None)
+    workspace = AgentWorkspace()
+    transport = backend.create_display_transport(workspace, "swap")
+
+    assert transport.attach(workspace.primary, "codex-abc").ok
+    assert workspace.primary.pane_id is not None
+    snapshot = backend.server_snapshot()
+
+    assert workspace.primary.pane_id in snapshot.panes
+    assert backend._sessions["codex-abc"].pane_id in snapshot.panes
+    assert transport.fallback_for_external_client(workspace.primary) is None
+
+
+def test_shared_reconciliation_preserves_native_attached_agent(tmp_path):
+    backend = WinMuxBackend(process_factory=_factory)
+    app = App(tmp_path, Config(), mux_backend=backend)
+    launch = backend.prepare_launch(["codex", "resume", "abc"], tmp_path)
+    assert backend.new_detached_session("codex-abc", launch) == (True, None)
+    session = backend._sessions["codex-abc"]
+    assert session.terminal is not None
+    session.terminal.feed(b"AGENT_PANEL_READY")
+    slot = app._agent_workspace().primary
+    assert app._display_transport().attach(slot, "codex-abc").ok
+
+    snapshot = backend.server_snapshot()
+    app._reconcile_display_slots(
+        lambda name: name in snapshot.sessions,
+        lambda pane_id: pane_id in snapshot.panes,
+    )
+
+    assert slot.pane_id is not None
+    assert slot.agent_tmux_name == "codex-abc"
+    assert "primary" in backend._display_regions()
+    assert any(
+        b"AGENT_PANEL_READY" in row
+        for _index, row in backend.screen_update().rows
+    )
+
+
 def test_windows_backend_preserves_unsuperseded_resume_offers(tmp_path):
     store = SessionStore(tmp_path / "sessions.json", "new-daemon")
     offer = SessionRecord(

{railmux-0.3.2.dev5 → railmux-0.4.0.dev1}/tests/test_winlocal_compositor.py

@@ -46,3 +46,22 @@ def test_sidebar_is_full_width_without_agent_and_status_cannot_scroll_frame():
         "sidebar"
     ].width == 40
     assert b"Projects" in rows[0]
+
+
+def test_compositor_preserves_cjk_agent_output_and_bottom_status():
+    sidebar = TerminalPane(20, 6)
+    primary = TerminalPane(20, 6)
+    sidebar.feed("会话列表".encode("utf-8"))
+    primary.feed("代理已恢复".encode("utf-8"))
+    compositor = Compositor(60, 12)
+
+    update = compositor.compose(
+        sidebar,
+        primary,
+        status="状态栏可见".encode("utf-8"),
+    )
+    rows = dict(update.rows)
+
+    assert "会话列表".encode("utf-8") in rows[0]
+    assert "代理已恢复".encode("utf-8") in rows[0]
+    assert "状态栏可见".encode("utf-8") in rows[11]

{railmux-0.3.2.dev5 → railmux-0.4.0.dev1}/tests/test_winlocal_daemon.py

@@ -10,8 +10,8 @@ from railmux.fast_display_protocol import (
     encode_resize,
 )
 from railmux.winlocal.backend import WinMuxBackend
-from railmux.winlocal.client import connect_endpoint, ensure_daemon
-from railmux.winlocal.daemon import AUTH_PREFIX, DaemonServer
+from railmux.winlocal.client import NativeClient, connect_endpoint, ensure_daemon
+from railmux.winlocal.daemon import AUTH_PREFIX, NATIVE_UI_FAILED, DaemonServer
 from railmux.winlocal.ipc import read_endpoint, receive_message, send_message
 
 
@@ -132,6 +132,59 @@ def test_app_exit_disconnects_frontend_but_keeps_daemon_available(tmp_path):
         thread.join(timeout=2)
 
 
+def test_app_crash_reports_failure_and_writes_bounded_traceback(tmp_path):
+    class App:
+        def run(self):
+            raise RuntimeError("refresh contract failed")
+
+    error_file = tmp_path / "native-ui-error.log"
+    server = DaemonServer(
+        _backend(),
+        endpoint_file=tmp_path / "endpoint.json",
+        app_factory=App,
+        ui_error_file=error_file,
+    )
+    endpoint = server.start()
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    client = connect_endpoint(endpoint)
+    client.settimeout(2)
+    try:
+        messages = []
+        deadline = time.monotonic() + 2
+        while time.monotonic() < deadline:
+            message = receive_message(client)
+            if message is None:
+                break
+            messages.append(message)
+            if message == NATIVE_UI_FAILED:
+                break
+        assert NATIVE_UI_FAILED in messages
+        detail = error_file.read_text(encoding="utf-8")
+        assert "RuntimeError: refresh contract failed" in detail
+        assert f"daemon_id={server.daemon_id}" in detail
+        assert len(detail) <= 65 * 1024
+    finally:
+        client.close()
+        server.close()
+        thread.join(timeout=2)
+
+
+def test_native_client_classifies_ui_failure_before_socket_close():
+    daemon, frontend = socket.socketpair()
+    client = NativeClient(frontend)
+    thread = threading.Thread(target=client._read_socket, daemon=True)
+    thread.start()
+    try:
+        send_message(daemon, NATIVE_UI_FAILED)
+        assert client._events.get(timeout=2) == ("ui_error", None)
+    finally:
+        client._stop.set()
+        daemon.close()
+        frontend.close()
+        thread.join(timeout=2)
+
+
 def test_idle_daemon_without_clients_or_sessions_exits(tmp_path):
     endpoint_file = tmp_path / "endpoint.json"
     server = DaemonServer(

{railmux-0.3.2.dev5 → railmux-0.4.0.dev1}/tests/test_winlocal_real_conpty.py

@@ -1,4 +1,5 @@
 import os
+import sys
 import time
 
 import pytest
@@ -59,3 +60,35 @@ def test_real_conpty_launches_cmd_shim_from_path_with_spaces(tmp_path):
     finally:
         if process.is_alive():
             process.terminate(force=True)
+
+
+@pytest.mark.skipif(os.name != "nt", reason="requires Windows ConPTY")
+def test_real_conpty_normalizes_cp936_child_output_to_utf8(tmp_path):
+    shim = tmp_path / "cp936-provider.cmd"
+    shim.write_text(
+        "@echo off\r\n"
+        "chcp 936 >nul\r\n"
+        f'"{sys.executable}" -c "print(\'\\u4e2d\\u6587\')"\r\n',
+        encoding="ascii",
+    )
+    process = PyWinPtyProcess.spawn(
+        provider_argv(str(shim), (), windows=True),
+        cwd=tmp_path,
+        env=dict(os.environ),
+        columns=80,
+        rows=24,
+    )
+    output = bytearray()
+    expected = "中文".encode("utf-8")
+    deadline = time.monotonic() + 10
+    try:
+        while time.monotonic() < deadline and expected not in output:
+            try:
+                output.extend(process.read(65536))
+            except EOFError:
+                break
+        assert expected in output
+        output.decode("utf-8")
+    finally:
+        if process.is_alive():
+            process.terminate(force=True)

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

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