railmux 0.4.0.dev30__tar.gz → 0.4.0.dev32__tar.gz

{railmux-0.4.0.dev30/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.dev30
+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.dev30 → railmux-0.4.0.dev32}/src/railmux/cli.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import argparse
 import os
+import signal
 import shutil
 import subprocess
 import sys
@@ -109,6 +110,9 @@ def _run_tmux_client_with_watchdog(
             attributes = termios.tcgetattr(sys.stdin.fileno())
         except (OSError, termios.error):
             pass
+    direct_terminal_size = (
+        _interactive_terminal_size() if managed_windows else None
+    )
     started_at = time.monotonic()
     try:
         popen_kwargs: dict[str, object] = {"env": env}
@@ -127,7 +131,7 @@ def _run_tmux_client_with_watchdog(
         *,
         asynchronous_probe: bool = False,
     ) -> tuple[int, bool]:
-        nonlocal expected_target, expected_session_id
+        nonlocal direct_terminal_size, expected_target, expected_session_id
         watchdog = tmux_health.FailureWatchdog.starting(
             (
                 time.monotonic()
@@ -151,6 +155,28 @@ def _run_tmux_client_with_watchdog(
             pump = getattr(process, "pump", None)
             if pump is None:
                 time.sleep(0.25)
+                if managed_windows:
+                    current_size = _interactive_terminal_size()
+                    if (
+                        current_size is not None
+                        and current_size != direct_terminal_size
+                    ):
+                        direct_terminal_size = current_size
+                        pid = getattr(process, "pid", None)
+                        if (
+                            isinstance(pid, int)
+                            and not isinstance(pid, bool)
+                            and pid > 0
+                        ):
+                            try:
+                                # MSYS2 occasionally misses the native
+                                # console's resize notification. Signal only
+                                # this launcher's direct tmux client so it
+                                # re-reads both dimensions; tmux remains the
+                                # authority for shared-window sizing.
+                                os.kill(pid, signal.SIGWINCH)
+                            except (OSError, ValueError):
+                                pass
             else:
                 pump(0.25)
             now = time.monotonic()

{railmux-0.4.0.dev30 → 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.dev30 → 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.dev30 → 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.
@@ -324,7 +329,13 @@ class InstallReporter:
         if package_count is not None:
             self._package_total = int(package_count.group(1))
             self._package_step = max(1, self._package_total // 10)
-            self._progress_detail = f"preparing {self._package_total} packages"
+            self._progress_detail = (
+                f"waiting for the first transfer among "
+                f"{self._package_total} packages"
+            )
+            self.note(
+                f"Package transaction resolved: {self._package_total} packages."
+            )
             return
         total_download = _TOTAL_DOWNLOAD_RE.match(line)
         if total_download is not None:

{railmux-0.4.0.dev30 → 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.dev30 → railmux-0.4.0.dev32}/src/railmux/windows_pacman.py

@@ -30,7 +30,9 @@ _MIRRORLIST_LIMIT = 256 * 1024
 _PACMAN_CONF_LIMIT = 256 * 1024
 _PROBE_BYTES = 256 * 1024
 _PROBE_TIMEOUT = 8.0
+_PACKAGE_PROBE_BYTES = 256 * 1024
 _PACKAGE_PROBE_TIMEOUT = 5.0
+_PACKAGE_PROBE_MIN_RATE = 128 * 1024
 _SWITCH_RATIO = 1.25
 _FRESHNESS_WINDOW_SECONDS = 6 * 60 * 60
 _ZSTD_MAGIC = b"\x28\xb5\x2f\xfd"
@@ -91,18 +93,21 @@ def _probe_package_url(
     url: str,
     *,
     opener: Callable[..., object] = urllib.request.urlopen,
+    clock: Callable[[], float] = time.monotonic,
 ) -> None:
-    """Require one real package prefix instead of trusting database access."""
+    """Require a responsive real package path, not only database access."""
     if urllib.parse.urlsplit(url).scheme.lower() != "https":
         raise PacmanMirrorError("package URL is not HTTPS")
     request = urllib.request.Request(
         url,
         headers={
             "Accept-Encoding": "identity",
-            "Range": "bytes=0-1023",
+            "Range": f"bytes=0-{_PACKAGE_PROBE_BYTES - 1}",
             "User-Agent": "Railmux-pacman-package-probe/1",
         },
     )
+    started = clock()
+    data = bytearray()
     try:
         with opener(request, timeout=_PACKAGE_PROBE_TIMEOUT) as response:
             final_url = getattr(response, "geturl", lambda: request.full_url)()
@@ -111,15 +116,31 @@ def _probe_package_url(
             status = getattr(response, "status", 200)
             if status not in (200, 206):
                 raise PacmanMirrorError(f"package returned HTTP {status}")
-            data = response.read(1024)
+            while len(data) < _PACKAGE_PROBE_BYTES:
+                chunk = response.read(min(
+                    64 * 1024, _PACKAGE_PROBE_BYTES - len(data)
+                ))
+                if not chunk:
+                    break
+                data.extend(chunk)
+                if clock() - started >= _PACKAGE_PROBE_TIMEOUT:
+                    break
     except PacmanMirrorError:
         raise
     except urllib.error.HTTPError as exc:
         raise PacmanMirrorError(f"package returned HTTP {exc.code}") from exc
     except (OSError, urllib.error.URLError, http.client.HTTPException) as exc:
         raise PacmanMirrorError("package probe failed") from exc
+    elapsed = max(clock() - started, 0.001)
+    if len(data) < 1024:
+        raise PacmanMirrorError("mirror returned too little package data")
     if not data.startswith(_ZSTD_MAGIC):
         raise PacmanMirrorError("mirror did not return an MSYS package")
+    if (
+        elapsed >= _PACKAGE_PROBE_TIMEOUT
+        or len(data) / elapsed < _PACKAGE_PROBE_MIN_RATE
+    ):
+        raise PacmanMirrorError("package transfer was too slow")
 
 
 def probe_pacman_mirror(

{railmux-0.4.0.dev30 → 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.dev30
+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