orzmc 2.0.0__py3-none-any.whl

orzmc/__init__.py

@@ -0,0 +1,171 @@
+"""OrzMC core library.
+
+This module is the **public API contract**. The application layer (orzmc-app)
+and any external project should only import from here; internals live under
+``domain`` / ``infra`` / ``core`` / ``services``.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from orzmc.core.mojang import VersionEntry
+from orzmc.domain.java import DEFAULT_JAVA_MAJOR, required_java_major
+from orzmc.domain.launch import DEFAULT_MAIN_CLASS, build_launch_command, game_args, jvm_args
+from orzmc.domain.libraries import Library, resolve_libraries
+from orzmc.domain.options import RuntimeOptions
+from orzmc.domain.paths import DEFAULT_ROOT, PathLayout
+from orzmc.domain.types import GameType
+from orzmc.infra.fs import FileStore
+from orzmc.infra.log import NullReporter, Reporter, RichReporter
+from orzmc.infra.progress import NullProgress, ProgressSink, RichProgress
+from orzmc.services.backup import Backup
+from orzmc.services.client import ClientService
+from orzmc.services.context import AppContext, Services
+from orzmc.services.server import ServerService
+from orzmc.services.versions import InstalledVersion, VersionManager
+from orzmc.version import __version__
+
+__all__ = [
+    "DEFAULT_JAVA_MAJOR",
+    "DEFAULT_MAIN_CLASS",
+    "DEFAULT_ROOT",
+    "AppContext",
+    "Backup",
+    "ClientService",
+    "FileStore",
+    "GameType",
+    "InstalledVersion",
+    "Library",
+    "NullProgress",
+    "NullReporter",
+    "PathLayout",
+    "ProgressSink",
+    # protocols & impls
+    "Reporter",
+    "RichProgress",
+    "RichReporter",
+    # domain
+    "RuntimeOptions",
+    "ServerService",
+    # services
+    "Services",
+    "VersionEntry",
+    "VersionManager",
+    # versions
+    "__version__",
+    "backup_world",
+    "build_launch_command",
+    "deploy_server",
+    "game_args",
+    "install_java",
+    "jvm_args",
+    # entry points
+    "launch_client",
+    "list_versions",
+    "remote_version_catalog",
+    "remote_versions",
+    "remove_version",
+    "required_java_major",
+    "resolve_libraries",
+]
+
+# ── entry points ─────────────────────────────────────────────────────────────
+
+
+def launch_client(
+    options: RuntimeOptions,
+    reporter: Reporter | None = None,
+    sink: ProgressSink | None = None,
+    confirm_java: Callable[[int, bool], bool] | None = None,
+) -> int:
+    """Launch the Minecraft client for ``options`` (auto-installs everything).
+
+    ``confirm_java`` (optional) is consulted before installing a Java runtime.
+    """
+    base = Services(options, reporter=reporter, sink=sink)
+    version = options.version or base.mojang.latest_release_id()
+    if not version:
+        raise RuntimeError("无法确定 Minecraft 版本")
+    return ClientService(base.for_version(version)).run(confirm_java=confirm_java)
+
+
+def deploy_server(
+    options: RuntimeOptions,
+    reporter: Reporter | None = None,
+    sink: ProgressSink | None = None,
+    confirm_java: Callable[[int, bool], bool] | None = None,
+    confirm_eula: Callable[[], bool] | None = None,
+    on_line: Callable[[str], None] | None = None,
+) -> int:
+    """Deploy and run a server for ``options`` (auto-installs everything).
+
+    ``confirm_eula`` (optional) accepts the Minecraft EULA interactively when
+    ``options.yes`` is not set. ``on_line`` receives streamed server output.
+    """
+    base = Services(options, reporter=reporter, sink=sink)
+    version = options.version or base.mojang.latest_release_id()
+    if not version:
+        raise RuntimeError("无法确定 Minecraft 版本")
+    return ServerService(base.for_version(version)).run(
+        confirm_java=confirm_java, confirm_eula=confirm_eula, on_line=on_line
+    )
+
+
+def list_versions(root_dir: str | None = None) -> list[InstalledVersion]:
+    """Enumerate installed versions (client / server types) under ``root_dir``."""
+    return VersionManager(root_dir=root_dir).list_versions()
+
+
+def remote_version_catalog(root_dir: str | None = None, update: bool = False) -> list[VersionEntry]:
+    """List all Mojang manifest versions (any type, newest first); installs nothing."""
+    options = RuntimeOptions(root_dir=root_dir or DEFAULT_ROOT)
+    return Services(options).mojang.version_entries(update=update)
+
+
+def remote_versions(root_dir: str | None = None, update: bool = False) -> list[str]:
+    """List Mojang release version ids (fetches/caches the manifest, installs nothing)."""
+    return [e.id for e in remote_version_catalog(root_dir, update) if e.is_release]
+
+
+def remove_version(
+    version: str,
+    *,
+    is_client: bool = True,
+    game_type: str | None = None,
+    root_dir: str | None = None,
+    yes: bool = False,
+    reporter: Reporter | None = None,
+    confirm: Callable[[str], bool] | None = None,
+) -> bool:
+    """Remove a version's client or a specific server type. ``confirm`` is
+    consulted unless ``yes`` is set."""
+    manager = VersionManager(root_dir=root_dir)
+    return manager.remove(version, is_client=is_client, game_type=game_type, yes=yes, confirm=confirm)
+
+
+def backup_world(
+    version: str,
+    game_type: str = "vanilla",
+    root_dir: str | None = None,
+    reporter: Reporter | None = None,
+) -> str:
+    """Back up ``versions/<version>/server/<game_type>/world`` to ``backup/worlds/``."""
+    return Backup(reporter=reporter, root_dir=root_dir).backup_world(version, game_type)
+
+
+def install_java(
+    major: int,
+    *,
+    need_jdk: bool = False,
+    root_dir: str | None = None,
+    reporter: Reporter | None = None,
+    sink: ProgressSink | None = None,
+    confirm: Callable[[int, bool], bool] | None = None,
+) -> str:
+    """Ensure a sandboxed Java ``major`` is installed under ``root_dir/java/``.
+
+    Returns the managed ``bin/java`` path.
+    """
+    options = RuntimeOptions(root_dir=root_dir or DEFAULT_ROOT)
+    return Services(options, reporter=reporter, sink=sink).java_env.resolve(major, need_jdk=need_jdk, confirm=confirm)

orzmc/core/client/__init__.py

@@ -0,0 +1,21 @@
+"""Client add-on strategies (``ClientProvider`` registry).
+
+Importing this package registers the vanilla / fabric / forge providers so
+``ClientProvider.for_type`` resolves them. Library-internal — none of these
+names are part of the public API contract in ``orzmc/__init__``.
+"""
+
+from orzmc.core.client.base import BuildJavaSeam, ClientPrepare, ClientProvider, DownloadSeam
+from orzmc.core.client.fabric import FabricProvider
+from orzmc.core.client.forge import ForgeProvider
+from orzmc.core.client.vanilla import VanillaProvider
+
+__all__ = [
+    "BuildJavaSeam",
+    "ClientPrepare",
+    "ClientProvider",
+    "DownloadSeam",
+    "FabricProvider",
+    "ForgeProvider",
+    "VanillaProvider",
+]

orzmc/core/client/base.py

@@ -0,0 +1,85 @@
+"""ClientProvider strategy: resolve an optional launch addon for a game type.
+
+Mirror of ``core/server``: providers receive every dependency as an injected
+seam (``ClientPrepare``), so this package never imports ``orzmc.services``.
+The orchestration seams ``download`` / ``resolve_build_java`` are supplied by
+``ClientService`` from the services layer — a textbook dependency inversion.
+
+Each concrete provider holds all knowledge of one client type in a single
+file, so editing one type never affects another: vanilla is a no-op, fabric
+wraps the fabric-meta profile json, forge runs the official installer and
+harvests its generated client jar.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any, Protocol
+
+from orzmc.core.profiles import ProfileAddon
+from orzmc.domain.paths import PathLayout
+from orzmc.domain.types import GameType
+from orzmc.infra.fs import FileStore
+from orzmc.infra.http import HttpClient
+from orzmc.infra.log import Reporter
+from orzmc.infra.runner import ProcessRunner
+
+
+class DownloadSeam(Protocol):
+    """Single-file download that skips an already-valid cache (download_file)."""
+
+    def __call__(self, url: str, dest: str, desc: str, sha1: str | None = None, force: bool = False) -> bool: ...
+
+
+class BuildJavaSeam(Protocol):
+    """Resolve a sandboxed java binary for an install step (JavaEnv.resolve)."""
+
+    def __call__(
+        self, major: int, need_jdk: bool = False, confirm: Callable[[int, bool], bool] | None = None
+    ) -> str: ...
+
+
+@dataclass(frozen=True)
+class ClientPrepare:
+    """Injected seams + parsed Mojang data a ClientProvider needs for an addon."""
+
+    version: str
+    version_json: dict[str, Any]
+    major: int
+    force_download: bool
+    confirm_java: Callable[[int, bool], bool] | None
+    # ── infra / domain seams ────────────────────────────────────────────────
+    paths: PathLayout
+    fs: FileStore
+    reporter: Reporter
+    http: HttpClient
+    process: ProcessRunner
+    # ── orchestration injections (services layer) ───────────────────────────
+    download: DownloadSeam
+    resolve_build_java: BuildJavaSeam
+
+
+_REGISTRY: dict[GameType, ClientProvider] = {}
+
+
+class ClientProvider(ABC):
+    """Strategy that produces a launch addon for ``game_type`` (or None).
+
+    Concrete providers are stateless singletons that self-register on import.
+    """
+
+    game_type: GameType
+
+    @abstractmethod
+    def addon(self, prepare: ClientPrepare) -> ProfileAddon | None:
+        """Resolve extra libraries/args/main-class; return None to launch vanilla."""
+
+    @classmethod
+    def register(cls, provider: ClientProvider) -> None:
+        _REGISTRY[provider.game_type] = provider
+
+    @classmethod
+    def for_type(cls, game_type: GameType) -> ClientProvider | None:
+        return _REGISTRY.get(game_type)

