railmux 0.4.0.dev29__tar.gz → 0.4.0.dev30__tar.gz

{railmux-0.4.0.dev29/src/railmux.egg-info → railmux-0.4.0.dev30}/PKG-INFO

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

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

{railmux-0.4.0.dev29 → railmux-0.4.0.dev30}/src/railmux/windows_install_log.py

@@ -22,6 +22,7 @@ from railmux.terminal_status import (
     STYLE_WARNING,
     styled,
 )
+from railmux.windows_paths import managed_windows_data_root
 
 
 _LOG_KEEP_COUNT = 5
@@ -79,14 +80,14 @@ def install_log_path(
     *,
     version: str,
     clock: Callable[[], float] = time.time,
+    data_root: Path | None = None,
 ) -> Path:
-    local_app_data = environ.get("LOCALAPPDATA", "").strip()
-    if not local_app_data:
-        raise OSError("LOCALAPPDATA is unavailable")
+    root = managed_windows_data_root(environ) if data_root is None else data_root
+    if root is None:
+        raise OSError("a non-virtualized Windows data directory is unavailable")
     stamp = time.strftime("%Y%m%dT%H%M%SZ", time.gmtime(clock()))
     return (
-        Path(local_app_data)
-        / "Railmux"
+        root
         / "logs"
         / f"install-{version}-{stamp}-{os.getpid()}.log"
     )

{railmux-0.4.0.dev29 → railmux-0.4.0.dev30}/src/railmux/windows_msys2.py

@@ -42,6 +42,10 @@ from railmux.windows_pacman import (
     validate_transaction_package_mirrors,
     write_msys_only_pacman_config,
 )
+from railmux.windows_paths import (
+    legacy_local_app_data_root,
+    managed_windows_data_root,
+)
 from railmux.terminal_status import STYLE_ACCENT, STYLE_MUTED, styled
 
 
@@ -554,17 +558,17 @@ class Msys2Runtime:
 
 
 def _managed_base(environ: Mapping[str, str]) -> Path | None:
-    local_app_data = environ.get("LOCALAPPDATA", "").strip()
-    if not local_app_data:
+    data_root = managed_windows_data_root(environ)
+    if data_root is None:
         return None
-    return Path(local_app_data) / "Railmux" / "runtimes"
+    return data_root / "runtimes"
 
 
 def _managed_cache(environ: Mapping[str, str]) -> Path | None:
-    local_app_data = environ.get("LOCALAPPDATA", "").strip()
-    if not local_app_data:
+    data_root = managed_windows_data_root(environ)
+    if data_root is None:
         return None
-    return Path(local_app_data) / "Railmux" / "cache"
+    return data_root / "cache"
 
 
 def _path_is_link_or_reparse(path: Path) -> bool:
@@ -595,6 +599,7 @@ def _prepare_cached_archive(
     cache: Path,
     *,
     downloader: Downloader | None,
+    prior_caches: Sequence[Path] = (),
 ) -> tuple[Path, str]:
     cache.mkdir(parents=True, exist_ok=True)
     archive = cache / MSYS2_ARCHIVE_NAME
