lean-runtime 2.0.1__tar.gz → 2.0.3__tar.gz

{lean_runtime-2.0.1 → lean_runtime-2.0.3}/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 2.0.3
+
+- Accept portable-copy symlinks whose normalized targets remain inside the
+  extracted copy, including common links such as `docs/README.md -> ../README.md`.
+- Continue rejecting absolute or escaping symlink targets, duplicate archive
+  members, and later archive writes that traverse an extracted symlink.
+
+## 2.0.2
+
+- Remove staged environments safely when Git-for-Windows leaves source pack
+  files read-only or briefly locked.
+- Preserve the primary environment-build diagnostic when staging cleanup also
+  fails.
+- Show the failed phase, command, exit code, and captured tool output when a
+  verbose CLI materialization fails.
+
 ## 2.0.1
 
 - Enable Git's long-path support for every Runtime-managed source operation so

{lean_runtime-2.0.1/lean_runtime.egg-info → lean_runtime-2.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-runtime
-Version: 2.0.1
+Version: 2.0.3
 Summary: Run Lean 4 proofs from Python or standalone files
 Author: Alejandro Radisic
 License-Expression: Apache-2.0

lean_runtime-2.0.3/lean_runtime/_paths.py

@@ -0,0 +1,38 @@
+"""Internal cross-platform filesystem operations."""
+
+from __future__ import annotations
+
+import os
+import shutil
+import stat
+import time
+from collections.abc import Callable
+from pathlib import Path
+from types import TracebackType
+from typing import Any
+
+
+def _retry_writable(
+    function: Callable[..., Any],
+    path: str,
+    _error: tuple[type[BaseException], BaseException, TracebackType | None],
+) -> None:
+    """Clear Git-for-Windows read-only attributes and retry one removal."""
+
+    os.chmod(path, stat.S_IWRITE)
+    function(path)
+
+
+def remove_tree(path: Path) -> None:
+    """Remove a tree containing Git packs, tolerating transient Windows locks."""
+
+    for attempt in range(4):
+        try:
+            shutil.rmtree(path, onerror=_retry_writable)
+            return
+        except PermissionError:
+            if not path.exists():
+                return
+            if attempt == 3:
+                raise
+            time.sleep(0.05 * (2**attempt))

{lean_runtime-2.0.1 → lean_runtime-2.0.3}/lean_runtime/bundles.py

@@ -20,6 +20,7 @@ from pathlib import Path, PurePosixPath
 from typing import Any
 
 from ._git import git_command
+from ._paths import remove_tree
 from .backends import Backend
 from .errors import EnvironmentError
 from .events import EventEmitter
@@ -202,11 +203,54 @@ def _require_media_type(descriptor: dict[str, Any], expected: str, label: str) -
 
 def _safe_name(name: str) -> PurePosixPath:
     path = PurePosixPath(name)
-    if not name or path.is_absolute() or ".." in path.parts or "\x00" in name:
+    if (
+        not name
+        or path == PurePosixPath(".")
+        or path.is_absolute()
+        or ".." in path.parts
+        or "\\" in name
+        or "\x00" in name
+    ):
         raise EnvironmentError(f"unsafe bundle member path: {name!r}")
     return path
 
 
+def _internal_link_target(member: PurePosixPath, linkname: str) -> PurePosixPath:
+    link = PurePosixPath(linkname)
+    if not linkname or link.is_absolute() or "\\" in linkname or "\x00" in linkname:
+        raise EnvironmentError(f"unsafe bundle symlink: {member.as_posix()!r}")
+    parts: list[str] = []
+    for part in member.parent.joinpath(link).parts:
+        if part in {"", "."}:
+            continue
+        if part == "..":
+            if not parts:
+                raise EnvironmentError(f"unsafe bundle symlink: {member.as_posix()!r}")
+            parts.pop()
+        else:
+            parts.append(part)
+    return PurePosixPath(*parts) if parts else PurePosixPath(".")
+
+
+def _ensure_directories(destination: Path, relative: PurePosixPath) -> None:
+    current = destination
+    for part in relative.parts:
+        if part == ".":
+            continue
+        current = current / part
+        if current.is_symlink():
+            raise EnvironmentError(
+                f"bundle member traverses an extracted symlink: {relative.as_posix()!r}"
+            )
+        if current.exists():
+            if not current.is_dir():
+                raise EnvironmentError(
+                    f"bundle member parent is not a directory: {relative.as_posix()!r}"
+                )
+        else:
+            current.mkdir()
+
+
 def _packages_directory(lock: EnvironmentLock) -> PurePosixPath:
     value = lock.manifest.get("packagesDir", ".lake/packages")
     if not isinstance(value, str):
@@ -220,6 +264,8 @@ def _packages_directory(lock: EnvironmentLock) -> PurePosixPath:
 def _extract_layer(data: bytes | Path, destination: Path) -> None:
     total = 0
     count = 0
+    if destination.is_symlink():
+        raise EnvironmentError("bundle extraction destination must not be a symlink")
     destination.mkdir(parents=True, exist_ok=True)
     try:
         if isinstance(data, Path):
@@ -239,10 +285,12 @@ def _extract_layer(data: bytes | Path, destination: Path) -> None:
             relative = _safe_name(member.name)
             target = destination.joinpath(*relative.parts)
             if member.isdir():
-                target.mkdir(parents=True, exist_ok=True)
+                _ensure_directories(destination, relative)
                 target.chmod(member.mode & 0o777)
             elif member.isfile():
-                target.parent.mkdir(parents=True, exist_ok=True)
+                _ensure_directories(destination, relative.parent)
+                if target.exists() or target.is_symlink():
+                    raise EnvironmentError(f"duplicate bundle member: {member.name!r}")
                 source = archive.extractfile(member)
                 if source is None:
                     raise EnvironmentError(f"bundle member has no content: {member.name}")
@@ -250,11 +298,10 @@ def _extract_layer(data: bytes | Path, destination: Path) -> None:
                     shutil.copyfileobj(source, handle)
                 target.chmod(member.mode & 0o777)
             elif member.issym():
-                link = PurePosixPath(member.linkname)
-                resolved = relative.parent.joinpath(link)
-                if link.is_absolute() or ".." in resolved.parts:
-                    raise EnvironmentError(f"unsafe bundle symlink: {member.name!r}")
-                target.parent.mkdir(parents=True, exist_ok=True)
+                _internal_link_target(relative, member.linkname)
+                _ensure_directories(destination, relative.parent)
+                if target.exists() or target.is_symlink():
+                    raise EnvironmentError(f"duplicate bundle member: {member.name!r}")
                 target.symlink_to(member.linkname)
             else:
                 raise EnvironmentError(f"unsupported bundle member: {member.name!r}")
@@ -667,7 +714,7 @@ class EnvironmentBundles:
                     stage.replace(destination)
                 finally:
                     if stage.exists():
-                        shutil.rmtree(stage)
+                        remove_tree(stage)
         if name:
             self.store.set_alias(name, environment_id)
         self.events.emit(

{lean_runtime-2.0.1 → lean_runtime-2.0.3}/lean_runtime/cli.py

@@ -50,6 +50,19 @@ def _progress(event: RuntimeEvent) -> None:
     print(f"lean-runtime: {event.kind}{package}: {event.message}", file=sys.stderr)
 
 
+def _print_operation_failure(exc: ResolutionError | MaterializationError, *, verbose: bool) -> None:
+    print(f"lean-runtime: {exc}", file=sys.stderr)
+    if not verbose:
+        return
+    print(f"phase: {exc.phase}", file=sys.stderr)
+    if exc.command:
+        print("command: " + " ".join(exc.command), file=sys.stderr)
+    if exc.exit_code is not None:
+        print(f"exit code: {exc.exit_code}", file=sys.stderr)
+    if exc.output:
+        print(exc.output.rstrip(), file=sys.stderr)
+
+
 def _cli_source_name(path: Path) -> str:
     if path.is_absolute():
         return path.name
@@ -643,7 +656,7 @@ def main(argv: list[str] | None = None) -> int:
                 )
             )
         else:
