roxxie-proxy-u-prod 0.1.0

package/source/packages/scramjet/packages/core/src/shared/util.ts

@@ -0,0 +1,35 @@
+import {
+	Array_from,
+	btoa,
+	TextEncoder_encode,
+	String_fromCharCode,
+	String_fromCodePoint,
+} from "@/shared/snapshot";
+
+function bytesToBase64Fallback(bytes: Uint8Array): string {
+	const binString = Array_from(bytes, (byte) =>
+		String_fromCodePoint(byte)
+	).join("");
+
+	return btoa(binString);
+}
+
+const bytesToBase64Native: ((this: Uint8Array) => string) | undefined = (
+	Uint8Array.prototype as any
+).toBase64;
+
+export const bytesToBase64: (bytes: Uint8Array) => string =
+	typeof bytesToBase64Native === "function"
+		? (bytes) => bytesToBase64Native.call(bytes)
+		: bytesToBase64Fallback;
+
+export function base64Encode(text: string) {
+	return btoa(
+		TextEncoder_encode(text)
+			.reduce(
+				(data, byte) => (data.push(String_fromCharCode(byte)), data),
+				[] as any
+			)
+			.join("")
+	);
+}

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

@@ -0,0 +1,9 @@
+/**
+ * @fileoverview
+ * See `types.ts` for context on these symbols.
+ */
+
+import { Symbol_for } from "@/shared/snapshot";
+
+export const SCRAMJETCLIENTNAME = "scramjet client global";
+export const SCRAMJETCLIENT = Symbol_for(SCRAMJETCLIENTNAME);

package/source/packages/scramjet/packages/core/src/sync.ts

@@ -0,0 +1,63 @@
+/* eslint-disable scramjet-core/no-globals */
+
+addEventListener(
+	"message",
+	({
+		data: {
+			sab,
+			args: [method, url, _, username, password],
+			body,
+			headers,
+		},
+	}) => {
+		const view = new DataView(sab);
+		const u8view = new Uint8Array(sab);
+
+		const xhr = new XMLHttpRequest();
+		xhr.responseType = "arraybuffer";
+
+		// force async since we need it to resolve to the sw
+		xhr.open(method, url, true, username, password);
+
+		if (headers)
+			for (const [k, v] of Object.entries(headers)) {
+				xhr.setRequestHeader(k, v as string);
+			}
+
+		xhr.send(body);
+
+		xhr.onload = () => {
+			let cursor = 1; // first byte is the lock
+
+			view.setUint16(cursor, xhr.status);
+			cursor += 2;
+
+			// next write the header string
+			const headers = xhr.getAllResponseHeaders();
+			view.setUint32(cursor, headers.length);
+			cursor += 4;
+
+			if (sab.byteLength < cursor + headers.length)
+				sab.grow(cursor + headers.length);
+			u8view.set(new TextEncoder().encode(headers), cursor);
+			cursor += headers.length;
+
+			view.setUint32(cursor, xhr.response.byteLength);
+			cursor += 4;
+
+			if (sab.byteLength < cursor + xhr.response.byteLength)
+				sab.grow(cursor + xhr.response.byteLength);
+			u8view.set(new Uint8Array(xhr.response), cursor);
+
+			// release the lock, main thread will stop spinning now
+			view.setUint8(0, 1);
+		};
+		xhr.ontimeout =
+			xhr.onerror =
+			xhr.onabort =
+				() => {
+					console.error("xhr failed");
+					view.setUint8(0, 1);
+				};
+	}
+);

package/source/packages/scramjet/packages/core/src/types.ts

