roxxie-proxy-u-prod 0.1.0

package/source/packages/roxxie-transport/src/transport.ts

@@ -0,0 +1,414 @@
+import type {
+	ProxyTransport,
+	RawHeaders,
+	TransferrableResponse,
+	WebSocketDataType,
+} from "@mercuryworkshop/proxy-transports";
+import {
+	PROTOCOL_VERSION,
+	type BinaryTransport,
+} from "roxxie-transports-adrift-protocol";
+import type { CandidateNode } from "roxxie-transports-tracker-protocol";
+
+import { WebRTCBinaryTransport } from "./binary.js";
+import { RoxxieConnection, type MultiplexedSocket } from "./connection.js";
+import type { ConnectionTimeouts, TrackerNetworkDocument } from "./config.js";
+import { RoxxieTrackerClient, type TrackerSignaling } from "./tracker.js";
+
+export type RoxxieTransportStatus =
+	| { state: "idle" }
+	| { state: "connecting"; tracker: string; candidateCount: number }
+	| {
+			state: "connected";
+			nodeId: string;
+			nodeName: string;
+			mode: "webrtc";
+			rttMs: number;
+	  }
+	| { state: "failed"; message: string };
+
+export type TrackerNetworkSource =
+	| TrackerNetworkDocument
+	| (() => Promise<TrackerNetworkDocument>);
+
+export interface ConnectedNode {
+	node: CandidateNode;
+	mode: "webrtc";
+	rttMs: number;
+}
+
+interface OpenableBinaryTransport extends BinaryTransport {
+	open(): Promise<void>;
+}
+
+export interface RoxxieTransportDependencies {
+	createTracker(document: TrackerNetworkDocument): TrackerSignaling;
+	createBinary(
+		candidate: CandidateNode,
+		tracker: TrackerSignaling,
+		timeouts: ConnectionTimeouts
+	): OpenableBinaryTransport;
+}
+
+interface CandidateAttempt {
+	candidate: CandidateNode;
+	binary: OpenableBinaryTransport;
+	connection: RoxxieConnection;
+	rttMs: number;
+}
+
+const NODE_FAILURE_COOLDOWN_MS = 60_000;
+
+function messageOf(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}
+
+function cloneHeaders(headers: RawHeaders): [string, string][] {
+	return headers.map(([name, value]) => [name, value]);
+}
+
+export class RoxxieProxyTransport implements ProxyTransport {
+	private document: TrackerNetworkDocument | undefined;
+	private tracker: TrackerSignaling | undefined;
+	private connection: RoxxieConnection | undefined;
+	private connectionPromise: Promise<RoxxieConnection> | undefined;
+	private listeners = new Set<(status: RoxxieTransportStatus) => void>();
+	private _status: RoxxieTransportStatus = { state: "idle" };
+	private _connectedNode: ConnectedNode | undefined;
+	private readonly nodeCooldowns = new Map<string, number>();
+	private readonly dependencies: RoxxieTransportDependencies;
+	private closed = false;
+
+	constructor(
+		private readonly source: TrackerNetworkSource,
+		dependencies: Partial<RoxxieTransportDependencies> = {}
+	) {
+		this.dependencies = {
+			createTracker:
+				dependencies.createTracker ??
+				((document) =>
+					new RoxxieTrackerClient(document.tracker, document.timeouts)),
+			createBinary:
+				dependencies.createBinary ??
+				((candidate, tracker, timeouts) =>
+					new WebRTCBinaryTransport(candidate, tracker, timeouts)),
+		};
+	}
+
+	get ready(): boolean {
+		return this.connection?.ready === true;
+	}
+
+	get status(): RoxxieTransportStatus {
+		return this._status;
+	}
+
+	get connectedNode(): ConnectedNode | undefined {
+		return this._connectedNode;
+	}
+
+	subscribe(listener: (status: RoxxieTransportStatus) => void): () => void {
+		this.listeners.add(listener);
+		listener(this._status);
+		return () => this.listeners.delete(listener);
+	}
+
+	async init(): Promise<void> {
+		await this.ensureConnection();
+	}
+
+	async request(
+		remote: URL,
+		method: string,
+		body: BodyInit | null | undefined,
+		headers: RawHeaders,
+		signal: AbortSignal | undefined
+	): Promise<TransferrableResponse> {
+		const connection = await this.ensureConnection();
+		const response = await connection.request(
+			remote,
+			method,
+			body,
+			cloneHeaders(headers),
+			signal
+		);
+		return {
+			body: response.body,
+			headers: response.headers,
+			status: response.status,
+			statusText: response.statusText,
+		};
+	}
+
+	/** Opens a target-site WebSocket inside the selected WebRTC proxy channel. */
+	connect(
+		url: URL,
+		protocols: string[],
+		requestHeaders: RawHeaders,
+		onopen: (protocol: string, extensions: string) => void,
+		onmessage: (data: WebSocketDataType) => void,
+		onclose: (code: number, reason: string) => void,
+		onerror: (error: string) => void
+	): [
+		(data: WebSocketDataType) => void,
+		(code: number, reason: string) => void,
+	] {
+		let socket: MultiplexedSocket | undefined;
+		let opened = false;
+		let terminal = false;
+		const pending: WebSocketDataType[] = [];
+		let requestedClose: { code: number; reason: string } | undefined;
+
+		void this.ensureConnection()
+			.then((connection) => {
+				if (terminal) return;
+				socket = connection.openSocket(
+					url,
+					protocols,
+					cloneHeaders(requestHeaders),
+					{
+						onopen: (protocol, extensions) => {
+							opened = true;
+							try {
+								onopen(protocol, extensions);
+							} finally {
+								for (const data of pending.splice(0)) socket?.send(data);
+								if (requestedClose !== undefined) {
+									socket?.close(requestedClose.code, requestedClose.reason);
+								}
+							}
+						},
+						onmessage,
+						onclose: (code, reason) => {
+							terminal = true;
+							onclose(code, reason);
+						},
+						onerror,
+					}
+				);
+			})
+			.catch((error: unknown) => {
+				if (terminal) return;
+				terminal = true;
+				const message = messageOf(error);
+				onerror(message);
+				onclose(1011, message);
+			});
+
+		return [
+			(data) => {
+				if (terminal) return;
+				if (socket === undefined || !opened) pending.push(data);
+				else socket.send(data);
+			},
+			(code, reason) => {
+				if (terminal) return;
+				requestedClose = { code, reason };
+				socket?.close(code, reason);
+			},
+		];
+	}
+
+	close(): void {
+		if (this.closed) return;
+		this.closed = true;
+		const connection = this.connection;
+		this.connection = undefined;
+		this._connectedNode = undefined;
+		connection?.close(new Error("Roxxie transport was closed"));
+		this.tracker?.close();
+		this.tracker = undefined;
+		this.publish({ state: "idle" });
+	}
+
+	private async ensureConnection(): Promise<RoxxieConnection> {
+		if (this.closed) throw new Error("Roxxie transport is closed");
+		if (this.connection?.ready === true) return this.connection;
+		if (this.connectionPromise !== undefined) return this.connectionPromise;
+		const attempt = this.establishConnection();
+		this.connectionPromise = attempt;
+		try {
+			const connection = await attempt;
+			if (!connection.ready) {
+				throw new Error(
+					"Selected Roxxie connection closed while being installed"
+				);
+			}
+			this.connection = connection;
+			return connection;
+		} finally {
+			if (this.connectionPromise === attempt) {
+				this.connectionPromise = undefined;
+			}
+		}
+	}
+
+	private async establishConnection(): Promise<RoxxieConnection> {
+		const document = await this.getDocument();
+		const tracker = this.getTracker(document);
+		const discovered = [...(await tracker.requestCandidates())]
+			.slice(0, 3)
+			.sort(
+				(left, right) =>
+					left.utilization - right.utilization ||
+					left.activeSessions - right.activeSessions
+			);
+		const compatible = discovered.filter(
+			(candidate) => candidate.protocolVersion === PROTOCOL_VERSION
+		);
+		if (compatible.length === 0) {
+			const message =
+				discovered.length === 0
+					? "Tracker returned no approved healthy Roxxie nodes"
+					: `Tracker returned no nodes compatible with protocol ${PROTOCOL_VERSION}`;
+			this.publish({ state: "failed", message });
+			throw new Error(message);
+		}
+
+		const now = Date.now();
+		const candidates = compatible.filter((candidate) => {
+			const until = this.nodeCooldowns.get(candidate.nodeId) ?? 0;
+			if (until > now) return false;
+			this.nodeCooldowns.delete(candidate.nodeId);
+			return true;
+		});
+		// A single-node deployment should recover after a transient failure instead
+		// of becoming unavailable solely because every result is on cooldown.
+		const candidatesToProbe = candidates.length > 0 ? candidates : compatible;
+		this.publish({
+			state: "connecting",
+			tracker: document.tracker.url,
+			candidateCount: candidatesToProbe.length,
+		});
+
+		const settled = await Promise.allSettled(
+			candidatesToProbe.map(async (candidate) =>
+				this.probeCandidate(candidate, tracker, document.timeouts)
+			)
+		);
+		const successes: CandidateAttempt[] = [];
+		const errors: Error[] = [];
+		for (let index = 0; index < settled.length; index += 1) {
+			const result = settled[index];
+			const candidate = candidatesToProbe[index];
+			if (result?.status === "fulfilled") {
+				successes.push(result.value);
+			} else if (result?.status === "rejected" && candidate !== undefined) {
+				this.nodeCooldowns.set(
+					candidate.nodeId,
+					Date.now() + NODE_FAILURE_COOLDOWN_MS
+				);
+				errors.push(
+					new Error(`${candidate.name}: ${messageOf(result.reason)}`, {
+						cause: result.reason,
+					})
+				);
+			}
+		}
+
+		if (this.closed) {
+			for (const success of successes) {
+				success.connection.close(
+					new Error("Roxxie transport closed during candidate selection")
+				);
+			}
+			throw new Error("Roxxie transport is closed");
+		}
+		if (successes.length === 0) {
+			const aggregate = new AggregateError(
+				errors,
+				"Unable to establish WebRTC with any tracker candidate"
+			);
+			this.publish({ state: "failed", message: aggregate.message });
+			throw aggregate;
+		}
+
+		successes.sort(
+			(left, right) =>
+				left.rttMs - right.rttMs ||
+				left.candidate.utilization - right.candidate.utilization
+		);
+		const winner = successes[0] as CandidateAttempt;
+		this.nodeCooldowns.delete(winner.candidate.nodeId);
+		for (const loser of successes.slice(1)) {
+			loser.connection.close(
+				new Error(`Candidate lost RTT probe (${loser.rttMs.toFixed(1)} ms)`)
+			);
+		}
+
+		this.connection = winner.connection;
+		this._connectedNode = {
+			node: winner.candidate,
+			mode: "webrtc",
+			rttMs: winner.rttMs,
+		};
+		winner.connection.setFailureHandler((error) => {
+			if (this.connection !== winner.connection) return;
+			this.connection = undefined;
+			this._connectedNode = undefined;
+			this.nodeCooldowns.set(
+				winner.candidate.nodeId,
+				Date.now() + NODE_FAILURE_COOLDOWN_MS
+			);
+			this.publish({ state: "failed", message: error.message });
+			setTimeout(() => {
+				if (!this.closed) void this.ensureConnection().catch(() => undefined);
+			}, 0);
+		});
+		this.publish({
+			state: "connected",
+			nodeId: winner.candidate.nodeId,
+			nodeName: winner.candidate.name,
+			mode: "webrtc",
+			rttMs: winner.rttMs,
+		});
+		return winner.connection;
+	}
+
+	private async probeCandidate(
+		candidate: CandidateNode,
+		tracker: TrackerSignaling,
+		timeouts: ConnectionTimeouts
+	): Promise<CandidateAttempt> {
+		const binary = this.dependencies.createBinary(candidate, tracker, timeouts);
+		let connection: RoxxieConnection | undefined;
+		try {
+			await binary.open();
+			if (this.closed) throw new Error("Roxxie transport is closed");
+			connection = await RoxxieConnection.create(binary, timeouts.handshakeMs);
+			const rttMs = await connection.ping(timeouts.probeMs);
+			if (this.closed) throw new Error("Roxxie transport is closed");
+			return { candidate, binary, connection, rttMs };
+		} catch (error) {
+			if (connection !== undefined) connection.close(error);
+			else binary.close(4000, "Candidate connection failed");
+			throw error;
+		}
+	}
+
+	private async getDocument(): Promise<TrackerNetworkDocument> {
+		if (this.document !== undefined) return this.document;
+		const document =
+			typeof this.source === "function" ? await this.source() : this.source;
+		this.document = document;
+		return document;
+	}
+
+	private getTracker(document: TrackerNetworkDocument): TrackerSignaling {
+		if (this.tracker === undefined) {
+			this.tracker = this.dependencies.createTracker(document);
+		}
+		return this.tracker;
+	}
+
+	private publish(status: RoxxieTransportStatus): void {
+		this._status = status;
+		for (const listener of this.listeners) {
+			try {
+				listener(status);
+			} catch (error) {
+				console.error("A Roxxie transport status listener threw", error);
+			}
+		}
+	}
+}