@@ -604,6 +609,18 @@ def _prepare_cached_archive(
         archive.unlink(missing_ok=True)
     except OSError as exc:
         raise RuntimeInstallError("could not replace the private archive cache") from exc
+    for prior_cache in prior_caches:
+        prior_archive = prior_cache / MSYS2_ARCHIVE_NAME
+        if prior_archive == archive or not _archive_cache_is_valid(prior_archive):
+            continue
+        try:
+            shutil.copyfile(prior_archive, archive)
+        except OSError:
+            archive.unlink(missing_ok=True)
+            continue
+        if _archive_cache_is_valid(archive):
+            return archive, "verified prior local cache"
+        archive.unlink(missing_ok=True)
     source = download_from_sources(
         archive,
         MSYS2_ARCHIVE_SHA256,
@@ -1178,7 +1195,9 @@ def apply_managed_runtime_prune(
     """Re-plan under the install lock, then remove only unchanged candidates."""
     base = _managed_base(environ)
     if base is None:
-        raise RuntimeInstallError("LOCALAPPDATA is unavailable")
+        raise RuntimeInstallError(
+            "a non-virtualized Windows user data directory is unavailable"
+        )
     effective_lock = install_lock if lock_factory is None else lock_factory
     with effective_lock(base):
         current = plan_managed_runtime_prune(
@@ -2629,11 +2648,16 @@ def install_managed_runtime(
     base = _managed_base(environ)
     cache_base = _managed_cache(environ)
     if base is None or cache_base is None:
-        raise RuntimeInstallError("LOCALAPPDATA is unavailable")
+        raise RuntimeInstallError(
+            "a non-virtualized Windows user data directory is unavailable"
+        )
+    data_root = base.parent
     try:
         base.mkdir(parents=True, exist_ok=True)
         cache_base.mkdir(parents=True, exist_ok=True)
-        log_path = install_log_path(environ, version=version)
+        log_path = install_log_path(
+            environ, version=version, data_root=data_root
+        )
     except OSError as exc:
         raise RuntimeInstallError("could not create the private runtime log") from exc
     final_root = base / "shared" / MSYS2_RUNTIME_ID
@@ -2749,6 +2773,11 @@ def install_managed_runtime(
                     archive, source = _prepare_cached_archive(
                         cache_base,
                         downloader=downloader,
+                        prior_caches=tuple(
+                            legacy / "cache"
+                            for legacy in (legacy_local_app_data_root(environ),)
+                            if legacy is not None and legacy != data_root
+                        ),
                     )
                     reporter.done(source)
 

railmux-0.4.0.dev30/src/railmux/windows_paths.py

@@ -0,0 +1,73 @@
+"""Stable native-Windows storage paths for the managed runtime.
+
+Microsoft Store and other MSIX-packaged Python interpreters can virtualize new
+writes beneath AppData.  Railmux's runtime contains executables that must be
+opened by child processes outside that virtualized view, so packaged Python
+uses a user-profile directory instead.
+"""
+
+from __future__ import annotations
+
+import ctypes
+import os
+import sys
+from collections.abc import Mapping
+from pathlib import Path
+
+
+_ERROR_INSUFFICIENT_BUFFER = 122
+_APPMODEL_ERROR_NO_PACKAGE = 15700
+_PACKAGED_PROFILE_DIRECTORY = ".railmux"
+_PACKAGED_WINDOWS_DIRECTORY = "windows"
+
+
+def _has_windows_package_identity() -> bool:
+    """Return whether this process has an MSIX/AppX package identity."""
+    if os.name != "nt":
+        return False
+    try:
+        get_family = ctypes.windll.kernel32.GetCurrentPackageFamilyName
+        length = ctypes.c_uint32(0)
+        result = int(get_family(ctypes.byref(length), None))
+    except (AttributeError, OSError, TypeError, ValueError):
+        return _looks_like_packaged_executable(sys.executable)
+    if result == _APPMODEL_ERROR_NO_PACKAGE:
+        return False
+    if result == _ERROR_INSUFFICIENT_BUFFER and length.value > 0:
+        return True
+    # A Store Python launcher and interpreter both have characteristic physical
+    # paths.  Keep this fallback fail-safe if the package API is unavailable or
+    # returns an unexpected platform error.
+    return _looks_like_packaged_executable(sys.executable)
+
+
+def _looks_like_packaged_executable(executable: str) -> bool:
+    normalized = executable.replace("/", "\\").casefold()
+    return "\\windowsapps\\" in normalized or (
+        "\\appdata\\local\\packages\\" in normalized and "\\localcache\\" in normalized
+    )
+
+
+def managed_windows_data_root(environ: Mapping[str, str]) -> Path | None:
+    """Select one data root visible to both Python and MSYS2 child processes."""
+    if _has_windows_package_identity():
+        user_profile = environ.get("USERPROFILE", "").strip()
+        if not user_profile:
+            return None
+        return (
+            Path(user_profile)
+            / _PACKAGED_PROFILE_DIRECTORY
+            / _PACKAGED_WINDOWS_DIRECTORY
+        )
+    local_app_data = environ.get("LOCALAPPDATA", "").strip()
+    if not local_app_data:
+        return None
+    return Path(local_app_data) / "Railmux"
+
+
+def legacy_local_app_data_root(environ: Mapping[str, str]) -> Path | None:
+    """Return the pre-packaged-Python-fix location for read-only cache reuse."""
+    local_app_data = environ.get("LOCALAPPDATA", "").strip()
+    if not local_app_data:
+        return None
+    return Path(local_app_data) / "Railmux"

{railmux-0.4.0.dev29 → railmux-0.4.0.dev30/src/railmux.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.4.0.dev29
+Version: 0.4.0.dev30
 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.dev29 → railmux-0.4.0.dev30}/src/railmux.egg-info/SOURCES.txt

@@ -63,6 +63,7 @@ src/railmux/windows_bootstrap.py
 src/railmux/windows_install_log.py
 src/railmux/windows_msys2.py
 src/railmux/windows_pacman.py
+src/railmux/windows_paths.py
 src/railmux/windows_tmux_lifecycle.py
 src/railmux/windows_ui_transition.py
 src/railmux.egg-info/PKG-INFO
@@ -168,6 +169,7 @@ tests/test_windows_bootstrap.py
 tests/test_windows_install_log.py
 tests/test_windows_msys2.py
 tests/test_windows_pacman.py
+tests/test_windows_paths.py
 tests/test_windows_tmux_lifecycle.py
 tests/test_windows_ui_transition.py
 tests/test_windows_wrapper_contract.py

{railmux-0.4.0.dev29 → railmux-0.4.0.dev30}/tests/test_windows_install_log.py

@@ -223,6 +223,25 @@ def test_log_path_is_private_versioned_and_utc(tmp_path, monkeypatch):
     )
 
 
+def test_log_path_uses_packaged_python_non_virtualized_root(tmp_path, monkeypatch):
+    monkeypatch.setattr(
+        windows_install_log,
+        "managed_windows_data_root",
+        lambda _environ: tmp_path / ".railmux" / "windows",
+    )
+
+    path = install_log_path(
+        {
+            "LOCALAPPDATA": str(tmp_path / "AppData" / "Local"),
+            "USERPROFILE": str(tmp_path),
+        },
+        version="0.4.0.dev30",
+        clock=lambda: 0,
+    )
+
+    assert path.parent == tmp_path / ".railmux" / "windows" / "logs"
+
+
 def test_default_command_runner_uses_no_stdin_and_captures_utf8(tmp_path):
     stream = io.StringIO()
     path = tmp_path / "install-0.4.0.dev7-20260803T000000Z-4.log"

{railmux-0.4.0.dev29 → railmux-0.4.0.dev30}/tests/test_windows_msys2.py

@@ -628,6 +628,22 @@ def test_preview_versions_share_one_base_but_use_separate_app_layers(tmp_path):
     )
 
 
+def test_packaged_python_runtime_root_avoids_local_app_data(tmp_path, monkeypatch):
+    safe = tmp_path / ".railmux" / "windows"
+    monkeypatch.setattr(
+        windows_msys2, "managed_windows_data_root", lambda _environ: safe
+    )
+    environ = {
+        "LOCALAPPDATA": str(tmp_path / "AppData" / "Local"),
+        "USERPROFILE": str(tmp_path),
+    }
+
+    assert managed_root(environ) == (
+        safe / "runtimes" / "shared" / windows_msys2.MSYS2_RUNTIME_ID
+    )
+    assert windows_msys2._managed_cache(environ) == safe / "cache"
+
+
 def test_explicit_user_runtime_is_probed_but_never_requires_managed_marker(tmp_path):
     root = tmp_path / "用户-owned-msys"
     runtime = make_runtime(root, managed=False)
@@ -1268,6 +1284,57 @@ def test_verified_base_archive_cache_avoids_a_second_download(tmp_path, monkeypa
     assert source == "verified local cache"
 
 
+def test_packaged_python_reuses_verified_pre_fix_archive_cache(tmp_path, monkeypatch):
+    payload = b"verified prior cache archive"
+    monkeypatch.setattr(windows_msys2, "MSYS2_ARCHIVE_SIZE", len(payload))
+    monkeypatch.setattr(
+        windows_msys2,
+        "MSYS2_ARCHIVE_SHA256",
+        hashlib.sha256(payload).hexdigest(),
+    )
+    prior = tmp_path / "virtualized-cache"
+    prior.mkdir()
+    (prior / MSYS2_ARCHIVE_NAME).write_bytes(payload)
+    current = tmp_path / "non-virtualized-cache"
+
+    selected, source = windows_msys2._prepare_cached_archive(
+        current,
+        downloader=lambda *_args: pytest.fail("prior cache should avoid downloading"),
+        prior_caches=(prior,),
+    )
+
+    assert selected.read_bytes() == payload
+    assert source == "verified prior local cache"
+
+
+def test_packaged_python_never_reuses_unverified_pre_fix_archive(
+    tmp_path, monkeypatch
+):
+    payload = b"expected archive"
+    monkeypatch.setattr(windows_msys2, "MSYS2_ARCHIVE_SIZE", len(payload))
+    monkeypatch.setattr(
+        windows_msys2,
+        "MSYS2_ARCHIVE_SHA256",
+        hashlib.sha256(payload).hexdigest(),
+    )
+    prior = tmp_path / "virtualized-cache"
+    prior.mkdir()
+    (prior / MSYS2_ARCHIVE_NAME).write_bytes(b"tampered archive")
+    current = tmp_path / "non-virtualized-cache"
+
+    def downloader(_url, destination, _sha256):
+        destination.write_bytes(payload)
+
+    selected, source = windows_msys2._prepare_cached_archive(
+        current,
+        downloader=downloader,
+        prior_caches=(prior,),
+    )
+
+    assert selected.read_bytes() == payload
+    assert source in {label for label, _url in MSYS2_ARCHIVE_SOURCES}
+
+
 def _write_test_tar(path: Path, entries: list[tuple[tarfile.TarInfo, bytes]]) -> None:
     with tarfile.open(path, mode="w:xz") as archive:
         for member, payload in entries:

railmux-0.4.0.dev30/tests/test_windows_paths.py

@@ -0,0 +1,83 @@
+from types import SimpleNamespace
+import ctypes
+
+from railmux import windows_paths
+
+
+def test_unpacked_python_keeps_local_app_data_contract(tmp_path, monkeypatch):
+    monkeypatch.setattr(windows_paths, "_has_windows_package_identity", lambda: False)
+    local = tmp_path / "AppData" / "Local"
+
+    root = windows_paths.managed_windows_data_root(
+        {"LOCALAPPDATA": str(local), "USERPROFILE": str(tmp_path)}
+    )
+
+    assert root == local / "Railmux"
+
+
+def test_packaged_python_avoids_virtualized_app_data(tmp_path, monkeypatch):
+    monkeypatch.setattr(windows_paths, "_has_windows_package_identity", lambda: True)
+    local = tmp_path / "AppData" / "Local"
+
+    root = windows_paths.managed_windows_data_root(
+        {"LOCALAPPDATA": str(local), "USERPROFILE": str(tmp_path)}
+    )
+
+    assert root == tmp_path / ".railmux" / "windows"
+    assert local not in root.parents
+
+
+def test_packaged_python_never_falls_back_to_virtualized_app_data(
+    tmp_path, monkeypatch
+):
+    monkeypatch.setattr(windows_paths, "_has_windows_package_identity", lambda: True)
+
+    assert (
+        windows_paths.managed_windows_data_root({"LOCALAPPDATA": str(tmp_path)}) is None
+    )
+
+
+def test_packaged_executable_path_fallback_is_narrow():
+    assert windows_paths._looks_like_packaged_executable(
+        r"C:\Program Files\WindowsApps\PythonSoftwareFoundation.Python.3.12\python.exe"
+    )
+    assert windows_paths._looks_like_packaged_executable(
+        r"C:\Users\u\AppData\Local\Packages\Python.Package\LocalCache\python.exe"
+    )
+    assert not windows_paths._looks_like_packaged_executable(
+        r"C:\Users\u\AppData\Local\Programs\Python\Python312\python.exe"
+    )
+
+
+def test_windows_package_identity_api_distinguishes_packaged_process(monkeypatch):
+    def get_family(length, _buffer):
+        ctypes.cast(length, ctypes.POINTER(ctypes.c_uint32)).contents.value = 64
+        return 122
+
+    monkeypatch.setattr(windows_paths.os, "name", "nt")
+    monkeypatch.setattr(
+        windows_paths.ctypes,
+        "windll",
+        SimpleNamespace(
+            kernel32=SimpleNamespace(GetCurrentPackageFamilyName=get_family)
+        ),
+        raising=False,
+    )
+
+    assert windows_paths._has_windows_package_identity()
+
+
+def test_windows_package_identity_api_preserves_unpacked_python(monkeypatch):
+    monkeypatch.setattr(windows_paths.os, "name", "nt")
+    monkeypatch.setattr(
+        windows_paths.ctypes,
+        "windll",
+        SimpleNamespace(
+            kernel32=SimpleNamespace(
+                GetCurrentPackageFamilyName=lambda _length, _buffer: 15700
+            )
+        ),
+        raising=False,
+    )
+
+    assert not windows_paths._has_windows_package_identity()

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

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