@serverkgg/bridge 0.0.7 → 0.0.9

package/src/runtime/bridgeServer.test.ts

@@ -0,0 +1,338 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { BridgeDesired, BridgeFailureCode, BridgeFailureError, BridgeRuntime, BridgeUserError } from "../core";
+import { BridgeMethod, type BridgePendingResult, type BridgeResponse } from "../protocol";
+import { createServer, type ServerOptions } from "./bridgeServer";
+
+const TOKEN = "test-token";
+
+const unreachable = (what: string) => {
+	return () => {
+		throw new Error(`${what} is not part of this test`);
+	};
+};
+
+const baseOptions = (socket: string): ServerOptions => ({
+	socket,
+	token: TOKEN,
+	onStatus: () => ({
+		version: "0.0.0",
+		runtime: BridgeRuntime.Stopped,
+		desired: BridgeDesired.Stopped,
+		exitCode: null,
+		outOfMemory: false,
+		restarts: 0,
+		installError: null,
+		installHold: null,
+	}),
+	onManifest: unreachable("manifest"),
+	onStart: unreachable("start"),
+	onStop: unreachable("stop"),
+	onCommand: unreachable("command"),
+	onInvoke: unreachable("invoke"),
+	onEvents: unreachable("events"),
+	onSample: unreachable("sample"),
+	onQuiesce: unreachable("quiesce"),
+	onRelease: unreachable("release"),
+	onDescribe: unreachable("describe"),
+	onAnnounce: unreachable("announce"),
+	onPendingList: unreachable("pendingList"),
+	onPendingAdd: unreachable("pendingAdd"),
+	onLog: () => {
+		return;
+	},
+});
+
+const call = async (socket: string, frame: Record<string, unknown>): Promise<BridgeResponse> => {
+	return await new Promise<BridgeResponse>((resolve, reject) => {
+		void Bun.connect<{
+			buffer: string;
+		}>({
+			unix: socket,
+			socket: {
+				open(connection) {
+					connection.data = {
+						buffer: "",
+					};
+
+					connection.write(`${JSON.stringify(frame)}\n`);
+				},
+
+				data(connection, chunk) {
+					connection.data.buffer += chunk.toString();
+
+					const [line] = connection.data.buffer.split("\n");
+
+					if (!line) {
+						return;
+					}
+
+					connection.end();
+
+					resolve(JSON.parse(line) as BridgeResponse);
+				},
+
+				error(_connection, error) {
+					reject(error);
+				},
+			},
+		}).catch(reject);
+	});
+};
+
+describe("pending dispatch", () => {
+	let dir = "";
+	let socket = "";
+
+	beforeEach(async () => {
+		dir = await mkdtemp(join(tmpdir(), "bridge-server-"));
+		socket = join(dir, "bridge.sock");
+	});
+
+	afterEach(async () => {
+		await rm(dir, {
+			force: true,
+			recursive: true,
+		});
+	});
+
+	const listed: BridgePendingResult = {
+		supported: true,
+		staging: ".serverk-staging/pending-upload",
+		extensions: [
+			"jar",
+		],
+		files: [],
+		rejected: null,
+	};
+
+	test("answers pendingList with what the driver lists", async () => {
+		const server = createServer({
+			...baseOptions(socket),
+			onPendingList: async () => listed,
+		});
+
+		const response = await call(socket, {
+			id: 1,
+			token: TOKEN,
+			method: BridgeMethod.PendingList,
+		});
+
+		server.stop(true);
+
+		expect(response).toEqual({
+			id: 1,
+			ok: true,
+			result: listed,
+		});
+	});
+
+	test("answers pendingList with the unsupported sentinel when the driver declares no pending module", async () => {
+		const server = createServer({
+			...baseOptions(socket),
+			onPendingList: async () => ({
+				supported: false,
+				staging: "",
+				extensions: [],
+				files: [],
+				rejected: null,
+			}),
+		});
+
+		const response = await call(socket, {
+			id: 2,
+			token: TOKEN,
+			method: BridgeMethod.PendingList,
+		});
+
+		server.stop(true);
+
+		expect(response).toEqual({
+			id: 2,
+			ok: true,
+			result: {
+				supported: false,
+				staging: "",
+				extensions: [],
+				files: [],
+				rejected: null,
+			},
+		});
+	});
+
+	test("passes the uploaded path to pendingAdd and answers with the refreshed list", async () => {
+		const received: string[] = [];
+
+		const server = createServer({
+			...baseOptions(socket),
+			onPendingAdd: async (input) => {
+				received.push(input);
+
+				return listed;
+			},
+		});
+
+		const response = await call(socket, {
+			id: 3,
+			token: TOKEN,
+			method: BridgeMethod.PendingAdd,
+			input: ".serverk-staging/pending-upload/patch.jar",
+		});
+
+		server.stop(true);
+
+		expect(received).toEqual([
+			".serverk-staging/pending-upload/patch.jar",
+		]);
+		expect(response).toEqual({
+			id: 3,
+			ok: true,
+			result: listed,
+		});
+	});
+
+	test("refuses a pendingAdd carrying no path", async () => {
+		const server = createServer({
+			...baseOptions(socket),
+			onPendingAdd: unreachable("pendingAdd"),
+		});
+
+		const response = await call(socket, {
+			id: 4,
+			token: TOKEN,
+			method: BridgeMethod.PendingAdd,
+		});
+
+		server.stop(true);
+
+		expect(response).toEqual({
+			id: 4,
+			ok: false,
+			error: "pendingAdd needs an input path",
+		});
+	});
+
+	test("answers pendingAdd with the rejection the driver reported beside the refreshed list", async () => {
+		const rejected: BridgePendingResult = {
+			...listed,
+			rejected: {
+				expected: [
+					"patch.jar",
+				],
+			},
+		};
+
+		const server = createServer({
+			...baseOptions(socket),
+			onPendingAdd: async () => rejected,
+		});
+
+		const response = await call(socket, {
+			id: 6,
+			token: TOKEN,
+			method: BridgeMethod.PendingAdd,
+			input: ".serverk-staging/pending-upload/wrong.jar",
+		});
+
+		server.stop(true);
+
+		expect(response).toEqual({
+			id: 6,
+			ok: true,
+			result: rejected,
+		});
+	});
+
+	test("names an unknown method so an older agent can degrade", async () => {
+		const server = createServer(baseOptions(socket));
+
+		const response = await call(socket, {
+			id: 5,
+			token: TOKEN,
+			method: "pendingRemove",
+		});
+
+		server.stop(true);
+
+		expect(response).toEqual({
+			id: 5,
+			ok: false,
+			error: 'unknown method "pendingRemove"',
+		});
+	});
+});
+
+describe("error serialisation", () => {
+	let dir = "";
+	let socket = "";
+
+	beforeEach(async () => {
+		dir = await mkdtemp(join(tmpdir(), "bridge-server-"));
+		socket = join(dir, "bridge.sock");
+	});
+
+	afterEach(async () => {
+		await rm(dir, {
+			force: true,
+			recursive: true,
+		});
+	});
+
+	const thrown = async (error: unknown) => {
+		const server = createServer({
+			...baseOptions(socket),
+			onPendingAdd: async () => {
+				throw error;
+			},
+		});
+
+		const response = await call(socket, {
+			id: 1,
+			token: TOKEN,
+			method: BridgeMethod.PendingAdd,
+			input: ".serverk-staging/pending-upload/patch.jar",
+		});
+
+		server.stop(true);
+
+		return response;
+	};
+
+	test("carries the localized text of a user error beside the message", async () => {
+		expect(
+			await thrown(
+				new BridgeUserError({
+					ar: "هذا مو الملف اللي ننتظره",
+					en: "this is not a file we are waiting for",
+				}),
+			),
+		).toEqual({
+			id: 1,
+			ok: false,
+			error: "this is not a file we are waiting for",
+			text: {
+				ar: "هذا مو الملف اللي ننتظره",
+				en: "this is not a file we are waiting for",
+			},
+		});
+	});
+
+	test("carries the failure code of a failure error and no text", async () => {
+		expect(await thrown(new BridgeFailureError(BridgeFailureCode.CatalogRestricted, "the author blocked it"))).toEqual({
+			id: 1,
+			ok: false,
+			error: "the author blocked it",
+			failure: BridgeFailureCode.CatalogRestricted,
+		});
+	});
+
+	test("carries the message alone for an ordinary error", async () => {
+		expect(await thrown(new Error("the file could not be read"))).toEqual({
+			id: 1,
+			ok: false,
+			error: "the file could not be read",
+		});
+	});
+});

