@midscene/web 0.7.1 → 0.7.2-beta-20241024094141.0

package/dist/lib/playground.js

@@ -46,6 +46,26 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), 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({
@@ -342,378 +362,24 @@ var require_dayjs_min = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/dotenv@16.4.5/node_modules/dotenv/package.json
-var require_package = __commonJS({
-  "../../node_modules/.pnpm/dotenv@16.4.5/node_modules/dotenv/package.json"(exports, module2) {
-    module2.exports = {
-      name: "dotenv",
-      version: "16.4.5",
-      description: "Loads environment variables from .env file",
-      main: "lib/main.js",
-      types: "lib/main.d.ts",
-      exports: {
-        ".": {
-          types: "./lib/main.d.ts",
-          require: "./lib/main.js",
-          default: "./lib/main.js"
-        },
-        "./config": "./config.js",
-        "./config.js": "./config.js",
-        "./lib/env-options": "./lib/env-options.js",
-        "./lib/env-options.js": "./lib/env-options.js",
-        "./lib/cli-options": "./lib/cli-options.js",
-        "./lib/cli-options.js": "./lib/cli-options.js",
-        "./package.json": "./package.json"
-      },
-      scripts: {
-        "dts-check": "tsc --project tests/types/tsconfig.json",
-        lint: "standard",
-        "lint-readme": "standard-markdown",
-        pretest: "npm run lint && npm run dts-check",
-        test: "tap tests/*.js --100 -Rspec",
-        "test:coverage": "tap --coverage-report=lcov",
-        prerelease: "npm test",
-        release: "standard-version"
-      },
-      repository: {
-        type: "git",
-        url: "git://github.com/motdotla/dotenv.git"
-      },
-      funding: "https://dotenvx.com",
-      keywords: [
-        "dotenv",
-        "env",
-        ".env",
-        "environment",
-        "variables",
-        "config",
-        "settings"
-      ],
-      readmeFilename: "README.md",
-      license: "BSD-2-Clause",
-      devDependencies: {
-        "@definitelytyped/dtslint": "^0.0.133",
-        "@types/node": "^18.11.3",
-        decache: "^4.6.1",
-        sinon: "^14.0.1",
-        standard: "^17.0.0",
-        "standard-markdown": "^7.1.0",
-        "standard-version": "^9.5.0",
-        tap: "^16.3.0",
-        tar: "^6.1.11",
-        typescript: "^4.8.4"
-      },
-      engines: {
-        node: ">=12"
-      },
-      browser: {
-        fs: false
-      }
-    };
-  }
-});
-
-// ../../node_modules/.pnpm/dotenv@16.4.5/node_modules/dotenv/lib/main.js
-var require_main = __commonJS({
-  "../../node_modules/.pnpm/dotenv@16.4.5/node_modules/dotenv/lib/main.js"(exports, module2) {
-    "use strict";
-    var fs = require("fs");
-    var path2 = require("path");
-    var os = require("os");
-    var crypto = require("crypto");
-    var packageJson = require_package();
-    var version = packageJson.version;
-    var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
-    function parse(src) {
-      const obj = {};
-      let lines = src.toString();
-      lines = lines.replace(/\r\n?/mg, "\n");
-      let match;
-      while ((match = LINE.exec(lines)) != null) {
-        const key = match[1];
-        let value = match[2] || "";
-        value = value.trim();
-        const maybeQuote = value[0];
-        value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
-        if (maybeQuote === '"') {
-          value = value.replace(/\\n/g, "\n");
-          value = value.replace(/\\r/g, "\r");
-        }
-        obj[key] = value;
-      }
-      return obj;
-    }
-    function _parseVault(options) {
-      const vaultPath = _vaultPath(options);
-      const result = DotenvModule.configDotenv({ path: vaultPath });
-      if (!result.parsed) {
-        const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
-        err.code = "MISSING_DATA";
-        throw err;
-      }
-      const keys = _dotenvKey(options).split(",");
-      const length = keys.length;
-      let decrypted;
-      for (let i = 0; i < length; i++) {
-        try {
-          const key = keys[i].trim();
-          const attrs = _instructions(result, key);
-          decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
-          break;
-        } catch (error) {
-          if (i + 1 >= length) {
-            throw error;
-          }
-        }
-      }
-      return DotenvModule.parse(decrypted);
-    }
-    function _log(message) {
-      console.log(`[dotenv@${version}][INFO] ${message}`);
-    }
-    function _warn(message) {
-      console.log(`[dotenv@${version}][WARN] ${message}`);
-    }
-    function _debug(message) {
-      console.log(`[dotenv@${version}][DEBUG] ${message}`);
-    }
-    function _dotenvKey(options) {
-      if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
-        return options.DOTENV_KEY;
-      }
-      if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
-        return process.env.DOTENV_KEY;
-      }
-      return "";
-    }
-    function _instructions(result, dotenvKey) {
-      let uri;
-      try {
-        uri = new URL(dotenvKey);
-      } catch (error) {
-        if (error.code === "ERR_INVALID_URL") {
-          const err = new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
-          err.code = "INVALID_DOTENV_KEY";
-          throw err;
-        }
-        throw error;
-      }
-      const key = uri.password;
-      if (!key) {
-        const err = new Error("INVALID_DOTENV_KEY: Missing key part");
-        err.code = "INVALID_DOTENV_KEY";
-        throw err;
-      }
-      const environment = uri.searchParams.get("environment");
-      if (!environment) {
-        const err = new Error("INVALID_DOTENV_KEY: Missing environment part");
-        err.code = "INVALID_DOTENV_KEY";
-        throw err;
-      }
-      const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
-      const ciphertext = result.parsed[environmentKey];
-      if (!ciphertext) {
-        const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
-        err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
-        throw err;
-      }
-      return { ciphertext, key };
-    }
-    function _vaultPath(options) {
-      let possibleVaultPath = null;
-      if (options && options.path && options.path.length > 0) {
-        if (Array.isArray(options.path)) {
-          for (const filepath of options.path) {
-            if (fs.existsSync(filepath)) {
-              possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
-            }
-          }
-        } else {
-          possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
-        }
-      } else {
-        possibleVaultPath = path2.resolve(process.cwd(), ".env.vault");
-      }
-      if (fs.existsSync(possibleVaultPath)) {
-        return possibleVaultPath;
-      }
-      return null;
-    }
-    function _resolveHome(envPath) {
-      return envPath[0] === "~" ? path2.join(os.homedir(), envPath.slice(1)) : envPath;
-    }
-    function _configVault(options) {
-      _log("Loading env from encrypted .env.vault");
-      const parsed = DotenvModule._parseVault(options);
-      let processEnv = process.env;
-      if (options && options.processEnv != null) {
-        processEnv = options.processEnv;
-      }
-      DotenvModule.populate(processEnv, parsed, options);
-      return { parsed };
-    }
-    function configDotenv(options) {
-      const dotenvPath = path2.resolve(process.cwd(), ".env");
-      let encoding = "utf8";
-      const debug = Boolean(options && options.debug);
-      if (options && options.encoding) {
-        encoding = options.encoding;
-      } else {
-        if (debug) {
-          _debug("No encoding is specified. UTF-8 is used by default");
-        }
-      }
-      let optionPaths = [dotenvPath];
-      if (options && options.path) {
-        if (!Array.isArray(options.path)) {
-          optionPaths = [_resolveHome(options.path)];
-        } else {
-          optionPaths = [];
-          for (const filepath of options.path) {
-            optionPaths.push(_resolveHome(filepath));
-          }
-        }
-      }
-      let lastError;
-      const parsedAll = {};
-      for (const path3 of optionPaths) {
-        try {
-          const parsed = DotenvModule.parse(fs.readFileSync(path3, { encoding }));
-          DotenvModule.populate(parsedAll, parsed, options);
-        } catch (e) {
-          if (debug) {
-            _debug(`Failed to load ${path3} ${e.message}`);
-          }
-          lastError = e;
-        }
-      }
-      let processEnv = process.env;
-      if (options && options.processEnv != null) {
-        processEnv = options.processEnv;
-      }
-      DotenvModule.populate(processEnv, parsedAll, options);
-      if (lastError) {
-        return { parsed: parsedAll, error: lastError };
-      } else {
-        return { parsed: parsedAll };
-      }
-    }
-    function config(options) {
-      if (_dotenvKey(options).length === 0) {
-        return DotenvModule.configDotenv(options);
-      }
-      const vaultPath = _vaultPath(options);
-      if (!vaultPath) {
-        _warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
-        return DotenvModule.configDotenv(options);
-      }
-      return DotenvModule._configVault(options);
-    }
-    function decrypt(encrypted, keyStr) {
-      const key = Buffer.from(keyStr.slice(-64), "hex");
-      let ciphertext = Buffer.from(encrypted, "base64");
-      const nonce = ciphertext.subarray(0, 12);
-      const authTag = ciphertext.subarray(-16);
-      ciphertext = ciphertext.subarray(12, -16);
-      try {
-        const aesgcm = crypto.createDecipheriv("aes-256-gcm", key, nonce);
-        aesgcm.setAuthTag(authTag);
-        return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
-      } catch (error) {
-        const isRange = error instanceof RangeError;
-        const invalidKeyLength = error.message === "Invalid key length";
-        const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
-        if (isRange || invalidKeyLength) {
-          const err = new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
-          err.code = "INVALID_DOTENV_KEY";
-          throw err;
-        } else if (decryptionFailed) {
-          const err = new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
-          err.code = "DECRYPTION_FAILED";
-          throw err;
-        } else {
-          throw error;
-        }
-      }
-    }
-    function populate(processEnv, parsed, options = {}) {
-      const debug = Boolean(options && options.debug);
-      const override = Boolean(options && options.override);
-      if (typeof parsed !== "object") {
-        const err = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
-        err.code = "OBJECT_REQUIRED";
-        throw err;
-      }
-      for (const key of Object.keys(parsed)) {
-        if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
-          if (override === true) {
-            processEnv[key] = parsed[key];
-          }
-          if (debug) {
-            if (override === true) {
-              _debug(`"${key}" is already defined and WAS overwritten`);
-            } else {
-              _debug(`"${key}" is already defined and was NOT overwritten`);
-            }
-          }
-        } else {
-          processEnv[key] = parsed[key];
-        }
-      }
-    }
-    var DotenvModule = {
-      configDotenv,
-      _configVault,
-      _parseVault,
-      config,
-      decrypt,
-      parse,
-      populate
-    };
-    module2.exports.configDotenv = DotenvModule.configDotenv;
-    module2.exports._configVault = DotenvModule._configVault;
-    module2.exports._parseVault = DotenvModule._parseVault;
-    module2.exports.config = DotenvModule.config;
-    module2.exports.decrypt = DotenvModule.decrypt;
-    module2.exports.parse = DotenvModule.parse;
-    module2.exports.populate = DotenvModule.populate;
-    module2.exports = DotenvModule;
-  }
-});
-
 // src/playground/index.ts
 var playground_exports = {};
 __export(playground_exports, {
-  PlaygroundServer: () => PlaygroundServer,
+  ERROR_CODE_NOT_IMPLEMENTED_AS_DESIGNED: () => ERROR_CODE_NOT_IMPLEMENTED_AS_DESIGNED,
   StaticPage: () => StaticPage,
   StaticPageAgent: () => StaticPageAgent
 });
 module.exports = __toCommonJS(playground_exports);
 
