railmux 0.4.0.dev28__tar.gz → 0.4.0.dev30__tar.gz

{railmux-0.4.0.dev28/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.dev28
+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.dev28 → 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
@@ -60,6 +61,7 @@ _MSYS2_RESTART_MARKER = (
     "to complete this update all msys2 processes including this terminal "
     "will be closed"
 )
+_ANSI_ESCAPE_RE = re.compile(r"\x1b\[[0-?]*[ -/]*[@-~]")
 _EXTRACTION_PERCENT_RE = re.compile(r"(?:^|\s)([0-9]{1,3})%\s")
 _PACKAGE_COUNT_RE = re.compile(r"^Packages \(([0-9]+)\)")
 _PACKAGE_DOWNLOAD_RE = re.compile(r"^\s*([^ ]+) downloading\.\.\.\s*$")
@@ -78,20 +80,25 @@ 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"
     )
 
 
-def _prune_install_logs(directory: Path, *, keep: int = _LOG_KEEP_COUNT) -> None:
+def _prune_install_logs(
+    directory: Path,
+    *,
+    keep: int = _LOG_KEEP_COUNT,
+    preserve: Path | None = None,
+) -> None:
     candidates: list[Path] = []
     try:
         entries = list(directory.iterdir())
@@ -107,7 +114,11 @@ def _prune_install_logs(directory: Path, *, keep: int = _LOG_KEEP_COUNT) -> None
         )
     except OSError:
         return
-    for stale in candidates[max(keep, 1) :]:
+    preserved = preserve if preserve in candidates else None
+    others = [candidate for candidate in candidates if candidate != preserved]
+    other_limit = max(keep, 1) - (1 if preserved is not None else 0)
+    stale_candidates = others[max(other_limit, 0) :]
+    for stale in stale_candidates:
         try:
             stale.unlink()
         except OSError:
@@ -147,12 +158,15 @@ class InstallReporter:
         self._pip_network_failure = False
         self._hard_failed_hosts: set[str] = set()
         self._msys2_restart_requested = False
+        self._msys2_restart_lines: deque[str] = deque(maxlen=3)
 
     def __enter__(self) -> InstallReporter:
         self.path.parent.mkdir(parents=True, exist_ok=True)
         self._log = self.path.open("x", encoding="utf-8", newline="\n")
         self._write_log("Railmux Windows runtime installation\n")
-        _prune_install_logs(self.path.parent)
+        # Windows may defer the visible last-write timestamp of an open file.
+        # Never let retention mistake the active evidence log for an old one.
+        _prune_install_logs(self.path.parent, preserve=self.path)
         return self
 
     def __exit__(self, _exc_type, _exc, _traceback) -> None:
@@ -215,6 +229,7 @@ class InstallReporter:
         self._pip_network_failure = False
         self._hard_failed_hosts.clear()
         self._msys2_restart_requested = False
+        self._msys2_restart_lines.clear()
         self._write_log(f"\n--- {label} ---\n")
 
     def command_output(self, output: bytes | str | None) -> None:
@@ -265,7 +280,10 @@ class InstallReporter:
         if line.strip():
             self._tail.append(line)
         lowered = line.lower()
-        if _MSYS2_RESTART_MARKER in lowered:
+        normalized = " ".join(_ANSI_ESCAPE_RE.sub("", lowered).split())
+        if normalized:
+            self._msys2_restart_lines.append(normalized)
+        if _MSYS2_RESTART_MARKER in " ".join(self._msys2_restart_lines):
             self._msys2_restart_requested = True
         if any(marker in lowered for marker in _NETWORK_ERROR_MARKERS):
             self._network_failure = True

