@serverkgg/bridge 0.0.13 → 0.0.14

package/src/runtime/bridgeConsoleHandler.test.ts

@@ -0,0 +1,196 @@
+import { describe, expect, test } from "bun:test";
+import type { BridgeCommandOptions, BridgeContext, BridgeReply } from "../context";
+import { BridgeKind, BridgeUserError } from "../core";
+import type { BridgeDriver, BridgeTerminalModule } from "../modules";
+import { createConsoleHandler } from "./bridgeConsoleHandler";
+
+const context = {} as unknown as BridgeContext;
+
+const driverWith = (terminal: BridgeTerminalModule | undefined): BridgeDriver => ({
+	install: {
+		kind: BridgeKind.Install,
+		run: async () => {
+			return;
+		},
+	},
+	lifecycle: {
+		kind: BridgeKind.Lifecycle,
+		command: async () => [
+			"run",
+		],
+	},
+	terminal,
+});
+
+const terminalWith = (run: BridgeTerminalModule["run"]): BridgeTerminalModule => ({
+	kind: BridgeKind.Terminal,
+	commands: [
+		{
+			name: "Save",
+			summary: {
+				ar: "يحفظ العالم.",
+				en: "Save the world.",
+			},
+		},
+	],
+	run,
+});
+
+const handlerFor = (driver: BridgeDriver) => {
+	const written: string[] = [];
+
+	const handler = createConsoleHandler({
+		driver,
+		context,
+		async onStdin(input: string, options: BridgeCommandOptions): Promise<BridgeReply> {
+			written.push(input);
+
+			return {
+				sent: input,
+				line: options.expect ? "matched" : null,
+				groups: {},
+			};
+		},
+	});
+
+	return {
+		handler,
+		written,
+	};
+};
+
+describe("routing a console line to the driver before the game's stdin", () => {
+	test("answers with the driver's reply when the driver handles the line", async () => {
+		const { handler, written } = handlerFor(
+			driverWith(
+				terminalWith(async (_context, input) => {
+					return {
+						sent: input,
+						line: "Save requested",
+						groups: {},
+					};
+				}),
+			),
+		);
+
+		expect(await handler("Save", {})).toEqual({
+			sent: "Save",
+			line: "Save requested",
+			groups: {},
+		});
+		expect(written).toEqual([]);
+	});
+
+	test("hands the driver the same line the caller typed", async () => {
+		const seen: string[] = [];
+
+		const { handler } = handlerFor(
+			driverWith(
+				terminalWith(async (_context, input) => {
+					seen.push(input);
+
+					return {
+						sent: input,
+						line: null,
+						groups: {},
+					};
+				}),
+			),
+		);
+
+		await handler("Broadcast hello world", {});
+
+		expect(seen).toEqual([
+			"Broadcast hello world",
+		]);
+	});
+
+	test("writes the line to stdin when the driver answers null", async () => {
+		const { handler, written } = handlerFor(
+			driverWith(
+				terminalWith(async () => {
+					return null;
+				}),
+			),
+		);
+
+		expect(await handler("save-all", {})).toEqual({
+			sent: "save-all",
+			line: null,
+			groups: {},
+		});
+		expect(written).toEqual([
+			"save-all",
+		]);
+	});
+
+	test("keeps the expect and timeout of a line the driver leaves alone", async () => {
+		const { handler } = handlerFor(
+			driverWith(
+				terminalWith(async () => {
+					return null;
+				}),
+			),
+		);
+
+		expect(
+			(
+				await handler("list", {
+					expect: /players online/,
+					timeoutMs: 1000,
+				})
+			).line,
+		).toBe("matched");
+	});
+
+	test("writes the line to stdin when the driver declares no handler", async () => {
+		const { handler, written } = handlerFor(
+			driverWith({
+				kind: BridgeKind.Terminal,
+				commands: [],
+			}),
+		);
+
+		await handler("list", {});
+
+		expect(written).toEqual([
+			"list",
+		]);
+	});
+
+	test("writes the line to stdin when the game declares no terminal at all", async () => {
+		const { handler, written } = handlerFor(driverWith(undefined));
+
+		await handler("list", {});
+
+		expect(written).toEqual([
+			"list",
+		]);
+	});
+
+	test("refuses the line with the driver's own text when the driver rejects it", async () => {
+		const refusal = {
+			ar: "هذا الأمر يشتغل داخل اللعبة بس.",
+			en: "That command only works inside the game.",
+		};
+
+		const { handler, written } = handlerFor(
+			driverWith(
+				terminalWith(async () => {
+					throw new BridgeUserError(refusal);
+				}),
+			),
+		);
+
+		try {
+			await handler("TeleportToPlayer meslzy", {});
+
+			expect.unreachable();
+		} catch (error) {
+			expect(error).toBeInstanceOf(BridgeUserError);
+			expect((error as BridgeUserError).text).toEqual(refusal);
+		}
+
+		expect(written).toEqual([]);
+	});
+});

