roxxie-proxy-u-prod 0.1.0

package/source/packages/chrome/src/proxy/roxxie.ts

@@ -0,0 +1,85 @@
+import {
+	BareCompatibleClient,
+	type ProxyTransport,
+} from "@mercuryworkshop/proxy-transports";
+import {
+	RoxxieProxyTransport,
+	loadTrackerNetworkDocument,
+	type ConnectedNode,
+	type RoxxieTransportStatus,
+} from "roxxie-transports";
+import { runtimeAssetUrl } from "../runtime-base.ts";
+
+export let bare: BareCompatibleClient;
+export let transport: ProxyTransport;
+
+export let roxxieTransport: RoxxieProxyTransport | undefined;
+export let roxxieStartupError: Error | null = null;
+
+let connectionAttempt: Promise<ConnectedNode> | undefined;
+
+function networkConfigurationUrl(): URL {
+	return runtimeAssetUrl("roxxie-network.json");
+}
+
+/** Installs the proxy adapter without contacting the tracker. */
+export function installRoxxieTransport(): RoxxieProxyTransport {
+	if (roxxieTransport !== undefined) return roxxieTransport;
+
+	const installed = new RoxxieProxyTransport(() =>
+		loadTrackerNetworkDocument(networkConfigurationUrl())
+	);
+	roxxieTransport = installed;
+	transport = installed;
+	bare = new BareCompatibleClient(transport);
+	return installed;
+}
+
+/**
+ * Resolves only after tracker discovery, WebRTC, the Adrift handshake, and the
+ * node RTT probe have all succeeded. Concurrent Start clicks share one attempt.
+ */
+export function connectRoxxieTransport(): Promise<ConnectedNode> {
+	const installed = installRoxxieTransport();
+	if (installed.ready && installed.connectedNode !== undefined) {
+		return Promise.resolve(installed.connectedNode);
+	}
+	if (connectionAttempt !== undefined) return connectionAttempt;
+
+	const attempt = (async () => {
+		try {
+			await installed.init();
+			const connectedNode = installed.connectedNode;
+			if (!installed.ready || connectedNode === undefined) {
+				throw new Error("Roxxie node connection closed during startup");
+			}
+			roxxieStartupError = null;
+			return connectedNode;
+		} catch (error) {
+			roxxieStartupError =
+				error instanceof Error ? error : new Error(String(error));
+			console.error(
+				"Roxxie proxy node initialization failed",
+				roxxieStartupError
+			);
+			throw roxxieStartupError;
+		}
+	})();
+	connectionAttempt = attempt;
+	void attempt
+		.finally(() => {
+			if (connectionAttempt === attempt) connectionAttempt = undefined;
+		})
+		.catch(() => undefined);
+	return attempt;
+}
+
+export function subscribeToRoxxieStatus(
+	listener: (status: RoxxieTransportStatus) => void
+): () => void {
+	if (!roxxieTransport) {
+		listener({ state: "idle" });
+		return () => undefined;
+	}
+	return roxxieTransport.subscribe(listener);
+}

package/source/packages/chrome/src/proxy/scramjet.ts