@@ -0,0 +1,66 @@
+/**
+ * Version information for the current Scramjet build.
+ * Contains both the semantic version string and the git commit hash for build identification.
+ */
+export interface ScramjetVersionInfo {
+	/** The semantic version */
+	version: string;
+	/** The git commit hash that this build was created from */
+	build: string;
+	/** The date of the build */
+	date: string;
+}
+
+/**
+ * Scramjet Feature Flags, configured at build time
+ */
+export type ScramjetFlags = {
+	syncxhr: boolean;
+	disableComputedWrap: boolean;
+	rewriterLogs: boolean;
+	captureErrors: boolean;
+	cleanErrors: boolean;
+	scramitize: boolean;
+	sourcemaps: boolean;
+	destructureRewrites: boolean;
+	allowInvalidJs: boolean;
+	allowFailedIntercepts: boolean;
+	debugTrampolines: boolean;
+	debugSourceURL: boolean;
+	encapsulateWorkers: boolean;
+};
+
+export interface ScramjetConfig {
+	globals: {
+		wrapfn: string;
+		wrappropertybase: string;
+		wrappropertyfn: string;
+		cleanrestfn: string;
+		importfn: string;
+		rewritefn: string;
+		metafn: string;
+		wrappostmessagefn: string;
+		pushsourcemapfn: string;
+		trysetfn: string;
+		templocid: string;
+		tempunusedid: string;
+	};
+	flags: ScramjetFlags;
+	siteFlags: Record<string, Partial<ScramjetFlags>>;
+	maskedfiles: string[];
+}
+
+/**
+ * The config for Scramjet initialization.
+ */
+export interface ScramjetInitConfig
+	extends Omit<ScramjetConfig, "codec" | "flags"> {
+	flags: Partial<ScramjetFlags>;
+	codec: {
+		encode: (url: string) => string;
+		decode: (url: string) => string;
+	};
+}
+
+//eslint-disable-next-line
+export type AnyFunction = Function;

package/source/packages/scramjet/packages/core/src/typesEntry.ts

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

package/source/packages/scramjet/packages/core/tsconfig.json

@@ -0,0 +1,21 @@
+{
+	"compilerOptions": {
+		"target": "esnext",
+		"module": "esnext",
+		"rootDir": "./src",
+		"moduleResolution": "Bundler",
+		"skipLibCheck": true,
+		"declaration": true,
+		"declarationDir": "./dist/types",
+		"outDir": "./dist/types",
+		"emitDeclarationOnly": true,
+		"removeComments": false,
+		"paths": {
+			"@rewriters/*": ["./src/shared/rewriters/*"],
+			"@client/*": ["./src/client/*"],
+			"@/*": ["./src/*"]
+		}
+	},
+	"include": ["src"],
+	"exclude": ["node_modules"]
+}

package/source/packages/scramjet/packages/rpc/index.ts

@@ -0,0 +1,100 @@
+export type RpcDescription = {
+	[method: string]: [args: any, returnType: any] | [args: any] | [];
+};
+
+export type MethodsDefinition<Description extends RpcDescription> = {
+	[Method in keyof Description]: (
+		...args: Description[Method] extends [infer A, ...any[]] ? [A] : []
+	) => Description[Method] extends [any, infer R]
+		? Promise<[R, Transferable[]]>
+		: Promise<void>;
+};
+
+export class RpcHelper<
+	Local extends RpcDescription,
+	Remote extends RpcDescription,
+> {
+	counter: number = 0;
+	promiseCallbacks: Map<
+		number,
+		{ resolve: (value: any) => void; reject: (reason?: any) => void }
+	> = new Map();
+	constructor(
+		private methods: MethodsDefinition<Local>,
+		private id: string,
+		private sendRaw: (data: any, transfer: Transferable[]) => void
+	) {}
+
+	recieve(data: any) {
+		if (data === undefined || data === null || typeof data !== "object") return;
+		const dt = data[this.id];
+		if (dt === undefined || dt === null || typeof dt !== "object") return;
+
+		const type = dt.$type;
+
+		if (type === "response") {
+			const token = dt.$token;
+			const data = dt.$data;
+			const error = dt.$error;
+			const cb = this.promiseCallbacks.get(token);
+			if (!cb) return;
+			this.promiseCallbacks.delete(token);
+			if (error !== undefined) {
+				cb.reject(new Error(error));
+			} else {
+				cb.resolve(data);
+			}
+		} else if (type === "request") {
+			const method = dt.$method as keyof Local;
+			const args = dt.$args as Local[typeof method][0];
+			(this.methods[method] as any)(args)
+				.then((r: any) => {
+					this.sendRaw(
+						{
+							[this.id]: {
+								$type: "response",
+								$token: dt.$token,
+								$data: r?.[0],
+							},
+						},
+						r?.[1]
+					);
+				})
+				.catch((err: any) => {
+					console.error(err);
+					this.sendRaw(
+						{
+							[this.id]: {
+								$type: "response",
+								$token: dt.$token,
+								$error: err?.toString() || "Unknown error",
+							},
+						},
+						[]
+					);
+				});
+		}
+	}
+
+	call<Method extends keyof Remote>(
+		method: Method,
+		args: Remote[Method][0],
+		transfer: Transferable[] = []
+	): Promise<Remote[Method][1]> {
+		const token = this.counter++;
+		return new Promise((resolve, reject) => {
+			this.promiseCallbacks.set(token, { resolve, reject });
+			this.sendRaw(
+				{
+					[this.id]: {
+						$type: "request",
+						$method: method,
+						$args: args,
+						$token: token,
+					},
+				},
+				transfer
+			);
+		});
+	}
+}