package/src/runtime/bridgeServer.ts

@@ -1,5 +1,5 @@
 import { timingSafeEqual } from "node:crypto";
-import { BridgeFailureError, BridgeSecretError, type BridgeValues } from "../core";
+import { BridgeFailureError, BridgeSecretError, BridgeUserError, type BridgeValues } from "../core";
 import {
 	BRIDGE_FRAME_LIMIT,
 	type BridgeAnnounceResult,
@@ -8,6 +8,7 @@ import {
 	type BridgeEventsResult,
 	type BridgeManifest,
 	BridgeMethod,
+	type BridgePendingResult,
 	type BridgeQuiesceResult,
 	type BridgeResponse,
 	type BridgeSampleResult,
@@ -30,6 +31,8 @@ export interface ServerOptions {
 	onRelease: () => Promise<void>;
 	onDescribe: () => Promise<BridgeDescribeResult>;
 	onAnnounce: (message: string) => Promise<BridgeAnnounceResult>;
+	onPendingList: () => Promise<BridgePendingResult>;
+	onPendingAdd: (input: string) => Promise<BridgePendingResult>;
 	onLog: BridgeLogger;
 }
 
@@ -47,7 +50,7 @@ interface IncomingFrame {
 	message?: unknown;
 }
 
-const asMessage = (value: unknown): string | null => {
+const asText = (value: unknown): string | null => {
 	return typeof value === "string" && value.length > 0 ? value : null;
 };
 
@@ -136,7 +139,7 @@ export const createServer = (options: ServerOptions) => {
 			}
 
 			case BridgeMethod.Announce: {
-				const message = asMessage(request.message);
+				const message = asText(request.message);
 
 				if (!message) {
 					throw new Error("announce needs a message");
@@ -145,6 +148,20 @@ export const createServer = (options: ServerOptions) => {
 				return await options.onAnnounce(message);
 			}
 
+			case BridgeMethod.PendingList: {
+				return await options.onPendingList();
+			}
+
+			case BridgeMethod.PendingAdd: {
+				const input = asText(request.input);
+
+				if (!input) {
+					throw new Error("pendingAdd needs an input path");
+				}
+
+				return await options.onPendingAdd(input);
+			}
+
 			default: {
 				throw new Error(`unknown method "${method}"`);
 			}
@@ -249,6 +266,11 @@ export const createServer = (options: ServerOptions) => {
 												failure: error.code,
 											}
 										: {}),
+									...(error instanceof BridgeUserError
+										? {
+												text: error.text,
+											}
+										: {}),
 								}),
 							);
 						});

