@serverkgg/bridge 0.0.9 → 0.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@serverkgg/bridge",
-	"version": "0.0.9",
+	"version": "0.0.10",
 	"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/cli/validate.ts

@@ -230,6 +230,7 @@ const validateGamePackage = async (source: PackageSource, manifest: Manifest, di
 		`  driver: ${Object.keys(driver.modules ?? {}).length} panel module(s), ${driver.panel?.tabs.length ?? 0} tab(s)`,
 	);
 	console.log(`  pending: ${driver.pending ? `declared (${driver.pending.extensions.length} extension(s))` : "none"}`);
+	console.log(`  setup: ${driver.setup ? `${driver.setup.steps.length} step(s)` : "none"}`);
 	reportEvents(driver);
 	reportActionTargets(driver);
 };

package/src/context/bridgeContext.ts

@@ -1,5 +1,5 @@
 import type { BridgeStream, BridgeValues } from "../core";
-import type { BridgeHttpMethod } from "../protocol";
+import type { BridgeHttpMethod, BridgeSetupRuntime } from "../protocol";
 
 export interface BridgeServer {
 	code: string;
@@ -121,6 +121,12 @@ export interface BridgeExecResult {
 export interface BridgeLogs {
 	tail(lines: number): Promise<string[]>;
 	watch(pattern: RegExp, timeoutMs: number): Promise<RegExpMatchArray | null>;
+	follow(pattern: RegExp, onMatch: (match: RegExpMatchArray) => void): () => void;
+}
+
+export interface BridgeSetupReporter {
+	report(runtime: BridgeSetupRuntime): void;
+	clear(): void;
 }
 
 export interface BridgeLog {
@@ -141,6 +147,7 @@ export interface BridgeContext {
 	command(input: string, options?: BridgeCommandOptions): Promise<BridgeReply>;
 	exec(command: string[], options?: BridgeExecOptions): Promise<BridgeExecResult>;
 	logs: BridgeLogs;
+	setup: BridgeSetupReporter;
 	emit(event: string, payload?: BridgeValues): void;
 	log: BridgeLog;
 }

package/src/core/bridgeKind.ts

@@ -14,4 +14,5 @@ export enum BridgeKind {
 	Preview = "preview",
 	Query = "query",
 	Settings = "settings",
+	Setup = "setup",
 }

package/src/core/bridgeProbeError.ts

@@ -0,0 +1,16 @@
+export enum BridgeProbeCode {
+	Unreachable = "unreachable",
+	TimedOut = "timed-out",
+	Malformed = "malformed",
+}
+
+export class BridgeProbeError extends Error {
+	readonly code: BridgeProbeCode;
+
+	constructor(code: BridgeProbeCode, message: string) {
+		super(message);
+
+		this.name = "BridgeProbeError";
+		this.code = code;
+	}
+}

package/src/core/bridgeSetup.ts

@@ -0,0 +1,20 @@
+export enum BridgeSetupStepKind {
+	Driver = "driver",
+	Form = "form",
+	Open = "open",
+}
+
+export enum BridgeSetupStepState {
+	Pending = "pending",
+	Active = "active",
+	Done = "done",
+	Failed = "failed",
+}
+
+export enum BridgeSetupPromptKind {
+	Wait = "wait",
+	Progress = "progress",
+	Link = "link",
+	Action = "action",
+	Failed = "failed",
+}

package/src/core/bridgeValue.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, test } from "bun:test";
+import { isLocalizedText } from "./bridgeValue";
+
+describe("isLocalizedText", () => {
+	test("recognises the shape a driver authors copy in", () => {
+		expect(
+			isLocalizedText({
+				ar: "التركيب",
+				en: "Setup",
+			}),
+		).toBe(true);
+	});
+
+	test("leaves every other bridge value alone", () => {
+		expect(isLocalizedText("Hytale")).toBe(false);
+		expect(isLocalizedText(12)).toBe(false);
+		expect(isLocalizedText(true)).toBe(false);
+		expect(isLocalizedText(null)).toBe(false);
+		expect(isLocalizedText(undefined)).toBe(false);
+	});
+
+	test("refuses a half-written text rather than rendering an empty language", () => {
+		expect(
+			isLocalizedText({
+				en: "Setup",
+			}),
+		).toBe(false);
+	});
+});

package/src/core/bridgeValue.ts

@@ -11,6 +11,18 @@ export interface LocalizedText {
 	en: string;
 }
 
+export type BridgeCopy = LocalizedText | string;
+
+export const isLocalizedText = (value: unknown): value is LocalizedText => {
+	if (typeof value !== "object" || value === null) {
+		return false;
+	}
+
+	const text = value as Partial<LocalizedText>;
+
+	return typeof text.ar === "string" && typeof text.en === "string";
+};
+
 export interface BridgeOption {
 	value: string;
 	label: LocalizedText;

package/src/core/index.ts

@@ -6,8 +6,10 @@ export * from "./bridgeId";
 export * from "./bridgeKind";
 export * from "./bridgeNetError";
 export * from "./bridgePort";
+export * from "./bridgeProbeError";
 export * from "./bridgeRuntime";
 export * from "./bridgeSecretError";
+export * from "./bridgeSetup";
 export * from "./bridgeStream";
 export * from "./bridgeUserError";
 export * from "./bridgeValue";

package/src/guides/blocks.ts

@@ -13,6 +13,8 @@ export enum GuideOpenTab {
 	Console = "console",
 	Files = "files",
 	Backups = "backups",
+	Access = "access",
+	Setup = "setup",
 	Panel = "panel",
 }
 
@@ -51,6 +53,12 @@ export const guideOpenTargetSchema = z.discriminatedUnion("tab", [
 	z.object({
 		tab: z.literal(GuideOpenTab.Backups),
 	}),
+	z.object({
+		tab: z.literal(GuideOpenTab.Access),
+	}),
+	z.object({
+		tab: z.literal(GuideOpenTab.Setup),
+	}),
 	z.object({
 		tab: z.literal(GuideOpenTab.Files),
 		path: zGuideFilePath.nullable(),

package/src/guides/markdown.test.ts

@@ -132,6 +132,8 @@ describe("directives", () => {
 				"@[open](backups)",
 				"@[open](files:server.properties)",
 				"@[open](files)",
+				"@[open](access)",
+				"@[open](setup)",
 				"@[open](panel:mods)",
 			].join("\n"),
 		);
@@ -163,6 +165,18 @@ describe("directives", () => {
 					path: null,
 				},
 			},
+			{
+				type: "open",
+				target: {
+					tab: GuideOpenTab.Access,
+				},
+			},
+			{
+				type: "open",
+				target: {
+					tab: GuideOpenTab.Setup,
+				},
+			},
 			{
 				type: "open",
 				target: {
@@ -181,6 +195,10 @@ describe("directives", () => {
 		expect(() => parse("@[open](nowhere)")).toThrow(/unknown open target "nowhere"/);
 	});
 
+	test("rejects an argument on a target that takes none", () => {
+		expect(() => parse("@[open](setup:sign-in)")).toThrow(/"setup" target does not take an argument/);
+	});
+
 	test("rejects a traversing file path", () => {
 		expect(() => parse("@[open](files:../../etc/passwd)")).toThrow();
 	});

package/src/guides/markdown.ts

@@ -312,7 +312,13 @@ const parseOpenTarget = (path: string, line: number, value: string): GuideOpenTa
 		fail(path, line, `"${tab}" target does not take an argument`);
 	}
 
-	if (tab !== GuideOpenTab.Overview && tab !== GuideOpenTab.Console && tab !== GuideOpenTab.Backups) {
+	if (
+		tab !== GuideOpenTab.Overview
+		&& tab !== GuideOpenTab.Console
+		&& tab !== GuideOpenTab.Backups
+		&& tab !== GuideOpenTab.Access
+		&& tab !== GuideOpenTab.Setup
+	) {
 		fail(path, line, `unknown open target "${value}"`);
 	}
 

package/src/manifest/manifest.test.ts

@@ -3,6 +3,7 @@ import { z } from "zod";
 import { PortJoin } from "../core";
 import { GameCategory } from "./category";
 import { guidePackageSchema, MANIFEST_SCHEMA_VERSION, manifestSchema, packageSchema } from "./manifest";
+import { isServerkAvatarTemplate, PRESENCE_AVATAR_LENGTH_LIMIT } from "./presence";
 
 const text = (value: string) => ({
 	ar: value,
@@ -626,7 +627,21 @@ describe("presence", () => {
 		expect(result.success && result.data.presence?.fields[0]?.inline).toBe(true);
 	});
 
-	test("refuses an avatar template that is not https", () => {
+	test("accepts a serverk avatar template", () => {
+		const result = manifestSchema.safeParse({
+			...base(),
+			presence: {
+				name: "player",
+				id: "playerId",
+				avatar: "serverk://avatars/hytale/{playerId}",
+			},
+		});
+
+		expect(result.success).toBe(true);
+		expect(result.success && result.data.presence?.avatar).toBe("serverk://avatars/hytale/{playerId}");
+	});
+
+	test("refuses an avatar template that is neither https nor a serverk avatar", () => {
 		const result = manifestSchema.safeParse({
 			...base(),
 			presence: {
@@ -635,7 +650,39 @@ describe("presence", () => {
 		});
 
 		expect(result.success).toBe(false);
-		expect(result.error && z.prettifyError(result.error)).toContain("must be an https url template");
+		expect(result.error && z.prettifyError(result.error)).toContain(
+			"must be an https or serverk://avatars/ url template",
+		);
+	});
+
+	test("refuses a serverk scheme that is not an avatar path", () => {
+		const result = manifestSchema.safeParse({
+			...base(),
+			presence: {
+				avatar: "serverk://heads/hytale/{playerId}",
+			},
+		});
+
+		expect(result.success).toBe(false);
+		expect(result.error && z.prettifyError(result.error)).toContain(
+			"must be an https or serverk://avatars/ url template",
+		);
+	});
+
+	test("refuses a serverk avatar template longer than the limit", () => {
+		const result = manifestSchema.safeParse({
+			...base(),
+			presence: {
+				avatar: `serverk://avatars/hytale/${"a".repeat(PRESENCE_AVATAR_LENGTH_LIMIT)}`,
+			},
+		});
+
+		expect(result.success).toBe(false);
+	});
+
+	test("tells a serverk avatar template apart from an https one", () => {
+		expect(isServerkAvatarTemplate("serverk://avatars/hytale/{playerId}")).toBe(true);
+		expect(isServerkAvatarTemplate("https://mc-heads.net/avatar/{skin}/128")).toBe(false);
 	});
 
 	test("refuses a payload key that could never be a capture group", () => {

package/src/manifest/presence.ts

@@ -6,6 +6,14 @@ export const PRESENCE_FIELDS_LIMIT = 6;
 
 export const PRESENCE_AVATAR_LENGTH_LIMIT = 300;
 
+export const SERVERK_AVATAR_PREFIX = "serverk://avatars/";
+
+export const PRESENCE_AVATAR_PATTERN = /^(https:\/\/|serverk:\/\/avatars\/)/;
+
+export const isServerkAvatarTemplate = (template: string): boolean => {
+	return template.startsWith(SERVERK_AVATAR_PREFIX);
+};
+
 export const manifestPresenceFieldSchema = z.object({
 	key: zPayloadKey,
 	label: localizedText(32),
@@ -20,7 +28,7 @@ export const manifestPresenceSchema = z.object({
 	avatar: z
 		.string()
 		.max(PRESENCE_AVATAR_LENGTH_LIMIT)
-		.regex(/^https:\/\//, "must be an https url template")
+		.regex(PRESENCE_AVATAR_PATTERN, "must be an https or serverk://avatars/ url template")
 		.optional(),
 	fields: z.array(manifestPresenceFieldSchema).max(PRESENCE_FIELDS_LIMIT).default([]),
 });

package/src/modules/bridge.ts

@@ -1,5 +1,6 @@
 import type { BridgeContext, BridgeExecResult, BridgeFileEntry, BridgeReply } from "../context";
 import type {
+	BridgeCopy,
 	BridgeInstallHold,
 	BridgeInstallOutcome,
 	BridgeOption,
@@ -34,6 +35,15 @@ import type {
 } from "../protocol/bridgeCatalog";
 import type { BridgePendingFile } from "../protocol/bridgeFrame";
 import type { BridgePreview } from "../protocol/bridgePreview";
+import type {
+	BridgeSetupAction,
+	BridgeSetupManifest,
+	BridgeSetupPrompt,
+	BridgeSetupRuntime,
+	BridgeSetupStep,
+	BridgeSetupStepStatus,
+	BridgeSetupSummary,
+} from "../protocol/bridgeSetup";
 import type { BridgeTerminalArg, BridgeTerminalCommand, BridgeTerminalRule } from "../terminal";
 import type { BridgeDriver } from "./bridgeDriver";
 import type {
@@ -56,6 +66,7 @@ import type {
 	BridgeSample,
 	BridgeServerAction,
 	BridgeSettingsModule,
+	BridgeSetupModule,
 	BridgeTerminalModule,
 } from "./bridgeModule";
 
@@ -72,6 +83,7 @@ export namespace Bridge {
 	export type CatalogQuery = BridgeCatalogQuery;
 	export type Collection<Row extends BridgeRow = BridgeRow> = BridgeCollectionModule<Row>;
 	export type Context = BridgeContext;
+	export type Copy = BridgeCopy;
 	export type Detail = BridgeDetailModule;
 	export type DetailAction = BridgeDetailAction;
 	export type DetailBadge = BridgeDetailBadge;
@@ -106,6 +118,14 @@ export namespace Bridge {
 	export type SectionAction = BridgeSectionAction;
 	export type ServerAction = BridgeServerAction;
 	export type Settings = BridgeSettingsModule;
+	export type Setup = BridgeSetupModule;
+	export type SetupAction = BridgeSetupAction;
+	export type SetupManifest = BridgeSetupManifest;
+	export type SetupPrompt = BridgeSetupPrompt;
+	export type SetupRuntime = BridgeSetupRuntime;
+	export type SetupStep = BridgeSetupStep;
+	export type SetupStepStatus = BridgeSetupStepStatus;
+	export type SetupSummary = BridgeSetupSummary;
 	export type Terminal = BridgeTerminalModule;
 	export type TerminalArg = BridgeTerminalArg;
 	export type TerminalCommand = BridgeTerminalCommand;

package/src/modules/bridgeDriver.ts

@@ -8,6 +8,7 @@ import type {
 	BridgePanelModule,
 	BridgePendingModule,
 	BridgeQueryModule,
+	BridgeSetupModule,
 	BridgeTerminalModule,
 } from "./bridgeModule";
 
@@ -19,6 +20,7 @@ export interface BridgeDriver {
 	backup?: BridgeBackupModule;
 	announce?: BridgeAnnounceModule;
 	pending?: BridgePendingModule;
+	setup?: BridgeSetupModule;
 	terminal?: BridgeTerminalModule;
 	panel?: BridgePanel;
 	modules?: Record<string, BridgePanelModule>;

package/src/modules/bridgeModule.ts

@@ -4,6 +4,7 @@ import type { BridgeDetail, BridgeDetailOutcome } from "../panel";
 import type { BridgeCatalogEntry, BridgeCatalogPage, BridgeCatalogQuery } from "../protocol/bridgeCatalog";
 import type { BridgeDescribeResult, BridgePendingFile } from "../protocol/bridgeFrame";
 import type { BridgePreview } from "../protocol/bridgePreview";
+import type { BridgeSetupStep } from "../protocol/bridgeSetup";
 import type { BridgeTerminalCommand, BridgeTerminalRule } from "../terminal";
 
 export type BridgeDescription = Omit<BridgeDescribeResult, "supported">;
@@ -43,6 +44,12 @@ export interface BridgePendingModule {
 	add(context: BridgeContext, input: string): Promise<void>;
 }
 
+export interface BridgeSetupModule {
+	kind: BridgeKind.Setup;
+	steps: BridgeSetupStep[];
+	submit?(context: BridgeContext, step: string, action: string, args: BridgeValues): Promise<void>;
+}
+
 export interface BridgeSample {
 	online: number | null;
 	max: number | null;

package/src/panel/bridgeDetail.ts

@@ -1,4 +1,4 @@
-import type { BridgeValue, LocalizedText } from "../core";
+import type { BridgeCopy, BridgeValue, LocalizedText } from "../core";
 
 export enum BridgeDetailTone {
 	Neutral = "neutral",
@@ -22,7 +22,7 @@ export interface BridgeDetailBadge {
 export interface BridgeDetailStat {
 	key: string;
 	label: LocalizedText;
-	value: BridgeValue;
+	value: BridgeValue | LocalizedText;
 	format: BridgeDetailFormat;
 }
 
@@ -33,9 +33,9 @@ export interface BridgeDetailLink {
 
 export interface BridgeDetail {
 	id: string;
-	title: string;
-	subtitle: string | null;
-	description: string | null;
+	title: BridgeCopy;
+	subtitle: BridgeCopy | null;
+	description: BridgeCopy | null;
 	image: string | null;
 	badges: BridgeDetailBadge[];
 	stats: BridgeDetailStat[];

package/src/probes/a2s.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, test } from "bun:test";
+import { BridgeProbeCode, BridgeProbeError } from "../core";
+import { probeA2s } from "./a2s";
+
+const HOST = "127.0.0.1";
+
+const CLOSED_PORT = 59_437;
+
+const listen = async (reply: Uint8Array | null) => {
+	return await Bun.udpSocket({
+		hostname: HOST,
+		port: 0,
+		socket: {
+			data(socket, _data, port, address) {
+				if (reply) {
+					socket.send(reply, port, address);
+				}
+			},
+		},
+	});
+};
+
+describe("probeA2s", () => {
+	test("rejects with an unreachable probe error when nothing listens on the port", async () => {
+		const probe = probeA2s(HOST, CLOSED_PORT, 2000);
+
+		await expect(probe).rejects.toBeInstanceOf(BridgeProbeError);
+	});
+
+	test("survives the port-unreachable the game leaves behind before it binds", async () => {
+		for (let attempt = 0; attempt < 3; attempt += 1) {
+			await probeA2s(HOST, CLOSED_PORT, 300).catch(() => null);
+		}
+
+		expect(process.exitCode ?? 0).toBe(0);
+	});
+
+	test("times out against a port that never answers", async () => {
+		const silent = await listen(null);
+
+		try {
+			const error = await probeA2s(HOST, silent.port, 250).catch((reason: unknown) => reason);
+
+			expect(error).toBeInstanceOf(BridgeProbeError);
+			expect((error as BridgeProbeError).code).toBe(BridgeProbeCode.TimedOut);
+		} finally {
+			silent.close();
+		}
+	});
+
+	test("rejects a reply that is not an a2s frame", async () => {
+		const noisy = await listen(
+			new Uint8Array([
+				1,
+				2,
+				3,
+				4,
+				5,
+			]),
+		);
+
+		try {
+			const error = await probeA2s(HOST, noisy.port, 2000).catch((reason: unknown) => reason);
+
+			expect(error).toBeInstanceOf(BridgeProbeError);
+			expect((error as BridgeProbeError).code).toBe(BridgeProbeCode.Malformed);
+		} finally {
+			noisy.close();
+		}
+	});
+});

package/src/probes/a2s.ts

@@ -1,4 +1,5 @@
 import type { BridgeA2sInfo } from "../context";
+import { BridgeProbeCode, BridgeProbeError } from "../core";
 
 const SIMPLE_PREFIX = 0xff;
 
@@ -67,7 +68,19 @@ const parseInfo = (view: Uint8Array) => {
 	};
 };
 
+const probeError = (code: BridgeProbeCode, message: string, cause: unknown) => {
+	if (cause instanceof BridgeProbeError) {
+		return cause;
+	}
+
+	const detail = cause instanceof Error && cause.message.length > 0 ? `: ${cause.message}` : "";
+
+	return new BridgeProbeError(code, `${message}${detail}`);
+};
+
 export const probeA2s = (host: string, hostPort: number, timeoutMs: number) => {
+	const target = `${host}:${hostPort}`;
+
 	return new Promise<BridgeA2sInfo>((resolve, reject) => {
 		const startedAt = performance.now();
 
@@ -75,7 +88,7 @@ export const probeA2s = (host: string, hostPort: number, timeoutMs: number) => {
 		let challenged = false;
 		let settled = false;
 
-		const finish = (outcome: Omit<BridgeA2sInfo, "latencyMs"> | Error) => {
+		const finish = (outcome: Omit<BridgeA2sInfo, "latencyMs"> | BridgeProbeError) => {
 			if (settled) {
 				return;
 			}
@@ -83,9 +96,12 @@ export const probeA2s = (host: string, hostPort: number, timeoutMs: number) => {
 			settled = true;
 
 			clearTimeout(timer);
-			socket?.close();
 
-			if (outcome instanceof Error) {
+			try {
+				socket?.close();
+			} catch {}
+
+			if (outcome instanceof BridgeProbeError) {
 				reject(outcome);
 
 				return;
@@ -98,7 +114,7 @@ export const probeA2s = (host: string, hostPort: number, timeoutMs: number) => {
 		};
 
 		const timer = setTimeout(() => {
-			finish(new Error("a2s query timed out"));
+			finish(new BridgeProbeError(BridgeProbeCode.TimedOut, `a2s query to ${target} timed out`));
 		}, timeoutMs);
 
 		const handle = (view: Uint8Array) => {
@@ -109,27 +125,31 @@ export const probeA2s = (host: string, hostPort: number, timeoutMs: number) => {
 				|| view[2] !== SIMPLE_PREFIX
 				|| view[3] !== SIMPLE_PREFIX
 			) {
-				finish(new Error("a2s response is malformed"));
+				finish(new BridgeProbeError(BridgeProbeCode.Malformed, "a2s response is malformed"));
 
 				return;
 			}
 
 			if (view[4] === CHALLENGE_HEADER) {
 				if (challenged || view.length < 9) {
-					finish(new Error("a2s challenge is malformed"));
+					finish(new BridgeProbeError(BridgeProbeCode.Malformed, "a2s challenge is malformed"));
 
 					return;
 				}
 
 				challenged = true;
 
-				socket?.send(infoRequest(view.slice(5, 9)));
+				try {
+					socket?.send(infoRequest(view.slice(5, 9)));
+				} catch (error) {
+					finish(probeError(BridgeProbeCode.Unreachable, `a2s challenge to ${target} could not be sent`, error));
+				}
 
 				return;
 			}
 
 			if (view[4] !== INFO_HEADER) {
-				finish(new Error("a2s response has an unexpected header"));
+				finish(new BridgeProbeError(BridgeProbeCode.Malformed, "a2s response has an unexpected header"));
 
 				return;
 			}
@@ -137,7 +157,7 @@ export const probeA2s = (host: string, hostPort: number, timeoutMs: number) => {
 			try {
 				finish(parseInfo(view));
 			} catch (error) {
-				finish(error instanceof Error ? error : new Error(String(error)));
+				finish(probeError(BridgeProbeCode.Malformed, `a2s response from ${target} could not be read`, error));
 			}
 		};
 
@@ -150,6 +170,9 @@ export const probeA2s = (host: string, hostPort: number, timeoutMs: number) => {
 				data(_socket, data) {
 					handle(data);
 				},
+				error(_socket, error) {
+					finish(probeError(BridgeProbeCode.Unreachable, `a2s query to ${target} failed`, error));
+				},
 			},
 		})
 			.then((created) => {
@@ -161,10 +184,14 @@ export const probeA2s = (host: string, hostPort: number, timeoutMs: number) => {
 
 				socket = created;
 
-				created.send(infoRequest(null));
+				try {
+					created.send(infoRequest(null));
+				} catch (error) {
+					finish(probeError(BridgeProbeCode.Unreachable, `a2s query to ${target} could not be sent`, error));
+				}
 			})
 			.catch((error) => {
-				finish(error instanceof Error ? error : new Error(String(error)));
+				finish(probeError(BridgeProbeCode.Unreachable, `a2s socket for ${target} could not be opened`, error));
 			});
 	});
 };

package/src/protocol/bridgeFrame.ts

@@ -1,4 +1,5 @@
 import type { BridgeDesired, BridgeInstallHold, BridgeRuntime, BridgeValues, LocalizedText } from "../core";
+import type { BridgeSetupSummary } from "./bridgeSetup";
 
 export const BRIDGE_SOCKET_NAME = "bridge.sock";
 
@@ -24,6 +25,8 @@ export enum BridgeMethod {
 	Quiesce = "quiesce",
 	Release = "release",
 	Sample = "sample",
+	SetupStatus = "setupStatus",
+	SetupSubmit = "setupSubmit",
 	Start = "start",
 	Status = "status",
 	Stop = "stop",
@@ -74,7 +77,9 @@ export interface BridgeStatus {
 	outOfMemory: boolean;
 	restarts: number;
 	installError: string | null;
+	installErrorText: LocalizedText | null;
 	installHold: BridgeInstallHold | null;
+	setup: BridgeSetupSummary | null;
 }
 
 export interface BridgeSampleResult {

package/src/protocol/bridgeLimits.ts

@@ -38,6 +38,8 @@ export const BRIDGE_EVENTS_LIMIT = 32;
 
 export const BRIDGE_PENDING_FILES_LIMIT = 64;
 
+export const BRIDGE_SETUP_STEPS_LIMIT = 8;
+
 export const BRIDGE_ID_LENGTH_LIMIT = 32;
 
 export const BRIDGE_KEY_LENGTH_LIMIT = 64;