@midscene/web 0.7.1 → 0.7.2-beta-20241024094141.0

package/dist/es/index.js

@@ -47,6 +47,26 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
 
 // ../../node_modules/.pnpm/dayjs@1.11.11/node_modules/dayjs/dayjs.min.js
 var require_dayjs_min = __commonJS({
@@ -863,7 +883,7 @@ var require_sha256 = __commonJS({
 });
 
 // src/playwright/ai-fixture.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID } from "crypto";
 
 // src/common/agent.ts
 import {
@@ -880,7 +900,6 @@ import {
   plan
 } from "@midscene/core";
 import { sleep } from "@midscene/core/utils";
-import { base64Encoded as base64Encoded2 } from "@midscene/shared/img";
 
 // src/common/task-cache.ts
 import { existsSync, readFileSync as readFileSync2 } from "fs";
@@ -890,21 +909,19 @@ import {
   stringifyDumpData,
   writeLogFile
 } from "@midscene/core/utils";
-import { getMidscenePkgInfo } from "@midscene/shared/fs";
+import { getRunningPkgInfo } from "@midscene/shared/fs";
+import { ifInBrowser } from "@midscene/shared/utils";
 
 // src/common/utils.ts
 var import_dayjs = __toESM(require_dayjs_min());
 import assert from "assert";
-import { randomUUID } from "crypto";
 import { readFileSync } from "fs";
 import path from "path";
 import { NodeType } from "@midscene/shared/constants";
 import { findNearestPackageJson } from "@midscene/shared/fs";
-import {
-  base64Encoded,
-  imageInfoOfBase64
-} from "@midscene/shared/img";
+import { imageInfoOfBase64 } from "@midscene/shared/img";
 import { compositeElementInfoImg } from "@midscene/shared/img";
+import { uuid } from "@midscene/shared/utils";
 
 // src/web-element.ts
 var WebElementInfo = class {
@@ -932,63 +949,68 @@ var WebElementInfo = class {
 };
 
 // src/common/utils.ts
-async function parseContextFromWebPage(page, _opt) {
-  assert(page, "page is required");
-  if (page._forceUsePageContext) {
-    return await page._forceUsePageContext();
-  }
-  const url = page.url();
-  const file = await page.screenshot();
-  const screenshotBase64 = base64Encoded(file);
-  const captureElementSnapshot = await page.getElementInfos();
-  const elementsInfo = await alignElements(captureElementSnapshot, page);
-  const elementsPositionInfoWithoutText = elementsInfo.filter((elementInfo) => {
-    if (elementInfo.attributes.nodeType === NodeType.TEXT) {
-      return false;
+function parseContextFromWebPage(page, _opt) {
+  return __async(this, null, function* () {
+    assert(page, "page is required");
+    if (page._forceUsePageContext) {
+      return yield page._forceUsePageContext();
     }
-    return true;
-  });
-  const size = await imageInfoOfBase64(screenshotBase64);
-  const screenshotBase64WithElementMarker = await compositeElementInfoImg({
-    inputImgBase64: screenshotBase64.split(";base64,").pop(),
-    elementsPositionInfo: elementsPositionInfoWithoutText
+    const url = page.url();
+    const screenshotBase64 = yield page.screenshotBase64();
+    const captureElementSnapshot = yield page.getElementInfos();
+    const elementsInfo = yield alignElements(captureElementSnapshot, page);
+    const elementsPositionInfoWithoutText = elementsInfo.filter((elementInfo) => {
+      if (elementInfo.attributes.nodeType === NodeType.TEXT) {
+        return false;
+      }
+      return true;
+    });
+    const size = yield imageInfoOfBase64(screenshotBase64);
+    const screenshotBase64WithElementMarker = yield compositeElementInfoImg({
+      inputImgBase64: screenshotBase64,
+      elementsPositionInfo: elementsPositionInfoWithoutText
+    });
+    return {
+      content: elementsInfo,
+      size,
+      screenshotBase64,
+      screenshotBase64WithElementMarker: `data:image/png;base64,${screenshotBase64WithElementMarker}`,
+      url
+    };
   });
-  return {
-    content: elementsInfo,
-    size,
-    screenshotBase64,
-    screenshotBase64WithElementMarker: `data:image/png;base64,${screenshotBase64WithElementMarker}`,
-    url
-  };
 }
-async function getExtraReturnLogic() {
-  const pathDir = findNearestPackageJson(__dirname);
-  assert(pathDir, `can't find pathDir, with ${__dirname}`);
-  const scriptPath = path.join(pathDir, "./dist/script/htmlElement.js");
-  const elementInfosScriptContent = readFileSync(scriptPath, "utf-8");
-  return `${elementInfosScriptContent}midscene_element_inspector.webExtractTextWithPosition()`;
+function getExtraReturnLogic() {
+  return __async(this, null, function* () {
+    const pathDir = findNearestPackageJson(__dirname);
+    assert(pathDir, `can't find pathDir, with ${__dirname}`);
+    const scriptPath = path.join(pathDir, "./dist/script/htmlElement.js");
+    const elementInfosScriptContent = readFileSync(scriptPath, "utf-8");
+    return `${elementInfosScriptContent}midscene_element_inspector.webExtractTextWithPosition()`;
+  });
 }
 var sizeThreshold = 3;
-async function alignElements(elements, page) {
-  const validElements = elements.filter((item) => {
-    return item.rect.height >= sizeThreshold && item.rect.width >= sizeThreshold;
+function alignElements(elements, page) {
+  return __async(this, null, function* () {
+    const validElements = elements.filter((item) => {
+      return item.rect.height >= sizeThreshold && item.rect.width >= sizeThreshold;
+    });
+    const textsAligned = [];
+    for (const item of validElements) {
+      const { rect, id, content, attributes, locator, indexId } = item;
+      textsAligned.push(
+        new WebElementInfo({
+          rect,
+          locator,
+          id,
+          content,
+          attributes,
+          page,
+          indexId
+        })
+      );
+    }
+    return textsAligned;
   });
-  const textsAligned = [];
-  for (const item of validElements) {
-    const { rect, id, content, attributes, locator, indexId } = item;
-    textsAligned.push(
-      new WebElementInfo({
-        rect,
-        locator,
-        id,
-        content,
-        attributes,
-        page,
-        indexId
-      })
-    );
-  }
-  return textsAligned;
 }
 function reportFileName(tag = "web") {
   const dateTimeInFileName = (0, import_dayjs.default)().format("YYYY-MM-DD_HH-mm-ss-SSS");
@@ -1019,7 +1041,7 @@ var testFileIndex = /* @__PURE__ */ new Map();
 function generateCacheId(fileName) {
   let taskFile = fileName || getCurrentExecutionFile();
   if (!taskFile) {
-    taskFile = randomUUID();
+    taskFile = uuid();
     console.warn(
       "Midscene - using random UUID for cache id. Cache may be invalid."
     );
@@ -1038,7 +1060,7 @@ function generateCacheId(fileName) {
 // src/common/task-cache.ts
 var TaskCache = class {
   constructor(opts) {
-    this.midscenePkgInfo = getMidscenePkgInfo(__dirname);
+    this.midscenePkgInfo = getRunningPkgInfo();
     this.cacheId = generateCacheId(opts == null ? void 0 : opts.fileName);
     this.cache = this.readCacheFromFile() || {
       aiTasks: []
@@ -1120,11 +1142,17 @@ var TaskCache = class {
     return this.newCache;
   }
   readCacheFromFile() {
+    if (ifInBrowser) {
+      return void 0;
+    }
     const cacheFile = join(getLogDirByType("cache"), `${this.cacheId}.json`);
     if (process.env.MIDSCENE_CACHE === "true" && existsSync(cacheFile)) {
       try {
         const data = readFileSync2(cacheFile, "utf8");
         const jsonData = JSON.parse(data);
+        if (!this.midscenePkgInfo) {
+          return void 0;
+        }
         if (jsonData.pkgName !== this.midscenePkgInfo.name || jsonData.pkgVersion !== this.midscenePkgInfo.version) {
           return void 0;
         }
@@ -1136,7 +1164,10 @@ var TaskCache = class {
     return void 0;
   }
   writeCacheToFile() {
-    const midscenePkgInfo = getMidscenePkgInfo(__dirname);
+    const midscenePkgInfo = getRunningPkgInfo();
+    if (!midscenePkgInfo) {
+      return;
+    }
     writeLogFile({
       fileName: `${this.cacheId}`,
       fileExt: "json",
@@ -1157,423 +1188,435 @@ var TaskCache = class {
 var PageTaskExecutor = class {
   constructor(page, opts) {
     this.page = page;
-    this.insight = new Insight(async () => {
-      return await parseContextFromWebPage(page);
-    });
+    this.insight = new Insight(() => __async(this, null, function* () {
+      return yield parseContextFromWebPage(page);
+    }));
     this.taskCache = new TaskCache({
       fileName: opts == null ? void 0 : opts.cacheId
     });
   }
-  async recordScreenshot(timing) {
-    const file = await this.page.screenshot();
-    const item = {
-      type: "screenshot",
-      ts: Date.now(),
-      screenshot: base64Encoded2(file),
-      timing
-    };
-    return item;
+  recordScreenshot(timing) {
+    return __async(this, null, function* () {
+      const base64 = yield this.page.screenshotBase64();
+      const item = {
+        type: "screenshot",
+        ts: Date.now(),
+        screenshot: base64,
+        timing
+      };
+      return item;
+    });
   }
   wrapExecutorWithScreenshot(taskApply) {
     const taskWithScreenshot = __spreadProps(__spreadValues({}, taskApply), {
-      executor: async (param, context, ...args) => {
+      executor: (param, context, ...args) => __async(this, null, function* () {
         const recorder = [];
         const { task } = context;
         task.recorder = recorder;
-        const shot = await this.recordScreenshot(`before ${task.type}`);
+        const shot = yield this.recordScreenshot(`before ${task.type}`);
         recorder.push(shot);
-        const result = await taskApply.executor(param, context, ...args);
+        const result = yield taskApply.executor(param, context, ...args);
         if (taskApply.type === "Action") {
-          await sleep(1e3);
-          const shot2 = await this.recordScreenshot("after Action");
+          yield sleep(1e3);
+          const shot2 = yield this.recordScreenshot("after Action");
           recorder.push(shot2);
         }
         return result;
-      }
+      })
     });
     return taskWithScreenshot;
   }
-  async convertPlanToExecutable(plans, cacheGroup) {
-    const tasks = plans.map((plan2) => {
-      if (plan2.type === "Locate") {
-        const taskFind = {
-          type: "Insight",
-          subType: "Locate",
-          param: plan2.param,
-          executor: async (param, taskContext) => {
-            const { task } = taskContext;
-            let insightDump;
-            const dumpCollector = (dump) => {
-              insightDump = dump;
-            };
-            this.insight.onceDumpUpdatedFn = dumpCollector;
-            const pageContext = await this.insight.contextRetrieverFn();
-            const locateCache = cacheGroup == null ? void 0 : cacheGroup.readCache(
-              pageContext,
-              "locate",
-              param.prompt
-            );
-            let locateResult;
-            const callAI = this.insight.aiVendorFn;
-            const element = await this.insight.locate(param.prompt, {
-              quickAnswer: plan2.quickAnswer,
-              callAI: async (...message) => {
-                if (locateCache) {
-                  locateResult = locateCache;
-                  return Promise.resolve(locateCache);
-                }
-                locateResult = await callAI(...message);
-                assert2(locateResult);
-                return locateResult;
-              }
-            });
-            if (locateResult) {
-              cacheGroup == null ? void 0 : cacheGroup.saveCache({
-                type: "locate",
-                pageContext: {
-                  url: pageContext.url,
-                  size: pageContext.size
-                },
-                prompt: param.prompt,
-                response: locateResult
-              });
-            }
-            if (!element) {
-              task.log = {
-                dump: insightDump
+  convertPlanToExecutable(plans, cacheGroup) {
+    return __async(this, null, function* () {
+      const tasks = plans.map((plan2) => {
+        if (plan2.type === "Locate") {
+          const taskFind = {
+            type: "Insight",
+            subType: "Locate",
+            param: plan2.param,
+            executor: (param, taskContext) => __async(this, null, function* () {
+              const { task } = taskContext;
+              let insightDump;
+              const dumpCollector = (dump) => {
+                insightDump = dump;
               };
-              throw new Error(`Element not found: ${param.prompt}`);
-            }
-            return {
-              output: {
-                element
-              },
-              log: {
-                dump: insightDump
-              },
-              cache: {
-                hit: Boolean(locateCache)
+              this.insight.onceDumpUpdatedFn = dumpCollector;
+              const pageContext = yield this.insight.contextRetrieverFn();
+              const locateCache = cacheGroup == null ? void 0 : cacheGroup.readCache(
+                pageContext,
+                "locate",
+                param.prompt
+              );
+              let locateResult;
+              const callAI = this.insight.aiVendorFn;
+              const element = yield this.insight.locate(param.prompt, {
+                quickAnswer: plan2.quickAnswer,
+                callAI: (...message) => __async(this, null, function* () {
+                  if (locateCache) {
+                    locateResult = locateCache;
+                    return Promise.resolve(locateCache);
+                  }
+                  locateResult = yield callAI(...message);
+                  assert2(locateResult);
+                  return locateResult;
+                })
+              });
+              if (locateResult) {
+                cacheGroup == null ? void 0 : cacheGroup.saveCache({
+                  type: "locate",
+                  pageContext: {
+                    url: pageContext.url,
+                    size: pageContext.size
+                  },
+                  prompt: param.prompt,
+                  response: locateResult
+                });
               }
-            };
-          }
-        };
-        return taskFind;
-      }
-      if (plan2.type === "Assert" || plan2.type === "AssertWithoutThrow") {
-        const assertPlan = plan2;
-        const taskAssert = {
-          type: "Insight",
-          subType: "Assert",
-          param: assertPlan.param,
-          executor: async (param, taskContext) => {
-            const { task } = taskContext;
-            let insightDump;
-            const dumpCollector = (dump) => {
-              insightDump = dump;
-            };
-            this.insight.onceDumpUpdatedFn = dumpCollector;
-            const assertion = await this.insight.assert(
-              assertPlan.param.assertion
-            );
-            if (!assertion.pass) {
-              if (plan2.type === "Assert") {
-                task.output = assertion;
+              if (!element) {
                 task.log = {
                   dump: insightDump
                 };
-                throw new Error(
-                  assertion.thought || "Assertion failed without reason"
-                );
+                throw new Error(`Element not found: ${param.prompt}`);
               }
-              task.error = assertion.thought;
-            }
-            return {
-              output: assertion,
-              log: {
-                dump: insightDump
+              return {
+                output: {
+                  element
+                },
+                log: {
+                  dump: insightDump
+                },
+                cache: {
+                  hit: Boolean(locateCache)
+                }
+              };
+            })
+          };
+          return taskFind;
+        }
+        if (plan2.type === "Assert" || plan2.type === "AssertWithoutThrow") {
+          const assertPlan = plan2;
+          const taskAssert = {
+            type: "Insight",
+            subType: "Assert",
+            param: assertPlan.param,
+            executor: (param, taskContext) => __async(this, null, function* () {
+              const { task } = taskContext;
+              let insightDump;
+              const dumpCollector = (dump) => {
+                insightDump = dump;
+              };
+              this.insight.onceDumpUpdatedFn = dumpCollector;
+              const assertion = yield this.insight.assert(
+                assertPlan.param.assertion
+              );
+              if (!assertion.pass) {
+                if (plan2.type === "Assert") {
+                  task.output = assertion;
+                  task.log = {
+                    dump: insightDump
+                  };
+                  throw new Error(
+                    assertion.thought || "Assertion failed without reason"
+                  );
+                }
+                task.error = assertion.thought;
               }
-            };
-          }
-        };
-        return taskAssert;
-      }
-      if (plan2.type === "Input") {
-        const taskActionInput = {
-          type: "Action",
-          subType: "Input",
-          param: plan2.param,
-          executor: async (taskParam, { element }) => {
-            if (element) {
-              await this.page.clearInput(element);
-              if (taskParam.value === "") {
-                return;
+              return {
+                output: assertion,
+                log: {
+                  dump: insightDump
+                }
+              };
+            })
+          };
+          return taskAssert;
+        }
+        if (plan2.type === "Input") {
+          const taskActionInput = {
+            type: "Action",
+            subType: "Input",
+            param: plan2.param,
+            executor: (_0, _1) => __async(this, [_0, _1], function* (taskParam, { element }) {
+              if (element) {
+                yield this.page.clearInput(element);
+                if (taskParam.value === "") {
+                  return;
+                }
+                yield this.page.keyboard.type(taskParam.value);
               }
-              await this.page.keyboard.type(taskParam.value);
-            }
-          }
-        };
-        return taskActionInput;
-      }
-      if (plan2.type === "KeyboardPress") {
-        const taskActionKeyboardPress = {
-          type: "Action",
-          subType: "KeyboardPress",
-          param: plan2.param,
-          executor: async (taskParam) => {
-            assert2(taskParam.value, "No key to press");
-            await this.page.keyboard.press(taskParam.value);
-          }
-        };
-        return taskActionKeyboardPress;
-      }
-      if (plan2.type === "Tap") {
-        const taskActionTap = {
-          type: "Action",
-          subType: "Tap",
-          executor: async (param, { element }) => {
-            assert2(element, "Element not found, cannot tap");
-            await this.page.mouse.click(
-              element.center[0],
-              element.center[1]
-            );
-          }
-        };
-        return taskActionTap;
-      }
-      if (plan2.type === "Hover") {
-        const taskActionHover = {
-          type: "Action",
-          subType: "Hover",
-          executor: async (param, { element }) => {
-            assert2(element, "Element not found, cannot hover");
-            await this.page.mouse.move(
-              element.center[0],
-              element.center[1]
-            );
-          }
-        };
-        return taskActionHover;
-      }
-      if (plan2.type === "Scroll") {
-        const taskActionScroll = {
-          type: "Action",
-          subType: "Scroll",
-          param: plan2.param,
-          executor: async (taskParam) => {
-            const scrollToEventName = taskParam.scrollType;
-            switch (scrollToEventName) {
-              case "scrollUntilTop":
-                await this.page.scrollUntilTop();
-                break;
-              case "scrollUntilBottom":
-                await this.page.scrollUntilBottom();
-                break;
-              case "scrollUpOneScreen":
-                await this.page.scrollUpOneScreen();
-                break;
-              case "scrollDownOneScreen":
-                await this.page.scrollDownOneScreen();
-                break;
-              default:
-                console.error(
-                  "Unknown scroll event type:",
-                  scrollToEventName
-                );
-            }
-          }
-        };
-        return taskActionScroll;
-      }
-      if (plan2.type === "Sleep") {
-        const taskActionSleep = {
-          type: "Action",
-          subType: "Sleep",
-          param: plan2.param,
-          executor: async (taskParam) => {
-            await sleep(taskParam.timeMs || 3e3);
-          }
-        };
-        return taskActionSleep;
-      }
-      if (plan2.type === "Error") {
-        const taskActionError = {
-          type: "Action",
-          subType: "Error",
-          param: plan2.param,
-          executor: async (taskParam) => {
-            assert2(
-              taskParam.thought,
-              "An error occurred, but no thought provided"
-            );
-            throw new Error(taskParam.thought);
-          }
-        };
-        return taskActionError;
-      }
-      throw new Error(`Unknown or Unsupported task type: ${plan2.type}`);
-    }).map((task) => {
-      return this.wrapExecutorWithScreenshot(task);
+            })
+          };
+          return taskActionInput;
+        }
+        if (plan2.type === "KeyboardPress") {
+          const taskActionKeyboardPress = {
+            type: "Action",
+            subType: "KeyboardPress",
+            param: plan2.param,
+            executor: (taskParam) => __async(this, null, function* () {
+              assert2(taskParam.value, "No key to press");
+              yield this.page.keyboard.press(taskParam.value);
+            })
+          };
+          return taskActionKeyboardPress;
+        }
+        if (plan2.type === "Tap") {
+          const taskActionTap = {
+            type: "Action",
+            subType: "Tap",
+            executor: (_0, _1) => __async(this, [_0, _1], function* (param, { element }) {
+              assert2(element, "Element not found, cannot tap");
+              yield this.page.mouse.click(
+                element.center[0],
+                element.center[1]
+              );
+            })
+          };
+          return taskActionTap;
+        }
+        if (plan2.type === "Hover") {
+          const taskActionHover = {
+            type: "Action",
+            subType: "Hover",
+            executor: (_0, _1) => __async(this, [_0, _1], function* (param, { element }) {
+              assert2(element, "Element not found, cannot hover");
+              yield this.page.mouse.move(
+                element.center[0],
+                element.center[1]
+              );
+            })
+          };
+          return taskActionHover;
+        }
+        if (plan2.type === "Scroll") {
+          const taskActionScroll = {
+            type: "Action",
+            subType: "Scroll",
+            param: plan2.param,
+            executor: (taskParam) => __async(this, null, function* () {
+              const scrollToEventName = taskParam.scrollType;
+              switch (scrollToEventName) {
+                case "scrollUntilTop":
+                  yield this.page.scrollUntilTop();
+                  break;
+                case "scrollUntilBottom":
+                  yield this.page.scrollUntilBottom();
+                  break;
+                case "scrollUpOneScreen":
+                  yield this.page.scrollUpOneScreen();
+                  break;
+                case "scrollDownOneScreen":
+                  yield this.page.scrollDownOneScreen();
+                  break;
+                default:
+                  console.error(
+                    "Unknown scroll event type:",
+                    scrollToEventName
+                  );
+              }
+            })
+          };
+          return taskActionScroll;
+        }
+        if (plan2.type === "Sleep") {
+          const taskActionSleep = {
+            type: "Action",
+            subType: "Sleep",
+            param: plan2.param,
+            executor: (taskParam) => __async(this, null, function* () {
+              yield sleep(taskParam.timeMs || 3e3);
+            })
+          };
+          return taskActionSleep;
+        }
+        if (plan2.type === "Error") {
+          const taskActionError = {
+            type: "Action",
+            subType: "Error",
+            param: plan2.param,
+            executor: (taskParam) => __async(this, null, function* () {
+              assert2(
+                taskParam.thought,
+                "An error occurred, but no thought provided"
+              );
+              throw new Error(taskParam.thought);
+            })
+          };
+          return taskActionError;
+        }
+        throw new Error(`Unknown or Unsupported task type: ${plan2.type}`);
+      }).map((task) => {
+        return this.wrapExecutorWithScreenshot(task);
+      });
+      return tasks;
     });
-    return tasks;
-  }
-  async action(userPrompt) {
-    const taskExecutor = new Executor(userPrompt);
-    const cacheGroup = this.taskCache.getCacheGroupByPrompt(userPrompt);
-    let plans = [];
-    const planningTask = {
-      type: "Planning",
-      param: {
-        userPrompt
-      },
-      executor: async (param) => {
-        const pageContext = await this.insight.contextRetrieverFn();
-        let planResult;
-        const planCache = cacheGroup.readCache(pageContext, "plan", userPrompt);
-        if (planCache) {
-          planResult = planCache;
-        } else {
-          planResult = await plan(param.userPrompt, {
-            context: pageContext
+  }
+  action(userPrompt) {
+    return __async(this, null, function* () {
+      const taskExecutor = new Executor(userPrompt);
+      const cacheGroup = this.taskCache.getCacheGroupByPrompt(userPrompt);
+      let plans = [];
+      const planningTask = {
+        type: "Planning",
+        param: {
+          userPrompt
+        },
+        executor: (param) => __async(this, null, function* () {
+          const pageContext = yield this.insight.contextRetrieverFn();
+          let planResult;
+          const planCache = cacheGroup.readCache(pageContext, "plan", userPrompt);
+          if (planCache) {
+            planResult = planCache;
+          } else {
+            planResult = yield plan(param.userPrompt, {
+              context: pageContext
+            });
+          }
+          assert2(planResult.plans.length > 0, "No plans found");
+          plans = planResult.plans;
+          cacheGroup.saveCache({
+            type: "plan",
+            pageContext: {
+              url: pageContext.url,
+              size: pageContext.size
+            },
+            prompt: userPrompt,
+            response: planResult
           });
-        }
-        assert2(planResult.plans.length > 0, "No plans found");
-        plans = planResult.plans;
-        cacheGroup.saveCache({
-          type: "plan",
-          pageContext: {
-            url: pageContext.url,
-            size: pageContext.size
-          },
-          prompt: userPrompt,
-          response: planResult
-        });
+          return {
+            output: planResult,
+            cache: {
+              hit: Boolean(planCache)
+            }
+          };
+        })
+      };
+      yield taskExecutor.append(this.wrapExecutorWithScreenshot(planningTask));
+      let output = yield taskExecutor.flush();
+      if (taskExecutor.isInErrorState()) {
         return {
-          output: planResult,
-          cache: {
-            hit: Boolean(planCache)
-          }
+          output,
+          executor: taskExecutor
         };
       }
-    };
-    await taskExecutor.append(this.wrapExecutorWithScreenshot(planningTask));
-    let output = await taskExecutor.flush();
-    if (taskExecutor.isInErrorState()) {
+      const executables = yield this.convertPlanToExecutable(plans, cacheGroup);
+      yield taskExecutor.append(executables);
+      output = yield taskExecutor.flush();
       return {
         output,
         executor: taskExecutor
       };
-    }
-    const executables = await this.convertPlanToExecutable(plans, cacheGroup);
-    await taskExecutor.append(executables);
-    output = await taskExecutor.flush();
-    return {
-      output,
-      executor: taskExecutor
-    };
-  }
-  async query(demand) {
-    const description = typeof demand === "string" ? demand : JSON.stringify(demand);
-    const taskExecutor = new Executor(description);
-    const queryTask = {
-      type: "Insight",
-      subType: "Query",
-      param: {
-        dataDemand: demand
-      },
-      executor: async (param) => {
-        let insightDump;
-        const dumpCollector = (dump) => {
-          insightDump = dump;
-        };
-        this.insight.onceDumpUpdatedFn = dumpCollector;
-        const data = await this.insight.extract(param.dataDemand);
-        return {
-          output: data,
-          log: { dump: insightDump }
-        };
-      }
-    };
-    await taskExecutor.append(this.wrapExecutorWithScreenshot(queryTask));
-    const output = await taskExecutor.flush();
-    return {
-      output,
-      executor: taskExecutor
-    };
+    });
   }
-  async assert(assertion) {
-    const description = `assert: ${assertion}`;
-    const taskExecutor = new Executor(description);
-    const assertionPlan = {
-      type: "Assert",
-      param: {
-        assertion
-      }
-    };
-    const assertTask = await this.convertPlanToExecutable([assertionPlan]);
-    await taskExecutor.append(this.wrapExecutorWithScreenshot(assertTask[0]));
-    const output = await taskExecutor.flush();
-    return {
-      output,
-      executor: taskExecutor
-    };
+  query(demand) {
+    return __async(this, null, function* () {
+      const description = typeof demand === "string" ? demand : JSON.stringify(demand);
+      const taskExecutor = new Executor(description);
+      const queryTask = {
+        type: "Insight",
+        subType: "Query",
+        param: {
+          dataDemand: demand
+        },
+        executor: (param) => __async(this, null, function* () {
+          let insightDump;
+          const dumpCollector = (dump) => {
+            insightDump = dump;
+          };
+          this.insight.onceDumpUpdatedFn = dumpCollector;
+          const data = yield this.insight.extract(param.dataDemand);
+          return {
+            output: data,
+            log: { dump: insightDump }
+          };
+        })
+      };
+      yield taskExecutor.append(this.wrapExecutorWithScreenshot(queryTask));
+      const output = yield taskExecutor.flush();
+      return {
+        output,
+        executor: taskExecutor
+      };
+    });
   }
-  async waitFor(assertion, opt) {
-    const description = `waitFor: ${assertion}`;
-    const taskExecutor = new Executor(description);
-    const { timeoutMs, checkIntervalMs } = opt;
-    assert2(assertion, "No assertion for waitFor");
-    assert2(timeoutMs, "No timeoutMs for waitFor");
-    assert2(checkIntervalMs, "No checkIntervalMs for waitFor");
-    const overallStartTime = Date.now();
-    let startTime = Date.now();
-    let errorThought = "";
-    while (Date.now() - overallStartTime < timeoutMs) {
-      startTime = Date.now();
-      const assertPlan = {
-        type: "AssertWithoutThrow",
+  assert(assertion) {
+    return __async(this, null, function* () {
+      const description = `assert: ${assertion}`;
+      const taskExecutor = new Executor(description);
+      const assertionPlan = {
+        type: "Assert",
         param: {
           assertion
         }
       };
-      const assertTask = await this.convertPlanToExecutable([assertPlan]);
-      await taskExecutor.append(this.wrapExecutorWithScreenshot(assertTask[0]));
-      const output = await taskExecutor.flush();
-      if (output == null ? void 0 : output.pass) {
-        return {
-          output: void 0,
-          executor: taskExecutor
-        };
-      }
-      errorThought = (output == null ? void 0 : output.thought) || "unknown error";
-      const now = Date.now();
-      if (now - startTime < checkIntervalMs) {
-        const timeRemaining = checkIntervalMs - (now - startTime);
-        const sleepPlan = {
-          type: "Sleep",
+      const assertTask = yield this.convertPlanToExecutable([assertionPlan]);
+      yield taskExecutor.append(this.wrapExecutorWithScreenshot(assertTask[0]));
+      const output = yield taskExecutor.flush();
+      return {
+        output,
+        executor: taskExecutor
+      };
+    });
+  }
+  waitFor(assertion, opt) {
+    return __async(this, null, function* () {
+      const description = `waitFor: ${assertion}`;
+      const taskExecutor = new Executor(description);
+      const { timeoutMs, checkIntervalMs } = opt;
+      assert2(assertion, "No assertion for waitFor");
+      assert2(timeoutMs, "No timeoutMs for waitFor");
+      assert2(checkIntervalMs, "No checkIntervalMs for waitFor");
+      const overallStartTime = Date.now();
+      let startTime = Date.now();
+      let errorThought = "";
+      while (Date.now() - overallStartTime < timeoutMs) {
+        startTime = Date.now();
+        const assertPlan = {
+          type: "AssertWithoutThrow",
           param: {
-            timeMs: timeRemaining
+            assertion
           }
         };
-        const sleepTask = await this.convertPlanToExecutable([sleepPlan]);
-        await taskExecutor.append(
-          this.wrapExecutorWithScreenshot(sleepTask[0])
-        );
-        await taskExecutor.flush();
-      }
-    }
-    const errorPlan = {
-      type: "Error",
-      param: {
-        thought: `waitFor timeout: ${errorThought}`
+        const assertTask = yield this.convertPlanToExecutable([assertPlan]);
+        yield taskExecutor.append(this.wrapExecutorWithScreenshot(assertTask[0]));
+        const output = yield taskExecutor.flush();
+        if (output == null ? void 0 : output.pass) {
+          return {
+            output: void 0,
+            executor: taskExecutor
+          };
+        }
+        errorThought = (output == null ? void 0 : output.thought) || "unknown error";
+        const now = Date.now();
+        if (now - startTime < checkIntervalMs) {
+          const timeRemaining = checkIntervalMs - (now - startTime);
+          const sleepPlan = {
+            type: "Sleep",
+            param: {
+              timeMs: timeRemaining
+            }
+          };
+          const sleepTask = yield this.convertPlanToExecutable([sleepPlan]);
+          yield taskExecutor.append(
+            this.wrapExecutorWithScreenshot(sleepTask[0])
+          );
+          yield taskExecutor.flush();
+        }
       }
-    };
-    const errorTask = await this.convertPlanToExecutable([errorPlan]);
-    await taskExecutor.append(errorTask[0]);
-    await taskExecutor.flush();
-    return {
-      output: void 0,
-      executor: taskExecutor
-    };
+      const errorPlan = {
+        type: "Error",
+        param: {
+          thought: `waitFor timeout: ${errorThought}`
+        }
+      };
+      const errorTask = yield this.convertPlanToExecutable([errorPlan]);
+      yield taskExecutor.append(errorTask[0]);
+      yield taskExecutor.flush();
+      return {
+        output: void 0,
+        executor: taskExecutor
+      };
+    });
   }
 };
 
@@ -1618,72 +1661,83 @@ var PageAgent = class {
       type: "dump",
       generateReport
     });
-    if (generateReport && autoPrintReportMsg) {
+    if (generateReport && autoPrintReportMsg && this.reportFile) {
       printReportMsg(this.reportFile);
     }
   }
-  async aiAction(taskPrompt) {
-    const { executor } = await this.taskExecutor.action(taskPrompt);
-    this.appendExecutionDump(executor.dump());
-    this.writeOutActionDumps();
-    if (executor.isInErrorState()) {
-      const errorTask = executor.latestErrorTask();
-      throw new Error(`${errorTask == null ? void 0 : errorTask.error}
+  aiAction(taskPrompt) {
+    return __async(this, null, function* () {
+      const { executor } = yield this.taskExecutor.action(taskPrompt);
+      this.appendExecutionDump(executor.dump());
+      this.writeOutActionDumps();
+      if (executor.isInErrorState()) {
+        const errorTask = executor.latestErrorTask();
+        throw new Error(`${errorTask == null ? void 0 : errorTask.error}
 ${errorTask == null ? void 0 : errorTask.errorStack}`);
-    }
+      }
+    });
   }
-  async aiQuery(demand) {
-    const { output, executor } = await this.taskExecutor.query(demand);
-    this.appendExecutionDump(executor.dump());
-    this.writeOutActionDumps();
-    if (executor.isInErrorState()) {
-      const errorTask = executor.latestErrorTask();
-      throw new Error(`${errorTask == null ? void 0 : errorTask.error}
+  aiQuery(demand) {
+    return __async(this, null, function* () {
+      const { output, executor } = yield this.taskExecutor.query(demand);
+      this.appendExecutionDump(executor.dump());
+      this.writeOutActionDumps();
+      if (executor.isInErrorState()) {
+        const errorTask = executor.latestErrorTask();
+        throw new Error(`${errorTask == null ? void 0 : errorTask.error}
 ${errorTask == null ? void 0 : errorTask.errorStack}`);
-    }
-    return output;
-  }
-  async aiAssert(assertion, msg, opt) {
-    const { output, executor } = await this.taskExecutor.assert(assertion);
-    this.appendExecutionDump(executor.dump());
-    this.writeOutActionDumps();
-    if (opt == null ? void 0 : opt.keepRawResponse) {
+      }
       return output;
-    }
-    if (!(output == null ? void 0 : output.pass)) {
-      const errMsg = msg || `Assertion failed: ${assertion}`;
-      const reasonMsg = `Reason: ${(output == null ? void 0 : output.thought) || "(no_reason)"}`;
-      throw new Error(`${errMsg}
-${reasonMsg}`);
-    }
+    });
   }
-  async aiWaitFor(assertion, opt) {
-    const { executor } = await this.taskExecutor.waitFor(assertion, {
-      timeoutMs: (opt == null ? void 0 : opt.timeoutMs) || 15 * 1e3,
-      checkIntervalMs: (opt == null ? void 0 : opt.checkIntervalMs) || 3 * 1e3,
-      assertion
+  aiAssert(assertion, msg, opt) {
+    return __async(this, null, function* () {
+      var _a;
+      const { output, executor } = yield this.taskExecutor.assert(assertion);
+      this.appendExecutionDump(executor.dump());
+      this.writeOutActionDumps();
+      if (opt == null ? void 0 : opt.keepRawResponse) {
+        return output;
+      }
+      if (!(output == null ? void 0 : output.pass)) {
+        const errMsg = msg || `Assertion failed: ${assertion}`;
+        const reasonMsg = `Reason: ${(output == null ? void 0 : output.thought) || ((_a = executor.latestErrorTask()) == null ? void 0 : _a.error) || "(no_reason)"}`;
+        throw new Error(`${errMsg}
+${reasonMsg}`);
+      }
     });
-    this.appendExecutionDump(executor.dump());
-    this.writeOutActionDumps();
-    if (executor.isInErrorState()) {
-      const errorTask = executor.latestErrorTask();
-      throw new Error(`${errorTask == null ? void 0 : errorTask.error}
+  }
+  aiWaitFor(assertion, opt) {
+    return __async(this, null, function* () {
+      const { executor } = yield this.taskExecutor.waitFor(assertion, {
+        timeoutMs: (opt == null ? void 0 : opt.timeoutMs) || 15 * 1e3,
+        checkIntervalMs: (opt == null ? void 0 : opt.checkIntervalMs) || 3 * 1e3,
+        assertion
+      });
+      this.appendExecutionDump(executor.dump());
+      this.writeOutActionDumps();
+      if (executor.isInErrorState()) {
+        const errorTask = executor.latestErrorTask();
+        throw new Error(`${errorTask == null ? void 0 : errorTask.error}
 ${errorTask == null ? void 0 : errorTask.errorStack}`);
-    }
+      }
+    });
   }
-  async ai(taskPrompt, type = "action") {
-    if (type === "action") {
-      return this.aiAction(taskPrompt);
-    }
-    if (type === "query") {
-      return this.aiQuery(taskPrompt);
-    }
-    if (type === "assert") {
-      return this.aiAssert(taskPrompt);
-    }
-    throw new Error(
-      `Unknown type: ${type}, only support 'action', 'query', 'assert'`
-    );
+  ai(taskPrompt, type = "action") {
+    return __async(this, null, function* () {
+      if (type === "action") {
+        return this.aiAction(taskPrompt);
+      }
+      if (type === "query") {
+        return this.aiQuery(taskPrompt);
+      }
+      if (type === "assert") {
+        return this.aiAssert(taskPrompt);
+      }
+      throw new Error(
+        `Unknown type: ${type}, only support 'action', 'query', 'assert'`
+      );
+    });
   }
 };
 
@@ -1712,7 +1766,7 @@ var PlaywrightAiFixture = () => {
   const agentForPage = (page, testInfo) => {
     let idForPage = page[midsceneAgentKeyId];
     if (!idForPage) {
-      idForPage = randomUUID2();
+      idForPage = randomUUID();
       page[midsceneAgentKeyId] = idForPage;
       const { testId } = testInfo;
       const { taskFile, taskTitle } = groupAndCaseForTest(testInfo);
@@ -1741,70 +1795,94 @@ var PlaywrightAiFixture = () => {
     }
   };
   return {
-    ai: async ({ page }, use, testInfo) => {
+    ai: (_0, _1, _2) => __async(void 0, [_0, _1, _2], function* ({ page }, use, testInfo) {
       const agent = agentForPage(page, testInfo);
-      await use(
-        async (taskPrompt, opts) => {
+      yield use(
+        (taskPrompt, opts) => __async(void 0, null, function* () {
           return new Promise((resolve, reject) => {
-            test.step(`ai - ${taskPrompt}`, async () => {
-              await waitForNetworkIdle(page);
+            test.step(`ai - ${taskPrompt}`, () => __async(void 0, null, function* () {
+              yield waitForNetworkIdle(page);
               const actionType = (opts == null ? void 0 : opts.type) || "action";
-              const result = await agent.ai(taskPrompt, actionType);
-              resolve(result);
-            });
+              try {
+                const result = yield agent.ai(taskPrompt, actionType);
+                resolve(result);
+              } catch (error) {
+                reject(error);
+              }
+            }));
           });
-        }
+        })
       );
       updateDumpAnnotation(testInfo, agent.dumpDataString());
-    },
-    aiAction: async ({ page }, use, testInfo) => {
+    }),
+    aiAction: (_0, _1, _2) => __async(void 0, [_0, _1, _2], function* ({ page }, use, testInfo) {
       const agent = agentForPage(page, testInfo);
-      await use(async (taskPrompt) => {
-        test.step(`aiAction - ${taskPrompt}`, async () => {
-          await waitForNetworkIdle(page);
-          await agent.aiAction(taskPrompt);
+      yield use((taskPrompt) => __async(void 0, null, function* () {
+        return new Promise((resolve, reject) => {
+          test.step(`aiAction - ${taskPrompt}`, () => __async(void 0, null, function* () {
+            yield waitForNetworkIdle(page);
+            try {
+              const result = yield agent.aiAction(taskPrompt);
+              resolve(result);
+            } catch (error) {
+              reject(error);
+            }
+          }));
         });
-      });
+      }));
       updateDumpAnnotation(testInfo, agent.dumpDataString());
-    },
-    aiQuery: async ({ page }, use, testInfo) => {
+    }),
+    aiQuery: (_0, _1, _2) => __async(void 0, [_0, _1, _2], function* ({ page }, use, testInfo) {
       const agent = agentForPage(page, testInfo);
-      await use(async (demand) => {
+      yield use((demand) => __async(void 0, null, function* () {
         return new Promise((resolve, reject) => {
-          test.step(`aiQuery - ${JSON.stringify(demand)}`, async () => {
-            await waitForNetworkIdle(page);
-            const result = await agent.aiQuery(demand);
-            resolve(result);
-          });
+          test.step(`aiQuery - ${JSON.stringify(demand)}`, () => __async(void 0, null, function* () {
+            yield waitForNetworkIdle(page);
+            try {
+              const result = yield agent.aiQuery(demand);
+              resolve(result);
+            } catch (error) {
+              reject(error);
+            }
+          }));
         });
-      });
+      }));
       updateDumpAnnotation(testInfo, agent.dumpDataString());
-    },
-    aiAssert: async ({ page }, use, testInfo) => {
+    }),
+    aiAssert: (_0, _1, _2) => __async(void 0, [_0, _1, _2], function* ({ page }, use, testInfo) {
       const agent = agentForPage(page, testInfo);
-      await use(async (assertion, errorMsg) => {
+      yield use((assertion, errorMsg) => __async(void 0, null, function* () {
         return new Promise((resolve, reject) => {
-          test.step(`aiAssert - ${assertion}`, async () => {
-            await waitForNetworkIdle(page);
-            await agent.aiAssert(assertion, errorMsg);
-            resolve(null);
-          });
+          test.step(`aiAssert - ${assertion}`, () => __async(void 0, null, function* () {
+            yield waitForNetworkIdle(page);
+            try {
+              yield agent.aiAssert(assertion, errorMsg);
+              resolve(null);
+            } catch (error) {
+              reject(error);
+            }
+          }));
         });
-      });
+      }));
       updateDumpAnnotation(testInfo, agent.dumpDataString());
-    },
-    aiWaitFor: async ({ page }, use, testInfo) => {
+    }),
+    aiWaitFor: (_0, _1, _2) => __async(void 0, [_0, _1, _2], function* ({ page }, use, testInfo) {
       const agent = agentForPage(page, testInfo);
-      await use(async (assertion, opt) => {
+      yield use((assertion, opt) => __async(void 0, null, function* () {
         return new Promise((resolve, reject) => {
-          test.step(`aiWaitFor - ${assertion}`, async () => {
-            await agent.aiWaitFor(assertion, opt);
-            resolve(null);
-          });
+          test.step(`aiWaitFor - ${assertion}`, () => __async(void 0, null, function* () {
+            yield waitForNetworkIdle(page);
+            try {
+              yield agent.aiWaitFor(assertion, opt);
+              resolve(null);
+            } catch (error) {
+              reject(error);
+            }
+          }));
         });
-      });
+      }));
       updateDumpAnnotation(testInfo, agent.dumpDataString());
-    }
+    })
   };
 };
 function waitForNetworkIdle(page) {
@@ -1818,86 +1896,112 @@ function waitForNetworkIdle(page) {
 // src/puppeteer/base-page.ts
 import { readFileSync as readFileSync3, writeFileSync } from "fs";
 import { getTmpFile } from "@midscene/core/utils";
-import { resizeImg } from "@midscene/shared/img";
+import { base64Encoded, resizeImg } from "@midscene/shared/img";
 var Page = class {
   evaluate(pageFunction, arg) {
     if (this.pageType === "puppeteer") {
-      return this.page.evaluate(pageFunction, arg);
+      return this.underlyingPage.evaluate(pageFunction, arg);
     }
-    return this.page.evaluate(pageFunction, arg);
+    return this.underlyingPage.evaluate(pageFunction, arg);
   }
-  constructor(page, pageType) {
-    this.page = page;
+  constructor(underlyingPage, pageType) {
+    this.underlyingPage = underlyingPage;
     this.pageType = pageType;
   }
-  async getElementInfos() {
-    const scripts = await getExtraReturnLogic();
-    const captureElementSnapshot = await this.evaluate(scripts);
-    return captureElementSnapshot;
-  }
-  async screenshot() {
-    const viewportSize = await this.evaluate(() => {
-      return {
-        width: document.documentElement.clientWidth,
-        height: document.documentElement.clientHeight,
-        deviceScaleFactor: window.devicePixelRatio
-      };
+  getElementInfos() {
+    return __async(this, null, function* () {
+      const scripts = yield getExtraReturnLogic();
+      const captureElementSnapshot = yield this.evaluate(scripts);
+      return captureElementSnapshot;
     });
-    const path3 = getTmpFile("png");
-    await this.page.screenshot({
-      path: path3,
-      type: "png"
-    });
-    let buf;
-    if (viewportSize.deviceScaleFactor > 1) {
-      buf = await resizeImg(readFileSync3(path3), {
-        width: viewportSize.width,
-        height: viewportSize.height
+  }
+  screenshotBase64() {
+    return __async(this, null, function* () {
+      const viewportSize = yield this.evaluate(() => {
+        return {
+          width: document.documentElement.clientWidth,
+          height: document.documentElement.clientHeight,
+          deviceScaleFactor: window.devicePixelRatio
+        };
       });
-      writeFileSync(path3, buf);
-    }
-    return path3;
+      const path3 = getTmpFile("png");
+      yield this.underlyingPage.screenshot({
+        path: path3,
+        type: "png"
+      });
+      let buf;
+      if (viewportSize.deviceScaleFactor > 1) {
+        buf = yield resizeImg(readFileSync3(path3), {
+          width: viewportSize.width,
+          height: viewportSize.height
+        });
+        writeFileSync(path3, buf);
+      }
+      return base64Encoded(path3, true);
+    });
   }
   url() {
-    return this.page.url();
+    return this.underlyingPage.url();
   }
   get mouse() {
     return {
-      click: async (x, y, options) => this.page.mouse.click(x, y, { button: (options == null ? void 0 : options.button) || "left" }),
-      wheel: async (deltaX, deltaY) => {
+      click: (x, y, options) => __async(this, null, function* () {
+        return this.underlyingPage.mouse.click(x, y, {
+          button: (options == null ? void 0 : options.button) || "left"
+        });
+      }),
+      wheel: (deltaX, deltaY) => __async(this, null, function* () {
         if (this.pageType === "puppeteer") {
-          await this.page.mouse.wheel({ deltaX, deltaY });
+          yield this.underlyingPage.mouse.wheel({
+            deltaX,
+            deltaY
+          });
         } else if (this.pageType === "playwright") {
-          await this.page.mouse.wheel(deltaX, deltaY);
+          yield this.underlyingPage.mouse.wheel(
+            deltaX,
+            deltaY
+          );
         }
-      },
-      move: async (x, y) => this.page.mouse.move(x, y)
+      }),
+      move: (x, y) => __async(this, null, function* () {
+        return this.underlyingPage.mouse.move(x, y);
+      })
     };
   }
   get keyboard() {
     return {
-      type: async (text) => this.page.keyboard.type(text),
-      press: async (key) => this.page.keyboard.press(key),
-      down: async (key) => this.page.keyboard.down(key),
-      up: async (key) => this.page.keyboard.up(key)
+      type: (text) => __async(this, null, function* () {
+        return this.underlyingPage.keyboard.type(text);
+      }),
+      press: (key) => __async(this, null, function* () {
+        return this.underlyingPage.keyboard.press(key);
+      }),
+      down: (key) => __async(this, null, function* () {
+        return this.underlyingPage.keyboard.down(key);
+      }),
+      up: (key) => __async(this, null, function* () {
+        return this.underlyingPage.keyboard.up(key);
+      })
     };
   }
-  async clearInput(element) {
-    if (!element) {
-      return;
-    }
-    await this.mouse.click(element.center[0], element.center[1]);
-    const isMac = process.platform === "darwin";
-    if (isMac) {
-      await this.page.keyboard.down("Meta");
-      await this.page.keyboard.press("a");
-      await this.page.keyboard.up("Meta");
-    } else {
-      await this.page.keyboard.down("Control");
-      await this.page.keyboard.press("a");
-      await this.page.keyboard.up("Control");
-    }
-    await this.keyboard.press("Backspace");
+  clearInput(element) {
+    return __async(this, null, function* () {
+      if (!element) {
+        return;
+      }
+      yield this.mouse.click(element.center[0], element.center[1]);
+      const isMac = process.platform === "darwin";
+      if (isMac) {
+        yield this.underlyingPage.keyboard.down("Meta");
+        yield this.underlyingPage.keyboard.press("a");
+        yield this.underlyingPage.keyboard.up("Meta");
+      } else {
+        yield this.underlyingPage.keyboard.down("Control");
+        yield this.underlyingPage.keyboard.press("a");
+        yield this.underlyingPage.keyboard.up("Control");
+      }
+      yield this.keyboard.press("Backspace");
+    });
   }
   scrollUntilTop() {
     return this.mouse.wheel(0, -9999999);
@@ -1905,15 +2009,19 @@ var Page = class {
   scrollUntilBottom() {
     return this.mouse.wheel(0, 9999999);
   }
-  async scrollUpOneScreen() {
-    const innerHeight = await this.evaluate(() => window.innerHeight);
-    const distance = innerHeight * 0.7;
-    await this.mouse.wheel(0, -distance);
+  scrollUpOneScreen() {
+    return __async(this, null, function* () {
+      const innerHeight = yield this.evaluate(() => window.innerHeight);
+      const distance = innerHeight * 0.7;
+      yield this.mouse.wheel(0, -distance);
+    });
   }
-  async scrollDownOneScreen() {
-    const innerHeight = await this.evaluate(() => window.innerHeight);
-    const distance = innerHeight * 0.7;
-    await this.mouse.wheel(0, distance);
+  scrollDownOneScreen() {
+    return __async(this, null, function* () {
+      const innerHeight = yield this.evaluate(() => window.innerHeight);
+      const distance = innerHeight * 0.7;
+      yield this.mouse.wheel(0, distance);
+    });
   }
 };
 
@@ -1942,7 +2050,7 @@ var PuppeteerAgent = class extends PageAgent {
 // src/appium/page.ts
 import fs from "fs";
 import { getTmpFile as getTmpFile2 } from "@midscene/core/utils";
-import { resizeImg as resizeImg2 } from "@midscene/shared/img";
+import { base64Encoded as base64Encoded2, resizeImg as resizeImg2 } from "@midscene/shared/img";
 import { DOMParser } from "@xmldom/xmldom";
 
 // src/extractor/web-extractor.ts
@@ -2145,26 +2253,30 @@ var Page2 = class {
     this.pageType = "appium";
     this.browser = browser;
   }
-  async getElementInfos() {
-    const pageSource = await this.browser.getPageSource();
-    const { width, height } = await this.browser.getWindowSize();
-    const parser = new DOMParser();
-    const doc = parser.parseFromString(pageSource, "text/xml");
-    const infos = extractTextWithPosition2(doc).filter(
-      (element) => element.rect.height !== height && element.rect.width !== width && element.rect.left !== 0 && element.rect.top !== 0 && element.attributes.visible === "true"
-    );
-    return infos;
-  }
-  async screenshot() {
-    const { width, height } = await this.browser.getWindowSize();
-    const path3 = getTmpFile2("png");
-    const screenshotBuffer = await this.browser.saveScreenshot(path3);
-    const resizedScreenshotBuffer = await resizeImg2(screenshotBuffer, {
-      width,
-      height
+  getElementInfos() {
+    return __async(this, null, function* () {
+      const pageSource = yield this.browser.getPageSource();
+      const { width, height } = yield this.browser.getWindowSize();
+      const parser = new DOMParser();
+      const doc = parser.parseFromString(pageSource, "text/xml");
+      const infos = extractTextWithPosition2(doc).filter(
+        (element) => element.rect.height !== height && element.rect.width !== width && element.rect.left !== 0 && element.rect.top !== 0 && element.attributes.visible === "true"
+      );
+      return infos;
+    });
+  }
+  screenshotBase64() {
+    return __async(this, null, function* () {
+      const { width, height } = yield this.browser.getWindowSize();
+      const path3 = getTmpFile2("png");
+      const screenshotBuffer = yield this.browser.saveScreenshot(path3);
+      const resizedScreenshotBuffer = yield resizeImg2(screenshotBuffer, {
+        width,
+        height
+      });
+      fs.writeFileSync(path3, resizedScreenshotBuffer);
+      return base64Encoded2(path3);
     });
-    fs.writeFileSync(path3, resizedScreenshotBuffer);
-    return path3;
   }
   get mouse() {
     return {
@@ -2180,14 +2292,16 @@ var Page2 = class {
       press: (key) => this.keyboardPress(key)
     };
   }
-  async clearInput(element) {
-    if (!element) {
-      return;
-    }
-    const ele = await this.browser.$(element.locator);
-    const blank = " ";
-    await this.keyboardType(blank);
-    await ele.clearValue();
+  clearInput(element) {
+    return __async(this, null, function* () {
+      if (!element) {
+        return;
+      }
+      const ele = yield this.browser.$(element.locator);
+      const blank = " ";
+      yield this.keyboardType(blank);
+      yield ele.clearValue();
+    });
   }
   url() {
     var _a;
@@ -2203,114 +2317,139 @@ var Page2 = class {
     return "";
   }
   // Scroll to top element
-  async scrollUntilTop() {
-    const { height } = await this.browser.getWindowSize();
-    await this.mouseWheel(0, height, 100);
+  scrollUntilTop() {
+    return __async(this, null, function* () {
+      const { height } = yield this.browser.getWindowSize();
+      yield this.mouseWheel(0, height, 100);
+    });
   }
   // Scroll to bottom element
-  async scrollUntilBottom() {
-    const { height } = await this.browser.getWindowSize();
-    await this.mouseWheel(0, -height, 100);
+  scrollUntilBottom() {
+    return __async(this, null, function* () {
+      const { height } = yield this.browser.getWindowSize();
+      yield this.mouseWheel(0, -height, 100);
+    });
   }
   // Scroll up one screen
-  async scrollUpOneScreen() {
-    const { height } = await this.browser.getWindowSize();
-    await this.mouseWheel(0, height, 1e3);
+  scrollUpOneScreen() {
+    return __async(this, null, function* () {
+      const { height } = yield this.browser.getWindowSize();
+      yield this.mouseWheel(0, height, 1e3);
+    });
   }
   // Scroll down one screen
-  async scrollDownOneScreen() {
-    const { height } = await this.browser.getWindowSize();
-    await this.mouseWheel(0, -height, 1e3);
-  }
-  async keyboardType(text) {
-    const actions = [];
-    for (const char of text) {
-      actions.push({ type: "keyDown", value: char });
-      actions.push({ type: "keyUp", value: char });
-    }
-    if (!actions.length) {
-      return;
-    }
-    await this.browser.performActions([
-      {
-        type: "key",
-        id: "keyboard",
-        actions
-      }
-    ]);
+  scrollDownOneScreen() {
+    return __async(this, null, function* () {
+      const { height } = yield this.browser.getWindowSize();
+      yield this.mouseWheel(0, -height, 1e3);
+    });
   }
-  async keyboardPress(key) {
-    await this.browser.performActions([
-      {
-        type: "key",
-        id: "keyboard",
-        actions: [
-          { type: "keyDown", value: key },
-          { type: "keyUp", value: key }
-        ]
+  keyboardType(text) {
+    return __async(this, null, function* () {
+      const actions = [];
+      for (const char of text) {
+        actions.push({ type: "keyDown", value: char });
+        actions.push({ type: "keyUp", value: char });
       }
-    ]);
-  }
-  async mouseClick(x, y, button = "left") {
-    await this.mouseMove(x, y);
-    await this.browser.performActions([
-      {
-        type: "pointer",
-        id: "mouse",
-        parameters: { pointerType: "mouse" },
-        actions: [
-          { type: "pointerMove", duration: 0, x, y },
-          { type: "pointerDown", button: buttonToNumber(button) },
-          { type: "pause", duration: 100 },
-          { type: "pointerUp", button: buttonToNumber(button) }
-        ]
+      if (!actions.length) {
+        return;
       }
-    ]);
+      yield this.browser.performActions([
+        {
+          type: "key",
+          id: "keyboard",
+          actions
+        }
+      ]);
+    });
   }
-  async mouseMove(x, y) {
-    await this.browser.performActions([
-      {
-        type: "pointer",
-        id: "mouse",
-        parameters: { pointerType: "mouse" },
-        actions: [{ type: "pointerMove", duration: 0, x, y }]
-      }
-    ]);
-  }
-  async mouseWheel(deltaX, deltaY, duration = 1e3) {
-    const n = 4;
-    const windowSize = await this.browser.getWindowSize();
-    const startX = deltaX < 0 ? (n - 1) * (windowSize.width / n) : windowSize.width / n;
-    const startY = deltaY < 0 ? (n - 1) * (windowSize.height / n) : windowSize.height / n;
-    const maxNegativeDeltaX = startX;
-    const maxPositiveDeltaX = (n - 1) * (windowSize.width / n);
-    const maxNegativeDeltaY = startY;
-    const maxPositiveDeltaY = (n - 1) * (windowSize.height / n);
-    deltaX = Math.max(-maxNegativeDeltaX, Math.min(deltaX, maxPositiveDeltaX));
-    deltaY = Math.max(-maxNegativeDeltaY, Math.min(deltaY, maxPositiveDeltaY));
-    await this.browser.performActions([
-      {
-        type: "pointer",
-        id: "finger1",
-        parameters: { pointerType: "touch" },
-        actions: [
-          { type: "pointerMove", duration: 0, x: startX, y: startY },
-          { type: "pointerDown", button: 0 },
-          { type: "pause", duration },
-          {
-            type: "pointerMove",
-            duration,
-            origin: "pointer",
-            // Use 'pointer' as the starting point
-            x: deltaX,
-            // X offset relative to the starting point
-            y: deltaY
-            // Y offset relative to the starting point
-          },
-          { type: "pointerUp", button: 0 }
-        ]
-      }
-    ]);
+  keyboardPress(key) {
+    return __async(this, null, function* () {
+      yield this.browser.performActions([
+        {
+          type: "key",
+          id: "keyboard",
+          actions: [
+            { type: "keyDown", value: key },
+            { type: "keyUp", value: key }
+          ]
+        }
+      ]);
+    });
+  }
+  mouseClick(x, y, button = "left") {
+    return __async(this, null, function* () {
+      yield this.mouseMove(x, y);
+      yield this.browser.performActions([
+        {
+          type: "pointer",
+          id: "mouse",
+          parameters: { pointerType: "mouse" },
+          actions: [
+            { type: "pointerMove", duration: 0, x, y },
+            { type: "pointerDown", button: buttonToNumber(button) },
+            { type: "pause", duration: 100 },
+            { type: "pointerUp", button: buttonToNumber(button) }
+          ]
+        }
+      ]);
+    });
+  }
+  mouseMove(x, y) {
+    return __async(this, null, function* () {
+      yield this.browser.performActions([
+        {
+          type: "pointer",
+          id: "mouse",
+          parameters: { pointerType: "mouse" },
+          actions: [{ type: "pointerMove", duration: 0, x, y }]
+        }
+      ]);
+    });
+  }
+  mouseWheel(deltaX, deltaY, duration = 1e3) {
+    return __async(this, null, function* () {
+      const n = 4;
+      const windowSize = yield this.browser.getWindowSize();
+      const startX = deltaX < 0 ? (n - 1) * (windowSize.width / n) : windowSize.width / n;
+      const startY = deltaY < 0 ? (n - 1) * (windowSize.height / n) : windowSize.height / n;
+      const maxNegativeDeltaX = startX;
+      const maxPositiveDeltaX = (n - 1) * (windowSize.width / n);
+      const maxNegativeDeltaY = startY;
+      const maxPositiveDeltaY = (n - 1) * (windowSize.height / n);
+      deltaX = Math.max(-maxNegativeDeltaX, Math.min(deltaX, maxPositiveDeltaX));
+      deltaY = Math.max(-maxNegativeDeltaY, Math.min(deltaY, maxPositiveDeltaY));
+      yield this.browser.performActions([
+        {
+          type: "pointer",
+          id: "finger1",
+          parameters: { pointerType: "touch" },
+          actions: [
+            { type: "pointerMove", duration: 0, x: startX, y: startY },
+            { type: "pointerDown", button: 0 },
+            { type: "pause", duration },
+            {
+              type: "pointerMove",
+              duration,
+              origin: "pointer",
+              // Use 'pointer' as the starting point
+              x: deltaX,
+              // X offset relative to the starting point
+              y: deltaY
+              // Y offset relative to the starting point
+            },
+            { type: "pointerUp", button: 0 }
+          ]
+        }
+      ]);
+    });
+  }
+};
+
+// src/playground/agent.ts
+var StaticPageAgent = class extends PageAgent {
+  constructor(page) {
+    super(page, {});
   }
 };
 
@@ -2322,67 +2461,67 @@ import {
   resizeImg as resizeImg3,
   saveBase64Image
 } from "@midscene/shared/img";
-async function generateExtractData(page, targetDir, saveImgType) {
-  const file = await page.screenshot();
-  const screenshotBuffer = readFileSync4(file);
-  const inputImgBase64 = screenshotBuffer.toString("base64");
-  const {
-    elementsPositionInfo,
-    captureElementSnapshot,
-    elementsPositionInfoWithoutText
-  } = await getElementInfos(page);
-  const inputImagePath = path2.join(targetDir, "input.png");
-  const outputImagePath = path2.join(targetDir, "output.png");
-  const outputWithoutTextImgPath = path2.join(
-    targetDir,
-    "output_without_text.png"
-  );
-  const resizeOutputImgPath = path2.join(targetDir, "resize-output.png");
-  const snapshotJsonPath = path2.join(targetDir, "element-snapshot.json");
-  const {
-    compositeElementInfoImgBase64,
-    compositeElementInfoImgWithoutTextBase64
-  } = await processImageElementInfo({
-    elementsPositionInfo,
-    elementsPositionInfoWithoutText,
-    inputImgBase64
-  });
-  const resizeImgBase64 = await resizeImg3(inputImgBase64);
-  const existingSnapshot = existsSync2(snapshotJsonPath) ? JSON.parse(readFileSync4(snapshotJsonPath, "utf-8")) : null;
-  if (existingSnapshot && JSON.stringify(existingSnapshot) === JSON.stringify(captureElementSnapshot)) {
-    console.log("skip save snapshot for ", targetDir);
-    return;
-  }
-  if (!(saveImgType == null ? void 0 : saveImgType.disableSnapshot)) {
-    writeFileSyncWithDir(
-      snapshotJsonPath,
-      JSON.stringify(captureElementSnapshot, null, 2)
+function generateExtractData(page, targetDir, saveImgType) {
+  return __async(this, null, function* () {
+    const inputImgBase64 = yield page.screenshotBase64();
+    const {
+      elementsPositionInfo,
+      captureElementSnapshot,
+      elementsPositionInfoWithoutText
+    } = yield getElementInfos(page);
+    const inputImagePath = path2.join(targetDir, "input.png");
+    const outputImagePath = path2.join(targetDir, "output.png");
+    const outputWithoutTextImgPath = path2.join(
+      targetDir,
+      "output_without_text.png"
     );
-  }
-  if (!(saveImgType == null ? void 0 : saveImgType.disableInputImage)) {
-    await saveBase64Image({
-      base64Data: inputImgBase64,
-      outputPath: inputImagePath
+    const resizeOutputImgPath = path2.join(targetDir, "resize-output.png");
+    const snapshotJsonPath = path2.join(targetDir, "element-snapshot.json");
+    const {
+      compositeElementInfoImgBase64,
+      compositeElementInfoImgWithoutTextBase64
+    } = yield processImageElementInfo({
+      elementsPositionInfo,
+      elementsPositionInfoWithoutText,
+      inputImgBase64
     });
-  }
-  if (!(saveImgType == null ? void 0 : saveImgType.disableOutputImage)) {
-    await saveBase64Image({
-      base64Data: compositeElementInfoImgBase64,
-      outputPath: outputImagePath
-    });
-  }
-  if (!(saveImgType == null ? void 0 : saveImgType.disableOutputWithoutTextImg)) {
-    await saveBase64Image({
-      base64Data: compositeElementInfoImgWithoutTextBase64,
-      outputPath: outputWithoutTextImgPath
-    });
-  }
-  if (!(saveImgType == null ? void 0 : saveImgType.disableResizeOutputImg)) {
-    await saveBase64Image({
-      base64Data: resizeImgBase64,
-      outputPath: resizeOutputImgPath
-    });
-  }
+    const resizeImgBase64 = yield resizeImg3(inputImgBase64);
+    const existingSnapshot = existsSync2(snapshotJsonPath) ? JSON.parse(readFileSync4(snapshotJsonPath, "utf-8")) : null;
+    if (existingSnapshot && JSON.stringify(existingSnapshot) === JSON.stringify(captureElementSnapshot)) {
+      console.log("skip save snapshot for ", targetDir);
+      return;
+    }
+    if (!(saveImgType == null ? void 0 : saveImgType.disableSnapshot)) {
+      writeFileSyncWithDir(
+        snapshotJsonPath,
+        JSON.stringify(captureElementSnapshot, null, 2)
+      );
+    }
+    if (!(saveImgType == null ? void 0 : saveImgType.disableInputImage)) {
+      yield saveBase64Image({
+        base64Data: inputImgBase64,
+        outputPath: inputImagePath
+      });
+    }
+    if (!(saveImgType == null ? void 0 : saveImgType.disableOutputImage)) {
+      yield saveBase64Image({
+        base64Data: compositeElementInfoImgBase64,
+        outputPath: outputImagePath
+      });
+    }
+    if (!(saveImgType == null ? void 0 : saveImgType.disableOutputWithoutTextImg)) {
+      yield saveBase64Image({
+        base64Data: compositeElementInfoImgWithoutTextBase64,
+        outputPath: outputWithoutTextImgPath
+      });
+    }
+    if (!(saveImgType == null ? void 0 : saveImgType.disableResizeOutputImg)) {
+      yield saveBase64Image({
+        base64Data: resizeImgBase64,
+        outputPath: resizeOutputImgPath
+      });
+    }
+  });
 }
 function ensureDirectoryExistence(filePath) {
   const dirname = path2.dirname(filePath);
@@ -2396,21 +2535,23 @@ function writeFileSyncWithDir(filePath, content, options = {}) {
   ensureDirectoryExistence(filePath);
   writeFileSync2(filePath, content, options);
 }
-async function getElementInfos(page) {
-  const captureElementSnapshot = await page.getElementInfos();
-  const elementsPositionInfoWithoutText = captureElementSnapshot.filter(
-    (elementInfo) => {
-      if (elementInfo.attributes.nodeType === NodeType3.TEXT) {
-        return false;
+function getElementInfos(page) {
+  return __async(this, null, function* () {
+    const captureElementSnapshot = yield page.getElementInfos();
+    const elementsPositionInfoWithoutText = captureElementSnapshot.filter(
+      (elementInfo) => {
+        if (elementInfo.attributes.nodeType === NodeType3.TEXT) {
+          return false;
+        }
+        return true;
       }
-      return true;
-    }
-  );
-  return {
-    elementsPositionInfo: captureElementSnapshot,
-    captureElementSnapshot,
-    elementsPositionInfoWithoutText
-  };
+    );
+    return {
+      elementsPositionInfo: captureElementSnapshot,
+      captureElementSnapshot,
+      elementsPositionInfoWithoutText
+    };
+  });
 }
 export {
   PageAgent as AppiumAgent,
@@ -2418,6 +2559,7 @@ export {
   PageAgent as PlaywrightAgent,
   PlaywrightAiFixture,
   PuppeteerAgent,
+  StaticPageAgent,
   generateExtractData
 };
 /*! Bundled license information: