raknet-typeo 1.0.0

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "raknet-typeo",
+  "version": "1.0.0",
+  "description": "Pure JavaScript RakNet implementation — no C++, works on all platforms",
+  "keywords": [
+    "raknet",
+    "udp",
+    "networking",
+    "gameserver",
+    "minecraft",
+    "bedrock",
+    "bedrock-protocol"
+  ],
+  "license": "MIT",
+  "author": "",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.js",
+    "./compat": "./src/compat/index.js",
+    "./compat/register": "./src/compat/register.js",
+    "./compat/bedrock-protocol": "./src/compat/bedrock-protocol.js"
+  },
+  "main": "./src/index.js",
+  "directories": {
+    "test": "test"
+  },
+  "files": [
+    "src"
+  ],
+  "scripts": {
+    "test": "node --test test/*.test.js"
+  },
+  "dependencies": {
+    "ws": "^8.20.1"
+  }
+}

package/src/client.js

@@ -0,0 +1,209 @@
+import { EventEmitter } from "events";
+import { Connection } from "./connection.js";
+import {
+  writeUnconnectedPing,
+  writeOpenConnectionRequest1,
+  writeOpenConnectionRequest2,
+} from "./protocol/offline.js";
+import {
+  MessageId,
+  PacketReliability,
+  PacketPriority,
+  DATAGRAM_FLAG,
+  ACK_FLAG,
+  NACK_FLAG,
+  MAX_MTU_SIZE,
+  MIN_MTU_SIZE,
+} from "./constants.js";
+import { UdpTransport } from "./transport/udp.js";
+
+const CONNECT_TIMEOUT_MS = 10_000;
+const HANDSHAKE_RETRY_MS = 1_000;
+
+export class RakClient extends EventEmitter {
+  constructor(serverAddress, serverPort, guid, options = {}) {
+    super();
+    this.serverAddress = serverAddress;
+    this.serverPort    = serverPort;
+    this._guid         = guid ?? randomBigInt();
+    this._transport    = options.transport ?? new UdpTransport();
+    this._connection   = null;
+    this._state        = "disconnected";
+    this._mtu          = MAX_MTU_SIZE;
+    this._retryTimer   = undefined;
+    this._connectTimer = undefined;
+    this._retryCount   = 0;
+
+    this._transport.onMessage((msg) => this._handleMessage(msg));
+    this._transport.onError((err) => this.emit("error", err));
+  }
+
+  connect() {
+    return new Promise((resolve, reject) => {
+      if (this._state !== "disconnected") { reject(new Error("Already connecting or connected")); return; }
+
+      this._transport.bind(0).then(() => {
+        this.once("connect", resolve);
+
+        this._connectTimer = setTimeout(() => {
+          this._cleanup();
+          reject(new Error("Connection timed out"));
+        }, CONNECT_TIMEOUT_MS);
+
+        this._beginHandshake();
+      }).catch(reject);
+    });
+  }
+
+  _beginHandshake() {
+    this._state      = "ocr1";
+    this._retryCount = 0;
+    this._sendOcr1();
+
+    this._retryTimer = setInterval(() => {
+      this._retryCount++;
+      if (this._state === "ocr1") {
+        if (this._retryCount > 5) this._mtu = Math.max(this._mtu - 100, MIN_MTU_SIZE);
+        this._sendOcr1();
+      } else if (this._state === "ocr2") {
+        this._sendOcr2();
+      }
+    }, HANDSHAKE_RETRY_MS);
+  }
+
+  _sendOcr1() {
+    this._transport.send(writeOpenConnectionRequest1(this._mtu), this.serverAddress, this.serverPort);
+  }
+
+  _sendOcr2() {
+    this._transport.send(
+      writeOpenConnectionRequest2(this.serverAddress, this.serverPort, this._mtu, this._guid),
+      this.serverAddress, this.serverPort
+    );
+  }
+
+  _handleMessage(msg) {
+    if (msg.length === 0) return;
+    const flag = msg[0];
+
+    if (this._state === "connected" || this._state === "connecting") {
+      if (
+        (flag & DATAGRAM_FLAG) === DATAGRAM_FLAG ||
+        (flag & ACK_FLAG)      === ACK_FLAG       ||
+        (flag & NACK_FLAG)     === NACK_FLAG
+      ) {
+        this._connection?.handleDatagram(msg);
+        return;
+      }
+    }
+
+    switch (flag) {
+      case MessageId.UnconnectedPong:
+        this.emit("pong", msg);
+        break;
+
+      case MessageId.OpenConnectionReply1: {
+        // layout: 1(id) + 16(magic) + 8(guid) + 1(security) + 2(mtu) = 28 bytes
+        if (this._state !== "ocr1" || msg.length < 28) return;
+        this._mtu   = Math.min(msg.readUInt16BE(1 + 16 + 8 + 1), MAX_MTU_SIZE);
+        this._state = "ocr2";
+        this._sendOcr2();
+        break;
+      }
+
+      case MessageId.OpenConnectionReply2: {
+        if (this._state !== "ocr2") return;
+        this._mtu = Math.min(msg.readUInt16BE(1 + 16 + 8 + 7), MAX_MTU_SIZE);
+        if (this._retryTimer) { clearInterval(this._retryTimer); this._retryTimer = undefined; }
+        this._state = "connecting";
+        this._setupConnection();
+        break;
+      }
+
+      case MessageId.IncompatibleProtocolVersion:
+        this._cleanup(); this.emit("error", new Error("Incompatible protocol version")); break;
+      case MessageId.NoFreeIncomingConnections:
+        this._cleanup(); this.emit("error", new Error("No free incoming connections")); break;
+      case MessageId.ConnectionBanned:
+        this._cleanup(); this.emit("error", new Error("Banned from server")); break;
+    }
+  }
+
+  _setupConnection() {
+    const sendFn = (buf, a, p) => this._transport.send(buf, a, p);
+
+    this._connection = new Connection(this.serverAddress, this.serverPort, 0n, sendFn, this._mtu);
+
+    this._connection.on("connected", () => {
+      if (this._connectTimer) { clearTimeout(this._connectTimer); this._connectTimer = undefined; }
+      this._state = "connected";
+      this.emit("connect");
+    });
+
+    this._connection.on("disconnected", (reason) => {
+      this._state      = "disconnected";
+      this._connection = null;
+      this.emit("disconnect", reason);
+    });
+
+    this._connection.on("timeout", () => {
+      this._state      = "disconnected";
+      this._connection = null;
+      this.emit("disconnect", "timeout");
+    });
+
+    this._connection.on("encapsulated", (packet) => {
+      this.emit("encapsulated", packet);
+      this.emit("message", packet);
+    });
+
+    this._connection.on("error", (err) => this.emit("error", err));
+
+    this._connection.start();
+    this._connection.sendConnectionRequest(this._guid);
+  }
+
+  ping(onPong) {
+    if (onPong) {
+      this.once("pong", (msg) => {
+        try {
+          const len  = msg.readUInt16BE(33);
+          const motd = msg.slice(35, 35 + len).toString("utf8");
+          onPong(motd);
+        } catch { onPong(""); }
+      });
+    }
+
+    const buf = writeUnconnectedPing(BigInt(Date.now()), this._guid, false);
+    this._transport.bind(0).then(() => {
+      this._transport.send(buf, this.serverAddress, this.serverPort);
+    }).catch(() => {
+      this._transport.send(buf, this.serverAddress, this.serverPort);
+    });
+  }
+
+  send(buf, priority = PacketPriority.Medium, reliability = PacketReliability.ReliableOrdered, channel = 0) {
+    if (!this._connection || this._state !== "connected") throw new Error("Not connected");
+    this._connection.sendEncapsulated(buf, priority, reliability, channel);
+  }
+
+  close() { this._cleanup(); this.emit("disconnect", "local_closed"); }
+
+  _cleanup() {
+    if (this._retryTimer)   { clearInterval(this._retryTimer);  this._retryTimer  = undefined; }
+    if (this._connectTimer) { clearTimeout(this._connectTimer); this._connectTimer = undefined; }
+    if (this._connection)   { this._connection.close(true); this._connection = null; }
+    this._state = "disconnected";
+    // Delay socket close by 80ms so the OS has time to flush the disconnect
+    // notification packet before the dgram handle is destroyed.
+    setTimeout(() => this._transport.close().catch(() => {}), 80);
+  }
+
+  get isConnected() { return this._state === "connected"; }
+}
+
+function randomBigInt() {
+  const hi = BigInt(Math.floor(Math.random() * 0x7fffffff));
+  const lo = BigInt(Math.floor(Math.random() * 0xffffffff));
+  return (hi << 32n) | lo;
+}

