railmux 0.4.0.dev6__tar.gz → 0.4.0.dev7__tar.gz

{railmux-0.4.0.dev6/src/railmux.egg-info → railmux-0.4.0.dev7}/PKG-INFO

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

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

{railmux-0.4.0.dev6 → railmux-0.4.0.dev7}/src/railmux/windows_bootstrap.py

@@ -26,7 +26,7 @@ def _print_help() -> None:
         "       railmux ssh HOST [OPTIONS]\n"
         "       railmux config [--remote HOST] [OPTIONS]\n"
         "       railmux doctor [--remote HOST] [OPTIONS]\n"
-        "       railmux runtime {status,install} [--yes]\n\n"
+        "       railmux runtime {status,install} [--yes] [--verbose]\n\n"
         "Windows preview: Railmux runs in a private managed MSYS2/tmux "
         "runtime while Codex and Claude Code remain Windows-native and use "
         "the existing Windows user session directories."
@@ -56,7 +56,8 @@ def _confirm_install(*, input_fn: Callable[[str], str] = input) -> bool:
     try:
         answer = input_fn(
             "Install the private MSYS2/tmux runtime now? "
-            "This downloads about 50 MB and uses about 300 MB [y/N] "
+            "This downloads a 50 MB base plus required updates and packages, "
+            "and uses about 300 MB or more of private disk space [y/N] "
         )
     except (EOFError, KeyboardInterrupt):
         print()
@@ -68,13 +69,18 @@ def _install(
     *,
     environ: Mapping[str, str],
     assume_yes: bool,
+    verbose: bool = False,
     input_fn: Callable[[str], str] = input,
 ) -> Msys2Runtime | None:
     if not assume_yes and not _confirm_install(input_fn=input_fn):
         print("MSYS2 runtime installation cancelled.", file=sys.stderr)
         return None
     try:
-        runtime = install_managed_runtime(version=__version__, environ=environ)
+        runtime = install_managed_runtime(
+            version=__version__,
+            environ=environ,
+            verbose=verbose,
+        )
     except RuntimeInstallError as exc:
         print(f"error: {exc}", file=sys.stderr)
         return None
