orzmc 2.0.0__tar.gz

orzmc-2.0.0/.gitignore

@@ -0,0 +1,177 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+.DS_Store
+.vscode/
+
+# uv
+.venv/
+
+# pytest
+.pytest_cache/
+
+# PyInstaller build dir (scripts/build.py)
+.pybuild/
+
+# runtime artifacts (managed under game root, not repo)
+java/

orzmc-2.0.0/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.5
+Name: orzmc
+Version: 2.0.0
+Summary: OrzMC core library: bootstrap Minecraft client/server, manage a sandboxed Java runtime and multiple game versions
+Author: OrzMC
+License: MIT
+Keywords: cli,java,launcher,minecraft,server
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Games/Entertainment
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: requests>=2.31
+Requires-Dist: rich>=13.7
+Description-Content-Type: text/markdown
+
+# orzmc
+
+OrzMC core library: bootstrap Minecraft client / server, manage a sandboxed Java
+runtime and multiple game versions. Framework-free, reusable, independently
+published to PyPI.
+
+```python
+from orzmc import GameType, RuntimeOptions, launch_client
+
+opts = RuntimeOptions(is_client=True, version="1.20.4", game_type="vanilla")
+launch_client(opts)
+```
+
+See the [project README](../README.md) for full documentation.

orzmc-2.0.0/README.md

@@ -0,0 +1,14 @@
+# orzmc
+
+OrzMC core library: bootstrap Minecraft client / server, manage a sandboxed Java
+runtime and multiple game versions. Framework-free, reusable, independently
+published to PyPI.
+
+```python
+from orzmc import GameType, RuntimeOptions, launch_client
+
+opts = RuntimeOptions(is_client=True, version="1.20.4", game_type="vanilla")
+launch_client(opts)
+```
+
+See the [project README](../README.md) for full documentation.

orzmc-2.0.0/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-2.0.0/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-2.0.0/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-2.0.0/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-2.0.0/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-2.0.0/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())