railmux 0.4.0.dev25__tar.gz → 0.4.0.dev27__tar.gz

{railmux-0.4.0.dev25 → railmux-0.4.0.dev27}/MANIFEST.in

@@ -1,3 +1,4 @@
 include tools/denested_transport_benchmark.py
 include tools/release_notes.py
 include tools/wheel_smoke.py
+include tools/windows_archive_smoke.py

{railmux-0.4.0.dev25/src/railmux.egg-info → railmux-0.4.0.dev27}/PKG-INFO

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

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

{railmux-0.4.0.dev25 → railmux-0.4.0.dev27}/src/railmux/windows_install_log.py

@@ -235,6 +235,24 @@ class InstallReporter:
             self._consume_output_line(self._pending_output)
             self._pending_output = ""
 
+    def extraction_progress(self, completed: int, total: int) -> None:
+        """Report bounded in-process archive extraction progress."""
+        if total <= 0:
+            return
+        completed = min(max(completed, 0), total)
+        percent = min(100, int(completed * 100 / total))
+        self._progress_detail = (
+            f"extracting private runtime: {completed}/{total} files "
+            f"({percent}%)"
+        )
+        if percent >= self._last_extraction_percent + 5 or percent == 100:
+            self.note(
+                f"Extracting private runtime: {completed}/{total} files "
+                f"({percent}%)"
+            )
+            self._last_extraction_percent = percent
+        self.heartbeat()
+
     def _consume_output_line(self, raw_line: str) -> None:
         line = _redact_line(raw_line)
         self._write_log(f"{line}\n")

{railmux-0.4.0.dev25 → railmux-0.4.0.dev27}/src/railmux/windows_msys2.py

@@ -10,6 +10,7 @@ import concurrent.futures
 import hashlib
 import http.client
 import json
+import lzma
 import os
 import re
 import secrets
@@ -17,6 +18,7 @@ import shutil
 import stat
 import subprocess
 import sys
+import tarfile
 import tempfile
 import time
 import urllib.error
@@ -25,7 +27,7 @@ import urllib.request
 from collections.abc import Callable, Iterator, Mapping, Sequence
 from contextlib import contextmanager
 from dataclasses import dataclass