package/source/packages/roxxie-transport/tsconfig.json

@@ -0,0 +1,18 @@
+{
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "ESNext",
+		"moduleResolution": "Bundler",
+		"lib": ["ES2022", "DOM", "DOM.Iterable"],
+		"rootDir": ".",
+		"outDir": "dist",
+		"declaration": true,
+		"declarationMap": true,
+		"sourceMap": true,
+		"strict": true,
+		"noUncheckedIndexedAccess": true,
+		"exactOptionalPropertyTypes": true,
+		"skipLibCheck": true
+	},
+	"include": ["src/**/*.ts", "test/**/*.ts"]
+}

package/source/packages/scramjet/packages/controller/package.json

@@ -0,0 +1,37 @@
+{
+	"name": "@mercuryworkshop/scramjet-controller",
+	"version": "0.0.14",
+	"type": "module",
+	"packageManager": "pnpm@10.12.1",
+	"license": "AGPL-3.0-only",
+	"main": "./dist/controller-external.mjs",
+	"module": "./dist/controller-external.mjs",
+	"types": "./dist/types/typesEntry.d.ts",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/MercuryWorkshop/scramjet.git",
+		"directory": "packages/controller"
+	},
+	"scripts": {
+		"build": "cd ../.. && rspack build --mode production --config-name scramjet-esmodule --config-name scramjet-controller",
+		"prepack": "pnpm build"
+	},
+	"exports": {
+		".": {
+			"types": "./dist/types/typesEntry.d.ts",
+			"default": "./dist/controller-external.mjs"
+		}
+	},
+	"peerDependencies": {
+		"@mercuryworkshop/scramjet": "*"
+	},
+	"dependencies": {
+		"@fastify/deepmerge": "^3.2.1",
+		"@mercuryworkshop/proxy-transports": "catalog:"
+	},
+	"devDependencies": {
+		"@mercuryworkshop/scramjet": "workspace:*",
+		"@types/serviceworker": "^0.0.197",
+		"@mercuryworkshop/rpc": "workspace:*"
+	}
+}