modsmith 0.1.0__py3-none-any.whl

modsmith/java.py

@@ -0,0 +1,294 @@
+"""Find Java runtimes from the official launcher, or download Mojang's."""
+
+import lzma
+import os
+import platform
+import stat
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from ._support import default_cache_dir
+from .errors import JavaError
+from .minecraft import GameDir, Version
+from .net import Resource, Session, file_hash
+from .net import download as fetch
+from .net._session import session_scope
+from .progress import CancelToken, ProgressCallback
+
+__all__ = [
+    "JavaRuntime",
+    "download",
+    "find",
+    "find_all",
+    "official_runtime_dirs",
+    "platform_key",
+    "required_for",
+]
+
+RUNTIME_INDEX_URL = "https://launchermeta.mojang.com/v1/products/java-runtime/2ec0cc96c44e5a76b9c8b7c39df7210883d12871/all.json"
+STORE_PACKAGE = "Microsoft.4297127D64EC6_8wekyb3d8bbwe"
+LEGACY_COMPONENT = "jre-legacy"
+# Available on every platform Mojang supports, including Apple Silicon.
+FALLBACK_COMPONENT = "java-runtime-delta"
+# Written last, so an interrupted download is never treated as installed.
+COMPLETE_MARKER = ".modsmith-complete"
+JAVA_BINARIES = ("bin/java.exe", "bin/java", "jre.bundle/Contents/Home/bin/java")
+# The order to try runtimes in when the exact one is not installed.
+PREFERRED_COMPONENTS = (
+    "java-runtime-delta",
+    "java-runtime-gamma",
+    "java-runtime-beta",
+    "java-runtime-epsilon",
+    "java-runtime-alpha",
+    LEGACY_COMPONENT,
+)
+
+
+@dataclass(frozen=True)
+class JavaRuntime:
+    """An installed Java runtime.
+
+    Attributes:
+        component: Mojang's name for the runtime, such as ``java-runtime-delta``.
+        executable: The path of the ``java`` binary.
+    """
+
+    component: str
+    executable: Path
+
+
+def platform_key() -> str:
+    """Return Mojang's name for this platform, such as ``windows-x64``."""
+    machine = platform.machine().lower()
+    arm = machine in ("arm64", "aarch64")
+    if sys.platform == "win32":
+        if arm:
+            return "windows-arm64"
+        return "windows-x64" if machine in ("amd64", "x86_64") else "windows-x86"
+    if sys.platform == "darwin":
+        return "mac-os-arm64" if arm else "mac-os"
+    return "linux" if machine in ("amd64", "x86_64") else "linux-i386"
+
+
+def official_runtime_dirs(game: GameDir | None = None) -> list[Path]:
+    """List the directories where the official launcher keeps Java runtimes.
+
+    Args:
+        game: The game directory. Defaults to `GameDir.default`.
+
+    Returns:
+        The candidate directories. They may not exist.
+    """
+    game = game or GameDir.default()
+    dirs = [game.path / "runtime"]
+    if sys.platform == "win32":
+        local = os.getenv("LOCALAPPDATA")
+        if local:
+            dirs.append(
+                Path(local, "Packages", STORE_PACKAGE, "LocalCache", "Local", "runtime")
+            )
+        program_files = os.getenv("PROGRAMFILES(X86)", r"C:\Program Files (x86)")
+        dirs.append(Path(program_files, "Minecraft Launcher", "runtime"))
+    return dirs
+
+
+def required_for(version: Version, game: GameDir | None = None) -> str:
+    """Return the runtime component a version needs.
+
+    Loader versions usually inherit it, so this follows ``inheritsFrom``.
+
+    Args:
+        version: The version.
+        game: The game directory that holds parent versions.
+
+    Returns:
+        The component, or ``jre-legacy`` if no version in the chain declares one.
+
+    Raises:
+        UnsupportedError: A parent version is not installed.
+    """
+    current = version
+    while current.java_component is None and current.inherits_from and game:
+        current = game.version(current.inherits_from)
+    return current.java_component or LEGACY_COMPONENT
+
+
+def _binary_in(runtime_dir: Path, component: str) -> Path | None:
+    """Find a component's ``java`` binary inside a runtime directory."""
+    component_dir = runtime_dir / component
+    if not component_dir.is_dir():
+        return None
+    for platform_dir in sorted(component_dir.iterdir()):
+        for binary in JAVA_BINARIES:
+            path = platform_dir / component / binary
+            if path.is_file():
+                return path
+    return None
+
+
+def _runtime_cache(cache_dir: Path | None) -> Path:
+    """Return the directory where downloaded runtimes are kept."""
+    return (cache_dir or default_cache_dir()) / "java"
+
+
+def find(
+    component: str,
+    *,
+    game: GameDir | None = None,
+    cache_dir: Path | None = None,
+) -> JavaRuntime | None:
+    """Find a runtime in the official launcher or the download cache.
+
+    Args:
+        component: The runtime component, such as ``java-runtime-delta``.
+        game: The game directory. Defaults to `GameDir.default`.
+        cache_dir: The cache directory. Defaults to the per-user cache.
+
+    Returns:
+        The runtime, or None if it is not installed.
+    """
+    for runtime_dir in official_runtime_dirs(game):
+        binary = _binary_in(runtime_dir, component)
+        if binary:
+            return JavaRuntime(component, binary)
+    cache = _runtime_cache(cache_dir)
+    if (cache / component / COMPLETE_MARKER).is_file():
+        binary = _binary_in(cache, component)
+        if binary:
+            return JavaRuntime(component, binary)
+    return None
+
+
+def find_all(
+    *, game: GameDir | None = None, cache_dir: Path | None = None
+) -> list[JavaRuntime]:
+    """Find every known runtime that is installed, in order of preference.
+
+    Args:
+        game: The game directory. Defaults to `GameDir.default`.
+        cache_dir: The cache directory. Defaults to the per-user cache.
+
+    Returns:
+        The runtimes found.
+    """
+    found = (find(c, game=game, cache_dir=cache_dir) for c in PREFERRED_COMPONENTS)
+    return [runtime for runtime in found if runtime]
+
+
+def _unpack(packed: Path, path: Path, sha1: str, cancel: CancelToken | None) -> None:
+    """Decompress an LZMA file, check its hash and delete the archive."""
+    with lzma.open(packed) as source, open(path, "wb") as dest:
+        while chunk := source.read(1 << 20):
+            if cancel is not None:
+                cancel.check()
+            dest.write(chunk)
+    packed.unlink()
+    if file_hash(path) != sha1:
+        path.unlink()
+        raise JavaError(f"Corrupt Java runtime file: {path.name}")
+
+
+def _install_entries(
+    entries: dict[str, Any],
+    target: Path,
+    session: Session,
+    progress: ProgressCallback | None,
+    cancel: CancelToken | None,
+) -> None:
+    """Install a runtime manifest's files, permissions and links."""
+    resources: list[Resource] = []
+    packed_files: list[tuple[Path, Path, str]] = []
+    links: list[tuple[Path, str]] = []
+    executables: list[Path] = []
+    for name, entry in entries.items():
+        path = target / name
+        kind = entry["type"]
+        if kind == "directory":
+            path.mkdir(parents=True, exist_ok=True)
+        elif kind == "link":
+            links.append((path, entry["target"]))
+        elif kind == "file":
+            raw = entry["downloads"]["raw"]
+            compressed = entry["downloads"].get("lzma")
+            if entry.get("executable"):
+                executables.append(path)
+            if path.is_file() and file_hash(path) == raw["sha1"]:
+                continue
+            if compressed:
+                packed = path.with_name(path.name + ".lzma")
+                resources.append(
+                    Resource.of(
+                        compressed["url"],
+                        packed,
+                        {"sha1": compressed["sha1"]},
+                        compressed.get("size"),
+                    )
+                )
+                packed_files.append((packed, path, raw["sha1"]))
+            else:
+                resources.append(
+                    Resource.of(
+                        raw["url"], path, {"sha1": raw["sha1"]}, raw.get("size")
+                    )
+                )
+
+    fetch(resources, session=session, progress=progress, cancel=cancel, task="java")
+    for packed, path, sha1 in packed_files:
+        _unpack(packed, path, sha1, cancel)
+    for path in executables:
+        path.chmod(path.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+    for path, link_target in links:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.unlink(missing_ok=True)
+        path.symlink_to(link_target)
+
+
+def download(
+    component: str,
+    *,
+    cache_dir: Path | None = None,
+    session: Session | None = None,
+    progress: ProgressCallback | None = None,
+    cancel: CancelToken | None = None,
+    index_url: str = RUNTIME_INDEX_URL,
+) -> JavaRuntime:
+    """Download a Mojang runtime into the cache, never the launcher's directory.
+
+    Files that are already valid are kept, so an interrupted download can be run
+    again.
+
+    Args:
+        component: The runtime component, such as ``java-runtime-delta``.
+        cache_dir: The cache directory. Defaults to the per-user cache.
+        session: The session to use. A temporary one is created if omitted.
+        progress: Receives download updates.
+        cancel: Stops the download.
+        index_url: Where to read Mojang's runtime index.
+
+    Returns:
+        The installed runtime.
+
+    Raises:
+        JavaError: Mojang has no such runtime for this platform, or it is corrupt.
+        NetworkError: The runtime index could not be fetched.
+        DownloadError: A file could not be downloaded.
+        Cancelled: ``cancel`` was triggered.
+    """
+    cache = _runtime_cache(cache_dir)
+    with session_scope(session) as client:
+        index = client.get_json(index_url)
+        builds: dict[str, Any] = index.get(platform_key(), {})
+        entries: list[dict[str, Any]] = builds.get(component) or []
+        if not entries:
+            raise JavaError(f"Mojang has no {component} for {platform_key()}")
+        manifest = client.get_json(entries[0]["manifest"]["url"])
+        target = cache / component / platform_key() / component
+        _install_entries(manifest["files"], target, client, progress, cancel)
+
+    (cache / component / COMPLETE_MARKER).touch()
+    binary = _binary_in(cache, component)
+    if binary is None:
+        raise JavaError(f"No java executable found in {component}")
+    return JavaRuntime(component, binary)

modsmith/launcher.py

@@ -0,0 +1,256 @@
+"""Read and change the official launcher's profiles."""
+
+import base64
+import json
+import shutil
+import subprocess
+import sys
+from collections.abc import Callable
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+from ._support import slugify, write_json
+from .errors import LauncherError
+from .minecraft import GameDir
+
+__all__ = ["Launcher", "Profile", "icon_data_uri", "is_running"]
+
+PROFILE_FILES = ("launcher_profiles.json", "launcher_profiles_microsoft_store.json")
+BACKUP_SUFFIX = ".modsmith.bak"
+KEY_PREFIX = "modsmith-"
+LAUNCHER_PROCESSES = frozenset(
+    {
+        "minecraft.exe",
+        "minecraftlauncher.exe",
+        "minecraft launcher",
+        "minecraft-launcher",
+    }
+)
+
+
+def parse_tasklist(output: str) -> set[str]:
+    """Extract lowercase process names from ``tasklist /FO CSV`` output."""
+    return {
+        line.split('","')[0].strip('"').lower() for line in output.splitlines() if line
+    }
+
+
+def parse_ps(output: str) -> set[str]:
+    """Extract lowercase process names from ``ps -o comm=`` output."""
+    return {
+        line.rsplit("/", 1)[-1].strip().lower() for line in output.splitlines() if line
+    }
+
+
+def _process_names() -> set[str]:
+    """List running process names, or nothing if they cannot be read."""
+    windows = sys.platform == "win32"
+    command = (
+        ["tasklist", "/FO", "CSV", "/NH"] if windows else ["ps", "-A", "-o", "comm="]
+    )
+    try:
+        output = subprocess.run(
+            command, capture_output=True, text=True, errors="replace", timeout=10
+        ).stdout
+    except (OSError, subprocess.SubprocessError):
+        return set()
+    return parse_tasklist(output) if windows else parse_ps(output)
+
+
+def is_running() -> bool:
+    """Return whether the official launcher appears to be running.
+
+    This is best-effort: it returns False if the process list cannot be read.
+    """
+    return bool(_process_names() & LAUNCHER_PROCESSES)
+
+
+def icon_data_uri(data: bytes, content_type: str = "image/png") -> str:
+    """Encode an image as the data URI that launcher profiles use for icons.
+
+    Args:
+        data: The image file's contents.
+        content_type: The image's media type.
+
+    Returns:
+        The data URI, ready for the ``icon`` argument of `Launcher.add_profile`.
+    """
+    encoded = base64.b64encode(data).decode("ascii")
+    return f"data:{content_type};base64,{encoded}"
+
+
+def _timestamp() -> str:
+    """Return the current UTC time in the launcher's format."""
+    return datetime.now(UTC).isoformat(timespec="milliseconds").replace("+00:00", "Z")
+
+
+@dataclass(frozen=True)
+class Profile:
+    """One launcher profile.
+
+    Attributes:
+        key: The profile's key in the launcher's file.
+        name: The display name.
+        version_id: The version it starts, or None.
+        game_dir: Its game directory, or None for the default.
+        java_args: Its JVM arguments, or None.
+        icon: Its icon, as a name or data URI, or None.
+    """
+
+    key: str
+    name: str
+    version_id: str | None = None
+    game_dir: str | None = None
+    java_args: str | None = None
+    icon: str | None = None
+
+    @classmethod
+    def from_dict(cls, key: str, data: dict[str, Any]) -> "Profile":
+        """Build a profile from the launcher's JSON.
+
+        Args:
+            key: The profile's key.
+            data: The profile's JSON.
+
+        Returns:
+            The parsed profile.
+        """
+        return cls(
+            key=key,
+            name=data.get("name", key),
+            version_id=data.get("lastVersionId"),
+            game_dir=data.get("gameDir"),
+            java_args=data.get("javaArgs"),
+            icon=data.get("icon"),
+        )
+
+
+class Launcher:
+    """The profiles of the official launcher that owns a `GameDir`.
+
+    Changes go to every profile file that exists, and each file is backed up
+    first. Keep the launcher closed while changing profiles.
+
+    Args:
+        game: The game directory. Defaults to `GameDir.default`.
+
+    Attributes:
+        game: The game directory.
+    """
+
+    def __init__(self, game: GameDir | None = None) -> None:
+        self.game = game or GameDir.default()
+
+    def profile_files(self) -> list[Path]:
+        """List the launcher's profile files that exist.
+
+        Returns:
+            The paths.
+
+        Raises:
+            LauncherError: There are none, because the launcher has never run here.
+        """
+        paths = [self.game.path / name for name in PROFILE_FILES]
+        existing = [path for path in paths if path.is_file()]
+        if not existing:
+            raise LauncherError(
+                f"No launcher profile in {self.game.path}; run the launcher once first"
+            )
+        return existing
+
+    def _read(self, path: Path) -> dict[str, Any]:
+        """Parse a profile file, allowing a byte order mark."""
+        try:
+            return json.loads(path.read_text(encoding="utf-8-sig"))
+        except ValueError as e:
+            raise LauncherError(f"Cannot parse {path.name}: {e}") from e
+
+    def _update(self, change: Callable[[dict[str, Any]], None]) -> None:
+        """Apply a change to the profiles in every file, with a backup."""
+        for path in self.profile_files():
+            data = self._read(path)
+            change(data.setdefault("profiles", {}))
+            shutil.copy2(path, path.with_name(path.name + BACKUP_SUFFIX))
+            write_json(path, data)
+
+    def profiles(self) -> dict[str, Profile]:
+        """Read every profile.
+
+        Returns:
+            The profiles by key. If files disagree, the first file wins.
+
+        Raises:
+            LauncherError: No profile file exists, or one cannot be parsed.
+        """
+        result: dict[str, Profile] = {}
+        for path in self.profile_files():
+            for key, value in self._read(path).get("profiles", {}).items():
+                result.setdefault(key, Profile.from_dict(key, value))
+        return result
+
+    def add_profile(
+        self,
+        name: str,
+        version_id: str,
+        game_dir: Path | str,
+        *,
+        key: str | None = None,
+        memory_mb: int | None = None,
+        java_args: str | None = None,
+        icon: str | None = None,
+    ) -> str:
+        """Create or update a profile and return its key.
+
+        Fields you do not set on an existing profile are kept.
+
+        Args:
+            name: The display name.
+            version_id: The version to start.
+            game_dir: The instance's directory. It is stored as an absolute path.
+            key: The profile's key. Defaults to ``modsmith-`` and a slug of ``name``.
+            memory_mb: The maximum heap size. Ignored if ``java_args`` is set.
+            java_args: The JVM arguments.
+            icon: The icon, such as a result of `icon_data_uri`.
+
+        Returns:
+            The profile's key.
+
+        Raises:
+            LauncherError: No profile file exists, or one cannot be parsed.
+        """
+        key = key or KEY_PREFIX + slugify(name)
+        now = _timestamp()
+        values: dict[str, Any] = {
+            "name": name,
+            "type": "custom",
+            "gameDir": str(Path(game_dir).resolve()),
+            "lastVersionId": version_id,
+            "lastUsed": now,
+        }
+        if memory_mb is not None:
+            values["javaArgs"] = f"-Xmx{memory_mb}M"
+        if java_args is not None:
+            values["javaArgs"] = java_args
+        if icon is not None:
+            values["icon"] = icon
+
+        def change(profiles: dict[str, Any]) -> None:
+            existing = profiles.get(key)
+            created = {"created": now} if existing is None else {}
+            profiles[key] = {**(existing or {}), **created, **values}
+
+        self._update(change)
+        return key
+
+    def remove_profile(self, key: str) -> None:
+        """Remove a profile. A key that does not exist is ignored.
+
+        Args:
+            key: The profile's key.
+
+        Raises:
+            LauncherError: No profile file exists, or one cannot be parsed.
+        """
+        self._update(lambda profiles: profiles.pop(key, None))

modsmith/loaders/__init__.py

@@ -0,0 +1,23 @@
+"""Install mod loaders. Subclass `Loader` and `register` it to add another."""
+
+from ._base import Loader, create, parse, register
+from ._fabric import Fabric, MetaLoader, Quilt
+from ._forge import Forge, NeoForge, ProcessorLoader
+from ._install_profile import InstallerJar, InstallProfile, Library, Processor
+
+__all__ = [
+    "Fabric",
+    "Forge",
+    "InstallProfile",
+    "InstallerJar",
+    "Library",
+    "Loader",
+    "MetaLoader",
+    "NeoForge",
+    "Processor",
+    "ProcessorLoader",
+    "Quilt",
+    "create",
+    "parse",
+    "register",
+]