{railmux-0.4.0.dev28 → 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
 
 
@@ -120,6 +124,28 @@ _PACKAGE_INVENTORY_COMMAND = "set -o pipefail; pacman -Q | LC_ALL=C sort"
 _PACKAGE_INVENTORY_LIMIT = 1024 * 1024
 _CORE_RUNTIME_PACKAGES = ("tmux", "python", "python-pip")
 _MAX_BASE_UPDATE_PASSES = 3
+_PACMAN_LOG_RELATIVE = Path("var") / "log" / "pacman.log"
+_PACMAN_LOG_MAX_SIZE = 8 * 1024 * 1024
+_PACMAN_LOG_APPEND_LIMIT = 2 * 1024 * 1024
+_PACMAN_LOCAL_DB_ENTRY_LIMIT = 4096
+_PACMAN_LOCAL_DESC_LIMIT = 64 * 1024
+# Keep this aligned with alpm_pkg_is_core_package in the pacman build shipped
+# by the pinned base. Any one of these packages makes MSYS2 close its processes.
+_PACMAN_CORE_PACKAGES = frozenset(
+    {
+        "bash",
+        "filesystem",
+        "mintty",
+        "msys2-runtime",
+        "msys2-runtime-devel",
+        "pacman",
+        "pacman-mirrors",
+    }
+)
+_PACMAN_CORE_CHANGE_RE = re.compile(
+    r"\[ALPM] (?:upgraded|downgraded) ([^ ]+) \(([^ ]+) -> ([^)]+)\)",
+    re.IGNORECASE,
+)
 _PRIVATE_GPG_SHUTDOWN_COMMAND = (
     "gpgconf --homedir /etc/pacman.d/gnupg --kill all"
 )
@@ -200,6 +226,16 @@ ArchiveProbe = Callable[[str, str, int], _ArchiveProbe]
 ArchiveResume = Callable[[str, str, int, int, Callable[[bytes], None]], None]
 
 
+@dataclass(frozen=True)
+class _PacmanLogCheckpoint:
+    existed: bool
+    size: int
+    identity: tuple[int, int] | None
+    tail_offset: int
+    tail_digest: str
+    core_versions: tuple[tuple[str, str], ...]
+
+
 def _format_download_size(size: int) -> str:
     if size >= 1024 * 1024:
         return f"{size / (1024 * 1024):.1f} MiB"
@@ -522,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:
@@ -563,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
@@ -572,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,
@@ -1146,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(
@@ -1638,9 +1689,11 @@ def _run_checked(
 def _explain_windows_status(returncode: int, reporter: InstallReporter) -> None:
     if _NATIVE_WINDOWS and returncode & 0xFFFFFFFF == 0xC0000135:
         reporter.note(
-            "Windows reported STATUS_DLL_NOT_FOUND outside a confirmed MSYS2 "
-            "core-update restart. Check whether security software quarantined "
-            "a file in the private MSYS2 staging tree.",
+            "Windows reported STATUS_DLL_NOT_FOUND, but this pass had neither "
+            "pacman's restart announcement nor a newly completed core "
+            "transaction with a matching package-database version change. "
+            "The temporary base will not be published; a missing or "
+            "quarantined staged DLL remains possible.",
             level="error",
         )
 
@@ -1676,6 +1729,215 @@ def _report_mirror_decision(
         )
 
 
+def _pacman_desc_value(text: str, field: str) -> str | None:
+    lines = text.splitlines()
+    marker = f"%{field}%"
+    for index, line in enumerate(lines[:-1]):
+        if line == marker and lines[index + 1]:
+            return lines[index + 1]
+    return None
+
+
+def _pacman_core_versions(root: Path) -> dict[str, str]:
+    local_db = root / "var" / "lib" / "pacman" / "local"
+    try:
+        if _path_is_link_or_reparse(local_db) or not local_db.is_dir():
+            raise RuntimeInstallError("the private pacman database is unsafe")
+        entries = list(local_db.iterdir())
+    except FileNotFoundError:
+        return {}
+    except OSError as exc:
+        raise RuntimeInstallError("could not inspect the private pacman database") from exc
+    if len(entries) > _PACMAN_LOCAL_DB_ENTRY_LIMIT:
+        raise RuntimeInstallError("the private pacman database is unexpectedly large")
+    versions: dict[str, str] = {}
+    for entry in entries:
+        if not any(
+            entry.name.startswith(prefix)
+            for prefix in (
+                "bash-",
+                "filesystem-",
+                "mintty-",
+                "msys2-runtime-",
+                "pacman-",
+            )
+        ):
+            continue
+        desc = entry / "desc"
+        try:
+            if (
+                _path_is_link_or_reparse(entry)
+                or not entry.is_dir()
+                or _path_is_link_or_reparse(desc)
+                or not desc.is_file()
+                or desc.stat().st_size > _PACMAN_LOCAL_DESC_LIMIT
+            ):
+                raise RuntimeInstallError("the private pacman database is unsafe")
+            text = desc.read_text(encoding="utf-8")
+        except RuntimeInstallError:
+            raise
+        except (OSError, UnicodeError) as exc:
+            raise RuntimeInstallError(
+                "could not read the private pacman database"
+            ) from exc
+        name = _pacman_desc_value(text, "NAME")
+        version = _pacman_desc_value(text, "VERSION")
+        if name is None or version is None or not _is_pacman_core_package(name):
+            continue
+        if name in versions:
+            raise RuntimeInstallError(
+                "the private pacman database contains duplicate core packages"
+            )
+        versions[name] = version
+    return versions
+
+
+def _pacman_log_checkpoint(root: Path) -> _PacmanLogCheckpoint:
+    """Pin the append-only pacman journal before a staged transaction."""
+    path = root / _PACMAN_LOG_RELATIVE
+    try:
+        info = path.lstat()
+    except FileNotFoundError:
+        return _PacmanLogCheckpoint(
+            False,
+            0,
+            None,
+            0,
+            hashlib.sha256().hexdigest(),
+            tuple(sorted(_pacman_core_versions(root).items())),
+        )
+    except OSError as exc:
+        raise RuntimeInstallError("could not inspect the private pacman log") from exc
+    try:
+        unsafe = _path_is_link_or_reparse(path)
+    except OSError as exc:
+        raise RuntimeInstallError("could not inspect the private pacman log") from exc
+    if (
+        unsafe
+        or not stat.S_ISREG(info.st_mode)
+        or info.st_size < 0
+        or info.st_size > _PACMAN_LOG_MAX_SIZE
+    ):
+        raise RuntimeInstallError("the private pacman log is unsafe")
+    tail_offset = max(0, info.st_size - 4096)
+    try:
+        with path.open("rb") as stream:
+            stream.seek(tail_offset)
+            tail = stream.read(info.st_size - tail_offset)
+    except OSError as exc:
+        raise RuntimeInstallError("could not read the private pacman log") from exc
+    return _PacmanLogCheckpoint(
+        True,
+        info.st_size,
+        (info.st_dev, info.st_ino),
+        tail_offset,
+        hashlib.sha256(tail).hexdigest(),
+        tuple(sorted(_pacman_core_versions(root).items())),
+    )
+
+
+def _is_pacman_core_package(name: str) -> bool:
+    return name in _PACMAN_CORE_PACKAGES or name.startswith("msys2-runtime-")
+
+
+def _pacman_log_core_transaction(
+    root: Path, checkpoint: _PacmanLogCheckpoint
+) -> tuple[str, ...]:
+    """Return core packages from one newly completed journal transaction."""
+    path = root / _PACMAN_LOG_RELATIVE
+    try:
+        info = path.lstat()
+        unsafe = _path_is_link_or_reparse(path)
+    except OSError:
+        return ()
+    if (
+        unsafe
+        or not stat.S_ISREG(info.st_mode)
+        or info.st_size < checkpoint.size
+        or info.st_size > _PACMAN_LOG_MAX_SIZE
+        or info.st_size - checkpoint.size > _PACMAN_LOG_APPEND_LIMIT
+    ):
+        return ()
+    if checkpoint.existed and (info.st_dev, info.st_ino) != checkpoint.identity:
+        return ()
+    try:
+        with path.open("rb") as stream:
+            if checkpoint.existed:
+                stream.seek(checkpoint.tail_offset)
+                previous_tail = stream.read(checkpoint.size - checkpoint.tail_offset)
+                if hashlib.sha256(previous_tail).hexdigest() != checkpoint.tail_digest:
+                    return ()
+            stream.seek(checkpoint.size)
+            appended = stream.read(_PACMAN_LOG_APPEND_LIMIT + 1)
+    except OSError:
+        return ()
+    if not appended or len(appended) > _PACMAN_LOG_APPEND_LIMIT:
+        return ()
+
+    core_started = False
+    transaction_started = False
+    changed: dict[str, tuple[str, str]] = {}
+    for line in appended.decode("utf-8", errors="replace").splitlines():
+        lowered = line.lower()
+        if "[pacman] starting core system upgrade" in lowered:
+            core_started = True
+            transaction_started = False
+            changed.clear()
+            continue
+        if not core_started:
+            continue
+        if "[alpm] transaction started" in lowered:
+            transaction_started = True
+            changed.clear()
+            continue
+        if not transaction_started:
+            continue
+        match = _PACMAN_CORE_CHANGE_RE.search(line)
+        if match is not None and _is_pacman_core_package(match.group(1)):
+            changed[match.group(1)] = (match.group(2), match.group(3))
+        if "[alpm] transaction completed" in lowered:
+            if changed:
+                try:
+                    after = _pacman_core_versions(root)
+                except RuntimeInstallError:
+                    return ()
+                before = dict(checkpoint.core_versions)
+                proven = tuple(
+                    sorted(
+                        name
+                        for name, (old_version, new_version) in changed.items()
+                        if before.get(name) == old_version
+                        and after.get(name) == new_version
+                        and old_version != new_version
+                    )
+                )
+                if proven:
+                    return proven
+            transaction_started = False
+    return ()
+
+
+def _restart_evidence(
+    root: Path,
+    checkpoint: _PacmanLogCheckpoint,
+    reporter: InstallReporter,
+    returncode: int,
+) -> bool:
+    if reporter.command_requested_msys2_restart:
+        return True
+    if returncode & 0xFFFFFFFF != 0xC0000135:
+        return False
+    packages = _pacman_log_core_transaction(root, checkpoint)
+    if not packages:
+        return False
+    reporter.note(
+        "The private pacman journal confirms a completed core update "
+        f"({', '.join(packages)}); its final console prompt was not captured.",
+        level="warning",
+    )
+    return True
+
+
 def _refresh_pacman_mirrors(
     root: Path,
     *,
@@ -1705,6 +1967,7 @@ def _run_pacman_with_recovery(
     mirror_optimizer: MirrorOptimizer,
     allow_core_restart: bool = False,
 ) -> bool:
+    checkpoint = _pacman_log_checkpoint(root) if not packages else None
     argv = _bash_command(root, _pacman_command(packages=packages, relaxed=False), str(cache))
     returncode = _run_checked(
         argv,
@@ -1715,9 +1978,23 @@ def _run_pacman_with_recovery(
         progress="pacman",
         allow_failure=True,
     )
-    restart_requested = reporter.command_requested_msys2_restart
+    restart_requested = (
+        _restart_evidence(root, checkpoint, reporter, returncode)
+        if checkpoint is not None
+        else False
+    )
     if returncode == 0:
         return restart_requested
+    if not packages and restart_requested and not allow_core_restart:
+        reporter.note(
+            "MSYS2 requested another core restart on the final permitted "
+            "update pass; the temporary base will not be published.",
+            level="error",
+        )
+        reporter.command_failed(label, returncode)
+        raise RuntimeInstallError(
+            f"{label} exhausted the permitted core-update restarts"
+        )
     if allow_core_restart and not packages and restart_requested:
         reporter.note(
             "MSYS2 replaced core runtime files and closed its own process as "
@@ -1759,6 +2036,7 @@ def _run_pacman_with_recovery(
         _pacman_command(packages=packages, relaxed=True),
         str(cache),
     )
+    retry_checkpoint = _pacman_log_checkpoint(root) if not packages else None
     retry_returncode = _run_checked(
         retry_argv,
         env=env,
@@ -1768,9 +2046,24 @@ def _run_pacman_with_recovery(
         progress="pacman",
         allow_failure=True,
     )
-    restart_requested = reporter.command_requested_msys2_restart
+    restart_requested = (
+        _restart_evidence(root, retry_checkpoint, reporter, retry_returncode)
+        if retry_checkpoint is not None
+        else False
+    )
     if retry_returncode == 0:
         return restart_requested
+    if not packages and restart_requested and not allow_core_restart:
+        reporter.note(
+            "MSYS2 requested another core restart on the final permitted "
+            "update pass; the temporary base will not be published.",
+            level="error",
+        )
+        reporter.command_failed(f"{label} resilient retry", retry_returncode)
+        raise RuntimeInstallError(
+            f"{label} resilient retry exhausted the permitted "
+            "core-update restarts"
+        )
     if allow_core_restart and not packages and restart_requested:
         reporter.note(
             "MSYS2 replaced core runtime files and closed its own process as "
@@ -2355,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
@@ -2475,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.dev28 → 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.dev28
+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.dev28 → 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