roxxie-proxy-u-prod 0.1.0

package/source/packages/chrome/src/reset.css

@@ -0,0 +1,124 @@
+html,
+body,
+div,
+span,
+applet,
+object,
+iframe,
+h1,
+h2,
+h3,
+h4,
+h5,
+h6,
+p,
+blockquote,
+pre,
+a,
+abbr,
+acronym,
+address,
+big,
+cite,
+code,
+del,
+dfn,
+em,
+img,
+ins,
+kbd,
+q,
+s,
+samp,
+small,
+strike,
+strong,
+sub,
+sup,
+tt,
+var,
+b,
+u,
+i,
+center,
+dl,
+dt,
+dd,
+ol,
+ul,
+li,
+fieldset,
+form,
+label,
+legend,
+table,
+caption,
+tbody,
+tfoot,
+thead,
+tr,
+th,
+td,
+article,
+aside,
+canvas,
+details,
+embed,
+figure,
+figcaption,
+footer,
+header,
+hgroup,
+menu,
+nav,
+output,
+ruby,
+section,
+summary,
+time,
+mark,
+audio,
+video {
+	margin: 0;
+	padding: 0;
+	border: 0;
+	font-size: 100%;
+	font: inherit;
+	vertical-align: baseline;
+}
+/* HTML5 display-role reset for older browsers */
+article,
+aside,
+details,
+figcaption,
+figure,
+footer,
+header,
+hgroup,
+menu,
+nav,
+section {
+	display: block;
+}
+body {
+	line-height: 1;
+}
+ol,
+ul {
+	list-style: none;
+}
+blockquote,
+q {
+	quotes: none;
+}
+blockquote:before,
+blockquote:after,
+q:before,
+q:after {
+	content: "";
+	content: none;
+}
+table {
+	border-collapse: collapse;
+	border-spacing: 0;
+}

package/source/packages/chrome/src/runtime-base.ts

@@ -0,0 +1,16 @@
+/* SPDX-License-Identifier: AGPL-3.0-only */
+
+/**
+ * Static assets may be delivered by a CDN while configuration and service
+ * workers must remain on the application's own origin. Development and the
+ * standalone build use Vite's ordinary base URL; the production npm build
+ * supplies `/browser/` explicitly.
+ */
+export function runtimeBaseUrl(): URL {
+	const configuredBase = import.meta.env.VITE_RUNTIME_BASE?.trim();
+	return new URL(configuredBase || import.meta.env.BASE_URL, location.href);
+}
+
+export function runtimeAssetUrl(path: string): URL {
+	return new URL(path, runtimeBaseUrl());
+}

package/source/packages/chrome/src/sentry.tsx

@@ -0,0 +1,45 @@
+if (import.meta.env.VITE_PUTER_BRANDING) {
+	let promises = [];
+
+	let puterSdk = <script src="https://js.puter.com/v2/"></script>;
+	document.head.append(puterSdk);
+	promises.push(
+		new Promise<void>((res) => {
+			puterSdk.onload = () => res();
+		})
+	);
+
+	if (import.meta.env.VITE_SENTRY_URL) {
+		let sentrySdk = (
+			<script
+				src={import.meta.env.VITE_SENTRY_URL}
+				crossorigin="anonymous"
+			></script>
+		);
+		document.head.append(sentrySdk);
+		promises.push(
+			new Promise<void>((res, rej) => {
+				sentrySdk.onload = () => res();
+				sentrySdk.onerror = () => {
+					console.error("Error loading Sentry (adblocker?)");
+					res();
+				};
+			})
+		);
+	}
+	if (import.meta.env.VITE_PLAUSIBLE_URL) {
+		let plausibleSdk = (
+			<script
+				src={import.meta.env.VITE_PLAUSIBLE_URL}
+				crossorigin="anonymous"
+			></script>
+		);
+		document.head.append(plausibleSdk);
+		plausibleSdk.onload = () => {
+			// @ts-expect-error no types yet
+			plausible.init();
+		};
+	}
+
+	await Promise.all(promises);
+}

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

