@serverkgg/bridge 0.0.12 → 0.0.13

package/src/steam/workshop.ts

@@ -0,0 +1,148 @@
+import type { BridgeContext } from "../context";
+import { BridgeHttpMethod } from "../protocol";
+import type { Steamcmd } from "./steamcmd";
+
+export const STEAM_REMOTE_STORAGE = "https://api.steampowered.com/ISteamRemoteStorage";
+
+export const WORKSHOP_CONTENT_DIRECTORY = "steamapps/workshop/content";
+
+const FORM_CONTENT_TYPE = "application/x-www-form-urlencoded";
+
+const DETAILS_CACHE_SECONDS = 600;
+
+const DOWNLOAD_BATCH = 20;
+
+export interface SteamWorkshopTag {
+	tag: string;
+}
+
+export interface SteamPublishedFile {
+	publishedfileid: string;
+	result: number;
+	creator?: string;
+	consumer_app_id?: number;
+	title?: string;
+	description?: string;
+	preview_url?: string;
+	file_size?: string;
+	time_created?: number;
+	time_updated?: number;
+	banned?: number;
+	tags?: SteamWorkshopTag[];
+}
+
+export interface SteamCollectionChild {
+	publishedfileid: string;
+	sortorder: number;
+	filetype: number;
+}
+
+export interface SteamCollection {
+	publishedfileid: string;
+	result: number;
+	children?: SteamCollectionChild[];
+}
+
+interface PublishedFileResponse {
+	response?: {
+		publishedfiledetails?: SteamPublishedFile[];
+	};
+}
+
+interface CollectionResponse {
+	response?: {
+		collectiondetails?: SteamCollection[];
+	};
+}
+
+export const workshopContentPath = (
+	workshopAppId: string,
+	id: string,
+	directory: string = WORKSHOP_CONTENT_DIRECTORY,
+) => {
+	return `${directory}/${workshopAppId}/${id}`;
+};
+
+export const workshopFormBody = (countKey: string, ids: string[]) => {
+	const form = new URLSearchParams();
+
+	form.set(countKey, String(ids.length));
+
+	for (const [index, id] of ids.entries()) {
+		form.set(`publishedfileids[${index}]`, id);
+	}
+
+	return form.toString();
+};
+
+const uniqueIds = (ids: string[]) => {
+	return [
+		...new Set(ids.filter((id) => id.length > 0)),
+	];
+};
+
+const post = async <Result>(context: BridgeContext, url: string, body: string) => {
+	return await context.net.json<Result>(url, {
+		httpMethod: BridgeHttpMethod.Post,
+		headers: {
+			"content-type": FORM_CONTENT_TYPE,
+		},
+		body,
+		cacheSeconds: DETAILS_CACHE_SECONDS,
+	});
+};
+
+export const publishedFileDetails = async (context: BridgeContext, ids: string[]): Promise<SteamPublishedFile[]> => {
+	const wanted = uniqueIds(ids);
+
+	if (wanted.length === 0) {
+		return [];
+	}
+
+	const page = await post<PublishedFileResponse>(
+		context,
+		`${STEAM_REMOTE_STORAGE}/GetPublishedFileDetails/v1/`,
+		workshopFormBody("itemcount", wanted),
+	);
+
+	return page.response?.publishedfiledetails ?? [];
+};
+
+export const collectionDetails = async (context: BridgeContext, ids: string[]): Promise<SteamCollection[]> => {
+	const wanted = uniqueIds(ids);
+
+	if (wanted.length === 0) {
+		return [];
+	}
+
+	const page = await post<CollectionResponse>(
+		context,
+		`${STEAM_REMOTE_STORAGE}/GetCollectionDetails/v1/`,
+		workshopFormBody("collectioncount", wanted),
+	);
+
+	return page.response?.collectiondetails ?? [];
+};
+
+export interface WorkshopDownloadOptions {
+	workshopAppId: string;
+	ids: string[];
+	batch?: number;
+}
+
+export const workshopDownloadArgs = (workshopAppId: string, ids: string[]) => {
+	return ids.flatMap((id) => [
+		"+workshop_download_item",
+		workshopAppId,
+		id,
+	]);
+};
+
+export const workshopDownload = async (steamcmd: Steamcmd, options: WorkshopDownloadOptions) => {
+	const wanted = uniqueIds(options.ids);
+	const batch = options.batch ?? DOWNLOAD_BATCH;
+
+	for (let cursor = 0; cursor < wanted.length; cursor += batch) {
+		await steamcmd.run(workshopDownloadArgs(options.workshopAppId, wanted.slice(cursor, cursor + batch)));
+	}
+};

package/src/utils/execDetail.ts