@@ -135,12 +141,24 @@ def main(
     if arguments[:2] == ["runtime", "status"] and len(arguments) == 2:
         return _runtime_status(runtime, environ=environ)
     if arguments and arguments[0] == "runtime":
-        if arguments[1:] not in (["install"], ["install", "--yes"]):
-            print("error: usage: railmux runtime {status,install} [--yes]", file=sys.stderr)
+        install_arguments = arguments[1:]
+        install_flags = install_arguments[1:] if install_arguments[:1] == ["install"] else []
+        if (
+            not install_arguments
+            or install_arguments[0] != "install"
+            or len(install_flags) != len(set(install_flags))
+            or any(flag not in {"--yes", "--verbose"} for flag in install_flags)
+        ):
+            print(
+                "error: usage: railmux runtime {status,install} "
+                "[--yes] [--verbose]",
+                file=sys.stderr,
+            )
             return 2
         runtime = runtime or _install(
             environ=environ,
-            assume_yes=arguments[-1:] == ["--yes"],
+            assume_yes="--yes" in install_flags,
+            verbose="--verbose" in install_flags,
             input_fn=input_fn,
         )
         return 0 if runtime is not None else 2
@@ -162,7 +180,12 @@ def main(
                 file=sys.stderr,
             )
             return 2
-        runtime = _install(environ=environ, assume_yes=False, input_fn=input_fn)
+        runtime = _install(
+            environ=environ,
+            assume_yes=False,
+            verbose=False,
+            input_fn=input_fn,
+        )
         if runtime is None:
             return 2
 

railmux-0.4.0.dev7/src/railmux/windows_install_log.py

@@ -0,0 +1,189 @@
+"""Bounded user output and complete UTF-8 logs for Windows runtime setup."""
+from __future__ import annotations
+
+import os
+import re
+import sys
+import time
+from collections import deque
+from collections.abc import Callable, Mapping
+from pathlib import Path
+from typing import BinaryIO, TextIO
+
+
+_LOG_KEEP_COUNT = 5
+_FAILURE_LINE_LIMIT = 500
+_LOG_NAME_RE = re.compile(
+    r"install-[0-9A-Za-z.+-]+-[0-9]{8}T[0-9]{6}Z-[0-9]+\.log\Z"
+)
+_URL_CREDENTIAL_RE = re.compile(r"(https?://)[^/@\s]+@", re.IGNORECASE)
+_SECRET_QUERY_RE = re.compile(
+    r"(?i)([?&](?:access_token|password|token)=)[^&\s]+"
+)
+_MIRROR_WARNING_MARKERS = (
+    "too many errors from ",
+    "failed retrieving file ",
+)
+
+
+def _redact_line(line: str) -> str:
+    line = _URL_CREDENTIAL_RE.sub(r"\1<redacted>@", line)
+    return _SECRET_QUERY_RE.sub(r"\1<redacted>", line)
+
+
+def install_log_path(
+    environ: Mapping[str, str],
+    *,
+    version: str,
+    clock: Callable[[], float] = time.time,
+) -> Path:
+    local_app_data = environ.get("LOCALAPPDATA", "").strip()
+    if not local_app_data:
+        raise OSError("LOCALAPPDATA is unavailable")
+    stamp = time.strftime("%Y%m%dT%H%M%SZ", time.gmtime(clock()))
+    return (
+        Path(local_app_data)
+        / "Railmux"
+        / "logs"
+        / f"install-{version}-{stamp}-{os.getpid()}.log"
+    )
+
+
+def _prune_install_logs(directory: Path, *, keep: int = _LOG_KEEP_COUNT) -> None:
+    candidates: list[Path] = []
+    try:
+        entries = list(directory.iterdir())
+    except OSError:
+        return
+    for entry in entries:
+        if entry.is_file() and _LOG_NAME_RE.fullmatch(entry.name):
+            candidates.append(entry)
+    try:
+        candidates.sort(
+            key=lambda path: (path.stat().st_mtime_ns, path.name),
+            reverse=True,
+        )
+    except OSError:
+        return
+    for stale in candidates[max(keep, 1) :]:
+        try:
+            stale.unlink()
+        except OSError:
+            continue
+
+
+class InstallReporter:
+    """Show stable phases while retaining complete command output."""
+
+    def __init__(
+        self,
+        path: Path,
+        *,
+        verbose: bool,
+        stream: TextIO | None = None,
+    ) -> None:
+        self.path = path
+        self.verbose = verbose
+        self.stream = sys.stdout if stream is None else stream
+        self._log: TextIO | None = None
+        self._tail: deque[str] = deque(maxlen=20)
+        self._reported_mirror_warning = False
+
+    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)
+        return self
+
+    def __exit__(self, _exc_type, _exc, _traceback) -> None:
+        if self._log is not None:
+            self._log.close()
+            self._log = None
+
+    def _write_log(self, text: str) -> None:
+        if self._log is None:
+            return
+        self._log.write(text)
+        self._log.flush()
+
+    def _console(self, text: str, *, flush: bool = True) -> None:
+        try:
+            print(text, file=self.stream, flush=flush)
+        except UnicodeEncodeError:
+            encoding = getattr(self.stream, "encoding", None) or "utf-8"
+            safe = text.encode(encoding, errors="replace").decode(encoding)
+            print(safe, file=self.stream, flush=flush)
+
+    def phase(self, number: int, total: int, message: str) -> None:
+        rendered = f"[{number}/{total}] {message}"
+        self._console(rendered)
+        self._write_log(f"\n{rendered}\n")
+
+    def done(self, detail: str | None = None) -> None:
+        rendered = "      done" + (f" · {detail}" if detail else "")
+        self._console(rendered)
+        self._write_log(f"{rendered}\n")
+
+    def note(self, message: str) -> None:
+        rendered = f"      {message}"
+        self._console(rendered)
+        self._write_log(f"{rendered}\n")
+
+    def command_started(self, label: str) -> None:
+        self._tail.clear()
+        self._reported_mirror_warning = False
+        self._write_log(f"\n--- {label} ---\n")
+
+    def command_output(self, output: bytes | str | None) -> None:
+        if not output:
+            return
+        if isinstance(output, bytes):
+            text = output.decode("utf-8", errors="replace")
+        else:
+            text = output
+        normalized = text.replace("\r\n", "\n").replace("\r", "\n")
+        for raw_line in normalized.splitlines():
+            line = _redact_line(raw_line)
+            self._write_log(f"{line}\n")
+            if line.strip():
+                self._tail.append(line)
+            if self.verbose:
+                self._console(line)
+            elif (
+                not self._reported_mirror_warning
+                and any(marker in line.lower() for marker in _MIRROR_WARNING_MARKERS)
+            ):
+                self.note(
+                    "A package mirror failed; pacman is trying the next "
+                    "approved source…"
+                )
+                self._reported_mirror_warning = True
+
+    def command_failed(self, label: str, returncode: int) -> None:
+        self.note(f"{label} failed with exit code {returncode}.")
+        if self._tail:
+            self.note("Last output:")
+            for line in list(self._tail)[-8:]:
+                if len(line) > _FAILURE_LINE_LIMIT:
+                    line = f"{line[:_FAILURE_LINE_LIMIT]}… [truncated; see log]"
+                self._console(f"        {line}")
+        self.note(f"Full UTF-8 log: {self.path}")
+
+    def finish(self) -> None:
+        self._write_log("\nInstallation completed successfully.\n")
+        self._console(f"Installation log: {self.path}")
+
+
+def stream_process_output(
+    process: object,
+    reporter: InstallReporter,
+) -> int:
+    stdout: BinaryIO | None = getattr(process, "stdout", None)
+    if stdout is not None:
+        while True:
+            chunk = stdout.readline()
+            if not chunk:
+                break
+            reporter.command_output(chunk)
+    return process.wait()