@@ -0,0 +1,136 @@
+import {
+	createState,
+	createDelegate,
+	type Delegate,
+	type Stateful,
+} from "dreamland/core";
+import type { RawDownload } from "../proxy/scramjet";
+import {
+	animateDownloadFly,
+	showDownloadsPopup,
+} from "../components/Omnibar/Omnibar";
+import { StatefulClass } from "../util/StatefulClass";
+
+export type DownloadEntry = {
+	url: string;
+	filename: string;
+	timestamp: number;
+	size: number;
+	id: string;
+	cancelled: boolean;
+
+	progress?: number;
+	progressbytes?: number;
+	paused?: boolean;
+	cancel?: Delegate<void>;
+	pause?: Delegate<void>;
+};
+
+export class DownloadsService extends StatefulClass {
+	sessionDownloadHistory: Stateful<DownloadEntry>[] = [];
+	globalDownloadHistory: Stateful<DownloadEntry>[] = [];
+	current: Stateful<DownloadEntry> | null = null;
+
+	async startDownload(download: RawDownload): Promise<Stateful<DownloadEntry>> {
+		let downloaded = 0;
+		animateDownloadFly();
+
+		let filename = download.filename;
+		if (!filename) {
+			let url = new URL(download.url);
+			filename =
+				decodeURIComponent(url.pathname.split("/").at(-1) || "") ||
+				url.hostname.replaceAll(".", "-");
+		}
+
+		let cancel = createDelegate<void>();
+		let pause = createDelegate<void>();
+
+		let entry: Stateful<DownloadEntry> = createState({
+			filename,
+			url: download.url,
+			size: download.length,
+			timestamp: Date.now(),
+			id: crypto.randomUUID(),
+			cancelled: false,
+
+			progress: 0,
+			progressbytes: 0,
+			paused: false,
+			cancel,
+			pause,
+		});
+		this.current = entry;
+		this.globalDownloadHistory = [entry, ...this.globalDownloadHistory];
+		this.sessionDownloadHistory = [entry, ...this.sessionDownloadHistory];
+
+		let resumeResolver: (() => void) | null = null;
+		const ac = new AbortController();
+
+		pause.listen(() => {
+			entry.paused = !entry.paused;
+			if (!entry.paused) {
+				resumeResolver?.();
+				resumeResolver = null;
+			}
+		});
+
+		cancel.listen(() => {
+			entry.cancelled = true;
+			ac.abort();
+		});
+
+		const pausableProgress = new TransformStream<Uint8Array, Uint8Array>({
+			async transform(chunk, controller) {
+				if (entry.paused)
+					await new Promise<void>((res) => (resumeResolver = res));
+				downloaded += chunk.byteLength;
+				entry.progressbytes = downloaded;
+				const progress = Math.min(
+					(download.length ? downloaded / download.length : 0) + 0.1,
+					1
+				);
+				entry.progress = progress;
+				controller.enqueue(chunk);
+			},
+		});
+
+		const streamnull = new WritableStream<Uint8Array>({
+			write() {},
+		});
+		if (!(download.body instanceof ReadableStream)) {
+			throw new TypeError("Download body is not a readable stream");
+		}
+
+		try {
+			await download.body
+				.pipeThrough(pausableProgress)
+				.pipeTo(streamnull, { signal: ac.signal });
+		} catch (err) {
+			if ((err as any)?.name !== "AbortError") throw err;
+		}
+		entry.cancel = undefined;
+		entry.pause = undefined;
+		entry.progress = undefined;
+		entry.progressbytes = undefined;
+		entry.paused = false;
+		showDownloadsPopup();
+		setTimeout(() => {
+			this.current = null;
+		}, 1000);
+
+		return entry;
+	}
+
+	pauseDownload(): void {
+		if (this.current) {
+			this.current.pause!();
+		}
+	}
+
+	cancelDownload(): void {
+		if (this.current) {
+			this.current.cancel!();
+		}
+	}
+}

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

