@serverkgg/bridge 0.1.1 → 0.1.2

package/src/steam/steamcmd.ts

@@ -1,4 +1,5 @@
-import type { BridgeContext } from "../context";
+import type { BridgeContext, BridgeExecResult } from "../context";
+import { BridgeUserError, type LocalizedText } from "../core";
 import { execDetail } from "../utils";
 import { installedBuildId } from "./steamApp";
 import { type SteamcmdLogin, SteamcmdLoginKind, steamcmdLoginArgs } from "./steamcmdLogin";
@@ -25,6 +26,8 @@ const ATTEMPTS = 3;
 
 const RETRY_DELAY_MS = 5000;
 
+const NO_SUBSCRIPTION = "No subscription";
+
 export interface SteamcmdOptions {
 	appId: string;
 	label: string;
@@ -100,6 +103,20 @@ export const steamcmdUpdateArgs = (appId: string, update: SteamcmdUpdateOptions)
 	return args;
 };
 
+export const steamcmdFailureText = (result: BridgeExecResult, label: string): LocalizedText => {
+	if (`${result.stdout}\n${result.stderr}`.includes(NO_SUBSCRIPTION)) {
+		return {
+			ar: `Steam رفض تنزيل ${label} لأن حساب التنزيل ما يملكه. راسل الدعم.`,
+			en: `Steam refused to download ${label} because the download account does not own it. Contact support.`,
+		};
+	}
+
+	return {
+		ar: `ما قدرنا ننزّل ${label} من Steam. جرّب مرة ثانية.`,
+		en: `We could not download ${label} from Steam. Try again.`,
+	};
+};
+
 const installRoot = async (context: BridgeContext) => {
 	const result = await context.exec([
 		"pwd",
@@ -162,7 +179,7 @@ export const createSteamcmd = (context: BridgeContext, options: SteamcmdOptions)
 
 		const attempts = runOptions.attempts ?? ATTEMPTS;
 
-		let failure = "";
+		let failure: BridgeExecResult | null = null;
 
 		for (let attempt = 1; attempt <= attempts; attempt++) {
 			const result = await context.exec(argv, {
@@ -178,7 +195,7 @@ export const createSteamcmd = (context: BridgeContext, options: SteamcmdOptions)
 				return;
 			}
 
-			failure = `steamcmd exited with code ${result.code} — ${execDetail(result)}`;
+			failure = result;
 
 			if (attempt < attempts) {
 				context.log("steamcmd did not finish, trying again", {
@@ -191,7 +208,13 @@ export const createSteamcmd = (context: BridgeContext, options: SteamcmdOptions)
 			}
 		}
 
-		throw new Error(failure);
+		if (!failure) {
+			throw new Error("steamcmd was not run");
+		}
+
+		throw new BridgeUserError(steamcmdFailureText(failure, options.label), {
+			cause: new Error(`steamcmd exited with code ${failure.code} — ${execDetail(failure)}`),
+		});
 	};
 
 	return {

package/src/utils/changedSettingKeys.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, test } from "bun:test";
+import { changedSettingKeys } from "./changedSettingKeys";
+
+describe("changedSettingKeys", () => {
+	test("keeps only the keys whose value really changed", () => {
+		expect(
+			changedSettingKeys(
+				{
+					difficulty: "easy",
+					expRate: "1.000000",
+					pvp: "True",
+					name: "My server",
+				},
+				{
+					difficulty: "hard",
+					expRate: 1,
+					pvp: true,
+					name: "My server",
+				},
+			),
+		).toEqual([
+			"difficulty",
+		]);
+	});
+
+	test("counts a key the stored values do not hold as changed", () => {
+		expect(
+			changedSettingKeys(
+				{},
+				{
+					seed: "42",
+				},
+			),
+		).toEqual([
+			"seed",
+		]);
+	});
+
+	test("counts every written key as changed when nothing could be read first", () => {
+		const written = {
+			difficulty: "hard",
+			pvp: false,
+		};
+
+		expect(changedSettingKeys(null, written)).toEqual([
+			"difficulty",
+			"pvp",
+		]);
+		expect(changedSettingKeys(undefined, written)).toEqual([
+			"difficulty",
+			"pvp",
+		]);
+	});
+
+	test("answers nothing for an empty write", () => {
+		expect(
+			changedSettingKeys(
+				{
+					difficulty: "easy",
+				},
+				{},
+			),
+		).toEqual([]);
+	});
+});

package/src/utils/changedSettingKeys.ts

@@ -0,0 +1,6 @@
+import type { BridgeValues } from "../core";
+import { sameSettingValue } from "./sameSettingValue";
+
+export const changedSettingKeys = (before: BridgeValues | null | undefined, written: BridgeValues): string[] => {
+	return Object.keys(written).filter((key) => !before || !sameSettingValue(before[key], written[key]));
+};

package/src/utils/describeExecFailure.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, test } from "bun:test";
+import { describeExecFailure } from "./describeExecFailure";
+
+describe("describeExecFailure", () => {
+	test("names the subject and the exit code in both languages", () => {
+		const text = describeExecFailure(
+			{
+				stdout: "",
+				stderr: "java.lang.RuntimeException",
+				code: 1,
+			},
+			"Forge installer",
+		);
+
+		expect(text).toEqual({
+			ar: "Forge installer فشل وطلع بكود 1.",
+			en: "Forge installer failed with exit code 1.",
+		});
+	});
+
+	test("keeps the process output out of the customer text", () => {
+		const text = describeExecFailure(
+			{
+				stdout: "token=abc",
+				stderr: "at /home/game/secret",
+				code: 2,
+			},
+			"unzip",
+		);
+
+		expect(JSON.stringify(text)).not.toContain("secret");
+		expect(JSON.stringify(text)).not.toContain("token");
+	});
+});

package/src/utils/describeExecFailure.ts

@@ -0,0 +1,9 @@
+import type { BridgeExecResult } from "../context";
+import type { LocalizedText } from "../core";
+
+export const describeExecFailure = (result: BridgeExecResult, subject: string): LocalizedText => {
+	return {
+		ar: `${subject} فشل وطلع بكود ${result.code}.`,
+		en: `${subject} failed with exit code ${result.code}.`,
+	};
+};

package/src/utils/index.ts

@@ -1,4 +1,7 @@
+export * from "./changedSettingKeys";
+export * from "./describeExecFailure";
 export * from "./execDetail";
 export * from "./glob";
+export * from "./sameSettingValue";
 export * from "./stripAnsi";
 export * from "./token";

package/src/utils/sameSettingValue.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, test } from "bun:test";
+import { sameSettingValue } from "./sameSettingValue";
+
+describe("sameSettingValue", () => {
+	test("treats a float the ini codec wrote as equal to the integer the form sends", () => {
+		expect(sameSettingValue("1.000000", 1)).toBe(true);
+		expect(sameSettingValue("1", "1.000000")).toBe(true);
+	});
+
+	test("treats decimals that differ only in trailing zeros as equal", () => {
+		expect(sameSettingValue("0.5", "0.50")).toBe(true);
+	});
+
+	test("treats boolean text as equal whatever its case", () => {
+		expect(sameSettingValue("True", "true")).toBe(true);
+		expect(sameSettingValue("False", false)).toBe(true);
+		expect(sameSettingValue(true, "FALSE")).toBe(false);
+	});
+
+	test("never treats an empty value as zero", () => {
+		expect(sameSettingValue("", "0")).toBe(false);
+		expect(sameSettingValue(null, 0)).toBe(false);
+	});
+
+	test("keeps a leading-zero string different from its number, since it may be an id", () => {
+		expect(sameSettingValue("01", "1")).toBe(false);
+	});
+
+	test("compares the trimmed text of anything else", () => {
+		expect(sameSettingValue(" easy ", "easy")).toBe(true);
+		expect(sameSettingValue("easy", "hard")).toBe(false);
+		expect(sameSettingValue("2", "3")).toBe(false);
+		expect(sameSettingValue(undefined, "")).toBe(true);
+	});
+});

package/src/utils/sameSettingValue.ts

@@ -0,0 +1,40 @@
+import type { BridgeValue } from "../core";
+
+const PLAIN_NUMBER = /^-?(0|[1-9]\d*)(\.\d+)?$/;
+
+const BOOLEAN_TEXT: Readonly<Record<string, boolean>> = {
+	true: true,
+	false: false,
+};
+
+const settingText = (value: BridgeValue | undefined) => {
+	return value === undefined || value === null ? "" : String(value).trim();
+};
+
+const numberOf = (text: string) => {
+	return PLAIN_NUMBER.test(text) ? Number(text) : null;
+};
+
+const booleanOf = (text: string) => {
+	return BOOLEAN_TEXT[text.toLowerCase()] ?? null;
+};
+
+export const sameSettingValue = (left: BridgeValue | undefined, right: BridgeValue | undefined): boolean => {
+	const a = settingText(left);
+	const b = settingText(right);
+
+	if (a === b) {
+		return true;
+	}
+
+	const leftNumber = numberOf(a);
+	const rightNumber = numberOf(b);
+
+	if (leftNumber !== null && rightNumber !== null) {
+		return leftNumber === rightNumber;
+	}
+
+	const leftBoolean = booleanOf(a);
+
+	return leftBoolean !== null && leftBoolean === booleanOf(b);
+};

package/src/wire/activity.test.ts

@@ -0,0 +1,95 @@
+import { describe, expect, test } from "bun:test";
+import { BRIDGE_ACTIVITY_DETAILS_LIMIT, BRIDGE_ACTIVITY_LIMIT, BridgeEventName } from "@serverkgg/bridge/protocol";
+import { bridgeActivitiesSchema, bridgeActivitySchema } from "./activity";
+
+const entry = {
+	name: BridgeEventName.ModpackInstalled,
+	text: {
+		ar: "ثبّتنا مودباك All the Mods 9",
+		en: "Installed modpack All the Mods 9",
+	},
+	subject: "All the Mods 9",
+	details: {
+		version: "0.3.2",
+		files: 312,
+	},
+};
+
+describe("bridgeActivitySchema", () => {
+	test("accepts a well-formed entry", () => {
+		expect(bridgeActivitySchema.parse(entry)).toEqual(entry);
+	});
+
+	test("accepts a name this reader does not know yet, so a newer game still reaches it", () => {
+		expect(
+			bridgeActivitySchema.safeParse({
+				...entry,
+				name: "PortalOpened",
+			}).success,
+		).toBe(true);
+	});
+
+	test("refuses a name that is not an event name", () => {
+		expect(
+			bridgeActivitySchema.safeParse({
+				...entry,
+				name: "portal opened",
+			}).success,
+		).toBe(false);
+	});
+
+	test("refuses an entry missing one language", () => {
+		expect(
+			bridgeActivitySchema.safeParse({
+				...entry,
+				text: {
+					ar: "",
+					en: "Installed",
+				},
+			}).success,
+		).toBe(false);
+	});
+
+	test("refuses more details than an entry carries", () => {
+		const details: Record<string, number> = {};
+
+		for (let index = 0; index <= BRIDGE_ACTIVITY_DETAILS_LIMIT; index++) {
+			details[`key${index}`] = index;
+		}
+
+		expect(
+			bridgeActivitySchema.safeParse({
+				...entry,
+				details,
+			}).success,
+		).toBe(false);
+	});
+
+	test("refuses a detail that is not a scalar", () => {
+		expect(
+			bridgeActivitySchema.safeParse({
+				...entry,
+				details: {
+					nested: {
+						deep: true,
+					},
+				},
+			}).success,
+		).toBe(false);
+	});
+});
+
+describe("bridgeActivitiesSchema", () => {
+	test("refuses more entries than one answer carries", () => {
+		expect(
+			bridgeActivitiesSchema.safeParse(
+				Array.from(
+					{
+						length: BRIDGE_ACTIVITY_LIMIT + 1,
+					},
+					() => entry,
+				),
+			).success,
+		).toBe(false);
+	});
+});

package/src/wire/activity.ts

@@ -0,0 +1,41 @@
+import {
+	BRIDGE_ACTIVITY_DETAIL_KEY_LENGTH_LIMIT,
+	BRIDGE_ACTIVITY_DETAIL_KEY_PATTERN,
+	BRIDGE_ACTIVITY_DETAILS_LIMIT,
+	BRIDGE_ACTIVITY_LIMIT,
+	BRIDGE_ACTIVITY_NAME_LENGTH_LIMIT,
+	BRIDGE_ACTIVITY_NAME_PATTERN,
+	BRIDGE_ACTIVITY_SUBJECT_LENGTH_LIMIT,
+	BRIDGE_ACTIVITY_TEXT_LENGTH_LIMIT,
+} from "@serverkgg/bridge/protocol";
+import { z } from "zod";
+
+const activityTextSchema = z.object({
+	ar: z.string().min(1).max(BRIDGE_ACTIVITY_TEXT_LENGTH_LIMIT),
+	en: z.string().min(1).max(BRIDGE_ACTIVITY_TEXT_LENGTH_LIMIT),
+});
+
+const activityDetailsSchema = z
+	.record(
+		z.string().min(1).max(BRIDGE_ACTIVITY_DETAIL_KEY_LENGTH_LIMIT).regex(BRIDGE_ACTIVITY_DETAIL_KEY_PATTERN),
+		z.union([
+			z.boolean(),
+			z.number(),
+			z.string().max(BRIDGE_ACTIVITY_TEXT_LENGTH_LIMIT),
+			z.null(),
+		]),
+	)
+	.refine((details) => Object.keys(details).length <= BRIDGE_ACTIVITY_DETAILS_LIMIT);
+
+export const bridgeActivitySchema = z.object({
+	name: z.string().min(1).max(BRIDGE_ACTIVITY_NAME_LENGTH_LIMIT).regex(BRIDGE_ACTIVITY_NAME_PATTERN),
+	text: activityTextSchema,
+	subject: z.string().min(1).max(BRIDGE_ACTIVITY_SUBJECT_LENGTH_LIMIT).optional(),
+	details: activityDetailsSchema.optional(),
+});
+
+export type BridgeActivityInput = z.infer<typeof bridgeActivitySchema>;
+
+export const bridgeActivitiesSchema = z.array(bridgeActivitySchema).max(BRIDGE_ACTIVITY_LIMIT);
+
+export type BridgeActivitiesInput = z.infer<typeof bridgeActivitiesSchema>;

package/src/wire/index.ts

@@ -1,2 +1,3 @@
+export * from "./activity";
 export * from "./panel";
 export * from "./zEnvKey";

package/src/wire/panel.test.ts

@@ -15,7 +15,7 @@ import {
 	BridgeSetupStepKind,
 	BridgeUploadMode,
 } from "@serverkgg/bridge/protocol";
-import { bridgeCellsSchema, bridgeManifestSchema } from "./panel";
+import { bridgeAvailabilitySchema, bridgeCellsSchema, bridgeManifestSchema } from "./panel";
 
 const text = (value: string) => ({
 	ar: value,
@@ -717,3 +717,69 @@ describe("the cell schema", () => {
 		).toBe(false);
 	});
 });
+
+describe("the availability schema", () => {
+	test("accepts reasons for the module and per subject", () => {
+		const availability = {
+			module: {
+				wipe: text("Closed right now"),
+			},
+			subjects: {
+				"world 1": {
+					delete: text("You cannot delete the active world"),
+				},
+			},
+		};
+
+		expect(bridgeAvailabilitySchema.parse(availability)).toEqual(availability);
+	});
+
+	test("accepts an answer with nothing unavailable", () => {
+		expect(
+			bridgeAvailabilitySchema.parse({
+				module: {},
+				subjects: {},
+			}),
+		).toEqual({
+			module: {},
+			subjects: {},
+		});
+	});
+
+	test("rejects a reason that is not localized", () => {
+		expect(
+			bridgeAvailabilitySchema.safeParse({
+				module: {
+					wipe: "closed",
+				},
+				subjects: {},
+			}).success,
+		).toBe(false);
+	});
+
+	test("keeps a manifest module that advertises availability among its actions", () => {
+		const parsed = bridgeManifestSchema.parse({
+			...manifest(),
+			modules: [
+				{
+					id: "worlds",
+					kind: BridgeKind.Collection,
+					requiresRunning: false,
+					refreshSeconds: null,
+					pageSize: null,
+					dependsOn: [],
+					actions: [
+						BridgeAction.List,
+						"delete",
+						BridgeAction.Availability,
+					],
+					protectedActions: [
+						"delete",
+					],
+				},
+			],
+		});
+
+		expect(parsed.modules[0]?.actions).toContain(BridgeAction.Availability);
+	});
+});

package/src/wire/panel.ts

@@ -68,6 +68,17 @@ export const panelTextSchema = z.object({
 	en: z.string().min(1).max(PANEL_TEXT_LENGTH_LIMIT),
 });
 
+export const bridgeUnavailableSchema = z.record(zKey, panelTextSchema);
+
+export type BridgeUnavailableInput = z.infer<typeof bridgeUnavailableSchema>;
+
+export const bridgeAvailabilitySchema = z.object({
+	module: bridgeUnavailableSchema,
+	subjects: z.record(z.string().min(1), bridgeUnavailableSchema),
+});
+
+export type BridgeAvailabilityInput = z.infer<typeof bridgeAvailabilitySchema>;
+
 export const bridgeCellSchema = z.union([
 	bridgeValueSchema,
 	panelTextSchema,