@serverkgg/bridge 0.0.21 → 0.1.1

package/src/runtime/bridgeRedaction.ts

@@ -0,0 +1,214 @@
+import { BridgeSetupPromptKind, type LocalizedText } from "../core";
+import type { BridgeDriver } from "../modules";
+import { BridgeControl, BridgeLayout } from "../panel";
+import type { BridgeSetupAction, BridgeSetupPrompt, BridgeSetupRuntime } from "../protocol";
+import type { BridgeLeveledLogger, BridgeLogger } from "./bridgeLog";
+
+export const REDACTED = "••••";
+
+export const REDACTION_MIN_LENGTH = 8;
+
+const REDACTION_DEPTH_LIMIT = 4;
+
+const PATTERN_SPECIALS = /[.*+?^${}()|[\]\\]/g;
+
+export type BridgeRedact = (text: string) => string;
+
+export interface BridgeRedactionSource {
+	variables(): Readonly<Record<string, string>>;
+	secrets(): Readonly<Record<string, string>>;
+}
+
+export const secretFieldKeys = (driver: BridgeDriver): string[] => {
+	const keys = new Set<string>();
+
+	for (const tab of driver.panel?.tabs ?? []) {
+		for (const section of tab.sections) {
+			if (section.layout !== BridgeLayout.Form) {
+				continue;
+			}
+
+			for (const field of section.fields) {
+				if (field.control === BridgeControl.Secret) {
+					keys.add(field.key);
+				}
+			}
+		}
+	}
+
+	return [
+		...keys,
+	];
+};
+
+const LINE_BREAK = /\r\n|\r|\n/;
+
+const redactableParts = (value: string): string[] => {
+	if (!LINE_BREAK.test(value)) {
+		return [
+			value,
+		];
+	}
+
+	return [
+		value,
+		...value.split(LINE_BREAK).map((line) => line.trim()),
+	];
+};
+
+const matcherFor = (values: string[]) => {
+	if (values.length === 0) {
+		return null;
+	}
+
+	return new RegExp(values.map((value) => value.replace(PATTERN_SPECIALS, "\\$&")).join("|"), "g");
+};
+
+export const createBridgeRedaction = (keys: string[], source: BridgeRedactionSource): BridgeRedact => {
+	let seenVariables: Readonly<Record<string, string>> | null = null;
+	let seenSecrets: Readonly<Record<string, string>> | null = null;
+	let signature = "";
+	let matcher: RegExp | null = null;
+
+	const current = () => {
+		const variables = source.variables();
+		const secrets = source.secrets();
+
+		if (variables === seenVariables && secrets === seenSecrets) {
+			return matcher;
+		}
+
+		seenVariables = variables;
+		seenSecrets = secrets;
+
+		const values = [
+			...new Set(
+				[
+					...keys.map((key) => variables[key] ?? ""),
+					...Object.values(secrets),
+				].flatMap(redactableParts),
+			),
+		]
+			.filter((value) => value.length >= REDACTION_MIN_LENGTH)
+			.sort((a, b) => b.length - a.length);
+		const next = values.join("\0");
+
+		if (next !== signature) {
+			signature = next;
+			matcher = matcherFor(values);
+		}
+
+		return matcher;
+	};
+
+	return (text) => {
+		const pattern = current();
+
+		return pattern ? text.replace(pattern, REDACTED) : text;
+	};
+};
+
+export const redactLocalized = (text: LocalizedText, redact: BridgeRedact): LocalizedText => {
+	return {
+		ar: redact(text.ar),
+		en: redact(text.en),
+	};
+};
+
+const redactActions = (actions: BridgeSetupAction[], redact: BridgeRedact): BridgeSetupAction[] => {
+	return actions.map((action) => ({
+		id: action.id,
+		label: redactLocalized(action.label, redact),
+	}));
+};
+
+const redactPrompt = (prompt: BridgeSetupPrompt, redact: BridgeRedact): BridgeSetupPrompt => {
+	const message = redactLocalized(prompt.message, redact);
+
+	switch (prompt.kind) {
+		case BridgeSetupPromptKind.Wait: {
+			return {
+				...prompt,
+				message,
+			};
+		}
+
+		case BridgeSetupPromptKind.Progress: {
+			return {
+				...prompt,
+				message,
+				detail: prompt.detail === null ? null : redact(prompt.detail),
+			};
+		}
+
+		case BridgeSetupPromptKind.Link: {
+			return {
+				...prompt,
+				message,
+				url: redact(prompt.url),
+				code: prompt.code === null ? null : redact(prompt.code),
+				actions: redactActions(prompt.actions, redact),
+			};
+		}
+
+		case BridgeSetupPromptKind.Action:
+		case BridgeSetupPromptKind.Failed: {
+			return {
+				...prompt,
+				message,
+				actions: redactActions(prompt.actions, redact),
+			};
+		}
+	}
+};
+
+export const redactSetupRuntime = (
+	runtime: BridgeSetupRuntime | null,
+	redact: BridgeRedact,
+): BridgeSetupRuntime | null => {
+	if (!runtime) {
+		return null;
+	}
+
+	return {
+		steps: runtime.steps,
+		prompt: runtime.prompt ? redactPrompt(runtime.prompt, redact) : null,
+	};
+};
+
+const redactValue = (value: unknown, redact: BridgeRedact, depth: number): unknown => {
+	if (typeof value === "string") {
+		return redact(value);
+	}
+
+	if (depth >= REDACTION_DEPTH_LIMIT || value === null || typeof value !== "object") {
+		return value;
+	}
+
+	if (Array.isArray(value)) {
+		return value.map((entry) => redactValue(entry, redact, depth + 1));
+	}
+
+	return Object.fromEntries(
+		Object.entries(value).map(([key, entry]) => [
+			key,
+			redactValue(entry, redact, depth + 1),
+		]),
+	);
+};
+
+const redactingWriter = (write: BridgeLogger, redact: BridgeRedact): BridgeLogger => {
+	return (message, fields) => {
+		write(
+			redact(message),
+			fields === undefined ? undefined : (redactValue(fields, redact, 0) as Record<string, unknown>),
+		);
+	};
+};
+
+export const redactLogger = (logger: BridgeLeveledLogger, redact: BridgeRedact): BridgeLeveledLogger => {
+	return Object.assign(redactingWriter(logger, redact), {
+		warn: redactingWriter(logger.warn, redact),
+		error: redactingWriter(logger.error, redact),
+	});
+};

