@midscene/web 0.7.1 → 0.7.2-beta-20241024094141.0

package/dist/es/midscene-playground.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({
@@ -684,23 +704,20 @@ var require_main = __commonJS({
 
 // src/playground/server.ts
 import assert3 from "assert";
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID } from "crypto";
 import { existsSync as existsSync2, readFileSync as readFileSync3, writeFileSync } from "fs";
 import { join as join2 } from "path";
 
 // 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 {
@@ -728,56 +745,59 @@ 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
-  };
 }
 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");
@@ -808,7 +828,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."
     );
@@ -826,8 +846,8 @@ function generateCacheId(fileName) {
 var ERROR_CODE_NOT_IMPLEMENTED_AS_DESIGNED = "NOT_IMPLEMENTED_AS_DESIGNED";
 
 // src/playground/server.ts
-var import_dotenv = __toESM(require_main());
 import { getTmpDir } from "@midscene/core/utils";
+import { ifInBrowser as ifInBrowser2 } from "@midscene/shared/utils";
 import cors from "cors";
 import express from "express";
 
@@ -846,7 +866,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";
@@ -856,10 +875,11 @@ 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";
 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: []
@@ -941,11 +961,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;
         }
@@ -957,7 +983,10 @@ var TaskCache = class {
     return void 0;
   }
   writeCacheToFile() {
-    const midscenePkgInfo = getMidscenePkgInfo(__dirname);
+    const midscenePkgInfo = getRunningPkgInfo();
+    if (!midscenePkgInfo) {
+      return;
+    }
     writeLogFile({
       fileName: `${this.cacheId}`,
       fileExt: "json",
@@ -978,423 +1007,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
+      };
+    });
   }
 };
 
@@ -1439,72 +1480,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'`
+      );
+    });
   }
 };
 
@@ -1516,8 +1568,6 @@ var StaticPageAgent = class extends PageAgent {
 };
 
 // src/playground/static-page.ts
