@serverkgg/bridge 0.1.11 → 0.1.12

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@serverkgg/bridge",
-	"version": "0.1.11",
+	"version": "0.1.12",
 	"description": "Serverk game bridge and driver runtime, wire protocol, manifest schema, and maintainer CLI",
 	"homepage": "https://serverk.gg",
 	"license": "SEE LICENSE IN LICENSE.md",

package/src/runtime/bridgeLineSpacing.test.ts

@@ -0,0 +1,132 @@
+import { describe, expect, it } from "bun:test";
+import { createLineSpacing } from "./bridgeLineSpacing";
+
+const shown = (lines: string[]) => {
+	const spacing = createLineSpacing();
+
+	return lines.flatMap((line) => spacing(line));
+};
+
+describe("createLineSpacing", () => {
+	it("drops the blank a game prints after every line once the pattern is clear", () => {
+		expect(
+			shown([
+				"[LOG] one",
+				"",
+				"[LOG] two",
+				"",
+				"[LOG] three",
+				"",
+				"[LOG] four",
+				"",
+				"[LOG] five",
+				"",
+			]),
+		).toEqual([
+			"[LOG] one",
+			"",
+			"[LOG] two",
+			"",
+			"[LOG] three",
+			"[LOG] four",
+			"[LOG] five",
+		]);
+	});
+
+	it("keeps a single blank line a single-spaced game uses to separate blocks", () => {
+		expect(
+			shown([
+				"Loading world",
+				"Loading players",
+				"",
+				"Server ready",
+			]),
+		).toEqual([
+			"Loading world",
+			"Loading players",
+			"",
+			"Server ready",
+		]);
+	});
+
+	it("collapses a run of blank lines into one", () => {
+		expect(
+			shown([
+				"banner",
+				"",
+				"",
+				"",
+				"first log line",
+			]),
+		).toEqual([
+			"banner",
+			"",
+			"first log line",
+		]);
+	});
+
+	it("still shows a deliberate break inside a double-spaced stream", () => {
+		expect(
+			shown([
+				"a",
+				"",
+				"b",
+				"",
+				"c",
+				"",
+				"d",
+				"",
+				"",
+				"e",
+			]),
+		).toEqual([
+			"a",
+			"",
+			"b",
+			"",
+			"c",
+			"d",
+			"",
+			"e",
+		]);
+	});
+
+	it("drops blank lines before the first line and whitespace-only lines", () => {
+		expect(
+			shown([
+				"",
+				"   ",
+				"first",
+			]),
+		).toEqual([
+			"first",
+		]);
+	});
+
+	it("goes back to keeping single blanks when the game starts writing lines back to back", () => {
+		expect(
+			shown([
+				"a",
+				"",
+				"b",
+				"",
+				"c",
+				"",
+				"d",
+				"e",
+				"",
+				"f",
+			]),
+		).toEqual([
+			"a",
+			"",
+			"b",
+			"",
+			"c",
+			"d",
+			"e",
+			"",
+			"f",
+		]);
+	});
+});

package/src/runtime/bridgeLineSpacing.ts

@@ -0,0 +1,49 @@
+const DOUBLE_SPACED_RUN = 3;
+
+export type BridgeLineSpacing = (line: string) => string[];
+
+export const createLineSpacing = (): BridgeLineSpacing => {
+	const gaps: number[] = [];
+
+	let pending = 0;
+	let started = false;
+
+	const doubleSpaced = () => {
+		return gaps.length === DOUBLE_SPACED_RUN && gaps.every((gap) => gap === 1);
+	};
+
+	return (line) => {
+		if (line.trim().length === 0) {
+			if (started) {
+				pending += 1;
+			}
+
+			return [];
+		}
+
+		const gap = pending;
+		const first = !started;
+
+		if (started) {
+			gaps.push(gap);
+
+			if (gaps.length > DOUBLE_SPACED_RUN) {
+				gaps.shift();
+			}
+		}
+
+		started = true;
+		pending = 0;
+
+		if (first || gap === 0 || (gap === 1 && doubleSpaced())) {
+			return [
+				line,
+			];
+		}
+
+		return [
+			"",
+			line,
+		];
+	};
+};