orzmc/core/client/fabric.py

@@ -0,0 +1,28 @@
+"""Fabric client: resolve the fabric-loader profile and download its libraries."""
+
+from __future__ import annotations
+
+from orzmc.core.client.base import ClientPrepare, ClientProvider
+from orzmc.core.fabric import Fabric
+from orzmc.core.profiles import ProfileAddon
+from orzmc.domain.types import GameType
+
+
+class FabricProvider(ClientProvider):
+    game_type = GameType.FABRIC
+
+    def addon(self, prepare: ClientPrepare) -> ProfileAddon | None:
+        addon = Fabric(prepare.http, prepare.version).profile()
+        for lib in addon.libraries:
+            if lib.url:
+                prepare.download(
+                    lib.url,
+                    prepare.paths.client_library_path(lib.path),
+                    f"下载 {lib.name}",
+                    lib.sha1,
+                    force=prepare.force_download,
+                )
+        return addon
+
+
+ClientProvider.register(FabricProvider())

orzmc/core/client/forge.py

@@ -0,0 +1,128 @@
+"""Forge client: run the official installer and assemble the launch addon.
+
+Forge ships no standalone client definition: the launch json is embedded in
+the installer jar and the patched ``client`` classifier jar (the Minecraft
+module the launcher needs) has **no downloadable source** — its ``url`` is
+empty in ``version.json`` and Maven 404s it. It is produced by the installer's
+binary-patching pipeline from the vanilla client jar.
+
+So this provider mirrors the server side: download the installer, run it
+headlessly (``--installClient``) into a temporary official-layout directory,
+then harvest the generated jar plus the forge libraries into our own
+``client/libraries/`` layout. The shared ``core.forge`` adapter resolves the
+version from ``promotions_slim.json`` and reads ``version.json`` from the jar.
+
+Only the modern ForgeBootstrap era (1.20.4+ / 49.x) is supported: those
+versions ship a plain ``arguments`` block with no ``{{token}}`` templating and
+exactly one generated jar. Older Forge (bootstraplauncher) versions raise a
+clear error instead of producing a broken launch.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+from orzmc.core.client.base import ClientPrepare, ClientProvider
+from orzmc.core.forge import Forge, extract_version_json
+from orzmc.core.profiles import ProfileAddon
+from orzmc.domain.libraries import Library
+from orzmc.domain.types import GameType
+
+_BOOTSTRAP_LAUNCHER = "cpw.mods.bootstraplauncher"
+_FORGE_MIN_JAVA = 17  # ForgeBootstrap-era installers require Java 17+
+
+_MINIMAL_LAUNCHER_PROFILE = {
+    "authenticationDatabase": {},
+    "selectedUser": {"account": "", "profile": ""},
+    "profiles": {},
+    "settings": {"enableSnapshots": False, "keepLauncherOpen": False},
+    "version": 1,
+}
+
+
+class ForgeProvider(ClientProvider):
+    game_type = GameType.FORGE
+
+    def addon(self, prepare: ClientPrepare) -> ProfileAddon | None:
+        forge = Forge(prepare.http)
+        full = forge.latest_full_version(prepare.version)
+        installer = os.path.join(prepare.paths.client_dir(), "forge", f"forge-{full}-installer.jar")
+        prepare.download(forge.installer_url(full), installer, f"下载 Forge 安装器 {full}")
+
+        forge_json = extract_version_json(installer)
+        if _BOOTSTRAP_LAUNCHER in str(forge_json.get("mainClass", "")):
+            raise RuntimeError(
+                f"Forge {full} 使用旧版启动器(BootstrapLauncher),暂不支持客户端启动"
+                "(仅支持 ForgeBootstrap 系,1.20.4 及以上)"
+            )
+
+        install_dir = os.path.join(prepare.paths.client_dir(), "forge", "install")
+        try:
+            self._run_client_install(prepare, installer, full, install_dir)
+            libraries = self._harvest_libraries(prepare, forge_json, install_dir)
+        finally:
+            prepare.fs.remove(install_dir)
+
+        return ProfileAddon(
+            libraries=libraries,
+            jvm_args=_forge_string_args(forge_json, "jvm"),
+            game_args=_forge_string_args(forge_json, "game"),
+            main_class=forge_json.get("mainClass"),
+            # the harvested client jar *is* the game jar; the vanilla jar must
+            # not also sit on the classpath or its unpatched classes shadow it
+            uses_own_client_jar=True,
+        )
+
+    # ── internals ───────────────────────────────────────────────────────────
+
+    def _run_client_install(self, prepare: ClientPrepare, installer: str, full: str, install_dir: str) -> None:
+        prepare.fs.ensure_dir(install_dir)
+        profile = os.path.join(install_dir, "launcher_profiles.json")
+        if not prepare.fs.is_file(profile):
+            prepare.fs.write_json(profile, _MINIMAL_LAUNCHER_PROFILE)
+        java_bin = prepare.resolve_build_java(
+            max(prepare.major, _FORGE_MIN_JAVA), need_jdk=False, confirm=prepare.confirm_java
+        )
+        prepare.reporter.info(f"正在生成 Forge 客户端 {full}...")
+        code = prepare.process.run_stream(
+            [java_bin, "-jar", installer, "--installClient", install_dir],
+            on_line=lambda line: prepare.reporter.plain(line),
+            cwd=install_dir,
+        )
+        if code != 0:
+            raise RuntimeError(f"Forge 客户端安装失败 ({full})")
+
+    def _harvest_libraries(self, prepare: ClientPrepare, forge_json: dict[str, Any], install_dir: str) -> list[Library]:
+        """Move the forge libraries (incl. the generated client jar) into our layout."""
+        libraries: list[Library] = []
+        for lib in forge_json.get("libraries", []):
+            artifact = (lib.get("downloads") or {}).get("artifact") or {}
+            path = artifact.get("path")
+            name = lib.get("name")
+            if not path or not name:
+                continue
+            src = os.path.join(install_dir, "libraries", path)
+            if not prepare.fs.is_file(src):
+                continue
+            prepare.fs.move(src, prepare.paths.client_library_path(path))
+            libraries.append(
+                Library(
+                    name=name,
+                    path=path,
+                    url=artifact.get("url") or "",
+                    sha1=artifact.get("sha1"),
+                    size=artifact.get("size"),
+                )
+            )
+        if not any(lib.path.endswith("-client.jar") for lib in libraries):
+            raise RuntimeError("未找到 Forge 客户端产物(client jar),安装可能不完整")
+        return libraries
+
+
+def _forge_string_args(forge_json: dict[str, Any], key: str) -> list[str]:
+    """Plain-string entries of ``arguments.<key>`` (forge ships no rule dicts here)."""
+    return [a for a in (forge_json.get("arguments") or {}).get(key, []) if isinstance(a, str)]
+
+
+ClientProvider.register(ForgeProvider())

orzmc/core/client/vanilla.py

@@ -0,0 +1,17 @@
+"""Vanilla client: no add-on — the plain Mojang launch definition suffices."""
+
+from __future__ import annotations
+
+from orzmc.core.client.base import ClientPrepare, ClientProvider
+from orzmc.core.profiles import ProfileAddon
+from orzmc.domain.types import GameType
+
+
+class VanillaProvider(ClientProvider):
+    game_type = GameType.VANILLA
+
+    def addon(self, prepare: ClientPrepare) -> ProfileAddon | None:
+        return None
+
+
+ClientProvider.register(VanillaProvider())

orzmc/core/fabric.py

@@ -0,0 +1,97 @@
+"""Fabric loader resolution & library download (fabric-meta API)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from orzmc.core.profiles import ProfileAddon
+from orzmc.domain.libraries import Library
+from orzmc.infra.http import HttpClient
+
+META_BASE = "https://meta.fabricmc.net/v2"
+
+
+class Fabric:
+    def __init__(self, http: HttpClient, version: str, loader: str | None = None) -> None:
+        self._http = http
+        self.version = version
+        self.loader = loader
+
+    def profile(self) -> ProfileAddon:
+        """Resolve the fabric-loader profile json for this MC version."""
+        loader_version = self.loader or self.latest_loader_version()
+        # fabric-meta stopped accepting the installer version in this URL (404
+        # for every combo); the loader version alone resolves the profile.
+        url = f"{META_BASE}/versions/loader/{self.version}/{loader_version}/profile/json"
+        config: dict[str, Any] = self._http.get_json(url)
+
+        libraries: list[Library] = []
+        for lib in config.get("libraries", []):
+            name = lib.get("name")
+            if not name:
+                continue
+            # fabric-meta's `url` is now just the repository base (e.g.
+            # ``https://maven.fabricmc.net/``), not a per-artifact url — the
+            # local path must come from the maven coordinates themselves.
+            path = _coordinate_path(name)
+            base = lib.get("url") or "https://maven.fabricmc.net/"
+            libraries.append(
+                Library(
+                    name=name,
+                    path=path,
+                    url=base.rstrip("/") + "/" + path,
+                    sha1=lib.get("sha1"),
+                    size=lib.get("size"),
+                )
+            )
+
+        arguments = config.get("arguments", {})
+        jvm_args = [a for a in arguments.get("jvm", []) if isinstance(a, str)]
+        game_args = [a for a in arguments.get("game", []) if isinstance(a, str)]
+        main_class = _main_class(config)
+
+        return ProfileAddon(libraries=libraries, jvm_args=jvm_args, game_args=game_args, main_class=main_class)
+
+    def latest_loader_version(self) -> str:
+        """Latest stable fabric-loader version for this MC version."""
+        entries = self._http.get_json(f"{META_BASE}/versions/loader/{self.version}")
+        for entry in entries:
+            loader = (entry or {}).get("loader", {})
+            if loader.get("stable"):
+                return loader["version"]
+        if entries:
+            return entries[0]["loader"]["version"]
+        raise RuntimeError(f"Fabric 不支持 Minecraft {self.version}")
+
+    def latest_installer_version(self) -> str:
+        """Latest stable fabric-installer version."""
+        entries = self._http.get_json(f"{META_BASE}/versions/installer")
+        for entry in entries:
+            if entry.get("stable"):
+                return entry["version"]
+        return entries[0]["version"]
+
+
+def _coordinate_path(name: str) -> str:
+    """Map maven coordinates ``group:artifact:version[:classifier]`` to a jar path."""
+    parts = name.split(":")
+    if len(parts) == 3:
+        group, artifact, version = parts
+        classifier = ""
+    elif len(parts) == 4:
+        group, artifact, version, classifier = parts
+    else:
+        return name.replace(":", "/") + ".jar"
+    base = f"{artifact}-{version}"
+    if classifier:
+        base += f"-{classifier}"
+    return f"{group.replace('.', '/')}/{artifact}/{version}/{base}.jar"
+
+
+def _main_class(config: dict[str, Any]) -> str | None:
+    main_class = config.get("mainClass")
+    if isinstance(main_class, str):
+        return main_class
+    if isinstance(main_class, dict):
+        return main_class.get("client") or main_class.get("server")
+    return None

