roxxie-proxy-u-prod 0.1.0

package/source/external/dreamlandjs/tsconfig.json

@@ -0,0 +1,15 @@
+{
+	"compilerOptions": {
+		"lib": ["ES2022", "dom", "dom.iterable"],
+		"target": "ES2022",
+		"declaration": true,
+		"declarationDir": "dist/types",
+		"rootDir": "src",
+		"moduleResolution": "bundler",
+		"stripInternal": true,
+		"strict": true,
+		"allowUnusedLabels": true
+	},
+	"include": ["src"],
+	"exclude": ["dist"]
+}

package/source/package.json

@@ -0,0 +1,48 @@
+{
+	"name": "roxxie-proxy-u",
+	"version": "0.1.0",
+	"description": "A static-hostable browser proxy with tracker-rendezvoused WebRTC exit nodes.",
+	"type": "module",
+	"keywords": [],
+	"author": "",
+	"license": "AGPL-3.0-only",
+	"packageManager": "pnpm@10.12.1",
+	"scripts": {
+		"build": "rspack build",
+		"build:protocol": "pnpm --filter roxxie-transports-adrift-protocol build",
+		"build:tracker-protocol": "pnpm --filter roxxie-transports-tracker-protocol build",
+		"build:transport": "pnpm --filter roxxie-transports build",
+		"build:node": "pnpm --filter roxxie-transports-node build",
+		"build:tracker": "pnpm --filter roxxie-transports-tracker build",
+		"build:dreamland": "cd external/dreamlandjs && pnpm build",
+		"build:chrome": "cd packages/chrome && pnpm build",
+		"build:static": "pnpm build:protocol && pnpm build:tracker-protocol && pnpm build:transport && pnpm build:dreamland && pnpm rewriter:build && CI=1 SKIP_DECLARATIONS=1 pnpm build && VITE_ISOLATION_ORIGIN=none VITE_SINGLEFILE=1 VITE_SOURCEMAP=0 pnpm --dir packages/chrome exec vite build --outDir ../../dist/static --emptyOutDir",
+		"build:all": "pnpm build:static && pnpm build:node && pnpm build:tracker",
+		"rewriter:build": "cd packages/scramjet/packages/core && pnpm run rewriter:build",
+		"test:roxxie": "pnpm --filter roxxie-transports-adrift-protocol test && pnpm --filter roxxie-transports-tracker-protocol test && pnpm --filter roxxie-transports test && pnpm --filter roxxie-transports-node test && pnpm --filter roxxie-transports-tracker test && pnpm --dir packages/chrome test:adblock",
+		"dev": "node --no-warnings=ExperimentalWarning devserver.ts",
+		"eslint": "node scripts/eslint-cli.mjs",
+		"lint": "pnpm eslint .",
+		"watch": "rspack build --watch",
+		"format": "prettier --write .",
+		"preinstall": "npx only-allow pnpm",
+		"ii": "pnpm install"
+	},
+	"devDependencies": {
+		"@eslint/eslintrc": "^3.3.5",
+		"@eslint/js": "^10.0.1",
+		"@rsdoctor/rspack-plugin": "^1.4.0",
+		"@rspack/cli": "^1.5.8",
+		"@rspack/core": "^1.5.8",
+		"@typescript-eslint/eslint-plugin": "8.57.3-alpha.3",
+		"@typescript-eslint/parser": "8.57.3-alpha.3",
+		"bufferutil": "^4.0.9",
+		"chafa-wasm": "^0.3.1",
+		"chalk": "^5.6.2",
+		"eslint": "^10.1.0",
+		"prettier": "^3.6.2",
+		"ts-checker-rspack-plugin": "^1.1.6",
+		"tsc-alias": "^1.8.16",
+		"vite": "^7.1.12"
+	}
+}

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

