roxxie-proxy-u-prod 0.1.0

package/source/packages/scramjet/packages/controller/src/inject.ts

@@ -0,0 +1,365 @@
+import type {
+	RawHeaders,
+	ProxyTransport,
+	TransferrableResponse,
+} from "@mercuryworkshop/proxy-transports";
+
+import { RpcHelper } from "@mercuryworkshop/rpc";
+import type { Config } from ".";
+import { CONTROLLERFRAME } from "./symbols";
+import type {
+	SerializedCookieSyncEntry,
+	ControllerToTransport,
+	TransportToController,
+	WebSocketMessage,
+} from "./types";
+import {
+	CookieJar,
+	SCRAMJETCLIENT,
+	ScramjetClient,
+	setWasm,
+	Tap,
+	type CookieSyncOptions,
+	type ScramjetConfig,
+	type ScramjetContext,
+	type TrackedHistoryState,
+} from "@mercuryworkshop/scramjet";
+
+const MessagePort_postMessage = MessagePort.prototype.postMessage;
+const postMessage = (
+	port: MessagePort,
+	data: any,
+	transfer?: Transferable[]
+) => {
+	MessagePort_postMessage.call(port, data, transfer as any);
+};
+
+class RemoteTransport implements ProxyTransport {
+	private readyResolve!: () => void;
+	private readyPromise: Promise<void> = new Promise((resolve) => {
+		this.readyResolve = resolve;
+	});
+
+	public ready = false;
+	async init() {
+		await this.readyPromise;
+		this.ready = true;
+	}
+
+	private rpc: RpcHelper<ControllerToTransport, TransportToController>;
+	constructor(public port: MessagePort) {
+		this.rpc = new RpcHelper<ControllerToTransport, TransportToController>(
+			{
+				ready: async () => {
+					this.readyResolve();
+				},
+			},
+			"transport",
+			(data, transfer) => {
+				postMessage(port, data, transfer);
+			}
+		);
+		port.onmessageerror = (ev) => {
+			console.error("onmessageerror (this should never happen!)", ev);
+		};
+		port.onmessage = (ev) => {
+			this.rpc.recieve(ev.data);
+		};
+		port.start();
+	}
+	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.rpc
+			.call(
+				"connect",
+				{
+					url: url.href,
+					protocols,
+					requestHeaders,
+					port: channel.port2,
+				},
+				[channel.port2]
+			)
+			.then((response) => {
+				console.log(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> {
+		return await this.rpc.call("request", {
+			remote: remote.href,
+			method,
+			body,
+			headers,
+		});
+	}
+
+	async sendSetCookie(
+		cookies: Array<{ url: URL; cookie: string }>,
+		options: CookieSyncOptions = {}
+	): Promise<void> {
+		await this.rpc.call("sendSetCookie", {
+			cookies: cookies.map(({ url, cookie }) => ({
+				url: url.href,
+				cookie,
+			})),
+			options,
+		});
+	}
+}
+
+const sw = navigator.serviceWorker.controller;
+
+type Init = {
+	config: Config;
+	sjconfig: ScramjetConfig;
+	prefix: URL;
+	cookies: string;
+	yieldGetInjectScripts: (
+		config: Config,
+		sjconfig: ScramjetConfig,
+		prefix: URL,
+		cookieJar: CookieJar,
+		codecEncode: (input: string) => string,
+		codecDecode: (input: string) => string
+	) => any;
+	codecEncode: (input: string) => string;
+	codecDecode: (input: string) => string;
+	initHeaders: RawHeaders;
+	history: TrackedHistoryState[];
+};
+
+export function load(init: Init) {
+	if (SCRAMJETCLIENT in globalThis) {
+		((globalThis as any)[SCRAMJETCLIENT] as ScramjetClient).syncDocumentInit({
+			initHeaders: init.initHeaders,
+			history: init.history,
+			cookies: init.cookies,
+		});
+		return;
+	}
+	if (!("WASM" in self)) {
+		throw new Error("WASM not found in global scope!");
+	}
+	const wasm = Uint8Array.from(atob(self.WASM), (c) => c.charCodeAt(0));
+	delete (self as any).WASM;
+	setWasm(wasm);
+
+	new ExecutionContextWrapper(globalThis, init);
+}
+
+function createFrameId() {
+	return `${Array(8)
+		.fill(0)
+		.map(() => Math.floor(Math.random() * 36).toString(36))
+		.join("")}`;
+}
+
+class ExecutionContextWrapper {
+	client!: ScramjetClient;
+	cookieJar: CookieJar;
+	transport: RemoteTransport;
+	private handleServiceWorkerCookieMessage: (event: MessageEvent) => void;
+
+	constructor(
+		public global: typeof globalThis,
+		public init: Init
+	) {
+		const channel = new MessageChannel();
+		this.transport = new RemoteTransport(channel.port1);
+		sw?.postMessage(
+			{
+				$sw$initRemoteTransport: {
+					port: channel.port2,
+					prefix: this.init.prefix.href,
+				},
+			},
+			[channel.port2]
+		);
+
+		this.cookieJar = new CookieJar();
+		this.cookieJar.load(this.init.cookies);
+
+		this.handleServiceWorkerCookieMessage = (event: MessageEvent) => {
+			if (
+				!event.data?.$controller$setCookie ||
+				typeof event.data.$controller$setCookie !== "object"
+			) {
+				return;
+			}
+
+			const payload = event.data.$controller$setCookie as {
+				cookies?: SerializedCookieSyncEntry[];
+				options?: CookieSyncOptions;
+				id?: string;
+			};
+
+			if (payload.options?.clear) {
+				this.cookieJar.clear();
+			}
+
+			if (Array.isArray(payload.cookies)) {
+				for (const cookie of payload.cookies) {
+					if (
+						typeof cookie?.url !== "string" ||
+						typeof cookie.cookie !== "string"
+					) {
+						continue;
+					}
+
+					try {
+						this.cookieJar.setCookies(cookie.cookie, new URL(cookie.url));
+					} catch {
+						console.error("Failed to set cookie", cookie);
+					}
+				}
+			}
+
+			if (typeof payload.id === "string") {
+				const targetSw = navigator.serviceWorker?.controller ?? sw;
+				targetSw?.postMessage({
+					$sw$setCookieDone: {
+						id: payload.id,
+					},
+				});
+			}
+		};
+
+		navigator.serviceWorker?.addEventListener(
+			"message",
+			this.handleServiceWorkerCookieMessage
+		);
+
+		this.injectScramjet();
+	}
+
+	injectScramjet() {
+		const frame = this.global.frameElement as HTMLIFrameElement | null;
+		if (frame && !frame.name) {
+			window.name = frame.name = createFrameId();
+		}
+		let controllerFrame = frame?.[CONTROLLERFRAME];
+		let isTopLevel = true;
+		if (!controllerFrame) {
+			isTopLevel = false;
+			let currentwin = this.global.window;
+			while (currentwin.parent !== currentwin) {
+				const currentclient = currentwin[SCRAMJETCLIENT];
+				if (!currentclient) {
+					currentwin = currentwin.parent.window;
+					continue;
+				}
+				const currentFrame = currentclient.descriptors.get(
+					"window.frameElement",
+					currentwin
+				);
+				if (currentFrame && currentFrame[CONTROLLERFRAME]) {
+					controllerFrame = currentFrame[CONTROLLERFRAME];
+					break;
+				}
+				currentwin = currentwin.parent.window;
+			}
+		}
+		const context: ScramjetContext = {
+			config: this.init.sjconfig,
+			prefix: this.init.prefix,
+			cookieJar: this.cookieJar,
+			interface: {
+				getInjectScripts: this.init.yieldGetInjectScripts(
+					this.init.config,
+					this.init.sjconfig,
+					this.init.prefix,
+					this.cookieJar,
+					this.init.codecEncode,
+					this.init.codecDecode
+				),
+				codecEncode: this.init.codecEncode,
+				codecDecode: this.init.codecDecode,
+			},
+		};
+		this.client = new ScramjetClient(this.global, {
+			context,
+			transport: this.transport,
+			sendSetCookie: async (cookies, options) => {
+				await this.transport.sendSetCookie(cookies, options);
+			},
+			shouldBlockMessageEvent: () => {
+				return false;
+			},
+			hookSubcontext: (frameself) => {
+				const context = new ExecutionContextWrapper(frameself, {
+					...this.init,
+					cookies: this.cookieJar.dump(),
+				});
+				return context.client;
+			},
+			initHeaders: this.init.initHeaders,
+			history: this.init.history,
+		});
+		const frameInitContext = {
+			window: this.global.window,
+			client: this.client,
+			isTopLevel,
+		};
+		if (controllerFrame)
+			Tap.dispatch(controllerFrame.hooks.init.pre, frameInitContext, {});
+		this.client.hook();
+		if (controllerFrame)
+			Tap.dispatch(controllerFrame.hooks.init.post, frameInitContext, {});
+	}
+}

package/source/packages/scramjet/packages/controller/src/sw.ts

@@ -0,0 +1,231 @@
+/// <reference lib="WebWorker" />
+/// <reference types="@types/serviceworker" />
+import { RpcHelper } from "@mercuryworkshop/rpc";
+import type { Controllerbound, SWbound } from "./types";
+import type { RawHeaders } from "@mercuryworkshop/proxy-transports";
+
+function makeId(): string {
+	return Math.random().toString(36).substring(2, 10);
+}
+
+const cookieResolvers: Record<string, (value: void) => void> = {};
+addEventListener("message", (e) => {
+	if (!e.data) return;
+	if (typeof e.data != "object") return;
+	if (e.data.$sw$setCookieDone && typeof e.data.$sw$setCookieDone == "object") {
+		const done = e.data.$sw$setCookieDone;
+
+		const resolver = cookieResolvers[done.id];
+		if (resolver) {
+			resolver();
+			delete cookieResolvers[done.id];
+		}
+	}
+
+	if (
+		e.data.$sw$initRemoteTransport &&
+		typeof e.data.$sw$initRemoteTransport == "object"
+	) {
+		const { port, prefix } = e.data.$sw$initRemoteTransport;
+
+		const relevantcontroller = tabs.find((tab) =>
+			new URL(prefix).pathname.startsWith(tab.prefix)
+		);
+		if (!relevantcontroller) {
+			console.error("No relevant controller found for transport init");
+			return;
+		}
+		relevantcontroller.rpc.call("initRemoteTransport", port, [port]);
+	}
+});
+
+class ControllerReference {
+	rpc: RpcHelper<SWbound, Controllerbound>;
+
+	constructor(
+		public prefix: string,
+		public id: string,
+		port: MessagePort
+	) {
+		this.rpc = new RpcHelper(
+			{
+				sendSetCookie: async ({ cookies, options }) => {
+					const clients = await self.clients.matchAll();
+					const ids: string[] = [];
+					const promises: Promise<string>[] = [];
+
+					// Navigation fetches (document/iframe) deliver cookies via the inject
+					// script's embedded cookieJar dump — the destination page doesn't have
+					// inject.ts loaded yet to ack, so awaiting would deadlock. Broadcast
+					// so any already-loaded clients can update their jars, but don't wait.
+					const isNavigation =
+						options?.destination === "document" ||
+						options?.destination === "iframe";
+
+					for (const client of clients) {
+						const id = makeId();
+						ids.push(id);
+						client.postMessage({
+							$controller$setCookie: {
+								cookies,
+								options,
+								id,
+							},
+						});
+						if (!isNavigation) {
+							promises.push(
+								new Promise<string>((resolve) => {
+									// Resolve with the id so we know which client replied.
+									cookieResolvers[id] = () => resolve(id);
+								})
+							);
+						}
+					}
+					// Wait for the first client to acknowledge the cookie sync.
+					// Using Promise.any (not Promise.all) so that extra SW clients created by
+					// window.open (e.g. test popup windows) don't cause timeouts — only the
+					// main controller client needs to respond.
+					if (promises.length > 0) {
+						let timeoutId: ReturnType<typeof setTimeout> | undefined;
+						let responded = false;
+						const timeoutPromise = new Promise<void>((resolve) => {
+							timeoutId = setTimeout(() => {
+								if (!responded) {
+									const pending = ids.filter(
+										(id) => cookieResolvers[id] !== undefined
+									);
+									console.error(
+										"timed out waiting for set cookie response (deadlock?): " +
+											`cookies=${cookies.length} clients=${clients.length} ` +
+											`pending=${pending.length}/${ids.length} ` +
+											`clientUrls=${clients.map((c) => c.url).join(",")}`
+									);
+								}
+								resolve();
+							}, 1000);
+						});
+
+						try {
+							await Promise.race([
+								timeoutPromise,
+								Promise.any(promises)
+									.then(() => {
+										responded = true;
+									})
+									.catch(() => {}),
+							]);
+						} finally {
+							// Clear the timeout so it doesn't fire spuriously after the
+							// race has already been won by Promise.any.
+							if (timeoutId !== undefined) clearTimeout(timeoutId);
+							// Clean up any pending resolvers so clients that never
+							// responded don't leak entries in cookieResolvers.
+							for (const id of ids) {
+								delete cookieResolvers[id];
+							}
+						}
+					}
+				},
+			},
+			"tabchannel-" + id,
+			(data, transfer) => {
+				port.postMessage(data, transfer);
+			}
+		);
+		port.onmessage = (e: MessageEvent) => {
+			this.rpc.recieve(e.data);
+		};
+		port.onmessageerror = console.error;
+
+		this.rpc.call("ready", undefined);
+	}
+}
+
+const tabs: ControllerReference[] = [];
+
+addEventListener("message", (e) => {
+	if (!e.data) return;
+	if (typeof e.data != "object") return;
+	if (!e.data.$controller$init) return;
+	if (typeof e.data.$controller$init != "object") return;
+	const init = e.data.$controller$init;
+
+	const existing = tabs.findIndex((t) => t.id === init.id);
+	if (existing !== -1) {
+		tabs.splice(existing, 1);
+	}
+	tabs.push(new ControllerReference(init.prefix, init.id, e.ports[0]));
+});
+
+export function shouldRoute(event: FetchEvent): boolean {
+	const url = new URL(event.request.url);
+	const tab = tabs.find((tab) => url.pathname.startsWith(tab.prefix));
+	return tab !== undefined;
+}
+
+export async function route(event: FetchEvent): Promise<Response> {
+	try {
+		const url = new URL(event.request.url);
+		const tab = tabs.find((tab) => url.pathname.startsWith(tab.prefix))!;
+		const client = await clients.get(event.clientId);
+
+		const rawheaders: RawHeaders = [...event.request.headers];
+
+		const response = await tab.rpc.call(
+			"request",
+			{
+				rawUrl: event.request.url,
+				rawReferrer: event.request.referrer,
+				destination: event.request.destination,
+				mode: event.request.mode,
+				referrer: event.request.referrer,
+				method: event.request.method,
+				body: event.request.body,
+				cache: event.request.cache,
+				forceCrossOriginIsolated: false,
+				initialHeaders: rawheaders,
+				rawClientUrl: client ? client.url : undefined,
+				clientId: event.clientId || event.resultingClientId,
+			},
+			event.request.body instanceof ReadableStream ||
+				// @ts-expect-error the types for fetchevent are messed up
+				event.request.body instanceof ArrayBuffer
+				? [event.request.body]
+				: undefined
+		);
+
+		return new Response(response.body, {
+			status: response.status,
+			statusText: response.statusText,
+			headers: response.headers,
+		});
+	} catch (e) {
+		console.error("Service Worker error:", e);
+		return new Response(
+			"Internal Service Worker Error: " + (e as Error).message,
+			{
+				status: 500,
+			}
+		);
+	}
+}
+
+addEventListener("install", () => {
+	self.skipWaiting();
+});
+
+addEventListener("activate", (event: ExtendableEvent) => {
+	event.waitUntil(clients.claim());
+});
+
+// the only way to know if a service worker has suddenly died is if this code runs again
+// notify all clients to send over their messageports again
+setTimeout(async () => {
+	console.log("service worker activated, notifying clients to revive");
+	for (const client of await clients.matchAll()) {
+		client.postMessage({
+			$controller$swrevive: {},
+		});
+	}
+	// short delay is apparently needed
+}, 100);

package/source/packages/scramjet/packages/controller/src/symbols.ts

@@ -0,0 +1 @@
+export const CONTROLLERFRAME = Symbol.for("controller frame handle");