railmux 0.4.0.dev5__tar.gz → 0.4.0.dev7__tar.gz

{railmux-0.4.0.dev5/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.dev5
+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.dev5 → 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()