@@ -0,0 +1,31 @@
+{
+	"name": "roxxie-transports-adrift-protocol",
+	"version": "6.0.0",
+	"description": "Browser-safe wire types and codecs for Roxxie Proxy U transports",
+	"type": "module",
+	"sideEffects": false,
+	"exports": {
+		".": {
+			"types": "./dist/src/index.d.ts",
+			"import": "./dist/src/index.js"
+		}
+	},
+	"files": [
+		"dist/src"
+	],
+	"scripts": {
+		"build": "tsc -p tsconfig.json",
+		"test": "npm run build && node --test dist/test/*.test.js"
+	},
+	"engines": {
+		"node": ">=20"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"license": "AGPL-3.0-only",
+	"devDependencies": {
+		"@types/node": "^20.0.0",
+		"typescript": "~5.9.3"
+	}
+}

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

@@ -0,0 +1,348 @@
+/**
+ * Version 6 removes the raw TCP surface and adds an application-level RTT
+ * probe. HTTP(S) requests and target-site WebSockets remain multiplexed over
+ * the selected WebRTC data channel.
+ */
+export const PROTOCOL_VERSION = "6.0";
+export const FRAME_HEADER_BYTES = 3;
+export const MAX_CHUNK_SIZE = 12 * 1024;
+export const MAX_DATA_CHANNEL_MESSAGE_BYTES = 256 * 1024;
+export const HEADER_LIMITS = Object.freeze({
+	maxEntries: 256,
+	maxNameBytes: 256,
+	maxValueBytes: 16 * 1024,
+	maxTotalBytes: 64 * 1024,
+});
+
+export const C2S_HELLO = "haiii ";
+export const S2C_HELLO_OK = ":3";
+export const S2C_HELLO_ERR = ":< ";
+
+export const C2SRequestTypes = {
+	HTTPRequestStart: 0,
+	HTTPRequestChunk: 1,
+	HTTPRequestEnd: 2,
+	WSOpen: 3,
+	WSClose: 4,
+	/** Single-frame compatibility operations for messages <= MAX_CHUNK_SIZE. */
+	WSSendText: 5,
+	WSSendBinary: 6,
+	WSTextStart: 7,
+	WSBinaryStart: 8,
+	WSDataChunk: 9,
+	WSDataEnd: 10,
+	HTTPRequestAbort: 11,
+	Ping: 12,
+} as const;
+
+export const S2CRequestTypes = {
+	HTTPResponseStart: 0,
+	HTTPResponseChunk: 1,
+	HTTPResponseEnd: 2,
+	WSOpen: 3,
+	WSClose: 4,
+	WSTextStart: 5,
+	WSBinaryStart: 6,
+	WSDataChunk: 7,
+	WSDataEnd: 8,
+	WSError: 9,
+	Pong: 10,
+} as const;
+
+export type ObjectValue<T> = T[keyof T];
+export type C2SRequestType = ObjectValue<typeof C2SRequestTypes>;
+export type S2CRequestType = ObjectValue<typeof S2CRequestTypes>;
+export type RequestType = C2SRequestType | S2CRequestType;
+
+/** Header names retain their original spelling and duplicate values stay ordered. */
+export type HeaderEntry = readonly [name: string, value: string];
+export type HeaderList = readonly HeaderEntry[];
+
+export interface HTTPRequestPayload {
+	method: string;
+	requestHeaders: HeaderList;
+	remote: string;
+	hasBody: boolean;
+}
+
+export interface HTTPResponsePayload {
+	status: number;
+	statusText: string;
+	headers: HeaderList;
+}
+
+export interface C2SWSOpenPayload {
+	url: string;
+	protocols: string[];
+	requestHeaders: HeaderList;
+}
+
+export interface S2CWSOpenPayload {
+	protocol: string;
+	extensions: string;
+}
+
+export interface WSClosePayload {
+	code: number;
+	reason: string;
+	wasClean?: boolean;
+}
+
+export interface WSErrorPayload {
+	message: string;
+}
+
+export interface PingPayload {
+	nonce: string;
+}
+
+export interface SessionDescriptionJSON {
+	type: "offer" | "answer" | "pranswer" | "rollback";
+	sdp?: string;
+}
+
+export interface IceCandidateJSON {
+	candidate: string;
+	sdpMid?: string | null;
+	sdpMLineIndex?: number | null;
+	usernameFragment?: string | null;
+}
+
+export interface RTCIceServerJSON {
+	urls: string | string[];
+	username?: string;
+	credential?: string;
+}
+
+export interface WebRTCSessionOffer {
+	protocolVersion: typeof PROTOCOL_VERSION | string;
+	offer: SessionDescriptionJSON;
+	candidates: IceCandidateJSON[];
+}
+
+export interface WebRTCSessionAnswer {
+	protocolVersion: typeof PROTOCOL_VERSION | string;
+	sessionId: string;
+	answer: SessionDescriptionJSON;
+	candidates: IceCandidateJSON[];
+}
+
+/** Minimal binary interface implemented by the WebRTC data-channel transport. */
+export interface BinaryTransport {
+	ondata: (data: ArrayBuffer) => void;
+	onopen?: () => void;
+	onclose?: (reason?: unknown) => void;
+	send(data: ArrayBuffer): void | Promise<void>;
+	close(code?: number, reason?: string): void;
+}
+
+export interface DecodedFrame<TOperation extends number = number> {
+	sequence: number;
+	operation: TOperation;
+	payload: ArrayBuffer;
+}
+
+export class ProtocolError extends Error {
+	constructor(message: string) {
+		super(message);
+		this.name = "ProtocolError";
+	}
+}
+
+function bytesOf(data: ArrayBuffer | ArrayBufferView): Uint8Array {
+	if (ArrayBuffer.isView(data)) {
+		return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+	}
+	// Constructing a view works for ArrayBuffers from another browser realm,
+	// unlike an instanceof check against this realm's ArrayBuffer constructor.
+	return new Uint8Array(data);
+}
+
+function copiedBuffer(bytes: Uint8Array): ArrayBuffer {
+	const copy = new Uint8Array(bytes.byteLength);
+	copy.set(bytes);
+	return copy.buffer;
+}
+
+export function encodeFrame(
+	sequence: number,
+	operation: number,
+	payload?: ArrayBuffer | ArrayBufferView
+): ArrayBuffer {
+	if (!Number.isInteger(sequence) || sequence < 0 || sequence > 0xffff) {
+		throw new ProtocolError(
+			"Frame sequence must be an unsigned 16-bit integer"
+		);
+	}
+	if (!Number.isInteger(operation) || operation < 0 || operation > 0xff) {
+		throw new ProtocolError(
+			"Frame operation must be an unsigned 8-bit integer"
+		);
+	}
+
+	const payloadBytes = payload ? bytesOf(payload) : new Uint8Array(0);
+	const output = new Uint8Array(FRAME_HEADER_BYTES + payloadBytes.byteLength);
+	const view = new DataView(output.buffer);
+	view.setUint16(0, sequence);
+	view.setUint8(2, operation);
+	output.set(payloadBytes, FRAME_HEADER_BYTES);
+	return output.buffer;
+}
+
+export function decodeFrame<TOperation extends number = number>(
+	data: ArrayBuffer | ArrayBufferView
+): DecodedFrame<TOperation> {
+	const bytes = bytesOf(data);
+	if (bytes.byteLength < FRAME_HEADER_BYTES) {
+		throw new ProtocolError(
+			`Frame must contain at least ${FRAME_HEADER_BYTES} bytes`
+		);
+	}
+
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	return {
+		sequence: view.getUint16(0),
+		operation: view.getUint8(2) as TOperation,
+		payload: copiedBuffer(bytes.subarray(FRAME_HEADER_BYTES)),
+	};
+}
+
+const encoder = new TextEncoder();
+const decoder = new TextDecoder("utf-8", { fatal: true });
+
+export function encodeJSON(value: unknown): ArrayBuffer {
+	return copiedBuffer(encoder.encode(JSON.stringify(value)));
+}
+
+export function decodeJSON<T = unknown>(
+	data: ArrayBuffer | ArrayBufferView
+): T {
+	let text: string;
+	try {
+		text = decoder.decode(bytesOf(data));
+	} catch {
+		throw new ProtocolError("Payload is not valid UTF-8");
+	}
+	try {
+		return JSON.parse(text) as T;
+	} catch {
+		throw new ProtocolError("Payload is not valid JSON");
+	}
+}
+
+export function encodeJSONFrame(
+	sequence: number,
+	operation: number,
+	value: unknown
+): ArrayBuffer {
+	return encodeFrame(sequence, operation, encodeJSON(value));
+}
+
+export function encodeClientHello(version = PROTOCOL_VERSION): ArrayBuffer {
+	return copiedBuffer(encoder.encode(C2S_HELLO + version));
+}
+
+export function decodeText(data: ArrayBuffer | ArrayBufferView): string {
+	try {
+		return decoder.decode(bytesOf(data));
+	} catch {
+		throw new ProtocolError("Message is not valid UTF-8");
+	}
+}
+
+export function parseClientHello(data: ArrayBuffer | ArrayBufferView): string {
+	const hello = decodeText(data);
+	if (!hello.startsWith(C2S_HELLO)) {
+		throw new ProtocolError("Invalid client hello");
+	}
+	const version = hello.slice(C2S_HELLO.length);
+	if (version.length === 0) throw new ProtocolError("Missing protocol version");
+	return version;
+}
+
+export function encodeServerHelloOK(): ArrayBuffer {
+	return copiedBuffer(encoder.encode(S2C_HELLO_OK));
+}
+
+export function encodeServerHelloError(
+	expectedVersion = PROTOCOL_VERSION
+): ArrayBuffer {
+	return copiedBuffer(encoder.encode(S2C_HELLO_ERR + expectedVersion));
+}
+
+export function assertHeaderList(value: unknown): asserts value is HeaderList {
+	if (!Array.isArray(value))
+		throw new ProtocolError("Headers must be an array");
+	if (value.length > HEADER_LIMITS.maxEntries) {
+		throw new ProtocolError(
+			`Headers exceed the ${HEADER_LIMITS.maxEntries}-entry limit`
+		);
+	}
+	let totalBytes = 0;
+	for (const entry of value) {
+		if (
+			!Array.isArray(entry) ||
+			entry.length !== 2 ||
+			typeof entry[0] !== "string" ||
+			typeof entry[1] !== "string"
+		) {
+			throw new ProtocolError("Invalid header entry");
+		}
+		const [name, headerValue] = entry;
+		if (!/^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/u.test(name)) {
+			throw new ProtocolError("Invalid header name");
+		}
+		if (/[\0-\x08\x0a-\x1f\x7f]/u.test(headerValue)) {
+			throw new ProtocolError("Invalid header value");
+		}
+		if (name.length > HEADER_LIMITS.maxNameBytes) {
+			throw new ProtocolError("Header name exceeds the byte limit");
+		}
+		if (headerValue.length > HEADER_LIMITS.maxValueBytes) {
+			throw new ProtocolError("Header value exceeds the byte limit");
+		}
+		const nameBytes = encoder.encode(name).byteLength;
+		const valueBytes = encoder.encode(headerValue).byteLength;
+		if (nameBytes > HEADER_LIMITS.maxNameBytes) {
+			throw new ProtocolError("Header name exceeds the byte limit");
+		}
+		if (valueBytes > HEADER_LIMITS.maxValueBytes) {
+			throw new ProtocolError("Header value exceeds the byte limit");
+		}
+		// Include the bytes used by `: ` and CRLF in the aggregate wire budget.
+		totalBytes += nameBytes + valueBytes + 4;
+		if (totalBytes > HEADER_LIMITS.maxTotalBytes) {
+			throw new ProtocolError("Headers exceed the aggregate byte limit");
+		}
+	}
+}
+
+export function headerListToRecord(
+	headers: HeaderList
+): Record<string, string | string[]> {
+	assertHeaderList(headers);
+	const result: Record<string, string | string[]> = Object.create(
+		null
+	) as Record<string, string | string[]>;
+	for (const [rawName, value] of headers) {
+		const name = rawName.toLowerCase();
+		const previous = result[name];
+		if (previous === undefined) result[name] = value;
+		else if (Array.isArray(previous)) previous.push(value);
+		else result[name] = [previous, value];
+	}
+	return result;
+}
+
+export function recordToHeaderList(
+	headers: Readonly<Record<string, string | readonly string[] | undefined>>
+): HeaderEntry[] {
+	const result: HeaderEntry[] = [];
+	for (const [name, rawValue] of Object.entries(headers)) {
+		if (rawValue === undefined) continue;
+		const values = Array.isArray(rawValue) ? rawValue : [rawValue];
+		for (const value of values) result.push([name, value]);
+	}
+	assertHeaderList(result);
+	return result;
+}

package/source/packages/adrift-protocol/tsconfig.json

@@ -0,0 +1,18 @@
+{
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "NodeNext",
+		"moduleResolution": "NodeNext",
+		"lib": ["ES2022", "DOM"],
+		"rootDir": ".",
+		"outDir": "dist",
+		"declaration": true,
+		"declarationMap": true,
+		"sourceMap": true,
+		"strict": true,
+		"noUncheckedIndexedAccess": true,
+		"exactOptionalPropertyTypes": true,
+		"skipLibCheck": true
+	},
+	"include": ["src/**/*.ts", "test/**/*.ts"]
+}