package/src/runtime/bridgeRegistry.test.ts

@@ -66,6 +66,9 @@ const registryFor = (driver: BridgeDriver, variables: Record<string, string> = {
 		onSetup() {
 			return;
 		},
+		async onRestart() {
+			return;
+		},
 	});
 
 	return createRegistry(driver, context, supervisor, ring);

package/src/runtime/bridgeRegistry.ts

@@ -95,12 +95,24 @@ const withVariables = (context: BridgeContext, overlay: Record<string, string>):
 		variable(key) {
 			return Object.hasOwn(overlay, key) ? (overlay[key] ?? null) : context.variable(key);
 		},
+		variables() {
+			return {
+				...context.variables(),
+				...overlay,
+			};
+		},
 		secret(key) {
 			return context.secret(key);
 		},
+		secrets() {
+			return context.secrets();
+		},
 		port(key) {
 			return context.port(key);
 		},
+		portBlock(key) {
+			return context.portBlock(key);
+		},
 		files: context.files,
 		codec: context.codec,
 		net: context.net,
@@ -117,6 +129,9 @@ const withVariables = (context: BridgeContext, overlay: Record<string, string>):
 		emit(event, payload) {
 			context.emit(event, payload);
 		},
+		restart() {
+			return context.restart();
+		},
 		log: context.log,
 	};
 };

package/src/runtime/bridgeServer.test.ts

@@ -654,3 +654,133 @@ describe("backup ownership dispatch", () => {
 		}
 	});
 });
