wuying-agentbay-sdk 0.11.0 → 0.12.0

package/dist/index.mjs

@@ -94,16 +94,22 @@ import {
   ModifyContextRequest,
   ModifyContextResponse,
   ModifyContextResponseBody,
+  PauseSessionAsyncRequest,
+  PauseSessionAsyncResponse,
+  PauseSessionAsyncResponseBody,
   ReleaseMcpSessionRequest,
   ReleaseMcpSessionResponse,
   ReleaseMcpSessionResponseBody,
+  ResumeSessionAsyncRequest,
+  ResumeSessionAsyncResponse,
+  ResumeSessionAsyncResponseBody,
   SetLabelRequest,
   SetLabelResponse,
   SetLabelResponseBody,
   SyncContextRequest,
   SyncContextResponse,
   SyncContextResponseBody
-} from "./chunk-E7QC5S76.mjs";
+} from "./chunk-BVWUCG4J.mjs";
 import {
   __commonJS,
   __dirname,
@@ -186,14 +192,14 @@ var require_main = __commonJS({
   "node_modules/dotenv/lib/main.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var fs6 = __require("fs");
-    var path6 = __require("path");
+    var fs7 = __require("fs");
+    var path7 = __require("path");
     var os = __require("os");
     var crypto2 = __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 parse2(src) {
+    function parse3(src) {
       const obj = {};
       let lines = src.toString();
       lines = lines.replace(/\r\n?/mg, "\n");
@@ -212,7 +218,7 @@ var require_main = __commonJS({
       }
       return obj;
     }
-    __name(parse2, "parse");
+    __name(parse3, "parse");
     function _parseVault(options) {
       options = options || {};
       const vaultPath = _vaultPath(options);
@@ -302,7 +308,7 @@ var require_main = __commonJS({
       if (options && options.path && options.path.length > 0) {
         if (Array.isArray(options.path)) {
           for (const filepath of options.path) {
-            if (fs6.existsSync(filepath)) {
+            if (fs7.existsSync(filepath)) {
               possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
             }
           }
@@ -310,16 +316,16 @@ var require_main = __commonJS({
           possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
         }
       } else {
-        possibleVaultPath = path6.resolve(process.cwd(), ".env.vault");
+        possibleVaultPath = path7.resolve(process.cwd(), ".env.vault");
       }
-      if (fs6.existsSync(possibleVaultPath)) {
+      if (fs7.existsSync(possibleVaultPath)) {
         return possibleVaultPath;
       }
       return null;
     }
     __name(_vaultPath, "_vaultPath");
     function _resolveHome(envPath) {
-      return envPath[0] === "~" ? path6.join(os.homedir(), envPath.slice(1)) : envPath;
+      return envPath[0] === "~" ? path7.join(os.homedir(), envPath.slice(1)) : envPath;
     }
     __name(_resolveHome, "_resolveHome");
     function _configVault(options) {
@@ -338,7 +344,7 @@ var require_main = __commonJS({
     }
     __name(_configVault, "_configVault");
     function configDotenv(options) {
-      const dotenvPath = path6.resolve(process.cwd(), ".env");
+      const dotenvPath = path7.resolve(process.cwd(), ".env");
       let encoding = "utf8";
       const debug = Boolean(options && options.debug);
       const quiet = options && "quiet" in options ? options.quiet : true;
@@ -362,13 +368,13 @@ var require_main = __commonJS({
       }
       let lastError;
       const parsedAll = {};
-      for (const path7 of optionPaths) {
+      for (const path8 of optionPaths) {
         try {
-          const parsed = DotenvModule.parse(fs6.readFileSync(path7, { encoding }));
+          const parsed = DotenvModule.parse(fs7.readFileSync(path8, { encoding }));
           DotenvModule.populate(parsedAll, parsed, options);
         } catch (e) {
           if (debug) {
-            _debug(`Failed to load ${path7} ${e.message}`);
+            _debug(`Failed to load ${path8} ${e.message}`);
           }
           lastError = e;
         }
@@ -383,7 +389,7 @@ var require_main = __commonJS({
         const shortPaths = [];
         for (const filePath of optionPaths) {
           try {
-            const relative = path6.relative(process.cwd(), filePath);
+            const relative = path7.relative(process.cwd(), filePath);
             shortPaths.push(relative);
           } catch (e) {
             if (debug) {
@@ -473,7 +479,7 @@ var require_main = __commonJS({
       _parseVault,
       config,
       decrypt,
-      parse: parse2,
+      parse: parse3,
       populate
     };
     module.exports.configDotenv = DotenvModule.configDotenv;
@@ -553,7 +559,7 @@ function getVersionFromPackageJson() {
     }
   } catch (error) {
   }
-  return "0.9.4";
+  return "0.12.0";
 }
 __name(getVersionFromPackageJson, "getVersionFromPackageJson");
 function isReleaseBuild() {
@@ -581,9 +587,9 @@ init_esm_shims();
 })();
 
 // src/agent-bay.ts
-var dotenv = __toESM(require_main());
-import * as fs4 from "fs";
-import * as path4 from "path";
+var dotenv2 = __toESM(require_main());
+import * as fs5 from "fs";
+import * as path5 from "path";
 
 // src/api/index.ts
 init_esm_shims();
@@ -1059,6 +1065,96 @@ var _Client = class _Client extends (OpenApi.default || OpenApi) {
     const runtime = new $dara.RuntimeOptions({});
     return await this.getSessionWithOptions(request, runtime);
   }
+  /**
+   * Pause session async
+   *
+   * @param request - PauseSessionAsyncRequest
+   * @param runtime - runtime options for this request RuntimeOptions
+   * @returns PauseSessionAsyncResponse
+   */
+  async pauseSessionAsyncWithOptions(request, runtime) {
+    request.validate();
+    const body = {};
+    if (!$dara.isNull(request.authorization)) {
+      body["Authorization"] = request.authorization;
+    }
+    if (!$dara.isNull(request.sessionId)) {
+      body["SessionId"] = request.sessionId;
+    }
+    const req = new $OpenApiUtil.OpenApiRequest({
+      body: OpenApiUtil.parseToMap(body)
+    });
+    const params = new $OpenApiUtil.Params({
+      action: "PauseSessionAsync",
+      version: "2025-05-06",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "Anonymous",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json"
+    });
+    return $dara.cast(
+      await this.callApi(params, req, runtime),
+      new PauseSessionAsyncResponse({})
+    );
+  }
+  /**
+   * Pause session async
+   *
+   * @param request - PauseSessionAsyncRequest
+   * @returns PauseSessionAsyncResponse
+   */
+  async pauseSessionAsync(request) {
+    const runtime = new $dara.RuntimeOptions({});
+    return await this.pauseSessionAsyncWithOptions(request, runtime);
+  }
+  /**
+   * Resume session async
+   *
+   * @param request - ResumeSessionAsyncRequest
+   * @param runtime - runtime options for this request RuntimeOptions
+   * @returns ResumeSessionAsyncResponse
+   */
+  async resumeSessionAsyncWithOptions(request, runtime) {
+    request.validate();
+    const body = {};
+    if (!$dara.isNull(request.authorization)) {
+      body["Authorization"] = request.authorization;
+    }
+    if (!$dara.isNull(request.sessionId)) {
+      body["SessionId"] = request.sessionId;
+    }
+    const req = new $OpenApiUtil.OpenApiRequest({
+      body: OpenApiUtil.parseToMap(body)
+    });
+    const params = new $OpenApiUtil.Params({
+      action: "ResumeSessionAsync",
+      version: "2025-05-06",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "Anonymous",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json"
+    });
+    return $dara.cast(
+      await this.callApi(params, req, runtime),
+      new ResumeSessionAsyncResponse({})
+    );
+  }
+  /**
+   * Resume session async
+   *
+   * @param request - ResumeSessionAsyncRequest
+   * @returns ResumeSessionAsyncResponse
+   */
+  async resumeSessionAsync(request) {
+    const runtime = new $dara.RuntimeOptions({});
+    return await this.resumeSessionAsyncWithOptions(request, runtime);
+  }
   /**
    * Get forwarding link for specific port
    *
@@ -1904,6 +2000,70 @@ var _Client = class _Client extends (OpenApi.default || OpenApi) {
 __name(_Client, "Client");
 var Client = _Client;
 
+// src/config.ts
+init_esm_shims();
+var dotenv = __toESM(require_main());
+import * as fs2 from "fs";
+import * as path2 from "path";
+var BROWSER_RECORD_PATH = "/home/guest/record";
+function findDotEnvFile(startPath) {
+  const currentPath = startPath ? path2.resolve(startPath) : process.cwd();
+  let searchPath = currentPath;
+  while (searchPath !== path2.dirname(searchPath)) {
+    const envFile = path2.join(searchPath, ".env");
+    if (fs2.existsSync(envFile)) {
+      return envFile;
+    }
+    const gitDir = path2.join(searchPath, ".git");
+    if (fs2.existsSync(gitDir)) {
+    }
+    searchPath = path2.dirname(searchPath);
+  }
+  const rootEnv = path2.join(searchPath, ".env");
+  if (fs2.existsSync(rootEnv)) {
+    return rootEnv;
+  }
+  return null;
+}
+__name(findDotEnvFile, "findDotEnvFile");
+function loadDotEnvWithFallback(customEnvPath) {
+  if (customEnvPath) {
+    if (fs2.existsSync(customEnvPath)) {
+      try {
+        const envConfig = dotenv.parse(fs2.readFileSync(customEnvPath));
+        for (const k in envConfig) {
+          if (!process.env.hasOwnProperty(k)) {
+            process.env[k] = envConfig[k];
+          }
+        }
+        return;
+      } catch (error) {
+      }
+    }
+  }
+  const envFile = findDotEnvFile();
+  if (envFile) {
+    try {
+      const envConfig = dotenv.parse(fs2.readFileSync(envFile));
+      for (const k in envConfig) {
+        if (!process.env.hasOwnProperty(k)) {
+          process.env[k] = envConfig[k];
+        }
+      }
+    } catch (error) {
+    }
+  }
+}
+__name(loadDotEnvWithFallback, "loadDotEnvWithFallback");
+var dotEnvLoaded = false;
+if (!dotEnvLoaded) {
+  try {
+    loadDotEnvWithFallback();
+    dotEnvLoaded = true;
+  } catch (error) {
+  }
+}
+
 // src/context.ts
 init_esm_shims();
 
@@ -1978,8 +2138,8 @@ var BrowserError = _BrowserError;
 
 // src/utils/logger.ts
 init_esm_shims();
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs3 from "fs";
+import * as path3 from "path";
 var LOG_LEVEL_VALUES = {
   DEBUG: 0,
   INFO: 1,
@@ -2158,17 +2318,17 @@ function writeToFile(message) {
     return;
   }
   try {
-    if (fs2.existsSync(logFilePath)) {
-      const stats = fs2.statSync(logFilePath);
+    if (fs3.existsSync(logFilePath)) {
+      const stats = fs3.statSync(logFilePath);
       if (stats.size >= logFileMaxSize) {
         const rotatedPath = `${logFilePath}.1`;
-        if (fs2.existsSync(rotatedPath)) {
-          fs2.unlinkSync(rotatedPath);
+        if (fs3.existsSync(rotatedPath)) {
+          fs3.unlinkSync(rotatedPath);
         }
-        fs2.renameSync(logFilePath, rotatedPath);
+        fs3.renameSync(logFilePath, rotatedPath);
       }
     }
-    fs2.appendFileSync(logFilePath, message + "\n", "utf8");
+    fs3.appendFileSync(logFilePath, message + "\n", "utf8");
   } catch (error) {
     if (consoleLoggingEnabled) {
       process.stderr.write(`Failed to write to log file: ${error}
@@ -2185,9 +2345,9 @@ function setupLogger(config) {
     if (config.logFile) {
       logFilePath = config.logFile;
       fileLoggingEnabled = true;
-      const dir = path2.dirname(logFilePath);
-      if (!fs2.existsSync(dir)) {
-        fs2.mkdirSync(dir, { recursive: true });
+      const dir = path3.dirname(logFilePath);
+      if (!fs3.existsSync(dir)) {
+        fs3.mkdirSync(dir, { recursive: true });
       }
       if (config.maxFileSize) {
         logFileMaxSize = parseFileSize(config.maxFileSize);
@@ -3223,7 +3383,7 @@ var _ContextService = class _ContextService {
     const maxAttempts = Math.floor(timeout / pollInterval);
     let attempt = 0;
     while (attempt < maxAttempts) {
-      await new Promise((resolve2) => setTimeout(resolve2, pollInterval * 1e3));
+      await new Promise((resolve3) => setTimeout(resolve3, pollInterval * 1e3));
       attempt++;
       const statusResult = await this.getClearStatus(contextId);
       if (!statusResult.success) {
@@ -3313,8 +3473,8 @@ var _ExtractPolicyClass = class _ExtractPolicyClass {
 __name(_ExtractPolicyClass, "ExtractPolicyClass");
 var ExtractPolicyClass = _ExtractPolicyClass;
 var _WhiteListValidator = class _WhiteListValidator {
-  static containsWildcard(path6) {
-    return /[*?\[\]]/.test(path6);
+  static containsWildcard(path7) {
+    return /[*?\[\]]/.test(path7);
   }
   static validate(whitelist) {
     if (this.containsWildcard(whitelist.path)) {
@@ -3389,12 +3549,12 @@ var _SyncPolicyImpl = class _SyncPolicyImpl {
 __name(_SyncPolicyImpl, "SyncPolicyImpl");
 var SyncPolicyImpl = _SyncPolicyImpl;
 var _ContextSync = class _ContextSync {
-  constructor(contextId, path6, policy) {
+  constructor(contextId, path7, policy) {
     if (policy) {
       validateSyncPolicy(policy);
     }
     this.contextId = contextId;
-    this.path = path6;
+    this.path = path7;
     this.policy = policy;
   }
   // WithPolicy sets the policy and returns the context sync for chaining
@@ -3495,9 +3655,9 @@ function validateSyncPolicy(policy) {
       );
     }
     if (policy.recyclePolicy.paths) {
-      for (const path6 of policy.recyclePolicy.paths) {
-        if (path6 && path6.trim() !== "") {
-          const tempWhiteList = { path: path6 };
+      for (const path7 of policy.recyclePolicy.paths) {
+        if (path7 && path7.trim() !== "") {
+          const tempWhiteList = { path: path7 };
           WhiteListValidator.validate(tempWhiteList);
         }
       }
@@ -3509,11 +3669,11 @@ function newSyncPolicyWithDefaults(policy) {
   return new SyncPolicyImpl(policy).toJSON();
 }
 __name(newSyncPolicyWithDefaults, "newSyncPolicyWithDefaults");
-function newContextSync(contextId, path6, policy) {
+function newContextSync(contextId, path7, policy) {
   if (policy) {
     validateSyncPolicy(policy);
   }
-  return new ContextSync(contextId, path6, policy);
+  return new ContextSync(contextId, path7, policy);
 }
 __name(newContextSync, "newContextSync");
 
@@ -3645,7 +3805,7 @@ var _Agent = class _Agent {
             };
         }
         logDebug(`Task ${taskId} is still running, please wait for a while.`);
-        await new Promise((resolve2) => setTimeout(resolve2, 3e3));
+        await new Promise((resolve3) => setTimeout(resolve3, 3e3));
         triedTime++;
       }
       return {
@@ -4582,8 +4742,8 @@ var _BrowserFingerprintGenerator = class _BrowserFingerprintGenerator {
   async saveToFile(jsonData, filename) {
     try {
       if (typeof __require !== "undefined") {
-        const fs6 = __require("fs");
-        fs6.writeFileSync(filename, jsonData, "utf8");
+        const fs7 = __require("fs");
+        fs7.writeFileSync(filename, jsonData, "utf8");
         console.log(`Fingerprint data saved to ${filename}`);
         return true;
       } else {
@@ -5032,7 +5192,7 @@ var _Browser = class _Browser {
         logDebug(`VPC mode, endpoint_router_port: ${this.session.httpPort}`);
         this._endpointUrl = `ws://${this.session.networkInterfaceIp}:${this.session.httpPort}`;
       } else {
-        const { GetCdpLinkRequest: GetCdpLinkRequest2 } = await import("./model-ZFTLKEMC.mjs");
+        const { GetCdpLinkRequest: GetCdpLinkRequest2 } = await import("./model-LGWQJWKQ.mjs");
         const request = new GetCdpLinkRequest2({
           authorization: `Bearer ${this.session.getAPIKey()}`,
           sessionId: this.session.sessionId
@@ -6544,7 +6704,7 @@ var _ContextManager = class _ContextManager {
    * }
    * ```
    */
-  async infoWithParams(contextId, path6, taskType) {
+  async infoWithParams(contextId, path7, taskType) {
     const request = new GetContextInfoRequest({
       authorization: `Bearer ${this.session.getAPIKey()}`,
       sessionId: this.session.getSessionId()
@@ -6552,8 +6712,8 @@ var _ContextManager = class _ContextManager {
     if (contextId) {
       request.contextId = contextId;
     }
-    if (path6) {
-      request.path = path6;
+    if (path7) {
+      request.path = path7;
     }
     if (taskType) {
       request.taskType = taskType;
@@ -6628,16 +6788,31 @@ var _ContextManager = class _ContextManager {
   /**
    * Synchronizes a context with the session. Supports both async and callback modes.
    *
-   * @param contextId - Optional context ID to synchronize
-   * @param path - Optional path where the context should be mounted
+   * @param contextId - Optional context ID to synchronize. If provided, `path` must also be provided.
+   * @param path - Optional path where the context should be mounted. If provided, `contextId` must also be provided.
    * @param mode - Optional synchronization mode (e.g., "upload", "download")
    * @param callback - Optional callback function. If provided, runs in background and calls callback when complete
    * @param maxRetries - Maximum number of retries for polling completion status (default: 150)
    * @param retryInterval - Milliseconds to wait between retries (default: 1500)
    * @returns Promise resolving to ContextSyncResult with success status and request ID
    * @throws Error if the API call fails
+   * @throws Error if `contextId` or `path` is provided without the other parameter.
+   *               Both must be provided together, or both must be omitted.
+   *
+   * @example
+   * Sync all contexts (no parameters):
+   * ```typescript
+   * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+   * const result = await agentBay.create();
+   * if (result.success) {
+   *   const syncResult = await result.session.context.sync();
+   *   console.log(`Sync: ${syncResult.success}`);
+   *   await result.session.delete();
+   * }
+   * ```
    *
    * @example
+   * Sync specific context with path:
    * ```typescript
    * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
    * const result = await agentBay.create();
@@ -6649,7 +6824,14 @@ var _ContextManager = class _ContextManager {
    * }
    * ```
    */
-  async sync(contextId, path6, mode, callback, maxRetries = 150, retryInterval = 1500) {
+  async sync(contextId, path7, mode, callback, maxRetries = 150, retryInterval = 1500) {
+    const hasContextId = contextId !== void 0 && contextId.trim() !== "";
+    const hasPath = path7 !== void 0 && path7.trim() !== "";
+    if (hasContextId !== hasPath) {
+      throw new Error(
+        "contextId and path must be provided together or both omitted. If you want to sync a specific context, both contextId and path are required. If you want to sync all contexts, omit both parameters."
+      );
+    }
     const request = new SyncContextRequest({
       authorization: `Bearer ${this.session.getAPIKey()}`,
       sessionId: this.session.getSessionId()
@@ -6657,8 +6839,8 @@ var _ContextManager = class _ContextManager {
     if (contextId) {
       request.contextId = contextId;
     }
-    if (path6) {
-      request.path = path6;
+    if (path7) {
+      request.path = path7;
     }
     if (mode) {
       request.mode = mode;
@@ -6708,7 +6890,7 @@ var _ContextManager = class _ContextManager {
       const fullResponse = response.body ? JSON.stringify(response.body, null, 2) : "";
       logAPIResponseWithDetails("SyncContext", requestId, success, keyFields, fullResponse);
       if (callback && success) {
-        this.pollForCompletion(callback, contextId, path6, maxRetries, retryInterval).catch((error) => {
+        this.pollForCompletion(callback, contextId, path7, maxRetries, retryInterval).catch((error) => {
           logError("Error in background polling:", error);
           callback(false);
         });
@@ -6720,7 +6902,7 @@ var _ContextManager = class _ContextManager {
       if (success) {
         const finalSuccess = await this.pollForCompletionAsync(
           contextId,
-          path6,
+          path7,
           maxRetries,
           retryInterval
         );
@@ -6741,10 +6923,10 @@ var _ContextManager = class _ContextManager {
   /**
    * Polls the info interface to check if sync is completed and calls callback.
    */
-  async pollForCompletion(callback, contextId, path6, maxRetries = 150, retryInterval = 1500) {
+  async pollForCompletion(callback, contextId, path7, maxRetries = 150, retryInterval = 1500) {
     for (let retry = 0; retry < maxRetries; retry++) {
       try {
-        const infoResult = await this.infoWithParams(contextId, path6);
+        const infoResult = await this.infoWithParams(contextId, path7);
         let allCompleted = true;
         let hasFailure = false;
         let hasSyncTasks = false;
@@ -6789,10 +6971,10 @@ var _ContextManager = class _ContextManager {
   /**
    * Async version of polling for sync completion.
    */
-  async pollForCompletionAsync(contextId, path6, maxRetries = 150, retryInterval = 1500) {
+  async pollForCompletionAsync(contextId, path7, maxRetries = 150, retryInterval = 1500) {
     for (let retry = 0; retry < maxRetries; retry++) {
       try {
-        const infoResult = await this.infoWithParams(contextId, path6);
+        const infoResult = await this.infoWithParams(contextId, path7);
         let allCompleted = true;
         let hasFailure = false;
         let hasSyncTasks = false;
@@ -6837,7 +7019,7 @@ var _ContextManager = class _ContextManager {
    * Sleep utility function for TypeScript
    */
   sleep(ms) {
-    return new Promise((resolve2) => setTimeout(resolve2, ms));
+    return new Promise((resolve3) => setTimeout(resolve3, ms));
   }
 };
 __name(_ContextManager, "ContextManager");
@@ -6852,8 +7034,8 @@ init_esm_shims();
 
 // src/filesystem/file-transfer.ts
 init_esm_shims();
-import * as fs3 from "fs";
-import * as path3 from "path";
+import * as fs4 from "fs";
+import * as path4 from "path";
 import fetch2 from "node-fetch";
 var _FileTransfer = class _FileTransfer {
   /**
@@ -6892,7 +7074,7 @@ var _FileTransfer = class _FileTransfer {
       progressCb = void 0
     } = options || {};
     try {
-      if (!fs3.existsSync(localPath)) {
+      if (!fs4.existsSync(localPath)) {
         return {
           success: false,
           bytesSent: 0,
@@ -6962,7 +7144,7 @@ var _FileTransfer = class _FileTransfer {
           // Assuming previous step succeeded
           etag: "",
           // Assuming previous step succeeded
-          bytesSent: fs3.statSync(localPath).size,
+          bytesSent: fs4.statSync(localPath).size,
           // Assuming previous step succeeded
           path: remotePath,
           error: `session.context.sync(upload) failed: ${e.message || e}`
@@ -6986,7 +7168,7 @@ var _FileTransfer = class _FileTransfer {
             // Assuming previous step succeeded
             etag: "",
             // Assuming previous step succeeded
-            bytesSent: fs3.statSync(localPath).size,
+            bytesSent: fs4.statSync(localPath).size,
             // Assuming previous step succeeded
             path: remotePath,
             error: `Upload sync not finished: ${error || "timeout or unknown"}`
@@ -6999,7 +7181,7 @@ var _FileTransfer = class _FileTransfer {
         requestIdSync: reqIdSync,
         httpStatus: 200,
         etag: "",
-        bytesSent: fs3.statSync(localPath).size,
+        bytesSent: fs4.statSync(localPath).size,
         path: remotePath
       };
     } catch (e) {
@@ -7086,11 +7268,11 @@ var _FileTransfer = class _FileTransfer {
       const downloadUrl = urlRes.url;
       const reqIdDownload = urlRes.requestId;
       try {
-        const dir = path3.dirname(localPath);
-        if (!fs3.existsSync(dir)) {
-          fs3.mkdirSync(dir, { recursive: true });
+        const dir = path4.dirname(localPath);
+        if (!fs4.existsSync(dir)) {
+          fs4.mkdirSync(dir, { recursive: true });
         }
-        if (fs3.existsSync(localPath) && !overwrite) {
+        if (fs4.existsSync(localPath) && !overwrite) {
           return {
             success: false,
             requestIdDownloadUrl: reqIdDownload,
@@ -7106,13 +7288,13 @@ var _FileTransfer = class _FileTransfer {
           localPath,
           progressCb
         );
-        if (fs3.existsSync(localPath)) {
+        if (fs4.existsSync(localPath)) {
           return {
             success: true,
             requestIdDownloadUrl: reqIdDownload,
             requestIdSync: reqIdSync,
             httpStatus: 200,
-            bytesReceived: fs3.statSync(localPath).size,
+            bytesReceived: fs4.statSync(localPath).size,
             path: remotePath,
             localPath
           };
@@ -7211,11 +7393,11 @@ var _FileTransfer = class _FileTransfer {
         const statusList = res.contextStatusData || [];
         for (const item of statusList) {
           const cid = item.contextId;
-          const path6 = item.path;
+          const path7 = item.path;
           const ttype = item.taskType;
           const status = item.status;
           const err = item.errorMessage;
-          if (cid === contextId && path6 === remotePath && (taskType === void 0 || ttype === taskType)) {
+          if (cid === contextId && path7 === remotePath && (taskType === void 0 || ttype === taskType)) {
             if (err) {
               return { success: false, error: `Task error: ${err}` };
             }
@@ -7228,7 +7410,7 @@ var _FileTransfer = class _FileTransfer {
       } catch (e) {
         lastErr = `info error: ${e.message || e}`;
       }
-      await new Promise((resolve2) => setTimeout(resolve2, interval * 1e3));
+      await new Promise((resolve3) => setTimeout(resolve3, interval * 1e3));
     }
     return { success: false, error: lastErr || "timeout" };
   }
@@ -7241,7 +7423,7 @@ var _FileTransfer = class _FileTransfer {
     if (contentType) {
       headers["Content-Type"] = contentType;
     }
-    const fileBuffer = fs3.readFileSync(filePath);
+    const fileBuffer = fs4.readFileSync(filePath);
     const response = await fetch2(url, {
       method: "PUT",
       body: fileBuffer,
@@ -7268,7 +7450,7 @@ var _FileTransfer = class _FileTransfer {
     }
     const buffer = await response.buffer();
     bytesReceived = buffer.length;
-    fs3.writeFileSync(destPath, buffer);
+    fs4.writeFileSync(destPath, buffer);
     if (progressCb) {
       progressCb(bytesReceived);
     }
@@ -7427,10 +7609,10 @@ var _FileSystem = class _FileSystem {
    * }
    * ```
    */
-  async createDirectory(path6) {
+  async createDirectory(path7) {
     try {
       const args = {
-        path: path6
+        path: path7
       };
       const result = await this.session.callMcpTool(
         "create_directory",
@@ -7478,10 +7660,10 @@ var _FileSystem = class _FileSystem {
    * }
    * ```
    */
-  async editFile(path6, edits, dryRun = false) {
+  async editFile(path7, edits, dryRun = false) {
     try {
       const args = {
-        path: path6,
+        path: path7,
         edits,
         dryRun
       };
@@ -7528,10 +7710,10 @@ var _FileSystem = class _FileSystem {
    * }
    * ```
    */
-  async getFileInfo(path6) {
+  async getFileInfo(path7) {
     try {
       const args = {
-        path: path6
+        path: path7
       };
       const result = await this.session.callMcpTool(
         "get_file_info",
@@ -7606,10 +7788,10 @@ var _FileSystem = class _FileSystem {
    *
    * @see {@link readFile}, {@link writeFile}
    */
-  async listDirectory(path6) {
+  async listDirectory(path7) {
     try {
       const args = {
-        path: path6
+        path: path7
       };
       const result = await this.session.callMcpTool(
         "list_directory",
@@ -7696,10 +7878,10 @@ var _FileSystem = class _FileSystem {
    * @param length - Optional: Number of bytes to read. If 0, reads the entire file from offset.
    * @returns FileContentResult with file content and requestId
    */
-  async readFileChunk(path6, offset = 0, length = 0) {
+  async readFileChunk(path7, offset = 0, length = 0) {
     try {
       const args = {
-        path: path6
+        path: path7
       };
       if (offset > 0) {
         args.offset = offset;
@@ -7778,8 +7960,8 @@ var _FileSystem = class _FileSystem {
         for (const line of lines) {
           const colonIndex = line.indexOf(":");
           if (colonIndex > 0 && currentPath === "" && !line.substring(0, colonIndex).includes(" ")) {
-            const path6 = line.substring(0, colonIndex).trim();
-            currentPath = path6;
+            const path7 = line.substring(0, colonIndex).trim();
+            currentPath = path7;
             if (line.length > colonIndex + 1) {
               const contentStart = line.substring(colonIndex + 1).trim();
               if (contentStart) {
@@ -7799,8 +7981,8 @@ var _FileSystem = class _FileSystem {
         if (currentPath) {
           fileContents[currentPath] = currentContent.join("\n");
         }
-        for (const path6 in fileContents) {
-          fileContents[path6] = fileContents[path6].replace(/\n+$/, "");
+        for (const path7 in fileContents) {
+          fileContents[path7] = fileContents[path7].replace(/\n+$/, "");
         }
       }
       return {
@@ -7840,10 +8022,10 @@ var _FileSystem = class _FileSystem {
    * }
    * ```
    */
-  async searchFiles(path6, pattern, excludePatterns = []) {
+  async searchFiles(path7, pattern, excludePatterns = []) {
     try {
       const args = {
-        path: path6,
+        path: path7,
         pattern
       };
       if (excludePatterns.length > 0) {
@@ -7887,7 +8069,7 @@ var _FileSystem = class _FileSystem {
    * @param mode - Optional: Write mode. One of "overwrite", "append", or "create_new". Default is "overwrite".
    * @returns BoolResult with write result and requestId
    */
-  async writeFileChunk(path6, content, mode = "overwrite") {
+  async writeFileChunk(path7, content, mode = "overwrite") {
     try {
       const validModes = ["overwrite", "append", "create_new"];
       if (!validModes.includes(mode)) {
@@ -7900,7 +8082,7 @@ var _FileSystem = class _FileSystem {
         };
       }
       const args = {
-        path: path6,
+        path: path7,
         content,
         mode
       };
@@ -7977,10 +8159,10 @@ var _FileSystem = class _FileSystem {
    *
    * @see {@link writeFile}, {@link listDirectory}
    */
-  async readFile(path6) {
+  async readFile(path7) {
     const chunkSize = DEFAULT_CHUNK_SIZE;
     try {
-      const fileInfoResult = await this.getFileInfo(path6);
+      const fileInfoResult = await this.getFileInfo(path7);
       if (!fileInfoResult.success) {
         return {
           requestId: fileInfoResult.requestId,
@@ -7994,7 +8176,7 @@ var _FileSystem = class _FileSystem {
           requestId: fileInfoResult.requestId,
           success: false,
           content: "",
-          errorMessage: `Path does not exist or is a directory: ${path6}`
+          errorMessage: `Path does not exist or is a directory: ${path7}`
         };
       }
       const fileSize = fileInfoResult.fileInfo.size || 0;
@@ -8014,7 +8196,7 @@ var _FileSystem = class _FileSystem {
           length = fileSize - offset;
         }
         try {
-          const chunkResult = await this.readFileChunk(path6, offset, length);
+          const chunkResult = await this.readFileChunk(path7, offset, length);
           if (!chunkResult.success) {
             return chunkResult;
           }
@@ -8100,16 +8282,16 @@ var _FileSystem = class _FileSystem {
    *
    * @see {@link readFile}, {@link listDirectory}
    */
-  async writeFile(path6, content, mode = "overwrite") {
+  async writeFile(path7, content, mode = "overwrite") {
     const chunkSize = DEFAULT_CHUNK_SIZE;
     try {
       const contentLen = content.length;
       if (contentLen <= chunkSize) {
-        return await this.writeFileChunk(path6, content, mode);
+        return await this.writeFileChunk(path7, content, mode);
       }
       const firstChunkEnd = Math.min(chunkSize, contentLen);
       const firstResult = await this.writeFileChunk(
-        path6,
+        path7,
         content.substring(0, firstChunkEnd),
         mode
       );
@@ -8120,7 +8302,7 @@ var _FileSystem = class _FileSystem {
       for (let offset = firstChunkEnd; offset < contentLen; ) {
         const end = Math.min(offset + chunkSize, contentLen);
         const chunkResult = await this.writeFileChunk(
-          path6,
+          path7,
           content.substring(offset, end),
           "append"
         );
@@ -8161,9 +8343,9 @@ var _FileSystem = class _FileSystem {
    * }
    * ```
    */
-  async getFileChange(path6) {
+  async getFileChange(path7) {
     try {
-      const args = { path: path6 };
+      const args = { path: path7 };
       const result = await this.session.callMcpTool("get_file_change", args);
       if (!result.success) {
         return {
@@ -8234,17 +8416,17 @@ var _FileSystem = class _FileSystem {
    * }
    * ```
    */
-  async watchDirectory(path6, callback, interval = 500, signal) {
-    console.log(`Starting directory monitoring for: ${path6}`);
+  async watchDirectory(path7, callback, interval = 500, signal) {
+    console.log(`Starting directory monitoring for: ${path7}`);
     console.log(`Polling interval: ${interval} ms`);
     const monitor = /* @__PURE__ */ __name(async () => {
       while (!signal?.aborted) {
         try {
           if (this.session._isExpired && this.session._isExpired()) {
-            console.log(`Session expired, stopping directory monitoring for: ${path6}`);
+            console.log(`Session expired, stopping directory monitoring for: ${path7}`);
             break;
           }
-          const result = await this.getFileChange(path6);
+          const result = await this.getFileChange(path7);
           if (result.success && result.events.length > 0) {
             console.log(`Detected ${result.events.length} file changes:`);
             for (const event of result.events) {
@@ -8258,29 +8440,29 @@ var _FileSystem = class _FileSystem {
           } else if (!result.success) {
             const errorMsg = (result.errorMessage || "").toLowerCase();
             if (errorMsg.includes("session") && (errorMsg.includes("expired") || errorMsg.includes("invalid"))) {
-              console.log(`Session expired, stopping directory monitoring for: ${path6}`);
+              console.log(`Session expired, stopping directory monitoring for: ${path7}`);
               break;
             }
             console.error(`Error monitoring directory: ${result.errorMessage}`);
           }
-          await new Promise((resolve2) => {
-            const timeoutId = setTimeout(resolve2, interval);
+          await new Promise((resolve3) => {
+            const timeoutId = setTimeout(resolve3, interval);
             signal?.addEventListener("abort", () => {
               clearTimeout(timeoutId);
-              resolve2(void 0);
+              resolve3(void 0);
             });
           });
         } catch (error) {
           console.error(`Unexpected error in directory monitoring: ${error}`);
           const errorStr = String(error).toLowerCase();
           if (errorStr.includes("session") && (errorStr.includes("expired") || errorStr.includes("invalid"))) {
-            console.log(`Session expired, stopping directory monitoring for: ${path6}`);
+            console.log(`Session expired, stopping directory monitoring for: ${path7}`);
             break;
           }
-          await new Promise((resolve2) => setTimeout(resolve2, interval));
+          await new Promise((resolve3) => setTimeout(resolve3, interval));
         }
       }
-      console.log(`Stopped monitoring directory: ${path6}`);
+      console.log(`Stopped monitoring directory: ${path7}`);
     }, "monitor");
     return monitor();
   }
@@ -8868,7 +9050,7 @@ var _Mobile = class _Mobile {
   async getAdbUrl(adbkeyPub) {
     try {
       const optionsJson = JSON.stringify({ adbkey_pub: adbkeyPub });
-      const { GetAdbLinkRequest: GetAdbLinkRequest2 } = await import("./model-ZFTLKEMC.mjs");
+      const { GetAdbLinkRequest: GetAdbLinkRequest2 } = await import("./model-LGWQJWKQ.mjs");
       const request = new GetAdbLinkRequest2({
         authorization: `Bearer ${this.session.getAPIKey()}`,
         sessionId: this.session.sessionId,
@@ -9298,12 +9480,12 @@ var _Oss = class _Oss {
    * }
    * ```
    */
-  async upload(bucket, object, path6) {
+  async upload(bucket, object, path7) {
     try {
       const args = {
         bucket,
         object,
-        path: path6
+        path: path7
       };
       const result = await this.session.callMcpTool("oss_upload", args);
       return {
@@ -9341,11 +9523,11 @@ var _Oss = class _Oss {
    * }
    * ```
    */
-  async uploadAnonymous(url, path6) {
+  async uploadAnonymous(url, path7) {
     try {
       const args = {
         url,
-        path: path6
+        path: path7
       };
       const result = await this.session.callMcpTool("oss_upload_annon", args);
       return {
@@ -9385,12 +9567,12 @@ var _Oss = class _Oss {
    * }
    * ```
    */
-  async download(bucket, object, path6) {
+  async download(bucket, object, path7) {
     try {
       const args = {
         bucket,
         object,
-        path: path6
+        path: path7
       };
       const result = await this.session.callMcpTool("oss_download", args);
       return {
@@ -9428,11 +9610,11 @@ var _Oss = class _Oss {
    * }
    * ```
    */
-  async downloadAnonymous(url, path6) {
+  async downloadAnonymous(url, path7) {
     try {
       const args = {
         url,
-        path: path6
+        path: path7
       };
       const result = await this.session.callMcpTool("oss_download_annon", args);
       return {
@@ -9667,7 +9849,7 @@ var _Session = class _Session {
         try {
           let syncResult;
           if (syncContextId) {
-            syncResult = await this.context.sync(syncContextId);
+            syncResult = await this.context.sync(syncContextId, BROWSER_RECORD_PATH);
             logInfo(`\u{1F3A5} Synced browser recording context: ${syncContextId}`);
           } else {
             syncResult = await this.context.sync();
@@ -10427,80 +10609,374 @@ var _Session = class _Session {
       };
     }
   }
-};
-__name(_Session, "Session");
-var Session = _Session;
-
-// src/agent-bay.ts
-var BROWSER_DATA_PATH2 = "/tmp/agentbay_browser";
-function defaultConfig() {
-  return {
-    endpoint: "wuyingai.cn-shanghai.aliyuncs.com",
-    timeout_ms: 6e4
-  };
-}
-__name(defaultConfig, "defaultConfig");
-function findDotEnvFile(startPath) {
-  const currentPath = startPath ? path4.resolve(startPath) : process.cwd();
-  let searchPath = currentPath;
-  while (searchPath !== path4.dirname(searchPath)) {
-    const envFile = path4.join(searchPath, ".env");
-    if (fs4.existsSync(envFile)) {
-      return envFile;
-    }
-    const gitDir = path4.join(searchPath, ".git");
-    if (fs4.existsSync(gitDir)) {
-    }
-    searchPath = path4.dirname(searchPath);
-  }
-  const rootEnv = path4.join(searchPath, ".env");
-  if (fs4.existsSync(rootEnv)) {
-    return rootEnv;
-  }
-  return null;
-}
-__name(findDotEnvFile, "findDotEnvFile");
-function loadDotEnvWithFallback(customEnvPath) {
-  if (customEnvPath) {
-    if (fs4.existsSync(customEnvPath)) {
-      try {
-        const envConfig = dotenv.parse(fs4.readFileSync(customEnvPath));
-        for (const k in envConfig) {
-          if (!process.env.hasOwnProperty(k)) {
-            process.env[k] = envConfig[k];
+  /**
+   * Asynchronously pause this session, putting it into a dormant state.
+   *
+   * This method calls the PauseSessionAsync API to initiate the pause operation and then polls
+   * the GetSession API to check the session status until it becomes PAUSED or until timeout is reached.
+   * During the paused state, resource usage and costs are reduced while session state is preserved.
+   *
+   * @param timeout - Timeout in seconds to wait for the session to pause. Defaults to 600 seconds.
+   * @param pollInterval - Interval in seconds between status polls. Defaults to 2.0 seconds.
+   *
+   * @returns Promise resolving to SessionPauseResult containing:
+   *          - success: Whether the pause operation succeeded
+   *          - requestId: Unique identifier for this API request
+   *          - status: Final session status (should be "PAUSED" if successful)
+   *          - errorMessage: Error description if pause failed
+   *
+   * @throws Error if the API call fails or network issues occur.
+   *
+   * @example
+   * ```typescript
+   * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+   * const result = await agentBay.create();
+   * if (result.success) {
+   *   const pauseResult = await result.session.pauseAsync();
+   *   if (pauseResult.success) {
+   *     console.log('Session paused successfully');
+   *   }
+   * }
+   * ```
+   *
+   * @remarks
+   * **Behavior:**
+   * - Initiates pause operation through PauseSessionAsync API
+   * - Polls session status until PAUSED state or timeout
+   * - Session state transitions: RUNNING -> PAUSING -> PAUSED
+   * - All session state is preserved during pause
+   *
+   * **Important Notes:**
+   * - Paused sessions cannot perform operations (deletion, task execution, etc.)
+   * - Use {@link resumeAsync} to restore the session to RUNNING state
+   * - During pause, both resource usage and costs are lower
+   * - If timeout is exceeded, returns with success=false
+   *
+   * @see {@link resumeAsync}
+   */
+  async pauseAsync(timeout = 600, pollInterval = 2) {
+    try {
+      const request = new PauseSessionAsyncRequest({
+        authorization: `Bearer ${this.getAPIKey()}`,
+        sessionId: this.sessionId
+      });
+      logAPICall("PauseSessionAsync", `SessionId=${this.sessionId}`);
+      const response = await this.getClient().pauseSessionAsync(request);
+      const requestId = extractRequestId(response) || "";
+      setRequestId(requestId);
+      const responseMap = response.to_map ? response.to_map() : response;
+      if (!responseMap) {
+        return {
+          requestId: requestId || "",
+          success: false,
+          errorMessage: "Invalid response format"
+        };
+      }
+      const body = responseMap.body;
+      if (!body) {
+        return {
+          requestId: requestId || "",
+          success: false,
+          errorMessage: "Invalid response body"
+        };
+      }
+      const success = body.success !== false;
+      const code = body.code || "";
+      const message = body.message || "";
+      const httpStatusCode = body.httpStatusCode || 0;
+      if (!success) {
+        const errorMessage = `[${code}] ${message}` || "Unknown error";
+        logError("PauseSessionAsync", errorMessage);
+        return {
+          requestId: requestId || "",
+          success: false,
+          errorMessage,
+          code,
+          message,
+          httpStatusCode
+        };
+      }
+      logInfo(`PauseSessionAsync`, `Session ${this.sessionId} pause initiated successfully`);
+      const startTime = Date.now();
+      const maxAttempts = Math.floor(timeout / pollInterval);
+      let attempt = 0;
+      while (attempt < maxAttempts) {
+        const getResult = await this.agentBay.getSession(this.sessionId);
+        if (!getResult.success) {
+          logError(`Failed to get session status: ${getResult.errorMessage}`);
+          return {
+            requestId: getResult.requestId || "",
+            success: false,
+            errorMessage: `Failed to get session status: ${getResult.errorMessage}`
+          };
+        }
+        if (getResult.data) {
+          const status = getResult.data.status || "UNKNOWN";
+          logDebug(`Session status: ${status} (attempt ${attempt + 1}/${maxAttempts})`);
+          if (status === "PAUSED") {
+            const elapsed2 = Date.now() - startTime;
+            logInfo(`Session paused successfully in ${elapsed2}ms`);
+            return {
+              requestId: getResult.requestId || "",
+              success: true,
+              status
+            };
+          } else if (status === "PAUSING") {
+          } else {
+            const elapsed2 = Date.now() - startTime;
+            const errorMessage = `Session pause failed: unexpected state '${status}' after ${elapsed2}ms`;
+            logError(errorMessage);
+            return {
+              requestId: getResult.requestId || "",
+              success: false,
+              errorMessage,
+              status
+            };
           }
         }
-        return;
-      } catch (error) {
-      }
-    }
-  }
-  const envFile = findDotEnvFile();
-  if (envFile) {
-    try {
-      const envConfig = dotenv.parse(fs4.readFileSync(envFile));
-      for (const k in envConfig) {
-        if (!process.env.hasOwnProperty(k)) {
-          process.env[k] = envConfig[k];
+        attempt++;
+        if (attempt < maxAttempts) {
+          await new Promise((resolve3) => setTimeout(resolve3, pollInterval * 1e3));
         }
       }
+      const elapsed = Date.now() - startTime;
+      const errorMsg = `Session pause timed out after ${elapsed}ms`;
+      logError(errorMsg);
+      return {
+        requestId: "",
+        success: false,
+        errorMessage: errorMsg
+      };
     } catch (error) {
+      logError("PauseSessionAsync", error);
+      return {
+        requestId: "",
+        success: false,
+        errorMessage: `Unexpected error pausing session: ${error}`
+      };
     }
   }
-}
-__name(loadDotEnvWithFallback, "loadDotEnvWithFallback");
-function loadConfig(customConfig, customEnvPath) {
-  if (customConfig) {
-    return customConfig;
-  }
-  const config = defaultConfig();
-  try {
-    loadDotEnvWithFallback(customEnvPath);
-  } catch (error) {
-  }
-  if (process.env.AGENTBAY_ENDPOINT) {
-    config.endpoint = process.env.AGENTBAY_ENDPOINT;
-  }
+  /**
+   * Asynchronously resume this session from a paused state.
+   *
+   * This method calls the ResumeSessionAsync API to initiate the resume operation and then polls
+   * the GetSession API to check the session status until it becomes RUNNING or until timeout is reached.
+   * After resuming, the session restores full functionality and can perform all operations normally.
+   *
+   * @param timeout - Timeout in seconds to wait for the session to resume. Defaults to 600 seconds.
+   * @param pollInterval - Interval in seconds between status polls. Defaults to 2.0 seconds.
+   *
+   * @returns Promise resolving to SessionResumeResult containing:
+   *          - success: Whether the resume operation succeeded
+   *          - requestId: Unique identifier for this API request
+   *          - status: Final session status (should be "RUNNING" if successful)
+   *          - errorMessage: Error description if resume failed
+   *
+   * @throws Error if the API call fails or network issues occur.
+   *
+   * @example
+   * ```typescript
+   * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+   * const result = await agentBay.get('paused_session_id');
+   * if (result.success) {
+   *   const resumeResult = await result.session.resumeAsync();
+   *   if (resumeResult.success) {
+   *     console.log('Session resumed successfully');
+   *   }
+   * }
+   * ```
+   *
+   * @remarks
+   * **Behavior:**
+   * - Initiates resume operation through ResumeSessionAsync API
+   * - Polls session status until RUNNING state or timeout
+   * - Session state transitions: PAUSED -> RESUMING -> RUNNING
+   * - All previous session state is restored during resume
+   *
+   * **Important Notes:**
+   * - Only sessions in PAUSED state can be resumed
+   * - After resume, the session can perform all operations normally
+   * - Use {@link pauseAsync} to put a session into PAUSED state
+   * - If timeout is exceeded, returns with success=false
+   *
+   * @see {@link pauseAsync}
+   */
+  async resumeAsync(timeout = 600, pollInterval = 2) {
+    try {
+      const request = new ResumeSessionAsyncRequest({
+        authorization: `Bearer ${this.getAPIKey()}`,
+        sessionId: this.sessionId
+      });
+      logAPICall("ResumeSessionAsync", `SessionId=${this.sessionId}`);
+      const response = await this.getClient().resumeSessionAsync(request);
+      const requestId = extractRequestId(response) || "";
+      setRequestId(requestId);
+      const responseMap = response.to_map ? response.to_map() : response;
+      if (!responseMap) {
+        return {
+          requestId: requestId || "",
+          success: false,
+          errorMessage: "Invalid response format"
+        };
+      }
+      const body = responseMap.body;
+      if (!body) {
+        return {
+          requestId: requestId || "",
+          success: false,
+          errorMessage: "Invalid response body"
+        };
+      }
+      const success = body.success !== false;
+      const code = body.code || "";
+      const message = body.message || "";
+      const httpStatusCode = body.httpStatusCode || 0;
+      if (!success) {
+        const errorMessage = `[${code}] ${message}` || "Unknown error";
+        logError("ResumeSessionAsync", errorMessage);
+        return {
+          requestId: requestId || "",
+          success: false,
+          errorMessage,
+          code,
+          message,
+          httpStatusCode
+        };
+      }
+      logInfo(`ResumeSessionAsync`, `Session ${this.sessionId} resume initiated successfully`);
+      const startTime = Date.now();
+      const maxAttempts = Math.floor(timeout / pollInterval);
+      let attempt = 0;
+      while (attempt < maxAttempts) {
+        const getResult = await this.agentBay.getSession(this.sessionId);
+        if (!getResult.success) {
+          logError(`Failed to get session status: ${getResult.errorMessage}`);
+          return {
+            requestId: getResult.requestId || "",
+            success: false,
+            errorMessage: `Failed to get session status: ${getResult.errorMessage}`
+          };
+        }
+        if (getResult.data) {
+          const status = getResult.data.status || "UNKNOWN";
+          logDebug(`Session status: ${status} (attempt ${attempt + 1}/${maxAttempts})`);
+          if (status === "RUNNING") {
+            const elapsed2 = Date.now() - startTime;
+            logInfo(`Session resumed successfully in ${elapsed2}ms`);
+            return {
+              requestId: getResult.requestId || "",
+              success: true,
+              status
+            };
+          } else if (status === "RESUMING") {
+          } else {
+            const elapsed2 = Date.now() - startTime;
+            const errorMessage = `Session resume failed: unexpected state '${status}' after ${elapsed2}ms`;
+            logError(errorMessage);
+            return {
+              requestId: getResult.requestId || "",
+              success: false,
+              errorMessage,
+              status
+            };
+          }
+        }
+        attempt++;
+        if (attempt < maxAttempts) {
+          await new Promise((resolve3) => setTimeout(resolve3, pollInterval * 1e3));
+        }
+      }
+      const elapsed = Date.now() - startTime;
+      const errorMsg = `Session resume timed out after ${elapsed}ms`;
+      logError(errorMsg);
+      return {
+        requestId: "",
+        success: false,
+        errorMessage: errorMsg
+      };
+    } catch (error) {
+      logError("ResumeSessionAsync", error);
+      return {
+        requestId: "",
+        success: false,
+        errorMessage: `Unexpected error resuming session: ${error}`
+      };
+    }
+  }
+};
+__name(_Session, "Session");
+var Session = _Session;
+
+// src/agent-bay.ts
+var BROWSER_DATA_PATH2 = "/tmp/agentbay_browser";
+function defaultConfig() {
+  return {
+    endpoint: "wuyingai.cn-shanghai.aliyuncs.com",
+    timeout_ms: 6e4
+  };
+}
+__name(defaultConfig, "defaultConfig");
+function findDotEnvFile2(startPath) {
+  const currentPath = startPath ? path5.resolve(startPath) : process.cwd();
+  let searchPath = currentPath;
+  while (searchPath !== path5.dirname(searchPath)) {
+    const envFile = path5.join(searchPath, ".env");
+    if (fs5.existsSync(envFile)) {
+      return envFile;
+    }
+    const gitDir = path5.join(searchPath, ".git");
+    if (fs5.existsSync(gitDir)) {
+    }
+    searchPath = path5.dirname(searchPath);
+  }
+  const rootEnv = path5.join(searchPath, ".env");
+  if (fs5.existsSync(rootEnv)) {
+    return rootEnv;
+  }
+  return null;
+}
+__name(findDotEnvFile2, "findDotEnvFile");
+function loadDotEnvWithFallback2(customEnvPath) {
+  if (customEnvPath) {
+    if (fs5.existsSync(customEnvPath)) {
+      try {
+        const envConfig = dotenv2.parse(fs5.readFileSync(customEnvPath));
+        for (const k in envConfig) {
+          if (!process.env.hasOwnProperty(k)) {
+            process.env[k] = envConfig[k];
+          }
+        }
+        return;
+      } catch (error) {
+      }
+    }
+  }
+  const envFile = findDotEnvFile2();
+  if (envFile) {
+    try {
+      const envConfig = dotenv2.parse(fs5.readFileSync(envFile));
+      for (const k in envConfig) {
+        if (!process.env.hasOwnProperty(k)) {
+          process.env[k] = envConfig[k];
+        }
+      }
+    } catch (error) {
+    }
+  }
+}
+__name(loadDotEnvWithFallback2, "loadDotEnvWithFallback");
+function loadConfig(customConfig, customEnvPath) {
+  if (customConfig) {
+    return customConfig;
+  }
+  const config = defaultConfig();
+  try {
+    loadDotEnvWithFallback2(customEnvPath);
+  } catch (error) {
+  }
+  if (process.env.AGENTBAY_ENDPOINT) {
+    config.endpoint = process.env.AGENTBAY_ENDPOINT;
+  }
   if (process.env.AGENTBAY_TIMEOUT_MS) {
     const timeout = parseInt(process.env.AGENTBAY_TIMEOUT_MS, 10);
     if (!isNaN(timeout) && timeout > 0) {
@@ -10530,9 +11006,8 @@ var _AgentBay = class _AgentBay {
    * @param options.envFile - Custom path to .env file. If not provided, will search upward from current directory.
    */
   constructor(options = {}) {
-    this.sessions = /* @__PURE__ */ new Map();
     this.fileTransferContext = null;
-    loadDotEnvWithFallback(options.envFile);
+    loadDotEnvWithFallback2(options.envFile);
     this.apiKey = options.apiKey || process.env.AGENTBAY_API_KEY || "";
     if (!this.apiKey) {
       throw new AuthenticationError(
@@ -10555,6 +11030,59 @@ var _AgentBay = class _AgentBay {
       throw new AuthenticationError(`Failed to constructor: ${error}`);
     }
   }
+  /**
+   * Wait for mobile simulate command to complete.
+   * 
+   * @param session - The session to wait for mobile simulate
+   * @param mobileSimPath - The dev info path to the mobile simulate
+   * @param mobileSimMode - The mode of the mobile simulate. If not provided, will use the default mode.
+   */
+  async _waitForMobileSimulate(session, mobileSimPath, mobileSimMode) {
+    log("\u23F3 Mobile simulate: Waiting for completion");
+    if (!session.mobile) {
+      logInfo("Mobile module not found in session, skipping mobile simulate");
+      return;
+    }
+    if (!session.command) {
+      logInfo("Command module not found in session, skipping mobile simulate");
+      return;
+    }
+    if (!mobileSimPath) {
+      logInfo("Mobile simulate path is empty, skipping mobile simulate");
+      return;
+    }
+    try {
+      const startTime = Date.now();
+      const devInfoFilePath = `${mobileSimPath}/dev_info.json`;
+      let wyaApplyOption = "";
+      if (!mobileSimMode || mobileSimMode === "PropertiesOnly") {
+        wyaApplyOption = "";
+      } else if (mobileSimMode === "SensorsOnly") {
+        wyaApplyOption = "-sensors";
+      } else if (mobileSimMode === "PackagesOnly") {
+        wyaApplyOption = "-packages";
+      } else if (mobileSimMode === "ServicesOnly") {
+        wyaApplyOption = "-services";
+      } else if (mobileSimMode === "All") {
+        wyaApplyOption = "-all";
+      }
+      const command = `chmod -R a+rwx ${mobileSimPath}; wya apply ${wyaApplyOption} ${devInfoFilePath}`.trim();
+      logInfo(`\u2139\uFE0F  \u23F3 Waiting for mobile simulate completion, command: ${command}`);
+      const cmdResult = await session.command.executeCommand(command);
+      if (cmdResult.success) {
+        const endTime = Date.now();
+        const consumeTime = (endTime - startTime) / 1e3;
+        log(`\u2705 Mobile simulate completed with mode: ${mobileSimMode || "PropertiesOnly"}, duration: ${consumeTime.toFixed(2)} seconds`);
+        if (cmdResult.output) {
+          log(`   Output: ${cmdResult.output.trim()}`);
+        }
+      } else {
+        logInfo(`Failed to execute mobile simulate command: ${cmdResult.errorMessage}`);
+      }
+    } catch (error) {
+      logInfo(`Error executing mobile simulate command: ${error}`);
+    }
+  }
   /**
    * Update browser replay context with AppInstanceId from response data.
    *
@@ -10635,13 +11163,28 @@ var _AgentBay = class _AgentBay {
   async create(params = {}) {
     try {
       logDebug(`default context syncs length: ${params.contextSync?.length}`);
+      if (params.extraConfigs?.mobile?.simulateConfig) {
+        const mobileSimContextId = params.extraConfigs.mobile.simulateConfig.simulatedContextId;
+        if (mobileSimContextId) {
+          const mobileSimContextSync = new ContextSync(
+            mobileSimContextId,
+            "/data/agentbay_mobile_info"
+          );
+          if (!params.contextSync) {
+            params.contextSync = [];
+          }
+          logInfo(`Adding context sync for mobile simulate: ${JSON.stringify(mobileSimContextSync)}`);
+          params.contextSync.push(mobileSimContextSync);
+        }
+      }
+      logDebug(`Origin context syncs length: ${params.contextSync?.length}`);
       const contextName = `file-transfer-context-${Date.now()}`;
       const contextResult = await this.context.get(contextName, true);
       if (contextResult.success && contextResult.context) {
         this.fileTransferContext = contextResult.context;
         const fileTransferContextSync = new ContextSync(
           contextResult.context.id,
-          "/temp/file-transfer"
+          "/tmp/file-transfer"
         );
         if (!params.contextSync) {
           params.contextSync = [];
@@ -10666,6 +11209,9 @@ var _AgentBay = class _AgentBay {
       }
       request.vpcResource = params.isVpc || false;
       let needsContextSync = false;
+      let needsMobileSim = false;
+      let mobileSimMode = void 0;
+      let mobileSimPath = void 0;
       if (params.contextSync && params.contextSync.length > 0) {
         const persistenceDataList = [];
         for (const contextSync of params.contextSync) {
@@ -10703,7 +11249,7 @@ var _AgentBay = class _AgentBay {
       }
       let recordContextId = "";
       if (params.enableBrowserReplay) {
-        const recordPath = "/home/guest/record";
+        const recordPath = BROWSER_RECORD_PATH;
         const recordContextName = generateRandomContextName();
         const result = await this.context.get(recordContextName, true);
         recordContextId = result.success ? result.contextId : "";
@@ -10718,6 +11264,15 @@ var _AgentBay = class _AgentBay {
       }
       if (params.extraConfigs) {
         request.extraConfigs = JSON.stringify(params.extraConfigs);
+        if (params.extraConfigs.mobile?.simulateConfig?.simulate) {
+          mobileSimPath = params.extraConfigs.mobile.simulateConfig.simulatePath;
+          if (!mobileSimPath) {
+            logInfo("mobile_sim_path is not set now, skip mobile simulate operation");
+          } else {
+            needsMobileSim = true;
+            mobileSimMode = params.extraConfigs.mobile.simulateConfig.simulateMode;
+          }
+        }
       }
       logAPICall("CreateMcpSession", {
         labels: params.labels,
@@ -10835,7 +11390,6 @@ var _AgentBay = class _AgentBay {
       session.fileTransferContextId = this.fileTransferContext ? this.fileTransferContext.id : null;
       session.recordContextId = recordContextId || null;
       session.imageId = params.imageId;
-      this.sessions.set(session.sessionId, session);
       if (params.extraConfigs && params.extraConfigs.mobile) {
         log("Applying mobile configuration...");
         try {
@@ -10890,13 +11444,16 @@ var _AgentBay = class _AgentBay {
               break;
             }
             logDebug(`Waiting for context synchronization, attempt ${retry + 1}/${maxRetries}`);
-            await new Promise((resolve2) => setTimeout(resolve2, retryInterval));
+            await new Promise((resolve3) => setTimeout(resolve3, retryInterval));
           } catch (error) {
             logError(`Error checking context status on attempt ${retry + 1}: ${error}`);
-            await new Promise((resolve2) => setTimeout(resolve2, retryInterval));
+            await new Promise((resolve3) => setTimeout(resolve3, retryInterval));
           }
         }
       }
+      if (needsMobileSim && mobileSimPath) {
+        await this._waitForMobileSimulate(session, mobileSimPath, mobileSimMode);
+      }
       return {
         requestId,
         success: true,
@@ -11082,7 +11639,6 @@ var _AgentBay = class _AgentBay {
         deleteResult.success,
         { sessionId: session.sessionId }
       );
-      this.sessions.delete(session.sessionId);
       return deleteResult;
     } catch (error) {
       logError("Error deleting session:", error);
@@ -11093,27 +11649,6 @@ var _AgentBay = class _AgentBay {
       };
     }
   }
-  /**
-   * Remove a session from the internal session cache.
-   *
-   * This is an internal utility method that removes a session reference from the AgentBay client's
-   * session cache without actually deleting the session from the cloud. Use this when you need to
-   * clean up local references to a session that was deleted externally or no longer needed.
-   *
-   * @param sessionId - The ID of the session to remove from the cache.
-   *
-   * @internal
-   *
-   * @remarks
-   * **Note:** This method only removes the session from the local cache. It does not delete the
-   * session from the cloud. To delete a session from the cloud, use {@link delete} or
-   * {@link Session.delete}.
-   *
-   * @see {@link delete}, {@link Session.delete}
-   */
-  removeSession(sessionId) {
-    this.sessions.delete(sessionId);
-  }
   /**
    * Get session information by session ID.
    *
@@ -11156,6 +11691,18 @@ var _AgentBay = class _AgentBay {
         errorMessage: ""
       };
       if (body?.data) {
+        const contextsList = body.data.contexts || [];
+        const contexts = [];
+        if (Array.isArray(contextsList)) {
+          for (const ctx of contextsList) {
+            if (ctx && typeof ctx === "object" && ctx.name && ctx.id) {
+              contexts.push({
+                name: ctx.name,
+                id: ctx.id
+              });
+            }
+          }
+        }
         result.data = {
           appInstanceId: body.data.appInstanceId || "",
           resourceId: body.data.resourceId || "",
@@ -11165,7 +11712,9 @@ var _AgentBay = class _AgentBay {
           networkInterfaceIp: body.data.networkInterfaceIp || "",
           token: body.data.token || "",
           vpcResource: body.data.vpcResource || false,
-          resourceUrl: body.data.resourceUrl || ""
+          resourceUrl: body.data.resourceUrl || "",
+          status: body.data.status || "",
+          contexts: contexts.length > 0 ? contexts : void 0
         };
         logAPIResponseWithDetails(
           "GetSession",
@@ -11249,13 +11798,40 @@ var _AgentBay = class _AgentBay {
       session.token = getResult.data.token;
       session.resourceUrl = getResult.data.resourceUrl;
     }
-    const contextName = `file-transfer-context-${Date.now()}`;
-    const contextResult = await this.context.get(contextName, true);
-    if (contextResult.success && contextResult.context) {
-      session.fileTransferContextId = contextResult.context.id;
-      logInfo(`\u{1F4C1} Created file transfer context for recovered session: ${contextResult.context.id}`);
+    if (getResult.data && getResult.data.contexts && getResult.data.contexts.length > 0) {
+      const contexts = getResult.data.contexts;
+      const fileTransferContexts = contexts.filter(
+        (ctx) => ctx.name && ctx.name.startsWith("file-transfer-context-")
+      );
+      if (fileTransferContexts.length === 0) {
+        const availableContexts = contexts.map((ctx) => ctx.name || "unknown");
+        logWarn(
+          `\u26A0\uFE0F  No file-transfer-context- found in contexts list for session ${sessionId}. Available contexts: ${availableContexts.join(", ")}`
+        );
+        session.fileTransferContextId = null;
+      } else if (fileTransferContexts.length === 1) {
+        const contextId = fileTransferContexts[0].id;
+        if (contextId) {
+          session.fileTransferContextId = contextId;
+          logInfo(`\u{1F4C1} Found file transfer context for recovered session: ${contextId}`);
+        } else {
+          logWarn(
+            `\u26A0\uFE0F  File transfer context found but missing 'id' field: ${JSON.stringify(fileTransferContexts[0])}`
+          );
+          session.fileTransferContextId = null;
+        }
+      } else {
+        const contextNames = fileTransferContexts.map((ctx) => ctx.name || "unknown");
+        logWarn(
+          `\u26A0\uFE0F  Multiple file-transfer-context- found in contexts list for session ${sessionId}. Found ${fileTransferContexts.length} contexts: ${contextNames.join(", ")}. Not setting fileTransferContextId.`
+        );
+        session.fileTransferContextId = null;
+      }
     } else {
-      logError(`\u26A0\uFE0F  Failed to create file transfer context for recovered session: ${contextResult.errorMessage || "Unknown error"}`);
+      logWarn(
+        `\u26A0\uFE0F  No contexts list found in GetSession response for session ${sessionId}. fileTransferContextId will remain null.`
+      );
+      session.fileTransferContextId = null;
     }
     return {
       requestId: getResult.requestId,
@@ -11294,6 +11870,88 @@ var _AgentBay = class _AgentBay {
   getAPIKey() {
     return this.apiKey;
   }
+  /**
+   * Asynchronously pause a session, putting it into a dormant state.
+   *
+   * This method directly calls the PauseSessionAsync API without waiting for the session
+   * to reach the PAUSED state.
+   *
+   * @param session - The session to pause.
+   * @param timeout - Timeout in seconds to wait for the session to pause. Defaults to 600 seconds.
+   * @param pollInterval - Interval in seconds between status polls. Defaults to 2.0 seconds.
+   * @returns SessionPauseResult indicating success or failure and request ID
+   *
+   * @example
+   * ```typescript
+   * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+   * const session = (await agentBay.create()).session;
+   * const pauseResult = await agentBay.pauseAsync(session);
+   * await agentBay.resumeAsync(session);
+   * await session.delete();
+   * ```
+   *
+   * @remarks
+   * **Behavior:**
+   * - This method does not wait for the session to reach the PAUSED state
+   * - It only submits the pause request to the API
+   * - The session state transitions from RUNNING -> PAUSING -> PAUSED
+   * - Paused sessions consume fewer resources but maintain their state
+   *
+   * @see {@link resumeAsync}, {@link Session.pauseAsync}
+   */
+  async pauseAsync(session, timeout = 600, pollInterval = 2) {
+    try {
+      return await session.pauseAsync(timeout, pollInterval);
+    } catch (error) {
+      logError("Error calling pause session async:", error);
+      return {
+        requestId: "",
+        success: false,
+        errorMessage: `Failed to pause session ${session.sessionId}: ${error}`
+      };
+    }
+  }
+  /**
+   * Asynchronously resume a session from a paused state.
+   *
+   * This method directly calls the ResumeSessionAsync API without waiting for the session
+   * to reach the RUNNING state.
+   *
+   * @param session - The session to resume.
+   * @param timeout - Timeout in seconds to wait for the session to resume. Defaults to 600 seconds.
+   * @param pollInterval - Interval in seconds between status polls. Defaults to 2.0 seconds.
+   * @returns SessionResumeResult indicating success or failure and request ID
+   *
+   * @example
+   * ```typescript
+   * const agentBay = new AgentBay({ apiKey: 'your_api_key' });
+   * const session = (await agentBay.create()).session;
+   * await agentBay.pauseAsync(session);
+   * const resumeResult = await agentBay.resumeAsync(session);
+   * await session.delete();
+   * ```
+   *
+   * @remarks
+   * **Behavior:**
+   * - This method does not wait for the session to reach the RUNNING state
+   * - It only submits the resume request to the API
+   * - The session state transitions from PAUSED -> RESUMING -> RUNNING
+   * - Only sessions in PAUSED state can be resumed
+   *
+   * @see {@link pauseAsync}, {@link Session.resumeAsync}
+   */
+  async resumeAsync(session, timeout = 600, pollInterval = 2) {
+    try {
+      return await session.resumeAsync(timeout, pollInterval);
+    } catch (error) {
+      logError("Error calling resume session async:", error);
+      return {
+        requestId: "",
+        success: false,
+        errorMessage: `Failed to resume session ${session.sessionId}: ${error}`
+      };
+    }
+  }
 };
 __name(_AgentBay, "AgentBay");
 var AgentBay = _AgentBay;
@@ -11303,8 +11961,8 @@ init_esm_shims();
 
 // src/extension.ts
 init_esm_shims();
-import * as fs5 from "fs";
-import * as path5 from "path";
+import * as fs6 from "fs";
+import * as path6 from "path";
 import * as crypto from "crypto";
 import fetch3 from "node-fetch";
 var EXTENSIONS_BASE_PATH = "/tmp/extensions";
@@ -11456,7 +12114,7 @@ var _ExtensionsService = class _ExtensionsService {
         throw new AgentBayError(`Failed to get upload URL: ${urlResult.url || "No URL returned"}`);
       }
       const preSignedUrl = urlResult.url;
-      const fileBuffer = fs5.readFileSync(localPath);
+      const fileBuffer = fs6.readFileSync(localPath);
       const response = await fetch3(preSignedUrl, {
         method: "PUT",
         body: fileBuffer
@@ -11539,15 +12197,15 @@ var _ExtensionsService = class _ExtensionsService {
    */
   async create(localPath) {
     await this._ensureInitialized();
-    if (!fs5.existsSync(localPath)) {
+    if (!fs6.existsSync(localPath)) {
       throw new Error(`The specified local file was not found: ${localPath}`);
     }
-    const fileExtension = path5.extname(localPath).toLowerCase();
+    const fileExtension = path6.extname(localPath).toLowerCase();
     if (fileExtension !== ".zip") {
       throw new Error(`Unsupported plugin format '${fileExtension}'. Only ZIP format (.zip) is supported.`);
     }
     const extensionId = `ext_${crypto.randomBytes(16).toString("hex")}${fileExtension}`;
-    const extensionName = path5.basename(localPath);
+    const extensionName = path6.basename(localPath);
     const remotePath = `${EXTENSIONS_BASE_PATH}/${extensionId}`;
     await this._uploadToCloud(localPath, remotePath);
     return new Extension(extensionId, extensionName);
@@ -11574,7 +12232,7 @@ var _ExtensionsService = class _ExtensionsService {
    */
   async update(extensionId, newLocalPath) {
     await this._ensureInitialized();
-    if (!fs5.existsSync(newLocalPath)) {
+    if (!fs6.existsSync(newLocalPath)) {
       throw new Error(`The specified new local file was not found: ${newLocalPath}`);
     }
     const existingExtensions = await this.list();
@@ -11584,7 +12242,7 @@ var _ExtensionsService = class _ExtensionsService {
     }
     const remotePath = `${EXTENSIONS_BASE_PATH}/${extensionId}`;
     await this._uploadToCloud(newLocalPath, remotePath);
-    return new Extension(extensionId, path5.basename(newLocalPath));
+    return new Extension(extensionId, path6.basename(newLocalPath));
   }
   /**
    * Gets detailed information about a specific browser extension.
@@ -11709,21 +12367,20 @@ var _ExtensionsService = class _ExtensionsService {
 __name(_ExtensionsService, "ExtensionsService");
 var ExtensionsService = _ExtensionsService;
 
-// src/types/index.ts
-init_esm_shims();
-
-// src/types/list-session-params.ts
+// src/mobile-simulate.ts
 init_esm_shims();
-function createListSessionParams(labels = {}) {
-  return {
-    maxResults: 10,
-    labels
-  };
-}
-__name(createListSessionParams, "createListSessionParams");
+import fetch4 from "node-fetch";
 
 // src/types/extra-configs.ts
 init_esm_shims();
+var MobileSimulateMode = /* @__PURE__ */ ((MobileSimulateMode2) => {
+  MobileSimulateMode2["PropertiesOnly"] = "PropertiesOnly";
+  MobileSimulateMode2["SensorsOnly"] = "SensorsOnly";
+  MobileSimulateMode2["PackagesOnly"] = "PackagesOnly";
+  MobileSimulateMode2["ServicesOnly"] = "ServicesOnly";
+  MobileSimulateMode2["All"] = "All";
+  return MobileSimulateMode2;
+})(MobileSimulateMode || {});
 function extraConfigsToJSON(extraConfigs) {
   if (!extraConfigs) {
     return "";
@@ -11759,6 +12416,21 @@ function validateAppManagerRule(rule) {
   }
 }
 __name(validateAppManagerRule, "validateAppManagerRule");
+function validateMobileSimulateConfig(config) {
+  if (typeof config.simulate !== "boolean") {
+    throw new Error("MobileSimulateConfig simulate must be a boolean");
+  }
+  if (config.simulateMode !== void 0) {
+    const validModes = Object.values(MobileSimulateMode);
+    if (!validModes.includes(config.simulateMode)) {
+      throw new Error(`Invalid simulateMode: ${config.simulateMode}. Must be one of: ${validModes.join(", ")}`);
+    }
+  }
+  if (config.simulatedContextId !== void 0 && typeof config.simulatedContextId !== "string") {
+    throw new Error("MobileSimulateConfig simulatedContextId must be a string");
+  }
+}
+__name(validateMobileSimulateConfig, "validateMobileSimulateConfig");
 function validateMobileExtraConfig(config) {
   if (typeof config.lockResolution !== "boolean") {
     throw new Error("MobileExtraConfig lockResolution must be a boolean");
@@ -11779,6 +12451,9 @@ function validateMobileExtraConfig(config) {
       }
     }
   }
+  if (config.simulateConfig) {
+    validateMobileSimulateConfig(config.simulateConfig);
+  }
 }
 __name(validateMobileExtraConfig, "validateMobileExtraConfig");
 function validateExtraConfigs(extraConfigs) {
@@ -11788,6 +12463,300 @@ function validateExtraConfigs(extraConfigs) {
 }
 __name(validateExtraConfigs, "validateExtraConfigs");
 
+// src/mobile-simulate.ts
+var MOBILE_INFO_DEFAULT_PATH = "/data/agentbay_mobile_info";
+var MOBILE_INFO_SUB_PATH = "/agentbay_mobile_info";
+var MOBILE_INFO_FILE_NAME = "dev_info.json";
+var _MobileSimulateService = class _MobileSimulateService {
+  /**
+   * Initialize the MobileSimulateService.
+   * 
+   * @param agentBay - The AgentBay instance.
+   */
+  constructor(agentBay) {
+    this.simulateEnable = false;
+    this.simulateMode = "PropertiesOnly" /* PropertiesOnly */;
+    this.useInternalContext = true;
+    if (!agentBay) {
+      throw new Error("agentBay is required");
+    }
+    if (!agentBay.context) {
+      throw new Error("agentBay.context is required");
+    }
+    this.agentBay = agentBay;
+    this.contextService = agentBay.context;
+  }
+  /**
+   * Set the simulate enable flag.
+   * 
+   * @param enable - The simulate feature enable flag.
+   */
+  setSimulateEnable(enable) {
+    this.simulateEnable = enable;
+  }
+  /**
+   * Get the simulate enable flag.
+   * 
+   * @returns The simulate feature enable flag.
+   */
+  getSimulateEnable() {
+    return this.simulateEnable;
+  }
+  /**
+   * Set the simulate mode.
+   * 
+   * @param mode - The simulate mode.
+   *   - PropertiesOnly: Simulate only device properties.
+   *   - SensorsOnly: Simulate only device sensors.
+   *   - PackagesOnly: Simulate only installed packages.
+   *   - ServicesOnly: Simulate only system services.
+   *   - All: Simulate all aspects of the device.
+   */
+  setSimulateMode(mode) {
+    this.simulateMode = mode;
+  }
+  /**
+   * Get the simulate mode.
+   * 
+   * @returns The simulate mode.
+   */
+  getSimulateMode() {
+    return this.simulateMode;
+  }
+  /**
+   * Set a previously saved simulate context id. Please make sure the context id is provided by MobileSimulateService
+   * but not user side created context.
+   * 
+   * @param contextId - The context ID of the previously saved mobile simulate context.
+   */
+  setSimulateContextId(contextId) {
+    this.contextId = contextId;
+    logInfo(`set simulate context id = ${contextId}`);
+    this.updateContext(true, contextId, void 0);
+  }
+  /**
+   * Get the simulate context id.
+   * 
+   * @returns The context ID of the mobile simulate context.
+   */
+  getSimulateContextId() {
+    return this.contextId;
+  }
+  /**
+   * Get the simulate config.
+   * 
+   * @returns The simulate config.
+   *   - simulate: The simulate feature enable flag.
+   *   - simulatePath: The path of the mobile dev info file.
+   *   - simulateMode: The simulate mode.
+   *   - simulatedContextId: The context ID of the mobile info.
+   */
+  getSimulateConfig() {
+    const simulatedContextId = this.useInternalContext ? this.contextId : void 0;
+    return {
+      simulate: this.simulateEnable,
+      simulatePath: this.mobileDevInfoPath,
+      simulateMode: this.simulateMode,
+      simulatedContextId
+    };
+  }
+  /**
+   * Check if the mobile dev info file exists in one context sync. (Only for user provided context sync)
+   * 
+   * @param contextSync - The context sync to check.
+   * @returns True if the mobile dev info file exists, False otherwise.
+   * @throws Error if context_sync is not provided or context_sync.context_id or context_sync.path is not provided.
+   * 
+   * @remarks
+   * This method can only be used when mobile simulate context sync is managed by user side. For internal mobile simulate
+   * context sync, this method will not work.
+   */
+  async hasMobileInfo(contextSync) {
+    if (!contextSync) {
+      throw new Error("contextSync is required");
+    }
+    if (!contextSync.contextId) {
+      throw new Error("contextSync.contextId is required");
+    }
+    if (!contextSync.path) {
+      throw new Error("contextSync.path is required");
+    }
+    const mobileDevInfoPath = contextSync.path + MOBILE_INFO_SUB_PATH + "/";
+    logDebug(`hasMobileInfo: context_id = ${contextSync.contextId}, mobile_dev_info_path = ${mobileDevInfoPath}`);
+    const res = await this.contextService.listFiles(contextSync.contextId, mobileDevInfoPath, 1, 50);
+    let foundDevInfo = false;
+    if (res.success) {
+      for (const entry of res.entries) {
+        if (entry.fileName === MOBILE_INFO_FILE_NAME) {
+          foundDevInfo = true;
+          break;
+        }
+      }
+    } else {
+      logError(`failed to list files: ${res.errorMessage}`);
+      return false;
+    }
+    if (foundDevInfo) {
+      logInfo("mobile dev info already exists");
+      this.updateContext(false, contextSync.contextId, contextSync);
+      return true;
+    } else {
+      logInfo("mobile dev info does not exist");
+      return false;
+    }
+  }
+  /**
+   * Upload the mobile simulate dev info.
+   * 
+   * @param mobileDevInfoContent - The mobile simulate dev info content to upload.
+   * @param contextSync - Optional
+   *   - If not provided, a new context sync will be created for the mobile simulate service and this context id will
+   *     be returned by the MobileSimulateUploadResult. User can use this context id to do persistent mobile simulate across sessions.
+   *   - If provided, the mobile simulate dev info will be uploaded to the context sync in a specific path.
+   * 
+   * @returns The result of the upload operation.
+   * 
+   * @throws Error if mobile_dev_info_content is not provided or not a valid JSON string.
+   * @throws Error if context_sync is provided but context_sync.context_id is not provided.
+   * 
+   * @remarks
+   * If context_sync is not provided, a new context sync will be created for the mobile simulate.
+   * If context_sync is provided, the mobile simulate dev info will be uploaded to the context sync.
+   * If the mobile simulate dev info already exists in the context sync, the context sync will be updated.
+   * If the mobile simulate dev info does not exist in the context sync, the context sync will be created.
+   * If the upload operation fails, the error message will be returned.
+   */
+  async uploadMobileInfo(mobileDevInfoContent, contextSync) {
+    if (!mobileDevInfoContent) {
+      throw new Error("mobileDevInfoContent is required");
+    }
+    try {
+      JSON.parse(mobileDevInfoContent);
+    } catch (error) {
+      throw new Error("mobileDevInfoContent is not a valid JSON string");
+    }
+    if (!contextSync) {
+      const createdContext = await this.createContextForSimulate();
+      if (!createdContext) {
+        logError("Failed to create context for simulate");
+        return {
+          success: false,
+          errorMessage: "Failed to create context for simulate"
+        };
+      }
+      this.updateContext(true, createdContext.id, void 0);
+    } else {
+      if (!contextSync.contextId) {
+        throw new Error("contextSync.contextId is required");
+      }
+      this.updateContext(false, contextSync.contextId, contextSync);
+    }
+    const uploadPath = `${this.mobileDevInfoPath}/${MOBILE_INFO_FILE_NAME}`;
+    const uploadUrlResult = await this.contextService.getFileUploadUrl(this.contextId, uploadPath);
+    if (!uploadUrlResult.success) {
+      logError(`Failed to get file upload URL: ${uploadUrlResult.errorMessage}`);
+      return {
+        success: false,
+        errorMessage: uploadUrlResult.errorMessage
+      };
+    }
+    logDebug(`upload_url = ${uploadUrlResult.url}`);
+    try {
+      const encoder = new TextEncoder();
+      const uint8Array = encoder.encode(mobileDevInfoContent);
+      const response = await fetch4(uploadUrlResult.url, {
+        method: "PUT",
+        body: uint8Array
+      });
+      if (!response.ok) {
+        throw new Error(`Upload failed with status ${response.status}: ${response.statusText}`);
+      }
+    } catch (error) {
+      const errorMsg = `An error occurred while uploading the file: ${error instanceof Error ? error.message : String(error)}`;
+      logError(errorMsg);
+      return {
+        success: false,
+        errorMessage: errorMsg
+      };
+    }
+    logInfo("mobile dev info uploaded successfully");
+    return {
+      success: true,
+      mobileSimulateContextId: this.contextId
+    };
+  }
+  /**
+   * Update the context information.
+   * 
+   * @param isInternal - Whether this is an internal context.
+   * @param contextId - The context ID.
+   * @param contextSync - The context sync (required for external context).
+   */
+  updateContext(isInternal, contextId, contextSync) {
+    if (!isInternal) {
+      if (!contextSync) {
+        throw new Error("contextSync is required for external context");
+      }
+      if (contextSync.policy?.bwList?.whiteLists) {
+        const exists = contextSync.policy.bwList.whiteLists.some(
+          (whiteList) => whiteList.path === MOBILE_INFO_SUB_PATH
+        );
+        if (!exists) {
+          contextSync.policy.bwList.whiteLists.push({
+            path: MOBILE_INFO_SUB_PATH,
+            excludePaths: []
+          });
+          logInfo(`added mobile_dev_info_path to context_sync.policy.bw_list.white_lists: ${MOBILE_INFO_SUB_PATH}`);
+        }
+      }
+    }
+    this.useInternalContext = isInternal;
+    this.contextId = contextId;
+    this.contextSync = contextSync;
+    if (isInternal) {
+      this.mobileDevInfoPath = MOBILE_INFO_DEFAULT_PATH;
+    } else {
+      this.mobileDevInfoPath = contextSync.path + MOBILE_INFO_SUB_PATH;
+    }
+    logInfo(`updated context, is_internal = ${isInternal}, context_id = ${this.contextId}, mobile_dev_info_path = ${this.mobileDevInfoPath}`);
+  }
+  /**
+   * Create a context for simulate.
+   * 
+   * @returns The created context or null if failed.
+   */
+  async createContextForSimulate() {
+    const randomHex = Array.from(
+      { length: 16 },
+      () => Math.floor(Math.random() * 256).toString(16).padStart(2, "0")
+    ).join("");
+    const contextName = `mobile_sim_${randomHex}_${Math.floor(Date.now() / 1e3)}`;
+    const contextResult = await this.contextService.get(contextName, true);
+    if (!contextResult.success || !contextResult.context) {
+      logError(`Failed to create mobile simulate context: ${contextResult.errorMessage}`);
+      return null;
+    }
+    const context = contextResult.context;
+    logInfo(`created mobile simulate context, context_id = ${context.id}, context_name = ${context.name}`);
+    return context;
+  }
+};
+__name(_MobileSimulateService, "MobileSimulateService");
+var MobileSimulateService = _MobileSimulateService;
+
+// src/types/index.ts
+init_esm_shims();
+
+// src/types/list-session-params.ts
+init_esm_shims();
+function createListSessionParams(labels = {}) {
+  return {
+    maxResults: 10,
+    labels
+  };
+}
+__name(createListSessionParams, "createListSessionParams");
+
 // src/session-params.ts
 init_esm_shims();
 var BROWSER_FINGERPRINT_PERSIST_PATH2 = "/tmp/browser_fingerprint";
@@ -12061,8 +13030,8 @@ var _CreateSessionParams = class _CreateSessionParams {
   /**
    * AddContextSync adds a context sync configuration to the session parameters.
    */
-  addContextSync(contextId, path6, policy) {
-    const contextSync = new ContextSync(contextId, path6, policy);
+  addContextSync(contextId, path7, policy) {
+    const contextSync = new ContextSync(contextId, path7, policy);
     this.contextSync.push(contextSync);
     return this;
   }
@@ -12273,15 +13242,23 @@ export {
   ListSessionResponseBodyData,
   MOBILE_COMMAND_TEMPLATES,
   Mobile,
+  MobileSimulateMode,
+  MobileSimulateService,
   ModifyContextRequest,
   ModifyContextResponse,
   ModifyContextResponseBody,
   Oss,
   OssError,
+  PauseSessionAsyncRequest,
+  PauseSessionAsyncResponse,
+  PauseSessionAsyncResponseBody,
   RESOLUTION_LOCK_TEMPLATE,
   ReleaseMcpSessionRequest,
   ReleaseMcpSessionResponse,
   ReleaseMcpSessionResponseBody,
+  ResumeSessionAsyncRequest,
+  ResumeSessionAsyncResponse,
+  ResumeSessionAsyncResponseBody,
   SHOW_NAVIGATION_BAR_TEMPLATE,
   Session,
   SessionError,
@@ -12325,7 +13302,8 @@ export {
   setupLogger,
   validateAppManagerRule,
   validateExtraConfigs,
-  validateMobileExtraConfig
+  validateMobileExtraConfig,
+  validateMobileSimulateConfig
 };
 //# sourceMappingURL=index.mjs.map