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

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,
+	);
 }

package/src/tools/puppeteer/06_stealth_screen.txt

@@ -1,72 +1,260 @@
-// Generate consistent "real" screen dimensions based on viewport
-const width = window.innerWidth;
-const height = window.innerHeight;
-const availWidth = width;
-const availHeight = Math_max(height - 40, 0); // Account for taskbar
-const colorDepth = 24;
-const pixelDepth = 24;
-const devicePixelRatio = window.devicePixelRatio && window.devicePixelRatio > 1 ? window.devicePixelRatio : 1.25;
-
-const defineScreenProp = (prop, value) => {
-  try {
-    Object_defineProperty(window.Screen?.prototype ?? window.screen, prop, {
-      get: () => value,
-      configurable: true,
-      enumerable: true,
+;(() => {
+  if (typeof Window_Proxy !== "function" || typeof Reflect_apply !== "function") return;
+
+  const screenObject = window.screen;
+  if (!screenObject) return;
+
+  const isFiniteNumber = (value) =>
+    typeof value === "number" &&
+    value === value &&
+    value !== Infinity &&
+    value !== -Infinity;
+
+  const readValue = (object, prop, fallback) => {
+    try {
+      const value = object[prop];
+      return value === undefined ? fallback : value;
+    } catch {
+      return fallback;
+    }
+  };
+
+  const finiteNumber = (value, fallback) =>
+    isFiniteNumber(value) ? value : fallback;
+
+  const positiveNumber = (value, fallback) =>
+    isFiniteNumber(value) && value > 0 ? value : fallback;
+
+  const integerNumber = (value, fallback) =>
+    isFiniteNumber(value) ? Math_floor(value) : fallback;
+
+  const positiveInteger = (value, fallback) =>
+    isFiniteNumber(value) && value > 0 ? Math_floor(value) : fallback;
+
+  const findDescriptorOwner = (object, prop) => {
+    let owner = object;
+    while (owner) {
+      let descriptor;
+      try {
+        descriptor = Object_getOwnPropertyDescriptor(owner, prop);
+      } catch {
+        return undefined;
+      }
+      if (descriptor) return [owner, descriptor];
+      try {
+        owner = Object_getPrototypeOf(owner);
+      } catch {
+        return undefined;
+      }
+    }
+    return undefined;
+  };
+
+  const patchGetter = (object, prop, getValue) => {
+    const found = findDescriptorOwner(object, prop);
+    if (!found) return false;
+
+    const owner = found[0];
+    const descriptor = found[1];
+    if (descriptor.configurable !== true || typeof descriptor.get !== "function") {
+      return false;
+    }
+
+    const originalGet = descriptor.get;
+    const patchedGet = new Window_Proxy(originalGet, {
+      apply(target, thisArg, args) {
+        const nativeValue = Reflect_apply(target, thisArg, args);
+        return getValue(nativeValue, thisArg);
+      },
     });
-  } catch {}
-};
-
-// Override screen properties
-for (const [prop, descriptor] of Object_entries({
-  width,
-  height,
-  availWidth,
-  availHeight,
-  availLeft: 0,
-  availTop: 0,
-  colorDepth,
-  pixelDepth,
-})) {
-  defineScreenProp(prop, descriptor);
-}
-
-// Ensure outer dimensions match screen for consistency
-const chromeFrameHeight = 85;
-Object_defineProperty(window, "outerWidth", {
-  get: () => window.innerWidth,
-  configurable: true,
-  enumerable: true,
-});
-Object_defineProperty(window, "outerHeight", {
-  get: () => window.innerHeight + chromeFrameHeight,
-  configurable: true,
-  enumerable: true,
-});
-
-if (window.visualViewport) {
-  const defineVvpProp = (prop, value) => {
+    patchToString(patchedGet, "get " + prop);
     try {
-      Object_defineProperty(window.visualViewport, prop, {
-        get: () => value,
-        configurable: true,
-        enumerable: true,
+      Object_defineProperty(owner, prop, {
+        configurable: descriptor.configurable,
+        enumerable: descriptor.enumerable,
+        get: patchedGet,
+        set: descriptor.set,
       });
-    } catch {}
+      return true;
+    } catch {
+      return false;
+    }
   };
 
-  defineVvpProp("width", width);
-  defineVvpProp("height", height);
-  defineVvpProp("scale", 1);
-  defineVvpProp("offsetLeft", 0);
-  defineVvpProp("offsetTop", 0);
-  defineVvpProp("pageLeft", 0);
-  defineVvpProp("pageTop", 0);
-}
-
-// Consistent devicePixelRatio
-Object_defineProperty(window, "devicePixelRatio", {
-  get: () => devicePixelRatio,
-  configurable: true,
-  enumerable: true,
-});
+  const patchStableNumber = (object, prop, value) => {
+    const current = readValue(object, prop, undefined);
+    if (current === value) return;
+    patchGetter(object, prop, () => value);
+  };
+
+  const initialInnerWidth = positiveInteger(readValue(window, "innerWidth", 0), 0);
+  const initialInnerHeight = positiveInteger(readValue(window, "innerHeight", 0), 0);
+  const initialOuterWidth = positiveInteger(
+    readValue(window, "outerWidth", Math_max(initialInnerWidth, 1)),
+    Math_max(initialInnerWidth, 1),
+  );
+  const initialOuterHeight = positiveInteger(
+    readValue(window, "outerHeight", Math_max(initialInnerHeight, 1)),
+    Math_max(initialInnerHeight, 1),
+  );
+  // Real Chrome reserves vertical space for the tab strip + URL bar, so
+  // outerHeight is always taller than innerHeight (~88px on a stock window).
+  // Headless reports outerHeight === innerHeight, which is a well-known tell, so
+  // synthesize a realistic chrome height when the window has no visible chrome.
+  const browserChromeHeight = 88;
+  const targetOuterHeight =
+    initialOuterHeight > initialInnerHeight
+      ? initialOuterHeight
+      : initialInnerHeight + browserChromeHeight;
+  const requiredWidth = Math_max(initialInnerWidth, initialOuterWidth, 1);
+  const requiredHeight = Math_max(initialInnerHeight, initialOuterHeight, targetOuterHeight, 1);
+
+  const screenWidth = Math_max(
+    positiveInteger(readValue(screenObject, "width", requiredWidth), requiredWidth),
+    requiredWidth,
+  );
+  const screenHeight = Math_max(
+    positiveInteger(readValue(screenObject, "height", requiredHeight), requiredHeight),
+    requiredHeight,
+  );
+
+  let screenAvailWidth = positiveInteger(
+    readValue(screenObject, "availWidth", screenWidth),
+    screenWidth,
+  );
+  if (screenAvailWidth < requiredWidth || screenAvailWidth > screenWidth) {
+    screenAvailWidth = screenWidth;
+  }
+
+  let screenAvailHeight = positiveInteger(
+    readValue(screenObject, "availHeight", screenHeight),
+    screenHeight,
+  );
+  if (screenAvailHeight < requiredHeight || screenAvailHeight > screenHeight) {
+    screenAvailHeight = screenHeight;
+  }
+
+  const screenAvailLeft = integerNumber(readValue(screenObject, "availLeft", 0), 0);
+  const screenAvailTop = integerNumber(readValue(screenObject, "availTop", 0), 0);
+  const screenColorDepth = positiveInteger(readValue(screenObject, "colorDepth", 24), 24);
+  const screenPixelDepth = positiveInteger(
+    readValue(screenObject, "pixelDepth", screenColorDepth),
+    screenColorDepth,
+  );
+
+  for (const entry of [
+    ["width", screenWidth],
+    ["height", screenHeight],
+    ["availWidth", screenAvailWidth],
+    ["availHeight", screenAvailHeight],
+    ["availLeft", screenAvailLeft],
+    ["availTop", screenAvailTop],
+    ["colorDepth", screenColorDepth],
+    ["pixelDepth", screenPixelDepth],
+  ]) {
+    patchStableNumber(screenObject, entry[0], entry[1]);
+  }
+
+  const outerWidthNeedsPatch =
+    !isFiniteNumber(readValue(window, "outerWidth", undefined)) ||
+    readValue(window, "outerWidth", 0) <= 0 ||
+    Math_floor(readValue(window, "outerWidth", 0)) < initialInnerWidth;
+  if (outerWidthNeedsPatch) {
+    patchGetter(window, "outerWidth", (nativeValue) =>
+      Math_max(
+        positiveInteger(nativeValue, initialOuterWidth),
+        positiveInteger(readValue(window, "innerWidth", requiredWidth), requiredWidth),
+      ),
+    );
+  }
+
+  const outerHeightNeedsPatch =
+    !isFiniteNumber(readValue(window, "outerHeight", undefined)) ||
+    readValue(window, "outerHeight", 0) <= 0 ||
+    Math_floor(readValue(window, "outerHeight", 0)) <= initialInnerHeight;
+  if (outerHeightNeedsPatch) {
+    patchGetter(window, "outerHeight", (nativeValue) =>
+      Math_max(
+        positiveInteger(nativeValue, initialOuterHeight),
+        positiveInteger(readValue(window, "innerHeight", requiredHeight), requiredHeight) +
+          browserChromeHeight,
+      ),
+    );
+  }
+
+  const initialDevicePixelRatio = positiveNumber(
+    readValue(window, "devicePixelRatio", 1),
+    1,
+  );
+  if (readValue(window, "devicePixelRatio", undefined) !== initialDevicePixelRatio) {
+    patchGetter(window, "devicePixelRatio", () => initialDevicePixelRatio);
+  }
+
+  const visualViewportObject = readValue(window, "visualViewport", null);
+  if (visualViewportObject) {
+    const initialScale = positiveNumber(readValue(visualViewportObject, "scale", 1), 1);
+    if (readValue(visualViewportObject, "scale", undefined) !== initialScale) {
+      patchGetter(visualViewportObject, "scale", (nativeValue) =>
+        positiveNumber(nativeValue, initialScale),
+      );
+    }
+
+    const getViewportScale = () =>
+      positiveNumber(readValue(visualViewportObject, "scale", initialScale), initialScale);
+
+    const getViewportWidthFallback = () =>
+      positiveNumber(readValue(window, "innerWidth", requiredWidth), requiredWidth) /
+      getViewportScale();
+
+    const getViewportHeightFallback = () =>
+      positiveNumber(readValue(window, "innerHeight", requiredHeight), requiredHeight) /
+      getViewportScale();
+
+    if (positiveNumber(readValue(visualViewportObject, "width", 0), 0) <= 0) {
+      patchGetter(visualViewportObject, "width", (nativeValue) =>
+        positiveNumber(nativeValue, getViewportWidthFallback()),
+      );
+    }
+
+    if (positiveNumber(readValue(visualViewportObject, "height", 0), 0) <= 0) {
+      patchGetter(visualViewportObject, "height", (nativeValue) =>
+        positiveNumber(nativeValue, getViewportHeightFallback()),
+      );
+    }
+
+    const getViewportOffsetLeft = () =>
+      finiteNumber(readValue(visualViewportObject, "offsetLeft", 0), 0);
+    const getViewportOffsetTop = () =>
+      finiteNumber(readValue(visualViewportObject, "offsetTop", 0), 0);
+
+    if (!isFiniteNumber(readValue(visualViewportObject, "offsetLeft", undefined))) {
+      patchGetter(visualViewportObject, "offsetLeft", (nativeValue) =>
+        finiteNumber(nativeValue, 0),
+      );
+    }
+
+    if (!isFiniteNumber(readValue(visualViewportObject, "offsetTop", undefined))) {
+      patchGetter(visualViewportObject, "offsetTop", (nativeValue) =>
+        finiteNumber(nativeValue, 0),
+      );
+    }
+
+    if (!isFiniteNumber(readValue(visualViewportObject, "pageLeft", undefined))) {
+      patchGetter(visualViewportObject, "pageLeft", (nativeValue) =>
+        finiteNumber(
+          nativeValue,
+          finiteNumber(readValue(window, "scrollX", 0), 0) + getViewportOffsetLeft(),
+        ),
+      );
+    }
+
+    if (!isFiniteNumber(readValue(visualViewportObject, "pageTop", undefined))) {
+      patchGetter(visualViewportObject, "pageTop", (nativeValue) =>
+        finiteNumber(
+          nativeValue,
+          finiteNumber(readValue(window, "scrollY", 0), 0) + getViewportOffsetTop(),
+        ),
+      );
+    }
+  }
+})();