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

package/src/tools/browser/tab-worker.ts

@@ -22,6 +22,12 @@ import { resizeImage } from "../../utils/image-resize";
 import { resolveToCwd } from "../path-utils";
 import { formatScreenshot } from "../render-utils";
 import { ToolAbortError, ToolError, throwIfAborted } from "../tool-errors";
+import {
+	type AriaSnapshotOptions,
+	captureAriaSnapshot,
+	parseAriaRefSelector,
+	resolveAriaRefHandle,
+} from "./aria/aria-snapshot";
 import {
 	applyStealthPatches,
 	applyViewport,
@@ -106,6 +112,7 @@ interface TabApi {
 		opts?: { waitUntil?: "load" | "domcontentloaded" | "networkidle0" | "networkidle2" },
 	): Promise<void>;
 	observe(opts?: { includeAll?: boolean; viewportOnly?: boolean }): Promise<Observation>;
+	ariaSnapshot(selector?: string, opts?: AriaSnapshotOptions): Promise<string>;
 	screenshot(opts?: ScreenshotOptions): Promise<ScreenshotResult>;
 	extract(format?: ReadableFormat): Promise<string>;
 	click(selector: string): Promise<void>;
@@ -128,6 +135,7 @@ interface TabApi {
 		opts?: { timeout?: number },
 	): Promise<HTTPResponse>;
 	id(n: number): Promise<ElementHandle>;
+	ref(id: string): Promise<ElementHandle>;
 }
 
 function normalizeSelector(selector: string): string {
@@ -792,6 +800,28 @@ export class WorkerCore {
 					);
 				}),
 			observe: opts => op("tab.observe()", quickOpMs, sig => this.#collectObservation({ ...opts, signal: sig })),
+			ariaSnapshot: (selector, opts) =>
+				op(
+					selector ? `tab.ariaSnapshot(${JSON.stringify(selector)})` : "tab.ariaSnapshot()",
+					quickOpMs,
+					async sig => {
+						let root: ElementHandle | null = null;
+						if (selector) {
+							root = (await untilAborted(sig, () =>
+								page.$(normalizeSelector(selector)),
+							)) as ElementHandle | null;
+							if (!root)
+								throw new ToolError(
+									`tab.ariaSnapshot: selector ${JSON.stringify(selector)} matched no element`,
+								);
+						}
+						try {
+							return await untilAborted(sig, () => captureAriaSnapshot(page, root, opts));
+						} finally {
+							await root?.dispose().catch(() => undefined);
+						}
+					},
+				),
 			screenshot: opts =>
 				op(describeScreenshot(opts), quickOpMs, sig =>
 					this.#captureScreenshot(session, displays, screenshots, sig, opts),
@@ -815,25 +845,50 @@ export class WorkerCore {
 				}),
 			click: selector =>
 				op(`tab.click(${JSON.stringify(selector)})`, INF, async sig => {
+					if (parseAriaRefSelector(selector) !== null) {
+						const handle = await this.#resolveAriaRef(selector);
+						try {
+							await untilAborted(sig, () => handle.click());
+						} finally {
+							await handle.dispose().catch(() => undefined);
+						}
+						return;
+					}
 					const resolved = normalizeSelector(selector);
 					if (resolved.startsWith("text/")) await clickQueryHandlerText(page, resolved, timeoutMs, sig);
 					else await untilAborted(sig, () => page.locator(resolved).setTimeout(timeoutMs).click());
 				}),
 			type: (selector, text) =>
 				op(`tab.type(${JSON.stringify(selector)})`, INF, async sig => {
-					const handle = (await untilAborted(sig, () =>
-						page.locator(normalizeSelector(selector)).setTimeout(timeoutMs).waitHandle(),
-					)) as ElementHandle;
+					const handle = await this.#resolveActionHandle(selector, timeoutMs, sig);
 					try {
 						await untilAborted(sig, () => handle.type(text, { delay: 0 }));
 					} finally {
-						await handle.dispose();
+						await handle.dispose().catch(() => undefined);
 					}
 				}),
 			fill: (selector, value) =>
-				op(`tab.fill(${JSON.stringify(selector)})`, INF, sig =>
-					untilAborted(sig, () => page.locator(normalizeSelector(selector)).setTimeout(timeoutMs).fill(value)),
-				),
+				op(`tab.fill(${JSON.stringify(selector)})`, INF, async sig => {
+					if (parseAriaRefSelector(selector) !== null) {
+						const handle = await this.#resolveAriaRef(selector);
+						try {
+							await untilAborted(sig, () =>
+								handle.evaluate(el => {
+									const node = el as unknown as { value?: string; focus?: () => void };
+									node.focus?.();
+									if ("value" in node) node.value = "";
+								}),
+							);
+							await untilAborted(sig, () => handle.type(value, { delay: 0 }));
+						} finally {
+							await handle.dispose().catch(() => undefined);
+						}
+						return;
+					}
+					await untilAborted(sig, () =>
+						page.locator(normalizeSelector(selector)).setTimeout(timeoutMs).fill(value),
+					);
+				}),
 			press: (key, opts) =>
 				op(`tab.press(${JSON.stringify(key)})`, INF, async sig => {
 					const selector = opts?.selector;
@@ -844,13 +899,8 @@ export class WorkerCore {
 				op("tab.scroll()", INF, sig => untilAborted(sig, () => page.mouse.wheel({ deltaX, deltaY }))),
 			drag: (from, to) => op("tab.drag()", INF, sig => this.#drag(from, to, sig)),
 			waitFor: selector =>
-				op(
-					`tab.waitFor(${JSON.stringify(selector)})`,
-					INF,
-					async sig =>
-						(await untilAborted(sig, () =>
-							page.locator(normalizeSelector(selector)).setTimeout(timeoutMs).waitHandle(),
-						)) as ElementHandle,
+				op(`tab.waitFor(${JSON.stringify(selector)})`, INF, sig =>
+					this.#resolveActionHandle(selector, timeoutMs, sig),
 				),
 			evaluate: (fn, ...args) =>
 				op("tab.evaluate()", INF, sig =>
@@ -862,9 +912,7 @@ export class WorkerCore {
 				) as never,
 			scrollIntoView: selector =>
 				op(`tab.scrollIntoView(${JSON.stringify(selector)})`, INF, async sig => {
-					const handle = (await untilAborted(sig, () =>
-						page.locator(normalizeSelector(selector)).setTimeout(timeoutMs).waitHandle(),
-					)) as ElementHandle;
+					const handle = await this.#resolveActionHandle(selector, timeoutMs, sig);
 					try {
 						await untilAborted(sig, () =>
 							handle.evaluate(el => {
@@ -889,6 +937,7 @@ export class WorkerCore {
 			waitForResponse: (pattern, opts) =>
 				op("tab.waitForResponse()", INF, sig => this.#waitForResponse(pattern, opts?.timeout ?? timeoutMs, sig)),
 			id: id => this.#resolveCachedHandle(id),
+			ref: id => this.#resolveAriaRef(id),
 		};
 	}
 
@@ -1188,6 +1237,29 @@ export class WorkerCore {
 		}
 		return handle;
 	}
+
+	async #resolveAriaRef(id: string): Promise<ElementHandle> {
+		const ref = parseAriaRefSelector(id) ?? id.trim();
+		const handle = await resolveAriaRefHandle(this.#requirePage(), ref);
+		if (!handle) {
+			throw new ToolError(
+				`Unknown ARIA ref ${JSON.stringify(ref)}. Run tab.ariaSnapshot() to refresh refs (they renumber each snapshot).`,
+			);
+		}
+		return handle;
+	}
+
+	/**
+	 * Resolve a selector to an ElementHandle for handle-based actions. An
+	 * `aria-ref=eN` selector resolves against the latest ariaSnapshot's refs
+	 * (main world); anything else goes through the normal locator wait.
+	 */
+	async #resolveActionHandle(selector: string, timeoutMs: number, sig: AbortSignal): Promise<ElementHandle> {
+		if (parseAriaRefSelector(selector) !== null) return this.#resolveAriaRef(selector);
+		return (await untilAborted(sig, () =>
+			this.#requirePage().locator(normalizeSelector(selector)).setTimeout(timeoutMs).waitHandle(),
+		)) as ElementHandle;
+	}
 	#clearElementCache(): void {
 		if (this.#elementCache.size === 0) {
 			this.#elementCounter = 0;

package/src/tools/browser.ts

@@ -16,6 +16,11 @@ import { ToolAbortError, ToolError, throwIfAborted } from "./tool-errors";
 import { toolResult } from "./tool-result";
 import { clampTimeout } from "./tool-timeouts";
 
+export {
+	type AriaSnapshotOptions,
+	buildAriaSnapshotScript,
+	parseAriaRefSelector,
+} from "./browser/aria/aria-snapshot";
 export { cmuxSnapshotToObservation, mapWaitUntil, resolveCmuxKind, serializeEval } from "./browser/cmux/rpc";
 export { CmuxSocketClient } from "./browser/cmux/socket-client";
 export { extractReadableFromHtml, type ReadableFormat, type ReadableResult } from "./browser/readable";

package/src/tools/find.ts

@@ -101,8 +101,7 @@ interface FindTarget {
 export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 	readonly name = "find";
 	readonly approval = "read" as const;
-	readonly summary = "Find files and directories matching a glob pattern";
-	readonly loadMode = "discoverable";
+	readonly loadMode = "essential";
 	readonly label = "Find";
 	readonly description: string;
 	readonly parameters = findSchema;

package/src/tools/index.ts

@@ -375,7 +375,7 @@ export type ToolFactory = (session: ToolSession) => Tool | null | Promise<Tool |
 export type BuiltinToolLoadMode = "essential" | "discoverable";
 
 /** Default essential tool names when tools.essentialOverride is empty. */
-export const DEFAULT_ESSENTIAL_TOOL_NAMES: readonly string[] = ["read", "bash", "edit"] as const;
+export const DEFAULT_ESSENTIAL_TOOL_NAMES: readonly string[] = ["read", "bash", "edit", "write", "find"] as const;
 
 /**
  * Resolve the active essential built-in tool names from settings.

package/src/tools/puppeteer/00_stealth_tampering.txt

@@ -1,8 +1,5 @@
-// Helper to generate native code string
-const makeNativeString = (name) =>
-  "function " + (name || "") + "() { [native code] }";
-
-// Patch toString for common fingerprinted functions
+// Register native-looking source for common fingerprinted functions without
+// adding own toString properties.
 const patchedFns = [
   [window.alert, "alert"],
   [window.prompt, "prompt"],
@@ -20,44 +17,28 @@ const patchedFns = [
 ];
 
 for (const [fn, name] of patchedFns) {
-  if (typeof fn === "function") {
-    const nativeStr = makeNativeString(name);
-    Object_defineProperty(fn, "toString", {
-      value: function toString() { return nativeStr; },
-      writable: false,
-      configurable: true,
-      enumerable: false,
-    });
-  }
+  patchToString(fn, name);
 }
 
-// Patch Object.getOwnPropertyDescriptor to return native-looking descriptors
-Object.getOwnPropertyDescriptor = function (obj, prop) {
-  const descriptor = Object_getOwnPropertyDescriptor.call(this, obj, prop);
+// Patch Object.getOwnPropertyDescriptor to return native-looking accessor
+// source through the shared Function.prototype.toString registry.
+const patchedGetOwnPropertyDescriptor = function getOwnPropertyDescriptor(obj, prop) {
+  const descriptor = Reflect_apply(Object_getOwnPropertyDescriptor, this, [obj, prop]);
   if (!descriptor) return descriptor;
 
-  // Make patched descriptors look native
   if (descriptor.get && typeof descriptor.get === "function") {
-    const getStr = makeNativeString("get " + String(prop));
-    Object_defineProperty(descriptor.get, "toString", {
-      value: function toString() { return getStr; },
-      writable: false,
-      configurable: true,
-      enumerable: false,
-    });
+    patchToString(descriptor.get, "get " + String(prop));
   }
   if (descriptor.set && typeof descriptor.set === "function") {
-    const setStr = makeNativeString("set " + String(prop));
-    Object_defineProperty(descriptor.set, "toString", {
-      value: function toString() { return setStr; },
-      writable: false,
-      configurable: true,
-      enumerable: false,
-    });
+    patchToString(descriptor.set, "set " + String(prop));
   }
 
   return descriptor;
 };
-
-// Cleanup
-document.head.removeChild(iframe);
+patchToString(patchedGetOwnPropertyDescriptor, "getOwnPropertyDescriptor");
+Object_defineProperty(Object, "getOwnPropertyDescriptor", {
+  value: patchedGetOwnPropertyDescriptor,
+  writable: true,
+  configurable: true,
+  enumerable: false,
+});

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;
 	}
 }