@serverkgg/bridge 0.0.13 → 0.0.14

package/src/rcon/rconClient.test.ts

@@ -0,0 +1,1544 @@
+import { describe, expect, test } from "bun:test";
+import type { Socket } from "bun";
+import { BridgeRconCode, BridgeRconError } from "../core";
+import { RconClient } from "./rconClient";
+import {
+	concatBytes,
+	decodeRconFrames,
+	encodeRconFrame,
+	RCON_AUTH_FAILED_ID,
+	RCON_BODY_LIMIT,
+	RCON_REPLY_LIMIT,
+	RCON_SPLIT_THRESHOLD,
+	type RconFrame,
+	RconRequest,
+	RconResponse,
+} from "./rconFrame";
+import { createRconWriter, type RconWriter } from "./rconWriter";
+
+const HOST = "127.0.0.1";
+
+const CLOSED_PORT = 59_433;
+
+const PASSWORD = "kX7-forbidden-in-errors";
+
+const LAST_ID = 2_147_483_646;
+
+const EMPTY = new Uint8Array(0);
+
+const TRAILER_BODY = String.fromCharCode(0, 1, 0, 0);
+
+const LONG_BODY = "a".repeat(RCON_SPLIT_THRESHOLD);
+
+type FakeSocket = Socket<undefined>;
+
+interface RconPeer {
+	frame(frame: RconFrame): void;
+	raw(bytes: Uint8Array): void;
+	end(): void;
+}
+
+interface RconScript {
+	strict?: boolean;
+	auth?(frame: RconFrame, peer: RconPeer): void;
+	command?(frame: RconFrame, peer: RconPeer): void;
+	probe?(frame: RconFrame, peer: RconPeer): void;
+}
+
+interface RconFake {
+	readonly port: number;
+	readonly auths: number;
+	readonly probes: number;
+	readonly closes: number;
+	readonly commands: string[];
+	readonly frames: RconFrame[];
+	password: string;
+	drop(): void;
+	stop(): void;
+}
+
+const createFake = (script: RconScript = {}): RconFake => {
+	const commands: string[] = [];
+	const frames: RconFrame[] = [];
+	const peers = new Set<FakeSocket>();
+	const buffers = new Map<FakeSocket, Uint8Array>();
+	const writers = new Map<FakeSocket, RconWriter>();
+
+	let auths = 0;
+	let probes = 0;
+	let closes = 0;
+
+	const peerOf = (socket: FakeSocket): RconPeer => {
+		const writer = writers.get(socket);
+
+		return {
+			frame(out) {
+				writer?.send(encodeRconFrame(out));
+			},
+
+			raw(bytes) {
+				writer?.send(bytes);
+			},
+
+			end() {
+				socket.end();
+			},
+		};
+	};
+
+	const onAuth =
+		script.auth
+		?? ((frame: RconFrame, peer: RconPeer) => {
+			peer.frame({
+				id: frame.id,
+				type: RconResponse.Value,
+				body: "",
+			});
+			peer.frame({
+				id: frame.body === fake.password ? frame.id : RCON_AUTH_FAILED_ID,
+				type: RconResponse.Auth,
+				body: "",
+			});
+		});
+
+	const onCommand =
+		script.command
+		?? ((frame: RconFrame, peer: RconPeer) => {
+			peer.frame({
+				id: frame.id,
+				type: RconResponse.Value,
+				body: `ran ${frame.body}`,
+			});
+		});
+
+	const onProbe =
+		script.probe
+		?? ((frame: RconFrame, peer: RconPeer) => {
+			peer.frame({
+				id: frame.id,
+				type: RconResponse.Value,
+				body: "",
+			});
+		});
+
+	const server = Bun.listen({
+		hostname: HOST,
+		port: 0,
+		socket: {
+			binaryType: "uint8array",
+			open(socket) {
+				peers.add(socket);
+				writers.set(
+					socket,
+					createRconWriter((bytes) => socket.write(bytes)),
+				);
+			},
+			close(socket) {
+				peers.delete(socket);
+				buffers.delete(socket);
+				writers.delete(socket);
+
+				closes += 1;
+			},
+			error() {},
+			drain(socket) {
+				writers.get(socket)?.drain();
+			},
+			data(socket, chunk) {
+				if (script.strict && chunk.length >= 4) {
+					const declared = new DataView(chunk.buffer, chunk.byteOffset, 4).getInt32(0, true);
+
+					if (declared !== chunk.length - 4) {
+						socket.end();
+
+						return;
+					}
+				}
+
+				const decoded = decodeRconFrames(concatBytes(buffers.get(socket) ?? EMPTY, chunk));
+
+				buffers.set(socket, decoded.rest.slice());
+
+				const peer = peerOf(socket);
+
+				for (const frame of decoded.frames) {
+					frames.push(frame);
+
+					if (frame.type === RconRequest.Auth) {
+						auths += 1;
+
+						onAuth(frame, peer);
+
+						continue;
+					}
+
+					if (frame.type === RconRequest.Command) {
+						commands.push(frame.body);
+
+						onCommand(frame, peer);
+
+						continue;
+					}
+
+					probes += 1;
+
+					onProbe(frame, peer);
+				}
+			},
+		},
+	});
+
+	const fake: RconFake = {
+		password: PASSWORD,
+		commands,
+		frames,
+
+		get port() {
+			return server.port;
+		},
+
+		get auths() {
+			return auths;
+		},
+
+		get probes() {
+			return probes;
+		},
+
+		get closes() {
+			return closes;
+		},
+
+		drop() {
+			for (const peer of peers) {
+				peer.end();
+			}
+		},
+
+		stop() {
+			server.stop(true);
+		},
+	};
+
+	return fake;
+};
+
+const until = async (check: () => boolean) => {
+	for (let attempt = 0; attempt < 400; attempt += 1) {
+		if (check()) {
+			return;
+		}
+
+		await Bun.sleep(5);
+	}
+
+	throw new Error("the fake never reached the expected state");
+};
+
+const failed = async (work: Promise<unknown>, code: BridgeRconCode) => {
+	const error = await work.catch((reason: unknown) => reason);
+
+	expect(error).toBeInstanceOf(BridgeRconError);
+	expect((error as BridgeRconError).code).toBe(code);
+
+	return error as BridgeRconError;
+};
+
+const commandIds = (fake: RconFake) => {
+	return fake.frames.filter((frame) => frame.type === RconRequest.Command).map((frame) => frame.id);
+};
+
+const connect = (fake: RconFake, options: Partial<ConstructorParameters<typeof RconClient>[0]> = {}) => {
+	return new RconClient({
+		host: HOST,
+		port: fake.port,
+		password: PASSWORD,
+		timeoutMs: 2000,
+		...options,
+	});
+};
+
+describe("RconClient authentication", () => {
+	test("connects through the empty preamble and the auth reply", async () => {
+		const fake = createFake();
+		const client = connect(fake);
+
+		try {
+			await client.connect();
+
+			expect(client.connected).toBe(true);
+			expect(fake.auths).toBe(1);
+		} finally {
+			await client.disconnect();
+
+			fake.stop();
+		}
+	});
+
+	test("connects when the server answers with the auth reply only", async () => {
+		const fake = createFake({
+			auth(frame, peer) {
+				peer.frame({
+					id: frame.id,
+					type: RconResponse.Auth,
+					body: "",
+				});
+			},
+		});
+
+		const client = connect(fake);
+
+		try {
+			await client.connect();
+
+			expect(client.connected).toBe(true);
+		} finally {
+			await client.disconnect();
+
+			fake.stop();
+		}
+	});
+
+	test("rejects a wrong password and ends the socket", async () => {
+		const fake = createFake();
+
+		fake.password = "another-password";
+
+		const client = connect(fake);
+
+		try {
+			await failed(client.connect(), BridgeRconCode.AuthFailed);
+			await until(() => fake.closes === 1);
+		} finally {
+			fake.stop();
+		}
+	});
+
+	test("reports a server that closes during authentication", async () => {
+		const fake = createFake({
+			auth(_frame, peer) {
+				peer.end();
+			},
+		});
+
+		const client = connect(fake);
+
+		try {
+			const error = await failed(client.connect(), BridgeRconCode.Closed);
+
+			expect(error.message).toContain("authentication");
+		} finally {
+			fake.stop();
+		}
+	});
+
+	test("times out an authentication the server never answers", async () => {
+		const fake = createFake({
+			auth() {},
+		});
+
+		const client = connect(fake, {
+			timeoutMs: 250,
+		});
+
+		try {
+			await failed(client.connect(), BridgeRconCode.TimedOut);
+		} finally {
+			fake.stop();
+		}
+	});
+
+	test("dials once for two sequential connect calls", async () => {
+		const fake = createFake();
+		const client = connect(fake);
+
+		try {
+			await client.connect();
+			await client.connect();
+
+			expect(fake.auths).toBe(1);
+		} finally {
+			await client.disconnect();
+
+			fake.stop();
+		}
+	});
+
+	test("never starts a third dial when an abandoned dial settles", async () => {
+		let dials = 0;
+
+		const fake = createFake({
+			auth(frame, peer) {
+				dials += 1;
+
+				const delay = dials === 1 ? 200 : 400;
+
+				setTimeout(() => {
+					peer.frame({
+						id: frame.id,
+						type: RconResponse.Value,
+						body: "",
+					});
+					peer.frame({
+						id: frame.id,
+						type: RconResponse.Auth,
+						body: "",
+					});
+				}, delay);
+			},
+		});
+
+		const client = connect(fake, {
+			timeoutMs: 3000,
+		});
+
+		try {
+			const abandoned = client.connect().catch((reason: unknown) => reason);
+
+			await client.disconnect();
+
+			const one = client.command("one");
+
+			await Bun.sleep(300);
+
+			const two = client.command("two");
+			const shared = client.connect();
+
+			expect(await abandoned).toBeInstanceOf(BridgeRconError);
+			expect(await one).toBe("ran one");
+			expect(await two).toBe("ran two");
+
+			await shared;
+
+			expect(fake.auths).toBe(2);
+		} finally {
+			await client.disconnect();
+
+			fake.stop();
+		}
+	});
+
+	test("shares one dial between concurrent connect calls", async () => {
+		const fake = createFake();
+		const client = connect(fake);
+
+		try {
+			await Promise.all([
+				client.connect(),
+				client.connect(),
+				client.connect(),
+			]);
+
+			expect(fake.auths).toBe(1);
+		} finally {
+			await client.disconnect();
+
+			fake.stop();
+		}
+	});
+});
+
+describe("RconClient packet ids", () => {
+	test("sends an increasing id for every command", async () => {
+		const fake = createFake();
+		const client = connect(fake);
+
+		try {
+			await client.command("one");
+			await client.command("two");
+			await client.command("three");
+
+			const ids = commandIds(fake);
+
+			expect(ids).toHaveLength(3);
+			expect(ids.at(1)).toBeGreaterThan(Number(ids.at(0)));
+			expect(ids.at(2)).toBeGreaterThan(Number(ids.at(1)));
+		} finally {
+			await client.disconnect();
+
+			fake.stop();
+		}
+	});
+
+	test("wraps its ids without ever sending zero or minus one", async () => {
+		const fake = createFake();
+
+		const client = connect(fake, {
+			idSeed: LAST_ID - 3,
+		});
+
+		try {
+			await client.command("one");
+			await client.command("two");
+
+			expect(commandIds(fake)).toEqual([
+				LAST_ID - 3,
+				1,
+			]);
+
+			for (const frame of fake.frames) {
+				expect(frame.id).toBeGreaterThan(0);
+			}
+		} finally {
+			await client.disconnect();
+
+			fake.stop();
+		}
+	});
+
+	test("ignores a reply carrying a foreign id", async () => {
+		const fake = createFake({
+			command(frame, peer) {
+				peer.frame({
+					id: frame.id + 5000,
+					type: RconResponse.Value,
+					body: "someone else",
+				});
+				peer.frame({
+					id: frame.id,
+					type: RconResponse.Value,
+					body: "mine",
+				});
+			},
+		});
+
+		const client = connect(fake);
+
+		try {
+			expect(await client.command("status")).toBe("mine");
+		} finally {
+			await client.disconnect();
+
+			fake.stop();
+		}
+	});
+
+	test("ignores unsolicited keep-alive frames around a reply", async () => {
+		const fake = createFake({
+			command(frame, peer) {
+				peer.frame({
+					id: 0,
+					type: RconResponse.Value,
+					body: "Keep Alive",
+				});
+				peer.frame({
+					id: frame.id,
+					type: RconResponse.Value,
+					body: LONG_BODY,
+				});
+				peer.frame({
+					id: 0,
+					type: RconResponse.Value,
+					body: "Keep Alive",
+				});
+				peer.frame({
+					id: frame.id,
+					type: RconResponse.Value,
+					body: "second",
+				});
+			},
+		});
+
+		const client = connect(fake);
+
+		try {
+			expect(await client.command("listplayers")).toBe(`${LONG_BODY}second`);
+		} finally {
+			await client.disconnect();
+
+			fake.stop();
+		}
+	});
+
+	test("ignores a frame of an unknown type", async () => {
+		const fake = createFake({
+			command(frame, peer) {
+				peer.frame({
+					id: frame.id,
+					type: 4,
+					body: "webrcon noise",
+				});
+				peer.frame({
+					id: frame.id,
+					type: RconResponse.Value,
+					body: "clean",
+				});
+			},
+		});
+
+		const client = connect(fake);
+
+		try {
+			expect(await client.command("status")).toBe("clean");
+		} finally {
+			await client.disconnect();
+
+			fake.stop();
+		}
+	});
+});
+
+describe("RconClient fragmentation", () => {
+	test("joins a reply written one byte at a time", async () => {
+		const fake = createFake({
+			command(frame, peer) {
+				const bytes = encodeRconFrame({
+					id: frame.id,
+					type: RconResponse.Value,
+					body: "byte by byte",
+				});
+
+				for (const byte of bytes) {
+					peer.raw(
+						new Uint8Array([
+							byte,
+						]),
+					);
+				}
+			},
+		});
+
+		const client = connect(fake);
+
+		try {
+			expect(await client.command("status")).toBe("byte by byte");
+		} finally {
+			await client.disconnect();
+
+			fake.stop();
+		}
+	});
+
+	test("reads two frames delivered in one chunk", async () => {
+		const fake = createFake({
+			command(frame, peer) {
+				peer.raw(
+					concatBytes(
+						encodeRconFrame({
+							id: frame.id,
+							type: RconResponse.Value,
+							body: LONG_BODY,
+						}),
+						encodeRconFrame({
+							id: frame.id,
+							type: RconResponse.Value,
+							body: "one chunk",
+						}),
+					),
+				);
+			},
+		});
+
+		const client = connect(fake);
+
+		try {
+			expect(await client.command("status")).toBe(`${LONG_BODY}one chunk`);
+		} finally {
+			await client.disconnect();
+
+			fake.stop();
+		}
+	});
+
+	test("joins a reply split at the body limit", async () => {
+		const fake = createFake({
+			command(frame, peer) {
+				peer.frame({
+					id: frame.id,
+					type: RconResponse.Value,
+					body: "a".repeat(RCON_BODY_LIMIT),
+				});
+				peer.frame({
+					id: frame.id,
+					type: RconResponse.Value,
+					body: "b".repeat(RCON_BODY_LIMIT),
+				});
+			},
+		});
+
+		const client = connect(fake);
+
+		try {
+			expect(await client.command("status")).toHaveLength(RCON_BODY_LIMIT * 2);
+		} finally {
+			await client.disconnect();
+
+			fake.stop();
+		}
+	});
+});
+
+describe("RconClient multi-packet replies", () => {
+	test("settles a short reply without ever sending a probe", async () => {
+		const fake = createFake();
+		const client = connect(fake);
+
+		try {
+			expect(await client.command("list")).toBe("ran list");
+			expect(fake.probes).toBe(0);
+		} finally {
+			await client.disconnect();
+
+			fake.stop();
+		}
+	});
+
+	test("joins every value frame in order at the probe echo", async () => {
+		const fake = createFake({
+			command(frame, peer) {
+				for (const part of [
+					LONG_BODY,
+					"second-",
+					"third",
+				]) {
+					peer.frame({
+						id: frame.id,
+						type: RconResponse.Value,
+						body: part,
+					});
+				}
+			},
+		});
+
+		const client = connect(fake);
+
+		try {
+			expect(await client.command("status")).toBe(`${LONG_BODY}second-third`);
+		} finally {
+			await client.disconnect();
+
+			fake.stop();
+		}
+	});
+
+	test("drops the srcds trailer that follows the echo", async () => {
+		const fake = createFake({
+			command(frame, peer) {
+				peer.frame({
+					id: frame.id,
+					type: RconResponse.Value,
+					body: LONG_BODY,
+				});
+			},
+			probe(frame, peer) {
+				peer.frame({
+					id: frame.id,
+					type: RconResponse.Value,
+					body: "",
+				});
+				peer.frame({
+					id: frame.id,
+					type: RconResponse.Value,
+					body: TRAILER_BODY,
+				});
+			},
+		});
+
+		const client = connect(fake);
+
+		try {
+			expect(await client.command("first")).toBe(LONG_BODY);
+			expect(await client.command("second")).toBe(LONG_BODY);
+		} finally {
+			await client.disconnect();
+
+			fake.stop();
+		}
+	});
+
+	test("terminates on the minecraft echo without appending it", async () => {
+		const fake = createFake({
+			command(frame, peer) {
+				peer.frame({
+					id: frame.id,
+					type: RconResponse.Value,
+					body: LONG_BODY,
+				});
+			},
+			probe(frame, peer) {
+				peer.frame({
+					id: frame.id,
+					type: RconResponse.Value,
+					body: "Unknown request 0",
+				});
+			},
+		});
+
+		const client = connect(fake);
+
+		try {
+			expect(await client.command("list")).toBe(LONG_BODY);
+		} finally {
+			await client.disconnect();
+
+			fake.stop();
+		}
+	});
+
+	test("settles on the first frame and sends no probe when multi-packet is off", async () => {
+		const fake = createFake({
+			command(frame, peer) {
+				peer.frame({
+					id: frame.id,
+					type: RconResponse.Value,
+					body: LONG_BODY,
+				});
+			},
+		});
+
+		const client = connect(fake, {
+			multiPacket: false,
+		});
+
+		try {
+			expect(await client.command("/players")).toBe(LONG_BODY);
+			expect(fake.probes).toBe(0);
+		} finally {
+			await client.disconnect();
+
+			fake.stop();
+		}
+	});
+
+	test("never puts two frames in one write for a server that refuses them", async () => {
+		const fake = createFake({
+			strict: true,
+			command(frame, peer) {
+				if (frame.body === "long") {
+					peer.frame({
+						id: frame.id,
+						type: RconResponse.Value,
+						body: LONG_BODY,
+					});
+					peer.frame({
+						id: frame.id,
+						type: RconResponse.Value,
+						body: "tail",
+					});
+
+					return;
+				}
+
+				peer.frame({
+					id: frame.id,
+					type: RconResponse.Value,
+					body: `ran ${frame.body}`,
+				});
+			},
+		});
+
+		const client = connect(fake);
+
+		try {
+			expect(await client.command("short")).toBe("ran short");
+			expect(await client.command("long")).toBe(`${LONG_BODY}tail`);
+			expect(fake.probes).toBe(1);
+			expect(fake.closes).toBe(0);
+		} finally {
+			await client.disconnect();
+
+			fake.stop();
+		}
+	});
+});
+
+describe("RconClient unmirrored ids", () => {
+	const palworld = () => {
+		return createFake({
+			command(_frame, peer) {
+				peer.frame({
+					id: 0,
+					type: RconResponse.Value,
+					body: LONG_BODY,
+				});
+			},
+		});
+	};
+
+	test("times out when the server answers with an id it never sent", async () => {
+		const fake = palworld();
+
+		const client = connect(fake, {
+			timeoutMs: 250,
+		});
+
+		try {
+			await failed(client.command("Info"), BridgeRconCode.TimedOut);
+		} finally {
+			fake.stop();
+		}
+	});
+
+	test("settles on the first value frame and sends no probe when ids are not mirrored", async () => {
+		const fake = palworld();
+
+		const client = connect(fake, {
+			mirroredIds: false,
+		});
+
+		try {
+			expect(await client.command("Info")).toBe(LONG_BODY);
+			expect(fake.probes).toBe(0);
+		} finally {
+			await client.disconnect();
+
+			fake.stop();
+		}
+	});
+
+	test("still drops a frame that arrives with no command in flight", async () => {
+		const fake = createFake({
+			auth(frame, peer) {
+				peer.frame({
+					id: frame.id,
+					type: RconResponse.Auth,
+					body: "",
+				});
+
+				setTimeout(() => {
+					peer.frame({
+						id: 0,
+						type: RconResponse.Value,
+						body: "unsolicited",
+					});
+				}, 20);
+			},
+		});
+
+		const client = connect(fake, {
+			mirroredIds: false,
+		});
+
+		try {
+			await client.connect();
+			await Bun.sleep(60);
+
+			expect(await client.command("ShowPlayers")).toBe("ran ShowPlayers");
+		} finally {
+			await client.disconnect();
+
+			fake.stop();
+		}
+	});
+});
+
+describe("RconClient failures", () => {
+	test("drops the link on a malformed frame and reconnects", async () => {
+		let broken = false;
+
+		const fake = createFake({
+			command(frame, peer) {
+				if (broken) {
+					peer.frame({
+						id: frame.id,
+						type: RconResponse.Value,
+						body: `ran ${frame.body}`,
+					});
+
+					return;
+				}
+
+				broken = true;
+
+				const packet = new Uint8Array(14);
+
+				new DataView(packet.buffer).setInt32(0, 2, true);
+
+				peer.raw(packet);
+			},
+		});
+
+		const client = connect(fake);
+
+		try {
+			await failed(client.command("first"), BridgeRconCode.Malformed);
+
+			expect(client.connected).toBe(false);
+			expect(await client.command("second")).toBe("ran second");
+			expect(fake.auths).toBe(2);
+		} finally {
+			await client.disconnect();
+
+			fake.stop();
+		}
+	});
+
+	test("reports a reply above the reply limit", async () => {
+		const fake = createFake({
+			command(frame, peer) {
+				for (let part = 0; part * RCON_BODY_LIMIT <= RCON_REPLY_LIMIT; part += 1) {
+					peer.frame({
+						id: frame.id,
+						type: RconResponse.Value,
+						body: "x".repeat(RCON_BODY_LIMIT),
+					});
+				}
+			},
+			probe() {},
+		});
+
+		const client = connect(fake);
+
+		try {
+			await failed(client.command("status"), BridgeRconCode.Oversized);
+		} finally {
+			await client.disconnect();
+
+			fake.stop();
+		}
+	});
+
+	test("refuses a body above the packet limit without touching the network", async () => {
+		const fake = createFake();
+		const client = connect(fake);
+
+		try {
+			await failed(client.command("x".repeat(RCON_BODY_LIMIT + 1)), BridgeRconCode.Oversized);
+
+			expect(fake.auths).toBe(0);
+		} finally {
+			await client.disconnect();
+
+			fake.stop();
+		}
+	});
+
+	test("reports a port nothing listens on", async () => {
+		const client = new RconClient({
+			host: HOST,
+			port: CLOSED_PORT,
+			password: PASSWORD,
+			timeoutMs: 1000,
+		});
+
+		await failed(client.connect(), BridgeRconCode.Unreachable);
+	});
+});
+
+describe("RconClient timeouts", () => {
+	test("times out a command the server never answers and never resends it", async () => {
+		const fake = createFake({
+			command() {},
+			probe() {},
+		});
+
+		const client = connect(fake, {
+			timeoutMs: 250,
+		});
+
+		try {
+			await failed(client.command("status"), BridgeRconCode.TimedOut);
+
+			expect(fake.commands.filter((body) => body === "status")).toHaveLength(1);
+		} finally {
+			fake.stop();
+		}
+	});
+
+	test("honours a per-command timeout shorter than the default", async () => {
+		const fake = createFake({
+			command() {},
+			probe() {},
+		});
+
+		const client = connect(fake, {
+			timeoutMs: 5000,
+		});
+
+		try {
+			const startedAt = performance.now();
+
+			await failed(
+				client.command("status", {
+					timeoutMs: 200,
+				}),
+				BridgeRconCode.TimedOut,
+			);
+
+			expect(performance.now() - startedAt).toBeLessThan(2000);
+		} finally {
+			fake.stop();
+		}
+	});
+
+	test("honours a per-command timeout longer than the default", async () => {
+		const fake = createFake({
+			command(frame, peer) {
+				setTimeout(() => {
+					peer.frame({
+						id: frame.id,
+						type: RconResponse.Value,
+						body: "late",
+					});
+				}, 400);
+			},
+		});
+
+		const client = connect(fake, {
+			timeoutMs: 200,
+			multiPacket: false,
+		});
+
+		try {
+			expect(
+				await client.command("status", {
+					timeoutMs: 2000,
+				}),
+			).toBe("late");
+		} finally {
+			await client.disconnect();
+
+			fake.stop();
+		}
+	});
+
+	test("times out a queued command on its own deadline without writing it", async () => {
+		const fake = createFake({
+			command() {},
+			probe() {},
+		});
+
+		const client = connect(fake, {
+			timeoutMs: 5000,
+		});
+
+		try {
+			const stalled = client.command("stalled", {
+				timeoutMs: 1000,
+			});
+
+			const queued = client.command("queued", {
+				timeoutMs: 200,
+			});
+
+			await failed(queued, BridgeRconCode.TimedOut);
+			await failed(stalled, BridgeRconCode.TimedOut);
+
+			expect(fake.commands).toEqual([
+				"stalled",
+			]);
+		} finally {
+			fake.stop();
+		}
+	});
+
+	test("reconnects and re-authenticates after a timeout", async () => {
+		let served = 0;
+
+		const fake = createFake({
+			command(frame, peer) {
+				served += 1;
+
+				if (served === 1) {
+					return;
+				}
+
+				peer.frame({
+					id: frame.id,
+					type: RconResponse.Value,
+					body: `ran ${frame.body}`,
+				});
+			},
+		});
+
+		const client = connect(fake, {
+			timeoutMs: 300,
+		});
+
+		try {
+			await failed(client.command("one"), BridgeRconCode.TimedOut);
+
+			expect(await client.command("two")).toBe("ran two");
+			expect(fake.auths).toBe(2);
+		} finally {
+			await client.disconnect();
+
+			fake.stop();
+		}
+	});
+
+	test("never writes a command whose deadline passed while the client was dialing", async () => {
+		const fake = createFake({
+			auth(frame, peer) {
+				setTimeout(() => {
+					peer.frame({
+						id: frame.id,
+						type: RconResponse.Value,
+						body: "",
+					});
+					peer.frame({
+						id: frame.id,
+						type: RconResponse.Auth,
+						body: "",
+					});
+				}, 300);
+			},
+		});
+
+		const client = connect(fake, {
+			timeoutMs: 2000,
+		});
+
+		try {
+			await failed(
+				client.command("status", {
+					timeoutMs: 100,
+				}),
+				BridgeRconCode.TimedOut,
+			);
+
+			await Bun.sleep(500);
+
+			expect(fake.commands).toEqual([]);
+			expect(fake.auths).toBe(1);
+		} finally {
+			await client.disconnect();
+
+			fake.stop();
+		}
+	});
+});
+
+describe("RconClient reconnects", () => {
+	test("reconnects transparently after the server closes between commands", async () => {
+		const fake = createFake();
+		const client = connect(fake);
+
+		try {
+			expect(await client.command("first")).toBe("ran first");
+
+			fake.drop();
+
+			await until(() => !client.connected);
+
+			expect(await client.command("second")).toBe("ran second");
+			expect(fake.auths).toBe(2);
+		} finally {
+			await client.disconnect();
+
+			fake.stop();
+		}
+	});
+
+	test("never resends a command the server cut off mid-reply", async () => {
+		const fake = createFake({
+			command(frame, peer) {
+				if (frame.body === "risky") {
+					peer.end();
+
+					return;
+				}
+
+				peer.frame({
+					id: frame.id,
+					type: RconResponse.Value,
+					body: `ran ${frame.body}`,
+				});
+			},
+		});
+
+		const client = connect(fake);
+
+		try {
+			await failed(client.command("risky"), BridgeRconCode.Closed);
+
+			expect(fake.commands.filter((body) => body === "risky")).toHaveLength(1);
+			expect(await client.command("safe")).toBe("ran safe");
+		} finally {
+			await client.disconnect();
+
+			fake.stop();
+		}
+	});
+
+	test("locks the client when the password stops working on a reconnect", async () => {
+		const fake = createFake();
+		const client = connect(fake);
+
+		try {
+			await client.connect();
+
+			fake.password = "rotated";
+
+			fake.drop();
+
+			await until(() => !client.connected);
+			await failed(client.command("first"), BridgeRconCode.AuthFailed);
+
+			expect(fake.auths).toBe(2);
+
+			await failed(client.command("second"), BridgeRconCode.AuthFailed);
+
+			expect(fake.auths).toBe(2);
+
+			fake.password = PASSWORD;
+
+			await client.connect();
+
+			expect(fake.auths).toBe(3);
+			expect(await client.command("third")).toBe("ran third");
+		} finally {
+			await client.disconnect();
+
+			fake.stop();
+		}
+	});
+});
+
+describe("RconClient concurrency", () => {
+	test("runs parallel commands in order with distinct ids", async () => {
+		const fake = createFake();
+		const client = connect(fake);
+
+		try {
+			expect(
+				await Promise.all([
+					client.command("one"),
+					client.command("two"),
+					client.command("three"),
+				]),
+			).toEqual([
+				"ran one",
+				"ran two",
+				"ran three",
+			]);
+
+			expect(new Set(commandIds(fake)).size).toBe(3);
+		} finally {
+			await client.disconnect();
+
+			fake.stop();
+		}
+	});
+
+	test("keeps a timed-out command from failing the next one", async () => {
+		const fake = createFake({
+			command(frame, peer) {
+				if (frame.body === "slow") {
+					return;
+				}
+
+				peer.frame({
+					id: frame.id,
+					type: RconResponse.Value,
+					body: `ran ${frame.body}`,
+				});
+			},
+		});
+
+		const client = connect(fake, {
+			timeoutMs: 400,
+		});
+
+		try {
+			const slow = client.command("slow");
+
+			const fast = client.command("fast", {
+				timeoutMs: 3000,
+			});
+
+			await failed(slow, BridgeRconCode.TimedOut);
+
+			expect(await fast).toBe("ran fast");
+		} finally {
+			await client.disconnect();
+
+			fake.stop();
+		}
+	});
+
+	test("rejects queued commands on disconnect and reconnects afterwards", async () => {
+		const fake = createFake({
+			command(frame, peer) {
+				if (frame.body === "stalled") {
+					return;
+				}
+
+				peer.frame({
+					id: frame.id,
+					type: RconResponse.Value,
+					body: `ran ${frame.body}`,
+				});
+			},
+		});
+
+		const client = connect(fake);
+
+		try {
+			const stalled = client.command("stalled");
+			const queued = client.command("queued");
+
+			await until(() => fake.commands.length === 1);
+			await client.disconnect();
+			await failed(stalled, BridgeRconCode.Closed);
+			await failed(queued, BridgeRconCode.Closed);
+
+			expect(fake.commands).toEqual([
+				"stalled",
+			]);
+			expect(await client.command("after")).toBe("ran after");
+			expect(fake.auths).toBe(2);
+		} finally {
+			await client.disconnect();
+
+			fake.stop();
+		}
+	});
+});
+
+describe("RconClient shutdown", () => {
+	test("ends the socket and resolves when the server closes it", async () => {
+		const fake = createFake();
+		const client = connect(fake);
+
+		try {
+			await client.connect();
+			await client.disconnect();
+			await until(() => fake.closes === 1);
+
+			expect(client.connected).toBe(false);
+		} finally {
+			fake.stop();
+		}
+	});
+
+	test("is idempotent", async () => {
+		const fake = createFake();
+		const client = connect(fake);
+
+		try {
+			await client.connect();
+			await client.disconnect();
+			await client.disconnect();
+
+			expect(client.connected).toBe(false);
+		} finally {
+			fake.stop();
+		}
+	});
+
+	test("resolves when the client never connected", async () => {
+		const fake = createFake();
+		const client = connect(fake);
+
+		try {
+			await client.disconnect();
+
+			expect(fake.auths).toBe(0);
+		} finally {
+			fake.stop();
+		}
+	});
+
+	test("tracks connected across a reconnect and a server close", async () => {
+		const fake = createFake();
+		const client = connect(fake);
+
+		try {
+			await client.connect();
+
+			expect(client.connected).toBe(true);
+
+			await client.disconnect();
+
+			expect(client.connected).toBe(false);
+
+			await client.connect();
+
+			expect(client.connected).toBe(true);
+
+			fake.drop();
+
+			await until(() => !client.connected);
+		} finally {
+			await client.disconnect();
+
+			fake.stop();
+		}
+	});
+});
+
+describe("RconClient secrecy", () => {
+	test("never names the password in an error", async () => {
+		const rejected = createFake();
+
+		rejected.password = "rotated";
+
+		const silent = createFake({
+			auth() {},
+		});
+
+		const cut = createFake({
+			auth(_frame, peer) {
+				peer.end();
+			},
+		});
+
+		const unreachable = new RconClient({
+			host: HOST,
+			port: CLOSED_PORT,
+			password: PASSWORD,
+			timeoutMs: 500,
+		});
+
+		try {
+			const errors = [
+				await failed(connect(rejected).connect(), BridgeRconCode.AuthFailed),
+				await failed(
+					connect(silent, {
+						timeoutMs: 250,
+					}).connect(),
+					BridgeRconCode.TimedOut,
+				),
+				await failed(connect(cut).connect(), BridgeRconCode.Closed),
+				await failed(unreachable.connect(), BridgeRconCode.Unreachable),
+			];
+
+			for (const error of errors) {
+				expect(error.message).not.toContain(PASSWORD);
+			}
+		} finally {
+			rejected.stop();
+			silent.stop();
+			cut.stop();
+		}
+	});
+
+	test("never names the command text in a timeout error", async () => {
+		const fake = createFake({
+			command() {},
+			probe() {},
+		});
+
+		const client = connect(fake, {
+			timeoutMs: 250,
+		});
+
+		try {
+			const error = await failed(client.command("banid 3 leaker"), BridgeRconCode.TimedOut);
+
+			expect(error.message).not.toContain("leaker");
+		} finally {
+			fake.stop();
+		}
+	});
+});
+
+describe("RconClient socket hygiene", () => {
+	test("leaves no socket open when the connect deadline passes", async () => {
+		const fake = createFake({
+			auth() {},
+		});
+
+		const client = connect(fake, {
+			timeoutMs: 200,
+		});
+
+		try {
+			await failed(client.connect(), BridgeRconCode.TimedOut);
+			await until(() => fake.closes === 1);
+		} finally {
+			fake.stop();
+		}
+	});
+});