hytale-server-status-query 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bruno Caitano
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,55 @@
+# Hytale Server Status Query
+
+A library for querying Hytale server status using the QUIC protocol.
+
+## Overview
+
+This library provides a simple and efficient way to check the status of Hytale game servers. It implements a QUIC client that can connect to Hytale servers and retrieve their online status and latency information.
+
+### Features
+
+- ✅ QUIC protocol support
+- ✅ Server status checking (online/offline)
+- ✅ Ping measurement
+
+## Installation
+
+Install the package using npm:
+
+```bash
+npm install hytale-server-status-query
+```
+
+```bash
+yarn add hytale-server-status-query
+```
+
+## Usage
+
+### Basic Usage
+
+```ts
+import { HytaleQuicClient } from 'hytale-server-status-query';
+
+const client = new HytaleQuicClient('your-server-address.com');
+
+client.checkServerStatus()
+  .then(result => {
+    console.log('Server Status:', result);
+  })
+  .catch(error => {
+    console.error('Error:', error.message);
+  });
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## Author
+
+Made with ❤️ by the SnowDev

package/dist/index.js

@@ -0,0 +1,128 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HytaleQuicClient = void 0;
+const dgram_1 = __importDefault(require("dgram"));
+const crypto_1 = __importDefault(require("crypto"));
+class HytaleQuicClient {
+    constructor(host, port = 5520, timeout = 5000) {
+        this.host = host;
+        this.port = port;
+        this.socket = null;
+        this.timeout = timeout;
+    }
+    createQuicInitialPacket() {
+        const buffer = Buffer.allocUnsafe(1200);
+        let offset = 0;
+        // Header Form (1 bit) = 1 (Long Header)
+        // Fixed Bit (1 bit) = 1
+        // Long Packet Type (2 bits) = 00 (Initial)
+        // Reserved Bits (2 bits) = 00
+        // Packet Number Length (2 bits) = 00 (1 byte)
+        const headerByte = 0b11000000; // 0xC0
+        buffer.writeUInt8(headerByte, offset++);
+        // Version (4 bytes) - QUIC v1 (RFC 9000)
+        buffer.writeUInt32BE(0x00000001, offset);
+        offset += 4;
+        // Destination Connection ID Length (1 byte)
+        const destConnIdLength = 8;
+        buffer.writeUInt8(destConnIdLength, offset++);
+        // Destination Connection ID (8 bytes - random)
+        const destConnId = crypto_1.default.randomBytes(8);
+        destConnId.copy(buffer, offset);
+        offset += destConnIdLength;
+        // Source Connection ID Length (1 byte)
+        const srcConnIdLength = 8;
+        buffer.writeUInt8(srcConnIdLength, offset++);
+        // Source Connection ID (8 bytes - random)
+        const srcConnId = crypto_1.default.randomBytes(8);
+        srcConnId.copy(buffer, offset);
+        offset += srcConnIdLength;
+        // Token Length (Variable Length Integer) - 0 para Initial sem token
+        buffer.writeUInt8(0, offset++);
+        // Length (Variable Length Integer)
+        // Tamanho do payload restante (simplificado)
+        const payloadLength = 100;
+        buffer.writeUInt16BE(0x4000 | payloadLength, offset); // 2-byte VarInt
+        offset += 2;
+        // Packet Number (1 byte)
+        buffer.writeUInt8(0, offset++);
+        // Payload - CRYPTO frame com ClientHello simplificado
+        // Frame Type: CRYPTO (0x06)
+        buffer.writeUInt8(0x06, offset++);
+        // Offset (VarInt) - 0
+        buffer.writeUInt8(0x00, offset++);
+        // Length (VarInt)
+        const cryptoDataLength = 50;
+        buffer.writeUInt8(cryptoDataLength, offset++);
+        // CRYPTO Data (TLS ClientHello simplificado)
+        // Este é um ClientHello mínimo para testar a conexão
+        const clientHello = Buffer.from([
+            0x01,
+            0x00, 0x00, 0x2e,
+            0x03, 0x03,
+            // Random (32 bytes)
+            ...crypto_1.default.randomBytes(32),
+            0x00,
+            0x00, 0x02,
+            0x13, 0x01,
+            0x01,
+            0x00, // Compression Method: none
+        ]);
+        clientHello.copy(buffer, offset, 0, Math.min(clientHello.length, cryptoDataLength));
+        offset += cryptoDataLength;
+        // Padding para atingir 1200 bytes mínimos
+        while (offset < 1200) {
+            buffer.writeUInt8(0, offset++);
+        }
+        return buffer.slice(0, 1200);
+    }
+    checkServerStatus() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const startTime = Date.now();
+                this.socket = dgram_1.default.createSocket('udp4');
+                const timeoutId = setTimeout(() => {
+                    reject(new Error(`Timeout: Servidor não respondeu em ${this.timeout}ms`));
+                }, this.timeout);
+                this.socket.on('error', (err) => {
+                    clearTimeout(timeoutId);
+                    reject(new Error(`Erro na conexão: ${err.message}`));
+                });
+                this.socket.on('message', (msg, rinfo) => {
+                    clearTimeout(timeoutId);
+                    const ping = Date.now() - startTime;
+                    resolve({
+                        online: true,
+                        ping: ping,
+                    });
+                });
+                try {
+                    const quicPacket = this.createQuicInitialPacket();
+                    this.socket.send(quicPacket, 0, quicPacket.length, this.port, this.host, (err) => {
+                        if (err) {
+                            clearTimeout(timeoutId);
+                            reject(new Error(`Erro ao enviar pacote: ${err.message}`));
+                        }
+                    });
+                }
+                catch (error) {
+                    clearTimeout(timeoutId);
+                    reject(new Error(`Erro ao criar pacote: ${error.message}`));
+                }
+            });
+        });
+    }
+}
+exports.HytaleQuicClient = HytaleQuicClient;

package/index.d.ts

@@ -0,0 +1,12 @@
+declare module "hytale-server-status-query" {
+  export interface ServerResponse {
+    online: boolean;
+    ping: number;
+  }
+
+  export class HytaleQuicClient {
+    constructor(host: string, port?: number, timeout?: number);
+
+    checkServerStatus(): Promise<ServerResponse>;
+  }
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "hytale-server-status-query",
+  "description": "Cliente QUIC para verificar status de servidores Hytale",
+  "version": "1.0.0",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SnowRunescape/hytale-server-status-query.git"
+  },
+  "scripts": {
+    "build": "tsc",
+    "package-release": "npm run build && npm publish"
+  },
+  "files": [
+    "dist",
+    "index.d.ts"
+  ],
+  "devDependencies": {
+    "@types/node": "^25.0.10",
+    "typescript": "^5.1.6"
+  },
+  "keywords": [
+    "hytale",
+    "server",
+    "status",
+    "query",
+    "quic"
+  ]
+}