roxxie-proxy-u-prod 0.1.0

package/source/packages/inject/src/transport.ts

@@ -0,0 +1,97 @@
+import type {
+	ProxyTransport,
+	TransferrableResponse,
+	RawHeaders,
+	WebSocketMessage,
+} from "@mercuryworkshop/proxy-transports";
+import type { RpcHelper } from "@mercuryworkshop/rpc";
+import { ExecutionContextWrapper } from "./context";
+
+const MessagePort_postMessage = MessagePort.prototype.postMessage;
+const postMessage = (
+	port: MessagePort,
+	data: any,
+	transfer?: Transferable[]
+) => {
+	MessagePort_postMessage.call(port, data, transfer as any);
+};
+
+export class RemoteTransport implements ProxyTransport {
+	public ready = true;
+	async init() {}
+
+	constructor(public context: ExecutionContextWrapper) {}
+	connect(
+		url: URL,
+		protocols: string[],
+		requestHeaders: RawHeaders,
+		onopen: (protocol: string, extensions: string) => void,
+		onmessage: (data: Blob | ArrayBuffer | string) => void,
+		onclose: (code: number, reason: string) => void,
+		onerror: (error: string) => void
+	): [
+		(data: Blob | ArrayBuffer | string) => void,
+		(code: number, reason: string) => void,
+	] {
+		const channel = new MessageChannel();
+		const port = channel.port1;
+		console.warn("connecting");
+		this.context.rpc
+			.call(
+				"wsconnect",
+				{
+					url: url.href,
+					protocols,
+					requestHeaders,
+					port: channel.port2,
+				},
+				[channel.port2]
+			)
+			.then((response) => {
+				if (response.result === "success") {
+					onopen(response.protocol, response.extensions);
+				} else {
+					onerror(response.error);
+				}
+			});
+		port.onmessage = (ev) => {
+			const message = ev.data as WebSocketMessage;
+			if (message.type === "data") {
+				onmessage(message.data);
+			} else if (message.type === "close") {
+				onclose(message.code, message.reason);
+			}
+		};
+		port.onmessageerror = (ev) => {
+			console.error("onmessageerror (this should never happen!)", ev);
+			onerror("Message error in transport port");
+		};
+
+		return [
+			(data) => {
+				postMessage(
+					port,
+					{
+						type: "data",
+						data: data,
+					},
+					data instanceof ArrayBuffer ? [data] : []
+				);
+			},
+			(code) => {
+				postMessage(port, {
+					type: "close",
+					code: code,
+				});
+			},
+		];
+	}
+
+	async request(
+		remote: URL,
+		method: string,
+		body: BodyInit | null,
+		headers: RawHeaders,
+		_signal: AbortSignal | undefined
+	): Promise<TransferrableResponse> {}
+}

package/source/packages/inject/src/types.d.ts