@@ -0,0 +1,642 @@
+import {
+	defaultConfig,
+	defaultConfigDev,
+	ScramjetFetchHandler,
+	type ScramjetConfig,
+	type ScramjetFetchRequest,
+	type ScramjetInterface,
+	unrewriteUrl,
+	type ScramjetFetchResponse,
+	rewriteUrl,
+	ScramjetHeaders,
+	isInlineDisplayableMimeType,
+} from "@mercuryworkshop/scramjet/bundled-wasm";
+import type { BareResponse } from "@mercuryworkshop/proxy-transports";
+import { RpcHelper } from "@mercuryworkshop/rpc";
+
+import scramjetWASM from "../../../scramjet/packages/core/dist/scramjet.wasm?url";
+import injectScript from "../../../inject/dist/inject.js?url";
+import { isIsolated } from ".";
+
+export const virtualWasmPath = "scramjet.wasm.js";
+export const virtualInjectPath = "inject.js";
+
+function makeConfig(): ScramjetConfig {
+	return {
+		...defaultConfig,
+		flags: {
+			...defaultConfigDev.flags,
+			captureErrors: false,
+		},
+		maskedfiles: ["inject.js", "scramjet.wasm.js"],
+	};
+}
+
+function base64Encode(str: string): string {
+	return btoa(
+		new Uint8Array(new TextEncoder().encode(str))
+			.reduce(
+				(data, byte) => (data.push(String.fromCharCode(byte)), data),
+				[] as any
+			)
+			.join("")
+	);
+}
+
+import type {
+	Chromebound,
+	Framebound,
+	FrameSequence,
+} from "../../../inject/src/types";
+import { transport } from "./roxxie";
+import { codecDecode, codecEncode } from "./codec";
+import { Controller, controllerForURL, makeId } from "./Controller";
+import type { Tab } from "../Tab/Tab";
+import { createMenu } from "@components/Menu";
+import { pageContextItems } from "./contextitems";
+import type {
+	BodyType,
+	WebSocketMessage,
+} from "../../../scramjet/packages/controller/src/types";
+import { getTheme } from "../themes";
+import {
+	adBlockService,
+	downloadsService,
+	profileService,
+	settingsService,
+	tabsService,
+} from "..";
+function findSequence(
+	top: Window,
+	target: Window,
+	path: FrameSequence = []
+): FrameSequence | null {
+	if (top == target) {
+		return path;
+	} else {
+		for (let i = 0; i < top.frames.length; i++) {
+			const child = top.frames[i];
+			const res = findSequence(child, target, [...path, i]);
+			if (res) return res;
+		}
+		return null;
+	}
+}
+
+export function reduceSequence(sequence: FrameSequence): Window | null {
+	return sequence.reduce<Window | null>((win, idx) => {
+		if (!win) return null;
+		return win.frames[idx];
+	}, self.top);
+}
+
+class ProxyFrameContext {
+	rpc: RpcHelper<Chromebound, Framebound>;
+	windowproxy: Window | null = null;
+	constructor(
+		public controller: Controller,
+		public id: string
+	) {
+		let tab: Tab | null = null;
+		let loadedUrl: string | null = null;
+		this.rpc = new RpcHelper<Chromebound, Framebound>(
+			{
+				load: async ({ url, sequence }) => {
+					loadedUrl = url;
+					this.windowproxy = reduceSequence(sequence);
+					tab =
+						tabsService.tabs.find(
+							(t) => t.frame.frame.contentWindow === this.windowproxy
+						) || null;
+					if (!tab) return;
+
+					if (tab.history.justTriggeredNavigation) {
+						// url bar was typed in, we triggered this navigation, don't push a new state since we already did
+						tab.history.justTriggeredNavigation = false;
+					} else {
+						// the page just loaded on its own (a link was clicked, window.location was set)
+						tab.history.push(new URL(url), undefined, null, false);
+					}
+					tab.initialLoad();
+					// it won't allow scrolling inputs until the tab is focused or something
+					// for some reason frame.focus() doesn't work but frame.click() does ? even cross origin
+					if (tabsService.activetab === tab) {
+						tab.frame.frame.click();
+					}
+				},
+				titlechange: async ({ title, icon }) => {
+					if (!tab) return;
+					if (title) {
+						tab.title = title;
+						tab.history.current().title = title;
+					}
+					if (icon) {
+						tab.icon = icon;
+						tab.history.current().favicon = icon;
+					}
+				},
+				contextmenu: async (msg) => {
+					if (!tab) return;
+					let offX = 0;
+					let offY = 0;
+					let { x, y } = tab!.frame.frame.getBoundingClientRect();
+					offX += x;
+					offY += y;
+					createMenu(
+						{ left: msg.x + offX, top: msg.y + offY },
+						pageContextItems(tab, msg)
+					);
+				},
+				history_go: async ({ delta }) => {
+					if (tab) {
+						console.error("hist go" + delta);
+						tab.history.go(delta);
+					}
+				},
+				history_pushState: async ({ url, title, state }) => {
+					if (tab) {
+						console.error("hist push", url);
+						tab.history.push(new URL(url), title, state, false, true);
+					}
+				},
+				history_replaceState: async ({ url, title, state }) => {
+					if (tab) {
+						tab.history.replace(new URL(url), title, state, false);
+					}
+				},
+				newtab: async ({ url }) => {
+					const tab = tabsService.newTab(new URL(url));
+					await tab.waitForInit;
+					const seq = findSequence(
+						top!,
+						tab.frame.frame.contentWindow as Window
+					);
+					if (!seq) throw new Error("No sequence found for new tab");
+
+					return [
+						{
+							sequence: seq,
+						},
+						[],
+					];
+				},
+				registerFrameContext: async ({ id: childId }) => {
+					contexts.push(new ProxyFrameContext(this.controller, childId));
+				},
+				setCookies: async ({ cookies }) => {
+					for (const { url, cookie } of cookies) {
+						try {
+							profileService.cookieJar.setCookies(cookie, new URL(url));
+						} catch {
+							console.error("Failed to set cookie", { url, cookie });
+						}
+					}
+					profileService.markDirty();
+
+					for (const ctx of contexts) {
+						if (ctx === this) continue;
+						if (!ctx.alive()) continue;
+						void ctx.rpc.call("setCookies", { cookies });
+					}
+				},
+				wsconnect: async ({ url, protocols, requestHeaders, port }) => {
+					const decision = adBlockService.matchWebSocket(
+						url,
+						loadedUrl ?? tab?.url.href
+					);
+					if (decision.action === "block" || decision.action === "redirect") {
+						port.close();
+						return [
+							{
+								result: "failure" as const,
+								error: "Blocked by Roxxie Proxy U",
+							},
+							[],
+						];
+					}
+					const connectionUrl =
+						decision.action === "rewrite" ? decision.url : url;
+					let resolve!: (arg: Chromebound["wsconnect"][1]) => void;
+					const promise = new Promise<Chromebound["wsconnect"][1]>(
+						(res) => (resolve = res)
+					);
+					const [send, close] = transport.connect(
+						new URL(connectionUrl),
+						protocols,
+						requestHeaders,
+						(protocol, extensions) => {
+							resolve({
+								result: "success",
+								protocol,
+								extensions,
+							});
+						},
+						(data) => {
+							port.postMessage(
+								{
+									type: "data",
+									data,
+								} as WebSocketMessage,
+								data instanceof ArrayBuffer ? [data] : []
+							);
+						},
+						(code, reason) => {
+							port.postMessage({
+								type: "close",
+								code,
+								reason,
+							} as WebSocketMessage);
+						},
+						(error) => {
+							resolve({
+								result: "failure",
+								error,
+							});
+						}
+					);
+					port.onmessageerror = (ev) => {
+						console.error(
+							"Transport port messageerror (this should never happen!)",
+							ev
+						);
+					};
+					port.onmessage = ({ data }: MessageEvent) => {
+						const message = data as WebSocketMessage;
+						if (message.type === "data") {
+							send(message.data);
+						} else if (message.type === "close") {
+							close(message.code, message.reason);
+						}
+					};
+
+					return [await promise, []];
+				},
+			},
+			id,
+			(message, transfer) => {
+				if (this.windowproxy) {
+					// is it a windowproxy?
+					if (isIsolated) {
+						this.windowproxy.postMessage(message, "*", transfer);
+					} else {
+						// TODO :(
+						(
+							this.windowproxy as Window & {
+								[key: symbol]: {
+									natives: { call: (...args: unknown[]) => unknown };
+								};
+							}
+						)[Symbol.for("scramjet client global")].natives.call(
+							"window.postMessage",
+							this.windowproxy,
+							message,
+							"*",
+							transfer
+						);
+					}
+				} else {
+					console.warn("No window proxy available for frame context", this.id);
+				}
+			}
+		);
+		addEventListener("message", (event) => {
+			this.rpc.recieve(event.data);
+		});
+	}
+
+	alive(): boolean {
+		// the windowproxy *object* will still exist, so we need to check if there's still a path to it
+		return findSequence(top!, this.windowproxy!) !== null;
+	}
+}
+
+export let contexts: ProxyFrameContext[] = [];
+(window as Window & { contexts?: ProxyFrameContext[] }).contexts = contexts;
+
+export function renderErrorPage(controller: Controller, error: Error): string {
+	const contextId = "context-" + makeId();
+	let frameContext = new ProxyFrameContext(controller, contextId);
+	contexts.push(frameContext);
+
+	const theme = getTheme(settingsService.settings.themeId);
+
+	return `
+		<script src="${controller.prefix.href}${virtualWasmPath}"></script>
+		<script src="${controller.prefix.href}${virtualInjectPath}"></script>
+		<script>
+			$injectLoadError({
+				id: "${contextId}",
+				sequence: ${JSON.stringify(findSequence(top!, self)!)},
+				config: ${JSON.stringify(makeConfig())},
+				cookies: ${JSON.stringify(profileService.cookieJar.dump())},
+				codecEncode: ${codecEncode.toString()},
+				codecDecode: ${codecDecode.toString()},
+				prefix: "${controller.prefix.href}",
+				initHeaders: [],
+				history: [],
+			}, {
+				message: ${JSON.stringify(error.message)},
+				stack: ${JSON.stringify(error.stack)},
+				theme: ${JSON.stringify(theme)},
+			});
+		</script>
+	`;
+}
+
+export function createFetchHandler(controller: Controller) {
+	const getInjectScripts: ScramjetInterface["getInjectScripts"] = (
+		meta,
+		handler,
+		htmlcontext,
+		script
+	) => {
+		const contextId = "context-" + makeId();
+		let frameContext = new ProxyFrameContext(controller, contextId);
+		contexts.push(frameContext);
+
+		const initHeaders = htmlcontext.headers ?? [];
+		const history = htmlcontext.history ?? [];
+
+		const injected = `
+			$injectLoad({
+				id: "${contextId}",
+				sequence: ${JSON.stringify(findSequence(top!, self)!)},
+				config: ${JSON.stringify(makeConfig())},
+				cookies: ${JSON.stringify(profileService.cookieJar.dump())},
+				codecEncode: ${codecEncode.toString()},
+				codecDecode: ${codecDecode.toString()},
+				prefix: "${controller.prefix.href}",
+				initHeaders: ${JSON.stringify(initHeaders)},
+				history: ${JSON.stringify(history)},
+			});
+			document.querySelectorAll("script[scramjet-injected]").forEach(script => script.remove());
+		`;
+
+		return [
+			script(controller.prefix.href + virtualWasmPath),
+			script(controller.prefix.href + virtualInjectPath),
+			script(
+				"data:text/javascript;charset=utf-8;base64," + base64Encode(injected)
+			),
+		];
+	};
+
+	const getWorkerInjectScripts: ScramjetInterface["getWorkerInjectScripts"] = (
+		meta,
+		type,
+		script
+	) => {
+		let str = "";
+
+		// workers don't have a document, so initHeaders/history are empty.
+		const injectLoad = `
+				$injectLoad({
+					config: ${JSON.stringify(makeConfig())},
+					cookies: null,
+					codecEncode: ${codecEncode.toString()},
+					codecDecode: ${codecDecode.toString()},
+					prefix: "${controller.prefix.href}",
+					initHeaders: [],
+					history: [],
+				});
+			`;
+		str += script(controller.prefix.href + virtualWasmPath);
+		str += script(controller.prefix.href + virtualInjectPath);
+		str += script(
+			`data:text/javascript;charset=utf-8;base64,${base64Encode(injectLoad)}`
+		);
+
+		return str;
+	};
+
+	const fetchHandler = new ScramjetFetchHandler({
+		transport: transport,
+		context: {
+			interface: {
+				getInjectScripts,
+				getWorkerInjectScripts,
+				codecEncode,
+				codecDecode,
+			},
+			cookieJar: profileService.cookieJar,
+			config: makeConfig(),
+			prefix: controller.prefix,
+		},
+		async fetchDataUrl(dataUrl: string) {
+			return (await fetch(dataUrl)) as BareResponse;
+		},
+		async fetchBlobUrl(blobUrl: string) {
+			// find a random tab under this controller
+			const tab = tabsService.tabs.find(
+				(tab) => tab.frame.controller === controller
+			);
+			if (!tab) throw new Error("No tab found for blob fetch (?)");
+			let framewindowproxy = tab.frame.frame.contentWindow;
+			if (!framewindowproxy)
+				throw new Error("No frame window proxy for blob fetch");
+			// find the context for this proxy
+			const context = contexts.find(
+				(ctx) => ctx.windowproxy === framewindowproxy
+			);
+			if (!context) throw new Error("No context found for blob fetch");
+
+			const response = await context.rpc.call("fetchBlob", blobUrl);
+
+			console.log("FETCHED BLOB", response);
+			let headers = new Headers();
+			headers.set("Content-Type", response.contentType);
+			return new Response(response.body, {
+				headers,
+			}) as BareResponse;
+		},
+		async sendSetCookie(cookies, options) {
+			profileService.markDirty();
+
+			const serialized = cookies.map(({ url, cookie }) => ({
+				url: url.href,
+				cookie,
+			}));
+			const promises: Promise<any>[] = [];
+			for (const context of contexts) {
+				if (context.alive()) {
+					promises.push(
+						context.rpc.call("setCookies", {
+							cookies: serialized,
+						})
+					);
+				}
+			}
+			if (promises.length === 0) return;
+
+			const isNavigation =
+				options?.destination === "document" ||
+				options?.destination === "iframe";
+			if (isNavigation) return;
+
+			let timeoutId: ReturnType<typeof setTimeout> | undefined;
+			const timeoutPromise = new Promise<void>((resolve) => {
+				timeoutId = setTimeout(() => {
+					console.error("timed out waiting for inject context cookie sync ack");
+					resolve();
+				}, 1000);
+			});
+			try {
+				await Promise.race([
+					timeoutPromise,
+					Promise.any(promises).catch(() => {}),
+				]);
+			} finally {
+				if (timeoutId !== undefined) clearTimeout(timeoutId);
+			}
+		},
+	});
+
+	return fetchHandler;
+}
+
+let wasmPayload: string | null = null;
+
+export type RawDownload = {
+	filename: string | null;
+	url: string;
+	type: string;
+	body: BodyType;
+	length: number;
+};
+
+function isDownload(
+	responseHeaders: ScramjetHeaders,
+	destination: string
+): boolean {
+	if (["document", "iframe"].includes(destination)) {
+		const header = responseHeaders.get("content-disposition");
+		if (header) {
+			if (header === "inline") {
+				return false; // force it to show in browser
+			} else {
+				return true;
+			}
+		} else {
+			const contentType = responseHeaders.get("content-type");
+			if (contentType && !isInlineDisplayableMimeType(contentType)) {
+				return true;
+			}
+		}
+	}
+
+	return false;
+}
+async function makeWasmResponse() {
+	if (!wasmPayload) {
+		const resp = await fetch(scramjetWASM);
+		const buf = await resp.arrayBuffer();
+		const b64 = btoa(
+			new Uint8Array(buf)
+				.reduce(
+					(data, byte) => (data.push(String.fromCharCode(byte)), data),
+					[] as any
+				)
+				.join("")
+		);
+
+		wasmPayload = `self.WASM = '${b64}';`;
+	}
+
+	return {
+		body: wasmPayload,
+		headers: ScramjetHeaders.fromRawHeaders([
+			["Content-Type", "application/javascript"],
+		]),
+		status: 200,
+		statusText: "OK",
+	};
+}
+
+export async function handlefetch(
+	data: ScramjetFetchRequest,
+	controller: Controller
+): Promise<ScramjetFetchResponse> {
+	// handle scramjet.all.js and scramjet.wasm.js requests
+	if (data.rawUrl.pathname === controller.prefix.pathname + virtualWasmPath) {
+		return await makeWasmResponse();
+	} else if (
+		data.rawUrl.pathname ===
+		controller.prefix.pathname + virtualInjectPath
+	) {
+		return await fetch(injectScript).then(async (x) => {
+			const text = await x.text();
+			return {
+				body: text,
+				headers: ScramjetHeaders.fromRawHeaders([
+					["Content-Type", "application/javascript"],
+				]),
+				status: 200,
+				statusText: "OK",
+			};
+		});
+	}
+
+	if (data.rawDestination === "document" || data.rawDestination === "iframe") {
+		const unrewritten = unrewriteUrl(
+			data.rawUrl,
+			controller.fetchHandler.context
+		);
+
+		// our controller is bound to a root domain
+		// if a site under the controller tries to iframe a cross-site domain it needs to redirect to that different controller
+		const newcontroller = await controllerForURL(new URL(unrewritten));
+		if (controller !== newcontroller) {
+			// then send a redirect so the browser will load the request from the other controller's sw
+			return {
+				body: "Redirecting Cross-Origin Frame Request...",
+				status: 302,
+				statusText: "Found",
+				headers: ScramjetHeaders.fromRawHeaders([
+					["Content-Type", "text/plain"],
+					[
+						"Location",
+						rewriteUrl(
+							new URL(unrewritten),
+							newcontroller.fetchHandler.context,
+							{
+								origin: newcontroller.prefix,
+								base: newcontroller.prefix,
+							}
+						),
+					],
+				]),
+			};
+		}
+	}
+
+	const fetchresponse = await controller.fetchHandler.handleFetch(data);
+
+	if (
+		isDownload(fetchresponse.headers, data.rawDestination) &&
+		fetchresponse.status === 200
+	) {
+		let filename: string | null = null;
+		const disp = fetchresponse.headers.get("content-disposition");
+		if (typeof disp === "string") {
+			const filenameMatch = disp.match(/filename=["']?([^"';\n]*)["']?/i);
+			if (filenameMatch && filenameMatch[1]) {
+				filename = filenameMatch[1];
+			}
+		}
+		const length = fetchresponse.headers.get("content-length") || "0";
+
+		downloadsService.startDownload({
+			filename,
+			url: unrewriteUrl(data.rawUrl, { prefix: controller.prefix } as any),
+			type:
+				fetchresponse.headers.get("content-type") || "application/octet-stream",
+			length: parseInt(length),
+			body: fetchresponse.body,
+		});
+
+		// endless vortex reference
+		await new Promise(() => {});
+	}
+
+	return fetchresponse;
+}