package/src/runtime/bridgeSupervisor.ts

@@ -4,6 +4,7 @@ import { BridgeLifecycleSubject } from "../modules/bridgeLifecycleSubject";
 import { BRIDGE_STOP_SIGNALS, type BridgeStopSignal } from "../modules/bridgeStopSignal";
 import { BRIDGE_CRASH_LINE_LIMIT, BridgeCrashPhase, type BridgeCrashRecord } from "../protocol";
 import { stripAnsi } from "../utils";
+import { createLineSpacing } from "./bridgeLineSpacing";
 import type { BridgeLeveledLogger } from "./bridgeLog";
 import { errorText } from "./bridgeLog";
 import { settleUid, unprivilegedArgv } from "./bridgePrivilege";
@@ -306,6 +307,7 @@ export const createSupervisor = (options: SupervisorOptions) => {
 	const pump = async (stream: ReadableStream<Uint8Array>, kind: BridgeStream) => {
 		const decoder = new TextDecoder();
 		const reader = stream.getReader();
+		const spacing = createLineSpacing();
 
 		let buffer = "";
 
@@ -325,7 +327,7 @@ export const createSupervisor = (options: SupervisorOptions) => {
 
 			buffer = split.rest;
 
-			for (const line of split.lines) {
+			for (const line of split.lines.flatMap(spacing)) {
 				emit({
 					stream: kind,
 					line,
@@ -333,10 +335,10 @@ export const createSupervisor = (options: SupervisorOptions) => {
 			}
 		}
 
-		if (buffer.length > 0) {
+		for (const line of spacing(buffer)) {
 			emit({
 				stream: kind,
-				line: buffer,
+				line,
 			});
 		}
 	};

package/src/steam/steamcmdNarrator.test.ts

@@ -20,7 +20,7 @@ const recorder = () => {
 };
 
 describe("steamcmdNarrator", () => {
-	it("reports download progress in ten percent steps", () => {
+	it("reports download progress in ten percent steps, each line with the percent steamcmd printed", () => {
 		const { log, lines, fields } = recorder();
 		const narrate = steamcmdNarrator(log, "palworld");
 
@@ -36,10 +36,10 @@ describe("steamcmdNarrator", () => {
 		}
 
 		expect(lines).toEqual([
-			"downloading palworld",
-			"downloading palworld",
-			"downloading palworld",
-			"downloading palworld",
+			"downloading palworld 2%",
+			"downloading palworld 11%",
+			"downloading palworld 25%",
+			"downloading palworld 99%",
 		]);
 		expect(fields).toEqual([
 			{
@@ -74,6 +74,19 @@ describe("steamcmdNarrator", () => {
 		]);
 	});
 
+	it("says how much of the download is done when steamcmd prints the byte counts", () => {
+		const { log, lines } = recorder();
+		const narrate = steamcmdNarrator(log, "palworld");
+
+		narrate("Update state (0x61) downloading, progress: 1.11 (127644881 / 11530459441)");
+		narrate("Update state (0x61) downloading, progress: 40.02 (4614180864 / 11530459441)");
+
+		expect(lines).toEqual([
+			"downloading palworld 1% (122 MB of 10.7 GB)",
+			"downloading palworld 40% (4.3 GB of 10.7 GB)",
+		]);
+	});
+
 	it("passes notable lines through with the ansi stripped", () => {
 		const { log, lines } = recorder();
 		const narrate = steamcmdNarrator(log, "rust");

package/src/steam/steamcmdNarrator.ts

@@ -1,12 +1,33 @@
 import type { BridgeLog } from "../context";
 import { stripAnsi } from "../utils";
 
-const PROGRESS = /Update state \(0x[0-9a-f]+\)\s*(?<phase>[^,]+),\s*progress:\s*(?<percent>\d+)\.\d+/i;
+const PROGRESS =
+	/Update state \(0x[0-9a-f]+\)\s*(?<phase>[^,]+),\s*progress:\s*(?<percent>\d+)\.\d+(?:\s*\((?<done>\d+)\s*\/\s*(?<total>\d+)\))?/i;
+
+const GIGABYTE = 1024 ** 3;
+
+const MEGABYTE = 1024 ** 2;
 
 const PROGRESS_STEP = 10;
 
 const NOTABLE = /^(Error|Warning|Failed|Success|Logging in|Connecting|Update state \(0x\d+\) (?!downloading))/i;
 
+const byteSizeOf = (bytes: number) => {
+	if (bytes >= GIGABYTE) {
+		return `${(bytes / GIGABYTE).toFixed(1)} GB`;
+	}
+
+	return `${Math.round(bytes / MEGABYTE)} MB`;
+};
+
+const progressLineOf = (phase: string, label: string, percent: number, done: number, total: number) => {
+	if (total < MEGABYTE) {
+		return `${phase} ${label} ${percent}%`;
+	}
+
+	return `${phase} ${label} ${percent}% (${byteSizeOf(done)} of ${byteSizeOf(total)})`;
+};
+
 export const steamcmdNarrator = (log: BridgeLog, label: string) => {
 	let phase = "";
 	let reported = -1;
@@ -28,7 +49,10 @@ export const steamcmdNarrator = (log: BridgeLog, label: string) => {
 			if (step > reported) {
 				reported = step;
 
-				log(`${phase} ${label}`, {
+				const done = Number(progress.groups.done ?? 0);
+				const total = Number(progress.groups.total ?? 0);
+
+				log(progressLineOf(phase, label, percent, done, total), {
 					percent: step,
 				});
 			}

package/src/wine/protonCommand.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "bun:test";
 import type { BridgeContext } from "../context";
-import { protonCommand, protonCompatPath } from "./protonCommand";
+import { ProtonVerb, protonCommand, protonCompatPath } from "./protonCommand";
 
 const ensured: string[] = [];
 
@@ -41,6 +41,22 @@ describe("protonCommand", () => {
 		]);
 	});
 
+	it("runs straight in the prefix when asked, so the game keeps the container's stdout", async () => {
+		expect(
+			(
+				await protonCommand(context, {
+					appId: "2394010",
+					exe: "Pal/Binaries/Win64/PalServer-Win64-Shipping-Cmd.exe",
+					verb: ProtonVerb.RunInPrefix,
+				})
+			).slice(-3),
+		).toEqual([
+			"/opt/proton/proton",
+			"runinprefix",
+			"Pal/Binaries/Win64/PalServer-Win64-Shipping-Cmd.exe",
+		]);
+	});
+
 	it("ensures the compat and steam directories", async () => {
 		ensured.length = 0;
 

package/src/wine/protonCommand.ts

@@ -7,6 +7,11 @@ export const PROTON_COMPAT_DIRECTORY = ".proton";
 
 export const STEAM_COMPAT_CLIENT_DIRECTORY = ".steam";
 
+export enum ProtonVerb {
+	Run = "run",
+	RunInPrefix = "runinprefix",
+}
+
 export interface ProtonCommandOptions {
 	appId: string;
 	exe: string;
@@ -16,6 +21,7 @@ export interface ProtonCommandOptions {
 	steamDir?: string;
 	home?: string;
 	environment?: Record<string, string>;
+	verb?: ProtonVerb;
 }
 
 export const protonCompatPath = (appId: string, compatDir: string = PROTON_COMPAT_DIRECTORY) => {
@@ -42,7 +48,7 @@ export const protonCommand = async (context: BridgeContext, options: ProtonComma
 		"env",
 		...Object.entries(environment).map(([key, value]) => `${key}=${value}`),
 		`${protonDir}/proton`,
-		"run",
+		options.verb ?? ProtonVerb.Run,
 		options.exe,
 		...(options.args ?? []),
 	];