@@ -0,0 +1,136 @@
+import {
+	ScramjetInterface,
+	TrackedHistoryState,
+} from "@mercuryworkshop/scramjet/bundled";
+import type { RawHeaders } from "@mercuryworkshop/proxy-transports";
+import type { ThemeDefinition } from "../../chrome/src/themes";
+export type FrameSequence = number[];
+
+export type Chromebound = {
+	wsconnect: [
+		{
+			url: string;
+			protocols: string[];
+			requestHeaders: RawHeaders;
+			port: MessagePort;
+		},
+		(
+			| {
+					result: "success";
+					protocol: string;
+					extensions: string;
+			  }
+			| {
+					result: "failure";
+					error: string;
+			  }
+		),
+	];
+	contextmenu: [
+		{
+			x: number;
+			y: number;
+			selection?: string;
+			image?: {
+				src: string;
+				width: number;
+				height: number;
+			};
+			anchor?: {
+				href: string;
+			};
+			video?: {
+				src: string;
+				width: number;
+				height: number;
+			};
+		},
+	];
+	titlechange: [
+		{
+			title?: string;
+			icon?: string;
+		},
+	];
+	load: [
+		{
+			url: string;
+			sequence: FrameSequence;
+		},
+	];
+	registerFrameContext: [{ id: string }];
+	newtab: [
+		{
+			url: string;
+		},
+		{
+			sequence: FrameSequence;
+		},
+	];
+	history_pushState: [
+		{
+			state: any;
+			title: string;
+			url: string;
+		},
+	];
+	history_replaceState: [
+		{
+			state: any;
+			title: string;
+			url: string;
+		},
+	];
+	history_go: [{ delta: number }];
+	/**
+	 * Inject → chrome: a write to `document.cookie` (or equivalent) just landed
+	 * in this frame. Chrome updates its shared cookieJar and fans the batch out
+	 * to every other live frame context so their local jars stay in sync.
+	 */
+	setCookies: [
+		{
+			cookies: { cookie: string; url: string }[];
+		},
+	];
+};
+
+export type Framebound = {
+	navigate: [
+		{
+			url: string;
+		},
+	];
+	popstate: [
+		{
+			state: any;
+			url: string;
+			title: string;
+		},
+	];
+	fetchBlob: [
+		string,
+		{
+			body: ArrayBuffer;
+			contentType: string;
+		},
+	];
+	setCookies: [
+		{
+			cookies: { cookie: string; url: string }[];
+		},
+	];
+	updateTheme: [ThemeDefinition];
+};
+
+export type InjectScramjetInit = {
+	sequence: FrameSequence;
+	id: string;
+	config: any;
+	cookies: string;
+	getInjectScripts: ScramjetInterface["getInjectScripts"];
+	prefix: string;
+	codecEncode: ScramjetInterface["codecEncode"];
+	codecDecode: ScramjetInterface["codecDecode"];
+	initHeaders: RawHeaders;
+	history: TrackedHistoryState[];
+};

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

