bedrockplus 0.1.0.dev1__py3-none-win_amd64.whl

bedrockplus/cli.py

@@ -0,0 +1,121 @@
+"""Public command entry point for the BedrockPlus Windows distribution."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+
+
+class DistributionError(RuntimeError):
+    pass
+
+
+def _release_root() -> tuple[Path, bool]:
+    packaged = Path(__file__).resolve().parent / "_assets"
+    if (packaged.joinpath("release-manifest.json").is_file()):
+        return packaged, True
+
+    # Editable SDK installs inside the private repository remain useful to the
+    # publisher without embedding private project files in the public wheel.
+    candidate = Path(__file__).resolve().parents[4]
+    if candidate.joinpath("bin", "bedrockplus.ps1").is_file():
+        return candidate, False
+    raise DistributionError(
+        "BedrockPlus runtime assets are missing. Reinstall the official Windows wheel."
+    )
+
+
+def _verify_release(root: Path) -> None:
+    manifest_path = root / "release-manifest.json"
+    try:
+        manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeError, json.JSONDecodeError) as error:
+        raise DistributionError("BedrockPlus release metadata is unreadable") from error
+    if (
+        not isinstance(manifest, dict)
+        or manifest.get("product") != "BedrockPlus"
+        or manifest.get("platform") != "windows-x64"
+        or not isinstance(manifest.get("files"), list)
+    ):
+        raise DistributionError("BedrockPlus release metadata is invalid")
+    for record in manifest["files"]:
+        if not isinstance(record, dict) or set(record) != {
+            "path", "role", "size_bytes", "sha256"
+        }:
+            raise DistributionError("BedrockPlus release inventory is invalid")
+        relative = record["path"]
+        if (
+            not isinstance(relative, str)
+            or not relative
+            or "\\" in relative
+            or relative.startswith("/")
+            or any(part in {"", ".", ".."} for part in relative.split("/"))
+        ):
+            raise DistributionError("BedrockPlus release path is invalid")
+        path = root.joinpath(*relative.split("/"))
+        try:
+            data = path.read_bytes()
+        except OSError as error:
+            raise DistributionError(f"BedrockPlus release file is missing: {relative}") from error
+        expected_size = record["size_bytes"]
+        expected_hash = record["sha256"]
+        if (
+            type(expected_size) is not int
+            or expected_size < 0
+            or not isinstance(expected_hash, str)
+            or len(expected_hash) != 64
+            or len(data) != expected_size
+            or hashlib.sha256(data).hexdigest() != expected_hash
+        ):
+            raise DistributionError(f"BedrockPlus release verification failed: {relative}")
+
+
+def main() -> int:
+    if os.name != "nt" or sys.maxsize <= 2**32:
+        print("BedrockPlus currently requires 64-bit Windows.", file=sys.stderr)
+        return 1
+    if sys.version_info[:2] != (3, 13):
+        print("BedrockPlus currently requires Python 3.13.x.", file=sys.stderr)
+        return 1
+    try:
+        release_root, packaged = _release_root()
+        if packaged:
+            _verify_release(release_root)
+        wrapper = release_root / "bin" / "bedrockplus.ps1"
+        if not wrapper.is_file():
+            raise DistributionError("BedrockPlus command wrapper is missing")
+        powershell = shutil.which("powershell.exe")
+        if not powershell:
+            raise DistributionError("Windows PowerShell is required to run BedrockPlus")
+        environment = os.environ.copy()
+        environment["BEDROCKPLUS_PYTHON_EXECUTABLE"] = sys.executable
+        completed = subprocess.run(
+            [
+                powershell,
+                "-NoLogo",
+                "-NoProfile",
+                "-ExecutionPolicy",
+                "Bypass",
+                "-File",
+                str(wrapper),
+                *sys.argv[1:],
+            ],
+            env=environment,
+            check=False,
+        )
+        return completed.returncode
+    except KeyboardInterrupt:
+        print("\nBedrockPlus stopped.", file=sys.stderr)
+        return 130
+    except (DistributionError, OSError) as error:
+        print(f"BedrockPlus failed: {error}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

bedrockplus/commands.py

@@ -0,0 +1,50 @@
+"""Typed command declarations for BedrockPlus Python plugins."""
+
+from collections.abc import Callable, Sequence
+from enum import IntEnum
+from typing import Literal, NotRequired, TypeAlias, TypedDict
+
+CommandArgumentType: TypeAlias = Literal[
+    "int", "integer", "float", "real", "number", "string", "str", "text", "message", "enum"
+]
+CommandValue: TypeAlias = int | float | str
+
+
+class CommandSourceKind(IntEnum):
+    CONSOLE = 0
+    PLAYER = 1
+
+
+class CommandArgument(TypedDict):
+    """One typed argument in a command overload."""
+
+    name: str
+    type: CommandArgumentType
+    optional: NotRequired[bool]
+    choices: NotRequired[Sequence[str]]
+
+
+CommandOverload: TypeAlias = Sequence[CommandArgument]
+
+
+class CommandInvocation(TypedDict):
+    """Input passed to a registered command callback."""
+
+    source_kind: CommandSourceKind
+    source_name: str
+    source_identity: str
+    command: str
+    arguments: str
+    args: list[CommandValue]
+
+
+class CommandResult(TypedDict, total=False):
+    """Structured command callback result."""
+
+    succeeded: bool
+    message: str
+    error_code: str
+
+
+CommandReturn: TypeAlias = None | bool | str | CommandResult
+CommandCallback: TypeAlias = Callable[[CommandInvocation], CommandReturn]

bedrockplus/events.py

@@ -0,0 +1,138 @@
+"""Typed event declarations for BedrockPlus Python plugins.
+
+Callbacks receive mutable dictionaries.  For cancellable events, set
+``event["cancelled"] = True``.  Mutable fields are written back by changing
+entries in ``event["fields"]``.
+"""
+
+from enum import IntEnum
+from typing import Literal, NotRequired, Required, TypeAlias, TypedDict
+
+
+class EventPriority(IntEnum):
+    LOWEST = -200
+    LOW = -100
+    NORMAL = 0
+    HIGH = 100
+    HIGHEST = 200
+    MONITOR = 300
+
+
+EventName: TypeAlias = Literal[
+    "server.tick",
+    "player.join",
+    "player.quit",
+    "player.chat",
+    "block.break",
+    "block.place",
+    "server.list_ping",
+    "player.jump",
+    "player.kick",
+    "player.login",
+    "player.move",
+    "server.command",
+    "player.command",
+]
+
+
+class Event(TypedDict):
+    name: EventName
+    sequence: int
+    fields: NotRequired[dict[str, str]]
+
+
+class CancellableEvent(Event):
+    cancellable: bool
+    cancelled: bool
+
+
+PlayerLifecycleFields = TypedDict(
+    "PlayerLifecycleFields",
+    {
+        "player.name": Required[str],
+        "player.session": Required[str],
+        "player.uuid": NotRequired[str],
+        "player.xuid": NotRequired[str],
+        "player.address": NotRequired[str],
+        "player.port": NotRequired[str],
+        "player.ping_ms": NotRequired[str],
+        "player.device_id": NotRequired[str],
+        "player.device_model": NotRequired[str],
+        "player.device_os": NotRequired[str],
+        "player.input_mode": NotRequired[str],
+        "player.game_version": NotRequired[str],
+        "player.locale": NotRequired[str],
+        "player.client_fps": NotRequired[str],
+    },
+)
+ServerCommandFields = TypedDict(
+    "ServerCommandFields",
+    {
+        "command": str,
+        "command.name": str,
+        "source.kind": str,
+        "source.name": str,
+    },
+)
+PlayerCommandFields = TypedDict(
+    "PlayerCommandFields",
+    {
+        "command": str,
+        "command.name": str,
+        "source.kind": str,
+        "source.name": str,
+        "player.name": str,
+    },
+)
+
+
+class ServerTickEvent(Event):
+    pass
+
+
+class PlayerJoinEvent(Event):
+    fields: Required[PlayerLifecycleFields]
+
+
+class PlayerQuitEvent(Event):
+    fields: Required[PlayerLifecycleFields]
+
+
+class PlayerChatEvent(CancellableEvent):
+    pass
+
+
+class BlockBreakEvent(CancellableEvent):
+    pass
+
+
+class BlockPlaceEvent(CancellableEvent):
+    pass
+
+
+class ServerListPingEvent(Event):
+    pass
+
+
+class PlayerJumpEvent(Event):
+    pass
+
+
+class PlayerKickEvent(CancellableEvent):
+    pass
+
+
+class PlayerLoginEvent(CancellableEvent):
+    pass
+
+
+class PlayerMoveEvent(CancellableEvent):
+    pass
+
+
+class ServerCommandEvent(CancellableEvent):
+    fields: Required[ServerCommandFields]
+
+
+class PlayerCommandEvent(CancellableEvent):
+    fields: Required[PlayerCommandFields]