package/source/packages/cdp/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020-present liriliri
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/source/packages/cdp/README.md

@@ -0,0 +1,47 @@
+# chobitsu
+
+[![NPM version][npm-image]][npm-url]
+[![Build status][ci-image]][ci-url]
+[![Test coverage][codecov-image]][codecov-url]
+[![License][license-image]][npm-url]
+
+[npm-image]: https://img.shields.io/npm/v/chobitsu?style=flat-square 
+[npm-url]: https://npmjs.org/package/chobitsu
+[ci-image]: https://img.shields.io/github/actions/workflow/status/liriliri/chobitsu/main.yml?branch=master&style=flat-square 
+[ci-url]: https://github.com/liriliri/chobitsu/actions/workflows/main.yml
+[codecov-image]: https://img.shields.io/codecov/c/github/liriliri/chobitsu?style=flat-square
+[codecov-url]: https://codecov.io/github/liriliri/chobitsu?branch=master
+[license-image]: https://img.shields.io/npm/l/chobitsu?style=flat-square
+
+[Chrome devtools protocol](https://chromedevtools.github.io/devtools-protocol/) JavaScript implementation.
+
+## Install
+
+You can get it on npm.
+
+```bash
+npm install chobitsu --save
+```
+
+## Usage
+
+```javascript
+const chobitsu = require('chobitsu');
+
+chobitsu.setOnMessage(message => {
+  console.log(message);
+});
+
+chobitsu.sendRawMessage(JSON.stringify({
+  id: 1,  
+  method: 'DOMStorage.clear',
+  params: {
+    storageId: {
+      isLocalStorage: true,
+      securityOrigin: 'http://example.com'
+    }
+  }
+}));
+```
+
+For more detailed usage instructions, please read the documentation at [chii.liriliri.io](https://chii.liriliri.io/docs/chobitsu.html)!