pybedrock-net 0.0.1__tar.gz

pybedrock_net-0.0.1/PKG-INFO

@@ -0,0 +1,179 @@
+Metadata-Version: 2.4
+Name: pybedrock-net
+Version: 0.0.1
+Summary: A Python-native RakNet foundation for Minecraft Bedrock protocol experiments.
+Author: ZENKAI
+Project-URL: Homepage, https://pypi.org/project/pybedrock-net/
+Project-URL: YouTube, https://www.youtube.com/@szewq
+Keywords: minecraft,bedrock,raknet,udp,protocol,bot
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Internet
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: build>=1.4.4
+Requires-Dist: pytest>=8.4.2
+Requires-Dist: twine>=6.2.0
+
+# pybedrock-net
+
+Python-native RakNet foundations for Minecraft Bedrock protocol experiments.
+
+Developed by ZENKAI, with Sader (سادر) leading the development and protocol
+implementation work.
+
+## Overview
+
+`pybedrock-net` is an early development project focused on understanding and
+implementing Minecraft Bedrock networking directly in Python. Bedrock uses
+RakNet as an important networking foundation. The long-term goal is a reusable
+Python foundation for programmable Bedrock clients, bots, protocol tools,
+testing tools, experiments, and automation systems.
+
+This project targets the network protocol rather than requiring a complete
+Minecraft game client. It is not a Minecraft server and is not a replacement
+for Minecraft.
+
+## Current implementation
+
+Version 0.0.1 contains a real UDP implementation of the RakNet offline
+handshake:
+
+```text
+0x05 OpenConnectionRequest1
+          ↓
+0x06 OpenConnectionReply1
+          ↓
+0x07 OpenConnectionRequest2
+          ↓
+0x08 OpenConnectionReply2
+```
+
+`RakNetSession` creates a UDP socket, sends Request1, parses Reply1, sends
+Request2, and parses Reply2. The command-line probe performs this exchange
+against a reachable Bedrock UDP endpoint.
+
+Successful Reply2 means only that the RakNet offline handshake completed. It
+does not mean the client logged into Minecraft or entered the world.
+
+## Architecture
+
+```text
+Python application / Bot
+          ↓
+      UDP transport
+          ↓
+        RakNet
+          ↓
+Minecraft Bedrock protocol
+          ↓
+Minecraft Bedrock server
+```
+
+The transport layer owns UDP communication. RakNet provides the connection and
+reliability foundation. The Bedrock layer will eventually provide login, world,
+player, chat, and command protocol support.
+
+## Live connection probe
+
+Run this against a real Bedrock UDP endpoint:
+
+```bash
+pybedrock-net example.org --port 19132
+```
+
+The host and port are supplied by the user and are never embedded in the
+package. No credentials or server infrastructure are included.
+
+## Usage
+
+The current session API is experimental:
+
+```python
+import asyncio
+from pybedrock_net import RakNetSession
+
+
+async def main() -> None:
+    session = RakNetSession("example.org", port=19132)
+    try:
+        reply = await session.connect()
+        print(reply.server_guid, reply.mtu)
+    finally:
+        session.close()
+
+
+asyncio.run(main())
+```
+
+This connects to RakNet only. It does not log in, move a player, follow a
+player, send chat, or execute commands yet.
+
+## Current limitations
+
+- Connected RakNet framing is not implemented.
+- Complete reliability, ACK, NAK, ordering, and channel handling are not
+  implemented.
+- RakNet connection request and accepted-connection stages are not implemented.
+- Bedrock login, encryption, network settings, start game, and play state are
+  not implemented.
+- Player position tracking and movement packets are not implemented.
+- Following a player, chat messages, and command execution are not implemented.
+- No stable high-level bot API is available.
+
+These limitations are explicit because sending guessed Bedrock packets can
+disconnect a server or corrupt a session.
+
+## Roadmap
+
+1. **RakNet offline handshake** — implemented and locally tested; real-server
+   verification depends on a reachable endpoint.
+2. **Connected RakNet framing** — in development.
+3. **Reliability, ACK/NAK, ordering, and session lifecycle** — planned.
+4. **Bedrock login and encryption** — planned.
+5. **Bedrock play protocol and player tracking** — planned.
+6. **Movement, follow-player behavior, chat, and permitted commands** — planned.
+7. **High-level Bedrock bot API** — long-term goal.
+
+## Installation
+
+```bash
+pip install pybedrock-net
+```
+
+Version 0.0.1 is an early foundation/development release. APIs may change,
+protocol implementation is incomplete, and the package is not production-ready.
+
+## Development
+
+```bash
+python -m pytest
+python -m build
+python -m twine check dist/*
+```
+
+## Developer & Community
+
+- **Developer:** ZENKAI
+- **Development:** Sader (سادر)
+- **Telegram:** `s_xwn`
+- **TikTok:** `s_xwn`
+- **YouTube:** https://www.youtube.com/@szewq
+
+An official support/community link may be added in a future release.
+
+## Future Support
+
+The intended future bot layer may allow Python programs to connect to Bedrock
+servers where supported, authenticate, receive player events, follow a target
+player, move, send chat, issue permitted commands, and automate protocol-level
+tasks. These are future capabilities, not features available in 0.0.1.
+
+## License
+
+No license file was present when this distribution was prepared. A license
+should be selected before the project is treated as a fully licensed
+open-source distribution.