{railmux-0.4.0.dev6 → railmux-0.4.0.dev7}/src/railmux/windows_msys2.py

@@ -24,6 +24,17 @@ from contextlib import contextmanager
 from dataclasses import dataclass
 from pathlib import Path
 
+from railmux.windows_install_log import (
+    InstallReporter,
+    install_log_path,
+    stream_process_output,
+)
+from railmux.windows_pacman import (
+    PacmanMirrorDecision,
+    PacmanMirrorError,
+    optimize_pacman_mirror,
+)
+
 
 MSYS2_RELEASE = "2026-03-22"
 MSYS2_ARCHIVE_NAME = f"msys2-base-x86_64-{MSYS2_RELEASE.replace('-', '')}.sfx.exe"
@@ -98,6 +109,7 @@ class RuntimeInstallError(RuntimeErrorBase):
 Probe = Callable[..., subprocess.CompletedProcess[bytes]]
 Runner = Callable[..., subprocess.CompletedProcess]
 Downloader = Callable[[str, Path, str], None]
+MirrorOptimizer = Callable[[Path], PacmanMirrorDecision]
 
 
 @dataclass(frozen=True)
@@ -817,15 +829,32 @@ def _run_checked(
     argv: Sequence[str],
     *,
     env: Mapping[str, str],
-    runner: Runner,
+    reporter: InstallReporter,
     label: str,
+    runner: Runner | None = None,
 ) -> None:
+    reporter.command_started(label)
     try:
-        result = runner(list(argv), env=dict(env), check=False)
+        if runner is None:
+            process = subprocess.Popen(
+                list(argv),
+                env=dict(env),
+                stdin=subprocess.DEVNULL,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                bufsize=-1,
+            )
+            returncode = stream_process_output(process, reporter)
+        else:
+            result = runner(list(argv), env=dict(env), check=False)
+            reporter.command_output(getattr(result, "stdout", None))
+            reporter.command_output(getattr(result, "stderr", None))
+            returncode = result.returncode
     except OSError as exc:
         raise RuntimeInstallError(f"could not start {label}") from exc
-    if result.returncode:
-        raise RuntimeInstallError(f"{label} failed with exit code {result.returncode}")
+    if returncode:
+        reporter.command_failed(label, returncode)
+        raise RuntimeInstallError(f"{label} failed with exit code {returncode}")
 
 
 def _bash_command(root: Path, command: str, *arguments: str) -> list[str]:
@@ -891,9 +920,11 @@ def install_managed_runtime(
     version: str,
     environ: Mapping[str, str],
     downloader: Downloader | None = None,
-    runner: Runner = subprocess.run,
+    runner: Runner | None = None,
     probe: Probe = _probe,
     lock_factory: Callable[[Path], object] = install_lock,
+    mirror_optimizer: MirrorOptimizer = optimize_pacman_mirror,
+    verbose: bool = False,
 ) -> Msys2Runtime:
     """Install a fresh private runtime and activate it only after verification."""
     if not _VERSION_RE.fullmatch(version):