orzmc/core/forge.py

@@ -0,0 +1,44 @@
+"""Forge version resolution & installer helpers (Maven API — no HTML scraping).
+
+The download page's own data source, ``promotions_slim.json``, maps a Minecraft
+version to its recommended/latest Forge build. Everything else comes from the
+Forge Maven repository, and the client launch definition (``version.json``) is
+extracted from the installer jar it is shipped inside. Shared by the client and
+server Forge providers.
+"""
+
+from __future__ import annotations
+
+import json
+import zipfile
+from typing import Any
+
+from orzmc.infra.http import HttpClient
+
+PROMOTIONS_URL = "https://files.minecraftforge.net/maven/net/minecraftforge/forge/promotions_slim.json"
+MAVEN_BASE = "https://maven.minecraftforge.net/net/minecraftforge/forge"
+
+
+class Forge:
+    """Resolve the Forge version for a MC version and locate installer artifacts."""
+
+    def __init__(self, http: HttpClient) -> None:
+        self._http = http
+
+    def latest_full_version(self, mc_version: str) -> str:
+        """``<mc>-<build>`` (e.g. ``1.20.4-49.2.8``) for ``mc_version``."""
+        promos = self._http.get_json(PROMOTIONS_URL).get("promos") or {}
+        for key in (f"{mc_version}-latest", f"{mc_version}-recommended"):
+            build = promos.get(key)
+            if build:
+                return f"{mc_version}-{build}"
+        raise RuntimeError(f"未找到 Minecraft {mc_version} 的 Forge 版本")
+
+    def installer_url(self, full_version: str) -> str:
+        return f"{MAVEN_BASE}/{full_version}/forge-{full_version}-installer.jar"
+
+
+def extract_version_json(installer_path: str) -> dict[str, Any]:
+    """Read the ``version.json`` embedded in a Forge installer jar."""
+    with zipfile.ZipFile(installer_path) as zf, zf.open("version.json") as f:
+        return json.load(f)