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

package/src/tools/puppeteer/01_stealth_activity.txt

@@ -1,20 +1,80 @@
-const scheduleActivity = () => {
-  const delay = 3000 + Math_random() * 4000;
-  Window_setTimeout(() => {
-    Object_defineProperty(document, "hidden", { get: () => false });
-    Object_defineProperty(document, "visibilityState", {
-      get: () => "visible",
+{
+  const visibilityDescriptors = Object_getOwnPropertyDescriptors({
+    get hidden() {
+      return false;
+    },
+    get visibilityState() {
+      return "visible";
+    },
+    get webkitHidden() {
+      return false;
+    },
+    get webkitVisibilityState() {
+      return "visible";
+    },
+  });
+  for (const key of Object_keys(visibilityDescriptors)) {
+    const descriptor = visibilityDescriptors[key];
+    if (descriptor && typeof descriptor.get === "function") {
+      patchToString(descriptor.get, "get " + key);
+    }
+  }
+  const focusDescriptor = Object_getOwnPropertyDescriptor(
+    {
+      hasFocus() {
+        return document.visibilityState === "visible";
+      },
+    },
+    "hasFocus",
+  );
+  if (focusDescriptor && typeof focusDescriptor.value === "function") {
+    patchToString(focusDescriptor.value, "hasFocus");
+  }
+
+  const clearOwnSlot = (name) => {
+    const ownDescriptor = Object_getOwnPropertyDescriptor(document, name);
+    if (!ownDescriptor) return true;
+    if (ownDescriptor.configurable !== true) return false;
+    return Reflect_deleteProperty(document, name);
+  };
+
+  const inheritedSlot = (name, expectedKind) => {
+    let proto = Object_getPrototypeOf(document);
+    while (proto) {
+      const descriptor = Object_getOwnPropertyDescriptor(proto, name);
+      if (descriptor && typeof descriptor[expectedKind] === "function") {
+        return [proto, descriptor];
+      }
+      proto = Object_getPrototypeOf(proto);
+    }
+  };
+
+  const defineAccessor = (name) => {
+    if (!clearOwnSlot(name)) return;
+    const slot = inheritedSlot(name, "get");
+    if (!slot || slot[1].configurable !== true) return;
+
+    Object_defineProperty(slot[0], name, {
+      get: visibilityDescriptors[name].get,
+      enumerable: slot[1].enumerable,
+      configurable: true,
     });
-    Object_defineProperty(document, "webkitVisibilityState", {
-      get: () => "visible",
-    });
-    document.dispatchEvent(new Window_Event("visibilitychange"));
-    if (Math_random() < 0.4) window.dispatchEvent(new Window_Event("focus"));
-    document.hasFocus = () => true;
-    if (Math_random() < 0.3) window.dispatchEvent(new Window_Event("scroll"));
-    if (navigator.wakeLock)
-      navigator.wakeLock.request("screen").catch(() => {});
-    scheduleActivity();
-  }, delay);
-};
-scheduleActivity();
+  };
+
+  defineAccessor("hidden");
+  defineAccessor("visibilityState");
+  defineAccessor("webkitHidden");
+  defineAccessor("webkitVisibilityState");
+
+  if (clearOwnSlot("hasFocus")) {
+    const slot = inheritedSlot("hasFocus", "value");
+    if (slot && slot[1].configurable === true) {
+      Object_defineProperty(slot[0], "hasFocus", {
+        value: focusDescriptor.value,
+        writable: slot[1].writable === true,
+        enumerable: slot[1].enumerable,
+        configurable: true,
+      });
+    }
+  }
+}

package/src/tools/puppeteer/02_stealth_hairline.txt

@@ -1,11 +1,57 @@
-const elementDescriptor = Object_getOwnPropertyDescriptor(
-  HTMLElement.prototype,
-  "offsetHeight",
-);
-Object_defineProperty(HTMLDivElement.prototype, "offsetHeight", {
-  ...elementDescriptor,
-  get: function () {
-    if (this.id === "modernizr") return 1;
-	    return Reflect_apply(elementDescriptor.get, this, []);
-  },
-});
+{
+  const htmlElementOffsetHeightDescriptor =
+    typeof HTMLElement === "undefined"
+      ? undefined
+      : Object_getOwnPropertyDescriptor(HTMLElement.prototype, "offsetHeight");
+  const htmlDivElementOffsetHeightDescriptor =
+    typeof HTMLDivElement === "undefined"
+      ? undefined
+      : Object_getOwnPropertyDescriptor(HTMLDivElement.prototype, "offsetHeight");
+  const offsetHeightDescriptor =
+    htmlDivElementOffsetHeightDescriptor || htmlElementOffsetHeightDescriptor;
+  const offsetHeightPrototype = htmlDivElementOffsetHeightDescriptor
+    ? HTMLDivElement.prototype
+    : htmlElementOffsetHeightDescriptor
+      ? HTMLElement.prototype
+      : undefined;
+  const elementIdDescriptor =
+    typeof Element === "undefined"
+      ? undefined
+      : Object_getOwnPropertyDescriptor(Element.prototype, "id");
+
+  if (
+    typeof HTMLDivElement !== "undefined" &&
+    offsetHeightPrototype &&
+    offsetHeightDescriptor &&
+    typeof offsetHeightDescriptor.get === "function" &&
+    offsetHeightDescriptor.configurable &&
+    elementIdDescriptor &&
+    typeof elementIdDescriptor.get === "function"
+  ) {
+    const offsetHeightGetter = new Window_Proxy(offsetHeightDescriptor.get, {
+      apply(target, thisArg, args) {
+        const height = Reflect_apply(target, thisArg, args);
+
+        if (
+          height === 0 &&
+          Object_getPrototypeOf(thisArg) === HTMLDivElement.prototype &&
+          Reflect_apply(elementIdDescriptor.get, thisArg, []) === "modernizr"
+        ) {
+          return 1;
+        }
+
+        return height;
+      },
+    });
+
+    patchToString(offsetHeightGetter, "get offsetHeight");
+
+    Object_defineProperty(
+      offsetHeightPrototype,
+      "offsetHeight",
+      Object_assign({}, offsetHeightDescriptor, {
+        get: offsetHeightGetter,
+      }),
+    );
+  }
+}

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 {}
+}