railmux 0.4.0.dev4__tar.gz → 0.4.0.dev5__tar.gz

{railmux-0.4.0.dev4/src/railmux.egg-info → railmux-0.4.0.dev5}/PKG-INFO

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

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

{railmux-0.4.0.dev4 → railmux-0.4.0.dev5}/src/railmux/windows_msys2.py

@@ -7,13 +7,16 @@ remain Windows-native.
 from __future__ import annotations
 
 import hashlib
+import http.client
 import json
 import os
 import re
 import subprocess
+import sys
 import tempfile
 import time
 import urllib.error
+import urllib.parse
 import urllib.request
 from collections.abc import Callable, Iterator, Mapping, Sequence
 from contextlib import contextmanager
@@ -23,10 +26,27 @@ from pathlib import Path
 
 MSYS2_RELEASE = "2026-03-22"
 MSYS2_ARCHIVE_NAME = f"msys2-base-x86_64-{MSYS2_RELEASE.replace('-', '')}.sfx.exe"
-MSYS2_ARCHIVE_URL = (
-    "https://github.com/msys2/msys2-installer/releases/download/"
-    f"{MSYS2_RELEASE}/{MSYS2_ARCHIVE_NAME}"
+MSYS2_ARCHIVE_SOURCES = (
+    (
+        "GitHub",
+        "https://github.com/msys2/msys2-installer/releases/download/"
+        f"{MSYS2_RELEASE}/{MSYS2_ARCHIVE_NAME}",
+    ),
+    (
+        "MSYS2 repository",
+        f"https://repo.msys2.org/distrib/x86_64/{MSYS2_ARCHIVE_NAME}",
+    ),
+    (
+        "TUNA mirror",
+        f"https://mirrors.tuna.tsinghua.edu.cn/msys2/distrib/x86_64/"
+        f"{MSYS2_ARCHIVE_NAME}",
+    ),
+    (
+        "NJU mirror",
+        f"https://mirror.nju.edu.cn/msys2/distrib/x86_64/{MSYS2_ARCHIVE_NAME}",
+    ),
 )
+MSYS2_ARCHIVE_SIZE = 52_820_994
 MSYS2_ARCHIVE_SHA256 = (
     "6fe0cc8154132040e034ff4daface2a4163a9d1f6ebaaa1133394bff460bd5cf"
 )
@@ -42,6 +62,7 @@ _HANDOFF_COMMAND = (
 )
 _PROBE_TIMEOUT_SECONDS = 15.0
 _DOWNLOAD_LIMIT = 128 * 1024 * 1024
+_DOWNLOAD_LOG_STEP = 8 * 1024 * 1024
 _VERSION_RE = re.compile(r"[0-9]+(?:\.[0-9]+)*(?:\.dev[0-9]+)?\Z")
 
 _INITIAL_UPDATE_COMMAND = (
@@ -71,6 +92,61 @@ Runner = Callable[..., subprocess.CompletedProcess]
 Downloader = Callable[[str, Path, str], None]
 
 
+def _format_download_size(size: int) -> str:
+    if size >= 1024 * 1024:
+        return f"{size / (1024 * 1024):.1f} MiB"
+    if size >= 1024:
+        return f"{size / 1024:.1f} KiB"
+    return f"{size} B"
+
+
+class _DownloadProgress:
+    """Render bounded progress without flooding redirected logs."""
+
+    def __init__(self, url: str) -> None:
+        self._stream = sys.stderr
+        self._source = urllib.parse.urlsplit(url).hostname or "approved source"
+        self._interactive = bool(getattr(self._stream, "isatty", lambda: False)())
+        self._last_logged = 0
+        self._active_line = False
+
+    def _message(self, downloaded: int, expected: int | None) -> str:
+        current = _format_download_size(downloaded)
+        if expected:
+            percent = min(100.0, downloaded * 100.0 / expected)
+            return (
+                f"  {self._source}: {current} / "
+                f"{_format_download_size(expected)} ({percent:.1f}%)"
+            )
+        return f"  {self._source}: {current} downloaded"
+
+    def update(
+        self,
+        downloaded: int,
+        expected: int | None,
+        *,
+        final: bool = False,
+    ) -> None:
+        message = self._message(downloaded, expected)
+        if self._interactive:
+            self._stream.write(f"\r{message}")
+            self._active_line = not final
+            if final:
+                self._stream.write("\n")
+            self._stream.flush()
+            return
+        if final or downloaded - self._last_logged >= _DOWNLOAD_LOG_STEP:
+            self._stream.write(f"{message}\n")
+            self._stream.flush()
+            self._last_logged = downloaded
+
+    def abort(self) -> None:
+        if self._interactive and self._active_line:
+            self._stream.write("\n")
+            self._stream.flush()
+            self._active_line = False
+
+
 @dataclass(frozen=True)
 class Msys2Runtime:
     root: Path
@@ -227,10 +303,30 @@ def find_runtime(
 
 def download_verified(url: str, destination: Path, sha256: str) -> None:
     """Download one bounded artifact and verify it before execution."""
+    if urllib.parse.urlsplit(url).scheme.lower() != "https":
+        raise RuntimeInstallError("the MSYS2 runtime source did not use HTTPS")
     digest = hashlib.sha256()
     total = 0
+    expected: int | None = None
+    progress = _DownloadProgress(url)
     try:
         with urllib.request.urlopen(url, timeout=60) as response:
+            final_url = getattr(response, "geturl", lambda: url)()
+            if urllib.parse.urlsplit(final_url).scheme.lower() != "https":
+                raise RuntimeInstallError(
+                    "the MSYS2 runtime source redirected outside HTTPS"
+                )
+            raw_length = response.headers.get("Content-Length")
+            if raw_length is not None:
+                try:
+                    parsed_length = int(raw_length)
+                except (TypeError, ValueError):
+                    parsed_length = 0
+                if parsed_length > 0:
+                    expected = parsed_length
+            if expected is not None and expected > _DOWNLOAD_LIMIT:
+                raise RuntimeInstallError("MSYS2 download exceeded its size limit")
+            progress.update(0, expected)
             with destination.open("xb") as output:
                 while True:
                     chunk = response.read(1024 * 1024)
@@ -241,12 +337,61 @@ def download_verified(url: str, destination: Path, sha256: str) -> None:
                         raise RuntimeInstallError("MSYS2 download exceeded its size limit")
                     digest.update(chunk)
                     output.write(chunk)
-    except RuntimeInstallError:
-        raise
-    except (OSError, urllib.error.URLError) as exc:
+                    progress.update(total, expected)
+        if digest.hexdigest().lower() != sha256.lower():
+            raise RuntimeInstallError(
+                "the downloaded MSYS2 archive failed SHA-256 verification"
+            )
+    except (
+        RuntimeInstallError,
+        OSError,
+        urllib.error.URLError,
+        http.client.HTTPException,
+    ) as exc:
+        progress.abort()
+        try:
+            destination.unlink(missing_ok=True)
+        except OSError as cleanup_error:
+            raise RuntimeInstallError(
+                "could not remove an incomplete MSYS2 download"
+            ) from cleanup_error
+        if isinstance(exc, RuntimeInstallError):
+            raise
         raise RuntimeInstallError("could not download the pinned MSYS2 runtime") from exc
-    if digest.hexdigest().lower() != sha256.lower():
-        raise RuntimeInstallError("the downloaded MSYS2 archive failed SHA-256 verification")
+    progress.update(total, expected, final=True)
+
+
+def download_from_sources(
+    destination: Path,
+    sha256: str,
+    *,
+    sources: Sequence[tuple[str, str]] = MSYS2_ARCHIVE_SOURCES,
+    downloader: Downloader = download_verified,
+) -> str:
+    """Try approved transports in order; every source uses the same pinned hash."""
+    last_error: RuntimeInstallError | None = None
+    for index, (label, url) in enumerate(sources, start=1):
+        print(f"Downloading from {label} ({index}/{len(sources)})…")
+        try:
+            downloader(url, destination, sha256)
+        except RuntimeInstallError as exc:
+            last_error = exc
+            try:
+                destination.unlink(missing_ok=True)
+            except OSError as cleanup_error:
+                raise RuntimeInstallError(
+                    "could not remove an incomplete MSYS2 download"
+                ) from cleanup_error
+            if index < len(sources):
+                print(
+                    f"{label} failed ({exc}); trying the next approved source…",
+                    file=sys.stderr,
+                )
+            continue
+        return label
+    raise RuntimeInstallError(
+        "could not download the pinned MSYS2 runtime from any approved source"
+    ) from last_error
 
 
 def _run_checked(
@@ -366,7 +511,11 @@ def install_managed_runtime(
             stage = Path(raw_stage)
             archive = stage / MSYS2_ARCHIVE_NAME
             print(f"Downloading verified MSYS2 {MSYS2_RELEASE} runtime…")
-            downloader(MSYS2_ARCHIVE_URL, archive, MSYS2_ARCHIVE_SHA256)
+            download_from_sources(
+                archive,
+                MSYS2_ARCHIVE_SHA256,
+                downloader=downloader,
+            )
 
             _run_checked(
                 [str(archive), "-y", f"-o{stage}"],

{railmux-0.4.0.dev4 → railmux-0.4.0.dev5/src/railmux.egg-info}/PKG-INFO

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

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import hashlib
+import io
 import json
 import subprocess
 from contextlib import contextmanager
@@ -8,11 +10,17 @@ from unittest.mock import MagicMock
 
 import pytest
 
+from railmux import windows_msys2
 from railmux.windows_msys2 import (
     MSYS2_ARCHIVE_NAME,
+    MSYS2_ARCHIVE_SHA256,
+    MSYS2_ARCHIVE_SIZE,
+    MSYS2_ARCHIVE_SOURCES,
     MSYS2_RUNTIME_ID,
     Msys2Runtime,
     RuntimeInstallError,
+    download_from_sources,
+    download_verified,
     find_runtime,
     install_managed_runtime,
     managed_root,
@@ -20,7 +28,36 @@ from railmux.windows_msys2 import (
 )
 
 
-VERSION = "0.4.0.dev4"
+VERSION = "0.4.0.dev5"
+
+
+class TtyBuffer(io.StringIO):
+    def isatty(self):
+        return True
+
+
+class FakeResponse(io.BytesIO):
+    def __init__(
+        self,
+        payload: bytes,
+        *,
+        content_length: str | None = None,
+        final_url: str = "https://example.invalid/archive.exe",
+    ):
+        super().__init__(payload)
+        self._final_url = final_url
+        self.headers = {}
+        if content_length is not None:
+            self.headers["Content-Length"] = content_length
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, _exc_type, _exc, _traceback):
+        self.close()
+
+    def geturl(self):
+        return self._final_url
 
 
 def completed(argv, returncode=0, stdout=b"", stderr=b""):
@@ -41,6 +78,136 @@ def make_runtime(root: Path, *, managed: bool) -> Msys2Runtime:
     return Msys2Runtime(root, managed=managed)
 
 
+def test_approved_archive_sources_are_https_and_share_one_pinned_artifact():
+    assert MSYS2_ARCHIVE_SIZE == 52_820_994
+    assert len(MSYS2_ARCHIVE_SOURCES) == 4
+    assert len({url for _label, url in MSYS2_ARCHIVE_SOURCES}) == 4
+    for label, url in MSYS2_ARCHIVE_SOURCES:
+        assert label
+        assert url.startswith("https://")
+        assert url.endswith(f"/{MSYS2_ARCHIVE_NAME}")
+
+
+def test_download_reports_bytes_and_percentage_on_a_terminal(tmp_path, monkeypatch):
+    payload = b"a" * (2 * 1024 * 1024)
+    progress = TtyBuffer()
+    monkeypatch.setattr(windows_msys2.sys, "stderr", progress)
+    monkeypatch.setattr(
+        windows_msys2.urllib.request,
+        "urlopen",
+        lambda _url, timeout: FakeResponse(
+            payload,
+            content_length=str(len(payload)),
+        ),
+    )
+    destination = tmp_path / "archive.exe"
+
+    download_verified(
+        "https://example.invalid/archive.exe",
+        destination,
+        hashlib.sha256(payload).hexdigest(),
+    )
+
+    rendered = progress.getvalue()
+    assert "\r  example.invalid: 1.0 MiB / 2.0 MiB (50.0%)" in rendered
+    assert "\r  example.invalid: 2.0 MiB / 2.0 MiB (100.0%)\n" in rendered
+    assert destination.read_bytes() == payload
+
+
+def test_download_hash_failure_removes_the_untrusted_archive(tmp_path, monkeypatch):
+    payload = b"not the pinned archive"
+    monkeypatch.setattr(
+        windows_msys2.urllib.request,
+        "urlopen",
+        lambda _url, timeout: FakeResponse(
+            payload,
+            content_length=str(len(payload)),
+        ),
+    )
+    destination = tmp_path / "archive.exe"
+
+    with pytest.raises(RuntimeInstallError, match="SHA-256 verification"):
+        download_verified(
+            "https://example.invalid/archive.exe",
+            destination,
+            MSYS2_ARCHIVE_SHA256,
+        )
+
+    assert not destination.exists()
+
+
+def test_download_rejects_an_https_downgrade_before_writing(tmp_path, monkeypatch):
+    monkeypatch.setattr(
+        windows_msys2.urllib.request,
+        "urlopen",
+        lambda _url, timeout: FakeResponse(
+            b"untrusted",
+            final_url="http://mirror.invalid/archive.exe",
+        ),
+    )
+    destination = tmp_path / "archive.exe"
+
+    with pytest.raises(RuntimeInstallError, match="redirected outside HTTPS"):
+        download_verified(
+            "https://example.invalid/archive.exe",
+            destination,
+            MSYS2_ARCHIVE_SHA256,
+        )
+
+    assert not destination.exists()
+
+
+def test_download_falls_back_after_removing_a_partial_archive(tmp_path):
+    destination = tmp_path / "archive.exe"
+    sources = (
+        ("first", "https://first.invalid/a"),
+        ("second", "https://second.invalid/a"),
+    )
+    attempted = []
+
+    def downloader(url, target, sha256):
+        attempted.append((url, sha256))
+        if "first" in url:
+            target.write_bytes(b"partial")
+            raise RuntimeInstallError("could not download the pinned MSYS2 runtime")
+        assert not target.exists()
+        target.write_bytes(b"verified")
+
+    selected = download_from_sources(
+        destination,
+        MSYS2_ARCHIVE_SHA256,
+        sources=sources,
+        downloader=downloader,
+    )
+
+    assert selected == "second"
+    assert [url for url, _sha256 in attempted] == [url for _label, url in sources]
+    assert {sha256 for _url, sha256 in attempted} == {MSYS2_ARCHIVE_SHA256}
+    assert destination.read_bytes() == b"verified"
+
+
+def test_download_fails_closed_after_every_approved_source(tmp_path):
+    destination = tmp_path / "archive.exe"
+    sources = (
+        ("first", "https://first.invalid/a"),
+        ("second", "https://second.invalid/a"),
+    )
+
+    def downloader(_url, target, _sha256):
+        target.write_bytes(b"untrusted")
+        raise RuntimeInstallError("archive failed verification")
+
+    with pytest.raises(RuntimeInstallError, match="any approved source"):
+        download_from_sources(
+            destination,
+            MSYS2_ARCHIVE_SHA256,
+            sources=sources,
+            downloader=downloader,
+        )
+
+    assert not destination.exists()
+
+
 def test_handoff_preserves_argv_and_uses_child_only_msys_environment(tmp_path):
     runtime = make_runtime(tmp_path / "msys", managed=False)
     arguments = ["ssh", "user@example", "--ssh-args=-J jump host", "开发"]
@@ -82,10 +249,10 @@ def test_managed_runtime_requires_utf8_marker_and_exact_package_version(tmp_path
     root = managed_root(environ, version=VERSION)
     assert root is not None
     runtime = make_runtime(root, managed=True)
-    probe = MagicMock(return_value=completed([], stdout=b"railmux 0.4.0.dev4\n"))
+    probe = MagicMock(return_value=completed([], stdout=b"railmux 0.4.0.dev5\n"))
 
     assert probe_runtime(runtime, version=VERSION, environ=environ, probe=probe)
-    assert not probe_runtime(runtime, version="0.4.0.dev5", environ=environ, probe=probe)
+    assert not probe_runtime(runtime, version="0.4.0.dev6", environ=environ, probe=probe)
 
 
 def test_runtime_probe_retries_one_transient_cold_start_failure(tmp_path):
@@ -93,7 +260,7 @@ def test_runtime_probe_retries_one_transient_cold_start_failure(tmp_path):
     probe = MagicMock(
         side_effect=[
             completed([], returncode=1),
-            completed([], stdout=b"railmux 0.4.0.dev4\n"),
+            completed([], stdout=b"railmux 0.4.0.dev5\n"),
         ]
     )
 
@@ -114,7 +281,7 @@ def test_each_preview_version_uses_a_separate_runtime_generation(tmp_path):
 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)
-    probe = MagicMock(return_value=completed([], stdout=b"railmux 0.4.0.dev4\n"))
+    probe = MagicMock(return_value=completed([], stdout=b"railmux 0.4.0.dev5\n"))
     environ = {"RAILMUX_MSYS2_ROOT": str(root), "USERPROFILE": r"C:\Users\u"}
 
     found = find_runtime(version=VERSION, environ=environ, probe=probe)
@@ -186,7 +353,7 @@ def test_install_is_staged_and_activated_only_after_exact_probe(tmp_path):
         return completed(argv)
 
     def probe(argv, *, env, timeout):
-        return completed(argv, stdout=b"railmux 0.4.0.dev4\n")
+        return completed(argv, stdout=b"railmux 0.4.0.dev5\n")
 
     @contextmanager
     def unlocked(_base):

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

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