+
+describe("error replies", () => {
+	const SECRET = "tok-1234567890-secret";
+
+	let dir = "";
+	let socket = "";
+
+	beforeEach(async () => {
+		dir = await mkdtemp(join(tmpdir(), "bridge-server-"));
+		socket = join(dir, "bridge.sock");
+	});
+
+	afterEach(async () => {
+		await rm(dir, {
+			force: true,
+			recursive: true,
+		});
+	});
+
+	test("hide a secret value from the error and the customer text", async () => {
+		const server = createServer({
+			...baseOptions(socket),
+			redact: (value) => value.split(SECRET).join("••••"),
+			onInvoke: async () => {
+				throw new BridgeUserError({
+					ar: `رفض ${SECRET}`,
+					en: `refused ${SECRET}`,
+				});
+			},
+		});
+
+		const response = await call(socket, {
+			id: 9,
+			token: TOKEN,
+			method: BridgeMethod.Invoke,
+			module: "botDeploy",
+			action: "redeploy",
+			args: {},
+		});
+
+		server.stop(true);
+
+		expect(response).toEqual({
+			id: 9,
+			ok: false,
+			error: "refused ••••",
+			text: {
+				ar: "رفض ••••",
+				en: "refused ••••",
+			},
+		});
+	});
+});
+
+describe("failure logging", () => {
+	let dir = "";
+	let socket = "";
+
+	beforeEach(async () => {
+		dir = await mkdtemp(join(tmpdir(), "bridge-server-"));
+		socket = join(dir, "bridge.sock");
+	});
+
+	afterEach(async () => {
+		await rm(dir, {
+			force: true,
+			recursive: true,
+		});
+	});
+
+	const logged = async (error: unknown) => {
+		const lines: {
+			message: string;
+			fields: Record<string, unknown>;
+		}[] = [];
+
+		const server = createServer({
+			...baseOptions(socket),
+			onLog: (message, fields = {}) => {
+				lines.push({
+					message,
+					fields,
+				});
+			},
+			onInvoke: async () => {
+				throw error;
+			},
+		});
+
+		await call(socket, {
+			id: 3,
+			token: TOKEN,
+			method: BridgeMethod.Invoke,
+			module: "botDeploy",
+			action: "redeploy",
+			args: {},
+		});
+
+		server.stop(true);
+
+		return lines;
+	};
+
+	test("logs a refused action as a refusal with its message and no stack", async () => {
+		expect(
+			await logged(
+				new BridgeUserError({
+					ar: "فيه نشر شغّال الحين",
+					en: "a deploy is already running",
+				}),
+			),
+		).toEqual([
+			{
+				message: "bridge call refused",
+				fields: {
+					method: BridgeMethod.Invoke,
+					error: "a deploy is already running",
+				},
+			},
+		]);
+	});
+
+	test("logs an ordinary error as a failure with its stack", async () => {
+		const [line] = await logged(new Error("the marker could not be written"));
+
+		expect(line?.message).toBe("bridge call failed");
+		expect(line?.fields.error).toBe("the marker could not be written");
+		expect(String(line?.fields.stack)).toContain("the marker could not be written");
+	});
+});

package/src/runtime/bridgeServer.ts

@@ -16,6 +16,7 @@ import {
 	type BridgeStatus,
 } from "../protocol";
 import { type BridgeLogger, errorText } from "./bridgeLog";