-            print(f"lean-runtime: {exc}", file=sys.stderr)
+            _print_operation_failure(exc, verbose=args.verbose)
         return 2
     except (LeanRuntimeError, OSError, UnicodeError, ValueError, json.JSONDecodeError) as exc:
         if getattr(args, "json", False):

{lean_runtime-2.0.1 → lean_runtime-2.0.3}/lean_runtime/environments.py

@@ -6,7 +6,6 @@ import asyncio
 import json
 import os
 import re
-import shutil
 import subprocess
 import tempfile
 import threading
@@ -21,6 +20,7 @@ from pathlib import Path, PurePosixPath
 from typing import Any, Generic, TextIO, TypeVar, cast
 
 from ._git import git_command
+from ._paths import remove_tree
 from .backends import Backend, BackendResult, InteractiveProcess, InteractiveTextReader
 from .diagnostics import error_diagnostic, parse_diagnostics
 from .errors import EnvironmentError, MaterializationError, PolicyError
@@ -559,7 +559,7 @@ class Environment:
 
         def cleanup() -> None:
             if instance.exists():
-                shutil.rmtree(instance)
+                remove_tree(instance)
             with suppress(OSError):
                 job_parent.rmdir()
 
@@ -847,7 +847,7 @@ class Environment:
             return result
         finally:
             if instance.exists():
