roxxie-proxy-u-prod 0.2.2 → 0.2.4

package/source/packages/chrome/src/proxy/navigation.test.ts

@@ -0,0 +1,91 @@
+/* SPDX-License-Identifier: AGPL-3.0-only */
+
+import { describe, expect, it, vi } from "vitest";
+
+import {
+	NavigationCommitTracker,
+	isCommittableNavigationStatus,
+} from "./navigation";
+
+describe("NavigationCommitTracker", () => {
+	it("commits a successful external document without waiting for HTML injection", () => {
+		const tracker = new NavigationCommitTracker();
+		const commit = vi.fn();
+		tracker.begin("https://proxy.test/runtime/ip.me#ignored", commit);
+
+		tracker.observe({
+			destination: "iframe",
+			requestUrl: "https://proxy.test/runtime/ip.me",
+			status: 200,
+		});
+
+		expect(commit).toHaveBeenCalledOnce();
+	});
+
+	it("waits through redirects, including a controller-origin change", () => {
+		const tracker = new NavigationCommitTracker();
+		const commit = vi.fn();
+		tracker.begin("https://first-controller.test/start", commit);
+
+		tracker.observe({
+			destination: "iframe",
+			requestUrl: "https://first-controller.test/start",
+			status: 302,
+			location: "https://second-controller.test/final",
+		});
+		expect(commit).not.toHaveBeenCalled();
+
+		tracker.observe({
+			destination: "iframe",
+			requestUrl: "https://second-controller.test/final",
+			status: 200,
+		});
+		expect(commit).toHaveBeenCalledOnce();
+	});
+
+	it("does not reveal a frame for subresources or failed/empty navigations", () => {
+		for (const status of [204, 205, 404, 500]) {
+			const tracker = new NavigationCommitTracker();
+			const commit = vi.fn();
+			tracker.begin("https://proxy.test/page", commit);
+
+			tracker.observe({
+				destination: "script",
+				requestUrl: "https://proxy.test/page",
+				status: 200,
+			});
+			expect(commit).not.toHaveBeenCalled();
+
+			tracker.observe({
+				destination: "document",
+				requestUrl: "https://proxy.test/page",
+				status,
+			});
+			expect(commit).not.toHaveBeenCalled();
+		}
+	});
+
+	it("supports cancelling a navigation before its response arrives", () => {
+		const tracker = new NavigationCommitTracker();
+		const commit = vi.fn();
+		const cancel = tracker.begin("https://proxy.test/slow", commit);
+		cancel();
+
+		tracker.observe({
+			destination: "iframe",
+			requestUrl: "https://proxy.test/slow",
+			status: 200,
+		});
+		expect(commit).not.toHaveBeenCalled();
+	});
+});
+
+describe("isCommittableNavigationStatus", () => {
+	it("matches browser document replacement semantics for successful responses", () => {
+		expect(isCommittableNavigationStatus(200)).toBe(true);
+		expect(isCommittableNavigationStatus(206)).toBe(true);
+		expect(isCommittableNavigationStatus(204)).toBe(false);
+		expect(isCommittableNavigationStatus(205)).toBe(false);
+		expect(isCommittableNavigationStatus(302)).toBe(false);
+	});
+});

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

