@serverkgg/bridge 0.0.8 → 0.0.10

package/src/runtime/bridgeDriver.ts

@@ -1,4 +1,11 @@
-import { BRIDGE_ID_PATTERN, BRIDGE_MODULE_ID_PATTERN, BridgeKind, type LocalizedText } from "../core";
+import {
+	BRIDGE_ID_PATTERN,
+	BRIDGE_MODULE_ID_PATTERN,
+	BridgeKind,
+	BridgeSetupStepKind,
+	type LocalizedText,
+} from "../core";
+import { GuideOpenTab } from "../guides";
 import type { ManifestPort } from "../manifest";
 import type { BridgeDriver, BridgePanelModule } from "../modules";
 import {
@@ -8,6 +15,7 @@ import {
 	type BridgeSection,
 	type BridgeSectionAction,
 	type BridgeTab,
+	BridgeUploadMode,
 	type BridgeVisibleWhen,
 } from "../panel";
 import {
@@ -16,6 +24,7 @@ import {
 	BRIDGE_EVENTS_LIMIT,
 	BRIDGE_EXTENSION_LENGTH_LIMIT,
 	BRIDGE_FIELD_OPTIONS_LIMIT,
+	BRIDGE_FORM_CLEARS_LIMIT,
 	BRIDGE_FORM_FIELDS_LIMIT,
 	BRIDGE_ID_LENGTH_LIMIT,
 	BRIDGE_KEY_LENGTH_LIMIT,
@@ -26,6 +35,7 @@ import {
 	BRIDGE_PLACEHOLDER_LENGTH_LIMIT,
 	BRIDGE_ROW_ACTIONS_LIMIT,
 	BRIDGE_SECTION_ACTIONS_LIMIT,
+	BRIDGE_SETUP_STEPS_LIMIT,
 	BRIDGE_STAGING_LENGTH_LIMIT,
 	BRIDGE_TAB_SECTIONS_LIMIT,
 	BRIDGE_TABLE_COLUMNS_LIMIT,
@@ -35,13 +45,17 @@ import {
 } from "../protocol";
 import { actionsOf } from "./bridgeActions";
 
+const UPLOAD_MODES = new Set<string>(Object.values(BridgeUploadMode));
+
 const RESERVED_MODULE_IDS = new Set([
 	"announce",
 	"backup",
 	"events",
 	"install",
 	"lifecycle",
+	"pending",
 	"query",
+	"setup",
 ]);
 
 export class BridgeDriverError extends Error {
@@ -259,6 +273,58 @@ const validateSection = (modules: Record<string, BridgePanelModule>, section: Br
 			countIn(section.fields.length, BRIDGE_FORM_FIELDS_LIMIT, "fields", where);
 			validateFields(modules, section.fields, where);
 
+			const clears = section.clears ?? [];
+
+			if (clears.length > 0 && section.target !== BridgeFormTarget.Variables) {
+				fail(`${where} clears variables but does not target variables`);
+			}
+
+			countIn(clears.length, BRIDGE_FORM_CLEARS_LIMIT, "cleared variables", where);
+
+			const cleared = new Set<string>();
+
+			for (const clear of clears) {
+				if (cleared.has(clear.variable)) {
+					fail(`${where} clears "${clear.variable}" more than once`);
+				}
+
+				cleared.add(clear.variable);
+
+				if (section.fields.some((field) => field.key === clear.variable)) {
+					fail(`${where} clears "${clear.variable}", which is one of its own fields`);
+				}
+
+				validateText(clear.warning, `clear "${clear.variable}" warning`, where);
+			}
+
+			return;
+		}
+
+		case BridgeLayout.Detail: {
+			const module = moduleOf(modules, section.module, where);
+
+			if (module.kind !== BridgeKind.Detail) {
+				fail(`${where} references "${section.module}", which is not a detail module`);
+
+				return;
+			}
+
+			countIn((section.actions ?? []).length, BRIDGE_SECTION_ACTIONS_LIMIT, "actions", where);
+			validateActions(modules, section.actions ?? [], where);
+
+			for (const action of section.actions ?? []) {
+				if (action.download) {
+					fail(`${where} declares action "${action.id}" as a download, which a detail cannot serve`);
+				}
+
+				if (!module.actions?.[action.id]) {
+					fail(`${where} declares action "${action.id}", which module "${section.module}" does not implement`);
+				}
+			}
+
+			validateText(section.confirmText, "confirm text", where);
+			validateText(section.related?.label, "related label", where);
+
 			return;
 		}
 
@@ -313,6 +379,10 @@ const validateSection = (modules: Record<string, BridgePanelModule>, section: Br
 					for (const extension of section.upload.extensions) {
 						lengthIn(extension, BRIDGE_EXTENSION_LENGTH_LIMIT, `upload extension "${extension}"`, where);
 					}
+
+					if (section.upload.mode !== undefined && !UPLOAD_MODES.has(section.upload.mode)) {
+						fail(`${where} declares an unknown upload mode "${section.upload.mode}"`);
+					}
 				}
 			}
 
@@ -346,6 +416,107 @@ const validateSection = (modules: Record<string, BridgePanelModule>, section: Br
 	}
 };
 
+const validatePending = (driver: BridgeDriver) => {
+	const pending = driver.pending;
+
+	if (!pending) {
+		return;
+	}
+
+	const where = "the pending module";
+
+	if (pending.kind !== BridgeKind.Pending) {
+		fail(`${where} declares kind "${pending.kind}", which is not "${BridgeKind.Pending}"`);
+	}
+
+	if (pending.staging.length === 0) {
+		fail(`${where} declares no staging path`);
+	}
+
+	lengthIn(pending.staging, BRIDGE_STAGING_LENGTH_LIMIT, "staging path", where);
+
+	if (pending.extensions.length === 0) {
+		fail(`${where} declares no extensions`);
+	}
+
+	countIn(pending.extensions.length, BRIDGE_UPLOAD_EXTENSIONS_LIMIT, "extensions", where);
+
+	for (const extension of pending.extensions) {
+		lengthIn(extension, BRIDGE_EXTENSION_LENGTH_LIMIT, `extension "${extension}"`, where);
+	}
+};
+
+const formSectionOf = (driver: BridgeDriver, tabId: string, sectionId: string) => {
+	const tab = (driver.panel?.tabs ?? []).find((entry) => entry.id === tabId);
+	const section = (tab?.sections ?? []).find((entry) => entry.id === sectionId);
+
+	if (!section || section.layout !== BridgeLayout.Form) {
+		return null;
+	}
+
+	return section;
+};
+
+const validateSetup = (driver: BridgeDriver) => {
+	const setup = driver.setup;
+
+	if (!setup) {
+		return;
+	}
+
+	const where = "the setup module";
+
+	if (setup.kind !== BridgeKind.Setup) {
+		fail(`${where} declares kind "${setup.kind}", which is not "${BridgeKind.Setup}"`);
+	}
+
+	if (setup.steps.length === 0) {
+		fail(`${where} declares no steps`);
+	}
+
+	countIn(setup.steps.length, BRIDGE_SETUP_STEPS_LIMIT, "steps", where);
+
+	const ids = new Set<string>();
+
+	for (const step of setup.steps) {
+		if (ids.has(step.id)) {
+			fail(`${where} declares step "${step.id}" more than once`);
+		}
+
+		ids.add(step.id);
+
+		const at = `${where} step "${step.id}"`;
+
+		validateId(step.id, `${where} step`);
+		validateText(step.title, "title", at);
+		validateText(step.help, "help", at);
+
+		if (step.kind === BridgeSetupStepKind.Form) {
+			const section = formSectionOf(driver, step.tab, step.section);
+
+			if (!section) {
+				fail(`${at} names tab "${step.tab}" section "${step.section}", which is not a form section of this panel`);
+
+				continue;
+			}
+
+			for (const key of step.fields ?? []) {
+				if (!section.fields.some((field) => field.key === key)) {
+					fail(`${at} names field "${key}", which section "${step.section}" does not declare`);
+				}
+			}
+		}
+
+		if (step.kind === BridgeSetupStepKind.Open) {
+			const target = step.target;
+
+			if (target.tab === GuideOpenTab.Panel && !(driver.panel?.tabs ?? []).some((tab) => tab.id === target.tabId)) {
+				fail(`${at} opens panel tab "${target.tabId}", which the panel does not declare`);
+			}
+		}
+	}
+};
+
 const validateTab = (modules: Record<string, BridgePanelModule>, tab: BridgeTab) => {
 	const sections = new Set<string>();
 
@@ -382,6 +553,9 @@ export const validateDriver = (driver: BridgeDriver) => {
 
 	countIn(emitted.size, BRIDGE_EVENTS_LIMIT, "event names", "the driver");
 
+	validatePending(driver);
+	validateSetup(driver);
+
 	for (const [id, module] of Object.entries(modules)) {
 		validateModuleId(id, "module");
 
@@ -401,7 +575,7 @@ export const validateDriver = (driver: BridgeDriver) => {
 			}
 		}
 
-		if (module.kind === BridgeKind.Collection) {
+		if (module.kind === BridgeKind.Collection || module.kind === BridgeKind.Detail) {
 			for (const action of Object.keys(module.actions ?? {})) {
 				validateModuleId(action, `module "${id}" action`);
 			}
@@ -429,6 +603,26 @@ export const validateDriver = (driver: BridgeDriver) => {
 
 		validateTab(modules, tab);
 	}
+
+	const declared = declaredVariables(driver);
+
+	for (const tab of driver.panel.tabs) {
+		for (const section of tab.sections) {
+			const where = `tab "${tab.id}" section "${section.id}"`;
+
+			if (section.layout === BridgeLayout.Detail && section.related && !tabs.has(section.related.tab)) {
+				fail(`${where} relates to tab "${section.related.tab}", which the panel does not declare`);
+			}
+
+			if (section.layout === BridgeLayout.Form) {
+				for (const clear of section.clears ?? []) {
+					if (!declared.has(clear.variable)) {
+						fail(`${where} clears "${clear.variable}", which no variables form, catalog or detail declares`);
+					}
+				}
+			}
+		}
+	}
 };
 
 const declaredVariables = (driver: BridgeDriver) => {
@@ -442,7 +636,7 @@ const declaredVariables = (driver: BridgeDriver) => {
 				}
 			}
 
-			if (section.layout === BridgeLayout.Catalog && section.variable) {
+			if ((section.layout === BridgeLayout.Catalog || section.layout === BridgeLayout.Detail) && section.variable) {
 				declared.add(section.variable);
 			}
 		}
@@ -461,7 +655,7 @@ export const validatePortActivation = (ports: ManifestPort[], driver: BridgeDriv
 			}
 
 			fail(
-				`port "${port.key}" activeWhen[${index}] names "${rule.variable}", which no variables form or catalog declares`,
+				`port "${port.key}" activeWhen[${index}] names "${rule.variable}", which no variables form, catalog or detail declares`,
 			);
 		}
 	}

package/src/runtime/bridgeEgress.ts

@@ -7,6 +7,7 @@ import {
 	BridgeEgressMethod,
 	type BridgeEgressRequest,
 	type BridgeEgressResponse,
+	type BridgeHttpMethod,
 } from "../protocol";
 
 const CONNECT_RETRY_MS = 10_000;
@@ -39,6 +40,8 @@ export class BridgeEgressCallError extends Error {
 }
 
 export interface BridgeEgressCallOptions {
+	httpMethod?: BridgeHttpMethod;
+	body?: string;
 	headers?: Record<string, string>;
 	timeoutMs?: number;
 	cache?: boolean;

package/src/runtime/bridgeEvents.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { BridgeKind } from "../core";
+import type { BridgeEventsModule } from "../modules";
+import { BridgeEventName } from "../protocol";
+import { createEventRing } from "./bridgeEvents";
+import type { BridgeLeveledLogger } from "./bridgeLog";
+import { createSupervisor } from "./bridgeSupervisor";
+
+const RESET = "\u001B[m";
+
+const PLAYER_JOINED = /^\[World\|(?<world>[^\]]+)\] Player '(?<player>[^']+)' joined world (?<target>\S+)$/;
+
+const silent: BridgeLeveledLogger = Object.assign(() => {}, {
+	warn: () => {},
+	error: () => {},
+});
+
+const events: BridgeEventsModule = {
+	kind: BridgeKind.Events,
+	patterns: [
+		{
+			match: PLAYER_JOINED,
+			emit: BridgeEventName.PlayerJoined,
+		},
+	],
+};
+
+const emittedFor = async (line: string) => {
+	const dir = await mkdtemp(join(tmpdir(), "bridge-events-"));
+	const path = join(dir, "line.txt");
+
+	await Bun.write(path, `${line}\n`);
+
+	const supervisor = createSupervisor({
+		cwd: dir,
+		uid: process.getuid?.() ?? 0,
+		gid: process.getgid?.() ?? 0,
+		stopTimeoutSeconds: 1,
+		onLog: silent,
+		resolveCommand: async () => [
+			"bash",
+			"-c",
+			'cat "$0"; sleep 300',
+			path,
+		],
+	});
+
+	const ring = createEventRing(events, supervisor);
+
+	await supervisor.start();
+
+	try {
+		for (let waited = 0; waited < 5000; waited += 50) {
+			if (ring.drain(0).events.length > 0) {
+				break;
+			}
+
+			await Bun.sleep(50);
+		}
+
+		return ring.drain(0).events;
+	} finally {
+		await supervisor.stop();
+		await rm(dir, {
+			force: true,
+			recursive: true,
+		});
+	}
+};
+
+const joined = {
+	seq: 1,
+	event: BridgeEventName.PlayerJoined,
+	payload: {
+		world: "default",
+		player: "Meslzy",
+		target: "default",
+	},
+};
+
+describe("matching a game line against the driver patterns", () => {
+	test("emits on the plain line", async () => {
+		expect(await emittedFor("[World|default] Player 'Meslzy' joined world default")).toEqual([
+			joined,
+		]);
+	});
+
+	test("emits on the line hytale really prints, wrapped in ansi resets at both ends", async () => {
+		expect(await emittedFor(`${RESET}[World|default] Player 'Meslzy' joined world default${RESET}`)).toEqual([
+			joined,
+		]);
+	});
+});

package/src/runtime/bridgeEvents.ts

@@ -1,6 +1,7 @@
 import type { BridgeValues } from "../core";
 import type { BridgeEventsModule } from "../modules";
 import type { BridgeEvent } from "../protocol";
+import { stripAnsi } from "../utils";
 import type { BridgeSupervisor } from "./bridgeSupervisor";
 
 const EVENT_BUFFER = 500;
@@ -26,22 +27,26 @@ export const createEventRing = (events: BridgeEventsModule | undefined, supervis
 
 	if (events) {
 		supervisor.subscribe((entry) => {
+			const line = stripAnsi(entry.line);
+
 			for (const pattern of events.patterns) {
 				if (pattern.stream && pattern.stream !== entry.stream) {
 					continue;
 				}
 
-				const match = entry.line.match(pattern.match);
+				const match = line.match(pattern.match);
 
 				if (!match) {
 					continue;
 				}
 
-				const groups = match.groups
-					? {
-							...match.groups,
-						}
-					: null;
+				const groups =
+					match.groups || pattern.payload
+						? {
+								...pattern.payload,
+								...match.groups,
+							}
+						: null;
 
 				push(pattern.emit, groups);
 			}