@petezah-games/scramjet-controller 0.0.9

package/src/inject.ts

@@ -0,0 +1,245 @@
+import type { CookieJar, ScramjetConfig } from "@mercuryworkshop/scramjet";
+import * as $scramjet from "@mercuryworkshop/scramjet";
+
+import type {
+	RawHeaders,
+	ProxyTransport,
+	TransferrableResponse,
+} from "@mercuryworkshop/proxy-transports";
+
+import { RpcHelper } from "@mercuryworkshop/rpc";
+import type {
+	ControllerToTransport,
+	TransportToController,
+	WebSocketData,
+	WebSocketMessage,
+} from "./types";
+
+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();
+		let 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,
+		});
+	}
+
+	meta() {
+		return {};
+	}
+}
+
+const sw = navigator.serviceWorker.controller;
+const { SCRAMJETCLIENT, ScramjetClient, CookieJar, setWasm } = $scramjet;
+
+type Config = any;
+type Init = {
+	config: Config;
+	sjconfig: ScramjetConfig;
+	cookies: string;
+	prefix: URL;
+	yieldGetInjectScripts: (
+		cookieJar: CookieJar,
+		config: Config,
+		sjconfig: ScramjetConfig,
+		prefix: URL
+	) => any;
+	codecEncode: (input: string) => string;
+	codecDecode: (input: string) => string;
+};
+
+export function load({
+	config,
+	sjconfig,
+	cookies,
+	prefix,
+	yieldGetInjectScripts,
+	codecEncode,
+	codecDecode,
+}: Init) {
+	let client;
+	if (SCRAMJETCLIENT in globalThis) {
+		client = globalThis[SCRAMJETCLIENT];
+	} else {
+		setWasm(Uint8Array.from(atob(self.WASM), (c) => c.charCodeAt(0)));
+		delete self.WASM;
+
+		const channel = new MessageChannel();
+		const transport = new RemoteTransport(channel.port1);
+		sw?.postMessage(
+			{
+				$sw$initRemoteTransport: {
+					port: channel.port2,
+					prefix: prefix.href,
+				},
+			},
+			[channel.port2]
+		);
+
+		const cookieJar = new CookieJar();
+		cookieJar.load(cookies);
+
+		const context = {
+			interface: {
+				getInjectScripts: yieldGetInjectScripts(
+					cookieJar,
+					config,
+					sjconfig,
+					prefix
+				),
+				codecEncode,
+				codecDecode,
+			},
+			prefix,
+			cookieJar,
+			config: sjconfig,
+		};
+		function createFrameId() {
+			return `${Array(8)
+				.fill(0)
+				.map(() => Math.floor(Math.random() * 36).toString(36))
+				.join("")}`;
+		}
+
+		const frame = globalThis.frameElement as HTMLIFrameElement | null;
+		if (frame && !frame.name) {
+			frame.name = createFrameId();
+		}
+
+		client = new ScramjetClient(globalThis, {
+			context,
+			transport,
+			sendSetCookie: async (url, cookie) => {
+				// sw.postMessage({
+				// 	$controller$setCookie: {
+				// 		url,
+				// 		cookie
+				// 	}
+				// });
+			},
+			shouldPassthroughWebsocket: (url) => {
+				return url === "wss://anura.pro/";
+			},
+			shouldBlockMessageEvent(i) {
+				return false;
+			},
+		});
+
+		client.hook();
+	}
+}

package/src/sw.ts

@@ -0,0 +1,159 @@
+declare var clients: Clients;
+import { RpcHelper } from "@mercuryworkshop/rpc";
+import type { Controllerbound, SWbound } from "./types";
+import type { RawHeaders } from "@mercuryworkshop/proxy-transports";
+import { ScramjetHeaders } from "@mercuryworkshop/scramjet";
+
+function makeId(): string {
+	return Math.random().toString(36).substring(2, 10);
+}
+
+let 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 ({ url, cookie }) => {
+					let clients = await self.clients.matchAll();
+					let promises = [];
+
+					for (const client of clients) {
+						let id = makeId();
+						client.postMessage({
+							$controller$setCookie: {
+								url,
+								cookie,
+								id,
+							},
+						});
+						promises.push(
+							new Promise<void>((resolve) => {
+								cookieResolvers[id] = resolve;
+							})
+						);
+					}
+					await Promise.race([
+						new Promise<void>((resolve) =>
+							setTimeout(() => {
+								console.error(
+									"timed out waiting for set cookie response (deadlock?)"
+								);
+								resolve();
+							}, 1000)
+						),
+						promises,
+					]);
+				},
+			},
+			"tabchannel-" + id,
+			(data, transfer) => {
+				port.postMessage(data, transfer);
+			}
+		);
+		port.addEventListener("message", (e) => {
+			this.rpc.recieve(e.data);
+		});
+		port.onmessageerror = console.error;
+
+		this.rpc.call("ready", null);
+	}
+}
+
+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;
+
+	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,
+				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,
+			},
+			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,
+			}
+		);
+	}
+}