package/src/runtime/bridgeSupervisor.ts

@@ -18,6 +18,8 @@ const RESTART_LIMIT = 5;
 
 const GAME_OOM_SCORE_ADJ = 500;
 
+const SIGKILL_EXIT_CODE = 128 + 9;
+
 export interface SupervisorLine {
 	stream: BridgeStream;
 	line: string;
@@ -113,6 +115,7 @@ export const createSupervisor = (options: SupervisorOptions) => {
 	let shouldRun = false;
 	let breaker = false;
 	let exitCode: number | null = null;
+	let outOfMemory = false;
 	let restarts = 0;
 	let queue: Promise<unknown> = Promise.resolve();
 
@@ -307,6 +310,8 @@ export const createSupervisor = (options: SupervisorOptions) => {
 		exitCode = code;
 
 		if (!shouldRun) {
+			outOfMemory = false;
+
 			runtime = BridgeRuntime.Stopped;
 
 			options.onLog("game stopped", {
@@ -316,6 +321,14 @@ export const createSupervisor = (options: SupervisorOptions) => {
 			return;
 		}
 
+		outOfMemory = code === SIGKILL_EXIT_CODE;
+
+		if (outOfMemory) {
+			options.onLog.error("the game was killed for running out of memory", {
+				code,
+			});
+		}
+
 		restarts += 1;
 		restartStamps.push(performance.now());
 
@@ -375,6 +388,10 @@ export const createSupervisor = (options: SupervisorOptions) => {
 			return exitCode;
 		},
 
+		get outOfMemory() {
+			return outOfMemory;
+		},
+
 		get restarts() {
 			return restarts;
 		},
@@ -382,6 +399,7 @@ export const createSupervisor = (options: SupervisorOptions) => {
 		async start() {
 			shouldRun = true;
 			breaker = false;
+			outOfMemory = false;
 			restartStamps.length = 0;
 
 			if (child) {