package/src/compat/bedrock-protocol.js

@@ -0,0 +1,147 @@
+/**
+ * bedrock-protocol compatibility shim.
+ *
+ * Exports Server, Client, PacketPriority, PacketReliability with the exact
+ * same shape that bedrock-protocol expects from the `raknet-native` C++ addon.
+ *
+ * Usage:
+ *   import { patchRequire } from 'raknet-typeo/compat/register'
+ *   patchRequire()                       // before requiring bedrock-protocol
+ *   const { createServer } = require('bedrock-protocol')
+ */
+
+import { EventEmitter } from "events";
+import { RakServer as InternalServer } from "../server.js";
+import { RakClient as InternalClient } from "../client.js";
+import { PacketReliability as PktRel, PacketPriority as PktPri } from "../constants.js";
+
+export const PacketPriority = Object.freeze({
+  IMMEDIATE_PRIORITY   : PktPri.Immediate,
+  HIGH_PRIORITY        : PktPri.High,
+  MEDIUM_PRIORITY      : PktPri.Medium,
+  LOW_PRIORITY         : PktPri.Low,
+  NUMBER_OF_PRIORITIES : 4,
+});
+
+export const PacketReliability = Object.freeze({
+  UNRELIABLE                        : PktRel.Unreliable,
+  UNRELIABLE_SEQUENCED              : PktRel.UnreliableSequenced,
+  RELIABLE                          : PktRel.Reliable,
+  RELIABLE_ORDERED                  : PktRel.ReliableOrdered,
+  RELIABLE_SEQUENCED                : PktRel.ReliableSequenced,
+  RELIABLE_WITH_ACK_RECEIPT         : PktRel.ReliableWithAckReceipt,
+  RELIABLE_ORDERED_WITH_ACK_RECEIPT : PktRel.ReliableOrderedWithAckReceipt,
+  NUMBER_OF_RELIABILITIES           : 7,
+});
+
+function makeAddr(address, port) {
+  return { address, port, version: 4, hash: `${address}:${port}` };
+}
+
+function wrapConnection(conn) {
+  const addr    = makeAddr(conn.address, conn.port);
+  const emitter = new EventEmitter();
+
+  emitter.address = addr;
+  emitter.guid    = conn.guid;
+
+  emitter.send = (buffer, priority, reliability, orderingChannel = 0) => {
+    conn.sendEncapsulated(buffer, priority, reliability, orderingChannel);
+  };
+
+  emitter.sendReliable = (buffer, immediate = false) => {
+    conn.sendEncapsulated(
+      buffer,
+      immediate ? PktPri.Immediate : PktPri.Medium,
+      PktRel.ReliableOrdered,
+      0
+    );
+  };
+
+  emitter.close = () => conn.close(true);
+
+  conn.on("encapsulated", (buffer) => emitter.emit("encapsulated", { buffer, address: addr }));
+  conn.on("disconnected", (reason) => emitter.emit("disconnect", reason));
+
+  return emitter;
+}
+
+export class Server extends EventEmitter {
+  constructor(host, port, options = {}) {
+    super();
+    this._connections = new Map();
+
+    this._server = new InternalServer(
+      host, port, undefined,
+      options.maxConnections ?? 20,
+      options.message ? options.message.toString("utf8") : undefined,
+      { transport: options.transport }
+    );
+
+    this._server.on("connect", (conn) => {
+      const wrapped = wrapConnection(conn);
+      const key     = `${conn.address}:${conn.port}`;
+      this._connections.set(key, wrapped);
+      wrapped.on("disconnect", () => this._connections.delete(key));
+      this.emit("openConnection", wrapped);
+    });
+
+    this._server.on("disconnect", (conn, reason) => {
+      const key     = `${conn.address}:${conn.port}`;
+      const wrapped = this._connections.get(key);
+      if (wrapped) { this._connections.delete(key); this.emit("closeConnection", wrapped, reason); }
+    });
+
+    this._server.on("message", (buffer, conn) => {
+      this.emit("encapsulated", { buffer, address: makeAddr(conn.address, conn.port) });
+    });
+
+    this._server.on("error", (err) => this.emit("error", err));
+  }
+
+  listen()                    { return this._server.listen(); }
+  setOfflineMessage(message)  { this._server.setMotd(message.toString("utf8")); }
+  close()                     { return this._server.close(); }
+}
+
+export class Client extends EventEmitter {
+  constructor(host, port, options = {}) {
+    super();
+    this._connected = false;
+
+    this._client = new InternalClient(host, port, undefined, { transport: options.transport });
+
+    this._client.on("connect", () => { this._connected = true; this.emit("connect"); });
+
+    this._client.on("disconnect", (reason) => {
+      this._connected = false;
+      this.emit("disconnect", { reason });
+    });
+
+    this._client.on("encapsulated", (buffer) => {
+      this.emit("encapsulated", { buffer, address: makeAddr(host, port) });
+    });
+
+    this._client.on("pong", (msg) => {
+      try {
+        let extra;
+        if (msg.length > 33) { const len = msg.readUInt16BE(33); extra = msg.slice(35, 35 + len); }
+        this.emit("pong", { extra });
+      } catch { this.emit("pong", { extra: Buffer.alloc(0) }); }
+    });
+
+    this._client.on("error", (err) => this.emit("error", err));
+  }
+
+  connect()                                             { return this._client.connect(); }
+  send(buffer, priority, reliability, orderingChannel = 0) {
+    if (!this._connected) return;
+    this._client.send(buffer, priority, reliability, orderingChannel);
+  }
+  sendReliable(buffer, immediate = false) {
+    this.send(buffer, immediate ? PktPri.Immediate : PktPri.Medium, PktRel.ReliableOrdered, 0);
+  }
+  ping()  { this._client.ping(); }
+  close() { this._connected = false; this._client.close(); }
+  get isConnected() { return this._connected; }
+}