pybedrock_net-0.0.1/README.md

@@ -0,0 +1,159 @@
+# pybedrock-net
+
+Python-native RakNet foundations for Minecraft Bedrock protocol experiments.
+
+Developed by ZENKAI, with Sader (سادر) leading the development and protocol
+implementation work.
+
+## Overview
+
+`pybedrock-net` is an early development project focused on understanding and
+implementing Minecraft Bedrock networking directly in Python. Bedrock uses
+RakNet as an important networking foundation. The long-term goal is a reusable
+Python foundation for programmable Bedrock clients, bots, protocol tools,
+testing tools, experiments, and automation systems.
+
+This project targets the network protocol rather than requiring a complete
+Minecraft game client. It is not a Minecraft server and is not a replacement
+for Minecraft.
+
+## Current implementation
+
+Version 0.0.1 contains a real UDP implementation of the RakNet offline
+handshake:
+
+```text
+0x05 OpenConnectionRequest1
+          ↓
+0x06 OpenConnectionReply1
+          ↓
+0x07 OpenConnectionRequest2
+          ↓
+0x08 OpenConnectionReply2
+```
+
+`RakNetSession` creates a UDP socket, sends Request1, parses Reply1, sends
+Request2, and parses Reply2. The command-line probe performs this exchange
+against a reachable Bedrock UDP endpoint.
+
+Successful Reply2 means only that the RakNet offline handshake completed. It
+does not mean the client logged into Minecraft or entered the world.
+
+## Architecture
+
+```text
+Python application / Bot
+          ↓
+      UDP transport
+          ↓
+        RakNet
+          ↓
+Minecraft Bedrock protocol
+          ↓
+Minecraft Bedrock server
+```
+
+The transport layer owns UDP communication. RakNet provides the connection and
+reliability foundation. The Bedrock layer will eventually provide login, world,
+player, chat, and command protocol support.
+
+## Live connection probe
+
+Run this against a real Bedrock UDP endpoint:
+
+```bash
+pybedrock-net example.org --port 19132
+```
+
+The host and port are supplied by the user and are never embedded in the
+package. No credentials or server infrastructure are included.
+
+## Usage
+
+The current session API is experimental:
+
+```python
+import asyncio
+from pybedrock_net import RakNetSession
+
+
+async def main() -> None:
+    session = RakNetSession("example.org", port=19132)
+    try:
+        reply = await session.connect()
+        print(reply.server_guid, reply.mtu)
+    finally:
+        session.close()
+
+
+asyncio.run(main())
+```
+
+This connects to RakNet only. It does not log in, move a player, follow a
+player, send chat, or execute commands yet.
+
+## Current limitations
+
+- Connected RakNet framing is not implemented.
+- Complete reliability, ACK, NAK, ordering, and channel handling are not
+  implemented.
+- RakNet connection request and accepted-connection stages are not implemented.
+- Bedrock login, encryption, network settings, start game, and play state are
+  not implemented.
+- Player position tracking and movement packets are not implemented.
+- Following a player, chat messages, and command execution are not implemented.
+- No stable high-level bot API is available.
+
+These limitations are explicit because sending guessed Bedrock packets can
+disconnect a server or corrupt a session.
+
+## Roadmap
+
+1. **RakNet offline handshake** — implemented and locally tested; real-server
+   verification depends on a reachable endpoint.
+2. **Connected RakNet framing** — in development.
+3. **Reliability, ACK/NAK, ordering, and session lifecycle** — planned.
+4. **Bedrock login and encryption** — planned.
+5. **Bedrock play protocol and player tracking** — planned.
+6. **Movement, follow-player behavior, chat, and permitted commands** — planned.
+7. **High-level Bedrock bot API** — long-term goal.
+
+## Installation
+
+```bash
+pip install pybedrock-net
+```
+
+Version 0.0.1 is an early foundation/development release. APIs may change,
+protocol implementation is incomplete, and the package is not production-ready.
+
+## Development
+
+```bash
+python -m pytest
+python -m build
+python -m twine check dist/*
+```
+
+## Developer & Community
+
+- **Developer:** ZENKAI
+- **Development:** Sader (سادر)
+- **Telegram:** `s_xwn`
+- **TikTok:** `s_xwn`
+- **YouTube:** https://www.youtube.com/@szewq
+
+An official support/community link may be added in a future release.
+
+## Future Support
+
+The intended future bot layer may allow Python programs to connect to Bedrock
+servers where supported, authenticate, receive player events, follow a target
+player, move, send chat, issue permitted commands, and automate protocol-level
+tasks. These are future capabilities, not features available in 0.0.1.
+
+## License
+
+No license file was present when this distribution was prepared. A license
+should be selected before the project is treated as a fully licensed
+open-source distribution.