package/source/packages/scramjet/packages/rpc/package.json

@@ -0,0 +1,7 @@
+{
+	"name": "@mercuryworkshop/rpc",
+	"version": "0.0.1",
+	"type": "module",
+	"packageManager": "pnpm@10.12.1",
+	"license": "AGPL-3.0-only"
+}

package/source/packages/scramjet/packages/utils/package.json

@@ -0,0 +1,39 @@
+{
+	"name": "@mercuryworkshop/scramjet-utils",
+	"version": "0.0.3",
+	"description": "Utilities for Scramjet proxy integrations",
+	"type": "module",
+	"packageManager": "pnpm@10.12.1",
+	"license": "AGPL-3.0-only",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/MercuryWorkshop/scramjet.git",
+		"directory": "packages/utils"
+	},
+	"types": "./dist/types/typesEntry.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/types/typesEntry.d.ts",
+			"import": "./dist/scramjet-utils.mjs",
+			"default": "./dist/scramjet-utils.js"
+		}
+	},
+	"files": [
+		"dist"
+	],
+	"scripts": {
+		"build": "cd ../.. && rspack build --mode production",
+		"prepack": "pnpm run build",
+		"prepublishOnly": "npx only-allow pnpm",
+		"pub": "pnpm publish --no-git-checks --access public"
+	},
+	"peerDependencies": {
+		"@mercuryworkshop/scramjet": "*",
+		"@mercuryworkshop/scramjet-controller": "*"
+	},
+	"devDependencies": {
+		"@mercuryworkshop/scramjet": "workspace:*",
+		"@mercuryworkshop/scramjet-controller": "workspace:*",
+		"@types/serviceworker": "^0.0.197"
+	}
+}

package/source/packages/scramjet/packages/utils/src/alwaysLastBubble.ts