@@ -0,0 +1,16 @@
+import type { BridgeExecResult } from "../context";
+
+const FAILURE_DETAIL = 800;
+
+const tail = (text: string) => {
+	return text.trim().slice(-FAILURE_DETAIL);
+};
+
+export const execDetail = (result: BridgeExecResult) => {
+	return [
+		tail(result.stdout),
+		tail(result.stderr),
+	]
+		.filter((part) => part.length > 0)
+		.join(" | ");
+};

package/src/utils/index.ts

@@ -1,2 +1,4 @@
+export * from "./execDetail";
 export * from "./glob";
 export * from "./stripAnsi";
+export * from "./token";

package/src/utils/token.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, test } from "bun:test";
+import { generateToken, TOKEN_ALPHABET } from "./token";
+
+describe("generateToken", () => {
+	test("returns a token of the requested length from the default alphabet", () => {
+		const token = generateToken(40);
+
+		expect(token).toHaveLength(40);
+		expect(
+			[
+				...token,
+			].every((character) => TOKEN_ALPHABET.includes(character)),
+		).toBe(true);
+	});
+
+	test("uses the alphabet it is given", () => {
+		expect(generateToken(32, "ab")).toMatch(/^[ab]{32}$/);
+	});
+
+	test("does not repeat itself", () => {
+		expect(generateToken(24)).not.toBe(generateToken(24));
+	});
+
+	test("draws every character of a small alphabet", () => {
+		const seen = new Set([
+			...generateToken(2000, "abc"),
+		]);
+
+		expect(
+			[
+				...seen,
+			].sort(),
+		).toEqual([
+			"a",
+			"b",
+			"c",
+		]);
+	});
+
+	test("refuses a length that is not a positive integer", () => {
+		expect(() => generateToken(0)).toThrow();
+		expect(() => generateToken(-4)).toThrow();
+		expect(() => generateToken(1.5)).toThrow();
+	});
+
+	test("refuses an unusable alphabet", () => {
+		expect(() => generateToken(8, "")).toThrow();
+		expect(() => generateToken(8, "x".repeat(257))).toThrow();
+	});
+});

package/src/utils/token.ts

@@ -0,0 +1,35 @@
+export const TOKEN_ALPHABET = "abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+
+const BYTE_RANGE = 256;
+
+export const generateToken = (length: number, alphabet: string = TOKEN_ALPHABET) => {
+	if (!Number.isSafeInteger(length) || length <= 0) {
+		throw new Error("a token needs a positive length");
+	}
+
+	if (alphabet.length === 0 || alphabet.length > BYTE_RANGE) {
+		throw new Error(`a token alphabet needs between 1 and ${BYTE_RANGE} characters`);
+	}
+
+	const ceiling = Math.floor(BYTE_RANGE / alphabet.length) * alphabet.length;
+	const bytes = new Uint8Array(length);
+	const picked: string[] = [];
+
+	while (picked.length < length) {
+		crypto.getRandomValues(bytes);
+
+		for (const byte of bytes) {
+			if (picked.length === length) {
+				break;
+			}
+
+			if (byte >= ceiling) {
+				continue;
+			}
+
+			picked.push(alphabet[byte % alphabet.length] ?? "");
+		}
+	}
+
+	return picked.join("");
+};

package/src/wine/index.ts

@@ -0,0 +1,3 @@
+export * from "./protonCommand";
+export * from "./wineCommand";
+export * from "./winePrefix";

package/src/wine/protonCommand.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, test } from "bun:test";
+import type { BridgeContext } from "../context";
+import { protonCommand, protonCompatPath } from "./protonCommand";
+
+const ensured: string[] = [];
+
+const context = {
+	files: {
+		async ensure(...paths: string[]) {
+			ensured.push(...paths);
+		},
+	},
+} as unknown as BridgeContext;
+
+describe("protonCompatPath", () => {
+	test("gives every app its own compat data directory", () => {
+		expect(protonCompatPath("2430930")).toBe(".proton/2430930");
+	});
+});
+
+describe("protonCommand", () => {
+	test("builds an env prefix pointing inside the container home", async () => {
+		expect(
+			await protonCommand(context, {
+				appId: "2430930",
+				exe: "ArkAscendedServer.exe",
+				args: [
+					"TheIsland_WP?listen",
+				],
+			}),
+		).toEqual([
+			"env",
+			"HOME=/home/container",
+			"STEAM_COMPAT_DATA_PATH=/home/container/.proton/2430930",
+			"STEAM_COMPAT_CLIENT_INSTALL_PATH=/home/container/.steam",
+			"WINEDEBUG=-all",
+			"/opt/proton/proton",
+			"run",
+			"ArkAscendedServer.exe",
+			"TheIsland_WP?listen",
+		]);
+	});
+
+	test("ensures the compat and steam directories", async () => {
+		ensured.length = 0;
+
+		await protonCommand(context, {
+			appId: "2278520",
+			exe: "enshrouded_server.exe",
+		});
+
+		expect(ensured).toEqual([
+			".proton/2278520",
+			".steam",
+		]);
+	});
+
+	test("honours another proton build", async () => {
+		expect(
+			await protonCommand(context, {
+				appId: "1",
+				exe: "a.exe",
+				protonDir: "/opt/proton-ge",
+			}),
+		).toContain("/opt/proton-ge/proton");
+	});
+});