-                shutil.rmtree(instance)
+                remove_tree(instance)
             with suppress(OSError):
                 job_parent.rmdir()
 
@@ -1107,7 +1107,10 @@ class EnvironmentManager:
             )
         finally:
             if stage.exists():
-                shutil.rmtree(stage)
+                # Preserve a build/materialization diagnostic if cleanup of
+                # Git's read-only pack files also fails on Windows.
+                with suppress(OSError):
+                    remove_tree(stage)
 
     def _ensure_sources(self, lock: EnvironmentLock) -> None:
         """Acquire exact locked sources without invoking Lake resolution."""

{lean_runtime-2.0.1 → lean_runtime-2.0.3}/lean_runtime/programs.py

@@ -10,7 +10,6 @@ from __future__ import annotations
 import hashlib
 import os
 import re
-import shutil
 import tempfile
 import uuid
 from collections.abc import Mapping, Sequence
@@ -20,6 +19,7 @@ from datetime import datetime, timezone
 from pathlib import Path, PurePosixPath
 from typing import Any, cast
 
+from ._paths import remove_tree
 from .backends import Backend, BackendResult, InteractiveProcess
 from .bundles import (
     INDEX_MEDIA_TYPE,
@@ -238,7 +238,7 @@ class ReadyProgram:
 
         def cleanup() -> None:
             if instance.exists():
-                shutil.rmtree(instance)
+                remove_tree(instance)
             with suppress(OSError):
                 job_parent.rmdir()
 
@@ -347,7 +347,7 @@ class ProgramManager:
                     stage.replace(destination)
                 finally:
                     if stage.exists():
-                        shutil.rmtree(stage)
+                        remove_tree(stage)
         self.events.emit(
             "program.created", "Created executable program", program_id=manifest.program_id
         )
@@ -534,7 +534,7 @@ class ProgramManager:
                     stage.replace(destination)
                 finally:
                     if stage.exists():
-                        shutil.rmtree(stage)
+                        remove_tree(stage)
         return self.open(manifest.program_id)
 
 

{lean_runtime-2.0.1 → lean_runtime-2.0.3}/lean_runtime/store.py

@@ -18,6 +18,7 @@ from pathlib import Path
 from typing import Any
 
 from ._git import git_command
+from ._paths import remove_tree
 from .errors import EnvironmentError
 from .lockfiles import EnvironmentLock
 from .locking import FileLock
@@ -348,7 +349,7 @@ class EnvironmentStore:
                     # Failed Git checkouts can leave locked pack files on
                     # Windows. Cleanup must not mask the actionable Git error.
                     with suppress(OSError):
-                        shutil.rmtree(stage)
+                        remove_tree(stage)
         return destination
 
     def environment_path(self, environment_id: str) -> Path:
@@ -556,7 +557,7 @@ class EnvironmentStore:
                         ):
                             retained.append(path.name)
                             continue
