Set 100 player limit and Bedrock owner operator

minecraft_stack.py

@@ -27,7 +27,9 @@ VIA_DIR = BASE / "viaproxy"
 # in-place, so using this directory preserves both initial login and token rotation.
 RELAY_DIR = PERSIST_ROOT / "relay"
 WORLD_DIR = PERSIST_ROOT / "world-20260927-surface-v2"
-BOT_USERNAME = os.environ.get("MC_USERNAME", "Naldo_Bot")
+BOT_USERNAME = os.environ.get("MC_USERNAME", "Naldo_Bot")
+ADMIN_USERNAME = "IffyBinkie6134"
+MAX_PLAYERS = 100
 TOOLS_DIR = BASE / "tools"
 BIN_DIR = BASE / "bin"
 LOG_PATH = BASE / "stack.log"
@@ -194,6 +196,28 @@ def _relay_diagnostics(lines: list[str]) -> dict[str, Any]:
         "backend_failures": sum("failed to dial backend" in line or "failed to log in to backend" in line
                                 for line in events),
     }
+
+
+def _offline_player_uuid(username: str) -> str:
+    return str(uuid.UUID(bytes=hashlib.md5(
+        f"OfflinePlayer:{username}".encode("utf-8")
+    ).digest(), version=3))
+
+
+def _ensure_admin_operator(path: Path, username: str) -> None:
+    """Seed the exact offline-mode Java profile used by the Bedrock relay."""
+    if not re.fullmatch(r"[A-Za-z0-9_]{1,16}", username):
+        raise ValueError("Invalid Minecraft operator username")
+    operators = json.loads(path.read_text(encoding="utf-8")) if path.exists() else []
+    if not isinstance(operators, list):
+        raise ValueError("Minecraft ops.json must be a list")
+    identity = _offline_player_uuid(username)
+    entry = {"uuid": identity, "name": username, "level": 4, "bypassesPlayerLimit": True}
+    preserved = [item for item in operators if not (
+        isinstance(item, dict) and (item.get("uuid") == identity or item.get("name") == username)
+    )]
+    preserved.append(entry)
+    path.write_text(json.dumps(preserved, indent=2) + "\n", encoding="utf-8")
 
 
 class MinecraftStack:
@@ -391,8 +415,9 @@ class MinecraftStack:
             "allow-flight": "true",
             "gamemode": "creative",
             "force-gamemode": "true",
-            "difficulty": "peaceful",
-            "max-players": "10",
+            "difficulty": "peaceful",
+            "max-players": str(MAX_PLAYERS),
+            "op-permission-level": "4",
             "view-distance": "8",
             "simulation-distance": "6",
             "level-name": "world",
@@ -400,11 +425,12 @@ class MinecraftStack:
             "generate-structures": "true",
             "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",
-        )
-        self._ensure_persistent_world()
+        (JAVA_DIR / "server.properties").write_text(
+            "\n".join(f"{k}={v}" for k, v in props.items()) + "\n",
+            encoding="utf-8",
+        )
+        _ensure_admin_operator(JAVA_DIR / "ops.json", ADMIN_USERNAME)
+        self._ensure_persistent_world()
         return launcher
 
     def _start_fabric(self) -> None:
@@ -548,7 +574,7 @@ class MinecraftStack:
             "nethernet_backend_address": "http://127.0.0.1:19134",
             "host_name": HOST_NAME,
             "world_name": WORLD_NAME,
-            "max_players": 10,
+            "max_players": MAX_PLAYERS,
             "fake_player_count": 0,
             "protocol": BEDROCK_PROTOCOL,
             "version": BEDROCK_VERSION,
@@ -638,6 +664,26 @@ class MinecraftStack:
                 all_lines = []
                 server_lines = []
             relay_health = _relay_diagnostics(all_lines[boot:] if all_lines else [])
+            try:
+                operators = json.loads((JAVA_DIR / "ops.json").read_text(encoding="utf-8"))
+                expected_uuid = _offline_player_uuid(ADMIN_USERNAME)
+                admin_operator = any(
+                    isinstance(entry, dict) and entry.get("uuid") == expected_uuid
+                    and entry.get("name") == ADMIN_USERNAME and entry.get("level") == 4
+                    for entry in operators
+                )
+            except (OSError, ValueError, TypeError):
+                admin_operator = False
+            admin_player_file_exists = (WORLD_DIR / "playerdata" / f"{_offline_player_uuid(ADMIN_USERNAME)}.dat").exists()
+            try:
+                properties = (JAVA_DIR / "server.properties").read_text(encoding="utf-8")
+                java_player_limit = int(re.search(r"(?m)^max-players=(\d+)$", properties).group(1))
+            except (OSError, AttributeError, ValueError):
+                java_player_limit = None
+            try:
+                xbox_player_limit = int(json.loads((RELAY_DIR / "config.json").read_text(encoding="utf-8"))["max_players"])
+            except (OSError, ValueError, KeyError, TypeError):
+                xbox_player_limit = None
             offline_uuid = uuid.UUID(bytes=hashlib.md5(
                 f"OfflinePlayer:{BOT_USERNAME}".encode("utf-8")
             ).digest(), version=3)
