roxxie-proxy-u-prod 0.2.3 → 0.2.4

package/source/packages/chrome/src/pages/nodes.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect, it } from "vitest";
+
+import {
+	AUTOMATIC_NODE,
+	type CandidateNode,
+	buildNodeRows,
+	nodeSummary,
+	resolvePreferredNode,
+	toNodeRow,
+	versionLabel,
+} from "./nodes";
+
+function candidate(overrides: Partial<CandidateNode> = {}): CandidateNode {
+	return {
+		nodeId: "018f1f5e-7b2a-7c35-8b1d-2a4d9f8e6c10",
+		name: "Roxxie community node",
+		activeSessions: 1,
+		maxSessions: 8,
+		utilization: 0.125,
+		protocolVersion: "6.0",
+		packageVersion: "0.5.1",
+		platform: "linux",
+		...overrides,
+	};
+}
+
+describe("advanced settings node list", () => {
+	it("surfaces the node software version", () => {
+		const row = toNodeRow(candidate());
+		expect(row.version).toBe("0.5.1");
+		expect(versionLabel(row)).toBe("v0.5.1");
+	});
+
+	it("says so plainly when a tracker does not report a version", () => {
+		// Trackers older than the version field omit it; showing "v undefined"
+		// would be worse than admitting we do not know.
+		const row = toNodeRow(candidate({ packageVersion: undefined }));
+		expect(row.version).toBeNull();
+		expect(versionLabel(row)).toBe("version unknown");
+	});
+
+	it("marks which node is currently connected", () => {
+		const row = toNodeRow(candidate(), candidate().nodeId);
+		expect(row.connected).toBe(true);
+		expect(toNodeRow(candidate(), "someone-else").connected).toBe(false);
+	});
+
+	it("renders load as a clamped percentage", () => {
+		expect(toNodeRow(candidate({ utilization: 0 })).loadPercent).toBe(0);
+		expect(toNodeRow(candidate({ utilization: 0.5 })).loadPercent).toBe(50);
+		expect(toNodeRow(candidate({ utilization: 1 })).loadPercent).toBe(100);
+		expect(toNodeRow(candidate({ utilization: 2 })).loadPercent).toBe(100);
+		expect(toNodeRow(candidate({ utilization: -1 })).loadPercent).toBe(0);
+		expect(toNodeRow(candidate({ utilization: Number.NaN })).loadPercent).toBe(
+			0
+		);
+	});
+
+	it("lists the least loaded node first", () => {
+		const rows = buildNodeRows([
+			candidate({ nodeId: "c", name: "C", utilization: 0.9 }),
+			candidate({ nodeId: "a", name: "A", utilization: 0.1 }),
+			candidate({ nodeId: "b", name: "B", utilization: 0.5 }),
+		]);
+		expect(rows.map((row) => row.nodeId)).toEqual(["a", "b", "c"]);
+	});
+
+	it("orders ties stably so the list does not reshuffle", () => {
+		const rows = buildNodeRows([
+			candidate({ nodeId: "z", name: "Same", utilization: 0.2 }),
+			candidate({ nodeId: "a", name: "Same", utilization: 0.2 }),
+		]);
+		expect(rows.map((row) => row.nodeId)).toEqual(["a", "z"]);
+	});
+
+	it("summarises a node in one line", () => {
+		expect(nodeSummary(toNodeRow(candidate()))).toBe(
+			"v0.5.1 · linux · 1/8 sessions · 13% load"
+		);
+	});
+
+	it("keeps a pin that still matches an offered node", () => {
+		const rows = buildNodeRows([candidate({ nodeId: "keep" })]);
+		expect(resolvePreferredNode("keep", rows)).toBe("keep");
+	});
+
+	it("falls back to automatic when the pinned node is gone", () => {
+		// Otherwise the user would be stuck pointing at a node that no longer
+		// exists with no obvious way back.
+		const rows = buildNodeRows([candidate({ nodeId: "present" })]);
+		expect(resolvePreferredNode("vanished", rows)).toBe(AUTOMATIC_NODE);
+		expect(resolvePreferredNode("", rows)).toBe(AUTOMATIC_NODE);
+	});
+});

package/source/packages/chrome/src/pages/nodes.ts

