@deitylamb/mcping 1.1.0

package/dist/src-Baubd7mm.cjs

@@ -0,0 +1,395 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let node_dns_promises = require("node:dns/promises");
+node_dns_promises = __toESM(node_dns_promises);
+let node_net = require("node:net");
+node_net = __toESM(node_net);
+let node_dgram = require("node:dgram");
+node_dgram = __toESM(node_dgram);
+let node_crypto = require("node:crypto");
+node_crypto = __toESM(node_crypto);
+//#region src/target.ts
+/**
+* Resolves host and port, handling SRV records and lookups.
+*/
+async function resolveTarget(targetStr, type) {
+	let host = targetStr;
+	let port = type === "bedrock" ? 19132 : 25565;
+	const parts = targetStr.split(":");
+	if (parts.length === 2 && !isNaN(parseInt(parts[1]))) {
+		host = parts[0];
+		port = parseInt(parts[1]);
+		const ip = await resolveIp(host);
+		return {
+			host,
+			port,
+			protocol: type === null ? "java" : type,
+			ip
+		};
+	}
+	if (type !== "bedrock") try {
+		const srv = await node_dns_promises.resolveSrv(`_minecraft._tcp.${host}`);
+		if (srv && srv.length > 0) {
+			const srvHost = srv[0].name;
+			return {
+				host: srvHost,
+				port: srv[0].port,
+				protocol: "java",
+				ip: await resolveIp(srvHost)
+			};
+		}
+	} catch (e) {}
+	if (type === "bedrock" && parts.length === 1) try {
+		const srv = await node_dns_promises.resolveSrv(`_minecraft._udp.${host}`);
+		if (srv && srv.length > 0) {
+			const srvHost = srv[0].name;
+			return {
+				host: srvHost,
+				port: srv[0].port,
+				protocol: "bedrock",
+				ip: await resolveIp(srvHost)
+			};
+		}
+	} catch (e) {}
+	const ip = await resolveIp(host);
+	return {
+		host,
+		port,
+		protocol: type || "java",
+		ip
+	};
+}
+async function resolveIp(host) {
+	try {
+		return (await node_dns_promises.lookup(host)).address;
+	} catch (e) {
+		return host;
+	}
+}
+//#endregion
+//#region src/varint.ts
+/**
+* VarInt encoding and decoding for Minecraft protocol.
+* Based on the specification at https://wiki.vg/Protocol#VarInt_and_VarLong
+*/
+function encodeVarInt(value) {
+	const bytes = [];
+	let temp = value >>> 0;
+	while (temp >= 128) {
+		bytes.push(temp & 127 | 128);
+		temp >>>= 7;
+	}
+	bytes.push(temp);
+	return Buffer.from(bytes);
+}
+function decodeVarInt(buffer, offset = 0) {
+	let value = 0;
+	let length = 0;
+	let currentByte;
+	while (true) {
+		currentByte = buffer.readUInt8(offset + length);
+		value |= (currentByte & 127) << length * 7;
+		length++;
+		if (length > 5) throw new Error("VarInt is too big");
+		if ((currentByte & 128) !== 128) break;
+	}
+	return {
+		value: value | 0,
+		length
+	};
+}
+function encodeString(str) {
+	const content = Buffer.from(str, "utf8");
+	return Buffer.concat([encodeVarInt(content.length), content]);
+}
+function decodeString(buffer, offset = 0) {
+	const { value: strLen, length: varIntLen } = decodeVarInt(buffer, offset);
+	return {
+		value: buffer.toString("utf8", offset + varIntLen, offset + varIntLen + strLen),
+		length: varIntLen + strLen
+	};
+}
+//#endregion
+//#region src/java-ping.ts
+async function pingJava(host, port, timeout) {
+	return new Promise((resolve, reject) => {
+		const client = new node_net.Socket();
+		let startTime;
+		let response;
+		const timeoutHandler = setTimeout(() => {
+			client.destroy();
+			reject(/* @__PURE__ */ new Error(`Connection timed out after ${timeout}ms`));
+		}, timeout);
+		client.connect(port, host, () => {
+			const protocolVersion = encodeVarInt(763);
+			const serverAddress = encodeString(host);
+			const serverPort = Buffer.alloc(2);
+			serverPort.writeUInt16BE(port);
+			const nextState = encodeVarInt(1);
+			const handshakePayload = Buffer.concat([
+				protocolVersion,
+				serverAddress,
+				serverPort,
+				nextState
+			]);
+			const packetIdBuffer = encodeVarInt(0);
+			const handshake = Buffer.concat([
+				encodeVarInt(handshakePayload.length + packetIdBuffer.length),
+				packetIdBuffer,
+				handshakePayload
+			]);
+			client.write(handshake);
+			const statusRequest = Buffer.concat([encodeVarInt(1), encodeVarInt(0)]);
+			client.write(statusRequest);
+			startTime = Date.now();
+		});
+		let data = Buffer.alloc(0);
+		client.on("data", (chunk) => {
+			data = Buffer.concat([data, chunk]);
+			while (data.length > 0) try {
+				const { value: packetLen, length: varIntLen } = decodeVarInt(data, 0);
+				if (data.length < packetLen + varIntLen) return;
+				const packet = data.subarray(varIntLen, varIntLen + packetLen);
+				data = data.subarray(varIntLen + packetLen);
+				const { value: packetId, length: idLen } = decodeVarInt(packet, 0);
+				if (packetId === 0) {
+					const { value: jsonStr } = decodeString(packet, idLen);
+					response = JSON.parse(jsonStr);
+					const pingPayload = Buffer.alloc(8);
+					pingPayload.writeBigInt64BE(BigInt(startTime));
+					const pingPacket = Buffer.concat([
+						encodeVarInt(9),
+						encodeVarInt(1),
+						pingPayload
+					]);
+					client.write(pingPacket);
+				} else if (packetId === 1) {
+					const latency = Date.now() - startTime;
+					clearTimeout(timeoutHandler);
+					client.destroy();
+					resolve({
+						response,
+						latency
+					});
+					return;
+				}
+			} catch (e) {
+				return;
+			}
+		});
+		client.on("error", (err) => {
+			clearTimeout(timeoutHandler);
+			reject(err);
+		});
+	});
+}
+//#endregion
+//#region src/bedrock-ping.ts
+const RAKNET_MAGIC = Buffer.from("00ffff00fefefefefdfdfdfd12345678", "hex");
+async function pingBedrock(host, port, timeout) {
+	return new Promise((resolve, reject) => {
+		const client = node_dgram.createSocket("udp4");
+		const timeoutHandler = setTimeout(() => {
+			client.close();
+			reject(/* @__PURE__ */ new Error(`Bedrock ping timed out after ${timeout}ms`));
+		}, timeout);
+		const startTime = BigInt(Date.now());
+		const clientGUID = node_crypto.randomBytes(8);
+		const packet = Buffer.alloc(33);
+		packet.writeUInt8(1, 0);
+		packet.writeBigInt64BE(startTime, 1);
+		RAKNET_MAGIC.copy(packet, 9);
+		clientGUID.copy(packet, 25);
+		client.send(packet, port, host);
+		client.on("message", (msg) => {
+			if (msg.readUInt8(0) === 28) {
+				clearTimeout(timeoutHandler);
+				client.close();
+				msg.readBigInt64BE(1);
+				msg.readBigInt64BE(9);
+				if (!msg.slice(17, 33).equals(RAKNET_MAGIC)) {
+					reject(/* @__PURE__ */ new Error("Invalid RakNet magic"));
+					return;
+				}
+				const stringLength = msg.readUInt16BE(33);
+				const parts = msg.toString("utf8", 35, 35 + stringLength).split(";");
+				resolve({
+					edition: parts[0] || "MCPE",
+					motdLine1: parts[1] || "",
+					protocolVersion: parseInt(parts[2]) || 0,
+					versionName: parts[3] || "",
+					playerCount: parseInt(parts[4]) || 0,
+					maxPlayerCount: parseInt(parts[5]) || 0,
+					serverUniqueId: parts[6] || "",
+					motdLine2: parts[7] || "",
+					gameMode: parts[8] || "",
+					nintendoLimited: parseInt(parts[9]) || 0,
+					ipv4Port: parts[10] ? parseInt(parts[10]) : null,
+					ipv6Port: parts[11] ? parseInt(parts[11]) : null
+				});
+			}
+		});
+		client.on("error", (err) => {
+			clearTimeout(timeoutHandler);
+			client.close();
+			reject(err);
+		});
+	});
+}
+//#endregion
+//#region src/chat.ts
+function parseChat(chat) {
+	if (typeof chat === "string") return chat;
+	if (!chat || typeof chat !== "object") return "";
+	let text = "";
+	const colorMap = {
+		black: "0",
+		dark_blue: "1",
+		dark_green: "2",
+		dark_aqua: "3",
+		dark_red: "4",
+		dark_purple: "5",
+		gold: "6",
+		gray: "7",
+		dark_gray: "8",
+		blue: "9",
+		green: "a",
+		aqua: "b",
+		red: "c",
+		light_purple: "d",
+		yellow: "e",
+		white: "f"
+	};
+	if (chat.color && colorMap[chat.color]) text += `§${colorMap[chat.color]}`;
+	if (chat.bold) text += "§l";
+	if (chat.italic) text += "§o";
+	if (chat.underlined) text += "§n";
+	if (chat.strikethrough) text += "§m";
+	if (chat.obfuscated) text += "§k";
+	text += chat.text || "";
+	if (chat.extra && Array.isArray(chat.extra)) for (const part of chat.extra) text += parseChat(part);
+	return text;
+}
+//#endregion
+//#region src/cache.ts
+const cache = /* @__PURE__ */ new Map();
+function getCache(target, options) {
+	const entry = cache.get(target);
+	if (!entry) return null;
+	if (!(Date.now() - entry.timestamp > options.ttl) || options.strategy === "swr") return {
+		...entry.response,
+		cached: true
+	};
+	return null;
+}
+function setCache(target, response) {
+	if (response.cached) return;
+	cache.set(target, {
+		response,
+		timestamp: Date.now()
+	});
+}
+function isExpired(target, options) {
+	const entry = cache.get(target);
+	if (!entry) return true;
+	return Date.now() - entry.timestamp > options.ttl;
+}
+//#endregion
+//#region src/index.ts
+async function ping(target, options) {
+	const timeout = options?.timeout || 5e3;
+	const type = options?.type || null;
+	const cacheOptions = options?.cache;
+	if (cacheOptions) {
+		const cached = getCache(target, cacheOptions);
+		if (cached) {
+			if (cacheOptions.strategy === "swr" && isExpired(target, cacheOptions)) pingServer(target, timeout, type).then((refreshed) => setCache(target, refreshed)).catch(() => {});
+			return cached;
+		}
+	}
+	const result = await pingServer(target, timeout, type);
+	if (cacheOptions) setCache(target, result);
+	return result;
+}
+async function pingServer(target, timeout, type) {
+	const resolved = await resolveTarget(target, type);
+	let javaError;
+	if (type === "java" || type === null) try {
+		const { response, latency } = await pingJava(resolved.host, resolved.port, timeout);
+		return {
+			type: "java",
+			version: {
+				name: response.version.name,
+				protocol: response.version.protocol
+			},
+			players: {
+				online: response.players.online,
+				max: response.players.max
+			},
+			motd: parseChat(response.description),
+			latency,
+			target: {
+				host: resolved.host,
+				port: resolved.port,
+				ip: resolved.ip
+			},
+			raw: response
+		};
+	} catch (e) {
+		javaError = e;
+		if (type === "java") throw e;
+	}
+	try {
+		const bedrockResolved = type === "bedrock" ? resolved : await resolveTarget(target, "bedrock");
+		const response = await pingBedrock(bedrockResolved.host, bedrockResolved.port, timeout);
+		return {
+			type: "bedrock",
+			version: {
+				name: response.versionName,
+				protocol: response.protocolVersion
+			},
+			players: {
+				online: response.playerCount,
+				max: response.maxPlayerCount
+			},
+			motd: response.motdLine2 ? `${response.motdLine1}\n${response.motdLine2}` : response.motdLine1,
+			latency: 0,
+			target: {
+				host: bedrockResolved.host,
+				port: bedrockResolved.port,
+				ip: bedrockResolved.ip
+			},
+			raw: response
+		};
+	} catch (bedrockErr) {
+		if (type === null && javaError) throw new Error(`Both Java and Bedrock pings failed. Java: ${javaError.message}. Bedrock: ${bedrockErr.message}`);
+		throw bedrockErr;
+	}
+}
+//#endregion
+Object.defineProperty(exports, "ping", {
+	enumerable: true,
+	get: function() {
+		return ping;
+	}
+});