@@ -0,0 +1,97 @@
+/* SPDX-License-Identifier: AGPL-3.0-only */
+
+export type NavigationResponseSignal = {
+	destination: RequestDestination;
+	requestUrl: string;
+	status: number;
+	location?: string | null;
+};
+
+type PendingNavigation = {
+	id: number;
+	expectedRequestUrl: string;
+	commit: () => void;
+};
+
+const REDIRECT_STATUSES = new Set([301, 302, 303, 307, 308]);
+
+function networkUrl(url: string, base?: string): string {
+	const parsed = new URL(url, base);
+	parsed.hash = "";
+	return parsed.href;
+}
+
+export function isNavigationDestination(
+	destination: RequestDestination
+): boolean {
+	return destination === "document" || destination === "iframe";
+}
+
+export function isCommittableNavigationStatus(status: number): boolean {
+	// A 204 or 205 response aborts a browser navigation rather than replacing the
+	// current document. Treat the remaining successful responses as commits.
+	return status >= 200 && status < 300 && status !== 204 && status !== 205;
+}
+
+/**
+ * Correlates a frame navigation started by the browser UI with the response
+ * returned by a Scramjet controller. This is intentionally independent of the
+ * response MIME type: non-HTML documents never execute the injected load RPC.
+ */
+export class NavigationCommitTracker {
+	private nextId = 1;
+	private pending: PendingNavigation[] = [];
+
+	begin(requestUrl: string, commit: () => void): () => void {
+		const navigation: PendingNavigation = {
+			id: this.nextId++,
+			expectedRequestUrl: networkUrl(requestUrl),
+			commit,
+		};
+		this.pending.push(navigation);
+
+		return () => {
+			this.remove(navigation.id);
+		};
+	}
+
+	observe(signal: NavigationResponseSignal): void {
+		if (!isNavigationDestination(signal.destination)) return;
+
+		let requestUrl: string;
+		try {
+			requestUrl = networkUrl(signal.requestUrl);
+		} catch {
+			return;
+		}
+
+		const navigation = this.pending.find(
+			(candidate) => candidate.expectedRequestUrl === requestUrl
+		);
+		if (!navigation) return;
+
+		if (REDIRECT_STATUSES.has(signal.status) && signal.location) {
+			try {
+				navigation.expectedRequestUrl = networkUrl(
+					signal.location,
+					requestUrl
+				);
+				return;
+			} catch {
+				// An invalid redirect cannot produce a successful document commit.
+			}
+		}
+
+		this.remove(navigation.id);
+		if (isCommittableNavigationStatus(signal.status)) {
+			navigation.commit();
+		}
+	}
+
+	private remove(id: number): void {
+		const index = this.pending.findIndex((navigation) => navigation.id === id);
+		if (index !== -1) this.pending.splice(index, 1);
+	}
+}
+
+export const navigationCommitTracker = new NavigationCommitTracker();

package/source/packages/chrome/src/proxy/scramjet-config.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from "vitest";
+
+import { makeScramjetConfig } from "./scramjet-config";
+
+describe("production Scramjet configuration", () => {
+	it("recovers unsupported scripts without enabling debug overhead", () => {
+		const config = makeScramjetConfig();
+
+		expect(config.flags).toMatchObject({
+			allowInvalidJs: true,
+			captureErrors: false,
+			debugSourceURL: false,
+			debugTrampolines: false,
+			rewriterLogs: false,
+			sourcemaps: false,
+		});
+		expect(config.maskedfiles).toEqual(["inject.js", "scramjet.wasm.js"]);
+	});
+});

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

@@ -0,0 +1,26 @@
+import {
+	defaultConfig,
+	type ScramjetConfig,
+} from "@mercuryworkshop/scramjet/bundled-wasm";
+
+/**
+ * Configuration shared by the service-worker rewriter and every injected
+ * page/worker runtime. Keep this on the production defaults: the development
+ * preset deliberately turns parser recovery off and enables debug work that
+ * is both noisy and expensive on large production bundles.
+ */
+export function makeScramjetConfig(): ScramjetConfig {
+	return {
+		...defaultConfig,
+		flags: {
+			...defaultConfig.flags,
+			allowInvalidJs: true,
+			captureErrors: false,
+			debugSourceURL: false,
+			debugTrampolines: false,
+			rewriterLogs: false,
+			sourcemaps: false,
+		},
+		maskedfiles: ["inject.js", "scramjet.wasm.js"],
+	};
+}

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

@@ -1,8 +1,5 @@
 import {
-	defaultConfig,
-	defaultConfigDev,
 	ScramjetFetchHandler,
-	type ScramjetConfig,
 	type ScramjetFetchRequest,
 	type ScramjetInterface,
 	unrewriteUrl,
@@ -17,21 +14,11 @@ 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 ".";
+import { makeScramjetConfig } from "./scramjet-config";
 
 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))