@@ -0,0 +1,172 @@
+import type { ScramjetClient } from "@mercuryworkshop/scramjet";
+
+export function setupAlwaysLastBubble(
+	client: ScramjetClient,
+	whatToCapture: string[]
+) {
+	// goal is to override the default behavior of clicking on an <a> link
+	// if the link is target=_blank it needs to open in a new browser.js tab instead of a native tab
+	// the browser does not provide a neat way of knowing when a link is clicked through
+	//
+	// so the only solution left is to addEventListener("click") on every single <a> element
+	// however, this presents an issue
+	// if the page has its *own* event listener, and it calls e.preventDefault(), we need to not open the tab, since we're essentially acting as the new default
+	// since events bubble down and can have non trivial control flows, this gets complicated fast
+	//
+	// the only solution is to register both the first and last event listeners, so that you control the entire call stack
+	// registering the first is easy, you just need to call it immediately after creation
+	// registering the *last* is extremely difficult
+
+	type EvtDesc = {
+		originalcb: ((e: Event) => void) | EventListenerObject;
+		injectafter?: (e: Event) => void;
+		type: string;
+	};
+	let currentlyExecutingDesc: EvtDesc | null = null;
+	const eventListeners: Map<EventTarget, EvtDesc[]> = new Map();
+
+	// start by recording every event registered so that we can rebuild the bubble path later
+	client.Proxy("EventTarget.prototype.addEventListener", {
+		apply(ctx) {
+			const eventName = ctx.args[0] as string;
+			const cb = ctx.args[1] as ((e: Event) => void) | EventListenerObject;
+			const options = ctx.args[2] as AddEventListenerOptions;
+			const target = ctx.this as EventTarget;
+			if (!whatToCapture.includes(eventName)) return;
+			// capture events don't go through the bubble process so we shouldn't include them
+			if (
+				(typeof options === "boolean" && options) ||
+				(typeof options === "object" && options.capture)
+			)
+				return;
+
+			ctx.args[1] = function (...args: any) {
+				// will always exist since we set it just below
+				const descs = eventListeners.get(target)!;
+				// find the one talking about us
+				const desc = descs.find((d) => d.originalcb === cb)!;
+
+				// have a flag for the event that's currently running so that we know where we are in the stack if preventDefault() or stopPropagation() is called
+				currentlyExecutingDesc = desc;
+				if (typeof cb === "function") {
+					Reflect.apply(cb, this, args);
+				} else if (typeof cb === "object" && cb !== null && cb.handleEvent) {
+					Reflect.apply(cb.handleEvent, cb, args);
+				}
+
+				if (desc.injectafter) {
+					desc.injectafter(args[0]);
+					delete desc.injectafter;
+				}
+				currentlyExecutingDesc = null;
+			};
+
+			const desc: EvtDesc = {
+				originalcb: cb,
+				type: eventName,
+			};
+
+			if (eventListeners.has(target)) {
+				eventListeners.get(target)!.push(desc);
+			} else {
+				eventListeners.set(target, [desc]);
+			}
+		},
+	});
+
+	return function addAlwaysLastEventListener<T extends Event>(
+		target: EventTarget,
+		eventName: string,
+		listener: (e: T) => void
+	) {
+		// this event will always run before all other ones, since it was registered at injectHistoryEmulation
+		// * unless you registered the event before appending to the dom
+		// * unless there's something inside of the <a> that has a listener on it
+		// * unless there's a capture listener
+		// TODO fix those cases
+
+		const callListener = (e: T) => {
+			// this goes into our code, so restore the original methods
+			// TODO: we probably shouldnt do it like this
+			e.stopPropagation =
+				client.natives.store["Event.prototype.stopPropagation"];
+			e.stopImmediatePropagation =
+				client.natives.store["Event.prototype.stopImmediatePropagation"];
+			listener(e);
+		};
+
+		client.natives.call(
+			"EventTarget.prototype.addEventListener",
+			target,
+			eventName,
+			(e: T) => {
+				let lastlistener;
+				const path = e.composedPath();
+
+				// travel the path, from the <a> all the way to Window
+				for (const elm of path) {
+					let descriptors = eventListeners.get(elm);
+					if (descriptors) {
+						descriptors = descriptors.filter((d) => d.type === eventName);
+						// last descriptor was last added and will be called last
+						lastlistener = descriptors[descriptors.length - 1];
+					}
+				}
+
+				// TODO: if a listener is added to a lower level of the dom inside the listener of a higher level, our lastlistener will not be correct
+				if (!lastlistener) {
+					// there are no other event listeners! great
+					callListener(e);
+				} else {
+					// we know what the last listener is. run this to inject after it
+					lastlistener.injectafter = (e) => {
+						callListener(e);
+					};
+				}
+
+				// except, if stopPropagation is called, it never gets to the lastlistener
+				client.RawProxy(e, "stopImmediatePropagation", {
+					apply() {
+						if (!currentlyExecutingDesc)
+							throw new Error(
+								"stopImmediatePropagation called but no desc found?"
+							);
+						// for stopImmediatePropagation this is the last one
+						currentlyExecutingDesc.injectafter = (e) => {
+							// in case preventDefault is called after stopImmediatePropagation(), wait for the event handler to be done
+							callListener(e as T);
+						};
+					},
+				});
+				client.RawProxy(e, "stopPropagation", {
+					apply(ctx) {
+						if (!currentlyExecutingDesc)
+							throw new Error("stopPropagation called but no desc found?");
+						// stopPropagation means there might still be more listeners on the same element
+						// find whatever the last one is on the this element and then inject after it too
+
+						const ev = ctx.this as Event;
+						if (!ev.target) throw new Error("no target");
+						const descs = eventListeners.get(ev.target);
+						if (!descs) throw new Error("no descs found in stopPropagation()");
+						const idx = descs.indexOf(currentlyExecutingDesc);
+						if (idx == -1)
+							throw new Error("couldn't find currentlyExecutingDesc");
+						const remaining = descs.slice(idx + 1, descs.length);
+						if (remaining.length > 0) {
+							const last = remaining[remaining.length - 1];
+							// finally we have the last in the chain after propagation is cut off
+							last.injectafter = (e) => {
+								callListener(e as T);
+							};
+						}
+					},
+				});
+			}
+		);
+	};
+}
+
+export type AddAlwaysLastEventListener = ReturnType<
+	typeof setupAlwaysLastBubble
+>;

package/source/packages/scramjet/packages/utils/src/catch-escaped-links.ts

