levistone 0.9.3__cp311-cp311-win_amd64.whl → 0.10.6__cp311-cp311-win_amd64.whl

endstone/__init__.py

@@ -12,7 +12,7 @@ from endstone._internal.endstone_python import (
 )
 from endstone._internal.version import __version__
 
-__minecraft_version__ = "1.21.93"
+__minecraft_version__ = "1.21.111"
 
 __all__ = [
     "__version__",

endstone/_internal/bootstrap/base.py

@@ -16,6 +16,7 @@ import click
 import importlib_resources
 import requests
 import sentry_crashpad
+import tomlkit
 from packaging.version import Version
 from rich.progress import BarColumn, DownloadColumn, Progress, TextColumn, TimeRemainingColumn
 
@@ -161,6 +162,28 @@ class Bootstrap:
             ref = importlib_resources.files("endstone") / "config" / "endstone.toml"
             with importlib_resources.as_file(ref) as path:
                 shutil.copy(path, self.config_path)
+        else:
+            ref = importlib_resources.files("endstone") / "config" / "endstone.toml"
+            with importlib_resources.as_file(ref) as path:
+                with open(path, "r", encoding="utf-8") as f:
+                    default_config = tomlkit.load(f)
+
+            with open(self.config_path, "r", encoding="utf-8") as f:
+                config = tomlkit.load(f)
+
+            def migrate_config(from_doc: tomlkit.TOMLDocument, to_doc: tomlkit.TOMLDocument) -> None:
+                for key, val in from_doc.items():
+                    if key not in to_doc:
+                        # if the user hasn’t set it, copy it (with comments!)
+                        to_doc[key] = val
+                    else:
+                        # if both are tables, dive deeper
+                        if isinstance(val, tomlkit.TOMLDocument) and isinstance(to_doc[key], tomlkit.TOMLDocument):
+                            migrate_config(val, to_doc[key])
+
+            migrate_config(default_config, config)
+            with open(self.config_path, "w", encoding="utf-8") as f:
+                tomlkit.dump(config, f)
 
     def _install(self) -> None:
         """

endstone/_internal/bootstrap/linux.py

@@ -2,7 +2,6 @@ import ctypes.util
 import os
 import stat
 import subprocess
-import sys
 from pathlib import Path
 
 from endstone._internal.bootstrap.base import Bootstrap
@@ -41,9 +40,6 @@ class LinuxBootstrap(Bootstrap):
     def _run(self, *args, **kwargs) -> int:
         process = subprocess.Popen(
             [str(self.executable_path.absolute())],
-            stdin=sys.stdin,
-            stdout=sys.stdout,
-            stderr=subprocess.STDOUT,
             text=True,
             encoding="utf-8",
             cwd=str(self.server_path.absolute()),

endstone/_internal/bootstrap/windows.py

@@ -1,9 +1,128 @@
+import _winapi
 import ctypes
 import os
 import subprocess
+import warnings
+from subprocess import STARTUPINFO, Handle, list2cmdline
 
+from endstone._internal import _detours
 from endstone._internal.bootstrap.base import Bootstrap
-from endstone._internal.winext import start_process_with_dll
+
+
+class PopenWithDll(subprocess.Popen):
+    def __init__(self, *args, **kwargs):
+        self.dll_names = kwargs.pop("dll_names", None)
+        super().__init__(*args, **kwargs)
+
+    def _execute_child(
+        self,
+        args,
+        executable,
+        preexec_fn,
+        close_fds,
+        pass_fds,
+        cwd,
+        env,
+        startupinfo,
+        creationflags,
+        shell,
+        p2cread,
+        p2cwrite,
+        c2pread,
+        c2pwrite,
+        errread,
+        errwrite,
+        unused_restore_signals,
+        unused_gid,
+        unused_gids,
+        unused_uid,
+        unused_umask,
+        unused_start_new_session,
+        unused_process_group,
+    ):
+        """Execute program (MS Windows version)"""
+
+        assert not pass_fds, "pass_fds not supported on Windows."
+
+        if isinstance(args, str):
+            pass
+        elif isinstance(args, bytes):
+            if shell:
+                raise TypeError("bytes args is not allowed on Windows")
+            args = list2cmdline([args])
+        elif isinstance(args, os.PathLike):
+            if shell:
+                raise TypeError("path-like args is not allowed when shell is true")
+            args = list2cmdline([args])
+        else:
+            args = list2cmdline(args)
+
+        if executable is not None:
+            executable = os.fsdecode(executable)
+
+        if startupinfo is None:
+            startupinfo = STARTUPINFO()
+        else:
+            startupinfo = startupinfo.copy()
+
+        use_std_handles = -1 not in (p2cread, c2pwrite, errwrite)
+        if use_std_handles:
+            startupinfo.dwFlags |= _winapi.STARTF_USESTDHANDLES
+            startupinfo.hStdInput = p2cread
+            startupinfo.hStdOutput = c2pwrite
+            startupinfo.hStdError = errwrite
+
+        attribute_list = startupinfo.lpAttributeList
+        have_handle_list = bool(attribute_list and "handle_list" in attribute_list and attribute_list["handle_list"])
+
+        # If we were given an handle_list or need to create one
+        if have_handle_list or (use_std_handles and close_fds):
+            if attribute_list is None:
+                attribute_list = startupinfo.lpAttributeList = {}
+            handle_list = attribute_list["handle_list"] = list(attribute_list.get("handle_list", []))
+
+            if use_std_handles:
+                handle_list += [int(p2cread), int(c2pwrite), int(errwrite)]
+
+            handle_list[:] = self._filter_handle_list(handle_list)
+
+            if handle_list:
+                if not close_fds:
+                    warnings.warn("startupinfo.lpAttributeList['handle_list'] overriding close_fds", RuntimeWarning)
+
+                # When using the handle_list we always request to inherit
+                # handles but the only handles that will be inherited are
+                # the ones in the handle_list
+                close_fds = False
+
+        assert not shell
+
+        if cwd is not None:
+            cwd = os.fsdecode(cwd)
+
+        # Start the process
+        try:
+            hp, ht, pid, tid = _detours.CreateProcessWithDllEx(
+                executable,
+                args,
+                # no special security
+                None,
+                None,
+                not close_fds,
+                creationflags,
+                env,
+                cwd,
+                startupinfo,
+                dll_name=self.dll_names,
+            )
+        finally:
+            self._close_pipe_fds(p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite)
+
+        # Retain the process handle, but close the thread handle
+        self._child_created = True
+        self._handle = Handle(hp)
+        self.pid = pid
+        _winapi.CloseHandle(ht)
 
 
 class WindowsBootstrap(Bootstrap):
@@ -35,7 +154,7 @@ class WindowsBootstrap(Bootstrap):
         env["_NT_SYMBOL_PATH"] = os.pathsep.join(symbol_path_list)
         return env
 
-    def _add_loopback_exemption(self) -> bool:
+    def _add_loopback_exemption(self) -> None:
         sid = "S-1-15-2-1958404141-86561845-1752920682-3514627264-368642714-62675701-733520436"
         ret = subprocess.run(
             ["CheckNetIsolation", "LoopbackExempt", "-s", f"-p={sid}"], check=True, capture_output=True
@@ -44,16 +163,25 @@ class WindowsBootstrap(Bootstrap):
             ret = ctypes.windll.shell32.ShellExecuteW(
                 None, "runas", "CheckNetIsolation", " ".join(["LoopbackExempt", "-a", f"-p={sid}"]), None, 1
             )
-            return ret > 32
-        else:
-            return True
+            if ret <= 32:
+                raise RuntimeError(f"CheckNetIsolation LoopbackExempt -a failed with exit code {ret}.")
 
     def _run(self, *args, **kwargs) -> int:
-        self._add_loopback_exemption()
+        try:
+            self._add_loopback_exemption()
+        except Exception as e:
+            self._logger.warning(
+                f"Unable to add loopback exemption: %s. See bedrock_server_how_to.html for more details. {e}"
+            )
 
-        return start_process_with_dll(
-            str(self.executable_path.absolute()),
-            str(self._endstone_runtime_path.absolute()),
+        process = PopenWithDll(
+            [str(self.executable_path.absolute())],
+            text=True,
+            encoding="utf-8",
             cwd=str(self.server_path.absolute()),
             env=self._endstone_runtime_env,
+            dll_names=str(self._endstone_runtime_path.absolute()),
+            *args,
+            **kwargs,
         )
+        return process.wait()