package/src/runtime/bridgeConsoleHandler.ts

@@ -0,0 +1,26 @@
+import type { BridgeCommandOptions, BridgeContext, BridgeReply } from "../context";
+import type { BridgeDriver } from "../modules";
+
+export type BridgeConsoleHandler = (input: string, options: BridgeCommandOptions) => Promise<BridgeReply>;
+
+export interface BridgeConsoleOptions {
+	driver: BridgeDriver;
+	context: BridgeContext;
+	onStdin: BridgeConsoleHandler;
+}
+
+export const createConsoleHandler = (options: BridgeConsoleOptions): BridgeConsoleHandler => {
+	return async (input, commandOptions) => {
+		const run = options.driver.terminal?.run;
+
+		if (run) {
+			const reply = await run(options.context, input);
+
+			if (reply) {
+				return reply;
+			}
+		}
+
+		return await options.onStdin(input, commandOptions);
+	};
+};

package/src/runtime/bridgeRcon.ts

@@ -1,15 +1,19 @@
 import type { BridgeRcons } from "../context";
-import { sourceRcon } from "../rcon";
+import { RconClient } from "../rcon";
 
 const RCON_HOST = "127.0.0.1";
 
 export const createBridgeRcons = (): BridgeRcons => {
 	return {
 		async source(options) {
-			return await sourceRcon({
+			const client = new RconClient({
 				...options,
 				host: RCON_HOST,
 			});
+
+			await client.connect();
+
+			return client;
 		},
 	};
 };

package/src/runtime/serve.ts

@@ -10,6 +10,7 @@ import {
 	type BridgeStatus,
 } from "../protocol";
 import { configPath, readConfig, socketPath, statePath } from "./bridgeConfigReader";
+import { createConsoleHandler } from "./bridgeConsoleHandler";
 import { createContext } from "./bridgeContext";
 import { validateDriver } from "./bridgeDriver";
 import { createEventRing } from "./bridgeEvents";
@@ -111,6 +112,14 @@ export const serve = async (driver: BridgeDriver) => {
 
 	const registry = createRegistry(driver, context, supervisor, ring);
 
+	const runConsole = createConsoleHandler({
+		driver,
+		context,
+		async onStdin(input, commandOptions) {
+			return await supervisor.command(input, commandOptions);
+		},
+	});
+
 	let current = desired;
 
 	const status = (): BridgeStatus => {
@@ -205,7 +214,7 @@ export const serve = async (driver: BridgeDriver) => {
 			await supervisor.stop();
 		},
 		async onCommand(input, expect, timeoutMs) {
-			return await supervisor.command(input, {
+			return await runConsole(input, {
 				expect: expect === undefined ? undefined : new RegExp(expect),
 				timeoutMs,
 			});

package/src/rcon/sourceRcon.test.ts

@@ -1,308 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { BridgeRconCode, BridgeRconError } from "../core";
-import { sourceRcon } from "./sourceRcon";
-import {
-	concatBytes,
-	decodeSourceRconFrames,
-	encodeSourceRconFrame,
-	SOURCE_RCON_AUTH_FAILED_ID,
-	type SourceRconFrame,
-	SourceRconRequest,
-	SourceRconResponse,
-} from "./sourceRconFrame";
-
-type Reply = (frame: SourceRconFrame) => void;
-
-const HOST = "127.0.0.1";
-
-const rconServer = (handle: (frame: SourceRconFrame, reply: Reply) => void) => {
-	const pending = new WeakMap<object, Uint8Array>();
-
-	return Bun.listen({
-		hostname: HOST,
-		port: 0,
-		socket: {
-			data(socket, chunk) {
-				const decoded = decodeSourceRconFrames(concatBytes(pending.get(socket) ?? new Uint8Array(0), chunk));
-
-				pending.set(socket, decoded.rest);
-
-				for (const frame of decoded.frames) {
-					handle(frame, (out) => {
-						socket.write(encodeSourceRconFrame(out));
-					});
-				}
-			},
-		},
-	});
-};
-
-const authOk = (frame: SourceRconFrame, reply: Reply) => {
-	reply({
-		id: frame.id,
-		type: SourceRconResponse.Value,
-		body: "",
-	});
-	reply({
-		id: frame.id,
-		type: SourceRconResponse.Auth,
-		body: "",
-	});
-};
-
-describe("sourceRcon", () => {
-	test("rejects a wrong password with an auth-failed error", async () => {
-		const server = rconServer((frame, reply) => {
-			if (frame.type !== SourceRconRequest.Auth) {
-				return;
-			}
-
-			reply({
-				id: frame.id,
-				type: SourceRconResponse.Value,
-				body: "",
-			});
-			reply({
-				id: SOURCE_RCON_AUTH_FAILED_ID,
-				type: SourceRconResponse.Auth,
-				body: "",
-			});
-		});
-
-		try {
-			const error = await sourceRcon({
-				host: HOST,
-				port: server.port,
-				password: "wrong",
-				timeoutMs: 2000,
-			}).catch((reason: unknown) => reason);
-
-			expect(error).toBeInstanceOf(BridgeRconError);
-			expect((error as BridgeRconError).code).toBe(BridgeRconCode.AuthFailed);
-		} finally {
-			server.stop(true);
-		}
-	});
-
-	test("authenticates and returns a single-packet reply", async () => {
-		const server = rconServer((frame, reply) => {
-			if (frame.type === SourceRconRequest.Auth) {
-				authOk(frame, reply);
-
-				return;
-			}
-
-			reply({
-				id: frame.id,
-				type: SourceRconResponse.Value,
-				body: frame.body.length === 0 ? "" : `ran ${frame.body}`,
-			});
-		});
-
-		try {
-			const client = await sourceRcon({
-				host: HOST,
-				port: server.port,
-				password: "right",
-				timeoutMs: 2000,
-			});
-
-			expect(await client.command("ListPlayers")).toBe("ran ListPlayers");
-
-			client.close();
-		} finally {
-			server.stop(true);
-		}
-	});
-
-	test("joins a multi-packet reply at the probe echo", async () => {
-		const server = rconServer((frame, reply) => {
-			if (frame.type === SourceRconRequest.Auth) {
-				authOk(frame, reply);
-
-				return;
-			}
-
-			if (frame.type === SourceRconResponse.Value) {
-				reply({
-					id: frame.id,
-					type: SourceRconResponse.Value,
-					body: "",
-				});
-
-				return;
-			}
-
-			for (const part of [
-				"first-",
-				"second-",
-				"third",
-			]) {
-				reply({
-					id: frame.id,
-					type: SourceRconResponse.Value,
-					body: part,
-				});
-			}
-		});
-
-		try {
-			const client = await sourceRcon({
-				host: HOST,
-				port: server.port,
-				password: "right",
-				timeoutMs: 2000,
-			});
-
-			expect(await client.command("status")).toBe("first-second-third");
-
-			client.close();
-		} finally {
-			server.stop(true);
-		}
-	});
-
-	test("settles on the first value frame when multi-packet is off", async () => {
-		let probes = 0;
-
-		const server = rconServer((frame, reply) => {
-			if (frame.type === SourceRconRequest.Auth) {
-				authOk(frame, reply);
-
-				return;
-			}
-
-			if (frame.type === SourceRconResponse.Value) {
-				probes += 1;
-
-				return;
-			}
-
-			reply({
-				id: frame.id,
-				type: SourceRconResponse.Value,
-				body: "single",
-			});
-		});
-
-		try {
-			const client = await sourceRcon({
-				host: HOST,
-				port: server.port,
-				password: "right",
-				timeoutMs: 2000,
-				multiPacket: false,
-			});
-
-			expect(await client.command("/players")).toBe("single");
-			expect(probes).toBe(0);
-
-			client.close();
-		} finally {
-			server.stop(true);
-		}
-	});
-
-	test("runs queued commands one after another", async () => {
-		const server = rconServer((frame, reply) => {
-			if (frame.type === SourceRconRequest.Auth) {
-				authOk(frame, reply);
-
-				return;
-			}
-
-			reply({
-				id: frame.id,
-				type: SourceRconResponse.Value,
-				body: frame.body.length === 0 ? "" : frame.body.toUpperCase(),
-			});
-		});
-
-		try {
-			const client = await sourceRcon({
-				host: HOST,
-				port: server.port,
-				password: "right",
-				timeoutMs: 2000,
-			});
-
-			expect(
-				await Promise.all([
-					client.command("one"),
-					client.command("two"),
-					client.command("three"),
-				]),
-			).toEqual([
-				"ONE",
-				"TWO",
-				"THREE",
-			]);
-
-			client.close();
-		} finally {
-			server.stop(true);
-		}
-	});
-
-	test("times out a command the server never answers", async () => {
-		const server = rconServer((frame, reply) => {
-			if (frame.type === SourceRconRequest.Auth) {
-				authOk(frame, reply);
-			}
-		});
-
-		try {
-			const client = await sourceRcon({
-				host: HOST,
-				port: server.port,
-				password: "right",
-				timeoutMs: 250,
-			});
-
-			const error = await client.command("status").catch((reason: unknown) => reason);
-
-			expect(error).toBeInstanceOf(BridgeRconError);
-			expect((error as BridgeRconError).code).toBe(BridgeRconCode.TimedOut);
-		} finally {
-			server.stop(true);
-		}
-	});
-
-	test("refuses a command body above the packet limit", async () => {
-		const server = rconServer((frame, reply) => {
-			if (frame.type === SourceRconRequest.Auth) {
-				authOk(frame, reply);
-			}
-		});
-
-		try {
-			const client = await sourceRcon({
-				host: HOST,
-				port: server.port,
-				password: "right",
-				timeoutMs: 2000,
-			});
-
-			const error = await client.command("x".repeat(5000)).catch((reason: unknown) => reason);
-
-			expect(error).toBeInstanceOf(BridgeRconError);
-			expect((error as BridgeRconError).code).toBe(BridgeRconCode.Oversized);
-
-			client.close();
-		} finally {
-			server.stop(true);
-		}
-	});
-
-	test("reports an unreachable port", async () => {
-		const error = await sourceRcon({
-			host: HOST,
-			port: 59_431,
-			password: "right",
-			timeoutMs: 1000,
-		}).catch((reason: unknown) => reason);
-
-		expect(error).toBeInstanceOf(BridgeRconError);
-		expect((error as BridgeRconError).code).toBe(BridgeRconCode.Unreachable);
-	});
-});