package/src/compat/index.js

@@ -0,0 +1,10 @@
+/**
+ * Re-exports for `raknet-native` drop-in compatibility (via raknet-typeo).
+ *
+ * When used as `raknet-native` via module patching (see register.js), this
+ * module exposes the exact same surface as the native C++ addon so that
+ * bedrock-protocol can use it transparently.
+ */
+
+export { Server, Client, PacketPriority, PacketReliability } from "./bedrock-protocol.js";
+export { patchRequire, configureBedrockServer }              from "./register.js";

package/src/compat/register.js

@@ -0,0 +1,62 @@
+/**
+ * Module patcher — call `patchRequire()` once at the very top of your entry
+ * point, before any `require('raknet-native')` or `require('bedrock-protocol')`
+ * calls.  Afterwards, every `require('raknet-native')` in the process will
+ * resolve to this pure-JS implementation instead of the native addon.
+ *
+ * Example (CommonJS):
+ *   require('raknet-typeo/compat/register').patchRequire()
+ *   const { createServer } = require('bedrock-protocol')
+ *
+ * Example (ESM):
+ *   import { patchRequire } from 'raknet-typeo/compat/register'
+ *   patchRequire()
+ *   const bp = await import('bedrock-protocol')
+ */
+
+import { createRequire } from "module";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname  = path.dirname(__filename);
+
+let patched = false;
+
+export function patchRequire() {
+  if (patched) return;
+  patched = true;
+
+  try {
+    const req       = createRequire(import.meta.url);
+    const NodeModule = req("module");
+    const originalResolve = NodeModule._resolveFilename.bind(NodeModule);
+    const compatPath = path.resolve(__dirname, "bedrock-protocol.js");
+
+    NodeModule._resolveFilename = function (request, ...rest) {
+      if (request === "raknet-native") return compatPath;
+      return originalResolve(request, ...rest);
+    };
+  } catch (err) {
+    console.warn(
+      "[raknet-typeo] patchRequire() failed — module hooking unavailable in this environment:",
+      err
+    );
+  }
+}
+
+/**
+ * Alternative: patch a specific bedrock-protocol server instance.
+ *
+ * @example
+ * import { configureBedrockServer } from 'raknet-typeo/compat/register'
+ * import { createServer } from 'bedrock-protocol'
+ *
+ * const server = createServer({ host: '0.0.0.0', port: 19132, version: '1.21.0' })
+ * configureBedrockServer(server)
+ */
+export function configureBedrockServer(server) {
+  const req    = createRequire(import.meta.url);
+  const compat = req(path.resolve(__dirname, "bedrock-protocol.js"));
+  server.RakServer = compat.Server;
+}