pybedrock_net-0.0.1/pybedrock_net/__init__.py

@@ -0,0 +1,7 @@
+"""Python-native foundations for Minecraft Bedrock networking."""
+
+__version__ = "0.0.1"
+
+from .protocol.raknet.session import RakNetSession
+
+__all__ = ["RakNetSession", "__version__"]

pybedrock_net-0.0.1/pybedrock_net/cli.py

@@ -0,0 +1,53 @@
+"""Command-line tools for checking a Bedrock server's RakNet endpoint."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import sys
+
+from .protocol.raknet.session import RakNetSession
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="pybedrock-net",
+        description="Run the RakNet offline handshake against a Bedrock server.",
+    )
+    parser.add_argument("host", help="Bedrock server hostname or IPv4 address")
+    parser.add_argument("--port", type=int, default=19132, help="Bedrock UDP port")
+    parser.add_argument("--mtu", type=int, default=1492, help="Requested MTU (576-1492)")
+    parser.add_argument("--timeout", type=float, default=5.0, help="Reply timeout in seconds")
+    return parser
+
+
+async def _run(args: argparse.Namespace) -> int:
+    session = RakNetSession(
+        args.host, port=args.port, mtu=args.mtu, timeout=args.timeout
+    )
+    try:
+        reply = await session.connect()
+        print(f"Connected to {args.host}:{args.port}")
+        print(f"Server GUID: {reply.server_guid}")
+        print(f"Negotiated MTU: {reply.mtu}")
+        print(f"Security enabled: {reply.security_enabled}")
+        print("RakNet offline handshake complete (0x05 → 0x06 → 0x07 → 0x08).")
+        print(
+            "Bedrock login/play is not completed by this release; "
+            "no movement or chat packets are sent."
+        )
+        return 0
+    except (OSError, TimeoutError, ValueError) as exc:
+        print(f"Connection failed: {exc}", file=sys.stderr)
+        return 1
+    finally:
+        session.close()
+
+
+def main() -> int:
+    args = build_parser().parse_args()
+    return asyncio.run(_run(args))
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

pybedrock_net-0.0.1/pybedrock_net/protocol/__init__.py

@@ -0,0 +1 @@
+"""Minecraft protocol implementations."""

pybedrock_net-0.0.1/pybedrock_net/protocol/raknet/__init__.py

@@ -0,0 +1,12 @@
+"""RakNet protocol primitives used by Minecraft Bedrock."""
+
+from .constants import OFFLINE_MAGIC
+from .packets import OpenConnectionReply1, OpenConnectionReply2
+from .session import RakNetSession
+
+__all__ = [
+    "OFFLINE_MAGIC",
+    "OpenConnectionReply1",
+    "OpenConnectionReply2",
+    "RakNetSession",
+]

pybedrock_net-0.0.1/pybedrock_net/protocol/raknet/constants.py

@@ -0,0 +1,33 @@
+"""RakNet constants."""
+
+from __future__ import annotations
+
+import struct
+
+OFFLINE_MAGIC = bytes.fromhex("00ffff00fefefefefdfdfdfd12345678")
+OPEN_CONNECTION_REQUEST_1 = 0x05
+OPEN_CONNECTION_REPLY_1 = 0x06
+OPEN_CONNECTION_REQUEST_2 = 0x07
+OPEN_CONNECTION_REPLY_2 = 0x08
+
+
+def pack_u16(value: int) -> bytes:
+    return struct.pack(">H", value)
+
+
+def pack_u64(value: int) -> bytes:
+    return struct.pack(">Q", value)
+
+
+def unpack_u16(data: bytes, offset: int) -> tuple[int, int]:
+    end = offset + 2
+    if len(data) < end:
+        raise ValueError("packet ended while reading uint16")
+    return struct.unpack(">H", data[offset:end])[0], end
+
+
+def unpack_u64(data: bytes, offset: int) -> tuple[int, int]:
+    end = offset + 8
+    if len(data) < end:
+        raise ValueError("packet ended while reading uint64")
+    return struct.unpack(">Q", data[offset:end])[0], end

pybedrock_net-0.0.1/pybedrock_net/protocol/raknet/offline.py

@@ -0,0 +1,81 @@
+"""RakNet offline packet encoding and decoding."""
+
+from __future__ import annotations
+
+import ipaddress
+
+from .constants import (
+    OFFLINE_MAGIC,
+    OPEN_CONNECTION_REPLY_1,
+    OPEN_CONNECTION_REPLY_2,
+    OPEN_CONNECTION_REQUEST_1,
+    OPEN_CONNECTION_REQUEST_2,
+    pack_u16,
+    pack_u64,
+    unpack_u16,
+    unpack_u64,
+)
+
+
+def encode_ipv4(address: str) -> bytes:
+    ip = ipaddress.ip_address(address)
+    if ip.version != 4:
+        raise ValueError("RakNet Bedrock transport currently requires an IPv4 address")
+    return bytes((0x04,)) + bytes((octet ^ 0xFF for octet in ip.packed))
+
+
+def decode_ipv4(data: bytes, offset: int = 0) -> tuple[str, int]:
+    if len(data) < offset + 5 or data[offset] != 0x04:
+        raise ValueError("expected RakNet IPv4 address")
+    raw = bytes(octet ^ 0xFF for octet in data[offset + 1 : offset + 5])
+    return str(ipaddress.ip_address(raw)), offset + 5
+
+
+def build_open_connection_request_1(mtu: int, protocol_version: int = 11) -> bytes:
+    if not 576 <= mtu <= 1492:
+        raise ValueError("MTU must be between 576 and 1492 bytes")
+    # Request1 is padded to the requested datagram size.
+    header = bytes((OPEN_CONNECTION_REQUEST_1,)) + OFFLINE_MAGIC + bytes((protocol_version,))
+    return header + bytes(max(0, mtu - len(header)))
+
+
+def build_open_connection_request_2(
+    server_host: str, server_port: int, mtu: int, client_guid: int
+) -> bytes:
+    if not 0 <= server_port <= 65535:
+        raise ValueError("server port must be between 0 and 65535")
+    return (
+        bytes((OPEN_CONNECTION_REQUEST_2,))
+        + OFFLINE_MAGIC
+        + encode_ipv4(server_host)
+        + pack_u16(server_port)
+        + pack_u16(mtu)
+        + pack_u64(client_guid)
+    )
+
+
+class OpenConnectionReply1:
+    """Parsed 0x06 OpenConnectionReply1."""
+
+    def __init__(self, data: bytes) -> None:
+        if len(data) < 28 or data[0] != OPEN_CONNECTION_REPLY_1:
+            raise ValueError("not an OpenConnectionReply1 packet")
+        if data[1:17] != OFFLINE_MAGIC:
+            raise ValueError("invalid RakNet offline magic")
+        self.server_guid, offset = unpack_u64(data, 17)
+        self.security_enabled = bool(data[offset])
+        self.mtu, _ = unpack_u16(data, offset + 1)
+
+
+class OpenConnectionReply2:
+    """Parsed 0x08 OpenConnectionReply2."""
+
+    def __init__(self, data: bytes) -> None:
+        if len(data) < 35 or data[0] != OPEN_CONNECTION_REPLY_2:
+            raise ValueError("not an OpenConnectionReply2 packet")
+        if data[1:17] != OFFLINE_MAGIC:
+            raise ValueError("invalid RakNet offline magic")
+        self.server_guid, offset = unpack_u64(data, 17)
+        self.client_address, offset = decode_ipv4(data, offset)
+        self.server_port, offset = unpack_u16(data, offset)
+        self.mtu, _ = unpack_u16(data, offset)

pybedrock_net-0.0.1/pybedrock_net/protocol/raknet/packets.py

@@ -0,0 +1,5 @@
+"""Compatibility exports for RakNet offline packet types."""
+
+from .offline import OpenConnectionReply1, OpenConnectionReply2
+
+__all__ = ["OpenConnectionReply1", "OpenConnectionReply2"]

pybedrock_net-0.0.1/pybedrock_net/protocol/raknet/session.py

@@ -0,0 +1,66 @@
+"""RakNet session lifecycle for the offline Bedrock handshake."""
+
+from __future__ import annotations
+
+import asyncio
+import secrets
+
+from .offline import (
+    OpenConnectionReply1,
+    OpenConnectionReply2,
+    build_open_connection_request_1,
+    build_open_connection_request_2,
+)
+from .transport import UdpTransport
+
+
+class RakNetSession:
+    """Perform the real RakNet offline handshake over UDP.
+
+    This intentionally stops after Reply2. Connected RakNet and Bedrock login
+    require additional protocol stages and encryption that are not silently
+    approximated here.
+    """
+
+    def __init__(
+        self,
+        host: str,
+        *,
+        port: int = 19132,
+        mtu: int = 1492,
+        timeout: float = 5.0,
+        client_guid: int | None = None,
+    ) -> None:
+        self.host = host
+        self.port = port
+        self.mtu = mtu
+        self.timeout = timeout
+        self.client_guid = client_guid if client_guid is not None else secrets.randbits(64)
+        self.transport = UdpTransport(host, port, timeout)
+        self.reply1: OpenConnectionReply1 | None = None
+        self.reply2: OpenConnectionReply2 | None = None
+
+    async def connect(self) -> OpenConnectionReply2:
+        await self.transport.open()
+        await self.transport.send(build_open_connection_request_1(self.mtu))
+        self.reply1 = OpenConnectionReply1(await self.transport.receive())
+        await self.transport.send(
+            build_open_connection_request_2(
+                self.transport.peer_host or self.host,
+                self.port,
+                self.reply1.mtu,
+                self.client_guid,
+            )
+        )
+        self.reply2 = OpenConnectionReply2(await self.transport.receive())
+        return self.reply2
+
+    async def run(self) -> None:
+        """Keep the UDP session available for future connected-RakNet work."""
+        if self.reply2 is None:
+            raise RuntimeError("call connect() before run()")
+        while True:
+            await self.transport.receive()
+
+    def close(self) -> None:
+        self.transport.close()

pybedrock_net-0.0.1/pybedrock_net/protocol/raknet/transport.py

@@ -0,0 +1,47 @@
+"""Async UDP transport for RakNet datagrams."""
+
+from __future__ import annotations
+
+import asyncio
+import socket
+
+
+class UdpTransport:
+    def __init__(self, host: str, port: int, timeout: float) -> None:
+        self.host = host
+        self.port = port
+        self.timeout = timeout
+        self._socket: socket.socket | None = None
+        self.peer_host: str | None = None
+
+    async def open(self) -> None:
+        infos = await asyncio.get_running_loop().getaddrinfo(
+            self.host, self.port, type=socket.SOCK_DGRAM
+        )
+        if not infos:
+            raise OSError(f"could not resolve {self.host}")
+        family, socktype, proto, _, address = infos[0]
+        self.peer_host = address[0]
+        sock = socket.socket(family, socktype, proto)
+        sock.setblocking(False)
+        await asyncio.get_running_loop().sock_connect(sock, address)
+        self._socket = sock
+
+    async def send(self, packet: bytes) -> None:
+        if self._socket is None:
+            raise RuntimeError("transport is not open")
+        await asyncio.get_running_loop().sock_sendall(self._socket, packet)
+
+    async def receive(self, max_size: int = 2048) -> bytes:
+        if self._socket is None:
+            raise RuntimeError("transport is not open")
+        return await asyncio.wait_for(
+            asyncio.get_running_loop().sock_recv(self._socket, max_size),
+            timeout=self.timeout,
+        )
+
+    def close(self) -> None:
+        if self._socket is not None:
+            self._socket.close()
+            self._socket = None
+            self.peer_host = None

pybedrock_net-0.0.1/pybedrock_net.egg-info/PKG-INFO

@@ -0,0 +1,179 @@
+Metadata-Version: 2.4
+Name: pybedrock-net
+Version: 0.0.1
+Summary: A Python-native RakNet foundation for Minecraft Bedrock protocol experiments.
+Author: ZENKAI
+Project-URL: Homepage, https://pypi.org/project/pybedrock-net/
+Project-URL: YouTube, https://www.youtube.com/@szewq
+Keywords: minecraft,bedrock,raknet,udp,protocol,bot
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Internet
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: build>=1.4.4
+Requires-Dist: pytest>=8.4.2
+Requires-Dist: twine>=6.2.0
+
+# pybedrock-net
+
+Python-native RakNet foundations for Minecraft Bedrock protocol experiments.
+
+Developed by ZENKAI, with Sader (سادر) leading the development and protocol
+implementation work.
+
+## Overview
+
+`pybedrock-net` is an early development project focused on understanding and
+implementing Minecraft Bedrock networking directly in Python. Bedrock uses
+RakNet as an important networking foundation. The long-term goal is a reusable
+Python foundation for programmable Bedrock clients, bots, protocol tools,
+testing tools, experiments, and automation systems.
+
+This project targets the network protocol rather than requiring a complete
+Minecraft game client. It is not a Minecraft server and is not a replacement
+for Minecraft.
+
+## Current implementation
+
+Version 0.0.1 contains a real UDP implementation of the RakNet offline
+handshake:
+
+```text
+0x05 OpenConnectionRequest1
+          ↓
+0x06 OpenConnectionReply1
+          ↓
+0x07 OpenConnectionRequest2
+          ↓
+0x08 OpenConnectionReply2
+```
+
+`RakNetSession` creates a UDP socket, sends Request1, parses Reply1, sends
+Request2, and parses Reply2. The command-line probe performs this exchange
+against a reachable Bedrock UDP endpoint.
+
+Successful Reply2 means only that the RakNet offline handshake completed. It
+does not mean the client logged into Minecraft or entered the world.
+
+## Architecture
+
+```text
+Python application / Bot
+          ↓
+      UDP transport
+          ↓
+        RakNet
+          ↓
+Minecraft Bedrock protocol
+          ↓
+Minecraft Bedrock server
+```
+
+The transport layer owns UDP communication. RakNet provides the connection and
+reliability foundation. The Bedrock layer will eventually provide login, world,
+player, chat, and command protocol support.
+
+## Live connection probe
+
+Run this against a real Bedrock UDP endpoint:
+
+```bash
+pybedrock-net example.org --port 19132
+```
+
+The host and port are supplied by the user and are never embedded in the
+package. No credentials or server infrastructure are included.
+
+## Usage
+
+The current session API is experimental:
+
+```python
+import asyncio
+from pybedrock_net import RakNetSession
+
+
+async def main() -> None:
+    session = RakNetSession("example.org", port=19132)
+    try:
+        reply = await session.connect()
+        print(reply.server_guid, reply.mtu)
+    finally:
+        session.close()
+
+
+asyncio.run(main())
+```
+
+This connects to RakNet only. It does not log in, move a player, follow a
+player, send chat, or execute commands yet.
+
+## Current limitations
+
+- Connected RakNet framing is not implemented.
+- Complete reliability, ACK, NAK, ordering, and channel handling are not
+  implemented.
+- RakNet connection request and accepted-connection stages are not implemented.
+- Bedrock login, encryption, network settings, start game, and play state are
+  not implemented.
+- Player position tracking and movement packets are not implemented.
+- Following a player, chat messages, and command execution are not implemented.
+- No stable high-level bot API is available.
+
+These limitations are explicit because sending guessed Bedrock packets can
+disconnect a server or corrupt a session.
+
+## Roadmap
+
+1. **RakNet offline handshake** — implemented and locally tested; real-server
+   verification depends on a reachable endpoint.
+2. **Connected RakNet framing** — in development.
+3. **Reliability, ACK/NAK, ordering, and session lifecycle** — planned.
+4. **Bedrock login and encryption** — planned.
+5. **Bedrock play protocol and player tracking** — planned.
+6. **Movement, follow-player behavior, chat, and permitted commands** — planned.
+7. **High-level Bedrock bot API** — long-term goal.
+
+## Installation
+
+```bash
+pip install pybedrock-net
+```
+
+Version 0.0.1 is an early foundation/development release. APIs may change,
+protocol implementation is incomplete, and the package is not production-ready.
+
+## Development
+
+```bash
+python -m pytest
+python -m build
+python -m twine check dist/*
+```
+
+## Developer & Community
+
+- **Developer:** ZENKAI
+- **Development:** Sader (سادر)
+- **Telegram:** `s_xwn`
+- **TikTok:** `s_xwn`
+- **YouTube:** https://www.youtube.com/@szewq
+
+An official support/community link may be added in a future release.
+
+## Future Support
+
+The intended future bot layer may allow Python programs to connect to Bedrock
+servers where supported, authenticate, receive player events, follow a target
+player, move, send chat, issue permitted commands, and automate protocol-level
+tasks. These are future capabilities, not features available in 0.0.1.
+
+## License
+
+No license file was present when this distribution was prepared. A license
+should be selected before the project is treated as a fully licensed
+open-source distribution.

pybedrock_net-0.0.1/pybedrock_net.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+README.md
+pyproject.toml
+pybedrock_net/__init__.py
+pybedrock_net/cli.py
+pybedrock_net.egg-info/PKG-INFO
+pybedrock_net.egg-info/SOURCES.txt
+pybedrock_net.egg-info/dependency_links.txt
+pybedrock_net.egg-info/entry_points.txt
+pybedrock_net.egg-info/requires.txt
+pybedrock_net.egg-info/top_level.txt
+pybedrock_net/protocol/__init__.py
+pybedrock_net/protocol/raknet/__init__.py
+pybedrock_net/protocol/raknet/constants.py
+pybedrock_net/protocol/raknet/offline.py
+pybedrock_net/protocol/raknet/packets.py
+pybedrock_net/protocol/raknet/session.py
+pybedrock_net/protocol/raknet/transport.py
+tests/test_offline.py

pybedrock_net-0.0.1/pybedrock_net.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pybedrock_net-0.0.1/pybedrock_net.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pybedrock-net = pybedrock_net.cli:main

pybedrock_net-0.0.1/pybedrock_net.egg-info/requires.txt

@@ -0,0 +1,3 @@
+build>=1.4.4
+pytest>=8.4.2
+twine>=6.2.0

pybedrock_net-0.0.1/pybedrock_net.egg-info/top_level.txt

@@ -0,0 +1 @@
+pybedrock_net

pybedrock_net-0.0.1/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pybedrock-net"
+version = "0.0.1"
+description = "A Python-native RakNet foundation for Minecraft Bedrock protocol experiments."
+readme = "README.md"
+requires-python = ">=3.9"
+authors = [{ name = "ZENKAI" }]
+keywords = ["minecraft", "bedrock", "raknet", "udp", "protocol", "bot"]
+classifiers = [
+  "Development Status :: 2 - Pre-Alpha",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Topic :: Internet",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "build>=1.4.4",
+    "pytest>=8.4.2",
+    "twine>=6.2.0",
+]
+
+[project.scripts]
+pybedrock-net = "pybedrock_net.cli:main"
+
+[project.urls]
+Homepage = "https://pypi.org/project/pybedrock-net/"
+YouTube = "https://www.youtube.com/@szewq"
+
+[tool.setuptools.packages.find]
+include = ["pybedrock_net*"]

pybedrock_net-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pybedrock_net-0.0.1/tests/test_offline.py

@@ -0,0 +1,38 @@
+import pytest
+
+from pybedrock_net.protocol.raknet.constants import OFFLINE_MAGIC
+from pybedrock_net.protocol.raknet.offline import (
+    OpenConnectionReply1,
+    build_open_connection_request_1,
+    encode_ipv4,
+)
+
+
+def test_request_one_has_magic_and_requested_mtu():
+    packet = build_open_connection_request_1(1492)
+    assert packet[0] == 0x05
+    assert packet[1:17] == OFFLINE_MAGIC
+    assert len(packet) == 1492
+
+
+def test_ipv4_is_encoded_in_raknet_complement_form():
+    assert encode_ipv4("127.0.0.1") == b"\x04\x80\xff\xff\xfe"
+
+
+def test_reply_one_parses_fields():
+    packet = (
+        b"\x06"
+        + OFFLINE_MAGIC
+        + (123).to_bytes(8, "big")
+        + b"\x00"
+        + (1400).to_bytes(2, "big")
+    )
+    reply = OpenConnectionReply1(packet)
+    assert reply.server_guid == 123
+    assert reply.mtu == 1400
+    assert reply.security_enabled is False
+
+
+def test_bad_magic_is_rejected():
+    with pytest.raises(ValueError, match="offline magic"):
+        OpenConnectionReply1(b"\x06" + b"\x00" * 30)