@mercuryworkshop/scramjet-controller 0.0.1 → 0.0.3

package/src/index.ts

@@ -0,0 +1,416 @@
+import { type MethodsDefinition, RpcHelper } from "@mercuryworkshop/rpc";
+import type * as ScramjetGlobal from "@mercuryworkshop/scramjet";
+
+declare const $scramjet: typeof ScramjetGlobal;
+
+import {
+	type TransportToController,
+	type Controllerbound,
+	type ControllerToTransport,
+	type SWbound,
+	type WebSocketMessage,
+} from "./types";
+import {
+	BareCompatibleClient,
+	type BareResponse,
+	type ProxyTransport,
+} from "@mercuryworkshop/proxy-transports";
+
+const cookieJar = new $scramjet.CookieJar();
+
+type Config = {
+	wasmPath: string;
+	injectPath: string;
+	scramjetPath: string;
+	virtualWasmPath: string;
+	prefix: string;
+};
+
+fetch("/scramjet/scramjet.wasm.wasm").then(async (resp) => {
+	$scramjet.setWasm(await resp.arrayBuffer());
+});
+
+export const config: Config = {
+	prefix: "/~/sj/",
+	virtualWasmPath: "scramjet.wasm.js",
+	injectPath: "/controller/controller.inject.js",
+	scramjetPath: "/scramjet/scramjet.js",
+	wasmPath: "/scramjet/scramjet.wasm.wasm",
+};
+
+const cfg = {
+	flags: {
+		...$scramjet.defaultConfig.flags,
+		allowFailedIntercepts: true,
+	},
+	maskedfiles: ["inject.js", "scramjet.wasm.js"],
+};
+
+const frames: Record<string, Frame> = {};
+
+let wasmPayload: string | null = null;
+
+function makeId(): string {
+	return Math.random().toString(36).substring(2, 10);
+}
+
+const codecEncode = (url: string) => {
+	if (!url) return url;
+
+	return encodeURIComponent(url);
+};
+
+const codecDecode = (url: string) => {
+	if (!url) return url;
+
+	return decodeURIComponent(url);
+};
+
+type ControllerInit = {
+	serviceworker: ServiceWorker;
+	transport: ProxyTransport;
+};
+export class Controller {
+	id: string;
+	prefix: string;
+	frames: Frame[] = [];
+	cookieJar = new $scramjet.CookieJar();
+
+	rpc: RpcHelper<Controllerbound, SWbound>;
+	private ready: Promise<void>;
+	private readyResolve!: () => void;
+
+	transport: ProxyTransport;
+
+	private methods: MethodsDefinition<Controllerbound> = {
+		ready: async () => {
+			this.readyResolve();
+		},
+		request: async (data) => {
+			try {
+				let path = new URL(data.rawUrl).pathname;
+				const frame = this.frames.find((f) => path.startsWith(f.prefix));
+				if (!frame) throw new Error("No frame found for request");
+
+				if (path === frame.prefix + config.virtualWasmPath) {
+					if (!wasmPayload) {
+						const resp = await fetch(config.wasmPath);
+						const buf = await resp.arrayBuffer();
+						const b64 = btoa(
+							new Uint8Array(buf)
+								.reduce(
+									(data, byte) => (data.push(String.fromCharCode(byte)), data),
+									[] as any
+								)
+								.join("")
+						);
+
+						let payload = "";
+						payload +=
+							"console.warn('WTF'); if ('document' in self && document.currentScript) { document.currentScript.remove(); }\n";
+						payload += `self.WASM = '${b64}';`;
+						wasmPayload = payload;
+					}
+
+					return [
+						{
+							body: wasmPayload,
+							status: 200,
+							statusText: "OK",
+							headers: {
+								"Content-Type": ["application/javascript"],
+							},
+						},
+						[],
+					];
+				}
+
+				let sjheaders = $scramjet.ScramjetHeaders.fromRawHeaders(
+					data.initialHeaders
+				);
+
+				const fetchresponse = await frame.fetchHandler.handleFetch({
+					initialHeaders: sjheaders,
+					rawClientUrl: data.rawClientUrl
+						? new URL(data.rawClientUrl)
+						: undefined,
+					rawUrl: new URL(data.rawUrl),
+					destination: data.destination,
+					method: data.method,
+					mode: data.mode,
+					referrer: data.referrer,
+					body: data.body,
+					cache: data.cache,
+				});
+
+				return [
+					{
+						body: fetchresponse.body,
+						status: fetchresponse.status,
+						statusText: fetchresponse.statusText,
+						headers: fetchresponse.headers.toRawHeaders(),
+					},
+					fetchresponse.body instanceof ReadableStream ||
+					fetchresponse.body instanceof ArrayBuffer
+						? [fetchresponse.body]
+						: [],
+				];
+			} catch (e) {
+				console.error("Error in controller request handler:", e);
+				throw e;
+			}
+		},
+		initRemoteTransport: async (port) => {
+			const rpc = new RpcHelper<TransportToController, ControllerToTransport>(
+				{
+					request: async ({ remote, method, body, headers }) => {
+						let response = await this.transport.request(
+							new URL(remote),
+							method,
+							body,
+							headers,
+							undefined
+						);
+						return [response, [response.body]];
+					},
+					connect: async ({ url, protocols, requestHeaders, port }) => {
+						let resolve: (arg: TransportToController["connect"][1]) => void;
+						let promise = new Promise<TransportToController["connect"][1]>(
+							(res) => (resolve = res)
+						);
+						const [send, close] = this.transport.connect(
+							new URL(url),
+							protocols,
+							requestHeaders,
+							(protocol) => {
+								resolve({
+									result: "success",
+									protocol: protocol,
+								});
+							},
+							(data) => {
+								port.postMessage(
+									{
+										type: "data",
+										data: data,
+									} as WebSocketMessage,
+									data instanceof ArrayBuffer ? [data] : []
+								);
+							},
+							(close, reason) => {
+								port.postMessage({
+									type: "close",
+									code: close,
+									reason: reason,
+								} as WebSocketMessage);
+							},
+							(error) => {
+								resolve({
+									result: "failure",
+									error: error,
+								});
+							}
+						);
+						port.onmessageerror = (ev) => {
+							console.error(
+								"Transport port messageerror (this should never happen!)",
+								ev
+							);
+						};
+						port.onmessage = ({ data }: { data: WebSocketMessage }) => {
+							if (data.type === "data") {
+								send(data.data);
+							} else if (data.type === "close") {
+								close(data.code, data.reason);
+							}
+						};
+
+						return [await promise, []];
+					},
+				},
+				"transport",
+				(data, transfer) => port.postMessage(data, transfer)
+			);
+			port.onmessageerror = (ev) => {
+				console.error(
+					"Transport port messageerror (this should never happen!)",
+					ev
+				);
+			};
+			port.onmessage = (e) => {
+				rpc.recieve(e.data);
+			};
+			rpc.call("ready", undefined, []);
+		},
+		sendSetCookie: async ({ url, cookie }) => {},
+	};
+
+	constructor(public init: ControllerInit) {
+		this.transport = init.transport;
+		this.id = makeId();
+		this.prefix = config.prefix + this.id + "/";
+
+		this.ready = new Promise<void>((resolve) => {
+			this.readyResolve = resolve;
+		});
+
+		let channel = new MessageChannel();
+		this.rpc = new RpcHelper<Controllerbound, SWbound>(
+			this.methods,
+			"tabchannel-" + this.id,
+			(data, transfer) => {
+				channel.port1.postMessage(data, transfer);
+			}
+		);
+		channel.port1.addEventListener("message", (e) => {
+			this.rpc.recieve(e.data);
+		});
+		channel.port1.start();
+
+		init.serviceworker.postMessage(
+			{
+				$controller$init: {
+					prefix: config.prefix + this.id,
+					id: this.id,
+				},
+			},
+			[channel.port2]
+		);
+	}
+
+	createFrame(element?: HTMLIFrameElement): Frame {
+		element ??= document.createElement("iframe");
+		const frame = new Frame(this, element);
+		this.frames.push(frame);
+		return frame;
+	}
+
+	wait(): Promise<void> {
+		return this.ready;
+	}
+}
+
+function yieldGetInjectScripts(
+	cookieJar: ScramjetGlobal.CookieJar,
+	config: Config,
+	sjconfig: ScramjetGlobal.ScramjetConfig,
+	prefix: URL
+) {
+	return function getInjectScripts(meta, handler, script) {
+		return [
+			script(config.scramjetPath),
+			script(config.injectPath),
+			script(prefix.href + config.virtualWasmPath),
+			script(
+				"data:text/javascript;base64," +
+					btoa(`
+					document.currentScript.remove();
+					$scramjetController.load({
+						config: ${JSON.stringify(config)},
+						sjconfig: ${JSON.stringify(sjconfig)},
+						cookies: ${cookieJar.dump()},
+						prefix: new URL("${prefix.href}"),
+						yieldGetInjectScripts: ${yieldGetInjectScripts.toString()},
+						codecEncode: ${codecEncode.toString()},
+						codecDecode: ${codecDecode.toString()},
+					})
+				`)
+			),
+		];
+	};
+}
+
+class Frame {
+	fetchHandler: ScramjetGlobal.ScramjetFetchHandler;
+	id: string;
+	prefix: string;
+
+	get context() {
+		let sjcfg = {
+			...$scramjet.defaultConfig,
+			...cfg,
+		};
+		return {
+			cookieJar,
+			prefix: new URL(this.prefix, location.href),
+			config: sjcfg,
+			interface: {
+				getInjectScripts: yieldGetInjectScripts(
+					this.controller.cookieJar,
+					config,
+					{ ...$scramjet.defaultConfig, ...cfg },
+					new URL(this.prefix, location.href)
+				),
+				getWorkerInjectScripts: (meta, type, script) => {
+					let str = "";
+
+					str += script(config.scramjetPath);
+					str += script(this.prefix + config.virtualWasmPath);
+					str += `
+					(()=>{
+						const { ScramjetClient, CookieJar, setWasm } = $scramjet;
+
+						setWasm(Uint8Array.from(atob(self.WASM), (c) => c.charCodeAt(0)));
+						delete self.WASM;
+
+						const sjconfig = ${JSON.stringify(sjcfg)};
+						const prefix = new URL("${this.prefix}", location.href);
+
+						const context = {
+							interface: {
+								codecEncode: ${codecEncode.toString()},
+								codecDecode: ${codecDecode.toString()},
+							},
+							prefix,
+							config: sjconfig
+						};
+
+						const client = new ScramjetClient(globalThis, {
+							context,
+							transport: null,
+							shouldPassthroughWebsocket: (url) => {
+								return url === "wss://anura.pro/";
+							}
+						});
+
+						client.hook();
+					})();
+					`;
+
+					return str;
+				},
+				codecEncode,
+				codecDecode,
+			},
+		};
+	}
+
+	constructor(
+		public controller: Controller,
+		public element: HTMLIFrameElement
+	) {
+		this.id = makeId();
+		this.prefix = this.controller.prefix + this.id + "/";
+
+		this.fetchHandler = new $scramjet.ScramjetFetchHandler({
+			crossOriginIsolated: self.crossOriginIsolated,
+			context: this.context,
+			transport: controller.transport,
+			async sendSetCookie(url, cookie) {},
+			async fetchBlobUrl(url) {
+				return (await fetch(url)) as BareResponseFetch;
+			},
+			async fetchDataUrl(url) {
+				return (await fetch(url)) as BareResponseFetch;
+			},
+		});
+	}
+
+	go(url: string) {
+		const encoded = $scramjet.rewriteUrl(url, this.context, {
+			origin: new URL(location.href),
+			base: new URL(location.href),
+		});
+		this.element.src = encoded;
+	}
+}

package/src/inject.ts

@@ -0,0 +1,246 @@
+import type { CookieJar, ScramjetConfig } from "@mercuryworkshop/scramjet";
+import type * as ScramjetGlobal from "@mercuryworkshop/scramjet";
+declare const $scramjet: typeof ScramjetGlobal;
+
+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();
+	}
+}