@serverkgg/bridge 0.1.1 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@serverkgg/bridge",
-	"version": "0.1.1",
+	"version": "0.1.2",
 	"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/bot/botPanel.test.ts

@@ -213,4 +213,34 @@ describe("the bot modules", () => {
 
 		await expect(module.actions[BotDeployAction.Redeploy]?.(context, {})).rejects.toThrow(BridgeUserError);
 	});
+
+	test("greys out both deploy buttons with the refusal's words while a running bot has not taken a deploy", async () => {
+		const module = createBotDeployModule();
+		const pending = deployContext(true, [
+			DEPLOY_MARKER,
+		]);
+
+		const unavailable = await module.unavailable?.(pending.context);
+
+		expect(Object.keys(unavailable ?? {}).sort()).toEqual([
+			BotDeployAction.Redeploy,
+			BotDeployAction.Reinstall,
+		]);
+		await expect(module.actions[BotDeployAction.Redeploy]?.(pending.context, {})).rejects.toThrow(
+			unavailable?.[BotDeployAction.Redeploy]?.en,
+		);
+	});
+
+	test("offers both deploy buttons when nothing is pending or the bot is stopped", async () => {
+		const module = createBotDeployModule();
+
+		expect(await module.unavailable?.(deployContext(true).context)).toEqual({});
+		expect(
+			await module.unavailable?.(
+				deployContext(false, [
+					DEPLOY_MARKER,
+				]).context,
+			),
+		).toEqual({});
+	});
 });

package/src/bot/botPanel.ts

@@ -1,5 +1,5 @@
 import type { BridgeContext } from "../context";
-import { BridgeKind, BridgeUserError, type BridgeValues, type LocalizedText } from "../core";
+import { BridgeKind, type BridgeUnavailable, BridgeUserError, type BridgeValues, type LocalizedText } from "../core";
 import type { BridgeActionsModule, BridgeDetailModule } from "../modules";
 import { BridgeIcon, BridgeLayout, BridgePlace, type BridgeTab } from "../panel";
 import { type DeployRequest, deployPending, requestDeploy } from "./botDeploy";
@@ -117,5 +117,13 @@ export const createBotDeployModule = (): BridgeActionsModule => {
 			[BotDeployAction.Redeploy]: deploy(false),
 			[BotDeployAction.Reinstall]: deploy(true),
 		},
+		async unavailable(context): Promise<BridgeUnavailable> {
+			return (await deployPending(context))
+				? {
+						[BotDeployAction.Redeploy]: DEPLOY_PENDING,
+						[BotDeployAction.Reinstall]: DEPLOY_PENDING,
+					}
+				: {};
+		},
 	};
 };

package/src/cli/validate.test.ts

@@ -16,7 +16,7 @@ import {
 	type BridgeTab,
 	type BridgeTableSection,
 } from "../panel";
-import { placementReportLines, runValidate, setupReportLines } from "./validate";
+import { availabilityReportLines, placementReportLines, runValidate, setupReportLines } from "./validate";
 
 const text = (value: string) => ({
 	ar: value,
@@ -602,3 +602,75 @@ describe("validating a bot package", () => {
 		);
 	});
 });
