railmux 0.4.0.dev22__tar.gz → 0.4.0.dev23__tar.gz

{railmux-0.4.0.dev22/src/railmux.egg-info → railmux-0.4.0.dev23}/PKG-INFO

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

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

{railmux-0.4.0.dev22 → railmux-0.4.0.dev23}/src/railmux/fast_display_client.py

@@ -281,6 +281,7 @@ class RemoteHello:
     config_status: str = "valid"
     tmux_configured: bool = False
     config_protocol: int = 0
+    platform: str = "posix"
 
 
 @dataclass(frozen=True)
@@ -296,6 +297,11 @@ class RemoteStartKind(Enum):
     TIMEOUT = "timeout"
 
 
+class RemoteLaunchMode(Enum):
+    POSIX = "posix"
+    DIRECT = "direct"
+
+
 class RemoteAttachKind(Enum):
     ACCEPTED = "accepted"
     BUSY = "busy"
@@ -369,6 +375,7 @@ def parse_remote_hello(line: bytes) -> RemoteHello:
     config_status = value.get("config_status", "valid")
     tmux_configured = value.get("tmux_configured", False)
     config_protocol = value.get("config_protocol", 0)
+    platform = value.get("platform", "posix")
     if (
         not isinstance(version, str)
         or not version
@@ -383,6 +390,7 @@ def parse_remote_hello(line: bytes) -> RemoteHello:
         or not isinstance(config_protocol, int)
         or isinstance(config_protocol, bool)
         or not 0 <= config_protocol <= 65535
+        or platform not in {"posix", "windows-msys2"}
     ):
         raise ValueError("invalid Railmux remote hello")
     try:
@@ -397,6 +405,7 @@ def parse_remote_hello(line: bytes) -> RemoteHello:
         config_status,
         tmux_configured,
         config_protocol,
+        platform,
     )
 
 
@@ -1540,12 +1549,18 @@ def _remote_launch_command(server_args: Sequence[str]) -> str:
     return "; ".join(branches)
 
 
+def _remote_direct_launch_command(server_args: Sequence[str]) -> str:
+    """Build a shell-neutral command accepted by Windows OpenSSH PowerShell."""
+    return shlex.join(["railmux", *server_args])
+
+
 def build_remote_command_argv(
     destination: str,
     *,
     remote_args: Sequence[str],
     ssh_args: Sequence[str],
     force_tty: bool = False,
+    launch_mode: RemoteLaunchMode = RemoteLaunchMode.POSIX,
 ) -> list[str]:
     """Build SSH argv through the shared remote Railmux discovery ladder."""
     return [
@@ -1556,7 +1571,11 @@ def build_remote_command_argv(
         # user arguments so a copied -t/-T flag cannot invert the transport.
         "-tt" if force_tty else "-T",
         destination,
-        _remote_launch_command(remote_args),
+        (
+            _remote_direct_launch_command(remote_args)
+            if launch_mode is RemoteLaunchMode.DIRECT
+            else _remote_launch_command(remote_args)
+        ),
     ]
 
 
@@ -1570,6 +1589,7 @@ def build_ssh_argv(
     ssh_args: Sequence[str],
     replace_existing_client: bool = False,
     existing_session_only: bool = False,
+    launch_mode: RemoteLaunchMode = RemoteLaunchMode.POSIX,
 ) -> list[str]:
     server_args = _remote_server_args(
         session=session,
@@ -1592,6 +1612,7 @@ def build_ssh_argv(
             "-o",
             "ServerAliveCountMax=3",
         ),
+        launch_mode=launch_mode,
     )
 
 
@@ -1757,6 +1778,43 @@ def remote_install_help(destination: str, version: str) -> str:
     )
 
 