@@ -0,0 +1,36 @@
+{
+	"name": "roxxie-transports",
+	"version": "6.0.0",
+	"description": "Tracker-discovered WebRTC transport for Roxxie Proxy U",
+	"type": "module",
+	"sideEffects": false,
+	"exports": {
+		".": {
+			"types": "./dist/src/index.d.ts",
+			"import": "./dist/src/index.js"
+		}
+	},
+	"files": [
+		"dist/src"
+	],
+	"scripts": {
+		"build": "tsc -p tsconfig.json",
+		"test": "npm run build && node --test dist/test/*.test.js"
+	},
+	"engines": {
+		"node": ">=20"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"license": "AGPL-3.0-only",
+	"dependencies": {
+		"@mercuryworkshop/proxy-transports": "catalog:",
+		"roxxie-transports-adrift-protocol": "workspace:*",
+		"roxxie-transports-tracker-protocol": "workspace:*"
+	},
+	"devDependencies": {
+		"@types/node": "^20.0.0",
+		"typescript": "~5.9.3"
+	}
+}

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

@@ -0,0 +1,398 @@
+import {
+	MAX_DATA_CHANNEL_MESSAGE_BYTES,
+	PROTOCOL_VERSION,
+	type BinaryTransport,
+} from "roxxie-transports-adrift-protocol";
+import type {
+	CandidateNode,
+	IceCandidateJSON,
+	RTCIceServerJSON,
+	SessionDescriptionJSON,
+	WebRTCOffer,
+} from "roxxie-transports-tracker-protocol";
+
+import type { ConnectionTimeouts } from "./config.js";
+import type { TrackerSignaling } from "./tracker.js";
+
+export const BINARY_TRANSPORT_BUFFER_HIGH_WATER_BYTES = 1024 * 1024;
+export const BINARY_TRANSPORT_BUFFER_LOW_WATER_BYTES = 256 * 1024;
+
+interface BufferedEventTarget extends EventTarget {
+	bufferedAmount: number;
+	bufferedAmountLowThreshold: number;
+}
+
+type DrainCancellation = (error: Error) => void;
+
+function rejectPendingDrains(
+	pending: Set<DrainCancellation>,
+	error: Error
+): void {
+	for (const cancel of [...pending]) cancel(error);
+}
+
+function waitForBufferedAmountLowEvent(
+	target: BufferedEventTarget,
+	isOpen: () => boolean,
+	pending: Set<DrainCancellation>
+): Promise<void> {
+	return new Promise<void>((resolve, reject) => {
+		let settled = false;
+		const cleanup = () => {
+			target.removeEventListener("bufferedamountlow", onBufferedAmountLow);
+			target.removeEventListener("close", onClose);
+			target.removeEventListener("error", onError);
+			pending.delete(cancel);
+		};
+		const settle = (error?: Error) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			if (error === undefined) resolve();
+			else reject(error);
+		};
+		const onBufferedAmountLow = () => settle();
+		const onClose = () =>
+			settle(new Error("WebRTC transport closed while buffering"));
+		const onError = () =>
+			settle(new Error("WebRTC transport error while buffering"));
+		const cancel: DrainCancellation = (error) => settle(error);
+
+		pending.add(cancel);
+		target.addEventListener("bufferedamountlow", onBufferedAmountLow);
+		target.addEventListener("close", onClose);
+		target.addEventListener("error", onError);
+		if (!isOpen()) onClose();
+		else if (target.bufferedAmount <= BINARY_TRANSPORT_BUFFER_LOW_WATER_BYTES) {
+			onBufferedAmountLow();
+		}
+	});
+}
+
+function errorMessage(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}
+
+function timeoutError(label: string, milliseconds: number): Error {
+	return new Error(`${label} timed out after ${milliseconds} ms`);
+}
+
+async function withTimeout<T>(
+	promise: Promise<T>,
+	milliseconds: number,
+	label: string,
+	onTimeout?: () => void
+): Promise<T> {
+	let timer: ReturnType<typeof setTimeout> | undefined;
+	const timeout = new Promise<never>((_resolve, reject) => {
+		timer = setTimeout(() => {
+			onTimeout?.();
+			reject(timeoutError(label, milliseconds));
+		}, milliseconds);
+	});
+	try {
+		return await Promise.race([promise, timeout]);
+	} finally {
+		if (timer !== undefined) clearTimeout(timer);
+	}
+}
+
+async function eventDataBuffer(value: unknown): Promise<ArrayBuffer> {
+	if (value instanceof ArrayBuffer) {
+		if (value.byteLength > MAX_DATA_CHANNEL_MESSAGE_BYTES) {
+			throw new Error("Proxy node exceeded the data-channel message limit");
+		}
+		return value;
+	}
+	if (ArrayBuffer.isView(value)) {
+		if (value.byteLength > MAX_DATA_CHANNEL_MESSAGE_BYTES) {
+			throw new Error("Proxy node exceeded the data-channel message limit");
+		}
+		return new Uint8Array(
+			value.buffer,
+			value.byteOffset,
+			value.byteLength
+		).slice().buffer;
+	}
+	if (value instanceof Blob) {
+		if (value.size > MAX_DATA_CHANNEL_MESSAGE_BYTES) {
+			throw new Error("Proxy node exceeded the data-channel message limit");
+		}
+		const result = await value.arrayBuffer();
+		if (result.byteLength > MAX_DATA_CHANNEL_MESSAGE_BYTES) {
+			throw new Error("Proxy node exceeded the data-channel message limit");
+		}
+		return result;
+	}
+	throw new Error("Proxy node sent a non-binary data-channel message");
+}
+
+function descriptionJSON(
+	description: RTCSessionDescription | RTCSessionDescriptionInit
+): SessionDescriptionJSON {
+	return {
+		type: description.type,
+		...(description.sdp === undefined || description.sdp === null
+			? {}
+			: { sdp: description.sdp }),
+	};
+}
+
+function candidateJSON(candidate: RTCIceCandidate): IceCandidateJSON {
+	const json = candidate.toJSON();
+	return {
+		candidate: json.candidate ?? "",
+		sdpMid: json.sdpMid ?? null,
+		sdpMLineIndex: json.sdpMLineIndex ?? null,
+		usernameFragment: json.usernameFragment ?? null,
+	};
+}
+
+function rtcIceServer(server: RTCIceServerJSON): RTCIceServer {
+	return {
+		urls: server.urls,
+		...(server.username === undefined ? {} : { username: server.username }),
+		...(server.credential === undefined
+			? {}
+			: { credential: server.credential }),
+	};
+}
+
+/**
+ * Browser-to-node proxy payload transport. The tracker is used only to forward
+ * SDP/ICE signaling; every payload byte after open() travels on this channel.
+ */
+export class WebRTCBinaryTransport implements BinaryTransport {
+	ondata: (data: ArrayBuffer) => void = () => undefined;
+	onopen?: () => void;
+	onclose?: (reason?: unknown) => void;
+
+	private peer: RTCPeerConnection | undefined;
+	private channel: RTCDataChannel | undefined;
+	private messageQueue: Promise<void> = Promise.resolve();
+	private readonly pendingDrains = new Set<DrainCancellation>();
+	private readonly abortController = new AbortController();
+	private closed = false;
+	private closeReported = false;
+
+	constructor(
+		readonly candidate: CandidateNode,
+		private readonly signaling: TrackerSignaling,
+		private readonly timeouts: ConnectionTimeouts
+	) {}
+
+	async open(): Promise<void> {
+		if (this.peer !== undefined)
+			throw new Error("WebRTC transport is already open");
+		if (this.closed) throw new Error("WebRTC transport is closed");
+		if (this.candidate.protocolVersion !== PROTOCOL_VERSION) {
+			throw new Error(
+				`Node ${this.candidate.nodeId} uses protocol ${this.candidate.protocolVersion}; expected ${PROTOCOL_VERSION}`
+			);
+		}
+
+		const peer = new RTCPeerConnection({
+			iceServers: this.candidate.iceServers.map(rtcIceServer),
+		});
+		this.peer = peer;
+		const channel = peer.createDataChannel("host-server", { ordered: true });
+		this.channel = channel;
+		channel.binaryType = "arraybuffer";
+		channel.bufferedAmountLowThreshold =
+			BINARY_TRANSPORT_BUFFER_LOW_WATER_BYTES;
+		this.installRuntimeListeners(peer, channel);
+
+		const candidates: IceCandidateJSON[] = [];
+		peer.addEventListener("icecandidate", (event) => {
+			// Firefox emits an RTCIceCandidate with an empty candidate string at
+			// the end of a generation. It is a completion marker, not a candidate,
+			// and the signaling schema intentionally rejects it.
+			if (event.candidate !== null && event.candidate.candidate.length > 0) {
+				candidates.push(candidateJSON(event.candidate));
+			}
+		});
+
+		try {
+			const offer = await peer.createOffer();
+			await peer.setLocalDescription(offer);
+			await this.waitForIceGathering(peer);
+			if (peer.localDescription === null) {
+				throw new Error("Browser did not create a WebRTC local description");
+			}
+			if (
+				candidates.length === 0 &&
+				!/(?:^|\r?\n)a=candidate:/u.test(peer.localDescription.sdp)
+			) {
+				throw new Error(
+					"Browser gathered no WebRTC ICE candidates. Direct node connections require WebRTC/UDP candidate access; check the browser WebRTC IP policy, VPN, firewall, and network settings"
+				);
+			}
+			const request: WebRTCOffer = {
+				protocolVersion: PROTOCOL_VERSION,
+				offer: descriptionJSON(peer.localDescription),
+				candidates,
+			};
+			const answer = await this.signaling.requestSession(
+				this.candidate.nodeId,
+				request,
+				this.abortController.signal
+			);
+			if (answer.protocolVersion !== PROTOCOL_VERSION) {
+				throw new Error(
+					`Node answered with protocol ${answer.protocolVersion}; expected ${PROTOCOL_VERSION}`
+				);
+			}
+			await peer.setRemoteDescription(answer.answer);
+			for (const candidate of answer.candidates) {
+				if (candidate.candidate.length > 0) {
+					await peer.addIceCandidate(candidate);
+				}
+			}
+			await withTimeout(
+				this.waitForChannelOpen(channel),
+				this.timeouts.webrtcMs,
+				"WebRTC connection",
+				() => this.abortController.abort("WebRTC connection timed out")
+			);
+			if (this.closed)
+				throw new Error("WebRTC transport was closed while opening");
+		} catch (error) {
+			this.close();
+			throw new Error(
+				`Unable to establish WebRTC transport: ${errorMessage(error)}`,
+				{ cause: error }
+			);
+		}
+
+		this.onopen?.();
+	}
+
+	async send(data: ArrayBuffer): Promise<void> {
+		const channel = this.channel;
+		if (channel?.readyState !== "open" || this.closed) {
+			throw new Error("WebRTC transport is not open");
+		}
+		if (data.byteLength > MAX_DATA_CHANNEL_MESSAGE_BYTES) {
+			throw new Error("Proxy frame exceeds the data-channel message limit");
+		}
+		if (channel.bufferedAmount > BINARY_TRANSPORT_BUFFER_HIGH_WATER_BYTES) {
+			await waitForBufferedAmountLowEvent(
+				channel,
+				() => channel.readyState === "open" && !this.closed,
+				this.pendingDrains
+			);
+		}
+		if (channel.readyState !== "open" || this.closed) {
+			throw new Error("WebRTC transport closed while buffering");
+		}
+		channel.send(data);
+	}
+
+	close(): void {
+		if (this.closed) return;
+		this.closed = true;
+		this.abortController.abort("WebRTC transport closed");
+		rejectPendingDrains(
+			this.pendingDrains,
+			new Error("WebRTC transport closed while buffering")
+		);
+		if (this.channel?.readyState !== "closed") this.channel?.close();
+		this.peer?.close();
+	}
+
+	private installRuntimeListeners(
+		peer: RTCPeerConnection,
+		channel: RTCDataChannel
+	): void {
+		channel.addEventListener("message", (event) => {
+			this.messageQueue = this.messageQueue
+				.then(async () => this.ondata(await eventDataBuffer(event.data)))
+				.catch((error: unknown) => {
+					this.reportClose(errorMessage(error));
+				});
+		});
+		channel.addEventListener("close", () => {
+			this.reportClose("WebRTC data channel closed");
+		});
+		channel.addEventListener("error", () => {
+			this.reportClose("WebRTC data channel error");
+		});
+		peer.addEventListener("connectionstatechange", () => {
+			if (peer.connectionState === "failed") {
+				this.reportClose("WebRTC peer connection failed");
+			}
+		});
+	}
+
+	private reportClose(message: string): void {
+		if (this.closed || this.closeReported) return;
+		this.closeReported = true;
+		rejectPendingDrains(this.pendingDrains, new Error(message));
+		this.onclose?.(new Error(message));
+	}
+
+	private async waitForIceGathering(peer: RTCPeerConnection): Promise<void> {
+		if (peer.iceGatheringState === "complete") return;
+		await new Promise<void>((resolve, reject) => {
+			const cleanup = () => {
+				clearTimeout(timer);
+				peer.removeEventListener("icegatheringstatechange", onState);
+				this.abortController.signal.removeEventListener("abort", onAbort);
+			};
+			const finish = () => {
+				cleanup();
+				resolve();
+			};
+			const onState = () => {
+				if (peer.iceGatheringState === "complete") finish();
+			};
+			const onAbort = () => {
+				cleanup();
+				reject(new Error("WebRTC transport closed during ICE gathering"));
+			};
+			// Continue with candidates gathered so far when the cap expires.
+			const timer = setTimeout(finish, this.timeouts.iceGatheringMs);
+			peer.addEventListener("icegatheringstatechange", onState);
+			this.abortController.signal.addEventListener("abort", onAbort, {
+				once: true,
+			});
+		});
+	}
+
+	private waitForChannelOpen(channel: RTCDataChannel): Promise<void> {
+		return new Promise<void>((resolve, reject) => {
+			if (channel.readyState === "open") {
+				resolve();
+				return;
+			}
+			const cleanup = () => {
+				channel.removeEventListener("open", onOpen);
+				channel.removeEventListener("error", onError);
+				channel.removeEventListener("close", onClose);
+				this.abortController.signal.removeEventListener("abort", onAbort);
+			};
+			const onOpen = () => {
+				cleanup();
+				resolve();
+			};
+			const onError = () => {
+				cleanup();
+				reject(new Error("WebRTC data channel failed"));
+			};
+			const onClose = () => {
+				cleanup();
+				reject(new Error("WebRTC data channel closed before opening"));
+			};
+			const onAbort = () => {
+				cleanup();
+				reject(new Error("WebRTC transport was closed while opening"));
+			};
+			channel.addEventListener("open", onOpen);
+			channel.addEventListener("error", onError);
+			channel.addEventListener("close", onClose);
+			this.abortController.signal.addEventListener("abort", onAbort, {
+				once: true,
+			});
+		});
+	}
+}