-                        shutil.rmtree(path)
+                        remove_tree(path)
                         usage.unlink(missing_ok=True)
                         removed.append(path.name)
         return CleanupReport(tuple(candidates), tuple(removed), tuple(retained), dry_run)

{lean_runtime-2.0.1 → lean_runtime-2.0.3/lean_runtime.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-runtime
-Version: 2.0.1
+Version: 2.0.3
 Summary: Run Lean 4 proofs from Python or standalone files
 Author: Alejandro Radisic
 License-Expression: Apache-2.0

{lean_runtime-2.0.1 → lean_runtime-2.0.3}/lean_runtime.egg-info/SOURCES.txt

@@ -26,6 +26,7 @@ examples/mathlib.toml
 lean_runtime/__init__.py
 lean_runtime/__main__.py
 lean_runtime/_git.py
+lean_runtime/_paths.py
 lean_runtime/backends.py
 lean_runtime/bundles.py
 lean_runtime/cli.py
@@ -91,6 +92,7 @@ tests/test_git.py
 tests/test_interactive.py
 tests/test_lockfiles.py
 tests/test_multifile.py
+tests/test_paths.py
 tests/test_prebuilt_policy.py
 tests/test_programs.py
 tests/test_projects.py

{lean_runtime-2.0.1 → lean_runtime-2.0.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lean-runtime"
-version = "2.0.1"
+version = "2.0.3"
 description = "Run Lean 4 proofs from Python or standalone files"
 readme = "README.md"
 requires-python = ">=3.10"

{lean_runtime-2.0.1 → lean_runtime-2.0.3}/tests/test_bundles.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import hashlib
 import http.server
+import io
 import json
 import os
 import shutil
@@ -15,7 +16,7 @@ from pathlib import Path
 import pytest
 
 from lean_runtime import EnvironmentError, EnvironmentLock, LockedPackage, Runtime
-from lean_runtime.bundles import _oci_archive
+from lean_runtime.bundles import _extract_layer, _oci_archive
 from lean_runtime.environments import ENVIRONMENT_SCHEMA
 from lean_runtime.oci import OCIEnvironmentPublisher, OCIRepository
 from lean_runtime.store import environment_identity, platform_record, source_snapshot_digest
@@ -119,6 +120,57 @@ def _archive_entries(path: Path) -> dict[str, bytes]:
     return result
 
 
+def _layer(*members: tuple[str, str, bytes | str]) -> bytes:
+    output = io.BytesIO()
+    with tarfile.open(fileobj=output, mode="w:gz", format=tarfile.PAX_FORMAT) as archive:
+        for kind, name, value in members:
+            info = tarfile.TarInfo(name)
+            info.mode = 0o644
+            if kind == "file":
+                assert isinstance(value, bytes)
+                info.size = len(value)
+                archive.addfile(info, io.BytesIO(value))
+            else:
+                assert kind == "symlink" and isinstance(value, str)
+                info.type = tarfile.SYMTYPE
+                info.linkname = value
+                archive.addfile(info)
+    return output.getvalue()
+
+
+@pytest.mark.skipif(os.name == "nt", reason="Windows runners may not permit symlink creation")
+def test_layer_extract_accepts_internal_parent_symlink(tmp_path: Path) -> None:
+    layer = _layer(
+        ("file", "README.md", b"Batteries\n"),
+        ("symlink", "docs/README.md", "../README.md"),
+    )
+
+    _extract_layer(layer, tmp_path / "output")
+
+    link = tmp_path / "output" / "docs" / "README.md"
+    assert link.is_symlink()
+    assert link.read_text() == "Batteries\n"
+
+
+@pytest.mark.skipif(os.name == "nt", reason="Windows runners may not permit symlink creation")
+def test_layer_extract_rejects_symlink_outside_destination(tmp_path: Path) -> None:
+    layer = _layer(("symlink", "docs/README.md", "../../outside"))
+
+    with pytest.raises(EnvironmentError, match="unsafe bundle symlink"):
+        _extract_layer(layer, tmp_path / "output")
+
+
+@pytest.mark.skipif(os.name == "nt", reason="Windows runners may not permit symlink creation")
+def test_layer_extract_rejects_later_write_through_symlink(tmp_path: Path) -> None:
+    layer = _layer(
+        ("symlink", "redirect", "inside"),
+        ("file", "redirect/payload", b"must not be written"),
+    )
+
+    with pytest.raises(EnvironmentError, match="traverses an extracted symlink"):
+        _extract_layer(layer, tmp_path / "output")
+
+
 def test_bundle_export_is_deterministic_and_imports_into_fresh_store(tmp_path: Path) -> None:
     producer, environment_id, lock = _published_runtime(tmp_path / "producer")
     first = tmp_path / "first.oci.tar.gz"

{lean_runtime-2.0.1 → lean_runtime-2.0.3}/tests/test_cli.py

@@ -4,7 +4,8 @@ import json
 from pathlib import Path
 
 from lean_runtime.bundles import PortableCopyInfo
-from lean_runtime.cli import main, parser
+from lean_runtime.cli import _print_operation_failure, main, parser
+from lean_runtime.errors import MaterializationError
 from lean_runtime.models import ExecutionResult
 from lean_runtime.verification import VerificationCheck, VerificationReport
 
@@ -34,6 +35,26 @@ def test_removed_v1_commands_are_absent() -> None:
     assert commands.isdisjoint(removed)
 
 
+def test_verbose_materialization_failure_includes_tool_output(capsys) -> None:
+    failure = MaterializationError(
+        "environment build failed",
+        phase="build",
+        command=("lake", "build"),
+        exit_code=1,
+        output="specific compiler failure\n",
+    )
+
+    _print_operation_failure(failure, verbose=True)
+
+    assert capsys.readouterr().err == (
+        "lean-runtime: environment build failed\n"
+        "phase: build\n"
+        "command: lake build\n"
+        "exit code: 1\n"
+        "specific compiler failure\n"
+    )
+
+
 def test_check_file_cli_json_result(monkeypatch, tmp_path: Path, capsys) -> None:
     source = tmp_path / "Main.lean"
     source.write_text("example : True := by trivial")

lean_runtime-2.0.3/tests/test_paths.py

@@ -0,0 +1,25 @@
+from pathlib import Path
+
+from lean_runtime._paths import remove_tree
+
+
+def test_remove_tree_retries_transient_permission_errors(tmp_path: Path, monkeypatch) -> None:
+    target = tmp_path / "tree"
+    target.mkdir()
+    calls = 0
+
+    def flaky_rmtree(path: Path, *, onerror) -> None:
+        nonlocal calls
+        calls += 1
+        if calls == 1:
+            raise PermissionError("Git pack is briefly locked")
+        assert onerror is not None
+        path.rmdir()
+
+    monkeypatch.setattr("lean_runtime._paths.shutil.rmtree", flaky_rmtree)
+    monkeypatch.setattr("lean_runtime._paths.time.sleep", lambda _seconds: None)
+
+    remove_tree(target)
+
+    assert calls == 2
+    assert not target.exists()

{lean_runtime-2.0.1 → lean_runtime-2.0.3}/tests/test_store.py

@@ -217,11 +217,13 @@ def test_source_snapshot_preserves_git_error_when_cleanup_also_fails(
         Path(command[-1]).mkdir()
         return subprocess.CompletedProcess(command, 1, "", "Filename too long")
 
-    def failed_cleanup(_path: Path) -> None:
+    def failed_cleanup(_path: Path, *, onerror) -> None:
+        assert onerror is not None
         raise PermissionError("pack file is locked")
 
     monkeypatch.setattr("lean_runtime.store.subprocess.run", failed_clone)
-    monkeypatch.setattr("lean_runtime.store.shutil.rmtree", failed_cleanup)
+    monkeypatch.setattr("lean_runtime._paths.shutil.rmtree", failed_cleanup)
+    monkeypatch.setattr("lean_runtime._paths.time.sleep", lambda _seconds: None)
 
     with pytest.raises(EnvironmentError, match="Filename too long"):
         store.publish_source(checkout, source_id, metadata)