@@ -0,0 +1,161 @@
+import * as tldts from "tldts";
+import { FAVICON_CACHE_TTL } from "../consts";
+import { bare } from "../proxy/roxxie";
+import { Service } from "./Service";
+
+export type FaviconCacheEntry = {
+	domain: string;
+	iconUrl: string;
+	iconData: string;
+	timestamp: number;
+};
+
+export type FaviconServiceState = {
+	faviconCache: {
+		domain: string;
+		iconUrl: string;
+		iconData: string;
+		timestamp: number;
+	}[];
+};
+
+export class FaviconService extends Service {
+	private faviconCache: FaviconCacheEntry[] = [];
+	private pendingFaviconRequests: Record<
+		string,
+		Promise<FaviconCacheEntry | null> | null
+	> = {};
+
+	constructor(data: FaviconServiceState | null) {
+		super();
+		if (data) {
+			this.faviconCache = data.faviconCache.map((e) => ({
+				domain: e.domain,
+				iconUrl: e.iconUrl,
+				iconData: e.iconData,
+				timestamp: e.timestamp,
+			}));
+		} else {
+			this.faviconCache = [];
+		}
+	}
+
+	save(): FaviconServiceState {
+		return {
+			faviconCache: this.faviconCache.map((e) => ({
+				domain: e.domain,
+				iconUrl: e.iconUrl,
+				iconData: e.iconData,
+				timestamp: e.timestamp,
+			})),
+		};
+	}
+
+	getCachedFavicon(hostname: string): FaviconCacheEntry | null {
+		const entry = this.faviconCache.find((e) => e.domain === hostname);
+		if (entry && entry.timestamp > Date.now() - FAVICON_CACHE_TTL) {
+			return entry;
+		}
+		return null;
+	}
+
+	private async __fetchFavicon(
+		hostname: string
+	): Promise<FaviconCacheEntry | null> {
+		const toDataUrl = async (res: Response) => {
+			const blob = await res.blob();
+			const iconData = await new Promise<string>((resolve, reject) => {
+				const reader = new FileReader();
+				reader.onloadend = () => resolve(reader.result as string);
+				reader.onerror = reject;
+				reader.readAsDataURL(blob);
+			});
+			return iconData;
+		};
+
+		try {
+			// first do google favicon search
+			const url = `https://www.google.com/s2/favicons?domain=${hostname}`;
+			let res = await bare.fetch(url);
+			if (!res.ok) {
+				throw new Error(
+					`failed to fetch favicon from google: ${res.statusText}`
+				);
+			}
+			const iconData = await toDataUrl(res);
+			const entry: FaviconCacheEntry = {
+				domain: hostname,
+				iconUrl: url,
+				iconData,
+				timestamp: Date.now(),
+			};
+			// Update cache
+			this.faviconCache = this.faviconCache.filter(
+				(e) => e.domain !== hostname
+			);
+			this.faviconCache.push(entry);
+			return entry;
+		} catch (e) {
+			// console.error(e);
+		}
+
+		try {
+			// fall back to direct fetch
+			const url = `https://${hostname}/favicon.ico`;
+			let res = await bare.fetch(url);
+			if (!res.ok) {
+				throw new Error(`failed to fetch favicon from: ${res.statusText}`);
+			}
+			const iconData = await toDataUrl(res);
+			const entry: FaviconCacheEntry = {
+				domain: hostname,
+				iconUrl: url,
+				iconData,
+				timestamp: Date.now(),
+			};
+			// Update cache
+			this.faviconCache = this.faviconCache.filter(
+				(e) => e.domain !== hostname
+			);
+			this.faviconCache.push(entry);
+			return entry;
+		} catch (e) {
+			// console.error(e);
+		}
+
+		return null;
+	}
+
+	private async _fetchFavicon(
+		hostname: string
+	): Promise<FaviconCacheEntry | null> {
+		let entry = this.faviconCache.find((e) => e.domain === hostname);
+		if (entry) {
+			if (entry.timestamp > Date.now() - FAVICON_CACHE_TTL) {
+				return entry;
+			}
+			this.faviconCache = this.faviconCache.filter(
+				(e) => e.domain !== entry!.domain
+			);
+		}
+
+		const parsed = tldts.parse(hostname);
+		if (parsed.isIp || !parsed.isIcann || hostname === "localhost") {
+			// probably not a real domain, so don't try to fetch a favicon
+			return null;
+		}
+
+		return this.__fetchFavicon(hostname);
+	}
+
+	async fetchFavicon(hostname: string): Promise<FaviconCacheEntry | null> {
+		if (this.pendingFaviconRequests[hostname]) {
+			return this.pendingFaviconRequests[hostname]!;
+		}
+		let p = this._fetchFavicon(hostname);
+		this.pendingFaviconRequests[hostname] = p;
+		let result = await p;
+		this.pendingFaviconRequests[hostname] = null;
+		return result;
+	}
+}

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