+def remote_windows_install_help(destination: str, version: str) -> str:
+    return (
+        f"Update the user-level Windows preview on {destination} from "
+        "PowerShell, then retry:\n"
+        f"  py -m pip install --upgrade railmux=={version}\n"
+        "  railmux runtime install --yes\n"
+        "The runtime command installs only the matching Railmux app layer and "
+        "reuses a verified managed MSYS2 base when its pinned version is "
+        "unchanged. It does not modify Codex or Claude session files. If 'py' "
+        "is unavailable, use the same Windows Python executable that installed "
+        "the Railmux command."
+    )
+
+
+def _remote_launch_mode(args: argparse.Namespace) -> RemoteLaunchMode:
+    selected = getattr(args, "_selected_remote_launch_mode", None)
+    if isinstance(selected, RemoteLaunchMode):
+        return selected
+    if getattr(args, "remote_platform", "auto") == "windows":
+        return RemoteLaunchMode.DIRECT
+    return RemoteLaunchMode.POSIX
+
+
+def _remember_remote_launch_mode(
+    args: argparse.Namespace, mode: RemoteLaunchMode
+) -> None:
+    args._selected_remote_launch_mode = mode
+
+
+def _remote_uses_windows_runtime(
+    args: argparse.Namespace, hello: RemoteHello | None = None
+) -> bool:
+    return _remote_launch_mode(args) is RemoteLaunchMode.DIRECT or (
+        hello is not None and hello.platform == "windows-msys2"
+    )
+
+
 def remote_tmux_help(destination: str) -> str:
     return (
         f"tmux is not installed or not on PATH on {destination}. Install it "
@@ -1989,6 +2047,7 @@ def _reconnect_remote_attach(
         ssh_args=ssh_args,
         replace_existing_client=replace_existing_client,
         existing_session_only=existing_session_only,
+        launch_mode=_remote_launch_mode(args),
     )
     process = (
         _spawn_remote(argv, suppress_stderr=True)
@@ -2215,6 +2274,7 @@ def prepare_remote_process(
         if before_interaction is not None:
             before_interaction()
 
+    launch_mode = _remote_launch_mode(args)
     argv = build_ssh_argv(
         args.destination,
         session=args.session,
@@ -2222,11 +2282,62 @@ def prepare_remote_process(
         height=current_size.lines,
         fps=args.fps,
         ssh_args=args.ssh_arg,
+        launch_mode=launch_mode,
     )
     if on_stage is not None:
         on_stage("Connecting to remote host…")
     process = _spawn_remote(argv)
     startup = await_remote_startup(process)
+    if (
+        getattr(args, "remote_platform", "auto") == "auto"
+        and launch_mode is RemoteLaunchMode.POSIX
+        and startup.kind is RemoteStartKind.FAILED
+        and startup.returncode != 255
+    ):
+        _stop_unstarted_remote(process)
+        direct_argv = build_ssh_argv(
+            args.destination,
+            session=args.session,
+            width=current_size.columns,
+            height=current_size.lines,
+            fps=args.fps,
+            ssh_args=args.ssh_arg,
+            launch_mode=RemoteLaunchMode.DIRECT,
+        )
+        process = _spawn_remote(direct_argv)
+        startup = await_remote_startup(process)
+        if startup.kind is RemoteStartKind.HELLO:
+            launch_mode = RemoteLaunchMode.DIRECT
+            _remember_remote_launch_mode(args, launch_mode)
+        else:
+            _stop_unstarted_remote(process)
+            if startup.returncode == 255:
+                raise ProbeError("ssh could not connect to the remote host")
+            if startup.kind is RemoteStartKind.TIMEOUT:
+                raise ProbeError(
+                    "timed out while checking the remote host's direct Railmux launcher"
+                )
+            raise ProbeError(
+                "the remote shell did not accept the POSIX discovery command, "
+                "and a direct Railmux launch did not complete. If this is a "
+                "Windows preview host:\n"
+                f"{remote_windows_install_help(args.destination, __version__)}"
+            )
+    elif startup.kind is RemoteStartKind.HELLO:
+        _remember_remote_launch_mode(args, launch_mode)
+
+    if (
+        getattr(args, "remote_platform", "auto") == "windows"
+        and startup.kind is not RemoteStartKind.HELLO
+    ):
+        _stop_unstarted_remote(process)
+        if startup.returncode == 255:
+            raise ProbeError("ssh could not connect to the remote host")
+        if startup.kind is RemoteStartKind.TIMEOUT:
+            raise ProbeError(
+                "timed out waiting for the Windows Railmux compatibility handshake"
+            )
+        raise ProbeError(remote_windows_install_help(args.destination, __version__))
     install_version = __version__
     install_reason: str | None = None
     if startup.kind is RemoteStartKind.MISSING:
@@ -2281,6 +2392,12 @@ def prepare_remote_process(
             if decision.action == "prompt" and decision.prompt == "remote_install":
                 assert decision.reason is not None
                 assert decision.install_version is not None
+                if _remote_uses_windows_runtime(args, hello):
+                    _stop_unstarted_remote(process)
+                    raise ProbeError(
+                        f"{decision.reason}\n"
+                        f"{remote_windows_install_help(args.destination, decision.install_version)}"
+                    )
                 consents["remote_install"] = _confirm_remote_install(
                     args,
                     decision.reason,
@@ -2295,9 +2412,14 @@ def prepare_remote_process(
                 _stop_unstarted_remote(process)
                 message = decision.reason or "incompatible remote Railmux"
                 if decision.install_version is not None:
+                    install_help = (
+                        remote_windows_install_help
+                        if _remote_uses_windows_runtime(args, hello)
+                        else remote_install_help
+                    )
                     message = (
                         f"{message}\n"
-                        f"{remote_install_help(args.destination, decision.install_version)}"
+                        f"{install_help(args.destination, decision.install_version)}"
                     )
                 raise ProbeError(message)
             if decision.warning is not None:
@@ -2320,6 +2442,14 @@ def prepare_remote_process(
             raise AssertionError(f"unknown compatibility action: {decision.action}")
 
     assert install_reason is not None
+    if _remote_uses_windows_runtime(
+        args, startup.hello if startup.kind is RemoteStartKind.HELLO else None
+    ):
+        _stop_unstarted_remote(process)
+        raise ProbeError(
+            f"{install_reason}\n"
+            f"{remote_windows_install_help(args.destination, install_version)}"
+        )
     if startup.kind is not RemoteStartKind.HELLO and not _confirm_remote_install(
         args,
         install_reason,
@@ -2430,6 +2560,16 @@ def parse_args(argv: Optional[Sequence[str]] = None) -> argparse.Namespace:
         default=20.0,
         help="maximum coalesced display update rate, 1-60 (default: 20)",
     )
+    parser.add_argument(
+        "--remote-platform",
+        choices=("auto", "posix", "windows"),
+        default="auto",
+        help=(
+            "remote shell family: auto tries POSIX discovery then direct "
+            "Windows launch; windows avoids the failed POSIX probe and an "
+            "extra password prompt (default: auto)"
+        ),
+    )
     parser.add_argument(
         "--no-mouse",
         action="store_true",

{railmux-0.4.0.dev22 → railmux-0.4.0.dev23}/src/railmux/fast_display_server.py

@@ -248,6 +248,11 @@ def _emit_remote_hello(
             "config_status": config_status,
             "tmux_configured": tmux_configured,
             "config_protocol": REMOTE_CONFIG_PROTOCOL,
+            "platform": (
+                "windows-msys2"
+                if os.environ.get("RAILMUX_WINDOWS_RUNTIME") == "msys2"
+                else "posix"
+            ),
             "version": __version__,
         },
         separators=(",", ":"),

{railmux-0.4.0.dev22 → railmux-0.4.0.dev23/src/railmux.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.4.0.dev22
+Version: 0.4.0.dev23
 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.dev22 → railmux-0.4.0.dev23}/tests/test_fast_full_window.py

@@ -68,6 +68,7 @@ from railmux.fast_display_client import (
     LOCAL_ESCAPE,
     RemoteHello,
     RemoteAttachKind,
+    RemoteLaunchMode,
     RemoteStartKind,
     RemoteStartup,
     ScreenModel,
@@ -4392,6 +4393,22 @@ def test_full_window_ssh_command_uses_railmux_remote_subcommand_and_protocol():
     assert "--width 120 --height 40 --fps 20.0" in argv[-1]
 
 
+def test_windows_remote_command_uses_shell_neutral_direct_launch():
+    argv = build_ssh_argv(
+        "windows-server",
+        session="rail mux",
+        width=120,
+        height=40,
+        fps=20.0,
+        ssh_args=(),
+        launch_mode=RemoteLaunchMode.DIRECT,
+    )
+
+    assert argv[-1].startswith("railmux remote-server ")
+    assert "if [" not in argv[-1]
+    assert "--session 'rail mux'" in argv[-1]
+
+
 def test_full_window_ssh_keepalive_defaults_follow_user_overrides():
     argv = build_ssh_argv(
         "server",
@@ -4538,6 +4555,12 @@ def test_remote_hello_is_strictly_bounded_and_typed():
     )
     assert configured.config_status == "invalid"
     assert configured.tmux_configured is True
+    windows = parse_remote_hello(
+        REMOTE_HELLO_PREFIX
+        + b'{"platform":"windows-msys2","protocol":6,"ready":true,'
+        b'"tmux":true,"version":"1.2.3"}\n'
+    )
+    assert windows.platform == "windows-msys2"
     with pytest.raises(ValueError):
         parse_remote_hello(
             REMOTE_HELLO_PREFIX + b'{"protocol":true,"ready":true,"tmux":true,'
@@ -4545,6 +4568,12 @@ def test_remote_hello_is_strictly_bounded_and_typed():
         )
     with pytest.raises(ValueError):
         parse_remote_hello(REMOTE_HELLO_PREFIX + b"not-json\n")
+    with pytest.raises(ValueError):
+        parse_remote_hello(
+            REMOTE_HELLO_PREFIX
+            + b'{"platform":"windows","protocol":6,"ready":true,'
+            b'"tmux":true,"version":"1.2.3"}\n'
+        )
 
 
 def test_remote_startup_wait_reads_hello_before_raw_mode():
@@ -4853,6 +4882,14 @@ def test_ssh_parser_accepts_ordered_exact_and_grouped_arguments():
     ]
 
 
+def test_ssh_parser_selects_remote_platform_without_changing_default():
+    assert parse_client_args(["server"]).remote_platform == "auto"
+    assert (
+        parse_client_args(["server", "--remote-platform", "windows"]).remote_platform
+        == "windows"
+    )
+
+
 def test_reconnect_attach_forces_noninteractive_bounded_ssh(monkeypatch):
     process = _PreflightProcess()
     built = MagicMock(return_value=["ssh", "remote"])
@@ -4901,6 +4938,7 @@ def test_reconnect_attach_forces_noninteractive_bounded_ssh(monkeypatch):
         "ConnectTimeout=5",
     ]
     assert built.call_args.kwargs["replace_existing_client"] is False
+    assert built.call_args.kwargs["launch_mode"] is RemoteLaunchMode.POSIX
     spawn.assert_called_once_with(
         ["ssh", "remote"],
         suppress_stderr=True,
@@ -4948,6 +4986,44 @@ def test_reconnect_connect_timeout_keeps_user_first_value(monkeypatch):
     )
 
 
+def test_reconnect_reuses_selected_windows_launch_mode(monkeypatch):
+    process = _PreflightProcess()
+    built = MagicMock(return_value=["ssh", "remote"])
+    monkeypatch.setattr(fast_display_client, "build_ssh_argv", built)
+    monkeypatch.setattr(
+        fast_display_client,
+        "_spawn_remote",
+        MagicMock(return_value=process),
+    )
+    monkeypatch.setattr(
+        fast_display_client,
+        "await_remote_startup",
+        lambda *_args, **_kwargs: RemoteStartup(
+            RemoteStartKind.HELLO,
+            RemoteHello(
+                fast_display_client.__version__,
+                PROTOCOL_VERSION,
+                True,
+                platform="windows-msys2",
+            ),
+        ),
+    )
+    monkeypatch.setattr(
+        fast_display_client,
+        "await_remote_attach_status",
+        lambda *_args, **_kwargs: RemoteAttachKind.ACCEPTED,
+    )
+    args = parse_client_args(["server", "--remote-platform", "windows"])
+
+    fast_display_client._reconnect_remote_attach(
+        args,
+        os.terminal_size((120, 40)),
+        replace_existing_client=False,
+    )
+
+    assert built.call_args.kwargs["launch_mode"] is RemoteLaunchMode.DIRECT
+
+
 def test_remote_command_keeps_railmux_tty_mode_after_user_flags():
     binary = build_remote_command_argv(
         "server",
@@ -5348,6 +5424,71 @@ def test_compatible_remote_is_confirmed_before_attach(monkeypatch):
     ]
 
 
+def test_auto_remote_launch_falls_back_to_windows_and_pins_reconnect_mode(
+    monkeypatch,
+):
+    _accept_attach(monkeypatch)
+    posix = _PreflightProcess(1)
+    windows = _PreflightProcess()
+    processes = iter((posix, windows))
+    commands = []
+
+    def spawn(argv):
+        commands.append(argv)
+        return next(processes)
+
+    startups = iter(
+        (
+            RemoteStartup(RemoteStartKind.FAILED, returncode=1),
+            RemoteStartup(
+                RemoteStartKind.HELLO,
+                RemoteHello(
+                    fast_display_client.__version__,
+                    PROTOCOL_VERSION,
+                    True,
+                    platform="windows-msys2",
+                ),
+            ),
+        )
+    )
+    monkeypatch.setattr(fast_display_client, "_spawn_remote", spawn)
+    monkeypatch.setattr(
+        fast_display_client,
+        "await_remote_startup",
+        lambda _process: next(startups),
+    )
+    args = parse_client_args(["server"])
+
+    selected = prepare_remote_process(args, os.terminal_size((120, 40)))
+
+    assert selected is windows
+    assert posix.terminated is False
+    assert "if [" in commands[0][-1]
+    assert commands[1][-1].startswith("railmux remote-server ")
+    assert args._selected_remote_launch_mode is RemoteLaunchMode.DIRECT
+    assert windows.stdin.getvalue() == REMOTE_START
+
+
+def test_explicit_windows_remote_failure_never_runs_posix_installer(monkeypatch):
+    process = _PreflightProcess(1)
+    args = parse_client_args(["server", "--remote-platform", "windows"])
+    monkeypatch.setattr(fast_display_client, "_spawn_remote", lambda _argv: process)
+    monkeypatch.setattr(
+        fast_display_client,
+        "await_remote_startup",
+        lambda _process: RemoteStartup(RemoteStartKind.FAILED, returncode=1),
+    )
+    install = MagicMock()
+    monkeypatch.setattr(fast_display_client, "_install_remote_and_start", install)
+
+    with pytest.raises(fast_display_client.ProbeError) as exc:
+        prepare_remote_process(args, os.terminal_size((120, 40)))
+
+    assert "py -m pip install --upgrade" in str(exc.value)
+    assert "railmux runtime install --yes" in str(exc.value)
+    install.assert_not_called()
+
+
 def test_reconnect_flag_does_not_change_initial_ssh_command():
     plain = parse_client_args(["server"])
     reconnecting = parse_client_args(["server", "--reconnect"])
@@ -5492,7 +5633,8 @@ def test_missing_remote_prompts_then_installs_and_starts(monkeypatch):
     missing = _PreflightProcess(127)
     installed = _PreflightProcess()
     args = parse_client_args(["server"])
-    monkeypatch.setattr(fast_display_client, "_spawn_remote", lambda _argv: missing)
+    spawn = MagicMock(return_value=missing)
+    monkeypatch.setattr(fast_display_client, "_spawn_remote", spawn)
     monkeypatch.setattr(
         fast_display_client,
         "await_remote_startup",
@@ -5515,6 +5657,7 @@ def test_missing_remote_prompts_then_installs_and_starts(monkeypatch):
 
     assert selected is installed
     assert installed.stdin.getvalue() == REMOTE_START
+    spawn.assert_called_once()
 
 
 def test_missing_remote_decline_returns_copyable_install_help(
@@ -5813,6 +5956,37 @@ def test_older_remote_protocol_prompts_for_matching_remote_upgrade(monkeypatch):
     assert upgraded.stdin.getvalue() == REMOTE_START
 
 
+def test_windows_remote_upgrade_fails_closed_with_windows_guidance(monkeypatch):
+    process = _PreflightProcess()
+    args = parse_client_args(["server", "--remote-platform", "windows"])
+    monkeypatch.setattr(fast_display_client, "_spawn_remote", lambda _argv: process)
+    monkeypatch.setattr(
+        fast_display_client,
+        "await_remote_startup",
+        lambda _process: RemoteStartup(
+            RemoteStartKind.HELLO,
+            RemoteHello(
+                "0.1.0",
+                PROTOCOL_VERSION - 1,
+                True,
+                platform="windows-msys2",
+            ),
+        ),
+    )
+    confirm = MagicMock()
+    install = MagicMock()
+    monkeypatch.setattr(fast_display_client, "_confirm", confirm)
+    monkeypatch.setattr(fast_display_client, "_install_remote_and_start", install)
+
+    with pytest.raises(fast_display_client.ProbeError) as exc:
+        prepare_remote_process(args, os.terminal_size((120, 40)))
+
+    assert "py -m pip install --upgrade" in str(exc.value)
+    assert "railmux runtime install --yes" in str(exc.value)
+    confirm.assert_not_called()
+    install.assert_not_called()
+
+
 def test_older_compatible_remote_can_be_upgraded_to_local_version(monkeypatch):
     _accept_attach(monkeypatch)
     monkeypatch.setattr(fast_display_client, "__version__", "0.2.5")
@@ -6066,6 +6240,18 @@ def test_remote_server_hello_reports_version_protocol_and_dependency(monkeypatch
     )
 
 
+def test_remote_server_hello_identifies_managed_windows_runtime(monkeypatch):
+    output = io.BytesIO()
+    monkeypatch.setenv("RAILMUX_WINDOWS_RUNTIME", "msys2")
+    monkeypatch.setattr(fast_display_server.shutil, "which", lambda _name: "/tmux")
+    monkeypatch.setattr(fast_display_server.sys, "stdout", MagicMock(buffer=output))
+
+    fast_display_server._emit_remote_hello(True)
+
+    hello = parse_remote_hello(output.getvalue())
+    assert hello.platform == "windows-msys2"
+
+
 def test_remote_server_waits_for_exact_start_confirmation(monkeypatch):
     remote_input = MagicMock(buffer=io.BytesIO(REMOTE_START))
     monkeypatch.setattr(fast_display_server.sys, "stdin", remote_input)

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

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