@@ -906,94 +937,163 @@ def install_managed_runtime(
     base = _managed_base(environ)
     if base is None:
         raise RuntimeInstallError("LOCALAPPDATA is unavailable")
-    base.mkdir(parents=True, exist_ok=True)
+    try:
+        base.mkdir(parents=True, exist_ok=True)
+        log_path = install_log_path(environ, version=version)
+    except OSError as exc:
+        raise RuntimeInstallError("could not create the private runtime log") from exc
     final_root = managed_root(environ, version=version)
     assert final_root is not None
     final_root.parent.mkdir(parents=True, exist_ok=True)
 
-    with lock_factory(base):
-        existing = find_runtime(version=version, environ=environ, probe=probe)
-        if existing is not None:
-            return existing
-        if final_root.exists():
-            if _marker_matches(final_root, version=version):
-                raise RuntimeInstallError(
-                    "the managed MSYS2 runtime is present but could not be "
-                    "verified; retry after checking antivirus or disk load"
-                )
-            raise RuntimeInstallError(
-                "the managed MSYS2 directory exists but is incomplete; "
-                "it was left untouched"
-            )
-
-        with tempfile.TemporaryDirectory(prefix=".install-", dir=base) as raw_stage:
-            stage = Path(raw_stage)
-            archive = stage / MSYS2_ARCHIVE_NAME
-            print(f"Downloading verified MSYS2 {MSYS2_RELEASE} runtime…")
-            download_from_sources(
-                archive,
-                MSYS2_ARCHIVE_SHA256,
-                downloader=downloader,
-            )
+    try:
+        with InstallReporter(log_path, verbose=verbose) as reporter:
+            with lock_factory(base):
+                existing = find_runtime(version=version, environ=environ, probe=probe)
+                if existing is not None:
+                    reporter.note("The exact managed runtime is already ready.")
+                    reporter.finish()
+                    return existing
+                if final_root.exists():
+                    if _marker_matches(final_root, version=version):
+                        raise RuntimeInstallError(
+                            "the managed MSYS2 runtime is present but could not be "
+                            "verified; retry after checking antivirus or disk load"
+                        )
+                    raise RuntimeInstallError(
+                        "the managed MSYS2 directory exists but is incomplete; "
+                        "it was left untouched"
+                    )
 
-            _run_checked(
-                [str(archive), "-y", f"-o{stage}"],
-                env=environ,
-                runner=runner,
-                label="MSYS2 extraction",
-            )
-            root = stage / "msys64"
-            if not (root / "usr" / "bin" / "bash.exe").is_file():
-                raise RuntimeInstallError("the verified MSYS2 archive was incomplete")
-            runtime = Msys2Runtime(root, managed=False)
-            child_env = runtime.environment(environ)
-
-            print("Updating the private MSYS2 base…")
-            _run_checked(
-                _bash_command(root, _INITIAL_UPDATE_COMMAND),
-                env=child_env,
-                runner=runner,
-                label="MSYS2 base update",
-            )
-            # A new process is required after msys2-runtime/bash updates.
-            child_env = runtime.environment(environ)
-            print("Installing tmux and the private Python runtime…")
-            _run_checked(
-                _bash_command(root, _PACKAGE_INSTALL_COMMAND),
-                env=child_env,
-                runner=runner,
-                label="MSYS2 package installation",
-            )
-            _run_checked(
-                _bash_command(root, _VENV_COMMAND),
-                env=child_env,
-                runner=runner,
-                label="Railmux virtual environment creation",
-            )
-            print(f"Installing Railmux {version} into the private runtime…")
-            _run_checked(
-                _bash_command(root, _PACKAGE_COMMAND, version),
-                env=child_env,
-                runner=runner,
-                label="Railmux runtime package installation",
-            )
-            _write_marker(root, version=version)
-            staged_runtime = Msys2Runtime(root, managed=True)
-            if not probe_runtime(
-                staged_runtime,
-                version=version,
-                environ=environ,
-                probe=probe,
-            ):
-                raise RuntimeInstallError("the staged Railmux runtime failed validation")
-            os.replace(root, final_root)
-
-        installed = Msys2Runtime(final_root, managed=True)
-        if not probe_runtime(
-            installed,
-            version=version,
-            environ=environ,
-            probe=probe,
-        ):
-            raise RuntimeInstallError("the activated Railmux runtime failed validation")
-        return installed
+                with tempfile.TemporaryDirectory(
+                    prefix=".install-", dir=base
+                ) as raw_stage:
+                    stage = Path(raw_stage)
+                    archive = stage / MSYS2_ARCHIVE_NAME
+                    reporter.phase(1, 7, f"Downloading MSYS2 {MSYS2_RELEASE} base")
+                    source = download_from_sources(
+                        archive,
+                        MSYS2_ARCHIVE_SHA256,
+                        downloader=downloader,
+                    )
+                    reporter.done(source)
+
+                    reporter.phase(2, 7, "Verifying and extracting the private base")
+                    _run_checked(
+                        [str(archive), "-y", f"-o{stage}"],
+                        env=environ,
+                        reporter=reporter,
+                        runner=runner,
+                        label="MSYS2 extraction",
+                    )
+                    root = stage / "msys64"
+                    if not (root / "usr" / "bin" / "bash.exe").is_file():
+                        raise RuntimeInstallError(
+                            "the verified MSYS2 archive was incomplete"
+                        )
+                    reporter.done()
+
+                    reporter.phase(3, 7, "Selecting an MSYS2 package mirror")
+                    try:
+                        decision = mirror_optimizer(root)
+                    except PacmanMirrorError as exc:
+                        reporter.note(
+                            f"Mirror measurement unavailable ({exc}); using the "
+                            "official order."
+                        )
+                        reporter.done("official order")
+                    else:
+                        for mirror_probe in decision.probes:
+                            reporter.command_output(
+                                f"mirror probe {mirror_probe.label}: "
+                                f"{_format_download_rate(mirror_probe.rate)}\n"
+                            )
+                        for label, reason in decision.failures:
+                            reporter.command_output(
+                                f"mirror probe {label}: unavailable ({reason})\n"
+                            )
+                        if decision.selected is None:
+                            reporter.done("official order")
+                        else:
+                            reporter.done(
+                                f"{decision.selected.label} · "
+                                f"{_format_download_rate(decision.selected.rate)}"
+                            )
+
+                    runtime = Msys2Runtime(root, managed=False)
+                    child_env = runtime.environment(environ)
+                    reporter.phase(4, 7, "Updating the private MSYS2 base")
+                    reporter.note(
+                        "pacman is noninteractive; displayed [Y/n] prompts do "
+                        "not require input."
+                    )
+                    _run_checked(
+                        _bash_command(root, _INITIAL_UPDATE_COMMAND),
+                        env=child_env,
+                        reporter=reporter,
+                        runner=runner,
+                        label="MSYS2 base update",
+                    )
+                    reporter.done()
+
+                    # A new process is required after msys2-runtime/bash updates.
+                    child_env = runtime.environment(environ)
+                    reporter.phase(5, 7, "Installing tmux and private Python")
+                    _run_checked(
+                        _bash_command(root, _PACKAGE_INSTALL_COMMAND),
+                        env=child_env,
+                        reporter=reporter,
+                        runner=runner,
+                        label="MSYS2 package installation",
+                    )
+                    reporter.done()
+
+                    reporter.phase(6, 7, f"Installing Railmux {version}")
+                    _run_checked(
+                        _bash_command(root, _VENV_COMMAND),
+                        env=child_env,
+                        reporter=reporter,
+                        runner=runner,
+                        label="Railmux virtual environment creation",
+                    )
+                    _run_checked(
+                        _bash_command(root, _PACKAGE_COMMAND, version),
+                        env=child_env,
+                        reporter=reporter,
+                        runner=runner,
+                        label="Railmux runtime package installation",
+                    )
+                    reporter.done()
+
+                    reporter.phase(7, 7, "Validating and activating the runtime")
+                    _write_marker(root, version=version)
+                    staged_runtime = Msys2Runtime(root, managed=True)
+                    if not probe_runtime(
+                        staged_runtime,
+                        version=version,
+                        environ=environ,
+                        probe=probe,
+                    ):
+                        raise RuntimeInstallError(
+                            "the staged Railmux runtime failed validation"
+                        )
+                    os.replace(root, final_root)
+
+                installed = Msys2Runtime(final_root, managed=True)
+                if not probe_runtime(
+                    installed,
+                    version=version,
+                    environ=environ,
+                    probe=probe,
+                ):
+                    raise RuntimeInstallError(
+                        "the activated Railmux runtime failed validation"
+                    )
+                reporter.done("ready")
+                reporter.finish()
+                return installed
+    except RuntimeInstallError as exc:
+        raise RuntimeInstallError(f"{exc}; full log: {log_path}") from exc
+    except OSError as exc:
+        detail = f"; full log: {log_path}" if log_path.is_file() else ""
+        raise RuntimeInstallError(f"runtime installation failed{detail}") from exc