+
+describe("availability report", () => {
+	const driverWithModules = (modules: BridgeDriver["modules"]): BridgeDriver => ({
+		install: {
+			kind: BridgeKind.Install,
+			run: async () => {
+				return;
+			},
+		},
+		lifecycle: {
+			kind: BridgeKind.Lifecycle,
+			command: async () => [
+				"run",
+			],
+		},
+		modules,
+	});
+
+	test("warns about a protected module that cannot say when its action is unavailable", () => {
+		expect(
+			availabilityReportLines(
+				driverWithModules({
+					worlds: {
+						kind: BridgeKind.Collection,
+						protectedActions: [
+							"delete",
+						],
+						list: async () => [],
+						actions: {
+							delete: async () => {
+								return;
+							},
+						},
+					},
+				}),
+			),
+		).toEqual([
+			'  warning: module "worlds" protects delete but declares no `unavailable` — the panel offers the action everywhere and the platform stops the game before the driver can refuse it',
+		]);
+	});
+
+	test("says nothing when the protected module declares the hook or protects nothing", () => {
+		expect(
+			availabilityReportLines(
+				driverWithModules({
+					worlds: {
+						kind: BridgeKind.Collection,
+						protectedActions: [
+							"delete",
+						],
+						list: async () => [],
+						actions: {
+							delete: async () => {
+								return;
+							},
+						},
+						unavailable: async () => ({}),
+					},
+					players: {
+						kind: BridgeKind.Collection,
+						list: async () => [],
+						actions: {
+							kick: async () => {
+								return;
+							},
+						},
+					},
+				}),
+			),
+		).toEqual([]);
+	});
+});

package/src/cli/validate.ts

@@ -5,7 +5,7 @@ import { parseArgs } from "node:util";
 import { z } from "zod";
 import { type ArticlePack, compileArticles } from "../blog";
 import { DETECT_TABLE_FILE, renderDetectTable } from "../bot/detect";
-import { PortProtocol } from "../core";
+import { BridgeKind, PortProtocol } from "../core";
 import { GuideOpenTab, type GuideOpenTarget, type GuidePack, readGuidePack, readGuidePackage } from "../guides";
 import {
 	declaredFiles,
@@ -279,6 +279,39 @@ const reportPlacement = (driver: BridgeDriver) => {
 	}
 };
 