package/src/wine/protonCommand.ts

@@ -0,0 +1,49 @@
+import type { BridgeContext } from "../context";
+import { CONTAINER_HOME } from "./wineCommand";
+
+export const PROTON_DIRECTORY = "/opt/proton";
+
+export const PROTON_COMPAT_DIRECTORY = ".proton";
+
+export const STEAM_COMPAT_CLIENT_DIRECTORY = ".steam";
+
+export interface ProtonCommandOptions {
+	appId: string;
+	exe: string;
+	args?: string[];
+	protonDir?: string;
+	compatDir?: string;
+	steamDir?: string;
+	home?: string;
+	environment?: Record<string, string>;
+}
+
+export const protonCompatPath = (appId: string, compatDir: string = PROTON_COMPAT_DIRECTORY) => {
+	return `${compatDir}/${appId}`;
+};
+
+export const protonCommand = async (context: BridgeContext, options: ProtonCommandOptions): Promise<string[]> => {
+	const home = options.home ?? CONTAINER_HOME;
+	const protonDir = options.protonDir ?? PROTON_DIRECTORY;
+	const steamDir = options.steamDir ?? STEAM_COMPAT_CLIENT_DIRECTORY;
+	const compat = protonCompatPath(options.appId, options.compatDir);
+
+	await context.files.ensure(compat, steamDir);
+
+	const environment: Record<string, string> = {
+		HOME: home,
+		STEAM_COMPAT_DATA_PATH: `${home}/${compat}`,
+		STEAM_COMPAT_CLIENT_INSTALL_PATH: `${home}/${steamDir}`,
+		WINEDEBUG: "-all",
+		...options.environment,
+	};
+
+	return [
+		"env",
+		...Object.entries(environment).map(([key, value]) => `${key}=${value}`),
+		`${protonDir}/proton`,
+		"run",
+		options.exe,
+		...(options.args ?? []),
+	];
+};

package/src/wine/wineCommand.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, test } from "bun:test";
+import type { BridgeContext } from "../context";
+import { wineCommand, wineDllOverrides } from "./wineCommand";
+
+const ensured: string[] = [];
+
+const context = {
+	files: {
+		async ensure(...paths: string[]) {
+			ensured.push(...paths);
+		},
+	},
+} as unknown as BridgeContext;
+
+describe("wineDllOverrides", () => {
+	test("joins the overrides the way wine reads them", () => {
+		expect(
+			wineDllOverrides({
+				winhttp: "n,b",
+				mscoree: "",
+			}),
+		).toBe("winhttp=n,b;mscoree=");
+	});
+});
+
+describe("wineCommand", () => {
+	test("builds an env prefix pointing inside the container home", async () => {
+		expect(
+			await wineCommand(context, {
+				exe: "VRisingServer.exe",
+				args: [
+					"-persistentDataPath",
+					"./save-data",
+				],
+			}),
+		).toEqual([
+			"env",
+			"HOME=/home/container",
+			"WINEPREFIX=/home/container/.wine",
+			"WINEDEBUG=-all",
+			"wine",
+			"VRisingServer.exe",
+			"-persistentDataPath",
+			"./save-data",
+		]);
+	});
+
+	test("ensures the prefix directory it points at", async () => {
+		ensured.length = 0;
+
+		await wineCommand(context, {
+			exe: "a.exe",
+			prefix: ".prefix",
+		});
+
+		expect(ensured).toEqual([
+			".prefix",
+		]);
+	});
+
+	test("wraps the game in xvfb-run when asked", async () => {
+		const argv = await wineCommand(context, {
+			exe: "a.exe",
+			xvfb: true,
+		});
+
+		expect(argv.slice(-4)).toEqual([
+			"xvfb-run",
+			"-a",
+			"wine",
+			"a.exe",
+		]);
+	});
+
+	test("adds the dll overrides and extra environment", async () => {
+		const argv = await wineCommand(context, {
+			exe: "a.exe",
+			dllOverrides: {
+				winhttp: "n,b",
+			},
+			environment: {
+				WINEDEBUG: "warn+all",
+				DXVK_HUD: "0",
+			},
+		});
+
+		expect(argv).toContain("WINEDLLOVERRIDES=winhttp=n,b");
+		expect(argv).toContain("WINEDEBUG=warn+all");
+		expect(argv).toContain("DXVK_HUD=0");
+		expect(argv).not.toContain("WINEDEBUG=-all");
+	});
+});