package/src/types.d.ts

@@ -0,0 +1,95 @@
+import type { RawHeaders } from "@mercuryworkshop/proxy-transports";
+
+export type BodyType =
+	| string
+	| ArrayBuffer
+	| Blob
+	| ReadableStream<Uint8Array<ArrayBufferLike>>;
+
+export type TransferRequest = {
+	rawUrl: string;
+	destination: RequestDestination;
+	mode: RequestMode;
+	referrer: string;
+	method: string;
+	body: BodyType | null;
+	cache: RequestCache;
+	forceCrossOriginIsolated: boolean;
+	initialHeaders: RawHeaders;
+	rawClientUrl?: string;
+};
+
+export type TransferResponse = {
+	body: BodyType;
+	headers: RawHeaders;
+	status: number;
+	statusText: string;
+};
+
+export type Controllerbound = {
+	ready: [];
+	request: [TransferRequest, TransferResponse];
+	sendSetCookie: [
+		{
+			url: string;
+			cookie: string;
+		},
+	];
+	initRemoteTransport: [MessagePort];
+};
+
+export type SWbound = {
+	sendSetCookie: [
+		{
+			url: string;
+			cookie: string;
+		},
+	];
+};
+
+export type TransportToController = {
+	request: [
+		{
+			remote: string;
+			method: string;
+			body: BodyInit | null;
+			headers: RawHeaders;
+			// signal: AbortSignal | undefined
+		},
+		TransferrableResponse,
+	];
+	connect: [
+		{
+			url: string;
+			protocols: string[];
+			requestHeaders: RawHeaders;
+			port: MessagePort;
+		},
+		(
+			| {
+					result: "success";
+					protocol: string;
+					extensions: string;
+			  }
+			| {
+					result: "failure";
+					error: string;
+			  }
+		),
+	];
+};
+
+export type ControllerToTransport = {
+	ready: [];
+};
+export type WebSocketData = string | ArrayBuffer | Blob;
+export type WebSocketMessage =
+	| {
+			type: "data";
+			data: WebSocketData;
+	  }
+	| {
+			type: "close";
+			code: number;
+			reason: string;
+	  };

package/src/typesEntry.ts

@@ -0,0 +1,6 @@
+import * as Types from "./index";
+export * from "./index";
+
+declare global {
+	const $scramjetController: typeof Types;
+}

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+	"compilerOptions": {
+		"target": "ES2022",
+		"useDefineForClassFields": true,
+		"module": "ESNext",
+		"lib": ["ES2022", "webworker", "DOM", "DOM.Iterable"],
+		"types": [],
+		"skipLibCheck": true,
+		/* Bundler mode */
+		"moduleResolution": "bundler",
+		"allowImportingTsExtensions": true,
+		"verbatimModuleSyntax": true,
+		"moduleDetection": "force",
+		"noEmit": true,
+		/* Linting */
+		"strict": true,
+		"noUnusedLocals": true,
+		"noUnusedParameters": false,
+		"erasableSyntaxOnly": false,
+		"noFallthroughCasesInSwitch": true,
+		"noUncheckedSideEffectImports": true
+	},
+	"include": ["src"]
+}

package/tsconfig.types.json

@@ -0,0 +1,16 @@
+{
+	"extends": "./tsconfig.json",
+	"compilerOptions": {
+		"declaration": true,
+		"emitDeclarationOnly": true,
+		"declarationDir": "./dist/types",
+		"removeComments": false,
+		"skipLibCheck": true,
+		"noEmitOnError": false,
+		"noEmit": false,
+		"strict": false,
+		"noUnusedLocals": false,
+		"noUnusedParameters": false
+	},
+	"include": ["src"]
+}