+export const availabilityReportLines = (driver: BridgeDriver): string[] => {
+	const lines: string[] = [];
+
+	for (const [id, module] of Object.entries(driver.modules ?? {})) {
+		if (
+			module.kind !== BridgeKind.Actions
+			&& module.kind !== BridgeKind.Catalog
+			&& module.kind !== BridgeKind.Collection
+			&& module.kind !== BridgeKind.Settings
+		) {
+			continue;
+		}
+
+		const protectedActions = module.protectedActions ?? [];
+
+		if (protectedActions.length === 0 || module.unavailable) {
+			continue;
+		}
+
+		lines.push(
+			`  warning: module "${id}" protects ${protectedActions.join(", ")} but declares no \`unavailable\` — the panel offers the action everywhere and the platform stops the game before the driver can refuse it`,
+		);
+	}
+
+	return lines;
+};
+
+const reportAvailability = (driver: BridgeDriver) => {
+	for (const line of availabilityReportLines(driver)) {
+		console.log(line);
+	}
+};
+
 const openTargetOf = (target: GuideOpenTarget) => {
 	if (target.tab === GuideOpenTab.Panel) {
 		return `panel tab "${target.tabId}"`;
@@ -432,6 +465,7 @@ const validateRunnablePackage = async (
 	reportEvents(driver);
 	reportActionTargets(driver);
 	reportPlacement(driver);
+	reportAvailability(driver);
 };
 
 export const runValidate = async (args: string[]) => {

package/src/context/bridgeContext.ts

@@ -1,4 +1,4 @@
-import type { BridgeStream, BridgeValues } from "../core";
+import type { BridgeActivity, BridgeStream, BridgeValues } from "../core";
 import type { BridgeHttpMethod, BridgeSetupRuntime } from "../protocol";
 
 export interface BridgeServer {
@@ -189,6 +189,10 @@ export interface BridgeSetupReporter {
 	clear(): void;
 }
 
+export interface BridgeActivityReporter {
+	report(entry: BridgeActivity): void;
+}
+
 export interface BridgeLog {
 	(message: string, fields?: BridgeValues): void;
 	warn(message: string, fields?: BridgeValues): void;
@@ -212,6 +216,7 @@ export interface BridgeContext {
 	exec(command: string[], options?: BridgeExecOptions): Promise<BridgeExecResult>;
 	logs: BridgeLogs;
 	setup: BridgeSetupReporter;
+	activity: BridgeActivityReporter;
 	emit(event: string, payload?: BridgeValues): void;
 	restart(): Promise<void>;
 	log: BridgeLog;

package/src/core/bridgeAction.ts

@@ -1,5 +1,6 @@
 export enum BridgeAction {
 	Add = "add",
+	Availability = "availability",
 	Install = "install",
 	Installed = "installed",
 	List = "list",
@@ -16,6 +17,7 @@ export enum BridgeAction {
 }
 
 export const BRIDGE_READ_ACTIONS: readonly string[] = [
+	BridgeAction.Availability,
 	BridgeAction.Releases,
 	BridgeAction.Installed,
 	BridgeAction.List,

package/src/core/bridgeActivity.ts

@@ -0,0 +1,9 @@
+import type { BridgeEventName } from "../protocol/bridgeEvents";
+import type { BridgeValues, LocalizedText } from "./bridgeValue";
+
+export interface BridgeActivity {
+	name: BridgeEventName;
+	text: LocalizedText;
+	subject?: string;
+	details?: BridgeValues;
+}

package/src/core/bridgeAvailability.ts

@@ -0,0 +1,10 @@
+import type { LocalizedText } from "./bridgeValue";
+
+export const BRIDGE_AVAILABILITY_KEY_PATTERN = /^[A-Za-z][A-Za-z0-9_-]*$/;
+
+export type BridgeUnavailable = Record<string, LocalizedText>;
+
+export interface BridgeAvailability {
+	module: BridgeUnavailable;
+	subjects: Record<string, BridgeUnavailable>;
+}

package/src/core/bridgeUserError.test.ts

@@ -17,6 +17,16 @@ describe("BridgeUserError", () => {
 		expect(error.text).toEqual(text);
 	});
 
+	test("keeps the cause a driver attaches for the staff log", () => {
+		const cause = new Error("cdn.modrinth.com answered 404");
+		const error = new BridgeUserError(text, {
+			cause,
+		});
+
+		expect(error.cause).toBe(cause);
+		expect(error.message).toBe(text.en);
+	});
+
 	test("is the class a driver reaches through the published namespace", () => {
 		expect(new Bridge.UserError(text)).toBeInstanceOf(BridgeUserError);
 	});

package/src/core/bridgeUserError.ts

@@ -1,10 +1,14 @@
 import type { LocalizedText } from "./bridgeValue";
 
+export interface BridgeUserErrorOptions {
+	cause?: unknown;
+}
+
 export class BridgeUserError extends Error {
 	readonly text: LocalizedText;
 
-	constructor(text: LocalizedText) {
-		super(text.en);
+	constructor(text: LocalizedText, options: BridgeUserErrorOptions = {}) {
+		super(text.en, options);
 
 		this.name = "BridgeUserError";
 		this.text = text;

package/src/core/describeDownloadFailure.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, test } from "bun:test";
+import { BridgeDownloadError } from "./bridgeDownloadError";
+import { BridgeNetError } from "./bridgeNetError";
+import { describeDownloadFailure } from "./describeDownloadFailure";
+
+const SUBJECT = "All the Mods 9";
+
+describe("describeDownloadFailure", () => {
+	test("says the file is gone for 404 and 410", () => {
+		for (const status of [
+			404,
+			410,
+		]) {
+			expect(describeDownloadFailure(new BridgeDownloadError(status, "gone"), SUBJECT).en).toBe(
+				"All the Mods 9 is no longer available from its source.",
+			);
+		}
+	});
+
+	test("says the source refused for 401 and 403", () => {
+		expect(describeDownloadFailure(new BridgeNetError(403, "forbidden"), SUBJECT).en).toBe(
+			"The source refused the download of All the Mods 9.",
+		);
+		expect(describeDownloadFailure(new BridgeDownloadError(401, "unauthorized"), SUBJECT).ar).toBe(
+			"المصدر رفض تنزيل All the Mods 9.",
+		);
+	});
+
+	test("says the source is busy for 429", () => {
+		expect(describeDownloadFailure(new BridgeDownloadError(429, "slow down"), SUBJECT).en).toContain("busy");
+	});
+
+	test("says the source is down for a 5xx", () => {
+		expect(describeDownloadFailure(new BridgeNetError(503, "unavailable"), SUBJECT).en).toBe(
+			"The source of All the Mods 9 is down right now. Try again in a bit.",
+		);
+	});
+
+	test("says the source could not be reached when there is no status", () => {
+		expect(describeDownloadFailure(new BridgeDownloadError(null, "ECONNRESET"), SUBJECT).en).toBe(
+			"We could not reach the source to download All the Mods 9. Try again.",
+		);
+	});
+
+	test("falls back to a plain download failure for anything else", () => {
+		const generic = "We could not download All the Mods 9. Try again.";
+
+		expect(describeDownloadFailure(new BridgeDownloadError(400, "bad request"), SUBJECT).en).toBe(generic);
+		expect(describeDownloadFailure(new Error("digest mismatch"), SUBJECT).en).toBe(generic);
+	});
+
+	test("always writes both languages", () => {
+		const text = describeDownloadFailure(new BridgeDownloadError(500, "boom"), SUBJECT);
+
+		expect(text.ar.length).toBeGreaterThan(0);
+		expect(text.en.length).toBeGreaterThan(0);
+	});
+});

package/src/core/describeDownloadFailure.ts

@@ -0,0 +1,69 @@
+import { BridgeDownloadError } from "./bridgeDownloadError";
+import { BridgeNetError } from "./bridgeNetError";
+import type { LocalizedText } from "./bridgeValue";
+
+const REMOVED_STATUSES: readonly number[] = [
+	404,
+	410,
+];
+
+const REFUSED_STATUSES: readonly number[] = [
+	401,
+	403,
+];
+
+const BUSY_STATUS = 429;
+
+const SERVER_ERROR_STATUS = 500;
+
+const statusOf = (error: unknown): number | null | undefined => {
+	if (error instanceof BridgeDownloadError || error instanceof BridgeNetError) {
+		return error.status;
+	}
+
+	return undefined;
+};
+
+export const describeDownloadFailure = (error: unknown, subject: string): LocalizedText => {
+	const status = statusOf(error);
+
+	if (status === null) {
+		return {
+			ar: `ما قدرنا نوصل للمصدر عشان ننزّل ${subject}. جرّب مرة ثانية.`,
+			en: `We could not reach the source to download ${subject}. Try again.`,
+		};
+	}
+
+	if (status !== undefined && REMOVED_STATUSES.includes(status)) {
+		return {
+			ar: `${subject} ما عاد موجود عند المصدر.`,
+			en: `${subject} is no longer available from its source.`,
+		};
+	}
+
+	if (status !== undefined && REFUSED_STATUSES.includes(status)) {
+		return {
+			ar: `المصدر رفض تنزيل ${subject}.`,
+			en: `The source refused the download of ${subject}.`,
+		};
+	}
+
+	if (status === BUSY_STATUS) {
+		return {
+			ar: `المصدر مشغول الحين وما قدرنا ننزّل ${subject}. جرّب بعد شوي.`,
+			en: `The source is busy right now, so we could not download ${subject}. Try again in a bit.`,
+		};
+	}
+
+	if (status !== undefined && status >= SERVER_ERROR_STATUS) {
+		return {
+			ar: `مصدر ${subject} فيه عطل الحين. جرّب بعد شوي.`,
+			en: `The source of ${subject} is down right now. Try again in a bit.`,
+		};
+	}
+
+	return {
+		ar: `ما قدرنا ننزّل ${subject}. جرّب مرة ثانية.`,
+		en: `We could not download ${subject}. Try again.`,
+	};
+};

package/src/core/index.ts

@@ -1,4 +1,6 @@
 export * from "./bridgeAction";
+export * from "./bridgeActivity";
+export * from "./bridgeAvailability";
 export * from "./bridgeDownloadError";
 export * from "./bridgeFailure";
 export * from "./bridgeHold";
@@ -14,3 +16,4 @@ export * from "./bridgeSetup";
 export * from "./bridgeStream";
 export * from "./bridgeUserError";
 export * from "./bridgeValue";
+export * from "./describeDownloadFailure";

package/src/modules/bridge.ts

@@ -1,5 +1,7 @@
-import type { BridgeContext, BridgeExecResult, BridgeFileEntry, BridgeReply } from "../context";
+import type { BridgeActivityReporter, BridgeContext, BridgeExecResult, BridgeFileEntry, BridgeReply } from "../context";
 import type {
+	BridgeActivity,
+	BridgeAvailability,
 	BridgeCell,
 	BridgeCells,
 	BridgeCopy,
@@ -7,6 +9,7 @@ import type {
 	BridgeInstallOutcome,
 	BridgeOption,
 	BridgeRow,
+	BridgeUnavailable,
 	BridgeValue,
 	BridgeValues,
 	LocalizedText,
@@ -75,8 +78,11 @@ import type {
 
 export namespace Bridge {
 	export type Actions = BridgeActionsModule;
+	export type Activity = BridgeActivity;
+	export type ActivityReporter = BridgeActivityReporter;
 	export type AddOutcome = BridgeAddOutcome;
 	export type Announce = BridgeAnnounceModule;
+	export type Availability = BridgeAvailability;
 	export type Backup = BridgeBackupModule;
 	export type Catalog = BridgeCatalogModule;
 	export type CatalogEntry = BridgeCatalogEntry;
@@ -138,6 +144,7 @@ export namespace Bridge {
 	export type TerminalRule = BridgeTerminalRule;
 	export type Tab = BridgeTab;
 	export type TabRef = BridgeTabRef;
+	export type Unavailable = BridgeUnavailable;
 	export type UploadMode = BridgeUploadMode;
 	export const UserError = BridgeUserError;
 	export type UserError = BridgeUserError;

package/src/modules/bridgeModule.ts

@@ -1,5 +1,13 @@
 import type { BridgeContext, BridgeReply } from "../context";
-import type { BridgeInstallOutcome, BridgeKind, BridgeOption, BridgeRow, BridgeStream, BridgeValues } from "../core";
+import type {
+	BridgeInstallOutcome,
+	BridgeKind,
+	BridgeOption,
+	BridgeRow,
+	BridgeStream,
+	BridgeUnavailable,
+	BridgeValues,
+} from "../core";
 import type { BridgeAddOutcome, BridgeDetail, BridgeDetailOutcome } from "../panel";
 import type {
 	BridgeCatalogEntry,
@@ -115,6 +123,7 @@ export interface BridgeSettingsModule {
 	protectedActions?: string[];
 	read(context: BridgeContext): Promise<BridgeValues>;
 	write?(context: BridgeContext, values: BridgeValues): Promise<void>;
+	unavailable?(context: BridgeContext): Promise<BridgeUnavailable>;
 }
 
 export type BridgeRowAction<Row extends BridgeRow = BridgeRow> = (
@@ -130,6 +139,7 @@ export interface BridgeActionsModule {
 	protectedActions?: string[];
 	requiresRunning?: boolean;
 	actions: Record<string, BridgeServerAction>;
+	unavailable?(context: BridgeContext): Promise<BridgeUnavailable>;
 }
 
 export interface BridgeCollectionModule<Row extends BridgeRow = BridgeRow> {
@@ -140,6 +150,7 @@ export interface BridgeCollectionModule<Row extends BridgeRow = BridgeRow> {
 	list(context: BridgeContext): Promise<Row[]>;
 	add?(context: BridgeContext, input: string): Promise<BridgeAddOutcome | undefined>;
 	actions?: Record<string, BridgeRowAction<Row>>;
+	unavailable?(context: BridgeContext, row: Row): Promise<BridgeUnavailable>;
 }
 
 export type BridgeDetailAction = (context: BridgeContext, args: BridgeValues) => Promise<BridgeDetailOutcome | null>;
@@ -164,6 +175,7 @@ export interface BridgeCatalogModule {
 	install(context: BridgeContext, id: string, releaseId?: string): Promise<BridgeCatalogEntry>;
 	remove(context: BridgeContext, id: string): Promise<void>;
 	toggle?(context: BridgeContext, id: string, enabled: boolean): Promise<void>;
+	unavailable?(context: BridgeContext, entry: BridgeCatalogEntry): Promise<BridgeUnavailable>;
 }
 
 export type BridgePanelModule =

package/src/panel/bridgeDetail.ts

@@ -1,4 +1,4 @@
-import type { BridgeCopy, BridgeValue, LocalizedText } from "../core";
+import type { BridgeCopy, BridgeUnavailable, BridgeValue, LocalizedText } from "../core";
 import type { BridgeIcon } from "./bridgeIcon";
 
 export enum BridgeDetailTone {
@@ -45,6 +45,7 @@ export interface BridgeDetail {
 	links: BridgeDetailLink[];
 	stale: boolean;
 	actions: string[];
+	unavailable?: BridgeUnavailable;
 }
 
 export interface BridgeDetailOutcome {

package/src/protocol/bridgeActivity.ts

@@ -0,0 +1,54 @@
+import type { BridgeActivity, BridgeValues } from "../core";
+
+export const BRIDGE_ACTIVITY_KEYS = {
+	ar: "activityAr",
+	en: "activityEn",
+	subject: "subject",
+} as const;
+
+export const BRIDGE_ACTIVITY_LIMIT = 8;
+
+export const BRIDGE_ACTIVITY_TEXT_LENGTH_LIMIT = 256;
+
+export const BRIDGE_ACTIVITY_SUBJECT_LENGTH_LIMIT = 64;
+
+export const BRIDGE_ACTIVITY_DETAILS_LIMIT = 16;
+
+export const BRIDGE_ACTIVITY_DETAIL_KEY_LENGTH_LIMIT = 64;
+
+export const BRIDGE_ACTIVITY_EXCERPT_LENGTH_LIMIT = 80;
+
+export const BRIDGE_ACTIVITY_NAME_LENGTH_LIMIT = 64;
+
+export const BRIDGE_ACTIVITY_NAME_PATTERN = /^[A-Z][A-Za-z0-9]*$/;
+
+export const BRIDGE_ACTIVITY_DETAIL_KEY_PATTERN = /^[A-Za-z][A-Za-z0-9_-]*$/;
+
+const ELLIPSIS = "…";
+
+export const isBridgeActivity = (payload: BridgeValues | null): boolean => {
+	return typeof payload?.[BRIDGE_ACTIVITY_KEYS.ar] === "string" && typeof payload[BRIDGE_ACTIVITY_KEYS.en] === "string";
+};
+
+export const activityPayload = (entry: BridgeActivity): BridgeValues => {
+	return {
+		...entry.details,
+		[BRIDGE_ACTIVITY_KEYS.ar]: entry.text.ar,
+		[BRIDGE_ACTIVITY_KEYS.en]: entry.text.en,
+		...(entry.subject === undefined
+			? {}
+			: {
+					[BRIDGE_ACTIVITY_KEYS.subject]: entry.subject,
+				}),
+	};
+};
+
+export const activityExcerpt = (text: string): string => {
+	const line = text.trim();
+
+	if (line.length <= BRIDGE_ACTIVITY_EXCERPT_LENGTH_LIMIT) {
+		return line;
+	}
+
+	return `${line.slice(0, BRIDGE_ACTIVITY_EXCERPT_LENGTH_LIMIT - ELLIPSIS.length).trimEnd()}${ELLIPSIS}`;
+};

package/src/protocol/bridgeEvents.ts

@@ -1,23 +1,53 @@
 export enum BridgeEventName {
+	AccessGranted = "AccessGranted",
+	AccessRevoked = "AccessRevoked",
+	BroadcastSent = "BroadcastSent",
+	GameInstalled = "GameInstalled",
 	GameModeChanged = "GameModeChanged",
+	GameplayChanged = "GameplayChanged",
+	InstallFailed = "InstallFailed",
 	MemoryUndersized = "MemoryUndersized",
 	MissingDependency = "MissingDependency",
 	ModCrashed = "ModCrashed",
+	ModDisabled = "ModDisabled",
+	ModEnabled = "ModEnabled",
+	ModInstalled = "ModInstalled",
 	ModLoaded = "ModLoaded",
+	ModLoaderInstalled = "ModLoaderInstalled",
+	ModLoaderRemoved = "ModLoaderRemoved",
+	ModRemoved = "ModRemoved",
+	ModpackInstalled = "ModpackInstalled",
+	ModpackRemoved = "ModpackRemoved",
+	ModpackSelected = "ModpackSelected",
 	PlayerAdvanced = "PlayerAdvanced",
 	PlayerBanned = "PlayerBanned",
+	PlayerChanged = "PlayerChanged",
 	PlayerDied = "PlayerDied",
 	PlayerJoined = "PlayerJoined",
 	PlayerKicked = "PlayerKicked",
 	PlayerLeft = "PlayerLeft",
+	PlayerUnbanned = "PlayerUnbanned",
 	PortBindFailed = "PortBindFailed",
+	SecretRotated = "SecretRotated",
 	ServerCrashed = "ServerCrashed",
 	ServerStarted = "ServerStarted",
 	ServerStopping = "ServerStopping",
 	ServerUpdated = "ServerUpdated",
+	SettingsApplied = "SettingsApplied",
+	SettingsChanged = "SettingsChanged",
+	SetupAction = "SetupAction",
+	SetupCompleted = "SetupCompleted",
+	SetupRejected = "SetupRejected",
+	SignInExpired = "SignInExpired",
 	TickLagging = "TickLagging",
+	WorldActivated = "WorldActivated",
+	WorldCloned = "WorldCloned",
 	WorldCorrupt = "WorldCorrupt",
+	WorldCreated = "WorldCreated",
+	WorldDeleted = "WorldDeleted",
+	WorldImported = "WorldImported",
 	WorldSaved = "WorldSaved",
+	WorldWiped = "WorldWiped",
 	WrongJavaVersion = "WrongJavaVersion",
 }
 

package/src/protocol/bridgeFrame.ts

@@ -1,4 +1,11 @@
-import type { BridgeDesired, BridgeInstallHold, BridgeRuntime, BridgeValues, LocalizedText } from "../core";
+import type {
+	BridgeActivity,
+	BridgeDesired,
+	BridgeInstallHold,
+	BridgeRuntime,
+	BridgeValues,
+	LocalizedText,
+} from "../core";
 import type { BridgeSetupSummary } from "./bridgeSetup";
 
 export const BRIDGE_SOCKET_NAME = "bridge.sock";
@@ -59,6 +66,7 @@ export interface BridgeSuccess {
 	id: number | null;
 	ok: true;
 	result: unknown;
+	activity?: BridgeActivity[];
 }
 
 export interface BridgeFailure {
@@ -68,6 +76,7 @@ export interface BridgeFailure {
 	secret?: string;
 	failure?: string;
 	text?: LocalizedText;
+	unchanged?: boolean;
 }
 
 export type BridgeResponse = BridgeFailure | BridgeSuccess;