package/src/wine/wineCommand.ts

@@ -0,0 +1,54 @@
+import type { BridgeContext } from "../context";
+
+export const CONTAINER_HOME = "/home/container";
+
+export const WINE_PREFIX_DIRECTORY = ".wine";
+
+export interface WineCommandOptions {
+	exe: string;
+	args?: string[];
+	xvfb?: boolean;
+	dllOverrides?: Record<string, string>;
+	prefix?: string;
+	home?: string;
+	environment?: Record<string, string>;
+}
+
+export const wineDllOverrides = (overrides: Record<string, string>) => {
+	return Object.entries(overrides)
+		.map(([library, mode]) => `${library}=${mode}`)
+		.join(";");
+};
+
+export const wineCommand = async (context: BridgeContext, options: WineCommandOptions): Promise<string[]> => {
+	const home = options.home ?? CONTAINER_HOME;
+	const prefix = options.prefix ?? WINE_PREFIX_DIRECTORY;
+
+	await context.files.ensure(prefix);
+
+	const environment: Record<string, string> = {
+		HOME: home,
+		WINEPREFIX: `${home}/${prefix}`,
+		WINEDEBUG: "-all",
+		...(options.dllOverrides === undefined
+			? {}
+			: {
+					WINEDLLOVERRIDES: wineDllOverrides(options.dllOverrides),
+				}),
+		...options.environment,
+	};
+
+	return [
+		"env",
+		...Object.entries(environment).map(([key, value]) => `${key}=${value}`),
+		...(options.xvfb === true
+			? [
+					"xvfb-run",
+					"-a",
+				]
+			: []),
+		"wine",
+		options.exe,
+		...(options.args ?? []),
+	];
+};

package/src/wine/winePrefix.test.ts

@@ -0,0 +1,111 @@
+import { describe, expect, test } from "bun:test";
+import type { BridgeContext, BridgeExecOptions } from "../context";
+import { prepareWinePrefix, WINE_PREFIX_STAMP } from "./winePrefix";
+
+const testContext = (code = 0) => {
+	const stored = new Map<string, string>();
+	const runs: string[][] = [];
+	const logs: string[] = [];
+
+	const context = {
+		files: {
+			async exists(path: string) {
+				return stored.has(path);
+			},
+			async read(path: string) {
+				return stored.get(path) ?? "";
+			},
+			async write(path: string, content: string) {
+				stored.set(path, content);
+			},
+			async ensure() {
+				return;
+			},
+		},
+		async exec(command: string[], _options?: BridgeExecOptions) {
+			runs.push(command);
+
+			return {
+				stdout: "",
+				stderr: code === 0 ? "" : "wineboot exploded",
+				code,
+			};
+		},
+		log(message: string) {
+			logs.push(message);
+		},
+	} as unknown as BridgeContext;
+
+	return {
+		context,
+		runs,
+		logs,
+		stored,
+	};
+};
+
+describe("prepareWinePrefix", () => {
+	test("boots a wine prefix once and stamps it", async () => {
+		const { context, runs, stored } = testContext();
+
+		await prepareWinePrefix(context);
+
+		expect(runs).toHaveLength(1);
+		expect(runs.at(0)?.slice(-3)).toEqual([
+			"wine",
+			"wineboot",
+			"-i",
+		]);
+		expect(stored.get(WINE_PREFIX_STAMP)).toContain('"ready": true');
+
+		await prepareWinePrefix(context);
+
+		expect(runs).toHaveLength(1);
+	});
+
+	test("boots the prefix through proton when asked", async () => {
+		const { context, runs } = testContext();
+
+		await prepareWinePrefix(context, {
+			proton: true,
+			appId: "2430930",
+		});
+
+		expect(runs.at(0)?.slice(-4)).toEqual([
+			"/opt/proton/proton",
+			"run",
+			"wineboot",
+			"-i",
+		]);
+	});
+
+	test("boots again when the runtime changed from wine to proton", async () => {
+		const { context, runs } = testContext();
+
+		await prepareWinePrefix(context);
+		await prepareWinePrefix(context, {
+			proton: true,
+			appId: "1",
+		});
+
+		expect(runs).toHaveLength(2);
+	});
+
+	test("refuses a proton prefix with no app id", async () => {
+		const { context } = testContext();
+
+		await expect(
+			prepareWinePrefix(context, {
+				proton: true,
+			}),
+		).rejects.toThrow("steam app id");
+	});
+
+	test("raises when wineboot fails and leaves no stamp", async () => {
+		const { context, stored } = testContext(1);
+
+		await expect(prepareWinePrefix(context)).rejects.toThrow("wineboot exploded");
+
+		expect(stored.has(WINE_PREFIX_STAMP)).toBe(false);
+	});
+});