Bundle portable Temurin Java for ZeroGPU

minecraft_stack.py

@@ -1,459 +1,482 @@
-from __future__ import annotations
-
-import hashlib
-import json
-import os
-import re
-import shutil
-import socket
-import subprocess
-import tarfile
-import threading
-import time
-import urllib.request
-from pathlib import Path
-from typing import Any
-
-import yaml
-
-BASE = Path(os.environ.get("MINECRAFT_HOME", "/tmp/minecraft-stack"))
-JAVA_DIR = BASE / "java"
-VIA_DIR = BASE / "viaproxy"
-RELAY_DIR = BASE / "relay"
-TOOLS_DIR = BASE / "tools"
-BIN_DIR = BASE / "bin"
-LOG_PATH = BASE / "stack.log"
-
-FABRIC_INSTALLER_URL = "https://maven.fabricmc.net/net/fabricmc/fabric-installer/0.11.2/fabric-installer-0.11.2.jar"
-FABRIC_MC_VERSION = "1.19"
-FABRIC_LOADER_VERSION = "0.14.18"
-
-VIAPROXY_URL = "https://github.com/ViaVersion/ViaProxy/releases/download/v3.4.13/ViaProxy-3.4.13.jar"
-VIAPROXY_SHA256 = "4bbb6a6b9d3dd6a2028773ed44b97a98751e4a48e416aaad4bf6d9c860083be9"
-
-GEYSER_URL = "https://download.geysermc.org/v2/projects/geyser/versions/2.11.3/builds/1247/downloads/viaproxy"
-GEYSER_SHA256 = "85eea53e7fe58e4d97c2144a9d061577d37f619ab635227b68a948aa62d22924"
-
-GO_URL = "https://go.dev/dl/go1.25.14.linux-amd64.tar.gz"
-GO_SHA256 = "a21ae5633a269bcd7e90cf767e48225633795e99d831742cbf3397064fee7712"
-
-BEDROCK_PROTOCOL = int(os.environ.get("BEDROCK_PROTOCOL", "2193"))
-BEDROCK_VERSION = os.environ.get("BEDROCK_VERSION", "1.26.51")
-WORLD_NAME = os.environ.get("MINECRAFT_WORLD_NAME", "Voyager AI World")
-HOST_NAME = os.environ.get("MINECRAFT_HOST_NAME", "Voyager AI")
-
-
-def _mkdirs() -> None:
-    for path in (BASE, JAVA_DIR, VIA_DIR, RELAY_DIR, TOOLS_DIR, BIN_DIR):
-        path.mkdir(parents=True, exist_ok=True)
-
-
-def _log(message: str) -> None:
-    _mkdirs()
-    line = f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] {message}"
-    print(line, flush=True)
-    with LOG_PATH.open("a", encoding="utf-8", errors="replace") as fh:
-        fh.write(line + "\n")
-
-
-def _sha256(path: Path) -> str:
-    h = hashlib.sha256()
-    with path.open("rb") as fh:
-        for chunk in iter(lambda: fh.read(1024 * 1024), b""):
-            h.update(chunk)
-    return h.hexdigest()
-
-
-def _download(url: str, path: Path, sha256: str | None = None) -> Path:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    if path.exists() and (not sha256 or _sha256(path) == sha256):
-        return path
-    tmp = path.with_suffix(path.suffix + ".part")
-    tmp.unlink(missing_ok=True)
-    req = urllib.request.Request(url, headers={"User-Agent": "minecraft-friends-ai-zerogpu/1.0"})
-    _log(f"download {url}")
-    with urllib.request.urlopen(req, timeout=120) as response, tmp.open("wb") as out:
-        shutil.copyfileobj(response, out)
-    if sha256 and _sha256(tmp) != sha256:
-        tmp.unlink(missing_ok=True)
-        raise RuntimeError(f"SHA256 mismatch for {url}")
-    tmp.replace(path)
-    return path
-
-
-def _wait_tcp(host: str, port: int, timeout: float) -> bool:
-    deadline = time.time() + timeout
-    while time.time() < deadline:
-        try:
-            with socket.create_connection((host, port), timeout=1):
-                return True
-        except OSError:
-            time.sleep(1)
-    return False
-
-
-def _run_capture(args: list[str], cwd: Path, timeout: int = 300, env: dict[str, str] | None = None) -> str:
-    _log("exec " + " ".join(args))
-    proc = subprocess.run(
-        args,
-        cwd=str(cwd),
-        env=env,
-        text=True,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.STDOUT,
-        timeout=timeout,
-        check=False,
-    )
-    output = proc.stdout or ""
-    for line in output.splitlines()[-80:]:
-        _log("setup> " + line)
-    if proc.returncode != 0:
-        raise RuntimeError(f"command failed rc={proc.returncode}: {' '.join(args)}")
-    return output
-
-
-def _patch_scalar(text: str, key: str, value: str) -> str:
-    pattern = rf"(?m)^(\s*{re.escape(key)}:\s*).*$"
-    if re.search(pattern, text):
-        return re.sub(pattern, lambda m: m.group(1) + value, text, count=1)
-    return text + f"\n{key}: {value}\n"
-
-
-class MinecraftStack:
-    def __init__(self) -> None:
-        self.lock = threading.RLock()
-        self.worker: threading.Thread | None = None
-        self.processes: dict[str, subprocess.Popen[str]] = {}
-        self.state = "stopped"
-        self.error = ""
-        self.started_at: float | None = None
-
-    def _pump(self, name: str, proc: subprocess.Popen[str]) -> None:
-        assert proc.stdout is not None
-        try:
-            for line in proc.stdout:
-                _log(f"{name}> {line.rstrip()}")
-        except Exception as exc:
-            _log(f"{name} log pump error: {exc!r}")
-
-    def _spawn(self, name: str, args: list[str], cwd: Path, env: dict[str, str] | None = None) -> subprocess.Popen[str]:
-        _log(f"start {name}: {' '.join(args)}")
-        proc = subprocess.Popen(
-            args,
-            cwd=str(cwd),
-            env=env,
-            stdin=subprocess.PIPE,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,
-            text=True,
-            bufsize=1,
-        )
-        self.processes[name] = proc
-        threading.Thread(target=self._pump, args=(name, proc), daemon=True, name=f"log-{name}").start()
-        return proc
-
-    def _stop_process(self, name: str) -> None:
-        proc = self.processes.get(name)
-        if not proc or proc.poll() is not None:
-            return
-        try:
-            if name == "minecraft" and proc.stdin:
-                proc.stdin.write("stop\n")
-                proc.stdin.flush()
-                proc.wait(timeout=20)
-                return
-        except Exception:
-            pass
-        try:
-            proc.terminate()
-            proc.wait(timeout=12)
-        except Exception:
-            try:
-                proc.kill()
-            except Exception:
-                pass
-
-    def _ensure_fabric(self) -> Path:
-        installer = _download(FABRIC_INSTALLER_URL, TOOLS_DIR / "fabric-installer-0.11.2.jar")
-        JAVA_DIR.mkdir(parents=True, exist_ok=True)
-        launcher = JAVA_DIR / "fabric-server-launch.jar"
-        if not launcher.exists():
-            _run_capture(
-                [
-                    "java", "-jar", str(installer), "server",
-                    "-mcversion", FABRIC_MC_VERSION,
-                    "-loader", FABRIC_LOADER_VERSION,
-                    "-downloadMinecraft",
-                    "-dir", str(JAVA_DIR),
-                ],
-                JAVA_DIR,
-                timeout=300,
-            )
-        (JAVA_DIR / "eula.txt").write_text("eula=true\n", encoding="utf-8")
-        props = {
-            "server-ip": "127.0.0.1",
-            "server-port": "25565",
-            "online-mode": "false",
-            "enforce-secure-profile": "false",
-            "enable-command-block": "true",
-            "spawn-protection": "0",
-            "allow-flight": "true",
-            "gamemode": "survival",
-            "force-gamemode": "true",
-            "difficulty": "peaceful",
-            "max-players": "10",
-            "view-distance": "8",
-            "simulation-distance": "6",
-            "level-name": "world",
-            "motd": "Voyager AI + Bedrock Friends",
-        }
-        (JAVA_DIR / "server.properties").write_text(
-            "\n".join(f"{k}={v}" for k, v in props.items()) + "\n",
-            encoding="utf-8",
-        )
-        return launcher
-
-    def _start_fabric(self) -> None:
-        launcher = self._ensure_fabric()
-        proc = self._spawn(
-            "minecraft",
-            ["java", "-Xms1G", "-Xmx8G", "-jar", str(launcher), "nogui"],
-            JAVA_DIR,
-        )
-        if not _wait_tcp("127.0.0.1", 25565, 120):
-            raise RuntimeError("Minecraft Java 1.19 did not open 127.0.0.1:25565")
-        time.sleep(2)
-        if proc.stdin:
-            for cmd in (
-                "op bot",
-                "gamerule keepInventory true",
-                "gamerule doDaylightCycle false",
-                "difficulty peaceful",
-            ):
-                proc.stdin.write(cmd + "\n")
-            proc.stdin.flush()
-        _log("Minecraft Java 1.19/Fabric ready on 127.0.0.1:25565")
-
-    def _ensure_viaproxy(self) -> tuple[Path, Path]:
-        jar = _download(VIAPROXY_URL, VIA_DIR / "ViaProxy-3.4.13.jar", VIAPROXY_SHA256)
-        plugin_dir = VIA_DIR / "plugins"
-        plugin_dir.mkdir(parents=True, exist_ok=True)
-        _download(GEYSER_URL, plugin_dir / "Geyser-ViaProxy.jar", GEYSER_SHA256)
-        cfg = VIA_DIR / "viaproxy.yml"
-        if not cfg.exists():
-            proc = subprocess.Popen(
-                ["java", "-jar", str(jar), "config", str(cfg)],
-                cwd=str(VIA_DIR),
-                stdout=subprocess.PIPE,
-                stderr=subprocess.STDOUT,
-                text=True,
-            )
-            deadline = time.time() + 25
-            while time.time() < deadline and not cfg.exists() and proc.poll() is None:
-                time.sleep(1)
-            if proc.poll() is None:
-                proc.terminate()
-                try:
-                    proc.wait(timeout=8)
-                except Exception:
-                    proc.kill()
-            if not cfg.exists():
-                raise RuntimeError("ViaProxy did not generate viaproxy.yml")
-        text = cfg.read_text(encoding="utf-8", errors="replace")
-        text = _patch_scalar(text, "bind-address", "127.0.0.1:25568")
-        text = _patch_scalar(text, "target-address", "127.0.0.1:25565")
-        text = _patch_scalar(text, "proxy-online-mode", "false")
-        text = _patch_scalar(text, "auth-method", "none")
-        cfg.write_text(text, encoding="utf-8")
-        return jar, cfg
-
-    def _patch_geyser(self, path: Path) -> None:
-        data: dict[str, Any] = yaml.safe_load(path.read_text(encoding="utf-8")) or {}
-        bedrock = data.setdefault("bedrock", {})
-        bedrock["address"] = "127.0.0.1"
-        bedrock["port"] = 19132
-        bedrock["clone-remote-port"] = False
-        java = data.setdefault("java", {})
-        java["auth-type"] = "offline"
-        advanced = data.setdefault("advanced", {})
-        adv_bedrock = advanced.setdefault("bedrock", {})
-        adv_bedrock["broadcast-port"] = 19132
-        adv_bedrock["validate-bedrock-login"] = False
-        data["debug-mode"] = False
-        path.write_text(yaml.safe_dump(data, sort_keys=False), encoding="utf-8")
-        _log("Geyser configured loopback-only; Xbox/NetherNet relay remains the auth boundary")
-
-    def _start_viaproxy(self) -> None:
-        jar, cfg = self._ensure_viaproxy()
-        geyser_cfg = VIA_DIR / "plugins" / "Geyser" / "config.yml"
-        if not geyser_cfg.exists():
-            proc = self._spawn("viaproxy-bootstrap", ["java", "-jar", str(jar), "config", str(cfg)], VIA_DIR)
-            deadline = time.time() + 35
-            while time.time() < deadline and not geyser_cfg.exists() and proc.poll() is None:
-                time.sleep(1)
-            self._stop_process("viaproxy-bootstrap")
-            if not geyser_cfg.exists():
-                raise RuntimeError("Geyser-ViaProxy did not generate plugins/Geyser/config.yml")
-        self._patch_geyser(geyser_cfg)
-        proc = self._spawn("viaproxy", ["java", "-jar", str(jar), "config", str(cfg)], VIA_DIR)
-        time.sleep(12)
-        if proc.poll() is not None:
-            raise RuntimeError(f"ViaProxy/Geyser exited rc={proc.returncode}")
-        _log("ViaProxy + Geyser running; Bedrock backend is 127.0.0.1:19132")
-
-    def _ensure_go(self) -> Path:
-        go = TOOLS_DIR / "go" / "bin" / "go"
-        if go.exists():
-            return go
-        archive = _download(GO_URL, TOOLS_DIR / "go1.25.14.linux-amd64.tar.gz", GO_SHA256)
-        target = TOOLS_DIR / "go"
-        if target.exists():
-            shutil.rmtree(target)
-        with tarfile.open(archive, "r:gz") as tf:
-            tf.extractall(TOOLS_DIR)
-        if not go.exists():
-            raise RuntimeError("Go toolchain extraction failed")
-        return go
-
-    def _ensure_nether2rak(self) -> Path:
-        binary = BIN_DIR / "nether2rak"
-        if binary.exists():
-            return binary
-        go = self._ensure_go()
-        src = Path("/app/third_party/nether2rak")
-        if not src.exists():
-            src = Path(__file__).resolve().parent / "third_party" / "nether2rak"
-        if not src.exists():
-            raise RuntimeError("Vendored nether2rak source is missing")
-        env = os.environ.copy()
-        env.update(
-            {
-                "PATH": f"{go.parent}:{env.get('PATH', '')}",
-                "GOTOOLCHAIN": "local",
-                "GOCACHE": str(BASE / "go-cache"),
-                "GOMODCACHE": str(BASE / "go-mod-cache"),
-                "CGO_ENABLED": "0",
-            }
-        )
-        _run_capture([str(go), "build", "-trimpath", "-o", str(binary), "."], src, timeout=900, env=env)
-        binary.chmod(0o755)
-        return binary
-
-    def _write_relay_config(self) -> Path:
-        cfg = {
-            "backend_transport": "raknet",
-            "geyser_address": "127.0.0.1:19132",
-            "nethernet_backend_address": "http://127.0.0.1:19134",
-            "host_name": HOST_NAME,
-            "world_name": WORLD_NAME,
-            "max_players": 10,
-            "fake_player_count": 0,
-            "protocol": BEDROCK_PROTOCOL,
-            "version": BEDROCK_VERSION,
-            "update_interval_seconds": 30,
-            "allowed_xuids": [],
-            "compression": "snappy",
-            "compression_threshold": 256,
-            "fix_native_bds_persistence": False,
-            "disable_client_encryption": False,
-            "relay_direct_ip": False,
-            "relay_direct_ip_listen_address": ":19134",
-            "invite_port": 7782,
-            "ping_port": 7777,
-            "pprof_port": 6060,
-            "extra_broadcasts": [],
-        }
-        path = RELAY_DIR / "config.json"
-        path.write_text(json.dumps(cfg, indent=2), encoding="utf-8")
-        return path
-
-    def _start_relay(self) -> None:
-        binary = self._ensure_nether2rak()
-        self._write_relay_config()
-        proc = self._spawn("friends", [str(binary)], RELAY_DIR)
-        time.sleep(4)
-        if proc.poll() is not None:
-            raise RuntimeError(f"Xbox Friends relay exited rc={proc.returncode}")
-        _log("Xbox Friends relay started; Microsoft device-code login may be required")
-
-    def _boot(self) -> None:
-        with self.lock:
-            self.state = "starting"
-            self.error = ""
-            self.started_at = time.time()
-        try:
-            _mkdirs()
-            _log("=== Minecraft stack bootstrap ===")
-            self._start_fabric()
-            self._start_viaproxy()
-            self._start_relay()
-            with self.lock:
-                self.state = "running"
-            _log("=== Minecraft stack running ===")
-        except Exception as exc:
-            with self.lock:
-                self.state = "error"
-                self.error = repr(exc)
-            _log(f"STACK ERROR: {exc!r}")
-
-    def start_async(self) -> dict[str, Any]:
-        with self.lock:
-            if self.worker and self.worker.is_alive():
-                return self.status()
-            if any(p.poll() is None for p in self.processes.values()) and self.state == "running":
-                return self.status()
-            self.worker = threading.Thread(target=self._boot, daemon=True, name="minecraft-stack")
-            self.worker.start()
-        return self.status()
-
-    def stop(self) -> dict[str, Any]:
-        with self.lock:
-            for name in ("friends", "viaproxy", "viaproxy-bootstrap", "minecraft"):
-                self._stop_process(name)
-            self.state = "stopped"
-        _log("Minecraft stack stopped")
-        return self.status()
-
-    def tail(self, lines: int = 160) -> str:
-        if not LOG_PATH.exists():
-            return "Sem logs do Minecraft ainda."
-        items = LOG_PATH.read_text(encoding="utf-8", errors="replace").splitlines()
-        return "\n".join(items[-max(10, min(lines, 500)):])
-
-    def status(self) -> dict[str, Any]:
-        with self.lock:
-            processes = {
-                name: {"pid": proc.pid, "running": proc.poll() is None, "returncode": proc.poll()}
-                for name, proc in self.processes.items()
-            }
-            log = self.tail(120)
-            login_url = None
-            device_code = None
-            url_match = re.findall(r"https://(?:www\.)?microsoft\.com/link", log, flags=re.I)
-            if url_match:
-                login_url = url_match[-1]
-            for pattern in (
-                r"(?:code|c[oó]digo)\s*[:=]\s*([A-Z0-9-]{6,16})",
-                r"enter\s+([A-Z0-9-]{6,16})\s+(?:to|at)",
-            ):
-                found = re.findall(pattern, log, flags=re.I)
-                if found:
-                    device_code = found[-1].upper()
-                    break
-            return {
-                "state": self.state,
-                "error": self.error or None,
-                "started_at": self.started_at,
-                "java_server": "127.0.0.1:25565",
-                "bedrock_backend": "127.0.0.1:19132",
-                "access": "Xbox/Microsoft Friends via NetherNet; no public UDP tunnel",
-                "bedrock_protocol": BEDROCK_PROTOCOL,
-                "bedrock_version": BEDROCK_VERSION,
-                "microsoft_login_url": login_url,
-                "microsoft_device_code": device_code,
-                "processes": processes,
-                "log_tail": log,
-            }
-
-
-STACK = MinecraftStack()
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import re
+import shutil
+import socket
+import subprocess
+import tarfile
+import threading
+import time
+import urllib.request
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+BASE = Path(os.environ.get("MINECRAFT_HOME", "/tmp/minecraft-stack"))
+JAVA_DIR = BASE / "java"
+VIA_DIR = BASE / "viaproxy"
+RELAY_DIR = BASE / "relay"
+TOOLS_DIR = BASE / "tools"
+BIN_DIR = BASE / "bin"
+LOG_PATH = BASE / "stack.log"
+
+FABRIC_INSTALLER_URL = "https://maven.fabricmc.net/net/fabricmc/fabric-installer/0.11.2/fabric-installer-0.11.2.jar"
+FABRIC_MC_VERSION = "1.19"
+FABRIC_LOADER_VERSION = "0.14.18"
+
+VIAPROXY_URL = "https://github.com/ViaVersion/ViaProxy/releases/download/v3.4.13/ViaProxy-3.4.13.jar"
+VIAPROXY_SHA256 = "4bbb6a6b9d3dd6a2028773ed44b97a98751e4a48e416aaad4bf6d9c860083be9"
+
+GEYSER_URL = "https://download.geysermc.org/v2/projects/geyser/versions/2.11.3/builds/1247/downloads/viaproxy"
+GEYSER_SHA256 = "85eea53e7fe58e4d97c2144a9d061577d37f619ab635227b68a948aa62d22924"
+
+GO_URL = "https://go.dev/dl/go1.25.14.linux-amd64.tar.gz"
+GO_SHA256 = "a21ae5633a269bcd7e90cf767e48225633795e99d831742cbf3397064fee7712"
+
+JAVA_URL = "https://github.com/adoptium/temurin21-binaries/releases/download/jdk-21.0.12.1%2B1/OpenJDK21U-jre_x64_linux_hotspot_21.0.12.1_1.tar.gz"
+JAVA_SHA256 = "2413149700df0f7d440500a84a8f764c535f21e5a5e87d38328b64eec2c5b500"
+
+BEDROCK_PROTOCOL = int(os.environ.get("BEDROCK_PROTOCOL", "2193"))
+BEDROCK_VERSION = os.environ.get("BEDROCK_VERSION", "1.26.51")
+WORLD_NAME = os.environ.get("MINECRAFT_WORLD_NAME", "Voyager AI World")
+HOST_NAME = os.environ.get("MINECRAFT_HOST_NAME", "Voyager AI")
+
+
+def _mkdirs() -> None:
+    for path in (BASE, JAVA_DIR, VIA_DIR, RELAY_DIR, TOOLS_DIR, BIN_DIR):
+        path.mkdir(parents=True, exist_ok=True)
+
+
+def _log(message: str) -> None:
+    _mkdirs()
+    line = f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] {message}"
+    print(line, flush=True)
+    with LOG_PATH.open("a", encoding="utf-8", errors="replace") as fh:
+        fh.write(line + "\n")
+
+
+def _sha256(path: Path) -> str:
+    h = hashlib.sha256()
+    with path.open("rb") as fh:
+        for chunk in iter(lambda: fh.read(1024 * 1024), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def _download(url: str, path: Path, sha256: str | None = None) -> Path:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if path.exists() and (not sha256 or _sha256(path) == sha256):
+        return path
+    tmp = path.with_suffix(path.suffix + ".part")
+    tmp.unlink(missing_ok=True)
+    req = urllib.request.Request(url, headers={"User-Agent": "minecraft-friends-ai-zerogpu/1.0"})
+    _log(f"download {url}")
+    with urllib.request.urlopen(req, timeout=120) as response, tmp.open("wb") as out:
+        shutil.copyfileobj(response, out)
+    if sha256 and _sha256(tmp) != sha256:
+        tmp.unlink(missing_ok=True)
+        raise RuntimeError(f"SHA256 mismatch for {url}")
+    tmp.replace(path)
+    return path
+
+
+def _wait_tcp(host: str, port: int, timeout: float) -> bool:
+    deadline = time.time() + timeout
+    while time.time() < deadline:
+        try:
+            with socket.create_connection((host, port), timeout=1):
+                return True
+        except OSError:
+            time.sleep(1)
+    return False
+
+
+def _run_capture(args: list[str], cwd: Path, timeout: int = 300, env: dict[str, str] | None = None) -> str:
+    _log("exec " + " ".join(args))
+    proc = subprocess.run(
+        args,
+        cwd=str(cwd),
+        env=env,
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        timeout=timeout,
+        check=False,
+    )
+    output = proc.stdout or ""
+    for line in output.splitlines()[-80:]:
+        _log("setup> " + line)
+    if proc.returncode != 0:
+        raise RuntimeError(f"command failed rc={proc.returncode}: {' '.join(args)}")
+    return output
+
+
+def _patch_scalar(text: str, key: str, value: str) -> str:
+    pattern = rf"(?m)^(\s*{re.escape(key)}:\s*).*$"
+    if re.search(pattern, text):
+        return re.sub(pattern, lambda m: m.group(1) + value, text, count=1)
+    return text + f"\n{key}: {value}\n"
+
+
+class MinecraftStack:
+    def __init__(self) -> None:
+        self.lock = threading.RLock()
+        self.worker: threading.Thread | None = None
+        self.processes: dict[str, subprocess.Popen[str]] = {}
+        self.state = "stopped"
+        self.error = ""
+        self.started_at: float | None = None
+
+    def _pump(self, name: str, proc: subprocess.Popen[str]) -> None:
+        assert proc.stdout is not None
+        try:
+            for line in proc.stdout:
+                _log(f"{name}> {line.rstrip()}")
+        except Exception as exc:
+            _log(f"{name} log pump error: {exc!r}")
+
+    def _spawn(self, name: str, args: list[str], cwd: Path, env: dict[str, str] | None = None) -> subprocess.Popen[str]:
+        _log(f"start {name}: {' '.join(args)}")
+        proc = subprocess.Popen(
+            args,
+            cwd=str(cwd),
+            env=env,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1,
+        )
+        self.processes[name] = proc
+        threading.Thread(target=self._pump, args=(name, proc), daemon=True, name=f"log-{name}").start()
+        return proc
+
+    def _stop_process(self, name: str) -> None:
+        proc = self.processes.get(name)
+        if not proc or proc.poll() is not None:
+            return
+        try:
+            if name == "minecraft" and proc.stdin:
+                proc.stdin.write("stop\n")
+                proc.stdin.flush()
+                proc.wait(timeout=20)
+                return
+        except Exception:
+            pass
+        try:
+            proc.terminate()
+            proc.wait(timeout=12)
+        except Exception:
+            try:
+                proc.kill()
+            except Exception:
+                pass
+
+    def _ensure_java(self) -> Path:
+        root = TOOLS_DIR / "jre21"
+        existing = list(root.glob("*/bin/java")) if root.exists() else []
+        if existing:
+            return existing[0]
+        archive = _download(JAVA_URL, TOOLS_DIR / "temurin21-jre.tar.gz", JAVA_SHA256)
+        if root.exists():
+            shutil.rmtree(root)
+        root.mkdir(parents=True, exist_ok=True)
+        with tarfile.open(archive, "r:gz") as tf:
+            tf.extractall(root)
+        found = list(root.glob("*/bin/java"))
+        if not found:
+            raise RuntimeError("Temurin JRE 21 extraction failed")
+        found[0].chmod(0o755)
+        version = _run_capture([str(found[0]), "-version"], BASE, timeout=30)
+        _log("portable Java ready: " + version.splitlines()[0])
+        return found[0]
+
+    def _ensure_fabric(self) -> Path:
+        java = self._ensure_java()
+        installer = _download(FABRIC_INSTALLER_URL, TOOLS_DIR / "fabric-installer-0.11.2.jar")
+        JAVA_DIR.mkdir(parents=True, exist_ok=True)
+        launcher = JAVA_DIR / "fabric-server-launch.jar"
+        if not launcher.exists():
+            _run_capture(
+                [
+                    str(java), "-jar", str(installer), "server",
+                    "-mcversion", FABRIC_MC_VERSION,
+                    "-loader", FABRIC_LOADER_VERSION,
+                    "-downloadMinecraft",
+                    "-dir", str(JAVA_DIR),
+                ],
+                JAVA_DIR,
+                timeout=300,
+            )
+        (JAVA_DIR / "eula.txt").write_text("eula=true\n", encoding="utf-8")
+        props = {
+            "server-ip": "127.0.0.1",
+            "server-port": "25565",
+            "online-mode": "false",
+            "enforce-secure-profile": "false",
+            "enable-command-block": "true",
+            "spawn-protection": "0",
+            "allow-flight": "true",
+            "gamemode": "survival",
+            "force-gamemode": "true",
+            "difficulty": "peaceful",
+            "max-players": "10",
+            "view-distance": "8",
+            "simulation-distance": "6",
+            "level-name": "world",
+            "motd": "Voyager AI + Bedrock Friends",
+        }
+        (JAVA_DIR / "server.properties").write_text(
+            "\n".join(f"{k}={v}" for k, v in props.items()) + "\n",
+            encoding="utf-8",
+        )
+        return launcher
+
+    def _start_fabric(self) -> None:
+        launcher = self._ensure_fabric()
+        proc = self._spawn(
+            "minecraft",
+            [str(self._ensure_java()), "-Xms1G", "-Xmx8G", "-jar", str(launcher), "nogui"],
+            JAVA_DIR,
+        )
+        if not _wait_tcp("127.0.0.1", 25565, 120):
+            raise RuntimeError("Minecraft Java 1.19 did not open 127.0.0.1:25565")
+        time.sleep(2)
+        if proc.stdin:
+            for cmd in (
+                "op bot",
+                "gamerule keepInventory true",
+                "gamerule doDaylightCycle false",
+                "difficulty peaceful",
+            ):
+                proc.stdin.write(cmd + "\n")
+            proc.stdin.flush()
+        _log("Minecraft Java 1.19/Fabric ready on 127.0.0.1:25565")
+
+    def _ensure_viaproxy(self) -> tuple[Path, Path]:
+        jar = _download(VIAPROXY_URL, VIA_DIR / "ViaProxy-3.4.13.jar", VIAPROXY_SHA256)
+        plugin_dir = VIA_DIR / "plugins"
+        plugin_dir.mkdir(parents=True, exist_ok=True)
+        _download(GEYSER_URL, plugin_dir / "Geyser-ViaProxy.jar", GEYSER_SHA256)
+        cfg = VIA_DIR / "viaproxy.yml"
+        if not cfg.exists():
+            proc = subprocess.Popen(
+                [str(self._ensure_java()), "-jar", str(jar), "config", str(cfg)],
+                cwd=str(VIA_DIR),
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True,
+            )
+            deadline = time.time() + 25
+            while time.time() < deadline and not cfg.exists() and proc.poll() is None:
+                time.sleep(1)
+            if proc.poll() is None:
+                proc.terminate()
+                try:
+                    proc.wait(timeout=8)
+                except Exception:
+                    proc.kill()
+            if not cfg.exists():
+                raise RuntimeError("ViaProxy did not generate viaproxy.yml")
+        text = cfg.read_text(encoding="utf-8", errors="replace")
+        text = _patch_scalar(text, "bind-address", "127.0.0.1:25568")
+        text = _patch_scalar(text, "target-address", "127.0.0.1:25565")
+        text = _patch_scalar(text, "proxy-online-mode", "false")
+        text = _patch_scalar(text, "auth-method", "none")
+        cfg.write_text(text, encoding="utf-8")
+        return jar, cfg
+
+    def _patch_geyser(self, path: Path) -> None:
+        data: dict[str, Any] = yaml.safe_load(path.read_text(encoding="utf-8")) or {}
+        bedrock = data.setdefault("bedrock", {})
+        bedrock["address"] = "127.0.0.1"
+        bedrock["port"] = 19132
+        bedrock["clone-remote-port"] = False
+        java = data.setdefault("java", {})
+        java["auth-type"] = "offline"
+        advanced = data.setdefault("advanced", {})
+        adv_bedrock = advanced.setdefault("bedrock", {})
+        adv_bedrock["broadcast-port"] = 19132
+        adv_bedrock["validate-bedrock-login"] = False
+        data["debug-mode"] = False
+        path.write_text(yaml.safe_dump(data, sort_keys=False), encoding="utf-8")
+        _log("Geyser configured loopback-only; Xbox/NetherNet relay remains the auth boundary")
+
+    def _start_viaproxy(self) -> None:
+        jar, cfg = self._ensure_viaproxy()
+        geyser_cfg = VIA_DIR / "plugins" / "Geyser" / "config.yml"
+        if not geyser_cfg.exists():
+            proc = self._spawn("viaproxy-bootstrap", [str(self._ensure_java()), "-jar", str(jar), "config", str(cfg)], VIA_DIR)
+            deadline = time.time() + 35
+            while time.time() < deadline and not geyser_cfg.exists() and proc.poll() is None:
+                time.sleep(1)
+            self._stop_process("viaproxy-bootstrap")
+            if not geyser_cfg.exists():
+                raise RuntimeError("Geyser-ViaProxy did not generate plugins/Geyser/config.yml")
+        self._patch_geyser(geyser_cfg)
+        proc = self._spawn("viaproxy", [str(self._ensure_java()), "-jar", str(jar), "config", str(cfg)], VIA_DIR)
+        time.sleep(12)
+        if proc.poll() is not None:
+            raise RuntimeError(f"ViaProxy/Geyser exited rc={proc.returncode}")
+        _log("ViaProxy + Geyser running; Bedrock backend is 127.0.0.1:19132")
+
+    def _ensure_go(self) -> Path:
+        go = TOOLS_DIR / "go" / "bin" / "go"
+        if go.exists():
+            return go
+        archive = _download(GO_URL, TOOLS_DIR / "go1.25.14.linux-amd64.tar.gz", GO_SHA256)
+        target = TOOLS_DIR / "go"
+        if target.exists():
+            shutil.rmtree(target)
+        with tarfile.open(archive, "r:gz") as tf:
+            tf.extractall(TOOLS_DIR)
+        if not go.exists():
+            raise RuntimeError("Go toolchain extraction failed")
+        return go
+
+    def _ensure_nether2rak(self) -> Path:
+        binary = BIN_DIR / "nether2rak"
+        if binary.exists():
+            return binary
+        go = self._ensure_go()
+        src = Path("/app/third_party/nether2rak")
+        if not src.exists():
+            src = Path(__file__).resolve().parent / "third_party" / "nether2rak"
+        if not src.exists():
+            raise RuntimeError("Vendored nether2rak source is missing")
+        env = os.environ.copy()
+        env.update(
+            {
+                "PATH": f"{go.parent}:{env.get('PATH', '')}",
+                "GOTOOLCHAIN": "local",
+                "GOCACHE": str(BASE / "go-cache"),
+                "GOMODCACHE": str(BASE / "go-mod-cache"),
+                "CGO_ENABLED": "0",
+            }
+        )
+        _run_capture([str(go), "build", "-trimpath", "-o", str(binary), "."], src, timeout=900, env=env)
+        binary.chmod(0o755)
+        return binary
+
+    def _write_relay_config(self) -> Path:
+        cfg = {
+            "backend_transport": "raknet",
+            "geyser_address": "127.0.0.1:19132",
+            "nethernet_backend_address": "http://127.0.0.1:19134",
+            "host_name": HOST_NAME,
+            "world_name": WORLD_NAME,
+            "max_players": 10,
+            "fake_player_count": 0,
+            "protocol": BEDROCK_PROTOCOL,
+            "version": BEDROCK_VERSION,
+            "update_interval_seconds": 30,
+            "allowed_xuids": [],
+            "compression": "snappy",
+            "compression_threshold": 256,
+            "fix_native_bds_persistence": False,
+            "disable_client_encryption": False,
+            "relay_direct_ip": False,
+            "relay_direct_ip_listen_address": ":19134",
+            "invite_port": 7782,
+            "ping_port": 7777,
+            "pprof_port": 6060,
+            "extra_broadcasts": [],
+        }
+        path = RELAY_DIR / "config.json"
+        path.write_text(json.dumps(cfg, indent=2), encoding="utf-8")
+        return path
+
+    def _start_relay(self) -> None:
+        binary = self._ensure_nether2rak()
+        self._write_relay_config()
+        proc = self._spawn("friends", [str(binary)], RELAY_DIR)
+        time.sleep(4)
+        if proc.poll() is not None:
+            raise RuntimeError(f"Xbox Friends relay exited rc={proc.returncode}")
+        _log("Xbox Friends relay started; Microsoft device-code login may be required")
+
+    def _boot(self) -> None:
+        with self.lock:
+            self.state = "starting"
+            self.error = ""
+            self.started_at = time.time()
+        try:
+            _mkdirs()
+            _log("=== Minecraft stack bootstrap ===")
+            self._start_fabric()
+            self._start_viaproxy()
+            self._start_relay()
+            with self.lock:
+                self.state = "running"
+            _log("=== Minecraft stack running ===")
+        except Exception as exc:
+            with self.lock:
+                self.state = "error"
+                self.error = repr(exc)
+            _log(f"STACK ERROR: {exc!r}")
+
+    def start_async(self) -> dict[str, Any]:
+        with self.lock:
+            if self.worker and self.worker.is_alive():
+                return self.status()
+            if any(p.poll() is None for p in self.processes.values()) and self.state == "running":
+                return self.status()
+            self.worker = threading.Thread(target=self._boot, daemon=True, name="minecraft-stack")
+            self.worker.start()
+        return self.status()
+
+    def stop(self) -> dict[str, Any]:
+        with self.lock:
+            for name in ("friends", "viaproxy", "viaproxy-bootstrap", "minecraft"):
+                self._stop_process(name)
+            self.state = "stopped"
+        _log("Minecraft stack stopped")
+        return self.status()
+
+    def tail(self, lines: int = 160) -> str:
+        if not LOG_PATH.exists():
+            return "Sem logs do Minecraft ainda."
+        items = LOG_PATH.read_text(encoding="utf-8", errors="replace").splitlines()
+        return "\n".join(items[-max(10, min(lines, 500)):])
+
+    def status(self) -> dict[str, Any]:
+        with self.lock:
+            processes = {
+                name: {"pid": proc.pid, "running": proc.poll() is None, "returncode": proc.poll()}
+                for name, proc in self.processes.items()
+            }
+            log = self.tail(120)
+            login_url = None
+            device_code = None
+            url_match = re.findall(r"https://(?:www\.)?microsoft\.com/link", log, flags=re.I)
+            if url_match:
+                login_url = url_match[-1]
+            for pattern in (
+                r"(?:code|c[oó]digo)\s*[:=]\s*([A-Z0-9-]{6,16})",
+                r"enter\s+([A-Z0-9-]{6,16})\s+(?:to|at)",
+            ):
+                found = re.findall(pattern, log, flags=re.I)
+                if found:
+                    device_code = found[-1].upper()
+                    break
+            return {
+                "state": self.state,
+                "error": self.error or None,
+                "started_at": self.started_at,
+                "java_server": "127.0.0.1:25565",
+                "bedrock_backend": "127.0.0.1:19132",
+                "access": "Xbox/Microsoft Friends via NetherNet; no public UDP tunnel",
+                "bedrock_protocol": BEDROCK_PROTOCOL,
+                "bedrock_version": BEDROCK_VERSION,
+                "microsoft_login_url": login_url,
+                "microsoft_device_code": device_code,
+                "processes": processes,
+                "log_tail": log,
+            }
+
+
+STACK = MinecraftStack()

packages.txt

@@ -1 +0,0 @@
-default-jre-headless