-from pathlib import Path
+from pathlib import Path, PurePosixPath
 
 from railmux.windows_install_log import (
     InstallReporter,
@@ -44,7 +46,7 @@ from railmux.terminal_status import STYLE_ACCENT, STYLE_MUTED, styled
 
 
 MSYS2_RELEASE = "2026-03-22"
-MSYS2_ARCHIVE_NAME = f"msys2-base-x86_64-{MSYS2_RELEASE.replace('-', '')}.sfx.exe"
+MSYS2_ARCHIVE_NAME = f"msys2-base-x86_64-{MSYS2_RELEASE.replace('-', '')}.tar.xz"
 MSYS2_ARCHIVE_SOURCES = (
     (
         "GitHub",
@@ -65,11 +67,20 @@ MSYS2_ARCHIVE_SOURCES = (
         f"https://mirror.nju.edu.cn/msys2/distrib/x86_64/{MSYS2_ARCHIVE_NAME}",
     ),
 )
-MSYS2_ARCHIVE_SIZE = 52_820_994
+MSYS2_ARCHIVE_SIZE = 53_466_096
 MSYS2_ARCHIVE_SHA256 = (
+    "6b4a986a3ec4f1e40313bdf17903a6f5c854373d4230c40f14c5e35c4bac7fce"
+)
+MSYS2_ARCHIVE_MEMBER_COUNT = 16_485
+MSYS2_ARCHIVE_UNPACKED_SIZE = 289_361_533
+# Schema-1 base-content markers released in dev24/dev25 use the SFX digest as
+# their pinned release-lineage token.  Keep accepting and writing that durable
+# value while the bootstrap consumes the equivalent official tar.xz artifact.
+MSYS2_BASE_LINEAGE_SHA256 = (
     "6fe0cc8154132040e034ff4daface2a4163a9d1f6ebaaa1133394bff460bd5cf"
 )
 MSYS2_RUNTIME_ID = f"msys2-{MSYS2_RELEASE}"
+_NATIVE_WINDOWS = os.name == "nt"
 RUNTIME_SCHEMA = 1
 
 _RUNTIME_OVERRIDE = "RAILMUX_MSYS2_ROOT"
@@ -141,7 +152,7 @@ class BaseContentIdentity:
         return {
             "schema": 1,
             "runtime": MSYS2_RUNTIME_ID,
-            "archive_sha256": MSYS2_ARCHIVE_SHA256,
+            "archive_sha256": MSYS2_BASE_LINEAGE_SHA256,
             "content_id": self.content_id,
             "package_count": self.package_count,
             "core_packages": dict(self.core_packages),
@@ -166,6 +177,7 @@ Probe = Callable[..., subprocess.CompletedProcess[bytes]]
 Runner = Callable[..., subprocess.CompletedProcess]
 Downloader = Callable[[str, Path, str], None]
 MirrorOptimizer = Callable[[Path], PacmanMirrorDecision]
+Extractor = Callable[..., None]
 
 
 @dataclass(frozen=True)
@@ -519,9 +531,20 @@ def _managed_cache(environ: Mapping[str, str]) -> Path | None:
     return Path(local_app_data) / "Railmux" / "cache"
 
 
+def _path_is_link_or_reparse(path: Path) -> bool:
+    info = path.lstat()
+    reparse_flag = getattr(stat, "FILE_ATTRIBUTE_REPARSE_POINT", 0x400)
+    return stat.S_ISLNK(info.st_mode) or bool(
+        getattr(info, "st_file_attributes", 0) & reparse_flag
+    )
+
+
 def _archive_cache_is_valid(path: Path) -> bool:
     try:
-        if path.is_symlink() or path.stat().st_size != MSYS2_ARCHIVE_SIZE:
+        if (
+            _path_is_link_or_reparse(path)
+            or path.stat().st_size != MSYS2_ARCHIVE_SIZE
+        ):
             return False
         digest = hashlib.sha256()
         with path.open("rb") as stream:
@@ -553,6 +576,176 @@ def _prepare_cached_archive(
     return archive, source
 
 
+def _safe_archive_parts(member: tarfile.TarInfo) -> tuple[str, ...]:
+    name = member.name
+    raw_parts = name.split("/")
+    pure = PurePosixPath(name)
+    if (
+        not name
+        or "\\" in name
+        or pure.is_absolute()
+        or any(part in {"", ".", ".."} for part in raw_parts)
+        or not raw_parts
+        or raw_parts[0] != "msys64"
+    ):
+        raise RuntimeInstallError(
+            "the verified MSYS2 archive contained an unsafe path"
+        )
+    return tuple(raw_parts)
+
+
+def _ensure_safe_archive_directory(root: Path, parts: Sequence[str]) -> Path:
+    current = root
+    for part in parts:
+        candidate = current / part
+        try:
+            if _path_is_link_or_reparse(candidate) or not candidate.is_dir():
+                raise RuntimeInstallError(
+                    "the MSYS2 extraction staging directory became unsafe"
+                )
+        except FileNotFoundError:
+            try:
+                candidate.mkdir()
+            except OSError as exc:
+                raise RuntimeInstallError(
+                    "could not create the MSYS2 extraction staging directory"
+                ) from exc
+            if _path_is_link_or_reparse(candidate) or not candidate.is_dir():
+                raise RuntimeInstallError(
+                    "the MSYS2 extraction staging directory became unsafe"
+                )
+        except OSError as exc:
+            raise RuntimeInstallError(
+                "could not inspect the MSYS2 extraction staging directory"
+            ) from exc
+        current = candidate
+    return current
+
+
+def _apply_archive_mode(path: Path, mode: int) -> None:
+    if _NATIVE_WINDOWS:
+        # Windows chmod maps a missing owner-write bit to the NTFS read-only
+        # attribute; applying tar's POSIX 0444/0555 modes would prevent pacman
+        # from replacing those files during the first base update.
+        os.chmod(path, stat.S_IWRITE)
+    else:
+        os.chmod(path, mode)
+
+
+def _extract_msys2_archive(
+    archive: Path,
+    destination: Path,
+    *,
+    reporter: InstallReporter,
+) -> None:
+    """Extract the pinned tar.xz without executing downloaded code."""
+    reporter.command_started("MSYS2 archive extraction", progress="extract")
+    seen: set[tuple[str, ...]] = set()
+    directories: list[tuple[Path, int]] = []
+    member_count = 0
+    unpacked_size = 0
+    try:
+        if _path_is_link_or_reparse(destination) or not destination.is_dir():
+            raise RuntimeInstallError(
+                "the MSYS2 extraction staging directory is unsafe"
+            )
+        with tarfile.open(archive, mode="r|xz") as stream:
+            for member in stream:
+                member_count += 1
+                if member_count > MSYS2_ARCHIVE_MEMBER_COUNT:
+                    raise RuntimeInstallError(
+                        "the verified MSYS2 archive member count changed"
+                    )
+                parts = _safe_archive_parts(member)
+                if parts in seen:
+                    raise RuntimeInstallError(
+                        "the verified MSYS2 archive contained a duplicate path"
+                    )
+                seen.add(parts)
+                if not (member.isdir() or member.isreg()):
+                    raise RuntimeInstallError(
+                        "the verified MSYS2 archive contained an unsupported link "
+                        "or special file"
+                    )
+                parent = _ensure_safe_archive_directory(destination, parts[:-1])
+                target = parent / parts[-1]
+                if member.isdir():
+                    directory = _ensure_safe_archive_directory(destination, parts)
+                    directories.append((directory, member.mode & 0o777))
+                else:
+                    if member.size < 0:
+                        raise RuntimeInstallError(
+                            "the verified MSYS2 archive contained an invalid file"
+                        )
+                    unpacked_size += member.size
+                    if unpacked_size > MSYS2_ARCHIVE_UNPACKED_SIZE:
+                        raise RuntimeInstallError(
+                            "the verified MSYS2 archive expanded beyond its "
+                            "pinned size"
+                        )
+                    try:
+                        try:
+                            target.lstat()
+                        except FileNotFoundError:
+                            pass
+                        else:
+                            raise RuntimeInstallError(
+                                "the MSYS2 extraction staging path already exists"
+                            )
+                        source = stream.extractfile(member)
+                        if source is None:
+                            raise RuntimeInstallError(
+                                "the verified MSYS2 archive file was unreadable"
+                            )
+                        remaining = member.size
+                        with target.open("xb") as output:
+                            while remaining:
+                                chunk = source.read(min(1024 * 1024, remaining))
+                                if not chunk:
+                                    raise RuntimeInstallError(
+                                        "the verified MSYS2 archive ended early"
+                                    )
+                                output.write(chunk)
+                                remaining -= len(chunk)
+                        _apply_archive_mode(target, member.mode & 0o777)
+                    except RuntimeInstallError:
+                        raise
+                    except OSError as exc:
+                        raise RuntimeInstallError(
+                            "could not write the MSYS2 extraction staging file"
+                        ) from exc
+                reporter.extraction_progress(
+                    member_count, MSYS2_ARCHIVE_MEMBER_COUNT
+                )
+        if member_count != MSYS2_ARCHIVE_MEMBER_COUNT:
+            raise RuntimeInstallError(
+                "the verified MSYS2 archive member count changed"
+            )
+        if unpacked_size != MSYS2_ARCHIVE_UNPACKED_SIZE:
+            raise RuntimeInstallError(
+                "the verified MSYS2 archive expanded to an unexpected size"
+            )
+        for directory, mode in reversed(directories):
+            _apply_archive_mode(directory, mode)
+    except RuntimeInstallError:
+        reporter.note(
+            "MSYS2 archive extraction failed; the temporary base was not "
+            "published.",
+            level="error",
+        )
+        raise
+    except (OSError, lzma.LZMAError, tarfile.TarError, EOFError) as exc:
+        reporter.note(
+            "MSYS2 archive extraction failed; the temporary base was not "
+            "published.",
+            level="error",
+        )
+        raise RuntimeInstallError(
+            "the verified MSYS2 tar.xz archive could not be extracted"
+        ) from exc
+    reporter.command_succeeded()
+
+
 def managed_root(environ: Mapping[str, str]) -> Path | None:
     base = _managed_base(environ)
     if base is None:
@@ -690,7 +883,7 @@ def _decode_base_content_marker(root: Path) -> BaseContentIdentity | None:
     if (
         payload.get("schema") != 1
         or payload.get("runtime") != MSYS2_RUNTIME_ID
-        or payload.get("archive_sha256") != MSYS2_ARCHIVE_SHA256
+        or payload.get("archive_sha256") != MSYS2_BASE_LINEAGE_SHA256
         or not isinstance(content_id, str)
         or re.fullmatch(r"[0-9a-f]{64}", content_id) is None
         or not isinstance(package_count, int)
@@ -1431,6 +1624,12 @@ def _run_checked(
     if returncode:
         if allow_failure:
             return returncode
+        if _NATIVE_WINDOWS and returncode & 0xFFFFFFFF == 0xC0000135:
+            reporter.note(
+                "Windows reported STATUS_DLL_NOT_FOUND. Check whether security "
+                "software quarantined a file in the private MSYS2 staging tree.",
+                level="error",
+            )
         reporter.command_failed(label, returncode)
         raise RuntimeInstallError(f"{label} failed with exit code {returncode}")
     reporter.command_succeeded()
@@ -2022,6 +2221,7 @@ def install_managed_runtime(
     probe: Probe = _probe,
     lock_factory: Callable[[Path], object] = install_lock,
     mirror_optimizer: MirrorOptimizer = optimize_pacman_mirror,
+    extractor: Extractor = _extract_msys2_archive,
     verbose: bool = False,
     reuse_only: bool = False,
 ) -> Msys2Runtime:
@@ -2160,14 +2360,7 @@ def install_managed_runtime(
                     reporter.done(source)
 
                     reporter.phase(2, 7, "Extracting the private MSYS2 base")
-                    _run_checked(
-                        [str(archive), "-y", f"-o{stage}"],
-                        env=environ,
-                        reporter=reporter,
-                        runner=runner,
-                        label="MSYS2 extraction",
-                        progress="extract",
-                    )
+                    extractor(archive, stage, reporter=reporter)
                     root = stage / "msys64"
                     if not (root / "usr" / "bin" / "bash.exe").is_file():
                         raise RuntimeInstallError(

{railmux-0.4.0.dev25 → railmux-0.4.0.dev27}/src/railmux/windows_ui_transition.py

@@ -23,7 +23,7 @@ from typing import Iterator, Mapping, Sequence
 from packaging.version import InvalidVersion, Version
 
 from railmux import restart_state, tmux_server
-from railmux.windows_msys2 import MSYS2_ARCHIVE_SHA256
+from railmux.windows_msys2 import MSYS2_BASE_LINEAGE_SHA256
 
 
 CURRENT_APP_OPTION = "@railmux_current_app_v1"
@@ -136,7 +136,7 @@ def _base_identity(runtime: str) -> str | None:
         or not isinstance(content, dict)
         or content.get("schema") != 1
         or content.get("runtime") != runtime
-        or content.get("archive_sha256") != MSYS2_ARCHIVE_SHA256
+        or content.get("archive_sha256") != MSYS2_BASE_LINEAGE_SHA256
         or not isinstance(content_id, str)
         or _CONTENT_RE.fullmatch(content_id) is None
         or not isinstance(package_count, int)

{railmux-0.4.0.dev25 → railmux-0.4.0.dev27/src/railmux.egg-info}/PKG-INFO

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

@@ -174,4 +174,5 @@ tests/test_windows_wrapper_contract.py
 tests/test_yolo_prompt.py
 tools/denested_transport_benchmark.py
 tools/release_notes.py
-tools/wheel_smoke.py
+tools/wheel_smoke.py
+tools/windows_archive_smoke.py

{railmux-0.4.0.dev25 → railmux-0.4.0.dev27}/tests/test_windows_install_log.py

@@ -2,8 +2,12 @@ from __future__ import annotations
 
 import io
 import os
+import subprocess
 import sys
 
+import pytest
+
+from railmux import windows_msys2
 from railmux.windows_install_log import InstallReporter, install_log_path
 from railmux.windows_msys2 import _run_checked
 
@@ -194,6 +198,27 @@ def test_default_command_runner_uses_no_stdin_and_captures_utf8(tmp_path):
     assert "captured 中文" in path.read_text(encoding="utf-8")
 
 
+def test_windows_missing_dll_status_is_explained(tmp_path, monkeypatch):
+    stream = io.StringIO()
+    path = tmp_path / "install.log"
+    monkeypatch.setattr(windows_msys2, "_NATIVE_WINDOWS", True)
+
+    with InstallReporter(path, verbose=False, stream=stream) as reporter:
+        with pytest.raises(windows_msys2.RuntimeInstallError, match="3221225781"):
+            _run_checked(
+                ["fixture.exe"],
+                env={},
+                reporter=reporter,
+                runner=lambda *_args, **_kwargs: subprocess.CompletedProcess(
+                    [], 0xC0000135
+                ),
+                label="MSYS2 base update",
+            )
+
+    assert "STATUS_DLL_NOT_FOUND" in stream.getvalue()
+    assert "security software" in path.read_text(encoding="utf-8")
+
+
 def test_compact_reporter_surfaces_extraction_and_package_progress(tmp_path):
     stream = io.StringIO()
     path = tmp_path / "install-0.4.0.dev8-20260803T000000Z-7.log"

{railmux-0.4.0.dev25 → railmux-0.4.0.dev27}/tests/test_windows_msys2.py

@@ -3,8 +3,11 @@ from __future__ import annotations
 import hashlib
 import io
 import json
+import os
 import re
+import stat
 import subprocess
+import tarfile
 from contextlib import contextmanager
 from pathlib import Path
 from types import SimpleNamespace
@@ -20,6 +23,7 @@ from railmux.windows_msys2 import (
     MSYS2_ARCHIVE_SHA256,
     MSYS2_ARCHIVE_SIZE,
     MSYS2_ARCHIVE_SOURCES,
+    MSYS2_BASE_LINEAGE_SHA256,
     MSYS2_RUNTIME_ID,
     Msys2Runtime,
     RuntimeInstallError,
@@ -102,7 +106,7 @@ def make_runtime(
                     {
                         "schema": 1,
                         "runtime": MSYS2_RUNTIME_ID,
-                        "archive_sha256": MSYS2_ARCHIVE_SHA256,
+                        "archive_sha256": MSYS2_BASE_LINEAGE_SHA256,
                         "content_id": _TEST_CONTENT_ID,
                         "package_count": 3,
                         "core_packages": {
@@ -156,7 +160,12 @@ def add_marked_app(root: Path, version: str) -> Path:
 
 
 def test_approved_archive_sources_are_https_and_share_one_pinned_artifact():
-    assert MSYS2_ARCHIVE_SIZE == 52_820_994
+    assert MSYS2_ARCHIVE_NAME.endswith(".tar.xz")
+    assert not MSYS2_ARCHIVE_NAME.endswith(".sfx.exe")
+    assert MSYS2_ARCHIVE_SIZE == 53_466_096
+    assert MSYS2_ARCHIVE_SHA256 == (
+        "6b4a986a3ec4f1e40313bdf17903a6f5c854373d4230c40f14c5e35c4bac7fce"
+    )
     assert len(MSYS2_ARCHIVE_SOURCES) == 4
     assert len({url for _label, url in MSYS2_ARCHIVE_SOURCES}) == 4
     for label, url in MSYS2_ARCHIVE_SOURCES:
@@ -728,21 +737,22 @@ def test_install_is_staged_and_activated_only_after_exact_probe(tmp_path):
         assert destination.name == MSYS2_ARCHIVE_NAME
         destination.write_bytes(b"verified fixture")
 
+    def extractor(archive, output, *, reporter):
+        assert archive.name == MSYS2_ARCHIVE_NAME
+        bash = output / "msys64" / "usr" / "bin" / "bash.exe"
+        bash.parent.mkdir(parents=True)
+        bash.write_bytes(b"fixture")
+        config = output / "msys64" / "etc" / "pacman.conf"
+        config.parent.mkdir(parents=True, exist_ok=True)
+        config.write_text(
+            "[options]\nParallelDownloads = 5\n"
+            "[mingw64]\nInclude = /etc/pacman.d/mirrorlist.mingw\n"
+            "[msys]\nInclude = /etc/pacman.d/mirrorlist.msys\n",
+            encoding="utf-8",
+        )
+
     def runner(argv, *, env, check):
         commands.append(argv)
-        if argv[0].endswith(MSYS2_ARCHIVE_NAME):
-            output = Path(next(arg[2:] for arg in argv if arg.startswith("-o")))
-            bash = output / "msys64" / "usr" / "bin" / "bash.exe"
-            bash.parent.mkdir(parents=True)
-            bash.write_bytes(b"fixture")
-            config = output / "msys64" / "etc" / "pacman.conf"
-            config.parent.mkdir(parents=True, exist_ok=True)
-            config.write_text(
-                "[options]\nParallelDownloads = 5\n"
-                "[mingw64]\nInclude = /etc/pacman.d/mirrorlist.mingw\n"
-                "[msys]\nInclude = /etc/pacman.d/mirrorlist.msys\n",
-                encoding="utf-8",
-            )
         return completed(argv)
 
     def probe(argv, *, env, timeout):
@@ -759,6 +769,7 @@ def test_install_is_staged_and_activated_only_after_exact_probe(tmp_path):
         environ=environ,
         downloader=downloader,
         runner=runner,
+        extractor=extractor,
         probe=probe,
         lock_factory=unlocked,
         mirror_optimizer=lambda _root: PacmanMirrorDecision(
@@ -790,6 +801,7 @@ def test_install_is_staged_and_activated_only_after_exact_probe(tmp_path):
     assert any("--needed tmux python python-pip" in command for command in joined)
     assert any('python -m venv "$1/venv"' in command for command in joined)
     assert any('railmux[ssh]==$2' in command for command in joined)
+    assert all(MSYS2_ARCHIVE_NAME not in command for command in joined)
     logs = list((Path(environ["LOCALAPPDATA"]) / "Railmux" / "logs").glob("*.log"))
     assert len(logs) == 1
     log = logs[0].read_text(encoding="utf-8")
@@ -1253,6 +1265,158 @@ def test_verified_base_archive_cache_avoids_a_second_download(tmp_path, monkeypa
     assert source == "verified local cache"
 
 
+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:
+            archive.addfile(member, io.BytesIO(payload) if member.isreg() else None)
+
+
+def _tar_directory(name: str) -> tuple[tarfile.TarInfo, bytes]:
+    member = tarfile.TarInfo(name)
+    member.type = tarfile.DIRTYPE
+    member.mode = 0o755
+    return member, b""
+
+
+def _tar_file(name: str, payload: bytes) -> tuple[tarfile.TarInfo, bytes]:
+    member = tarfile.TarInfo(name)
+    member.size = len(payload)
+    member.mode = 0o755 if name.endswith(".exe") else 0o644
+    return member, payload
+
+
+def test_tar_xz_extraction_is_internal_bounded_and_progress_visible(
+    tmp_path,
+    monkeypatch,
+):
+    entries = [
+        _tar_directory("msys64"),
+        _tar_directory("msys64/usr"),
+        _tar_file("msys64/usr/bash.exe", b"verified bash"),
+        _tar_file("msys64/usr/read-only-upstream", b"must stay writable"),
+    ]
+    entries[-1][0].mode = 0o444
+    archive = tmp_path / MSYS2_ARCHIVE_NAME
+    _write_test_tar(archive, entries)
+    monkeypatch.setattr(windows_msys2, "MSYS2_ARCHIVE_MEMBER_COUNT", 4)
+    monkeypatch.setattr(
+        windows_msys2,
+        "MSYS2_ARCHIVE_UNPACKED_SIZE",
+        len(b"verified bash") + len(b"must stay writable"),
+    )
+    destination = tmp_path / "stage"
+    destination.mkdir()
+    log = tmp_path / "install.log"
+    output = io.StringIO()
+
+    with InstallReporter(log, verbose=False, stream=output) as reporter:
+        windows_msys2._extract_msys2_archive(archive, destination, reporter=reporter)
+
+    assert (destination / "msys64" / "usr" / "bash.exe").read_bytes() == (
+        b"verified bash"
+    )
+    package_owned = destination / "msys64" / "usr" / "read-only-upstream"
+    if os.name == "nt":
+        readonly = getattr(stat, "FILE_ATTRIBUTE_READONLY", 0x1)
+        assert not getattr(package_owned.stat(), "st_file_attributes", 0) & readonly
+    else:
+        assert stat.S_IMODE(package_owned.stat().st_mode) == 0o444
+    rendered = output.getvalue()
+    assert "Extracting private runtime: 1/4 files (25%)" in rendered
+    assert "Extracting private runtime: 4/4 files (100%)" in rendered
+    assert "MSYS2 archive extraction" in log.read_text(encoding="utf-8")
+
+
+def test_native_windows_extraction_clears_posix_read_only_modes(
+    tmp_path, monkeypatch,
+):
+    path = tmp_path / "package-owned"
+    path.write_bytes(b"fixture")
+    applied = []
+    monkeypatch.setattr(windows_msys2, "_NATIVE_WINDOWS", True)
+    monkeypatch.setattr(
+        windows_msys2.os, "chmod", lambda target, mode: applied.append((target, mode))
+    )
+
+    windows_msys2._apply_archive_mode(path, 0o444)
+
+    assert applied == [(path, stat.S_IWRITE)]
+
+
+@pytest.mark.parametrize(
+    ("member", "message"),
+    [
+        (_tar_file("../outside", b"bad"), "unsafe path"),
+        (_tar_file("/absolute", b"bad"), "unsafe path"),
+        (_tar_file(r"msys64\..\outside", b"bad"), "unsafe path"),
+    ],
+)
+def test_tar_xz_extraction_rejects_paths_outside_staging(
+    tmp_path,
+    monkeypatch,
+    member,
+    message,
+):
+    archive = tmp_path / MSYS2_ARCHIVE_NAME
+    _write_test_tar(archive, [member])
+    monkeypatch.setattr(windows_msys2, "MSYS2_ARCHIVE_MEMBER_COUNT", 1)
+    monkeypatch.setattr(windows_msys2, "MSYS2_ARCHIVE_UNPACKED_SIZE", 3)
+    destination = tmp_path / "stage"
+    destination.mkdir()
+
+    with InstallReporter(
+        tmp_path / "install.log", verbose=False, stream=io.StringIO()
+    ) as reporter:
+        with pytest.raises(RuntimeInstallError, match=message):
+            windows_msys2._extract_msys2_archive(
+                archive, destination, reporter=reporter
+            )
+
+    assert not (tmp_path / "outside").exists()
+
+
+def test_tar_xz_extraction_rejects_links_and_special_files(tmp_path, monkeypatch):
+    member = tarfile.TarInfo("msys64/link")
+    member.type = tarfile.SYMTYPE
+    member.linkname = "../outside"
+    archive = tmp_path / MSYS2_ARCHIVE_NAME
+    _write_test_tar(archive, [_tar_directory("msys64"), (member, b"")])
+    monkeypatch.setattr(windows_msys2, "MSYS2_ARCHIVE_MEMBER_COUNT", 2)
+    monkeypatch.setattr(windows_msys2, "MSYS2_ARCHIVE_UNPACKED_SIZE", 0)
+    destination = tmp_path / "stage"
+    destination.mkdir()
+
+    with InstallReporter(
+        tmp_path / "install.log", verbose=False, stream=io.StringIO()
+    ) as reporter:
+        with pytest.raises(RuntimeInstallError, match="unsupported link"):
+            windows_msys2._extract_msys2_archive(
+                archive, destination, reporter=reporter
+            )
+
+
+def test_tar_xz_extraction_rejects_changed_inventory_without_publishing(
+    tmp_path,
+    monkeypatch,
+):
+    archive = tmp_path / MSYS2_ARCHIVE_NAME
+    _write_test_tar(archive, [_tar_directory("msys64")])
+    monkeypatch.setattr(windows_msys2, "MSYS2_ARCHIVE_MEMBER_COUNT", 2)
+    monkeypatch.setattr(windows_msys2, "MSYS2_ARCHIVE_UNPACKED_SIZE", 0)
+    destination = tmp_path / "stage"
+    destination.mkdir()
+
+    with InstallReporter(
+        tmp_path / "install.log", verbose=False, stream=io.StringIO()
+    ) as reporter:
+        with pytest.raises(RuntimeInstallError, match="member count changed"):
+            windows_msys2._extract_msys2_archive(
+                archive, destination, reporter=reporter
+            )
+
+    assert (destination / "msys64").is_dir()
+
+
 def test_pacman_network_failure_retries_with_cache_and_relaxed_timeout(tmp_path):
     root = tmp_path / "msys64"
     bash = root / "usr" / "bin" / "bash.exe"