@@ -0,0 +1,169 @@
+type KVType = "localstorage" | "puter";
+
+/**
+ * Smart JSON serializer that handles circular references.
+ * Uses a WeakMap to track visited objects and replaces circular references
+ * with unique reference IDs that can be reconstructed during parsing.
+ */
+function smartSerialize(value: any): string {
+	const visited = new WeakMap<object, number>();
+	let refCounter = 0;
+
+	function replacer(key: string, val: any): any {
+		if (val === null || typeof val !== "object") {
+			return val;
+		}
+
+		// Check for circular reference
+		if (visited.has(val)) {
+			const refId = visited.get(val)!;
+			return { __circular_ref__: refId };
+		}
+
+		// Track this object with a unique ID
+		const refId = refCounter++;
+		visited.set(val, refId);
+
+		return val;
+	}
+
+	try {
+		const serialized = JSON.stringify(value, replacer);
+		return serialized;
+	} catch (error) {
+		// Fallback to regular JSON.stringify if something goes wrong
+		return JSON.stringify(value);
+	}
+}
+
+/**
+ * Smart JSON parser that reconstructs circular references.
+ * Replaces circular reference placeholders with actual object references.
+ */
+function smartParse<T = any>(json: string): T {
+	const parsed = JSON.parse(json);
+
+	// First pass: collect all objects in DFS order to build reference map
+	const objects: any[] = [];
+	const visited = new WeakSet<object>();
+
+	function collectObjects(obj: any): void {
+		if (obj === null || typeof obj !== "object" || visited.has(obj)) {
+			return;
+		}
+
+		// Skip circular reference placeholders
+		if (obj.__circular_ref__ !== undefined && Object.keys(obj).length === 1) {
+			return;
+		}
+
+		visited.add(obj);
+		objects.push(obj);
+
+		if (Array.isArray(obj)) {
+			obj.forEach((item) => collectObjects(item));
+		} else {
+			for (const key in obj) {
+				if (obj.hasOwnProperty(key)) {
+					collectObjects(obj[key]);
+				}
+			}
+		}
+	}
+
+	collectObjects(parsed);
+
+	// Second pass: resolve circular references
+	function resolveRefs(
+		obj: any,
+		resolving: WeakSet<object> = new WeakSet()
+	): any {
+		if (obj === null || typeof obj !== "object") {
+			return obj;
+		}
+
+		// Handle circular reference placeholder
+		if (obj.__circular_ref__ !== undefined && Object.keys(obj).length === 1) {
+			const refId = obj.__circular_ref__;
+			return objects[refId] || obj;
+		}
+
+		// Avoid infinite loops during resolution
+		if (resolving.has(obj)) {
+			return obj;
+		}
+		resolving.add(obj);
+
+		if (Array.isArray(obj)) {
+			for (let i = 0; i < obj.length; i++) {
+				obj[i] = resolveRefs(obj[i], resolving);
+			}
+		} else {
+			for (const key in obj) {
+				if (obj.hasOwnProperty(key)) {
+					obj[key] = resolveRefs(obj[key], resolving);
+				}
+			}
+		}
+
+		resolving.delete(obj);
+		return obj;
+	}
+
+	return resolveRefs(parsed) as T;
+}
+
+export class KVWrapper {
+	prefix = "bjs-";
+	constructor(private type: KVType) {}
+
+	async rawget(key: string): Promise<string | null> {
+		if (this.type === "localstorage") {
+			return localStorage.getItem(this.prefix + key);
+		} else {
+			return await puter.kv.get(key);
+		}
+	}
+
+	async rawset(key: string, value: string): Promise<void> {
+		if (this.type === "localstorage") {
+			localStorage.setItem(this.prefix + key, value);
+		} else {
+			await puter.kv.set(key, value);
+		}
+	}
+
+	async remove(key: string): Promise<void> {
+		if (this.type === "localstorage") {
+			localStorage.removeItem(this.prefix + key);
+		} else {
+			await puter.kv.del(key);
+		}
+	}
+
+	async has(key: string): Promise<boolean> {
+		if (this.type === "localstorage") {
+			return localStorage.getItem(this.prefix + key) !== null;
+		} else {
+			return (await puter.kv.list(key)).length;
+		}
+	}
+
+	async get<T = any>(key: string): Promise<T | null> {
+		const value = await this.rawget(key);
+		if (value === null) {
+			return null;
+		}
+		try {
+			return smartParse<T>(value);
+		} catch (error) {
+			console.error(`Failed to parse JSON for key "${key}":`, error);
+			return null;
+		}
+	}
+
+	async set(key: string, value: any): Promise<void> {
+		const serialized = smartSerialize(value);
+		await this.rawset(key, serialized);
+	}
+}