@@ -682,6 +728,9 @@ class MinecraftStack:
                 "world_persistence": str(WORLD_DIR),
                 "player_save": player_save,
                 "relay_health": relay_health,
+                "player_limit": {"java": java_player_limit, "xbox_friends": xbox_player_limit},
+                "admin_operator": admin_operator,
+                "admin_player_file_exists": admin_player_file_exists,
                 "bot_username": BOT_USERNAME,
                 "bot_display_name": "Naldo Bot",
                 "bedrock_protocol": BEDROCK_PROTOCOL,

tests/test_server_admin_config.py

@@ -0,0 +1,60 @@
+import json
+import tempfile
+from pathlib import Path
+
+import minecraft_stack as mc
+
+
+def test_operator_seed_preserves_other_operators():
+    with tempfile.TemporaryDirectory() as tmp:
+        path = Path(tmp) / "ops.json"
+        other = {"uuid": "other", "name": "ExistingAdmin", "level": 3, "bypassesPlayerLimit": False}
+        path.write_text(json.dumps([other]), encoding="utf-8")
+        mc._ensure_admin_operator(path, "IffyBinkie6134")
+        mc._ensure_admin_operator(path, "IffyBinkie6134")
+        entries = json.loads(path.read_text(encoding="utf-8"))
+        assert entries[0] == other
+        assert len(entries) == 2
+        assert entries[1] == {
+            "uuid": mc._offline_player_uuid("IffyBinkie6134"),
+            "name": "IffyBinkie6134", "level": 4, "bypassesPlayerLimit": True,
+        }
+        try:
+            mc._ensure_admin_operator(path, "bad name; op someone")
+        except ValueError:
+            pass
+        else:
+            raise AssertionError("invalid username accepted")
+        assert json.loads(path.read_text(encoding="utf-8")) == entries
+
+
+def test_status_reports_real_configured_limits_and_operator():
+    with tempfile.TemporaryDirectory() as tmp:
+        base = Path(tmp)
+        old = (mc.JAVA_DIR, mc.RELAY_DIR, mc.WORLD_DIR, mc.LOG_PATH)
+        try:
+            mc.JAVA_DIR, mc.RELAY_DIR = base / "java", base / "relay"
+            mc.WORLD_DIR, mc.LOG_PATH = base / "world", base / "stack.log"
+            mc.JAVA_DIR.mkdir()
+            mc.RELAY_DIR.mkdir()
+            mc.WORLD_DIR.mkdir()
+            (mc.JAVA_DIR / "server.properties").write_text("max-players=100\n", encoding="utf-8")
+            (mc.RELAY_DIR / "config.json").write_text('{"max_players":100}', encoding="utf-8")
+            mc._ensure_admin_operator(mc.JAVA_DIR / "ops.json", mc.ADMIN_USERNAME)
+            status = mc.MinecraftStack().status()
+            assert status["player_limit"] == {"java": 100, "xbox_friends": 100}
+            assert status["admin_operator"] is True
+            assert status["admin_player_file_exists"] is False
+            (mc.WORLD_DIR / "playerdata").mkdir()
+            (mc.WORLD_DIR / "playerdata" / f"{mc._offline_player_uuid(mc.ADMIN_USERNAME)}.dat").write_bytes(b"saved")
+            assert mc.MinecraftStack().status()["admin_player_file_exists"] is True
+            (mc.JAVA_DIR / "ops.json").write_text("[]", encoding="utf-8")
+            assert mc.MinecraftStack().status()["admin_operator"] is False
+        finally:
+            mc.JAVA_DIR, mc.RELAY_DIR, mc.WORLD_DIR, mc.LOG_PATH = old
+
+
+if __name__ == "__main__":
+    test_operator_seed_preserves_other_operators()
+    test_status_reports_real_configured_limits_and_operator()
+    print("PASS player limit and persistent operator seed")