+import { redactLocalized } from "./bridgeRedaction";
 
 export interface ServerOptions {
 	socket: string;
@@ -37,6 +38,7 @@ export interface ServerOptions {
 	onSetupStatus: () => BridgeSetupResult;
 	onSetupSubmit: (step: string, action: string, args: BridgeValues) => Promise<BridgeSetupResult>;
 	onLog: BridgeLogger;
+	redact?: (text: string) => string;
 }
 
 interface IncomingFrame {
@@ -87,6 +89,23 @@ const asArgs = (value: unknown): BridgeValues => {
 	return out;
 };
 
+const logFailure = (onLog: BridgeLogger, method: string, error: unknown) => {
+	if (error instanceof BridgeUserError) {
+		onLog("bridge call refused", {
+			method,
+			error: error.message,
+		});
+
+		return;
+	}
+
+	onLog("bridge call failed", {
+		method,
+		error: errorText(error),
+		stack: error instanceof Error ? (error.stack ?? null) : null,
+	});
+};
+
 export const createServer = (options: ServerOptions) => {
 	const handle = async (method: string, request: IncomingFrame): Promise<unknown> => {
 		switch (method) {
@@ -270,17 +289,15 @@ export const createServer = (options: ServerOptions) => {
 							);
 						})
 						.catch((error: unknown) => {
-							options.onLog("bridge call failed", {
-								method: String(request.method ?? ""),
-								error: errorText(error),
-								stack: error instanceof Error ? (error.stack ?? null) : null,
-							});
+							logFailure(options.onLog, String(request.method ?? ""), error);
+
+							const redact = options.redact ?? ((text: string) => text);
 
 							socket.write(
 								encode({
 									id,
 									ok: false,
-									error: errorText(error),
+									error: redact(errorText(error)),
 									...(error instanceof BridgeSecretError
 										? {
 												secret: error.key,
@@ -293,7 +310,7 @@ export const createServer = (options: ServerOptions) => {
 										: {}),
 									...(error instanceof BridgeUserError
 										? {
-												text: error.text,
+												text: redactLocalized(error.text, redact),
 											}
 										: {}),
 								}),

package/src/runtime/bridgeSetupHandlers.test.ts

@@ -51,6 +51,9 @@ const contextOf = (): BridgeContext => {
 		onSetup() {
 			return;
 		},
+		async onRestart() {
+			return;
+		},
 	});
 };
 
@@ -301,3 +304,88 @@ describe("the setup handlers", () => {
 		);
 	});
 });
+
+describe("the setup handlers redaction", () => {
+	const SECRET = "123456789:AAHdqTcvCH1vGWJxfSeofSAs0K5PALDsaw";
+
+	const redact = (value: string) => value.split(SECRET).join("••••");
+
+	test("blanks a secret value in the prompt a driver reports", () => {
+		const { logger } = recorder();
+		const handlers = createSetupHandlers(driverWith(setupWith()), logger, redact);
+
+		handlers.onSetup({
+			steps: [
+				{
+					id: "sign-in",
+					state: BridgeSetupStepState.Active,
+				},
+			],
+			prompt: {
+				kind: BridgeSetupPromptKind.Progress,
+				message: text(`checking ${SECRET}`),
+				percent: 50,
+				detail: `token ${SECRET}`,
+			},
+		});
+
+		expect(handlers.onSetupStatus().runtime?.prompt).toEqual({
+			kind: BridgeSetupPromptKind.Progress,
+			message: text("checking ••••"),
+			percent: 50,
+			detail: "token ••••",
+		});
+	});
+
+	test("blanks a secret value in every text of a link prompt", () => {
+		const { logger } = recorder();
+		const handlers = createSetupHandlers(driverWith(setupWith()), logger, redact);
+		const reported = signIn();
+
+		handlers.onSetup({
+			...reported,
+			prompt: {
+				kind: BridgeSetupPromptKind.Link,
+				message: text(`sign in ${SECRET}`),
+				url: "https://hytale.com/device",
+				code: "ABCD-EFGH",
+				expiresAt: null,
+				actions: [
+					{
+						id: "renew",
+						label: text(`renew ${SECRET}`),
+					},
+				],
+			},
+		});
+
+		expect(JSON.stringify(handlers.current())).not.toContain(SECRET);
+		expect(handlers.current()?.prompt).toMatchObject({
+			message: text("sign in ••••"),
+			url: "https://hytale.com/device",
+			code: "ABCD-EFGH",
+		});
+	});
+
+	test("blanks a secret value in the text of a rejected submit", async () => {
+		const { logger } = recorder();
+		const handlers = createSetupHandlers(
+			driverWith(
+				setupWith(async () => {
+					throw new BridgeUserError(text(`telegram refused ${SECRET}`));
+				}),
+			),
+			logger,
+			redact,
+		);
+
+		handlers.onSetup(signIn());
+
+		const result = await handlers.onSetupSubmit(contextOf(), "sign-in", "renew", {});
+
+		expect(result.runtime?.prompt).toMatchObject({
+			kind: BridgeSetupPromptKind.Failed,
+			message: text("telegram refused ••••"),
+		});
+	});
+});

package/src/runtime/bridgeSetupHandlers.ts

@@ -3,6 +3,7 @@ import { BridgeUserError, type BridgeValues } from "../core";
 import type { BridgeDriver } from "../modules";
 import type { BridgeSetupResult, BridgeSetupRuntime } from "../protocol";
 import type { BridgeLeveledLogger } from "./bridgeLog";
+import { type BridgeRedact, redactLocalized, redactSetupRuntime } from "./bridgeRedaction";
 import { failedSetup, normalizeSetupRuntime, unsupportedSetup } from "./bridgeSetup";
 
 export interface BridgeSetupHandlers {
@@ -12,7 +13,13 @@ export interface BridgeSetupHandlers {
 	current(): BridgeSetupRuntime | null;
 }
 
-export const createSetupHandlers = (driver: BridgeDriver, log: BridgeLeveledLogger): BridgeSetupHandlers => {
+const unredacted: BridgeRedact = (text) => text;
+
+export const createSetupHandlers = (
+	driver: BridgeDriver,
+	log: BridgeLeveledLogger,
+	redact: BridgeRedact = unredacted,
+): BridgeSetupHandlers => {
 	const declared: ReadonlySet<string> = new Set((driver.setup?.steps ?? []).map((step) => step.id));
 
 	let current: BridgeSetupRuntime | null = null;
@@ -20,10 +27,13 @@ export const createSetupHandlers = (driver: BridgeDriver, log: BridgeLeveledLogg
 	return {
 		onSetup(runtime) {
 			current = driver.setup
-				? normalizeSetupRuntime(runtime, {
-						declared,
-						warn: log.warn,
-					})
+				? redactSetupRuntime(
+						normalizeSetupRuntime(runtime, {
+							declared,
+							warn: log.warn,
+						}),
+						redact,
+					)
 				: null;
 		},
 		current() {
@@ -59,7 +69,7 @@ export const createSetupHandlers = (driver: BridgeDriver, log: BridgeLeveledLogg
 					error: error.message,
 				});
 
-				return failedSetup(current, error.text);
+				return failedSetup(current, redactLocalized(error.text, redact));
 			}
 
 			return {