-import { getTmpFile } from "@midscene/core/utils";
-import { saveBase64Image } from "@midscene/shared/img";
 var ThrowNotImplemented = (methodName) => {
   throw new Error(
     `The method "${methodName}" is not implemented as designed since this is a static UI context. (${ERROR_CODE_NOT_IMPLEMENTED_AS_DESIGNED})`
@@ -1537,38 +1587,52 @@ var StaticPage = class {
     };
     this.uiContext = uiContext;
   }
-  async getElementInfos() {
-    return ThrowNotImplemented("getElementInfos");
+  getElementInfos() {
+    return __async(this, null, function* () {
+      return ThrowNotImplemented("getElementInfos");
+    });
   }
-  async screenshot() {
-    const base64 = this.uiContext.screenshotBase64;
-    if (!base64) {
-      throw new Error("screenshot base64 is empty");
-    }
-    const tmpFilePath = getTmpFile("png");
-    await saveBase64Image({ base64Data: base64, outputPath: tmpFilePath });
-    return tmpFilePath;
+  screenshotBase64() {
+    return __async(this, null, function* () {
+      const base64 = this.uiContext.screenshotBase64;
+      if (!base64) {
+        throw new Error("screenshot base64 is empty");
+      }
+      return base64;
+    });
   }
   url() {
     return this.uiContext.url;
   }
-  async scrollUntilTop() {
-    return ThrowNotImplemented("scrollUntilTop");
+  scrollUntilTop() {
+    return __async(this, null, function* () {
+      return ThrowNotImplemented("scrollUntilTop");
+    });
   }
-  async scrollUntilBottom() {
-    return ThrowNotImplemented("scrollUntilBottom");
+  scrollUntilBottom() {
+    return __async(this, null, function* () {
+      return ThrowNotImplemented("scrollUntilBottom");
+    });
   }
-  async scrollUpOneScreen() {
-    return ThrowNotImplemented("scrollUpOneScreen");
+  scrollUpOneScreen() {
+    return __async(this, null, function* () {
+      return ThrowNotImplemented("scrollUpOneScreen");
+    });
   }
-  async scrollDownOneScreen() {
-    return ThrowNotImplemented("scrollDownOneScreen");
+  scrollDownOneScreen() {
+    return __async(this, null, function* () {
+      return ThrowNotImplemented("scrollDownOneScreen");
+    });
   }
-  async clearInput() {
-    return ThrowNotImplemented("clearInput");
+  clearInput() {
+    return __async(this, null, function* () {
+      return ThrowNotImplemented("clearInput");
+    });
   }
-  async _forceUsePageContext() {
-    return this.uiContext;
+  _forceUsePageContext() {
+    return __async(this, null, function* () {
+      return this.uiContext;
+    });
   }
 };
 
@@ -1582,123 +1646,128 @@ var errorHandler = (err, req, res, next) => {
     error: err.message
   });
 };
-var setup = () => {
-  import_dotenv.default.config();
-};
+var setup = () => __async(void 0, null, function* () {
+  if (!ifInBrowser2) {
+    const dotenv = yield Promise.resolve().then(() => __toESM(require_main()));
+    dotenv.config();
+  }
+});
 var PlaygroundServer = class {
   constructor() {
     this.app = express();
     this.tmpDir = getTmpDir();
     setup();
   }
-  filePathForUuid(uuid) {
-    return join2(this.tmpDir, `${uuid}.json`);
+  filePathForUuid(uuid2) {
+    return join2(this.tmpDir, `${uuid2}.json`);
   }
-  saveContextFile(uuid, context) {
-    const tmpFile = this.filePathForUuid(uuid);
+  saveContextFile(uuid2, context) {
+    const tmpFile = this.filePathForUuid(uuid2);
     console.log(`save context file: ${tmpFile}`);
     writeFileSync(tmpFile, context);
     return tmpFile;
   }
-  async launch() {
-    this.app.use(errorHandler);
-    this.app.use(
-      cors({
-        origin: "*",
-        credentials: true
-      })
-    );
-    this.app.get("/status", cors(), async (req, res) => {
-      res.send({
-        status: "ok"
-      });
-    });
-    this.app.get("/", (req, res) => {
-      res.sendFile(join2(staticPath, "index.html"));
-    });
-    this.app.get("/playground/:uuid", async (req, res) => {
-      res.sendFile(join2(staticPath, "index.html"));
-    });
-    this.app.get("/context/:uuid", async (req, res) => {
-      const { uuid } = req.params;
-      const contextFile = this.filePathForUuid(uuid);
-      assert3(existsSync2(contextFile), "Context not found");
-      const context = readFileSync3(contextFile, "utf8");
-      res.json({
-        context
+  launch() {
+    return __async(this, null, function* () {
+      this.app.use(errorHandler);
+      this.app.use(
+        cors({
+          origin: "*",
+          credentials: true
+        })
+      );
+      this.app.get("/status", cors(), (req, res) => __async(this, null, function* () {
+        res.send({
+          status: "ok"
+        });
+      }));
+      this.app.get("/", (req, res) => {
+        res.sendFile(join2(staticPath, "index.html"));
       });
-    });
-    this.app.post(
-      "/playground-with-context",
-      express.json({ limit: "50mb" }),
-      async (req, res) => {
-        const context = req.body.context;
-        assert3(context, "context is required");
-        const uuid = randomUUID2();
-        this.saveContextFile(uuid, context);
-        return res.json({
-          location: `/playground/${uuid}`,
-          uuid
+      this.app.get("/playground/:uuid", (req, res) => __async(this, null, function* () {
+        res.sendFile(join2(staticPath, "index.html"));
+      }));
+      this.app.get("/context/:uuid", (req, res) => __async(this, null, function* () {
+        const { uuid: uuid2 } = req.params;
+        const contextFile = this.filePathForUuid(uuid2);
+        assert3(existsSync2(contextFile), "Context not found");
+        const context = readFileSync3(contextFile, "utf8");
+        res.json({
+          context
         });
-      }
-    );
-    this.app.post(
-      "/execute",
-      express.json({ limit: "30mb" }),
-      async (req, res) => {
-        const { context, type, prompt } = req.body;
-        assert3(context, "context is required");
-        assert3(type, "type is required");
-        assert3(prompt, "prompt is required");
-        const requestId = agentRequestCount++;
-        console.log(`handle request: #${requestId}, ${type}, ${prompt}`);
-        const page = new StaticPage(context);
-        const agent = new StaticPageAgent(page);
-        const response = {
-          result: null,
-          dump: null,
-          error: null
-        };
-        try {
-          if (type === "aiQuery") {
-            response.result = await agent.aiQuery(prompt);
-          } else if (type === "aiAction") {
-            response.result = await agent.aiAction(prompt);
-          } else if (type === "aiAssert") {
-            response.result = await agent.aiAssert(prompt, void 0, {
-              keepRawResponse: true
-            });
-          } else {
-            response.error = `Unknown type: ${type}`;
+      }));
+      this.app.post(
+        "/playground-with-context",
+        express.json({ limit: "50mb" }),
+        (req, res) => __async(this, null, function* () {
+          const context = req.body.context;
+          assert3(context, "context is required");
+          const uuid2 = randomUUID();
+          this.saveContextFile(uuid2, context);
+          return res.json({
+            location: `/playground/${uuid2}`,
+            uuid: uuid2
+          });
+        })
+      );
+      this.app.post(
+        "/execute",
+        express.json({ limit: "30mb" }),
+        (req, res) => __async(this, null, function* () {
+          const { context, type, prompt } = req.body;
+          assert3(context, "context is required");
+          assert3(type, "type is required");
+          assert3(prompt, "prompt is required");
+          const requestId = agentRequestCount++;
+          console.log(`handle request: #${requestId}, ${type}, ${prompt}`);
+          const page = new StaticPage(context);
+          const agent = new StaticPageAgent(page);
+          const response = {
+            result: null,
+            dump: null,
+            error: null
+          };
+          try {
+            if (type === "aiQuery") {
+              response.result = yield agent.aiQuery(prompt);
+            } else if (type === "aiAction") {
+              response.result = yield agent.aiAction(prompt);
+            } else if (type === "aiAssert") {
+              response.result = yield agent.aiAssert(prompt, void 0, {
+                keepRawResponse: true
+              });
+            } else {
+              response.error = `Unknown type: ${type}`;
+            }
+          } catch (error) {
+            if (!error.message.includes(ERROR_CODE_NOT_IMPLEMENTED_AS_DESIGNED)) {
+              response.error = error.message;
+            }
           }
-        } catch (error) {
-          if (!error.message.includes(ERROR_CODE_NOT_IMPLEMENTED_AS_DESIGNED)) {
-            response.error = error.message;
+          try {
+            response.dump = JSON.parse(agent.dumpDataString());
+            agent.writeOutActionDumps();
+          } catch (error) {
+            console.error(
+              `write out dump failed: #${requestId}, ${error.message}`
+            );
           }
-        }
-        try {
-          response.dump = JSON.parse(agent.dumpDataString());
-          agent.writeOutActionDumps();
-        } catch (error) {
-          console.error(
-            `write out dump failed: #${requestId}, ${error.message}`
-          );
-        }
-        res.send(response);
-        if (response.error) {
-          console.error(
-            `handle request failed: #${requestId}, ${response.error}`
-          );
-        } else {
-          console.log(`handle request done: #${requestId}`);
-        }
-      }
-    );
-    return new Promise((resolve, reject) => {
-      const port = this.port || defaultPort;
-      this.server = this.app.listen(port, () => {
-        this.port = port;
-        resolve(this);
+          res.send(response);
+          if (response.error) {
+            console.error(
+              `handle request failed: #${requestId}, ${response.error}`
+            );
+          } else {
+            console.log(`handle request done: #${requestId}`);
+          }
+        })
+      );
+      return new Promise((resolve, reject) => {
+        const port = this.port || defaultPort;
+        this.server = this.app.listen(port, () => {
+          this.port = port;
+          resolve(this);
+        });
       });
     });
   }