@oh-my-pi/pi-coding-agent 16.1.7 → 16.1.9

package/src/tools/puppeteer/03_stealth_botd.txt

@@ -1,15 +1,3 @@
-const makeNativeString = (name) => "function " + (name || "") + "() { [native code] }";
-const patchToString = (fn, name) => {
-	if (typeof fn !== "function") return;
-	Object_defineProperty(fn, "toString", {
-		value: function toString() {
-			return makeNativeString(name);
-		},
-		writable: false,
-		configurable: true,
-		enumerable: false,
-	});
-};
 
 // Ensure navigator.webdriver behaves like real Chrome
 if (navigator.webdriver !== false && navigator.webdriver !== undefined) {
@@ -356,13 +344,19 @@ if (window.chrome && !("runtime" in window.chrome) && isSecureOrigin) {
 // Suppress Permission.query for automation-controlled
 if (navigator.permissions?.query) {
 	if (isSecureOrigin && "Notification" in window) {
+		const notificationPermissionGetter = Object_getOwnPropertyDescriptor({
+			get permission() {
+				return "default";
+			},
+		}, "permission").get;
+		patchToString(notificationPermissionGetter, "get permission");
 		Object_defineProperty(Notification, "permission", {
-			get: () => "default",
+			get: notificationPermissionGetter,
 			configurable: true,
 		});
 	} else if (!isSecureOrigin) {
 		const originalQuery = navigator.permissions.query;
-		navigator.permissions.query = function (parameters) {
+		const patchedPermissionsQuery = function query(parameters) {
 			if (parameters?.name === "notifications") {
 			const status = { state: "denied", onchange: null };
 			if (typeof PermissionStatus !== "undefined") {
@@ -372,6 +366,8 @@ if (navigator.permissions?.query) {
 			}
 			return originalQuery.call(this, parameters);
 		};
+		patchToString(patchedPermissionsQuery, "query");
+		navigator.permissions.query = patchedPermissionsQuery;
 	}
 }
 

package/src/tools/puppeteer/04_stealth_iframe.txt

@@ -1,81 +1,174 @@
+const iframeWindowProxies = new WeakMap();
+
+const isFrameIndexKey = (key) => {
+	if (typeof key !== "string" || key === "") return false;
+	const number = +key;
+	return number >= 0 && number < 4294967295 && Math_floor(number) === number && `${number}` === key;
+};
+
+const getPropertyDescriptor = (object, key) => {
+	let current = object;
+	while (current) {
+		const descriptor = Object_getOwnPropertyDescriptor(current, key);
+		if (descriptor) return descriptor;
+		current = Object_getPrototypeOf(current);
+	}
+};
+
+const descriptorWithValue = (target, key, value, writable) => {
+	const descriptor = Reflect_getOwnPropertyDescriptor(target, key);
+	if (descriptor && descriptor.configurable === false) return descriptor;
+	const next = descriptor ? Object_assign({}, descriptor) : { configurable: true, enumerable: true };
+	Reflect_deleteProperty(next, "get");
+	Reflect_deleteProperty(next, "set");
+	next.value = value;
+	if (!Reflect_has(next, "writable")) next.writable = writable;
+	return next;
+};
+const iframeContentWindowDescriptor =
+	typeof HTMLIFrameElement === "undefined"
+		? undefined
+		: getPropertyDescriptor(HTMLIFrameElement.prototype, "contentWindow");
+const iframeSrcdocDescriptor =
+	typeof HTMLIFrameElement === "undefined"
+		? undefined
+		: getPropertyDescriptor(HTMLIFrameElement.prototype, "srcdoc");
+
+const getNativeContentWindow = (iframe) => {
+	if (iframeContentWindowDescriptor && iframeContentWindowDescriptor.get) {
+		return Reflect_apply(iframeContentWindowDescriptor.get, iframe, []);
+	}
+	return undefined;
+};
+
 const addContentWindowProxy = (iframe) => {
+	let state = Reflect_apply(Page_WeakMap_get, iframeWindowProxies, [iframe]);
+	if (state) return state.proxy;
+
+	state = { proxy: undefined, target: undefined, wasConnected: false, setProxyTarget: undefined };
+
+	const isDiscarded = () => {
+		if (iframe.isConnected) state.wasConnected = true;
+		return state.wasConnected && !iframe.isConnected;
+	};
+
+	const currentFrameElement = () => {
+		if (iframe.isConnected) {
+			state.wasConnected = true;
+			return iframe;
+		}
+		return state.wasConnected ? null : iframe;
+	};
+
 	const contentWindowProxy = {
 		get(target, key) {
-			if (key === "self") return this;
-			if (key === "frameElement") return iframe;
-			if (key === "0") return undefined;
+			if (key === "self" || key === "window" || key === "frames" || key === "globalThis") return state.proxy;
+			if (key === "frameElement") return currentFrameElement();
+			if (key === "closed" && isDiscarded()) return true;
+			if (isFrameIndexKey(key)) return undefined;
+			if (key === "length") return 0;
 			return Reflect_get(target, key);
 		},
+		getOwnPropertyDescriptor(target, key) {
+			if (key === "self" || key === "window" || key === "frames" || key === "globalThis") {
+				return descriptorWithValue(target, key, state.proxy, true);
+			}
+			if (key === "frameElement") {
+				return descriptorWithValue(target, key, currentFrameElement(), false);
+			}
+			if (key === "closed" && isDiscarded()) {
+				return descriptorWithValue(target, key, true, false);
+			}
+			if (isFrameIndexKey(key)) return undefined;
+			if (key === "length") return descriptorWithValue(target, key, 0, false);
+			return Reflect_getOwnPropertyDescriptor(target, key);
+		},
+		has(target, key) {
+			if (key === "self" || key === "window" || key === "frames" || key === "globalThis" || key === "frameElement") return true;
+			if (isFrameIndexKey(key)) return false;
+			return Reflect_has(target, key);
+		},
+		ownKeys(target) {
+			const keys = Reflect_ownKeys(target);
+			const filtered = [];
+			for (let index = 0; index < keys.length; index++) {
+				if (!isFrameIndexKey(keys[index])) filtered.push(keys[index]);
+			}
+			return filtered;
+		},
 	};
 
-	if (!iframe.contentWindow) {
-		const proxy = new Window_Proxy(window, contentWindowProxy);
-		Object_defineProperty(iframe, "contentWindow", {
-			get() {
-				return proxy;
-			},
-			set(newValue) {
-				return newValue;
-			},
-			enumerable: true,
-			configurable: false,
-		});
-	}
-};
+	const setProxyTarget = (target) => {
+		if (state.target === target && state.proxy) return state.proxy;
+		state.target = target;
+		state.proxy = new Window_Proxy(target, contentWindowProxy);
+		return state.proxy;
+	};
+	state.setProxyTarget = setProxyTarget;
+	const initialContentWindow = getNativeContentWindow(iframe);
+	if (initialContentWindow) setProxyTarget(initialContentWindow);
+	if (iframe.isConnected) state.wasConnected = true;
+	Reflect_apply(Page_WeakMap_set, iframeWindowProxies, [iframe, state]);
 
-const handleIframeCreation = (target, thisArg, args) => {
-	const iframe = Reflect_apply(target, thisArg, args);
-	const originalIframe = iframe;
-	const originalSrcdoc = originalIframe.srcdoc;
 
-	Object_defineProperty(iframe, "srcdoc", {
-		configurable: true,
-		get() {
-			return originalSrcdoc;
-		},
-		set(newValue) {
-			addContentWindowProxy(this);
-			Object_defineProperty(iframe, "srcdoc", {
-				configurable: false,
-				writable: false,
-				value: originalSrcdoc,
-			});
-			originalIframe.srcdoc = newValue;
+	return state.proxy;
+};
+if (
+	iframeContentWindowDescriptor &&
+	iframeContentWindowDescriptor.get &&
+	iframeContentWindowDescriptor.configurable !== false
+) {
+	const contentWindowAccessors = {
+		get contentWindow() {
+			const state = Reflect_apply(Page_WeakMap_get, iframeWindowProxies, [this]);
+			if (!state) return getNativeContentWindow(this);
+			if (this.isConnected) state.wasConnected = true;
+			if (state.wasConnected && !this.isConnected) return null;
+			const nativeContentWindow = getNativeContentWindow(this);
+			if (!nativeContentWindow) return nativeContentWindow;
+			return state.setProxyTarget(nativeContentWindow);
 		},
+	};
+	const contentWindowGetter = Object_getOwnPropertyDescriptor(contentWindowAccessors, "contentWindow").get;
+	patchToString(contentWindowGetter, "get contentWindow");
+	Object_defineProperty(HTMLIFrameElement.prototype, "contentWindow", {
+		get: contentWindowGetter,
+		set: iframeContentWindowDescriptor.set,
+		enumerable: iframeContentWindowDescriptor.enumerable,
+		configurable: iframeContentWindowDescriptor.configurable,
 	});
+}
 
-	return iframe;
-};
 
-const addIframeCreationSniffer = () => {
-	const originalCreateElement = document.createElement;
-	const handler = {
-		apply(target, thisArg, args) {
-			const isIframe = args && args.length && `${args[0]}`.toLowerCase() === "iframe";
-			if (!isIframe) {
-				return Reflect_apply(target, thisArg, args);
+if (
+	iframeSrcdocDescriptor &&
+	iframeSrcdocDescriptor.configurable !== false
+) {
+	const srcdocAccessors = {
+		get srcdoc() {
+			if (iframeSrcdocDescriptor.get) {
+				return Reflect_apply(iframeSrcdocDescriptor.get, this, []);
 			}
-			return handleIframeCreation(target, thisArg, args);
+			const value = this.getAttribute("srcdoc");
+			return value === null ? "" : value;
 		},
-		get(target, key) {
-			return Reflect_get(target, key);
+		set srcdoc(newValue) {
+			addContentWindowProxy(this);
+			if (iframeSrcdocDescriptor.set) {
+				return Reflect_apply(iframeSrcdocDescriptor.set, this, [newValue]);
+			}
+			return this.setAttribute("srcdoc", newValue);
 		},
 	};
-
-	const proxied = new Window_Proxy(originalCreateElement, handler);
-	Object_defineProperty(document, "createElement", {
-		value: proxied,
-		writable: true,
-		configurable: true,
-	});
-	Object_defineProperty(document.createElement, "toString", {
-		value: Function_toString.bind(originalCreateElement),
-		writable: false,
-		configurable: true,
-		enumerable: false,
+	const srcdocDescriptor = Object_getOwnPropertyDescriptor(srcdocAccessors, "srcdoc");
+	const srcdocGetter = srcdocDescriptor.get;
+	const srcdocSetter = srcdocDescriptor.set;
+	patchToString(srcdocGetter, "get srcdoc");
+	patchToString(srcdocSetter, "set srcdoc");
+	Object_defineProperty(HTMLIFrameElement.prototype, "srcdoc", {
+		get: srcdocGetter,
+		set: srcdocSetter,
+		enumerable: iframeSrcdocDescriptor.enumerable,
+		configurable: iframeSrcdocDescriptor.configurable,
 	});
-};
-
-try {
-	addIframeCreationSniffer();
-} catch {}
+}

package/src/tools/puppeteer/05_stealth_webgl.txt

@@ -1,75 +1,233 @@
-const vendors = ["Intel Inc.", "NVIDIA Corporation", "AMD"];
-const renderers = [
-  "Intel(R) Iris(TM) Plus Graphics 640",
-  "Intel(R) HD Graphics 630",
-  "NVIDIA GeForce GTX 1050 Ti",
-  "NVIDIA GeForce GTX 1060",
-  "NVIDIA GeForce RTX 3060",
-  "AMD Radeon RX 580",
-  "AMD Radeon Pro 560",
-];
-const vendor = vendors[Math_floor(Math_random() * vendors.length)];
-const renderer = renderers[Math_floor(Math_random() * renderers.length)];
-
-const getParameterProxyHandler = {
-  apply(target, thisArg, args) {
-    const param = args[0];
-    // VENDOR = 0x1F00
-    if (param === 0x1F00) return vendor;
-    // RENDERER = 0x1F01
-    if (param === 0x1F01) return renderer;
-    // UNMASKED_VENDOR_WEBGL = 0x9245
-    if (param === 0x9245) return vendor;
-    // UNMASKED_RENDERER_WEBGL = 0x9246
-    if (param === 0x9246) return renderer;
-	    return Reflect_apply(target, thisArg, args);
-  },
+const webglPlatformSource =
+	String(navigator.userAgentData?.platform || navigator.platform || "") +
+	" " +
+	String(navigator.userAgent || "");
+const webglPlatformText = webglPlatformSource.toLowerCase();
+const webglPlatformKind = webglPlatformText.includes("android")
+	? "android"
+	: webglPlatformText.includes("iphone") ||
+		  webglPlatformText.includes("ipad") ||
+		  webglPlatformText.includes("ipod")
+		? "ios"
+		: webglPlatformText.includes("mac")
+			? "mac"
+			: webglPlatformText.includes("win")
+				? "windows"
+				: webglPlatformText.includes("cros")
+					? "cros"
+					: "linux";
+
+const webglFallbackProfiles = {
+	android: {
+		vendor: "Qualcomm",
+		renderer: "Adreno (TM) 640",
+	},
+	ios: {
+		vendor: "Apple Inc.",
+		renderer: "Apple GPU",
+	},
+	mac: {
+		vendor: "Google Inc. (Intel Inc.)",
+		renderer: "ANGLE (Intel Inc., Intel(R) Iris(TM) Plus Graphics 640 OpenGL Engine, OpenGL 4.1)",
+	},
+	windows: {
+		vendor: "Google Inc. (Intel)",
+		renderer: "ANGLE (Intel, Intel(R) UHD Graphics 620 Direct3D11 vs_5_0 ps_5_0, D3D11)",
+	},
+	cros: {
+		vendor: "Google Inc. (Intel)",
+		renderer: "ANGLE (Intel, Mesa Intel(R) UHD Graphics 620 (KBL GT2), OpenGL 4.6)",
+	},
+	linux: {
+		vendor: "Google Inc. (Intel)",
+		renderer: "ANGLE (Intel, Mesa Intel(R) UHD Graphics 620 (KBL GT2), OpenGL 4.6)",
+	},
 };
+const webglFallbackProfile = webglFallbackProfiles[webglPlatformKind] || webglFallbackProfiles.linux;
+const webglContextProfiles = new WeakMap();
+const webglIsObjectKey = (value) =>
+	(typeof value === "object" && value !== null) || typeof value === "function";
 
-// Hook WebGL contexts
-const hookWebGL = (proto) => {
-  const originalGetParameter = proto.getParameter;
-  Object_defineProperty(proto, "getParameter", {
-    value: new Window_Proxy(originalGetParameter, getParameterProxyHandler),
-    writable: true,
-    configurable: true,
-    enumerable: true,
-  });
+const webglLooksSoftware = (value) => {
+	const text = String(value || "").toLowerCase();
+	return (
+		text.includes("swiftshader") ||
+		text.includes("llvmpipe") ||
+		text.includes("lavapipe") ||
+		text.includes("software") ||
+		text.includes("mesa offscreen") ||
+		text.includes("google inc. (google)")
+	);
 };
 
-if (window.WebGLRenderingContext) {
-  hookWebGL(WebGLRenderingContext.prototype);
-}
-if (window.WebGL2RenderingContext) {
-  hookWebGL(WebGL2RenderingContext.prototype);
-}
+const webglMatchesPlatform = (renderer) => {
+	const text = String(renderer || "").toLowerCase();
+	if (webglPlatformKind === "windows") {
+		return !text.includes("apple") && !text.includes("mesa") && !text.includes("opengl engine");
+	}
+	if (webglPlatformKind === "mac") {
+		return !text.includes("direct3d") && !text.includes("d3d") && !text.includes("mesa");
+	}
+	if (webglPlatformKind === "android") {
+		return (
+			text.includes("adreno") ||
+			text.includes("mali") ||
+			text.includes("powervr") ||
+			text.includes("qualcomm")
+		);
+	}
+	if (webglPlatformKind === "ios") {
+		return text.includes("apple");
+	}
+	return !text.includes("direct3d") && !text.includes("d3d") && !text.includes("apple");
+};
+
+const webglGetContextProfile = (target, thisArg) => {
+	if (!webglIsObjectKey(thisArg)) return webglFallbackProfile;
+	const cached = Reflect_apply(Page_WeakMap_get, webglContextProfiles, [thisArg]);
+	if (cached) return cached;
+
+	let nativeVendor;
+	let nativeRenderer;
+	try {
+		nativeVendor = Reflect_apply(target, thisArg, [0x9245]);
+		nativeRenderer = Reflect_apply(target, thisArg, [0x9246]);
+	} catch {}
+
+	const nativeProfile =
+		typeof nativeVendor === "string" &&
+		typeof nativeRenderer === "string" &&
+		nativeVendor &&
+		nativeRenderer &&
+		!webglLooksSoftware(nativeVendor) &&
+		!webglLooksSoftware(nativeRenderer) &&
+		webglMatchesPlatform(nativeRenderer)
+			? { vendor: nativeVendor, renderer: nativeRenderer }
+			: webglFallbackProfile;
+
+	Reflect_apply(Page_WeakMap_set, webglContextProfiles, [thisArg, nativeProfile]);
+	return nativeProfile;
+};
+
+const webglGetParameterHandler = {
+	apply(target, thisArg, args) {
+		const nativeValue = Reflect_apply(target, thisArg, args);
+		const param = args[0];
+		if (param === 0x1f00 && typeof nativeValue === "string") return "WebKit";
+		if (param === 0x1f01 && typeof nativeValue === "string") return "WebKit WebGL";
+		if ((param === 0x9245 || param === 0x9246) && typeof nativeValue === "string") {
+			const profile = webglGetContextProfile(target, thisArg);
+			return param === 0x9245 ? profile.vendor : profile.renderer;
+		}
+		return nativeValue;
+	},
+};
+
+const webglFloatPrecisionTypes = {
+	0x8df0: true,
+	0x8df1: true,
+	0x8df2: true,
+};
+
+const webglClonePrecisionFormat = (result, values) => {
+	const ownKeys = Reflect_ownKeys(result);
+	let hasRangeMin = false;
+	let hasRangeMax = false;
+	let hasPrecision = false;
+	for (let index = 0; index < ownKeys.length; index += 1) {
+		if (ownKeys[index] === "rangeMin") hasRangeMin = true;
+		if (ownKeys[index] === "rangeMax") hasRangeMax = true;
+		if (ownKeys[index] === "precision") hasPrecision = true;
+	}
+	if (!hasRangeMin || !hasRangeMax || !hasPrecision) return result;
+
+	const clone = Object_create(Object_getPrototypeOf(result));
+	for (let index = 0; index < ownKeys.length; index += 1) {
+		const key = ownKeys[index];
+		const descriptor = Object_getOwnPropertyDescriptor(result, key);
+		if (!descriptor) return result;
+		if (key === "rangeMin" || key === "rangeMax" || key === "precision") {
+			if (!("value" in descriptor)) return result;
+			descriptor.value = values[key];
+		}
+		try {
+			Object_defineProperty(clone, key, descriptor);
+		} catch {
+			return result;
+		}
+	}
+	return clone;
+};
+
+const webglGetShaderPrecisionFormatHandler = {
+	apply(target, thisArg, args) {
+		const result = Reflect_apply(target, thisArg, args);
+		const precisionType = args[1];
+		if (
+			!result ||
+			webglPlatformKind === "android" ||
+			webglPlatformKind === "ios" ||
+			!webglFloatPrecisionTypes[precisionType]
+		) {
+			return result;
+		}
+
+		const rangeMin = result.rangeMin;
+		const rangeMax = result.rangeMax;
+		const precision = result.precision;
+		if (
+			typeof rangeMin !== "number" ||
+			typeof rangeMax !== "number" ||
+			typeof precision !== "number"
+		) {
+			return result;
+		}
+
+		const values = {
+			rangeMin: Math_max(rangeMin, 127),
+			rangeMax: Math_max(rangeMax, 127),
+			precision: Math_max(precision, 23),
+		};
+		if (
+			values.rangeMin === rangeMin &&
+			values.rangeMax === rangeMax &&
+			values.precision === precision
+		) {
+			return result;
+		}
+		return webglClonePrecisionFormat(result, values);
+	},
+};
 
-// Also mask getShaderPrecisionFormat for software rendering detection
-const precisionMask = (proto) => {
-  const original = proto.getShaderPrecisionFormat;
-  if (!original) return;
-  Object_defineProperty(proto, "getShaderPrecisionFormat", {
-    value: function (shaderType, precisionType) {
-      const result = original.call(this, shaderType, precisionType);
-      if (result) {
-        // Hardware typically has higher precision than SwiftShader defaults
-        return {
-          precision: Math_max(result.precision, 23),
-          rangeMin: Math_min(result.rangeMin, 127),
-          rangeMax: Math_max(result.rangeMax, 127),
-        };
-      }
-      return result;
-    },
-    writable: true,
-    configurable: true,
-    enumerable: true,
-  });
+const webglInstallMethodProxy = (proto, name, handler) => {
+	if (!proto) return;
+	const descriptor = Object_getOwnPropertyDescriptor(proto, name);
+	if (!descriptor || typeof descriptor.value !== "function") return;
+	const proxy = new Window_Proxy(descriptor.value, handler);
+	patchToString(proxy, name);
+	try {
+		Object_defineProperty(proto, name, {
+			value: proxy,
+			writable: descriptor.writable,
+			configurable: descriptor.configurable,
+			enumerable: descriptor.enumerable,
+		});
+	} catch {}
 };
 
 if (window.WebGLRenderingContext) {
-  precisionMask(WebGLRenderingContext.prototype);
+	webglInstallMethodProxy(WebGLRenderingContext.prototype, "getParameter", webglGetParameterHandler);
+	webglInstallMethodProxy(
+		WebGLRenderingContext.prototype,
+		"getShaderPrecisionFormat",
+		webglGetShaderPrecisionFormatHandler,
+	);
 }
 if (window.WebGL2RenderingContext) {
-  precisionMask(WebGL2RenderingContext.prototype);
+	webglInstallMethodProxy(WebGL2RenderingContext.prototype, "getParameter", webglGetParameterHandler);
+	webglInstallMethodProxy(
+		WebGL2RenderingContext.prototype,
+		"getShaderPrecisionFormat",
+		webglGetShaderPrecisionFormatHandler,
+	);
 }