@@ -0,0 +1,108 @@
+/**
+ * The parts of a tracker candidate this page renders. Declared structurally so
+ * the settings page does not need a direct dependency on the tracker protocol
+ * package.
+ */
+export type CandidateNode = {
+	nodeId: string;
+	name: string;
+	activeSessions: number;
+	maxSessions: number;
+	utilization: number;
+	protocolVersion: string;
+	packageVersion?: string | undefined;
+	platform?: string | undefined;
+};
+
+/** A node as presented in Advanced settings. */
+export type NodeRow = {
+	nodeId: string;
+	name: string;
+	/** Node agent release, or null when the tracker does not report one. */
+	version: string | null;
+	platform: string | null;
+	activeSessions: number;
+	maxSessions: number;
+	/** 0-100, rounded, clamped. */
+	loadPercent: number;
+	protocolVersion: string;
+	connected: boolean;
+};
+
+/** Value used in the picker to mean "let the browser choose". */
+export const AUTOMATIC_NODE = "";
+
+function clampPercent(value: number): number {
+	if (!Number.isFinite(value)) return 0;
+	return Math.min(100, Math.max(0, Math.round(value * 100)));
+}
+
+export function toNodeRow(
+	candidate: CandidateNode,
+	connectedNodeId?: string
+): NodeRow {
+	return {
+		nodeId: candidate.nodeId,
+		name: candidate.name,
+		// Trackers predating version reporting simply omit it.
+		version: candidate.packageVersion ?? null,
+		platform: candidate.platform ?? null,
+		activeSessions: candidate.activeSessions,
+		maxSessions: candidate.maxSessions,
+		loadPercent: clampPercent(candidate.utilization),
+		protocolVersion: candidate.protocolVersion,
+		connected: candidate.nodeId === connectedNodeId,
+	};
+}
+
+/**
+ * Least loaded first, so the ordering matches how a node would be picked
+ * automatically. Ties fall back to name then id to keep the list from
+ * reshuffling between refreshes.
+ */
+export function sortNodeRows(rows: readonly NodeRow[]): NodeRow[] {
+	return [...rows].sort(
+		(left, right) =>
+			left.loadPercent - right.loadPercent ||
+			left.activeSessions - right.activeSessions ||
+			left.name.localeCompare(right.name) ||
+			left.nodeId.localeCompare(right.nodeId)
+	);
+}
+
+export function buildNodeRows(
+	candidates: readonly CandidateNode[],
+	connectedNodeId?: string
+): NodeRow[] {
+	return sortNodeRows(
+		candidates.map((candidate) => toNodeRow(candidate, connectedNodeId))
+	);
+}
+
+/** Version text for display, distinguishing "unknown" from a real version. */
+export function versionLabel(row: NodeRow): string {
+	return row.version === null ? "version unknown" : `v${row.version}`;
+}
+
+/** Short summary line shown under each node's name. */
+export function nodeSummary(row: NodeRow): string {
+	const parts = [versionLabel(row)];
+	if (row.platform) parts.push(row.platform);
+	parts.push(`${row.activeSessions}/${row.maxSessions} sessions`);
+	parts.push(`${row.loadPercent}% load`);
+	return parts.join(" · ");
+}
+
+/**
+ * Whether a saved preference still refers to a node the tracker is offering.
+ * A stale pin is treated as automatic rather than leaving the user stuck.
+ */
+export function resolvePreferredNode(
+	preferredNodeId: string,
+	rows: readonly NodeRow[]
+): string {
+	if (!preferredNodeId) return AUTOMATIC_NODE;
+	return rows.some((row) => row.nodeId === preferredNodeId)
+		? preferredNodeId
+		: AUTOMATIC_NODE;
+}

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.2",
+	"version": "6.1.0",
 	"description": "Tracker-discovered WebRTC transport for Roxxie Proxy U",
 	"type": "module",
 	"sideEffects": false,

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/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/tracker-protocol/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "roxxie-transports-tracker-protocol",
-	"version": "1.2.1",
+	"version": "1.3.0",
 	"description": "Browser-safe control-plane contracts for the Roxxie tracker, nodes, and browsers",
 	"type": "module",
 	"sideEffects": false,

package/source/packages/tracker-protocol/src/index.ts

@@ -109,6 +109,13 @@ export interface CandidateNode {
 	maxSessions: number;
 	utilization: number;
 	protocolVersion: string;
+	/**
+	 * Node agent release, surfaced so operators can see what each node runs.
+	 * Optional for compatibility with trackers that predate it.
+	 */
+	packageVersion?: string;
+	/** Operating system the node runs on, when the tracker reports it. */
+	platform?: string;
 	iceServers: RTCIceServerJSON[];
 }
 
@@ -668,6 +675,21 @@ export function assertBrowserServerMessage(
 						`candidates[${index}].utilization is invalid`
 					);
 				}
+				// Optional: older trackers omit these entirely.
+				if (candidate.packageVersion !== undefined) {
+					stringValue(
+						candidate.packageVersion,
+						`candidates[${index}].packageVersion`,
+						32
+					);
+				}
+				if (candidate.platform !== undefined) {
+					stringValue(
+						candidate.platform,
+						`candidates[${index}].platform`,
+						32
+					);
+				}
 				assertIceServers(
 					candidate.iceServers,
 					`candidates[${index}].iceServers`

package/source/pnpm-lock.yaml

@@ -341,7 +341,7 @@ importers:
         specifier: 6.0.1
         version: link:../adrift-protocol
       roxxie-transports-tracker-protocol:
-        specifier: 1.2.1
+        specifier: 1.3.0
         version: link:../tracker-protocol
       ws:
         specifier: 8.21.1

package/standalone.html

@@ -18,8 +18,8 @@
 		<div id="roxxie-browser"></div>
 		<script
 			defer
-			src="https://cdn.jsdelivr.net/npm/roxxie-proxy-u-prod@0.2.3/embed.js"
-			integrity="sha384-yu0TlvCJ9LcKoOG66anQWT/iHEz3uC7rUGLmaDZV9otcFcWsQ6EvX8y2GPuxFsOH"
+			src="https://cdn.jsdelivr.net/npm/roxxie-proxy-u-prod@0.2.4/embed.js"
+			integrity="sha384-o6wwoyCvQbj3evNh2USZSUAOc625OxxX2yUnWs7o2i4NmKGhII4Y9SxvCG03OjAk"
 			crossorigin="anonymous"
 			data-roxxie-target="#roxxie-browser"
 		></script>