@@ -327,7 +314,7 @@ export function renderErrorPage(controller: Controller, error: Error): string {
 			$injectLoadError({
 				id: "${contextId}",
 				sequence: ${JSON.stringify(findSequence(top!, self)!)},
-				config: ${JSON.stringify(makeConfig())},
+				config: ${JSON.stringify(makeScramjetConfig())},
 				cookies: ${JSON.stringify(profileService.cookieJar.dump())},
 				codecEncode: ${codecEncode.toString()},
 				codecDecode: ${codecDecode.toString()},
@@ -361,7 +348,7 @@ export function createFetchHandler(controller: Controller) {
 			$injectLoad({
 				id: "${contextId}",
 				sequence: ${JSON.stringify(findSequence(top!, self)!)},
-				config: ${JSON.stringify(makeConfig())},
+				config: ${JSON.stringify(makeScramjetConfig())},
 				cookies: ${JSON.stringify(profileService.cookieJar.dump())},
 				codecEncode: ${codecEncode.toString()},
 				codecDecode: ${codecDecode.toString()},
@@ -391,7 +378,7 @@ export function createFetchHandler(controller: Controller) {
 		// workers don't have a document, so initHeaders/history are empty.
 		const injectLoad = `
 				$injectLoad({
-					config: ${JSON.stringify(makeConfig())},
+					config: ${JSON.stringify(makeScramjetConfig())},
 					cookies: null,
 					codecEncode: ${codecEncode.toString()},
 					codecDecode: ${codecDecode.toString()},
@@ -419,7 +406,7 @@ export function createFetchHandler(controller: Controller) {
 				codecDecode,
 			},
 			cookieJar: profileService.cookieJar,
-			config: makeConfig(),
+			config: makeScramjetConfig(),
 			prefix: controller.prefix,
 		},
 		async fetchDataUrl(dataUrl: string) {

package/source/packages/chrome/src/proxy/user-agent.test.ts

@@ -0,0 +1,78 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import {
+	applyUserAgentHeader,
+	browserUserAgent,
+	resetUserAgentCache,
+} from "../../../scramjet/packages/core/src/fetch/user-agent";
+
+/** Minimal stand-in for ScramjetHeaders' case-insensitive storage. */
+function headers(initial: Record<string, string> = {}) {
+	const store = new Map<string, string>();
+	for (const [name, value] of Object.entries(initial)) {
+		store.set(name.toLowerCase(), value);
+	}
+	return {
+		get: (key: string) => store.get(key.toLowerCase()) ?? null,
+		set: (key: string, value: string) => {
+			store.set(key.toLowerCase(), value);
+		},
+		raw: store,
+	};
+}
+
+const FIREFOX =
+	"Mozilla/5.0 (X11; Linux x86_64; rv:140.0) Gecko/20100101 Firefox/140.0";
+
+afterEach(() => {
+	resetUserAgentCache();
+	vi.unstubAllGlobals();
+});
+
+describe("User-Agent forwarding", () => {
+	it("sends the browser's own User-Agent when the request carries none", () => {
+		// Without this an origin that content-negotiates on User-Agent serves its
+		// non-browser representation: ip.me returns a text/plain IP, not its page.
+		vi.stubGlobal("navigator", { userAgent: FIREFOX });
+		const h = headers();
+
+		applyUserAgentHeader(h);
+
+		expect(h.get("user-agent")).toBe(FIREFOX);
+	});
+
+	it("matches the header case-insensitively", () => {
+		vi.stubGlobal("navigator", { userAgent: FIREFOX });
+		const h = headers({ "User-Agent": "PageChosen/1.0" });
+
+		applyUserAgentHeader(h);
+
+		expect(h.get("user-agent")).toBe("PageChosen/1.0");
+	});
+
+	it("never overwrites a User-Agent the page set deliberately", () => {
+		vi.stubGlobal("navigator", { userAgent: FIREFOX });
+		const h = headers({ "user-agent": "CustomBot/2.0" });
+
+		applyUserAgentHeader(h);
+
+		expect(h.get("user-agent")).toBe("CustomBot/2.0");
+	});
+
+	it("leaves the header absent rather than inventing one", () => {
+		vi.stubGlobal("navigator", { userAgent: "" });
+		const h = headers();
+
+		applyUserAgentHeader(h);
+
+		expect(h.get("user-agent")).toBeNull();
+	});
+
+	it("tolerates environments with no navigator at all", () => {
+		vi.stubGlobal("navigator", undefined);
+		const h = headers();
+
+		expect(() => applyUserAgentHeader(h)).not.toThrow();
+		expect(browserUserAgent()).toBeNull();
+	});
+});

package/source/packages/chrome/src/services/SettingsService.ts

@@ -24,6 +24,8 @@ export type Settings = {
 	clearHistoryOnExit: boolean;
 	doNotTrack: boolean;
 	extensionsDevMode: boolean;
+	/** Node id the user pinned in Advanced settings; empty means automatic. */
+	preferredNodeId: string;
 };
 
 export type TabLayoutMode = Settings["tabLayout"];
@@ -44,6 +46,7 @@ const DEFAULT_SETTINGS: Settings = {
 	clearHistoryOnExit: false,
 	doNotTrack: true,
 	extensionsDevMode: false,
+	preferredNodeId: "",
 };
 
 export type SettingsServiceState = {
@@ -63,6 +66,7 @@ export type SettingsServiceState = {
 		clearHistoryOnExit: boolean;
 		doNotTrack: boolean;
 		extensionsDevMode: boolean;
+		preferredNodeId: string;
 	};
 };
 
@@ -72,7 +76,9 @@ export class SettingsService extends Service {
 	constructor(data: SettingsServiceState | null) {
 		super();
 		if (data) {
-			this.settings = createState(data.settings);
+			// Profiles saved before a setting existed omit it entirely, so fill in
+			// defaults rather than leaving the state with undefined values.
+			this.settings = createState({ ...DEFAULT_SETTINGS, ...data.settings });
 		} else {
 			this.settings = createState(DEFAULT_SETTINGS);
 		}
@@ -102,6 +108,7 @@ export class SettingsService extends Service {
 				clearHistoryOnExit: this.settings.clearHistoryOnExit,
 				doNotTrack: this.settings.doNotTrack,
 				extensionsDevMode: this.settings.extensionsDevMode,
+				preferredNodeId: this.settings.preferredNodeId ?? "",
 			},
 		};
 	}

package/source/packages/roxxie-transport/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "roxxie-transports",
-	"version": "6.0.1",
+	"version": "6.1.0",
 	"description": "Tracker-discovered WebRTC transport for Roxxie Proxy U",
 	"type": "module",
 	"sideEffects": false,

package/source/packages/roxxie-transport/src/connection.ts

@@ -534,7 +534,10 @@ export class RoxxieConnection {
 			else if (this.sockets.has(frame.sequence)) {
 				this.handleSocketFrame(frame.sequence, frame.operation, frame.payload);
 			} else if (this.ignoredHTTP.has(frame.sequence)) {
-				if (frame.operation === S2CRequestTypes.HTTPResponseEnd) {
+				if (
+					frame.operation === S2CRequestTypes.HTTPResponseEnd ||
+					frame.operation === S2CRequestTypes.HTTPResponseError
+				) {
 					this.ignoredHTTP.delete(frame.sequence);
 				} else if (
 					frame.operation !== S2CRequestTypes.HTTPResponseStart &&
@@ -618,6 +621,20 @@ export class RoxxieConnection {
 				pending.removeAbort?.();
 				this.http.delete(sequence);
 				break;
+			case S2CRequestTypes.HTTPResponseError:
+				if (!pending.responseStarted || pending.controller === undefined) {
+					throw new Error("Node failed HTTP response before response headers");
+				}
+				// The node could not deliver the whole body. Erroring the stream
+				// keeps the partial bytes from being parsed or cached as if they
+				// were a complete response. Only this request is affected, so the
+				// session stays up.
+				pending.controller.error(
+					new Error("Proxy node could not deliver the complete response body")
+				);
+				pending.removeAbort?.();
+				this.http.delete(sequence);
+				break;
 			default:
 				throw new Error(`Node sent invalid HTTP operation ${operation}`);
 		}

package/source/packages/roxxie-transport/src/transport.ts

@@ -78,6 +78,9 @@ export class RoxxieProxyTransport implements ProxyTransport {
 	private readonly nodeCooldowns = new Map<string, number>();
 	private readonly dependencies: RoxxieTransportDependencies;
 	private closed = false;
+	/** Node the user pinned in advanced settings, if any. */
+	private preferredNodeId: string | undefined;
+	private lastCandidates: readonly CandidateNode[] = [];
 
 	constructor(
 		private readonly source: TrackerNetworkSource,
@@ -243,16 +246,57 @@ export class RoxxieProxyTransport implements ProxyTransport {
 		}
 	}
 
+	/**
+	 * Nodes the tracker offered on the most recent connection attempt. Used by
+	 * the settings UI to show what is available without forcing a reconnect.
+	 */
+	get availableNodes(): readonly CandidateNode[] {
+		return this.lastCandidates;
+	}
+
+	/** Ask the tracker for the current node list without connecting. */
+	async listNodes(): Promise<readonly CandidateNode[]> {
+		const document = await this.getDocument();
+		const tracker = this.getTracker(document);
+		const candidates = [...(await tracker.requestCandidates())];
+		this.lastCandidates = candidates;
+		return candidates;
+	}
+
+	get preferredNode(): string | undefined {
+		return this.preferredNodeId;
+	}
+
+	/**
+	 * Pin future connections to one node, or pass undefined to go back to
+	 * automatic selection. Takes effect on the next connection.
+	 */
+	setPreferredNode(nodeId: string | undefined): void {
+		this.preferredNodeId = nodeId || undefined;
+	}
+
 	private async establishConnection(): Promise<RoxxieConnection> {
 		const document = await this.getDocument();
 		const tracker = this.getTracker(document);
-		const discovered = [...(await tracker.requestCandidates())]
-			.slice(0, 3)
-			.sort(
-				(left, right) =>
-					left.activeSessions - right.activeSessions ||
-					left.utilization - right.utilization
-			);
+		const offered = [...(await tracker.requestCandidates())];
+		// Keep the full list for the settings UI; only the probe set is trimmed.
+		this.lastCandidates = offered;
+		const ranked = offered.sort(
+			(left, right) =>
+				left.activeSessions - right.activeSessions ||
+				left.utilization - right.utilization
+		);
+		// A pinned node has to be selected before the list is trimmed, or picking
+		// a lightly-used node outside the top few would silently do nothing.
+		const pinned =
+			this.preferredNodeId === undefined
+				? []
+				: ranked.filter(
+						(candidate) => candidate.nodeId === this.preferredNodeId
+					);
+		// Fall back to automatic selection rather than stranding the user on a node
+		// that has gone away since they picked it.
+		const discovered = pinned.length > 0 ? pinned : ranked.slice(0, 3);
 		const compatible = discovered.filter(
 			(candidate) => candidate.protocolVersion === PROTOCOL_VERSION
 		);

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

@@ -151,6 +151,13 @@ export async function doHandleFetch(
 	if (response.body && !isRedirect(response)) {
 		responseBody = await rewriteBody(handler, request, parsed, response);
 
+		// The service worker constructs a new Response around this body. HTML,
+		// JavaScript, CSS, and worker rewrites change its byte length, while even
+		// pass-through streams are no longer the native network response that
+		// supplied Content-Length. Firefox treats a mismatched retained length as
+		// corrupted content and can truncate modules/documents at that boundary.
+		responseHeaders.delete("content-length");
+
 		// After rewriting HTML, the body is a JS string which will be encoded as
 		// UTF-8 by the Response constructor. Normalize the Content-Type charset so
 		// the browser doesn't try to decode UTF-8 bytes with the original encoding.

package/source/packages/scramjet/packages/core/src/fetch/headers.ts

@@ -13,6 +13,7 @@ import {
 import { RawHeaders } from "@mercuryworkshop/proxy-transports";
 import { _URL, _Set } from "@/shared/snapshot";
 import { createReferrerString } from "./util";
+import { applyUserAgentHeader } from "./user-agent";
 
 /**
  * Headers for security policy features that haven't been emulated yet
@@ -123,6 +124,13 @@ export function rewriteRequestHeaders(
 ): ScramjetHeaders {
 	const headers = request.initialHeaders.clone();
 
+	// A service worker never sees User-Agent on the request it intercepts, and
+	// nothing downstream adds one, so requests reach origins with no User-Agent
+	// at all. Servers that content-negotiate on it then serve their non-browser
+	// representation - ip.me, for example, answers with a bare text/plain IP
+	// instead of its actual page.
+	applyUserAgentHeader(headers);
+
 	// avoid leaking the scramjet referer
 	headers.delete("Referer");
 

package/source/packages/scramjet/packages/core/src/fetch/user-agent.ts

@@ -0,0 +1,51 @@
+/**
+ * User-Agent forwarding.
+ *
+ * A service worker never sees User-Agent on the request it intercepts - the
+ * browser strips it before the fetch event - and nothing further down the proxy
+ * adds one. Requests therefore reached origins with no User-Agent at all, and
+ * servers that content-negotiate on it served their non-browser representation.
+ * ip.me, for instance, answers a bare `text/plain` IP address rather than its
+ * actual page.
+ *
+ * Kept free of the rest of the fetch pipeline's imports so it stays testable on
+ * its own.
+ */
+
+/** The minimal surface this needs from ScramjetHeaders. */
+export interface UserAgentHeaders {
+	get(key: string): string | null;
+	set(key: string, value: string): void;
+}
+
+let cachedUserAgent: string | null | undefined;
+
+/**
+ * The browser's own User-Agent, or null where no navigator is available. Cached
+ * because the value cannot change for the life of the worker.
+ */
+export function browserUserAgent(): string | null {
+	if (cachedUserAgent === undefined) {
+		const value =
+			typeof navigator === "undefined" ? undefined : navigator.userAgent;
+		cachedUserAgent =
+			typeof value === "string" && value.length > 0 ? value : null;
+	}
+	return cachedUserAgent;
+}
+
+/** Forces the next read to re-detect the User-Agent. Intended for tests. */
+export function resetUserAgentCache(): void {
+	cachedUserAgent = undefined;
+}
+
+/**
+ * Send the real browser User-Agent, unless the page set one of its own. Passing
+ * the browser's string through unchanged keeps a proxied request
+ * indistinguishable from a direct one for content negotiation.
+ */
+export function applyUserAgentHeader(headers: UserAgentHeaders): void {
+	if (headers.get("user-agent")) return;
+	const agent = browserUserAgent();
+	if (agent) headers.set("User-Agent", agent);
+}

package/source/packages/scramjet/packages/core/src/shared/rewriters/js.ts

@@ -146,8 +146,7 @@ export function rewriteJs(
 		dbg.warn(
 			"failed rewriting js for",
 			url || "(unknown)",
-			err.message,
-			typeof js !== "string" ? TextDecoder_decode(js) : js
+			err.message
 		);
 		if (flagEnabled("allowInvalidJs", context, meta.base)) {
 			return js;

package/source/packages/tracker-protocol/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "roxxie-transports-tracker-protocol",
-	"version": "1.2.0",
+	"version": "1.3.0",
 	"description": "Browser-safe control-plane contracts for the Roxxie tracker, nodes, and browsers",
 	"type": "module",
 	"sideEffects": false,
@@ -18,7 +18,7 @@
 		"test": "npm run build && node --test dist/test/*.test.js"
 	},
 	"engines": {
-		"node": ">=20"
+		"node": ">=18"
 	},
 	"publishConfig": {
 		"access": "public"