railmux 0.4.0.dev31__tar.gz → 0.4.0.dev32__tar.gz

{railmux-0.4.0.dev31/src/railmux.egg-info → railmux-0.4.0.dev32}/PKG-INFO

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

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

{railmux-0.4.0.dev31 → railmux-0.4.0.dev32}/src/railmux/ui/app.py

@@ -2035,21 +2035,35 @@ class App:
 
     # --- history preview (display pane shows a transcript, not an agent session) ---
 
+    def _paint_session_row_click_now(self, session_id: str | None) -> None:
+        """Acknowledge a pointer selection before synchronous tmux work."""
+        pane = getattr(self, "_sessions_pane", None)
+        if pane is None:
+            return
+        pane.set_selected_session(session_id)
+        loop = getattr(self, "_loop", None)
+        if loop is not None:
+            loop.draw_screen()
+
     def _on_session_row_preview(self, session: SessionMeta) -> None:
         """Apply click semantics after rechecking whether the row is live."""
-        running = self._by_session_id(session.session_id)
-        if (running is not None
-                and self._agent_session_alive(running.tmux_name)):
-            self._on_running_select(
-                RunningEntry(
-                    tmux_name=running.tmux_name,
-                    label=running.label,
-                    status=running.status,
-                ),
-                steal_focus=False,
-            )
-            return
-        self._on_session_preview(session)
+        self._paint_session_row_click_now(session.session_id)
+        try:
+            running = self._by_session_id(session.session_id)
+            if (running is not None
+                    and self._agent_session_alive(running.tmux_name)):
+                self._on_running_select(
+                    RunningEntry(
+                        tmux_name=running.tmux_name,
+                        label=running.label,
+                        status=running.status,
+                    ),
+                    steal_focus=False,
+                )
+                return
+            self._on_session_preview(session)
+        finally:
+            self._paint_session_row_click_now(None)
 
     def _on_session_preview(self, session: SessionMeta) -> None:
         """Show the provider's canonical current-branch history.

{railmux-0.4.0.dev31 → railmux-0.4.0.dev32}/src/railmux/windows_bootstrap.py

@@ -20,6 +20,7 @@ from railmux.windows_msys2 import (
     plan_managed_runtime_prune,
     reusable_managed_base_candidate,
 )
+from railmux.windows_paths import managed_windows_data_root
 
 
 _MINIMUM_WINDOWS_PYTHON = (3, 10)
@@ -49,6 +50,14 @@ def _runtime_status(
 ) -> int:
     snapshot = managed_runtime_status(
         version=__version__, environ=environ, verify=verify)
+    data_root = (
+        managed_windows_data_root(environ)
+        if runtime is None or runtime.managed
+        else None
+    )
+    if data_root is not None:
+        snapshot["data_root"] = str(data_root)
+        snapshot["log_directory"] = str(data_root / "logs")
     if json_output:
         json.dump(snapshot, sys.stdout, indent=2, sort_keys=True)
         print()
@@ -75,6 +84,9 @@ def _runtime_status(
         if root is not None:
             print(f"Managed location: {root}")
         print("Next: run 'railmux runtime install' from an interactive PowerShell.")
+    if data_root is not None:
+        print(f"Data root: {data_root}")
+        print(f"Install logs: {data_root / 'logs'}")
     print("Provider data: shared from the Windows user profile")
     content = snapshot.get("content_identity")
     if isinstance(content, str):

{railmux-0.4.0.dev31 → railmux-0.4.0.dev32}/src/railmux/windows_install_log.py

@@ -162,7 +162,12 @@ class InstallReporter:
 
     def __enter__(self) -> InstallReporter:
         self.path.parent.mkdir(parents=True, exist_ok=True)
-        self._log = self.path.open("x", encoding="utf-8", newline="\n")
+        # Windows PowerShell 5 treats BOM-less UTF-8 as the active ANSI code
+        # page.  The signature keeps Chinese systems from rendering the
+        # middle dot/ellipsis as mojibake while remaining ordinary UTF-8 for
+        # modern readers (use ``utf-8-sig`` when the exact first character
+        # matters).
+        self._log = self.path.open("x", encoding="utf-8-sig", newline="\n")
         self._write_log("Railmux Windows runtime installation\n")
         # Windows may defer the visible last-write timestamp of an open file.
         # Never let retention mistake the active evidence log for an old one.

{railmux-0.4.0.dev31 → railmux-0.4.0.dev32}/src/railmux/windows_msys2.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 import concurrent.futures
 import hashlib
 import http.client
+import importlib.metadata as importlib_metadata
 import json
 import lzma
 import os
@@ -160,6 +161,22 @@ _PACKAGE_COMMAND = (
     '--cache-dir "$cache" --only-binary=:all: '
     '--timeout "$4" --retries "$5" "railmux[ssh]==$2"'
 )
+_LOCAL_APP_CHECK_COMMAND = (
+    'chmod 755 "$1/venv/bin/railmux" && '
+    '"$1/venv/bin/python" -m pip check && '
+    '"$1/venv/bin/python" -c '
+    "'import packaging, pyte, tomlkit, typing_extensions, urwid, wcwidth, "
+    "railmux, sys; assert railmux.__version__ == sys.argv[1]' \"$2\""
+)
+_LOCAL_APP_COPY_FILE_LIMIT = 20_000
+_LOCAL_APP_COPY_SIZE_LIMIT = 128 * 1024 * 1024
+_DEPENDENCY_SEED_NAMES = frozenset(
+    {"packaging", "pyte", "tomlkit", "typing_extensions.py", "urwid", "wcwidth"}
+)
+_DEPENDENCY_DIST_INFO_RE = re.compile(
+    r"(?:packaging|pyte|tomlkit|typing_extensions|urwid|wcwidth)-.+\.dist-info\Z",
+    re.IGNORECASE,
+)
 
 
 class RuntimeErrorBase(RuntimeError):
@@ -2454,6 +2471,289 @@ def _validate_managed_application_root(root: Path) -> None:
         )
 
 
+def _venv_site_packages(application: Path) -> Path | None:
+    """Return one ordinary MSYS2 venv site-packages directory."""
+    library = application / "venv" / "lib"
+    try:
+        candidates = list(library.glob("python*/site-packages"))
+    except OSError:
+        return None
+    valid: list[Path] = []
+    for candidate in candidates:
+        try:
+            if _path_is_link_or_reparse(candidate) or not candidate.is_dir():
+                continue
+        except OSError:
+            continue
+        valid.append(candidate)
+    return valid[0] if len(valid) == 1 else None
+
+
+def _native_application_payload(version: str) -> tuple[Path, Path] | None:
+    """Locate the currently executing pure-Python package and dist-info."""
+    try:
+        distribution = importlib_metadata.distribution("railmux")
+    except importlib_metadata.PackageNotFoundError:
+        return None
+    if distribution.version != version:
+        return None
+    package = Path(__file__).resolve().parent
+    if not package.is_dir():
+        return None
+    info_names = {
+        Path(str(item)).parts[0]
+        for item in distribution.files or ()
+        if Path(str(item)).parts
+        and Path(str(item)).parts[0].casefold().startswith("railmux-")
+        and Path(str(item)).parts[0].casefold().endswith(".dist-info")
+    }
+    if len(info_names) != 1:
+        return None
+    info = Path(distribution.locate_file(next(iter(info_names))))
+    if not info.is_dir():
+        return None
+    return package, info
+
+
+def _copy_local_tree(
+    source: Path,
+    destination: Path,
+    *,
+    budget: list[int],
+    ignored_names: frozenset[str] = frozenset(),
+) -> None:
+    """Copy one bounded tree without following links or reparse points."""
+    try:
+        if _path_is_link_or_reparse(source) or not source.is_dir():
+            raise RuntimeInstallError("a local application seed tree was unsafe")
+    except OSError as exc:
+        raise RuntimeInstallError(
+            "a local application seed tree could not be inspected"
+        ) from exc
+    destination.mkdir()
+    for current_text, directories, files in os.walk(source, followlinks=False):
+        current = Path(current_text)
+        relative = current.relative_to(source)
+        target_root = destination / relative
+        kept_directories: list[str] = []
+        for name in directories:
+            if name in ignored_names or name == "__pycache__":
+                continue
+            child = current / name
+            try:
+                if _path_is_link_or_reparse(child) or not child.is_dir():
+                    raise RuntimeInstallError(
+                        "a local application seed contained an unsafe directory"
+                    )
+            except OSError as exc:
+                raise RuntimeInstallError(
+                    "a local application seed could not be inspected"
+                ) from exc
+            kept_directories.append(name)
+            (target_root / name).mkdir()
+        directories[:] = kept_directories
+        for name in files:
+            if (
+                name in ignored_names
+                or name.endswith((".pyc", ".pyo"))
+                or name.endswith((".pth", ".egg-link"))
+            ):
+                continue
+            child = current / name
+            try:
+                info = child.lstat()
+                if (
+                    _path_is_link_or_reparse(child)
+                    or not stat.S_ISREG(info.st_mode)
+                ):
+                    raise RuntimeInstallError(
+                        "a local application seed contained an unsafe file"
+                    )
+            except OSError as exc:
+                raise RuntimeInstallError(
+                    "a local application seed could not be inspected"
+                ) from exc
+            budget[0] += 1
+            budget[1] += info.st_size
+            if (
+                budget[0] > _LOCAL_APP_COPY_FILE_LIMIT
+                or budget[1] > _LOCAL_APP_COPY_SIZE_LIMIT
+            ):
+                raise RuntimeInstallError(
+                    "the local application seed exceeded its safety bound"
+                )
+            # Do not carry an NTFS read-only attribute from a packaged-Python
+            # cache or an older app layer into the new writable venv.
+            shutil.copyfile(child, target_root / name)
+
+
+def _copy_local_file(source: Path, destination: Path, *, budget: list[int]) -> None:
+    try:
+        info = source.lstat()
+        if _path_is_link_or_reparse(source) or not stat.S_ISREG(info.st_mode):
+            raise RuntimeInstallError("a local dependency seed file was unsafe")
+    except OSError as exc:
+        raise RuntimeInstallError(
+            "a local dependency seed file could not be inspected"
+        ) from exc
+    budget[0] += 1
+    budget[1] += info.st_size
+    if (
+        budget[0] > _LOCAL_APP_COPY_FILE_LIMIT
+        or budget[1] > _LOCAL_APP_COPY_SIZE_LIMIT
+    ):
+        raise RuntimeInstallError("the local application seed exceeded its safety bound")
+    shutil.copyfile(source, destination)
+
+
+def _dependency_seed_entries(site_packages: Path) -> list[Path] | None:
+    try:
+        entries = list(site_packages.iterdir())
+    except OSError:
+        return None
+    selected = [
+        entry
+        for entry in entries
+        if entry.name in _DEPENDENCY_SEED_NAMES
+        or _DEPENDENCY_DIST_INFO_RE.fullmatch(entry.name)
+    ]
+    names = {entry.name for entry in selected}
+    if not _DEPENDENCY_SEED_NAMES.issubset(names):
+        return None
+    for dependency in _DEPENDENCY_SEED_NAMES - {"typing_extensions.py"}:
+        if not any(
+            name.casefold().startswith(f"{dependency.casefold()}-")
+            and name.casefold().endswith(".dist-info")
+            for name in names
+        ):
+            return None
+    if not any(
+        name.casefold().startswith("typing_extensions-")
+        and name.casefold().endswith(".dist-info")
+        for name in names
+    ):
+        return None
+    return selected
+
+
+def _verified_dependency_seed(
+    root: Path,
+    *,
+    version: str,
+    environ: Mapping[str, str],
+    probe: Probe,
+) -> tuple[str, Path] | None:
+    marked = _marked_app_versions(root)
+    if not marked:
+        return None
+    for candidate_version in sorted(marked, key=_version_key, reverse=True):
+        if candidate_version == version:
+            continue
+        app_name = _app_name(candidate_version)
+        candidate = Msys2Runtime(root, managed=False, app_name=app_name)
+        if not probe_runtime(
+            candidate,
+            version=candidate_version,
+            environ=environ,
+            probe=probe,
+        ):
+            continue
+        site_packages = _venv_site_packages(marked[candidate_version])
+        if (
+            site_packages is not None
+            and _dependency_seed_entries(site_packages) is not None
+        ):
+            return candidate_version, site_packages
+    return None
+
+
+def _install_application_from_local_seed(
+    root: Path,
+    *,
+    final_app: Path,
+    final_posix: str,
+    version: str,
+    environ: Mapping[str, str],
+    reporter: InstallReporter,
+    runner: Runner | None,
+    probe: Probe,
+) -> str:
+    """Build an upgrade layer locally; return ready, unavailable, or failed."""
+    payload = _native_application_payload(version)
+    seed = _verified_dependency_seed(
+        root, version=version, environ=environ, probe=probe)
+    target_site = _venv_site_packages(final_app)
+    if payload is None or seed is None or target_site is None:
+        return "unavailable"
+    source_package, source_info = payload
+    seed_version, seed_site = seed
+    seed_entries = _dependency_seed_entries(seed_site)
+    if seed_entries is None:
+        return "unavailable"
+    budget = [0, 0]
+    try:
+        for source in seed_entries:
+            destination = target_site / source.name
+            if destination.exists() or destination.is_symlink():
+                raise RuntimeInstallError(
+                    "the new application environment unexpectedly contained "
+                    f"{source.name}"
+                )
+            if source.is_dir():
+                _copy_local_tree(source, destination, budget=budget)
+            else:
+                _copy_local_file(source, destination, budget=budget)
+        _copy_local_tree(
+            source_package,
+            target_site / "railmux",
+            budget=budget,
+        )
+        _copy_local_tree(
+            source_info,
+            target_site / source_info.name,
+            budget=budget,
+            ignored_names=frozenset(
+                {"RECORD", "direct_url.json", "INSTALLER", "REQUESTED"}
+            ),
+        )
+        entrypoint = final_app / "venv" / "bin" / "railmux"
+        with entrypoint.open("x", encoding="utf-8", newline="\n") as stream:
+            stream.write(
+                f"#!{final_posix}/venv/bin/python\n"
+                "from railmux.entrypoint import main\n"
+                "raise SystemExit(main())\n"
+            )
+    except (OSError, shutil.Error, RuntimeInstallError) as exc:
+        reporter.note(
+            "Verified local app-layer reuse was unavailable "
+            f"({exc}); falling back to the private PyPI cache.",
+            level="warning",
+        )
+        return "failed"
+    returncode = _run_checked(
+        _bash_command(root, _LOCAL_APP_CHECK_COMMAND, final_posix, version),
+        env=Msys2Runtime(root, managed=False).environment(environ),
+        reporter=reporter,
+        runner=runner,
+        label="Local Railmux application validation",
+        allow_failure=True,
+    )
+    if returncode:
+        reporter.note(
+            "The locally reused dependency layer did not satisfy the current "
+            "package contract; falling back to the private PyPI cache.",
+            level="warning",
+        )
+        return "failed"
+    reporter.note(
+        f"Reused verified dependencies from Railmux {seed_version}; installed "
+        f"Railmux {version} from the current Windows package without network "
+        "access.",
+        level="success",
+    )
+    return "ready"
+
+
 def _install_application(
     root: Path,
     *,
@@ -2534,21 +2834,48 @@ def _install_application(
         runner=runner,
         label="Railmux virtual environment creation",
     )
-    package_arguments = (
-        final_posix,
-        version,
-        str(cache),
-        str(_PIP_INITIAL_TIMEOUT_SECONDS),
-        str(_PIP_INITIAL_RETRIES),
-    )
-    package_returncode = _run_checked(
-        _bash_command(root, _PACKAGE_COMMAND, *package_arguments),
-        env=child_env,
+    local_install = _install_application_from_local_seed(
+        root,
+        final_app=final_app,
+        final_posix=final_posix,
+        version=version,
+        environ=environ,
         reporter=reporter,
         runner=runner,
-        label="Railmux runtime package installation",
-        allow_failure=True,
+        probe=probe,
     )
+    if local_install == "failed":
+        try:
+            shutil.rmtree(final_app / "venv")
+        except OSError as exc:
+            raise RuntimeInstallError(
+                "could not reset the unpublished local application seed"
+            ) from exc
+        _run_checked(
+            _bash_command(root, _VENV_COMMAND, final_posix),
+            env=child_env,
+            reporter=reporter,
+            runner=runner,
+            label="Railmux virtual environment recovery",
+        )
+    if local_install == "ready":
+        package_returncode = 0
+    else:
+        package_arguments = (
+            final_posix,
+            version,
+            str(cache),
+            str(_PIP_INITIAL_TIMEOUT_SECONDS),
+            str(_PIP_INITIAL_RETRIES),
+        )
+        package_returncode = _run_checked(
+            _bash_command(root, _PACKAGE_COMMAND, *package_arguments),
+            env=child_env,
+            reporter=reporter,
+            runner=runner,
+            label="Railmux runtime package installation",
+            allow_failure=True,
+        )
     if package_returncode:
         network_failure = (
             reporter.command_had_network_failure

{railmux-0.4.0.dev31 → railmux-0.4.0.dev32/src/railmux.egg-info}/PKG-INFO

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

@@ -1256,6 +1256,7 @@ def test_preview_reports_info_status():
     app._show_transcript = MagicMock(return_value=True)
     app._set_active_target = MagicMock()
     app._set_status = MagicMock()
+    app._sessions_pane = MagicMock()
 
     session = MagicMock()
     session.display_title = "old chat"
@@ -1267,6 +1268,7 @@ def test_preview_reports_info_status():
     assert app._in_history_mode is True
     msg = app._set_status.call_args.args[0]
     assert "Previewing" in msg and "old chat" in msg
+    app._sessions_pane.set_selected_session.assert_not_called()
 
 
 def test_preview_targets_explicit_active_secondary_slot():

{railmux-0.4.0.dev31 → railmux-0.4.0.dev32}/tests/test_sessions_pane.py

@@ -2,6 +2,7 @@
 
 import time
 from pathlib import Path
+from unittest.mock import MagicMock
 
 import pytest
 import urwid
@@ -273,6 +274,38 @@ def test_stale_running_registry_does_not_hide_stopped_preview(monkeypatch):
     assert previewed == [True]
 
 
+def test_session_row_click_paints_before_synchronous_preview(monkeypatch):
+    """Windows tmux work must not postpone the pointer acknowledgement."""
+    from railmux.ui.app import App
+
+    project = _project()
+    session = _session(project)
+    app = App.__new__(App)
+    events = []
+    app._sessions_pane = MagicMock()
+    app._sessions_pane.set_selected_session.side_effect = (
+        lambda value: events.append(("selected", value))
+    )
+    app._loop = MagicMock()
+    app._loop.draw_screen.side_effect = lambda: events.append(("draw", None))
+    monkeypatch.setattr(app, "_by_session_id", lambda _session_id: None)
+    monkeypatch.setattr(
+        app,
+        "_on_session_preview",
+        lambda _session: events.append(("preview", _session.session_id)),
+    )
+
+    app._on_session_row_preview(session)
+
+    assert events == [
+        ("selected", session.session_id),
+        ("draw", None),
+        ("preview", session.session_id),
+        ("selected", None),
+        ("draw", None),
+    ]
+
+
 def test_agent_session_liveness_uses_displayed_swap_pane(monkeypatch):
     """A swap placeholder session must not mask death of the real pane."""
     from types import SimpleNamespace

{railmux-0.4.0.dev31 → railmux-0.4.0.dev32}/tests/test_windows_bootstrap.py

@@ -72,9 +72,10 @@ def test_noninteractive_missing_runtime_is_actionable_and_never_installs(capsys)
 
 
 def test_runtime_status_reports_missing_without_installing(capsys):
+    environ = {"LOCALAPPDATA": r"C:\Users\u\AppData\Local"}
     result = main(
         ["runtime", "status"],
-        environ={"LOCALAPPDATA": r"C:\Users\u\AppData\Local"},
+        environ=environ,
         runtime_finder=lambda **_kwargs: None,
         version_info=(3, 10),
     )
@@ -83,6 +84,34 @@ def test_runtime_status_reports_missing_without_installing(capsys):
     output = capsys.readouterr().out
     assert "Status: not installed" in output
     assert "Provider data: shared" in output
+    data_root = windows_bootstrap.managed_windows_data_root(environ)
+    assert f"Data root: {data_root}" in output
+    assert f"Install logs: {data_root / 'logs'}" in output
+
+
+def test_runtime_status_json_exposes_the_actual_packaged_python_log_root(
+    capsys, tmp_path, monkeypatch
+):
+    data_root = tmp_path / ".railmux" / "windows"
+    monkeypatch.setattr(
+        windows_bootstrap,
+        "managed_windows_data_root",
+        lambda _environ: data_root,
+    )
+
+    assert main(
+        ["runtime", "status", "--json"],
+        environ={
+            "LOCALAPPDATA": str(tmp_path / "AppData" / "Local"),
+            "USERPROFILE": str(tmp_path),
+        },
+        runtime_finder=lambda **_kwargs: None,
+        version_info=(3, 10),
+    ) == 1
+
+    snapshot = json.loads(capsys.readouterr().out)
+    assert snapshot["data_root"] == str(data_root)
+    assert snapshot["log_directory"] == str(data_root / "logs")
 
 
 def test_runtime_status_labels_user_owned_override(capsys, tmp_path):

{railmux-0.4.0.dev31 → railmux-0.4.0.dev32}/tests/test_windows_install_log.py

@@ -64,6 +64,18 @@ def test_verbose_reporter_streams_the_same_sanitized_output(tmp_path):
     assert "package 中文\nprogress\n" in path.read_text(encoding="utf-8")
 
 
+def test_install_log_has_utf8_signature_for_windows_powershell(tmp_path):
+    path = tmp_path / "install-0.4.0.dev32-20260806T000000Z-2.log"
+
+    with InstallReporter(path, verbose=False, stream=io.StringIO()) as reporter:
+        reporter.done("共享基础 · 正常")
+
+    assert path.read_bytes().startswith(b"\xef\xbb\xbf")
+    rendered = path.read_text(encoding="utf-8-sig")
+    assert rendered.startswith("Railmux Windows runtime installation")
+    assert "共享基础 · 正常" in rendered
+
+
 def test_reporter_recognizes_only_the_explicit_msys2_core_restart(tmp_path):
     path = tmp_path / "install.log"
     with InstallReporter(path, verbose=False, stream=io.StringIO()) as reporter: