roxxie-proxy-u-prod 0.2.3 → 0.2.5

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
 		);