railmux 0.4.0.dev17__tar.gz → 0.4.0.dev19__tar.gz

{railmux-0.4.0.dev17/src/railmux.egg-info → railmux-0.4.0.dev19}/PKG-INFO

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

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

{railmux-0.4.0.dev17 → railmux-0.4.0.dev19}/src/railmux/cli.py

@@ -26,6 +26,7 @@ from railmux import tmux_server
 from railmux import windows_tmux_lifecycle
 from railmux.system_deps import ensure_tmux_available
 from railmux.ssh_args import AppendSshArgument, ExtendSshArguments
+from railmux.terminal_status import command_status
 
 
 def _show_startup_message(
@@ -85,6 +86,9 @@ def _run_tmux_client_with_watchdog(
     expected_session_id: str | None = None,
 ) -> int:
     """Keep one monitor outside tmux so a frozen server cannot trap the TTY."""
+    from railmux.provider_paths import running_in_managed_windows_wrapper
+
+    managed_windows = running_in_managed_windows_wrapper()
     attributes = None
     if sys.stdin.isatty():
         try:
@@ -93,7 +97,14 @@ def _run_tmux_client_with_watchdog(
             pass
     started_at = time.monotonic()
     try:
-        process: object = subprocess.Popen(argv, env=env)
+        popen_kwargs: dict[str, object] = {"env": env}
+        if managed_windows and expected_target is not None:
+            # A fast direct-client rejection is an implementation detail when
+            # the server-origin bridge succeeds. Suppress tmux's raw
+            # ``open terminal failed`` line and emit one Railmux-owned status
+            # below; bridge failures still receive an actionable error.
+            popen_kwargs["stderr"] = subprocess.DEVNULL
+        process: object = subprocess.Popen(argv, **popen_kwargs)
     except OSError as exc:
         print(f"error: could not start tmux client: {exc}", file=sys.stderr)
         return 2
@@ -204,10 +215,6 @@ def _run_tmux_client_with_watchdog(
                 expected_session_id = tmux_server.target_session_id(
                     expected_target, "railmux", timeout=0.5)
 
-            from railmux.provider_paths import running_in_managed_windows_wrapper
-
-            managed_windows = running_in_managed_windows_wrapper()
-
             can_relay = bool(
                 current_target == expected_target
                 and expected_session_id is not None
@@ -223,13 +230,7 @@ def _run_tmux_client_with_watchdog(
                     start_relay_client,
                 )
 
-                print(
-                    "info: direct tmux attach was unavailable; reconnecting "
-                    "through the Windows terminal bridge",
-                    file=sys.stderr,
-                )
                 try:
-                    tty.setraw(sys.stdin.fileno())
                     relay = start_relay_client(
                         target=expected_target,
                         session_id=expected_session_id,
@@ -237,6 +238,15 @@ def _run_tmux_client_with_watchdog(
                         stdin_fd=sys.stdin.fileno(),
                         stdout_fd=sys.stdout.fileno(),
                     )
+                    print(
+                        command_status(
+                            "info",
+                            "connected through the Windows terminal bridge",
+                            stream=sys.stderr,
+                        ),
+                        file=sys.stderr,
+                    )
+                    tty.setraw(sys.stdin.fileno())
                     process = relay
                     returncode, watchdog_failed = monitor_client(
                         asynchronous_probe=True)
@@ -296,6 +306,14 @@ def _run_tmux_client_with_watchdog(
                     ),
                     consecutive_failures=1,
                 )
+                if not relay_attempted:
+                    print(
+                        "error: direct tmux attach was rejected and the "
+                        "Windows terminal bridge was unavailable; the "
+                        "existing workspace was left running; run "
+                        "'railmux doctor' for diagnostics",
+                        file=sys.stderr,
+                    )
         # Routine post-exit removal of a proof-authorized last-session socket
         # is housekeeping. Only pre-launch recovery is user-visible.
         windows_tmux_lifecycle.recover_abandoned_socket()
@@ -593,14 +611,28 @@ def main(argv: list[str] | None = None) -> int:
             if Path(sys.argv[0]).name == "__main__.py"
             else [sys.argv[0]]
         )
-        cmd = tmux_server.launcher_argv(launch_prefix, raw_args)
+        client_env = tmux_server.exec_environment()
         dedicated_session_id = (
             tmux_server.target_session_id(dedicated_target, "railmux")
             if dedicated_target is not None else None
         )
+        if dedicated_target is not None and dedicated_session_id is None:
+            from railmux.provider_paths import (
+                running_in_managed_windows_wrapper,
+            )
+            if running_in_managed_windows_wrapper():
+                dedicated_session_id = (
+                    tmux_server.ensure_detached_launcher_session(
+                        dedicated_target,
+                        launch_prefix,
+                        raw_args,
+                        env=client_env,
+                    )
+                )
+        cmd = tmux_server.launcher_argv(launch_prefix, raw_args)
         return _run_tmux_client_with_watchdog(
             cmd,
-            tmux_server.exec_environment(),
+            client_env,
             expected_target=dedicated_target,
             expected_session_id=dedicated_session_id,
         )

{railmux-0.4.0.dev17 → railmux-0.4.0.dev19}/src/railmux/tmux_server.py

@@ -645,3 +645,87 @@ def launcher_argv(
         "--inside-tmux",
         *forwarded_args,
     )
+
+
+_MANAGED_WINDOWS_SESSION_ENV = (
+    "RAILMUX_WINDOWS_RUNTIME",
+    "RAILMUX_MSYS2_RUNTIME_ID",
+    "RAILMUX_MSYS2_APP_ID",
+)
+_MANAGED_WINDOWS_SESSION_VALUE_RE = re.compile(
+    r"[A-Za-z0-9_.-]{1,128}\Z"
+)
+
+
+def _managed_windows_session_environment_args(
+    env: Mapping[str, str] | None,
+) -> list[str]:
+    """Return bounded, non-secret tmux ``new-session -e`` arguments.
+
+    A detached outer session can be created by an existing dedicated server
+    whose inherited environment belongs to an older Railmux app layer. Pass
+    only the three independently verified managed-runtime identity hints to
+    the new pane; provider credentials and the rest of the caller environment
+    must remain outside tmux metadata.
+    """
+    if env is None or env.get("RAILMUX_WINDOWS_RUNTIME") != "msys2":
+        return []
+    result: list[str] = []
+    for name in _MANAGED_WINDOWS_SESSION_ENV:
+        value = env.get(name)
+        if (not isinstance(value, str)
+                or _MANAGED_WINDOWS_SESSION_VALUE_RE.fullmatch(value) is None):
+            continue
+        result.extend(["-e", f"{name}={value}"])
+    return result
+
+
+def ensure_detached_launcher_session(
+    target: TmuxServerTarget,
+    launch_prefix: Sequence[str],
+    forwarded_args: Sequence[str],
+    *,
+    env: Mapping[str, str] | None = None,
+    timeout: float = 5.0,
+) -> str | None:
+    """Create the outer UI detached on one already-proven server.
+
+    Managed Windows uses this only when a proven existing server has no outer
+    UI, commonly because Soft Quit left provider sessions alive in another
+    Terminal Services session.  A new tmux client can then reject
+    ``new-session -A`` before the outer session exists, so the server-origin
+    terminal bridge has no immutable session to attach.
+
+    An exact pre/post server-PID check fences the mutation.  A concurrent
+    launcher may win the create race; resolving one exact resulting session is
+    success regardless of this client's ``new-session`` return code.
+    """
+    existing = target_session_id(target, "railmux", timeout=0.5)
+    if existing is not None:
+        return existing
+    if not launch_prefix or not target_is_live(target, timeout=1.0, env=env):
+        return None
+    try:
+        subprocess.run(
+            target_argv(
+                target,
+                "new-session",
+                "-d",
+                "-s",
+                "railmux",
+                *_managed_windows_session_environment_args(env),
+                *launch_prefix,
+                "--inside-tmux",
+                *forwarded_args,
+            ),
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            timeout=timeout,
+            check=False,
+            env=None if env is None else dict(env),
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    if not target_is_live(target, timeout=1.0, env=env):
+        return None
+    return target_session_id(target, "railmux", timeout=1.0)

{railmux-0.4.0.dev17 → railmux-0.4.0.dev19}/src/railmux/ui/app.py

@@ -902,6 +902,7 @@ class App:
         self._projected_target_pane_id: str | None = None
         self._target_toggle_warning_shown = False
         self._status_navigation_warning_shown = False
+        self._status_navigation_projected = False
         self._teardown_core_done: bool = False
         self._outer_teardown_done: bool = False
         self._exit_in_progress: bool = False
@@ -2523,11 +2524,7 @@ class App:
                     "warn",
                 )
             if manager.status_navigation_available:
-                # The initial bar is painted before the shared binding lease is
-                # acquired. Repaint once ownership is known so its wide
-                # Mode/Layout ranges (and compact page ranges) are immediately
-                # live rather than waiting for the next unrelated transition.
-                self._apply_tmux_bar(self._tmux_error_bar)
+                self._project_status_navigation()
             elif (running_in_windows_wrapper()
                   and not self._status_navigation_warning_shown):
                 self._status_navigation_warning_shown = True
@@ -2538,6 +2535,35 @@ class App:
                 )
             self._sync_termux_tap_route()
 
+    def _project_status_navigation(self) -> None:
+        """Publish clickable ranges after both lease and status bar exist.
+
+        The Windows worker can finish before ``run`` enables the session-local
+        bar. Its immediate projection is then intentionally a no-op, so the
+        periodic caller retries until the first live bar has received both its
+        left navigation and unchanged right-side Copy range.
+        """
+        if getattr(self, "_status_navigation_projected", False):
+            return
+        manager = getattr(self, "_tmux_binding_manager", None)
+        if (not getattr(self, "_tmux_status_enabled", False)
+                or getattr(manager, "status_navigation_available", False)
+                is not True):
+            return
+        # The initial bar is painted before the shared binding lease is
+        # acquired. Invalidate its cache so the same visible labels are still
+        # rewritten with the newly available range metadata.
+        self._applied_tmux_bar_state = None
+        self._apply_tmux_bar(self._tmux_error_bar)
+        status_text = getattr(self, "_rendered_status_text", "")
+        if status_text:
+            self._render_status_to_tmux(
+                status_text,
+                getattr(self, "_rendered_status_level", "info"),
+                remember=False,
+            )
+        self._status_navigation_projected = True
+
     def _start_windows_tmux_setup(self) -> None:
         """Prepare expensive shared tmux leases without delaying first paint."""
         if not running_in_windows_wrapper():
@@ -11154,6 +11180,7 @@ class App:
 
     def _on_tick(self, loop, _user_data) -> None:
         self._refresh()
+        self._project_status_navigation()
         if self._pending_restore_state is not None:
             # A portable Codex preview may have been waiting for the first
             # immutable history generation even when no live recovery

{railmux-0.4.0.dev17 → railmux-0.4.0.dev19/src/railmux.egg-info}/PKG-INFO

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

@@ -1,4 +1,5 @@
 import os
+import subprocess
 from unittest.mock import MagicMock, patch
 
 import pytest
@@ -472,6 +473,73 @@ def test_prelaunch_recovery_is_scoped_to_the_dedicated_server(monkeypatch):
     assert os.environ["TMUX_PANE"] == "%9"
 
 
+def test_managed_windows_precreates_missing_outer_session_for_bridge(
+    monkeypatch,
+):
+    target = TmuxServerTarget("/tmp/tmux-private/railmux", 789)
+    monkeypatch.setattr(
+        "railmux.cli.tmux_server.discover_target", lambda: target)
+    monkeypatch.setattr(
+        "railmux.cli.tmux_server.is_current_server", lambda _target: False)
+    monkeypatch.setattr(
+        "railmux.cli.tmux_server.target_session_id", lambda *_a, **_kw: None)
+    monkeypatch.setattr("railmux.cli.sys.argv", ["/opt/railmux/bin/railmux"])
+    monkeypatch.setattr(
+        "railmux.provider_paths.running_in_managed_windows_wrapper",
+        lambda: True,
+    )
+    prepared = MagicMock(return_value="$9")
+    monkeypatch.setattr(
+        "railmux.cli.tmux_server.ensure_detached_launcher_session", prepared)
+    run_client = MagicMock(return_value=0)
+    monkeypatch.setattr(
+        "railmux.cli._run_tmux_client_with_watchdog", run_client)
+
+    assert main(["--project", "/work"]) == 0
+
+    client_env = tmux_server.exec_environment()
+    prepared.assert_called_once_with(
+        target,
+        ["/opt/railmux/bin/railmux"],
+        ["--project", "/work"],
+        env=client_env,
+    )
+    assert run_client.call_args.kwargs == {
+        "expected_target": target,
+        "expected_session_id": "$9",
+    }
+
+
+def test_posix_missing_outer_session_keeps_ordinary_new_session_path(
+    monkeypatch,
+):
+    target = TmuxServerTarget("/tmp/tmux-private/railmux", 789)
+    monkeypatch.setattr(
+        "railmux.cli.tmux_server.discover_target", lambda: target)
+    monkeypatch.setattr(
+        "railmux.cli.tmux_server.is_current_server", lambda _target: False)
+    monkeypatch.setattr(
+        "railmux.cli.tmux_server.target_session_id", lambda *_a, **_kw: None)
+    monkeypatch.setattr(
+        "railmux.provider_paths.running_in_managed_windows_wrapper",
+        lambda: False,
+    )
+    prepared = MagicMock()
+    monkeypatch.setattr(
+        "railmux.cli.tmux_server.ensure_detached_launcher_session", prepared)
+    run_client = MagicMock(return_value=0)
+    monkeypatch.setattr(
+        "railmux.cli._run_tmux_client_with_watchdog", run_client)
+
+    assert main([]) == 0
+
+    prepared.assert_not_called()
+    assert run_client.call_args.kwargs == {
+        "expected_target": target,
+        "expected_session_id": None,
+    }
+
+
 def test_local_tmux_watchdog_exits_and_records_after_consecutive_failures(
     monkeypatch, capsys,
 ):
@@ -641,8 +709,8 @@ def test_managed_windows_fast_attach_rejection_uses_one_terminal_bridge(
             self.closed = True
 
     relay = SuccessfulRelay()
-    monkeypatch.setattr(
-        "railmux.cli.subprocess.Popen", lambda *_args, **_kwargs: ExitedClient())
+    popen = MagicMock(return_value=ExitedClient())
+    monkeypatch.setattr("railmux.cli.subprocess.Popen", popen)
     monkeypatch.setattr("railmux.cli.sys.stdin.isatty", lambda: True)
     monkeypatch.setattr("railmux.cli.sys.stdout.isatty", lambda: True)
     monkeypatch.setattr("railmux.cli.sys.stdin.fileno", lambda: 10)
@@ -682,11 +750,55 @@ def test_managed_windows_fast_attach_rejection_uses_one_terminal_bridge(
     assert relay.closed
     recover.assert_called_once_with()
     record.assert_not_called()
+    assert popen.call_args.kwargs["stderr"] is subprocess.DEVNULL
     stderr = capsys.readouterr().err
     assert "Windows terminal bridge" in stderr
+    assert "direct tmux attach was unavailable" not in stderr
+    assert "open terminal failed" not in stderr
     assert "cleaned an abandoned" not in stderr
 
 
+def test_managed_windows_attach_without_bridge_is_actionable(
+    monkeypatch, capsys,
+):
+    target = TmuxServerTarget("/tmp/railmux", 77)
+
+    class ExitedClient:
+        returncode = 1
+
+        def poll(self):
+            return self.returncode
+
+    popen = MagicMock(return_value=ExitedClient())
+    monkeypatch.setattr("railmux.cli.subprocess.Popen", popen)
+    monkeypatch.setattr("railmux.cli.sys.stdin.isatty", lambda: False)
+    monkeypatch.setattr(
+        "railmux.cli.tmux_server.discover_target", lambda **_kw: target)
+    monkeypatch.setattr(
+        "railmux.provider_paths.running_in_managed_windows_wrapper",
+        lambda: True,
+    )
+    record = MagicMock(return_value=True)
+    monkeypatch.setattr("railmux.cli.tmux_health.record_incident", record)
+
+    assert _run_tmux_client_with_watchdog(
+        ["tmux", "-L", "railmux"],
+        {"RAILMUX_WINDOWS_RUNTIME": "msys2"},
+        expected_target=target,
+        expected_session_id="$7",
+    ) == 1
+
+    assert popen.call_args.kwargs["stderr"] is subprocess.DEVNULL
+    record.assert_called_once_with(
+        component="launcher",
+        reason="launcher-attach-rejected",
+        consecutive_failures=1,
+    )
+    stderr = capsys.readouterr().err
+    assert "bridge was unavailable" in stderr
+    assert "run 'railmux doctor'" in stderr
+
+
 def test_invalid_config_is_actionable_without_traceback(
     monkeypatch, tmp_path, capsys,
 ):

{railmux-0.4.0.dev17 → railmux-0.4.0.dev19}/tests/test_fullscreen_binding.py

@@ -108,6 +108,67 @@ def test_windows_unavailable_status_clicks_warn_with_keyboard_fallback(
     )
 
 
+def test_finished_status_lease_repaints_left_and_current_copy_range():
+    manager = MagicMock()
+    manager.target_toggle_available = True
+    manager.status_navigation_available = True
+    manager.selection_isolation_available = False
+    app = _bare_app(
+        _tmux_binding_manager=manager,
+        _selection_isolation_manager=None,
+        _tmux_status_enabled=False,
+        _tmux_error_bar=False,
+        _applied_tmux_bar_state=("stale",),
+        _rendered_status_text="Restored session safely",
+        _rendered_status_level="success",
+    )
+    app._apply_tmux_bar = MagicMock()
+    app._render_status_to_tmux = MagicMock()
+    app._sync_target_pane_option = MagicMock()
+    app._sync_termux_tap_route = MagicMock()
+
+    app._finish_tmux_bindings(True)
+
+    app._apply_tmux_bar.assert_not_called()
+    app._render_status_to_tmux.assert_not_called()
+    assert getattr(app, "_status_navigation_projected", False) is False
+
+    # The worker may finish before run() enables its session-local status bar.
+    # The first periodic reconciliation must project the same remembered text.
+    app._tmux_status_enabled = True
+    app._project_status_navigation()
+
+    assert app._applied_tmux_bar_state is None
+    assert app._status_navigation_projected is True
+    app._apply_tmux_bar.assert_called_once_with(False)
+    app._render_status_to_tmux.assert_called_once_with(
+        "Restored session safely", "success", remember=False,
+    )
+
+
+def test_finished_status_lease_does_not_invent_empty_copy_source():
+    manager = MagicMock()
+    manager.target_toggle_available = True
+    manager.status_navigation_available = True
+    manager.selection_isolation_available = False
+    app = _bare_app(
+        _tmux_binding_manager=manager,
+        _selection_isolation_manager=None,
+        _tmux_status_enabled=True,
+        _tmux_error_bar=False,
+        _rendered_status_text="",
+    )
+    app._apply_tmux_bar = MagicMock()
+    app._render_status_to_tmux = MagicMock()
+    app._sync_target_pane_option = MagicMock()
+    app._sync_termux_tap_route = MagicMock()
+
+    app._finish_tmux_bindings(True)
+
+    app._apply_tmux_bar.assert_called_once_with(False)
+    app._render_status_to_tmux.assert_not_called()
+
+
 def test_slow_windows_startup_summary_mentions_read_only_cache():
     import time
 

{railmux-0.4.0.dev17 → railmux-0.4.0.dev19}/tests/test_tmux_server.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import os
 import subprocess
 from types import SimpleNamespace
+from unittest.mock import MagicMock
 
 import pytest
 
@@ -37,6 +38,140 @@ def test_launcher_argv_preserves_multi_argument_python_module_prefix():
     ]
 
 
+def test_detached_launcher_session_is_pinned_before_and_after_create(
+    monkeypatch,
+):
+    target = tmux_server.TmuxServerTarget("/tmp/private", 44)
+    live = []
+    session_ids = iter((None, "$7"))
+    # Another launcher can win after our initial absence check. tmux then
+    # rejects this duplicate create, while the exact resulting session is the
+    # safe shared outcome.
+    run = SimpleNamespace(returncode=1)
+    launched = []
+
+    def target_is_live(candidate, **kwargs):
+        live.append((candidate, kwargs))
+        return True
+
+    monkeypatch.setattr(tmux_server, "target_is_live", target_is_live)
+    monkeypatch.setattr(
+        tmux_server,
+        "target_session_id",
+        lambda *_args, **_kwargs: next(session_ids),
+    )
+    monkeypatch.setattr(
+        subprocess,
+        "run",
+        lambda argv, **kwargs: launched.append((argv, kwargs)) or run,
+    )
+
+    assert tmux_server.ensure_detached_launcher_session(
+        target,
+        ["/opt/railmux/bin/python", "-m", "railmux"],
+        ["--mode", "codex"],
+        env={"PATH": "/usr/bin"},
+    ) == "$7"
+
+    assert len(live) == 2
+    assert launched[0][0] == [
+        "tmux", "-S", "/tmp/private",
+        "new-session", "-d", "-s", "railmux",
+        "/opt/railmux/bin/python", "-m", "railmux", "--inside-tmux",
+        "--mode", "codex",
+    ]
+    assert launched[0][1]["env"] == {"PATH": "/usr/bin"}
+
+
+def test_detached_managed_windows_session_receives_only_runtime_identity(
+    monkeypatch,
+):
+    target = tmux_server.TmuxServerTarget("/tmp/private", 44)
+    session_ids = iter((None, "$7"))
+    launched = []
+    monkeypatch.setattr(tmux_server, "target_is_live", lambda *_a, **_k: True)
+    monkeypatch.setattr(
+        tmux_server,
+        "target_session_id",
+        lambda *_args, **_kwargs: next(session_ids),
+    )
+    monkeypatch.setattr(
+        subprocess,
+        "run",
+        lambda argv, **kwargs: launched.append((argv, kwargs))
+        or SimpleNamespace(returncode=0),
+    )
+    env = {
+        "RAILMUX_WINDOWS_RUNTIME": "msys2",
+        "RAILMUX_MSYS2_RUNTIME_ID": "msys2-2026-03-22",
+        "RAILMUX_MSYS2_APP_ID": "railmux-0.4.0.dev19",
+        "CODEX_API_KEY": "must-not-enter-tmux",
+    }
+
+    assert tmux_server.ensure_detached_launcher_session(
+        target, ["/opt/railmux/bin/railmux"], [], env=env,
+    ) == "$7"
+
+    argv = launched[0][0]
+    assert argv == [
+        "tmux", "-S", "/tmp/private", "new-session", "-d", "-s",
+        "railmux",
+        "-e", "RAILMUX_WINDOWS_RUNTIME=msys2",
+        "-e", "RAILMUX_MSYS2_RUNTIME_ID=msys2-2026-03-22",
+        "-e", "RAILMUX_MSYS2_APP_ID=railmux-0.4.0.dev19",
+        "/opt/railmux/bin/railmux", "--inside-tmux",
+    ]
+    assert all("CODEX_API_KEY" not in value for value in argv)
+
+
+def test_detached_session_rejects_unbounded_runtime_identity(monkeypatch):
+    target = tmux_server.TmuxServerTarget("/tmp/private", 44)
+    session_ids = iter((None, "$7"))
+    launched = []
+    monkeypatch.setattr(tmux_server, "target_is_live", lambda *_a, **_k: True)
+    monkeypatch.setattr(
+        tmux_server,
+        "target_session_id",
+        lambda *_args, **_kwargs: next(session_ids),
+    )
+    monkeypatch.setattr(
+        subprocess,
+        "run",
+        lambda argv, **kwargs: launched.append(argv)
+        or SimpleNamespace(returncode=0),
+    )
+
+    assert tmux_server.ensure_detached_launcher_session(
+        target,
+        ["railmux"],
+        [],
+        env={
+            "RAILMUX_WINDOWS_RUNTIME": "msys2",
+            "RAILMUX_MSYS2_APP_ID": "bad=value",
+        },
+    ) == "$7"
+
+    assert "RAILMUX_WINDOWS_RUNTIME=msys2" in launched[0]
+    assert all("bad=value" not in value for value in launched[0])
+
+
+def test_detached_launcher_session_refuses_changed_server_identity(
+    monkeypatch,
+):
+    target = tmux_server.TmuxServerTarget("/tmp/private", 44)
+    session_id = MagicMock(return_value=None)
+    monkeypatch.setattr(tmux_server, "target_session_id", session_id)
+    monkeypatch.setattr(
+        tmux_server, "target_is_live", MagicMock(side_effect=(True, False)))
+    monkeypatch.setattr(
+        subprocess, "run", MagicMock(return_value=SimpleNamespace(returncode=0)))
+
+    assert tmux_server.ensure_detached_launcher_session(
+        target, ["railmux"], [],
+    ) is None
+    session_id.assert_called_once_with(target, "railmux", timeout=0.5)
+
+
 def test_current_socket_parser_allows_commas_in_the_path():
     env = {"TMUX": "/tmp/with,comma/railmux,123,0"}
     assert tmux_server.current_socket_path(env) == "/tmp/with,comma/railmux"

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

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