@@ -0,0 +1,34 @@
+import { ScramjetHeaders } from "@mercuryworkshop/scramjet";
+import { ManagedPlugin } from "@mercuryworkshop/scramjet-controller";
+import type { Frame } from "@mercuryworkshop/scramjet-controller";
+
+/**
+ * Intercepts top-level navigation requests (triggered by clicking "open in new tab" on a link, or window.open)
+ * Without this plugin, they would open without the proxy shell, which is usually undesired.
+ * give a callback telling it how to redirect back to the proxy shell.
+ */
+export class CatchEscapedLinksPlugin extends ManagedPlugin {
+	constructor(private toLocation: (url: URL) => string | URL) {
+		super("catch-escaped-links", []);
+	}
+
+	install(frame: Frame): void {
+		this.tap(
+			frame.hooks.fetch.intercept,
+			(context, props) => {
+				if (context.parsed.destination !== "document") return;
+
+				const location = this.toLocation(context.parsed.url);
+				props.response = {
+					body: "",
+					status: 302,
+					statusText: "Found",
+					headers: ScramjetHeaders.fromRawHeaders([
+						["Location", String(location)],
+					]),
+				};
+			},
+			{ after: ["scramjet-http-cache"] }
+		);
+	}
+}

package/source/packages/scramjet/packages/utils/src/event-handler-plugin.ts

@@ -0,0 +1,86 @@
+import { ManagedPlugin } from "@mercuryworkshop/scramjet-controller";
+import type { Frame } from "@mercuryworkshop/scramjet-controller";
+import {
+	setupAlwaysLastBubble,
+	type AddAlwaysLastEventListener,
+} from "./alwaysLastBubble";
+
+export type { AddAlwaysLastEventListener } from "./alwaysLastBubble";
+export { setupAlwaysLastBubble } from "./alwaysLastBubble";
+
+export type EventHandlerPluginOptions = {
+	/** Bubble-phase event types to track. Defaults to click, auxclick, and contextmenu. */
+	events?: string[];
+};
+
+/**
+ * Allows you to register an event listener on an element, such that it will only run after the page's own listeners (including after stopPropagation).
+ * This allows you to fake "native" browser behavior with ease
+ */
+export class EventHandlerPlugin extends ManagedPlugin {
+	private addAlwaysLastEventListeners: Map<Window, AddAlwaysLastEventListener> =
+		new Map();
+	private eventsToCapture: string[] = [];
+
+	constructor(private options: EventHandlerPluginOptions = {}) {
+		super("event-handler", []);
+	}
+
+	install(frame: Frame): void {
+		super.install(frame);
+
+		this.tap(frame.hooks.init.post, (context) => {
+			this.addAlwaysLastEventListeners.set(
+				context.window,
+				setupAlwaysLastBubble(context.client, this.eventsToCapture)
+			);
+		});
+	}
+
+	addEventToCapture(eventName: string): void {
+		if (this.eventsToCapture.includes(eventName)) return;
+		this.eventsToCapture.push(eventName);
+	}
+
+	private getWindow(target: EventTarget): Window | null {
+		if (!target) return null;
+		// TODO: object safety
+		// @ts-expect-error
+		if ("ownerDocument" in target && target.ownerDocument.defaultView) {
+			// @ts-expect-error
+			return target.ownerDocument.defaultView;
+		}
+
+		if (
+			"constructor" in target &&
+			target.constructor &&
+			"constructor" in target.constructor &&
+			target.constructor.constructor
+		) {
+			// @ts-expect-error hack hack hack sahur
+			return new target.constructor.constructor("return globalThis")();
+		}
+
+		return null;
+	}
+
+	addEventListener<T extends Event>(
+		target: EventTarget,
+		eventName: string,
+		listener: (e: T) => void
+	): void {
+		const window = this.getWindow(target);
+		if (!window) {
+			console.warn("target's original realm could not be found", target);
+			return;
+		}
+		const addAlwaysLastEventListener =
+			this.addAlwaysLastEventListeners.get(window);
+		if (!addAlwaysLastEventListener) {
+			throw new Error(
+				"somehow the realm of the target never had addAlwaysLastEventListener installed"
+			);
+		}
+		addAlwaysLastEventListener(target, eventName, listener);
+	}
+}

package/source/packages/scramjet/packages/utils/src/global.d.ts

@@ -0,0 +1,8 @@
+import type * as ScramjetController from "@mercuryworkshop/scramjet-controller";
+
+declare global {
+	const $scramjet: typeof import("@mercuryworkshop/scramjet");
+	const $scramjetController: typeof ScramjetController;
+}
+
+export {};