-// src/common/agent.ts
-var import_utils5 = require("@midscene/core/utils");
-
-// src/common/tasks.ts
-var import_node_assert2 = __toESM(require("assert"));
-var import_core = require("@midscene/core");
-var import_utils3 = require("@midscene/core/utils");
-var import_img3 = require("@midscene/shared/img");
-
-// src/common/task-cache.ts
-var import_node_fs2 = require("fs");
-var import_node_path2 = require("path");
-var import_utils = require("@midscene/core/utils");
-var import_fs2 = require("@midscene/shared/fs");
-
 // src/common/utils.ts
 var import_node_assert = __toESM(require("assert"));
-var import_node_crypto = require("crypto");
 var import_node_fs = require("fs");
 var import_node_path = __toESM(require("path"));
 var import_constants = require("@midscene/shared/constants");
 var import_fs = require("@midscene/shared/fs");
 var import_img = require("@midscene/shared/img");
 var import_img2 = require("@midscene/shared/img");
+var import_utils = require("@midscene/shared/utils");
 var import_dayjs = __toESM(require_dayjs_min());
 
 // src/web-element.ts
@@ -742,56 +408,59 @@ var WebElementInfo = class {
 };
 
 // src/common/utils.ts
-async function parseContextFromWebPage(page, _opt) {
-  (0, import_node_assert.default)(page, "page is required");
-  if (page._forceUsePageContext) {
-    return await page._forceUsePageContext();
-  }
-  const url = page.url();
-  const file = await page.screenshot();
-  const screenshotBase64 = (0, import_img.base64Encoded)(file);
-  const captureElementSnapshot = await page.getElementInfos();
-  const elementsInfo = await alignElements(captureElementSnapshot, page);
-  const elementsPositionInfoWithoutText = elementsInfo.filter((elementInfo) => {
-    if (elementInfo.attributes.nodeType === import_constants.NodeType.TEXT) {
-      return false;
+function parseContextFromWebPage(page, _opt) {
+  return __async(this, null, function* () {
+    (0, import_node_assert.default)(page, "page is required");
+    if (page._forceUsePageContext) {
+      return yield page._forceUsePageContext();
     }
-    return true;
-  });
-  const size = await (0, import_img.imageInfoOfBase64)(screenshotBase64);
-  const screenshotBase64WithElementMarker = await (0, import_img2.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 === import_constants.NodeType.TEXT) {
+        return false;
+      }
+      return true;
+    });
+    const size = yield (0, import_img.imageInfoOfBase64)(screenshotBase64);
+    const screenshotBase64WithElementMarker = yield (0, import_img2.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");
@@ -822,7 +491,7 @@ var testFileIndex = /* @__PURE__ */ new Map();
 function generateCacheId(fileName) {
   let taskFile = fileName || getCurrentExecutionFile();
   if (!taskFile) {
-    taskFile = (0, import_node_crypto.randomUUID)();
+    taskFile = (0, import_utils.uuid)();
     console.warn(
       "Midscene - using random UUID for cache id. Cache may be invalid."
     );
@@ -839,10 +508,23 @@ function generateCacheId(fileName) {
 }
 var ERROR_CODE_NOT_IMPLEMENTED_AS_DESIGNED = "NOT_IMPLEMENTED_AS_DESIGNED";
 
+// src/common/agent.ts
+var import_utils7 = require("@midscene/core/utils");
+
+// src/common/tasks.ts
+var import_node_assert2 = __toESM(require("assert"));
+var import_core = require("@midscene/core");
+var import_utils5 = require("@midscene/core/utils");
+
 // src/common/task-cache.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+var import_utils2 = require("@midscene/core/utils");
+var import_fs2 = require("@midscene/shared/fs");
+var import_utils3 = require("@midscene/shared/utils");
 var TaskCache = class {
   constructor(opts) {
-    this.midscenePkgInfo = (0, import_fs2.getMidscenePkgInfo)(__dirname);
+    this.midscenePkgInfo = (0, import_fs2.getRunningPkgInfo)();
     this.cacheId = generateCacheId(opts == null ? void 0 : opts.fileName);
     this.cache = this.readCacheFromFile() || {
       aiTasks: []
@@ -924,11 +606,17 @@ var TaskCache = class {
     return this.newCache;
   }
   readCacheFromFile() {
-    const cacheFile = (0, import_node_path2.join)((0, import_utils.getLogDirByType)("cache"), `${this.cacheId}.json`);
+    if (import_utils3.ifInBrowser) {
+      return void 0;
+    }
+    const cacheFile = (0, import_node_path2.join)((0, import_utils2.getLogDirByType)("cache"), `${this.cacheId}.json`);
     if (process.env.MIDSCENE_CACHE === "true" && (0, import_node_fs2.existsSync)(cacheFile)) {
       try {
         const data = (0, import_node_fs2.readFileSync)(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;
         }
@@ -940,11 +628,14 @@ var TaskCache = class {
     return void 0;
   }
   writeCacheToFile() {
-    const midscenePkgInfo = (0, import_fs2.getMidscenePkgInfo)(__dirname);
-    (0, import_utils.writeLogFile)({
+    const midscenePkgInfo = (0, import_fs2.getRunningPkgInfo)();
+    if (!midscenePkgInfo) {
+      return;
+    }
+    (0, import_utils2.writeLogFile)({
       fileName: `${this.cacheId}`,
       fileExt: "json",
-      fileContent: (0, import_utils.stringifyDumpData)(
+      fileContent: (0, import_utils2.stringifyDumpData)(
         __spreadValues({
           pkgName: midscenePkgInfo.name,
           pkgVersion: midscenePkgInfo.version,
@@ -961,423 +652,435 @@ var TaskCache = class {
 var PageTaskExecutor = class {
   constructor(page, opts) {
     this.page = page;
-    this.insight = new import_core.Insight(async () => {
-      return await parseContextFromWebPage(page);
-    });
+    this.insight = new import_core.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: (0, import_img3.base64Encoded)(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 (0, import_utils3.sleep)(1e3);
-          const shot2 = await this.recordScreenshot("after Action");
+          yield (0, import_utils5.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);
-                (0, import_node_assert2.default)(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);
+                  (0, import_node_assert2.default)(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) => {
-            (0, import_node_assert2.default)(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 }) => {
-            (0, import_node_assert2.default)(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 }) => {
-            (0, import_node_assert2.default)(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 (0, import_utils3.sleep)(taskParam.timeMs || 3e3);
-          }
-        };
-        return taskActionSleep;
-      }
-      if (plan2.type === "Error") {
-        const taskActionError = {
-          type: "Action",
-          subType: "Error",
-          param: plan2.param,
-          executor: async (taskParam) => {
-            (0, import_node_assert2.default)(
-              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* () {
+              (0, import_node_assert2.default)(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 }) {
+              (0, import_node_assert2.default)(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 }) {
+              (0, import_node_assert2.default)(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 (0, import_utils5.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* () {
+              (0, import_node_assert2.default)(
+                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 import_core.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 (0, import_core.plan)(param.userPrompt, {
-            context: pageContext
+  action(userPrompt) {
+    return __async(this, null, function* () {
+      const taskExecutor = new import_core.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 (0, import_core.plan)(param.userPrompt, {
+              context: pageContext
+            });
+          }
+          (0, import_node_assert2.default)(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
           });
-        }
-        (0, import_node_assert2.default)(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 import_core.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 import_core.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 import_core.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 import_core.Executor(description);
-    const { timeoutMs, checkIntervalMs } = opt;
-    (0, import_node_assert2.default)(assertion, "No assertion for waitFor");
-    (0, import_node_assert2.default)(timeoutMs, "No timeoutMs for waitFor");
-    (0, import_node_assert2.default)(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 import_core.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 import_core.Executor(description);
+      const { timeoutMs, checkIntervalMs } = opt;
+      (0, import_node_assert2.default)(assertion, "No assertion for waitFor");
+      (0, import_node_assert2.default)(timeoutMs, "No timeoutMs for waitFor");
+      (0, import_node_assert2.default)(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
+      };
+    });
   }
 };
 
@@ -1411,83 +1114,94 @@ var PageAgent = class {
   dumpDataString() {
     this.dump.groupName = this.opts.groupName;
     this.dump.groupDescription = this.opts.groupDescription;
-    return (0, import_utils5.stringifyDumpData)(this.dump);
+    return (0, import_utils7.stringifyDumpData)(this.dump);
   }
   writeOutActionDumps() {
     const { generateReport, autoPrintReportMsg } = this.opts;
-    this.reportFile = (0, import_utils5.writeLogFile)({
+    this.reportFile = (0, import_utils7.writeLogFile)({
       fileName: this.reportFileName,
-      fileExt: import_utils5.groupedActionDumpFileExt,
+      fileExt: import_utils7.groupedActionDumpFileExt,
       fileContent: this.dumpDataString(),
       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'`
+      );
+    });
   }
 };
 
@@ -1498,19 +1212,7 @@ var StaticPageAgent = class extends PageAgent {
   }
 };
 
-// src/playground/server.ts
-var import_node_assert3 = __toESM(require("assert"));
-var import_node_crypto2 = require("crypto");
-var import_node_fs3 = require("fs");
-var import_node_path3 = require("path");
-var import_utils10 = require("@midscene/core/utils");
-var import_cors = __toESM(require("cors"));
-var import_dotenv = __toESM(require_main());
-var import_express = __toESM(require("express"));
-
 // src/playground/static-page.ts
-var import_utils8 = require("@midscene/core/utils");
-var import_img4 = require("@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})`
@@ -1530,180 +1232,57 @@ 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 = (0, import_utils8.getTmpFile)("png");
-    await (0, import_img4.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");
-  }
-  async scrollUntilBottom() {
-    return ThrowNotImplemented("scrollUntilBottom");
-  }
-  async scrollUpOneScreen() {
-    return ThrowNotImplemented("scrollUpOneScreen");
-  }
-  async scrollDownOneScreen() {
-    return ThrowNotImplemented("scrollDownOneScreen");
-  }
-  async clearInput() {
-    return ThrowNotImplemented("clearInput");
-  }
-  async _forceUsePageContext() {
-    return this.uiContext;
-  }
-};
-
-// src/playground/server.ts
-var defaultPort = 5800;
-var staticPath = (0, import_node_path3.join)(__dirname, "../../static");
-var agentRequestCount = 1;
-var errorHandler = (err, req, res, next) => {
-  console.error(err);
-  res.status(500).json({
-    error: err.message
-  });
-};
-var setup = () => {
-  import_dotenv.default.config();
-};
-var PlaygroundServer = class {
-  constructor() {
-    this.app = (0, import_express.default)();
-    this.tmpDir = (0, import_utils10.getTmpDir)();
-    setup();
-  }
-  filePathForUuid(uuid) {
-    return (0, import_node_path3.join)(this.tmpDir, `${uuid}.json`);
-  }
-  saveContextFile(uuid, context) {
-    const tmpFile = this.filePathForUuid(uuid);
-    console.log(`save context file: ${tmpFile}`);
-    (0, import_node_fs3.writeFileSync)(tmpFile, context);
-    return tmpFile;
-  }
-  async launch() {
-    this.app.use(errorHandler);
-    this.app.use(
-      (0, import_cors.default)({
-        origin: "*",
-        credentials: true
-      })
-    );
-    this.app.get("/status", (0, import_cors.default)(), async (req, res) => {
-      res.send({
-        status: "ok"
-      });
+  scrollUntilTop() {
+    return __async(this, null, function* () {
+      return ThrowNotImplemented("scrollUntilTop");
     });
-    this.app.get("/", (req, res) => {
-      res.sendFile((0, import_node_path3.join)(staticPath, "index.html"));
+  }
+  scrollUntilBottom() {
+    return __async(this, null, function* () {
+      return ThrowNotImplemented("scrollUntilBottom");
     });
-    this.app.get("/playground/:uuid", async (req, res) => {
-      res.sendFile((0, import_node_path3.join)(staticPath, "index.html"));
+  }
+  scrollUpOneScreen() {
+    return __async(this, null, function* () {
+      return ThrowNotImplemented("scrollUpOneScreen");
     });
-    this.app.get("/context/:uuid", async (req, res) => {
-      const { uuid } = req.params;
-      const contextFile = this.filePathForUuid(uuid);
-      (0, import_node_assert3.default)((0, import_node_fs3.existsSync)(contextFile), "Context not found");
-      const context = (0, import_node_fs3.readFileSync)(contextFile, "utf8");
-      res.json({
-        context
-      });
+  }
+  scrollDownOneScreen() {
+    return __async(this, null, function* () {
+      return ThrowNotImplemented("scrollDownOneScreen");
     });
-    this.app.post(
-      "/playground-with-context",
-      import_express.default.json({ limit: "50mb" }),
-      async (req, res) => {
-        const context = req.body.context;
-        (0, import_node_assert3.default)(context, "context is required");
-        const uuid = (0, import_node_crypto2.randomUUID)();
-        this.saveContextFile(uuid, context);
-        return res.json({
-          location: `/playground/${uuid}`,
-          uuid
-        });
-      }
-    );
-    this.app.post(
-      "/execute",
-      import_express.default.json({ limit: "30mb" }),
-      async (req, res) => {
-        const { context, type, prompt } = req.body;
-        (0, import_node_assert3.default)(context, "context is required");
-        (0, import_node_assert3.default)(type, "type is required");
-        (0, import_node_assert3.default)(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}`;
-          }
-        } 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}`
-          );
-        }
-        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);
-      });
+  }
+  clearInput() {
+    return __async(this, null, function* () {
+      return ThrowNotImplemented("clearInput");
     });
   }
-  close() {
-    if (this.server) {
-      return this.server.close();
-    }
+  _forceUsePageContext() {
+    return __async(this, null, function* () {
+      return this.uiContext;
+    });
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  PlaygroundServer,
+  ERROR_CODE_NOT_IMPLEMENTED_AS_DESIGNED,
   StaticPage,
   StaticPageAgent
 });