adspower-browser 2.0.0-beta.2 → 2.0.0-beta.4

package/cli/index.js

@@ -106,6 +106,10 @@ var import_node_child_process = require("child_process");
 var import_colors = require("colors");
 var import_fs_extra2 = require("fs-extra2");
 var VERSION = "1.0.0";
+var toTerminalLink = (url, label) => {
+  const text = label || url;
+  return `\x1B]8;;${url}\x07${text}\x1B]8;;\x07`;
+};
 var logError = (message) => {
   console.error((0, import_colors.red)(message));
 };
@@ -355,11 +359,14 @@ var startChild = (type) => {
     );
     try {
       const mainJs = path2.join(__dirname, "../cwd/lib", "main.min.js");
-      child = (0, import_node_child_process2.fork)(mainJs, {
+      const forkOptions = {
         env,
         detached: true,
+        windowsHide: true,
+        // 隐藏子进程的控制台窗口
         stdio: ["ignore", "ignore", "ignore", "ipc"]
-      });
+      };
+      child = (0, import_node_child_process2.fork)(mainJs, [], forkOptions);
       ensureBrowserPath();
       store.setStoreValue("status", "starting");
       logSuccess(`[i] Adspower program is starting...`);
@@ -376,14 +383,19 @@ var startChild = (type) => {
         if (text.indexOf("START_API_SERVER_SUCCESS_$$_") === 0) {
           const port = text.replace("START_API_SERVER_SUCCESS_$$_", "").trim();
           store.setStoreValue("apiPort", port);
+          const localUrl = `http://local.adspower.net:${port}`;
           logSuccess(`Server running at:`);
-          logSuccess(` - local: http://local.adspower.net:${port}`);
+          logSuccess(` - local: ${toTerminalLink(localUrl)}`);
           writePidFile(store.getAllStoreValue());
           if (child) {
             child.disconnect();
             child.unref();
           }
         }
+        if (text.includes("CACHE_FOLDER_$$_")) {
+          const cacheFolder = text.replace("CACHE_FOLDER_$$_", "").trim();
+          logSuccess(`[i] Cache folder: ${cacheFolder}`);
+        }
         if (text.indexOf("START_API_SERVER_FAIL_$$_") === 0) {
           const serverMsg = text.replace("START_API_SERVER_FAIL_$$_", "").split("_").filter(Boolean);
           if (serverMsg[0]) {
@@ -572,106 +584,772 @@ var PORT = config.port;
 var API_KEY = config.apiKey;
 var CONFIG = config;
 
+// ../core/src/constants/localApiContracts.ts
+var LOCAL_API_CONTRACTS = {
+  "check-status": {
+    method: "GET",
+    path: "/status",
+    params: {}
+  },
+  "get-application-list": {
+    method: "GET",
+    path: "/api/v2/category/list",
+    params: {
+      category_id: { apiName: "category_id", location: "query" },
+      page: { apiName: "page", location: "query" },
+      limit: { apiName: "limit", location: "query" }
+    }
+  },
+  "open-browser": {
+    method: "POST",
+    path: "/api/v2/browser-profile/start",
+    params: {
+      profile_id: { apiName: "profile_id", location: "body" },
+      profile_no: { apiName: "profile_no", location: "body" },
+      ip_tab: { apiName: "ip_tab", location: "body" },
+      launch_args: { apiName: "launch_args", location: "body" },
+      headless: { apiName: "headless", location: "body" },
+      last_opened_tabs: { apiName: "last_opened_tabs", location: "body" },
+      proxy_detection: { apiName: "proxy_detection", location: "body" },
+      password_filling: { apiName: "password_filling", location: "body" },
+      password_saving: { apiName: "password_saving", location: "body" },
+      cdp_mask: { apiName: "cdp_mask", location: "body" },
+      delete_cache: { apiName: "delete_cache", location: "body" },
+      device_scale: { apiName: "device_scale", location: "body" }
+    }
+  },
+  "close-browser": {
+    method: "POST",
+    path: "/api/v2/browser-profile/stop",
+    params: {
+      profile_id: { apiName: "profile_id", location: "body" },
+      profile_no: { apiName: "profile_no", location: "body" }
+    }
+  },
+  "create-browser": {
+    method: "POST",
+    path: "/api/v2/browser-profile/create",
+    params: {
+      group_id: { apiName: "group_id", location: "body" },
+      username: { apiName: "username", location: "body" },
+      password: { apiName: "password", location: "body" },
+      cookie: { apiName: "cookie", location: "body" },
+      fakey: { apiName: "fakey", location: "body" },
+      name: { apiName: "name", location: "body" },
+      platform: { apiName: "platform", location: "body" },
+      remark: { apiName: "remark", location: "body" },
+      user_proxy_config: { apiName: "user_proxy_config", location: "body" },
+      proxyid: { apiName: "proxyid", location: "body" },
+      repeat_config: { apiName: "repeat_config", location: "body" },
+      ignore_cookie_error: { apiName: "ignore_cookie_error", location: "body" },
+      tabs: { apiName: "tabs", location: "body" },
+      ip: { apiName: "ip", location: "body" },
+      country: { apiName: "country", location: "body" },
+      region: { apiName: "region", location: "body" },
+      city: { apiName: "city", location: "body" },
+      ipchecker: { apiName: "ipchecker", location: "body" },
+      category_id: { apiName: "category_id", location: "body" },
+      profile_tag_ids: { apiName: "profile_tag_ids", location: "body" },
+      fingerprint_config: { apiName: "fingerprint_config", location: "body" },
+      platform_account: { apiName: "platform_account", location: "body" }
+    }
+  },
+  "update-browser": {
+    method: "POST",
+    path: "/api/v2/browser-profile/update",
+    params: {
+      profile_id: { apiName: "profile_id", location: "body" },
+      group_id: { apiName: "group_id", location: "body" },
+      username: { apiName: "username", location: "body" },
+      password: { apiName: "password", location: "body" },
+      cookie: { apiName: "cookie", location: "body" },
+      fakey: { apiName: "fakey", location: "body" },
+      name: { apiName: "name", location: "body" },
+      platform: { apiName: "platform", location: "body" },
+      remark: { apiName: "remark", location: "body" },
+      user_proxy_config: { apiName: "user_proxy_config", location: "body" },
+      proxyid: { apiName: "proxyid", location: "body" },
+      repeat_config: { apiName: "repeat_config", location: "body" },
+      ignore_cookie_error: { apiName: "ignore_cookie_error", location: "body" },
+      tabs: { apiName: "tabs", location: "body" },
+      ip: { apiName: "ip", location: "body" },
+      country: { apiName: "country", location: "body" },
+      region: { apiName: "region", location: "body" },
+      city: { apiName: "city", location: "body" },
+      ipchecker: { apiName: "ipchecker", location: "body" },
+      category_id: { apiName: "category_id", location: "body" },
+      profile_tag_ids: { apiName: "profile_tag_ids", location: "body" },
+      fingerprint_config: { apiName: "fingerprint_config", location: "body" },
+      platform_account: { apiName: "platform_account", location: "body" },
+      launch_args: { apiName: "launch_args", location: "body" },
+      tags_update_type: { apiName: "tags_update_type", location: "body" }
+    }
+  },
+  "delete-browser": {
+    method: "POST",
+    path: "/api/v2/browser-profile/delete",
+    params: {
+      profile_id: { apiName: "profile_id", location: "body" }
+    }
+  },
+  "get-browser-list": {
+    method: "POST",
+    path: "/api/v2/browser-profile/list",
+    params: {
+      group_id: { apiName: "group_id", location: "body" },
+      limit: { apiName: "limit", location: "body" },
+      page: { apiName: "page", location: "body" },
+      profile_id: { apiName: "profile_id", location: "body" },
+      profile_no: { apiName: "profile_no", location: "body" },
+      sort_type: { apiName: "sort_type", location: "body" },
+      sort_order: { apiName: "sort_order", location: "body" },
+      tag_ids: { apiName: "tag_ids", location: "body" },
+      tags_filter: { apiName: "tags_filter", location: "body" },
+      name: { apiName: "name", location: "body" },
+      name_filter: { apiName: "name_filter", location: "body" }
+    }
+  },
+  "get-opened-browser": {
+    method: "GET",
+    path: "/api/v1/browser/local-active",
+    params: {}
+  },
+  "move-browser": {
+    method: "POST",
+    path: "/api/v1/user/regroup",
+    params: {
+      user_ids: { apiName: "user_ids", location: "body" },
+      group_id: { apiName: "group_id", location: "body" }
+    }
+  },
+  "get-profile-cookies": {
+    method: "GET",
+    path: "/api/v2/browser-profile/cookies",
+    params: {
+      profile_id: { apiName: "profile_id", location: "query" },
+      profile_no: { apiName: "profile_no", location: "query" }
+    }
+  },
+  "get-profile-ua": {
+    method: "POST",
+    path: "/api/v2/browser-profile/ua",
+    params: {
+      profile_id: { apiName: "profile_id", location: "body" },
+      profile_no: { apiName: "profile_no", location: "body" }
+    }
+  },
+  "close-all-profiles": {
+    method: "POST",
+    path: "/api/v2/browser-profile/stop-all",
+    params: {}
+  },
+  "new-fingerprint": {
+    method: "POST",
+    path: "/api/v2/browser-profile/new-fingerprint",
+    params: {
+      profile_id: { apiName: "profile_id", location: "body" },
+      profile_no: { apiName: "profile_no", location: "body" }
+    }
+  },
+  "delete-cache-v2": {
+    method: "POST",
+    path: "/api/v2/browser-profile/delete-cache",
+    params: {
+      profile_id: { apiName: "profile_id", location: "body" },
+      type: { apiName: "type", location: "body" }
+    }
+  },
+  "share-profile": {
+    method: "POST",
+    path: "/api/v2/browser-profile/share",
+    params: {
+      profile_id: { apiName: "profile_id", location: "body" },
+      receiver: { apiName: "receiver", location: "body" },
+      share_type: { apiName: "share_type", location: "body" },
+      content: { apiName: "content", location: "body" }
+    }
+  },
+  "get-browser-active": {
+    method: "GET",
+    path: "/api/v2/browser-profile/active",
+    params: {
+      profile_id: { apiName: "profile_id", location: "query" },
+      profile_no: { apiName: "profile_no", location: "query" }
+    }
+  },
+  "get-cloud-active": {
+    method: "POST",
+    path: "/api/v1/browser/cloud-active",
+    params: {
+      user_ids: { apiName: "user_ids", location: "body" }
+    }
+  },
+  "create-group": {
+    method: "POST",
+    path: "/api/v1/group/create",
+    params: {
+      group_name: { apiName: "group_name", location: "body" },
+      remark: { apiName: "remark", location: "body" }
+    }
+  },
+  "update-group": {
+    method: "POST",
+    path: "/api/v1/group/update",
+    params: {
+      group_id: { apiName: "group_id", location: "body" },
+      group_name: { apiName: "group_name", location: "body" },
+      remark: { apiName: "remark", location: "body" }
+    }
+  },
+  "get-group-list": {
+    method: "GET",
+    path: "/api/v1/group/list",
+    params: {
+      group_name: { apiName: "group_name", location: "query" },
+      page: { apiName: "page", location: "query" },
+      page_size: { apiName: "page_size", location: "query" }
+    }
+  },
+  "create-proxy": {
+    method: "POST",
+    path: "/api/v2/proxy-list/create",
+    params: {},
+    bodyShape: "array"
+  },
+  "update-proxy": {
+    method: "POST",
+    path: "/api/v2/proxy-list/update",
+    params: {
+      proxy_id: { apiName: "proxy_id", location: "body" },
+      type: { apiName: "type", location: "body" },
+      host: { apiName: "host", location: "body" },
+      port: { apiName: "port", location: "body" },
+      user: { apiName: "user", location: "body" },
+      password: { apiName: "password", location: "body" },
+      proxy_url: { apiName: "proxy_url", location: "body" },
+      remark: { apiName: "remark", location: "body" },
+      ipchecker: { apiName: "ipchecker", location: "body" }
+    }
+  },
+  "get-proxy-list": {
+    method: "POST",
+    path: "/api/v2/proxy-list/list",
+    params: {
+      proxy_id: { apiName: "proxy_id", location: "body" },
+      limit: { apiName: "limit", location: "body" },
+      page: { apiName: "page", location: "body" }
+    }
+  },
+  "delete-proxy": {
+    method: "POST",
+    path: "/api/v2/proxy-list/delete",
+    params: {
+      proxy_id: { apiName: "proxy_id", location: "body" }
+    }
+  },
+  "get-tag-list": {
+    method: "POST",
+    path: "/api/v2/browser-tags/list",
+    params: {
+      ids: { apiName: "ids", location: "body" },
+      page: { apiName: "page", location: "body" },
+      limit: { apiName: "limit", location: "body" }
+    }
+  },
+  "create-tag": {
+    method: "POST",
+    path: "/api/v2/browser-tags/create",
+    params: {
+      tags: { apiName: "tags", location: "body" }
+    }
+  },
+  "update-tag": {
+    method: "POST",
+    path: "/api/v2/browser-tags/update",
+    params: {
+      tags: { apiName: "tags", location: "body" }
+    }
+  },
+  "delete-tag": {
+    method: "POST",
+    path: "/api/v2/browser-tags/delete",
+    params: {
+      ids: { apiName: "ids", location: "body" }
+    }
+  },
+  "download-kernel": {
+    method: "POST",
+    path: "/api/v2/browser-profile/download-kernel",
+    params: {
+      kernel_type: { apiName: "kernel_type", location: "body" },
+      kernel_version: { apiName: "kernel_version", location: "body" }
+    }
+  },
+  "get-kernel-list": {
+    method: "GET",
+    path: "/api/v2/browser-profile/kernels",
+    params: {
+      kernel_type: { apiName: "kernel_type", location: "query" }
+    }
+  },
+  "update-patch": {
+    method: "POST",
+    path: "/api/v2/browser-profile/update-patch",
+    params: {
+      version_type: { apiName: "version_type", location: "body" }
+    }
+  }
+};
+
 // ../core/src/constants/api.ts
+function readLocalApiMinIntervalMs() {
+  const raw = process.env.ADSP_LOCAL_API_MIN_INTERVAL_MS?.trim() ?? "";
+  if (!raw) {
+    return 0;
+  }
+  const n = Number(raw);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : 0;
+}
+var localApiThrottleLock = Promise.resolve();
+var localApiLastRequestStartMs = 0;
+async function sleep(ms) {
+  await new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+async function throttleLocalApiRequest() {
+  const gapMs = readLocalApiMinIntervalMs();
+  if (gapMs <= 0) {
+    return;
+  }
+  const prev = localApiThrottleLock;
+  let release;
+  localApiThrottleLock = new Promise((resolve) => {
+    release = resolve;
+  });
+  await prev;
+  try {
+    const now = Date.now();
+    const earliest = localApiLastRequestStartMs === 0 ? now : localApiLastRequestStartMs + gapMs;
+    const waitMs = Math.max(0, earliest - now);
+    if (waitMs > 0) {
+      await sleep(waitMs);
+    }
+    localApiLastRequestStartMs = Date.now();
+  } finally {
+    release();
+  }
+}
+function isLocalApiRequestUrl(url) {
+  if (!url) {
+    return false;
+  }
+  try {
+    const u = new URL(url, "http://127.0.0.1");
+    return u.hostname === "127.0.0.1" || u.hostname === "localhost";
+  } catch {
+    return url.includes("127.0.0.1") || url.includes("localhost");
+  }
+}
 var LOCAL_API_BASE = `http://127.0.0.1:${PORT}`;
 var getLocalApiBase = () => {
   return `http://127.0.0.1:${CONFIG.port}`;
 };
 var API_ENDPOINTS = {
   STATUS: "/status",
-  START_BROWSER: "/api/v2/browser-profile/start",
-  CLOSE_BROWSER: "/api/v2/browser-profile/stop",
-  CREATE_BROWSER: "/api/v2/browser-profile/create",
-  GET_BROWSER_LIST: "/api/v2/browser-profile/list",
-  UPDATE_BROWSER: "/api/v2/browser-profile/update",
-  DELETE_BROWSER: "/api/v2/browser-profile/delete",
-  GET_PROFILE_COOKIES: "/api/v2/browser-profile/cookies",
-  GET_PROFILE_UA: "/api/v2/browser-profile/ua",
-  CLOSE_ALL_PROFILES: "/api/v2/browser-profile/stop-all",
-  NEW_FINGERPRINT: "/api/v2/browser-profile/new-fingerprint",
-  DELETE_CACHE_V2: "/api/v2/browser-profile/delete-cache",
-  SHARE_PROFILE: "/api/v2/browser-profile/share",
-  GET_BROWSER_ACTIVE: "/api/v2/browser-profile/active",
-  CREATE_PROXY: "/api/v2/proxy-list/create",
-  UPDATE_PROXY: "/api/v2/proxy-list/update",
-  GET_PROXY_LIST: "/api/v2/proxy-list/list",
-  DELETE_PROXY: "/api/v2/proxy-list/delete",
-  GET_OPENED_BROWSER: "/api/v1/browser/local-active",
-  GET_CLOUD_ACTIVE: "/api/v1/browser/cloud-active",
-  MOVE_BROWSER: "/api/v1/user/regroup",
-  GET_GROUP_LIST: "/api/v1/group/list",
-  CREATE_GROUP: "/api/v1/group/create",
-  UPDATE_GROUP: "/api/v1/group/update",
-  GET_APPLICATION_LIST: "/api/v2/category/list",
-  GET_TAG_LIST: "/api/v2/browser-tags/list",
-  CREATE_TAG: "/api/v2/browser-tags/create",
-  UPDATE_TAG: "/api/v2/browser-tags/update",
-  DELETE_TAG: "/api/v2/browser-tags/delete",
-  DOWNLOAD_KERNEL: "/api/v2/browser-profile/download-kernel",
-  GET_KERNEL_LIST: "/api/v2/browser-profile/kernels",
-  UPDATE_PATCH: "/api/v2/browser-profile/update-patch"
+  START_BROWSER: LOCAL_API_CONTRACTS["open-browser"].path,
+  CLOSE_BROWSER: LOCAL_API_CONTRACTS["close-browser"].path,
+  CREATE_BROWSER: LOCAL_API_CONTRACTS["create-browser"].path,
+  GET_BROWSER_LIST: LOCAL_API_CONTRACTS["get-browser-list"].path,
+  UPDATE_BROWSER: LOCAL_API_CONTRACTS["update-browser"].path,
+  DELETE_BROWSER: LOCAL_API_CONTRACTS["delete-browser"].path,
+  GET_PROFILE_COOKIES: LOCAL_API_CONTRACTS["get-profile-cookies"].path,
+  GET_PROFILE_UA: LOCAL_API_CONTRACTS["get-profile-ua"].path,
+  CLOSE_ALL_PROFILES: LOCAL_API_CONTRACTS["close-all-profiles"].path,
+  NEW_FINGERPRINT: LOCAL_API_CONTRACTS["new-fingerprint"].path,
+  DELETE_CACHE_V2: LOCAL_API_CONTRACTS["delete-cache-v2"].path,
+  SHARE_PROFILE: LOCAL_API_CONTRACTS["share-profile"].path,
+  GET_BROWSER_ACTIVE: LOCAL_API_CONTRACTS["get-browser-active"].path,
+  CREATE_PROXY: LOCAL_API_CONTRACTS["create-proxy"].path,
+  UPDATE_PROXY: LOCAL_API_CONTRACTS["update-proxy"].path,
+  GET_PROXY_LIST: LOCAL_API_CONTRACTS["get-proxy-list"].path,
+  DELETE_PROXY: LOCAL_API_CONTRACTS["delete-proxy"].path,
+  GET_OPENED_BROWSER: LOCAL_API_CONTRACTS["get-opened-browser"].path,
+  GET_CLOUD_ACTIVE: LOCAL_API_CONTRACTS["get-cloud-active"].path,
+  MOVE_BROWSER: LOCAL_API_CONTRACTS["move-browser"].path,
+  GET_GROUP_LIST: LOCAL_API_CONTRACTS["get-group-list"].path,
+  CREATE_GROUP: LOCAL_API_CONTRACTS["create-group"].path,
+  UPDATE_GROUP: LOCAL_API_CONTRACTS["update-group"].path,
+  GET_APPLICATION_LIST: LOCAL_API_CONTRACTS["get-application-list"].path,
+  GET_TAG_LIST: LOCAL_API_CONTRACTS["get-tag-list"].path,
+  CREATE_TAG: LOCAL_API_CONTRACTS["create-tag"].path,
+  UPDATE_TAG: LOCAL_API_CONTRACTS["update-tag"].path,
+  DELETE_TAG: LOCAL_API_CONTRACTS["delete-tag"].path,
+  DOWNLOAD_KERNEL: LOCAL_API_CONTRACTS["download-kernel"].path,
+  GET_KERNEL_LIST: LOCAL_API_CONTRACTS["get-kernel-list"].path,
+  UPDATE_PATCH: LOCAL_API_CONTRACTS["update-patch"].path
 };
 var apiClient = import_axios.default.create({
   headers: API_KEY ? { "Authorization": `Bearer ${API_KEY}` } : {}
 });
 var getApiClient = () => {
-  return import_axios.default.create({
+  const client = import_axios.default.create({
     headers: CONFIG.apiKey ? { "Authorization": `Bearer ${CONFIG.apiKey}` } : {}
   });
+  client.interceptors.request.use(async (config2) => {
+    if (isLocalApiRequestUrl(config2.url)) {
+      await throttleLocalApiRequest();
+    }
+    return config2;
+  });
+  return client;
 };
 
+// ../core/src/constants/toolIntentMetadata.ts
+var TOOL_INTENT_BY_NAME = {
+  "open-browser": {
+    intentEn: "Start an existing AdsPower browser profile (launch the profile browser).",
+    intentZh: "\u542F\u52A8\u5DF2\u5B58\u5728\u7684 AdsPower \u6D4F\u89C8\u5668\u73AF\u5883\uFF08\u7528\u6237\u5E38\u79F0\u73AF\u5883\u3001\u914D\u7F6E\u6587\u4EF6\u3001profile\uFF09\u3002",
+    triggersEn: "open browser, launch profile, start environment, open AdsPower, open config profile",
+    triggersZh: "\u6253\u5F00\u6D4F\u89C8\u5668,\u542F\u52A8\u73AF\u5883,\u6253\u5F00\u914D\u7F6E,\u6253\u5F00\u914D\u7F6E\u6587\u4EF6,\u6253\u5F00profile,\u62C9\u8D77AdsPower,\u542F\u52A8\u6307\u7EB9\u6D4F\u89C8\u5668"
+  },
+  "close-browser": {
+    intentEn: "Stop a running AdsPower browser profile.",
+    intentZh: "\u5173\u95ED\u6B63\u5728\u8FD0\u884C\u7684\u6D4F\u89C8\u5668\u73AF\u5883 / profile\u3002",
+    triggersEn: "close browser, stop profile, shutdown environment, kill browser",
+    triggersZh: "\u5173\u95ED\u6D4F\u89C8\u5668,\u505C\u6B62\u73AF\u5883,\u5173\u6389profile,\u7ED3\u675F\u6D4F\u89C8\u5668,\u9000\u51FA\u6307\u7EB9\u73AF\u5883"
+  },
+  "create-browser": {
+    intentEn: "Create a new AdsPower browser profile (account).",
+    intentZh: "\u65B0\u5EFA\u6D4F\u89C8\u5668\u73AF\u5883 / \u8D26\u53F7 profile\u3002",
+    triggersEn: "create profile, new browser, add account, spin up profile",
+    triggersZh: "\u65B0\u5EFA\u73AF\u5883,\u521B\u5EFAprofile,\u6DFB\u52A0\u6D4F\u89C8\u5668,\u65B0\u5F00\u6307\u7EB9,\u521B\u5EFA\u8D26\u53F7"
+  },
+  "update-browser": {
+    intentEn: "Update fields of an existing browser profile.",
+    intentZh: "\u66F4\u65B0\u5DF2\u6709 profile \u7684\u914D\u7F6E\uFF08\u5907\u6CE8\u3001\u4EE3\u7406\u3001\u6307\u7EB9\u7B49\uFF09\u3002",
+    triggersEn: "edit profile, change settings, modify browser, update fingerprint",
+    triggersZh: "\u4FEE\u6539\u914D\u7F6E,\u66F4\u65B0profile,\u6539\u4EE3\u7406,\u6539\u6307\u7EB9,\u7F16\u8F91\u73AF\u5883"
+  },
+  "delete-browser": {
+    intentEn: "Delete one or more browser profiles permanently.",
+    intentZh: "\u6C38\u4E45\u5220\u9664\u4E00\u4E2A\u6216\u591A\u4E2A\u6D4F\u89C8\u5668 profile\u3002",
+    triggersEn: "remove profile, delete account, trash browser",
+    triggersZh: "\u5220\u9664\u73AF\u5883,\u79FB\u9664profile,\u5220\u6389\u6D4F\u89C8\u5668\u8D26\u53F7"
+  },
+  "get-browser-list": {
+    intentEn: "List or search browser profiles (pagination, filters).",
+    intentZh: "\u5206\u9875/\u6761\u4EF6\u67E5\u8BE2\u6D4F\u89C8\u5668 profile \u5217\u8868\u3002",
+    triggersEn: "list profiles, search browsers, query accounts, show all profiles",
+    triggersZh: "\u5217\u8868,\u67E5\u8BE2\u73AF\u5883,\u641C\u7D22profile,\u5217\u51FA\u6240\u6709\u6D4F\u89C8\u5668"
+  },
+  "get-opened-browser": {
+    intentEn: "List browser profiles currently open on this device.",
+    intentZh: "\u67E5\u770B\u672C\u673A\u5F53\u524D\u5DF2\u6253\u5F00\u7684\u6D4F\u89C8\u5668 profile\u3002",
+    triggersEn: "opened browsers, running profiles, active local sessions",
+    triggersZh: "\u5DF2\u6253\u5F00,\u6B63\u5728\u8FD0\u884C,\u5F53\u524D\u4F1A\u8BDD,\u672C\u5730\u6D3B\u8DC3"
+  },
+  "move-browser": {
+    intentEn: "Move profiles to another group (regroup).",
+    intentZh: "\u5C06 profile \u79FB\u52A8\u5230\u6307\u5B9A\u5206\u7EC4\u3002",
+    triggersEn: "move to group, regroup profiles, change group",
+    triggersZh: "\u79FB\u52A8\u5206\u7EC4,\u6362\u7EC4,\u5F52\u7C7B\u5230\u7EC4"
+  },
+  "get-profile-cookies": {
+    intentEn: "Read cookies for one profile.",
+    intentZh: "\u8BFB\u53D6\u5355\u4E2A profile \u7684 Cookie\u3002",
+    triggersEn: "get cookies, export cookies, read cookie jar",
+    triggersZh: "\u5BFC\u51FACookie,\u67E5\u770BCookie,\u8BFB\u53D6\u7AD9\u70B9Cookie"
+  },
+  "get-profile-ua": {
+    intentEn: "Get User-Agent strings for up to 10 profiles.",
+    intentZh: "\u6279\u91CF\u67E5\u8BE2\u6700\u591A 10 \u4E2A profile \u7684 UA\u3002",
+    triggersEn: "user agent, UA string, browser UA",
+    triggersZh: "UA,\u7528\u6237\u4EE3\u7406,\u6D4F\u89C8\u5668\u6807\u8BC6"
+  },
+  "close-all-profiles": {
+    intentEn: "Close all opened profiles on this device.",
+    intentZh: "\u5173\u95ED\u672C\u673A\u6240\u6709\u5DF2\u6253\u5F00\u7684\u73AF\u5883\u3002",
+    triggersEn: "close everything, stop all browsers, shutdown all profiles",
+    triggersZh: "\u5168\u90E8\u5173\u95ED,\u4E00\u952E\u5173\u73AF\u5883,\u5173\u6240\u6709\u6D4F\u89C8\u5668"
+  },
+  "new-fingerprint": {
+    intentEn: "Generate a new fingerprint for up to 10 profiles.",
+    intentZh: "\u4E3A\u6700\u591A 10 \u4E2A profile \u91CD\u65B0\u751F\u6210\u6307\u7EB9\u3002",
+    triggersEn: "refresh fingerprint, regenerate fp, new device identity",
+    triggersZh: "\u5237\u65B0\u6307\u7EB9,\u91CD\u65B0\u6307\u7EB9,\u6362\u8BBE\u5907\u6307\u7EB9"
+  },
+  "delete-cache-v2": {
+    intentEn: "Clear selected local cache types for profiles.",
+    intentZh: "\u6309\u7C7B\u578B\u6E05\u7406 profile \u672C\u5730\u7F13\u5B58\u3002",
+    triggersEn: "clear cache, wipe storage, delete history cache",
+    triggersZh: "\u6E05\u7F13\u5B58,\u5220\u5386\u53F2,\u6E05\u7406\u672C\u5730\u6570\u636E"
+  },
+  "share-profile": {
+    intentEn: "Share profiles to another AdsPower account.",
+    intentZh: "\u5C06 profile \u5206\u4EAB\u7ED9\u5176\u4ED6 AdsPower \u8D26\u53F7\u3002",
+    triggersEn: "share account, transfer profile, send browser to user",
+    triggersZh: "\u5206\u4EAB\u73AF\u5883,\u8F6C\u8BA9profile,\u53D1\u7ED9\u540C\u4E8B"
+  },
+  "get-browser-active": {
+    intentEn: "Get active status/details for one profile.",
+    intentZh: "\u67E5\u8BE2\u5355\u4E2A profile \u7684\u6D3B\u8DC3/\u8FD0\u884C\u4FE1\u606F\u3002",
+    triggersEn: "is profile running, active status, browser state",
+    triggersZh: "\u662F\u5426\u5728\u7EBF,\u6D3B\u8DC3\u72B6\u6001,\u8FD0\u884C\u4FE1\u606F"
+  },
+  "get-cloud-active": {
+    intentEn: "Query cloud-side active status for many profile IDs.",
+    intentZh: "\u6309 user_ids \u6279\u91CF\u67E5\u8BE2\u4E91\u7AEF\u6D3B\u8DC3\u72B6\u6001\u3002",
+    triggersEn: "cloud status, remote active, team multi device caveat",
+    triggersZh: "\u4E91\u7AEF\u72B6\u6001,\u8FDC\u7A0B\u662F\u5426\u6253\u5F00,\u591A\u8BBE\u5907\u6A21\u5F0F\u9650\u5236"
+  },
+  "create-group": {
+    intentEn: "Create a browser profile group.",
+    intentZh: "\u65B0\u5EFA\u6D4F\u89C8\u5668\u5206\u7EC4\u3002",
+    triggersEn: "new group, add folder for profiles",
+    triggersZh: "\u65B0\u5EFA\u5206\u7EC4,\u521B\u5EFA\u7EC4,\u73AF\u5883\u5206\u7EC4"
+  },
+  "update-group": {
+    intentEn: "Rename or update a group.",
+    intentZh: "\u91CD\u547D\u540D\u6216\u66F4\u65B0\u5206\u7EC4\u4FE1\u606F\u3002",
+    triggersEn: "rename group, edit group",
+    triggersZh: "\u6539\u7EC4\u540D,\u66F4\u65B0\u5206\u7EC4"
+  },
+  "get-group-list": {
+    intentEn: "List groups with optional name search.",
+    intentZh: "\u5206\u9875\u67E5\u8BE2\u5206\u7EC4\u5217\u8868\uFF0C\u53EF\u6309\u540D\u79F0\u641C\u7D22\u3002",
+    triggersEn: "list groups, search group name",
+    triggersZh: "\u5206\u7EC4\u5217\u8868,\u67E5\u7EC4\u540D"
+  },
+  "check-status": {
+    intentEn: "Check Local API availability on this machine.",
+    intentZh: "\u68C0\u6D4B\u672C\u673A Local API \u662F\u5426\u53EF\u7528\u3002",
+    triggersEn: "API health, connection status, ping AdsPower API",
+    triggersZh: "\u63A5\u53E3\u901A\u4E0D\u901A,\u68C0\u6D4BAPI,\u8FDE\u63A5\u72B6\u6001"
+  },
+  "get-application-list": {
+    intentEn: "List application/extension categories with pagination.",
+    intentZh: "\u5206\u9875\u83B7\u53D6\u5E94\u7528/\u6269\u5C55\u5206\u7C7B\u5217\u8868\u3002",
+    triggersEn: "categories, extension list, application catalog",
+    triggersZh: "\u5E94\u7528\u5206\u7C7B,\u6269\u5C55\u76EE\u5F55,\u7C7B\u522B\u5217\u8868"
+  },
+  "create-proxy": {
+    intentEn: "Create one or more proxy entries.",
+    intentZh: "\u65B0\u5EFA\u4E00\u6761\u6216\u591A\u6761\u4EE3\u7406\u914D\u7F6E\u3002",
+    triggersEn: "add proxy, new proxy row",
+    triggersZh: "\u6DFB\u52A0\u4EE3\u7406,\u65B0\u5EFA\u4EE3\u7406"
+  },
+  "update-proxy": {
+    intentEn: "Update an existing proxy entry.",
+    intentZh: "\u66F4\u65B0\u5DF2\u6709\u4EE3\u7406\u9879\u3002",
+    triggersEn: "edit proxy, change proxy host",
+    triggersZh: "\u4FEE\u6539\u4EE3\u7406,\u66F4\u65B0\u4EE3\u7406"
+  },
+  "get-proxy-list": {
+    intentEn: "List proxies with filters/pagination.",
+    intentZh: "\u5206\u9875/\u6761\u4EF6\u67E5\u8BE2\u4EE3\u7406\u5217\u8868\u3002",
+    triggersEn: "list proxies, search proxy",
+    triggersZh: "\u4EE3\u7406\u5217\u8868,\u67E5\u4EE3\u7406"
+  },
+  "delete-proxy": {
+    intentEn: "Delete proxies by id list.",
+    intentZh: "\u6309 ID \u5217\u8868\u5220\u9664\u4EE3\u7406\u3002",
+    triggersEn: "remove proxy, delete proxy entries",
+    triggersZh: "\u5220\u9664\u4EE3\u7406,\u79FB\u9664\u4EE3\u7406"
+  },
+  "get-tag-list": {
+    intentEn: "List browser tags.",
+    intentZh: "\u67E5\u8BE2\u6D4F\u89C8\u5668\u6807\u7B7E\u5217\u8868\u3002",
+    triggersEn: "list tags, label list",
+    triggersZh: "\u6807\u7B7E\u5217\u8868,\u67E5\u770B\u6807\u7B7E"
+  },
+  "create-tag": {
+    intentEn: "Create tags (batch).",
+    intentZh: "\u6279\u91CF\u521B\u5EFA\u6807\u7B7E\u3002",
+    triggersEn: "new tag, add label",
+    triggersZh: "\u65B0\u5EFA\u6807\u7B7E,\u6DFB\u52A0\u6807\u7B7E"
+  },
+  "update-tag": {
+    intentEn: "Update existing tags (batch).",
+    intentZh: "\u6279\u91CF\u66F4\u65B0\u6807\u7B7E\u3002",
+    triggersEn: "rename tag, change tag color",
+    triggersZh: "\u6539\u6807\u7B7E\u540D,\u6539\u989C\u8272"
+  },
+  "delete-tag": {
+    intentEn: "Delete tags by id list.",
+    intentZh: "\u6309 ID \u5220\u9664\u6807\u7B7E\u3002",
+    triggersEn: "remove tags",
+    triggersZh: "\u5220\u9664\u6807\u7B7E"
+  },
+  "download-kernel": {
+    intentEn: "Download or update a browser kernel version.",
+    intentZh: "\u4E0B\u8F7D\u6216\u66F4\u65B0\u6307\u5B9A\u5185\u6838\u7248\u672C\u3002",
+    triggersEn: "download chrome kernel, fetch firefox kernel",
+    triggersZh: "\u4E0B\u8F7D\u5185\u6838,\u66F4\u65B0Chrome\u5185\u6838"
+  },
+  "get-kernel-list": {
+    intentEn: "List supported kernel versions (optional type filter).",
+    intentZh: "\u67E5\u8BE2\u652F\u6301\u7684\u5185\u6838\u7248\u672C\u5217\u8868\u3002",
+    triggersEn: "kernel versions, supported browsers list",
+    triggersZh: "\u5185\u6838\u5217\u8868,\u53EF\u7528\u7248\u672C"
+  },
+  "update-patch": {
+    intentEn: "Update AdsPower client patch channel.",
+    intentZh: "\u5C06 AdsPower \u5BA2\u6237\u7AEF\u66F4\u65B0\u5230\u8865\u4E01\u901A\u9053\u7248\u672C\u3002",
+    triggersEn: "upgrade client, patch update, stable beta channel",
+    triggersZh: "\u5347\u7EA7\u5BA2\u6237\u7AEF,\u8865\u4E01\u66F4\u65B0,\u7A33\u5B9A\u7248\u6D4B\u8BD5\u7248"
+  },
+  "connect-browser-with-ws": {
+    intentEn: "Attach Playwright automation using ws from open-browser.",
+    intentZh: "\u7528 open-browser \u8FD4\u56DE\u7684 ws \u8FDE\u63A5\u81EA\u52A8\u5316\uFF08Playwright\uFF09\u3002",
+    triggersEn: "connect puppeteer, attach playwright, ws automation",
+    triggersZh: "\u8FDE\u63A5\u81EA\u52A8\u5316,\u6302\u4E0APlaywright,\u7528ws\u63A7\u5236"
+  },
+  "open-new-page": {
+    intentEn: "Open a new page in the connected automation session.",
+    intentZh: "\u5728\u5DF2\u8FDE\u63A5\u4F1A\u8BDD\u4E2D\u6253\u5F00\u65B0\u6807\u7B7E\u9875/\u9875\u9762\u3002",
+    triggersEn: "new tab, new page",
+    triggersZh: "\u65B0\u6807\u7B7E\u9875,\u65B0\u9875\u9762"
+  },
+  "navigate": {
+    intentEn: "Navigate current automation page to a URL.",
+    intentZh: "\u81EA\u52A8\u5316\u5F53\u524D\u9875\u8DF3\u8F6C\u5230 URL\u3002",
+    triggersEn: "goto url, open url in automation",
+    triggersZh: "\u8DF3\u8F6C\u7F51\u5740,\u6253\u5F00\u94FE\u63A5"
+  },
+  "screenshot": {
+    intentEn: "Capture screenshot of the automation page.",
+    intentZh: "\u622A\u53D6\u81EA\u52A8\u5316\u5F53\u524D\u9875\u9762\u622A\u56FE\u3002",
+    triggersEn: "screenshot, capture page image",
+    triggersZh: "\u622A\u56FE,\u622A\u5C4F"
+  },
+  "get-page-visible-text": {
+    intentEn: "Read visible text of the current page.",
+    intentZh: "\u8BFB\u53D6\u5F53\u524D\u9875\u53EF\u89C1\u6587\u672C\u3002",
+    triggersEn: "visible text, page text content",
+    triggersZh: "\u53EF\u89C1\u6587\u5B57,\u9875\u9762\u6587\u672C"
+  },
+  "get-page-html": {
+    intentEn: "Read HTML of the current page.",
+    intentZh: "\u8BFB\u53D6\u5F53\u524D\u9875 HTML\u3002",
+    triggersEn: "page source, dom html",
+    triggersZh: "\u7F51\u9875\u6E90\u7801,HTML"
+  },
+  "click-element": {
+    intentEn: "Click an element by selector in automation session.",
+    intentZh: "\u5728\u81EA\u52A8\u5316\u4F1A\u8BDD\u4E2D\u6309\u9009\u62E9\u5668\u70B9\u51FB\u5143\u7D20\u3002",
+    triggersEn: "click button, tap element",
+    triggersZh: "\u70B9\u51FB\u6309\u94AE,\u70B9\u5143\u7D20"
+  },
+  "fill-input": {
+    intentEn: "Fill an input field by selector.",
+    intentZh: "\u6309\u9009\u62E9\u5668\u586B\u5199\u8F93\u5165\u6846\u3002",
+    triggersEn: "type text, enter value, input field",
+    triggersZh: "\u8F93\u5165\u6587\u5B57,\u586B\u8868\u5355"
+  },
+  "select-option": {
+    intentEn: "Select a dropdown option by selector and value.",
+    intentZh: "\u4E0B\u62C9\u6846\u6309 selector \u4E0E value \u9009\u62E9\u3002",
+    triggersEn: "dropdown select, pick option",
+    triggersZh: "\u4E0B\u62C9\u9009\u62E9,\u9009\u9009\u9879"
+  },
+  "hover-element": {
+    intentEn: "Hover an element by selector.",
+    intentZh: "\u60AC\u505C\u5230\u6307\u5B9A\u5143\u7D20\u3002",
+    triggersEn: "mouse over, hover menu",
+    triggersZh: "\u9F20\u6807\u60AC\u505C,\u5212\u8FC7\u83DC\u5355"
+  },
+  "scroll-element": {
+    intentEn: "Scroll an element into view or by selector.",
+    intentZh: "\u6EDA\u52A8\u6307\u5B9A\u5143\u7D20\u6216\u533A\u57DF\u3002",
+    triggersEn: "scroll into view, page scroll",
+    triggersZh: "\u6EDA\u52A8\u5230\u53EF\u89C1,\u9875\u9762\u6EDA\u52A8"
+  },
+  "press-key": {
+    intentEn: "Press a keyboard key (optional focused selector).",
+    intentZh: "\u6A21\u62DF\u6309\u952E\uFF08\u53EF\u9009\u9650\u5B9A\u5728\u5143\u7D20\u4E0A\uFF09\u3002",
+    triggersEn: "hit Enter, keyboard shortcut",
+    triggersZh: "\u6309\u56DE\u8F66,\u5FEB\u6377\u952E"
+  },
+  "evaluate-script": {
+    intentEn: "Run JavaScript in the page context.",
+    intentZh: "\u5728\u9875\u9762\u4E0A\u4E0B\u6587\u6267\u884C JS\u3002",
+    triggersEn: "execute js, run script in page",
+    triggersZh: "\u6267\u884C\u811A\u672C,\u9875\u9762JS"
+  },
+  "drag-element": {
+    intentEn: "Drag an element to a target element.",
+    intentZh: "\u62D6\u62FD\u5143\u7D20\u5230\u53E6\u4E00\u5143\u7D20\u3002",
+    triggersEn: "drag and drop, dnd",
+    triggersZh: "\u62D6\u62FD,\u62D6\u653E"
+  },
+  "iframe-click-element": {
+    intentEn: "Click inside an iframe by iframe and inner selectors.",
+    intentZh: "\u5728 iframe \u5185\u70B9\u51FB\u5B50\u5143\u7D20\u3002",
+    triggersEn: "iframe click, nested frame",
+    triggersZh: "\u6846\u67B6\u5185\u70B9\u51FB,iframe\u91CC\u70B9"
+  }
+};
+function formatDescription(rec) {
+  return `${rec.intentEn} / ${rec.intentZh} | Triggers: ${rec.triggersEn}; ${rec.triggersZh}`;
+}
+function buildMcpToolDescription(toolName, legacyFallback) {
+  const rec = TOOL_INTENT_BY_NAME[toolName];
+  return rec ? formatDescription(rec) : legacyFallback;
+}
+function buildCliCommandDescription(commandName, legacyFallback) {
+  return buildMcpToolDescription(commandName, legacyFallback);
+}
+
+// ../core/src/handlers/browser.ts
+var import_node_os = __toESM(require("os"));
+
 // ../core/src/utils/requestBuilder.ts
-function buildRequestBody(params) {
+function toContractValue(value) {
+  if (Array.isArray(value)) {
+    return value;
+  }
+  if (value && typeof value === "object") {
+    return buildNestedConfig(value);
+  }
+  return value;
+}
+function buildRequestBodyFor(command, params) {
   const requestBody = {};
-  const basicFields = {
-    groupId: "group_id",
-    username: "username",
-    password: "password",
-    cookie: "cookie",
-    fakey: "fakey",
-    name: "name",
-    platform: "platform",
-    remark: "remark",
-    proxyid: "proxyid",
-    repeatConfig: "repeat_config",
-    ignoreCookieError: "ignore_cookie_error",
-    tabs: "tabs",
-    ip: "ip",
-    country: "country",
-    region: "region",
-    city: "city",
-    ipchecker: "ipchecker",
-    categoryId: "category_id",
-    launchArgs: "launch_args",
-    profileId: "profile_id",
-    profileTagIds: "profile_tag_ids",
-    tagsUpdateType: "tags_update_type"
-  };
-  Object.entries(basicFields).forEach(([paramKey, key]) => {
-    const value = params[paramKey];
+  const contract = LOCAL_API_CONTRACTS[command];
+  Object.entries(contract.params).forEach(([inputName, config2]) => {
+    if (config2.location !== "body") {
+      return;
+    }
+    const value = params[inputName];
     if (value !== void 0) {
-      requestBody[key] = value;
+      requestBody[config2.apiName] = toContractValue(value);
     }
   });
-  if (params.userProxyConfig) {
-    const proxyConfig = buildNestedConfig(params.userProxyConfig);
-    if (Object.keys(proxyConfig).length > 0) {
-      requestBody.user_proxy_config = proxyConfig;
+  return requestBody;
+}
+function buildQueryParamsFor(command, params) {
+  const query = new URLSearchParams();
+  const contract = LOCAL_API_CONTRACTS[command];
+  Object.entries(contract.params).forEach(([inputName, config2]) => {
+    if (config2.location !== "query") {
+      return;
     }
-  }
-  if (params.fingerprintConfig) {
-    const fpConfig = buildNestedConfig(params.fingerprintConfig);
-    if (Object.keys(fpConfig).length > 0) {
-      requestBody.fingerprint_config = fpConfig;
+    const value = params[inputName];
+    if (value === void 0) {
+      return;
     }
-  }
-  return requestBody;
+    query.set(config2.apiName, Array.isArray(value) ? value.join(",") : String(value));
+  });
+  return query;
 }
 function buildNestedConfig(config2) {
   const result = {};
   Object.entries(config2).forEach(([key, value]) => {
     if (value !== void 0) {
-      if (typeof value === "object" && value !== null) {
+      if (Array.isArray(value)) {
+        result[key] = value;
+      } else if (typeof value === "object" && value !== null) {
         const nestedConfig = buildNestedConfig(value);
         if (Object.keys(nestedConfig).length > 0) {
           result[key] = nestedConfig;
@@ -684,47 +1362,58 @@ function buildNestedConfig(config2) {
   return result;
 }
 
+// ../core/src/utils/openBrowserHeadless.ts
+function isTruthyCi(env) {
+  const v = env.CI;
+  return v === "true" || v === "1" || v === "True";
+}
+function linuxLooksHeadless(env) {
+  const d = (env.DISPLAY ?? "").trim();
+  const w = (env.WAYLAND_DISPLAY ?? "").trim();
+  return d === "" && w === "";
+}
+function resolveOpenBrowserHeadless(params, env, platform) {
+  if (params.headless !== void 0) {
+    return { params: { ...params }, didAutoSetHeadless: false };
+  }
+  let needHeadless = false;
+  if (isTruthyCi(env)) {
+    needHeadless = true;
+  } else if (platform === "linux" && linuxLooksHeadless(env)) {
+    needHeadless = true;
+  }
+  if (!needHeadless) {
+    return { params: { ...params }, didAutoSetHeadless: false };
+  }
+  return {
+    params: { ...params, headless: "1" },
+    didAutoSetHeadless: true
+  };
+}
+
 // ../core/src/handlers/browser.ts
 var browserHandlers = {
-  async openBrowser({ profileNo, profileId, ipTab, launchArgs, clearCacheAfterClosing, cdpMask }) {
-    const requestBody = {};
-    if (profileId) {
-      requestBody.profile_id = profileId;
-    }
-    if (profileNo) {
-      requestBody.profile_no = profileNo;
-    }
-    if (ipTab) {
-      requestBody.ip_tab = ipTab;
-    }
-    if (launchArgs) {
-      requestBody.launch_args = launchArgs;
-    }
-    if (clearCacheAfterClosing) {
-      requestBody.delete_cache = clearCacheAfterClosing;
-    }
-    if (cdpMask) {
-      requestBody.cdp_mask = cdpMask;
-    }
+  async openBrowser(params) {
+    const { params: resolvedParams, didAutoSetHeadless } = resolveOpenBrowserHeadless(
+      params,
+      process.env,
+      import_node_os.default.platform()
+    );
+    const requestBody = buildRequestBodyFor("open-browser", resolvedParams);
     const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.START_BROWSER}`, requestBody);
     if (response.data.code === 0) {
+      const autoNote = didAutoSetHeadless ? "\n\u5DF2\u6839\u636E\u8FD0\u884C\u73AF\u5883\u81EA\u52A8\u4F7F\u7528 headless=1\uFF08\u65E0\u53EF\u7528\u56FE\u5F62\u4F1A\u8BDD\uFF09\u3002\nAuto-set headless=1 (no graphical session detected)." : "";
       return `Browser opened successfully with: ${Object.entries(response.data.data).map(([key, value]) => {
         if (value && typeof value === "object") {
           return Object.entries(value).map(([key2, value2]) => `ws.${key2}: ${value2}`).join("\n");
         }
         return `${key}: ${value}`;
-      }).join("\n")}`;
+      }).join("\n")}${autoNote}`;
     }
     throw new Error(`Failed to open browser: ${response.data.msg}`);
   },
-  async closeBrowser({ profileId, profileNo }) {
-    const requestBody = {};
-    if (profileId) {
-      requestBody.profile_id = profileId;
-    }
-    if (profileNo) {
-      requestBody.profile_no = profileNo;
-    }
+  async closeBrowser(params) {
+    const requestBody = buildRequestBodyFor("close-browser", params);
     const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.CLOSE_BROWSER}`, requestBody);
     if (response.data.code === 0) {
       return "Browser closed successfully";
@@ -732,7 +1421,7 @@ var browserHandlers = {
     throw new Error(`Failed to close browser: ${response.data.msg}`);
   },
   async createBrowser(params) {
-    const requestBody = buildRequestBody(params);
+    const requestBody = buildRequestBodyFor("create-browser", params);
     const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.CREATE_BROWSER}`, requestBody);
     if (response.data.code === 0) {
       return `Browser created successfully with: ${Object.entries(response.data.data).map(([key, value]) => `${key}: ${value}`).join("\n")}`;
@@ -740,58 +1429,25 @@ var browserHandlers = {
     throw new Error(`Failed to create browser: ${response.data.msg}`);
   },
   async updateBrowser(params) {
-    const requestBody = buildRequestBody(params);
+    const requestBody = buildRequestBodyFor("update-browser", params);
     const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.UPDATE_BROWSER}`, requestBody);
     if (response.data.code === 0) {
       return `Browser updated successfully with: ${Object.entries(response.data.data || {}).map(([key, value]) => `${key}: ${value}`).join("\n")}`;
     }
     throw new Error(`Failed to update browser: ${response.data.msg}`);
   },
-  async deleteBrowser({ profileIds }) {
-    const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.DELETE_BROWSER}`, {
-      profile_id: profileIds
-    });
+  async deleteBrowser(params) {
+    const response = await getApiClient().post(
+      `${getLocalApiBase()}${API_ENDPOINTS.DELETE_BROWSER}`,
+      buildRequestBodyFor("delete-browser", params)
+    );
     if (response.data.code === 0) {
-      return `Browsers deleted successfully: ${profileIds.join(", ")}`;
+      return `Browsers deleted successfully: ${params.profile_id.join(", ")}`;
     }
     throw new Error(`Failed to delete browsers: ${response.data.msg}`);
   },
   async getBrowserList(params) {
-    const { groupId, limit, page, profileId, profileNo, sortType, sortOrder, tag_ids, tags_filter, name, name_filter } = params;
-    const requestBody = {};
-    if (limit !== void 0) {
-      requestBody.limit = limit;
-    }
-    if (page !== void 0) {
-      requestBody.page = page;
-    }
-    if (profileId && profileId.length > 0) {
-      requestBody.profile_id = profileId;
-    }
-    if (profileNo && profileNo.length > 0) {
-      requestBody.profile_no = profileNo;
-    }
-    if (groupId !== void 0) {
-      requestBody.group_id = groupId;
-    }
-    if (sortType) {
-      requestBody.sort_type = sortType;
-    }
-    if (sortOrder) {
-      requestBody.sort_order = sortOrder;
-    }
-    if (tag_ids && tag_ids.length > 0) {
-      requestBody.tag_ids = tag_ids;
-    }
-    if (tags_filter) {
-      requestBody.tags_filter = tags_filter;
-    }
-    if (name) {
-      requestBody.name = name;
-    }
-    if (name_filter) {
-      requestBody.name_filter = name_filter;
-    }
+    const requestBody = buildRequestBodyFor("get-browser-list", params);
     const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.GET_BROWSER_LIST}`, requestBody);
     if (response.data.code === 0) {
       return `Browser list: ${JSON.stringify(response.data.data.list, null, 2)}`;
@@ -805,38 +1461,25 @@ var browserHandlers = {
     }
     throw new Error(`Failed to get opened browsers: ${response.data.msg}`);
   },
-  async moveBrowser({ groupId, userIds }) {
-    const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.MOVE_BROWSER}`, {
-      group_id: groupId,
-      user_ids: userIds
-    });
+  async moveBrowser(params) {
+    const requestBody = buildRequestBodyFor("move-browser", params);
+    const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.MOVE_BROWSER}`, requestBody);
+    const { group_id, user_ids } = params;
     if (response.data.code === 0) {
-      return `Browsers moved successfully to group ${groupId}: ${userIds.join(", ")}`;
+      return `Browsers moved successfully to group ${group_id}: ${user_ids.join(", ")}`;
     }
     throw new Error(`Failed to move browsers: ${response.data.msg}`);
   },
-  async getProfileCookies({ profileId, profileNo }) {
-    const params = new URLSearchParams();
-    if (profileId) {
-      params.set("profile_id", profileId);
-    }
-    if (profileNo) {
-      params.set("profile_no", profileNo);
-    }
-    const response = await getApiClient().get(`${getLocalApiBase()}${API_ENDPOINTS.GET_PROFILE_COOKIES}`, { params });
+  async getProfileCookies(params) {
+    const query = buildQueryParamsFor("get-profile-cookies", params);
+    const response = await getApiClient().get(`${getLocalApiBase()}${API_ENDPOINTS.GET_PROFILE_COOKIES}`, { params: query });
     if (response.data.code === 0) {
       return `Profile cookies: ${JSON.stringify(response.data.data, null, 2)}`;
     }
     throw new Error(`Failed to get profile cookies: ${response.data.msg}`);
   },
-  async getProfileUa({ profileId, profileNo }) {
-    const requestBody = {};
-    if (profileId && profileId.length > 0) {
-      requestBody.profile_id = profileId;
-    }
-    if (profileNo && profileNo.length > 0) {
-      requestBody.profile_no = profileNo;
-    }
+  async getProfileUa(params) {
+    const requestBody = buildRequestBodyFor("get-profile-ua", params);
     const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.GET_PROFILE_UA}`, requestBody);
     if (response.data.code === 0) {
       return `Profile User-Agent: ${JSON.stringify(response.data.data, null, 2)}`;
@@ -850,65 +1493,43 @@ var browserHandlers = {
     }
     throw new Error(`Failed to close all profiles: ${response.data.msg}`);
   },
-  async newFingerprint({ profileId, profileNo }) {
-    const requestBody = {};
-    if (profileId && profileId.length > 0) {
-      requestBody.profile_id = profileId;
-    }
-    if (profileNo && profileNo.length > 0) {
-      requestBody.profile_no = profileNo;
-    }
+  async newFingerprint(params) {
+    const requestBody = buildRequestBodyFor("new-fingerprint", params);
     const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.NEW_FINGERPRINT}`, requestBody);
     if (response.data.code === 0) {
       return `New fingerprint created: ${JSON.stringify(response.data.data, null, 2)}`;
     }
     throw new Error(`Failed to create new fingerprint: ${response.data.msg}`);
   },
-  async deleteCacheV2({ profileIds, type }) {
-    const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.DELETE_CACHE_V2}`, {
-      profile_id: profileIds,
-      type
-    });
+  async deleteCacheV2(params) {
+    const response = await getApiClient().post(
+      `${getLocalApiBase()}${API_ENDPOINTS.DELETE_CACHE_V2}`,
+      buildRequestBodyFor("delete-cache-v2", params)
+    );
     if (response.data.code === 0) {
-      return `Cache deleted successfully for profiles: ${profileIds.join(", ")}`;
+      return `Cache deleted successfully for profiles: ${params.profile_id.join(", ")}`;
     }
     throw new Error(`Failed to delete cache: ${response.data.msg}`);
   },
-  async shareProfile({ profileIds, receiver, shareType, content }) {
-    const requestBody = {
-      profile_id: profileIds,
-      receiver
-    };
-    if (shareType !== void 0) {
-      requestBody.share_type = shareType;
-    }
-    if (content !== void 0) {
-      requestBody.content = content;
-    }
+  async shareProfile(params) {
+    const requestBody = buildRequestBodyFor("share-profile", params);
     const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.SHARE_PROFILE}`, requestBody);
     if (response.data.code === 0) {
-      return `Profiles shared successfully: ${profileIds.join(", ")}`;
+      return `Profiles shared successfully: ${params.profile_id.join(", ")}`;
     }
     throw new Error(`Failed to share profiles: ${response.data.msg}`);
   },
-  async getBrowserActive({ profileId, profileNo }) {
-    const params = new URLSearchParams();
-    if (profileId) {
-      params.set("profile_id", profileId);
-    }
-    if (profileNo) {
-      params.set("profile_no", profileNo);
-    }
-    const response = await getApiClient().get(`${getLocalApiBase()}${API_ENDPOINTS.GET_BROWSER_ACTIVE}`, { params });
+  async getBrowserActive(params) {
+    const query = buildQueryParamsFor("get-browser-active", params);
+    const response = await getApiClient().get(`${getLocalApiBase()}${API_ENDPOINTS.GET_BROWSER_ACTIVE}`, { params: query });
     if (response.data.code === 0) {
       return `Browser active info: ${JSON.stringify(response.data.data, null, 2)}`;
     }
     throw new Error(`Failed to get browser active: ${response.data.msg}`);
   },
-  async getCloudActive({ userIds }) {
-    const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.GET_CLOUD_ACTIVE}`, {
-      user_ids: userIds
-    });
+  async getCloudActive(params) {
+    const requestBody = buildRequestBodyFor("get-cloud-active", params);
+    const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.GET_CLOUD_ACTIVE}`, requestBody);
     if (response.data.code === 0) {
       return `Cloud active browsers: ${JSON.stringify(response.data.data, null, 2)}`;
     }
@@ -918,46 +1539,31 @@ var browserHandlers = {
 
 // ../core/src/handlers/group.ts
 var groupHandlers = {
-  async createGroup({ groupName, remark }) {
-    const requestBody = {
-      group_name: groupName
-    };
-    if (remark !== void 0) {
-      requestBody.remark = remark;
-    }
+  async createGroup(params) {
+    const requestBody = buildRequestBodyFor("create-group", params);
     const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.CREATE_GROUP}`, requestBody);
+    const { group_name, remark } = params;
     if (response.data.code === 0) {
-      return `Group created successfully with name: ${groupName}${remark ? `, remark: ${remark}` : ""}`;
+      return `Group created successfully with name: ${group_name}${remark ? `, remark: ${remark}` : ""}`;
     }
     throw new Error(`Failed to create group: ${response.data.msg}`);
   },
-  async updateGroup({ groupId, groupName, remark }) {
-    const requestBody = {
-      group_id: groupId,
-      group_name: groupName
-    };
-    if (remark !== void 0) {
-      requestBody.remark = remark;
-    }
+  async updateGroup(params) {
+    const requestBody = buildRequestBodyFor("update-group", params);
     const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.UPDATE_GROUP}`, requestBody);
+    const { group_id, group_name, remark } = params;
     if (response.data.code === 0) {
-      return `Group updated successfully with id: ${groupId}, name: ${groupName}${remark !== void 0 ? `, remark: ${remark === null ? "(cleared)" : remark}` : ""}`;
+      return `Group updated successfully with id: ${group_id}, name: ${group_name}${remark !== void 0 ? `, remark: ${remark === null ? "(cleared)" : remark}` : ""}`;
     }
     throw new Error(`Failed to update group: ${response.data.msg}`);
   },
-  async getGroupList({ groupName, size, page }) {
-    const params = new URLSearchParams();
-    if (groupName) {
-      params.set("group_name", groupName);
-    }
-    if (size) {
-      params.set("page_size", size.toString());
-    }
-    if (page) {
-      params.set("page", page.toString());
+  async getGroupList(params) {
+    const query = buildQueryParamsFor("get-group-list", params);
+    const response = await getApiClient().get(`${getLocalApiBase()}${API_ENDPOINTS.GET_GROUP_LIST}`, { params: query });
+    if (response.data.code === 0) {
+      return `Group list: ${JSON.stringify(response.data.data.list, null, 2)}`;
     }
-    const response = await getApiClient().get(`${getLocalApiBase()}${API_ENDPOINTS.GET_GROUP_LIST}`, { params });
-    return `Group list: ${JSON.stringify(response.data.data.list, null, 2)}`;
+    throw new Error(`Failed to get group list: ${response.data.msg}`);
   }
 };
 
@@ -967,54 +1573,14 @@ var applicationHandlers = {
     const response = await getApiClient().get(`${getLocalApiBase()}${API_ENDPOINTS.STATUS}`);
     return `Connection status: ${JSON.stringify(response.data, null, 2)}`;
   },
-  async getApplicationList({ category_id, page, limit }) {
-    const params = new URLSearchParams();
-    if (category_id) {
-      params.set("category_id", category_id);
-    }
-    if (page !== void 0) {
-      params.set("page", page.toString());
-    }
-    if (limit !== void 0) {
-      params.set("limit", limit.toString());
-    }
-    const response = await getApiClient().get(`${getLocalApiBase()}${API_ENDPOINTS.GET_APPLICATION_LIST}`, { params });
+  async getApplicationList(params) {
+    const query = buildQueryParamsFor("get-application-list", params);
+    const response = await getApiClient().get(`${getLocalApiBase()}${API_ENDPOINTS.GET_APPLICATION_LIST}`, { params: query });
     return `Application list: ${JSON.stringify(response.data.data.list, null, 2)}`;
   }
 };
 
 // ../core/src/handlers/proxy.ts
-function buildProxyRequestBody(params) {
-  const requestBody = {};
-  if (params.proxyId) {
-    requestBody.proxy_id = params.proxyId;
-  }
-  if (params.type !== void 0) {
-    requestBody.type = params.type;
-  }
-  if (params.host !== void 0) {
-    requestBody.host = params.host;
-  }
-  if (params.port !== void 0) {
-    requestBody.port = params.port;
-  }
-  if (params.user !== void 0) {
-    requestBody.user = params.user;
-  }
-  if (params.password !== void 0) {
-    requestBody.password = params.password;
-  }
-  if (params.proxyUrl !== void 0) {
-    requestBody.proxy_url = params.proxyUrl;
-  }
-  if (params.remark !== void 0) {
-    requestBody.remark = params.remark;
-  }
-  if (params.ipchecker !== void 0) {
-    requestBody.ipchecker = params.ipchecker;
-  }
-  return requestBody;
-}
 function buildCreateProxyRequestBody(proxy) {
   const requestBody = {};
   requestBody.type = proxy.type;
@@ -1039,7 +1605,7 @@ function buildCreateProxyRequestBody(proxy) {
 }
 var proxyHandlers = {
   async createProxy(params) {
-    const requestBody = params.proxies.map((proxy) => buildCreateProxyRequestBody(proxy));
+    const requestBody = params.map((proxy) => buildCreateProxyRequestBody(proxy));
     const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.CREATE_PROXY}`, requestBody);
     if (response.data.code === 0) {
       return `Proxy created successfully with: ${Object.entries(response.data.data || {}).map(([key, value]) => `${key}: ${value}`).join("\n")}`;
@@ -1047,7 +1613,7 @@ var proxyHandlers = {
     throw new Error(`Failed to create proxy: ${response.data.msg}`);
   },
   async updateProxy(params) {
-    const requestBody = buildProxyRequestBody(params);
+    const requestBody = buildRequestBodyFor("update-proxy", params);
     const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.UPDATE_PROXY}`, requestBody);
     if (response.data.code === 0) {
       return `Proxy updated successfully with: ${Object.entries(response.data.data || {}).map(([key, value]) => `${key}: ${value}`).join("\n")}`;
@@ -1055,29 +1621,21 @@ var proxyHandlers = {
     throw new Error(`Failed to update proxy: ${response.data.msg}`);
   },
   async getProxyList(params) {
-    const { limit, page, proxyId } = params;
-    const requestBody = {};
-    if (limit !== void 0) {
-      requestBody.limit = limit;
-    }
-    if (page !== void 0) {
-      requestBody.page = page;
-    }
-    if (proxyId && proxyId.length > 0) {
-      requestBody.proxy_id = proxyId;
-    }
+    const requestBody = buildRequestBodyFor("get-proxy-list", params);
     const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.GET_PROXY_LIST}`, requestBody);
     if (response.data.code === 0) {
       return `Proxy list: ${JSON.stringify(response.data.data.list || response.data.data, null, 2)}`;
     }
     throw new Error(`Failed to get proxy list: ${response.data.msg}`);
   },
-  async deleteProxy({ proxyIds }) {
-    const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.DELETE_PROXY}`, {
-      proxy_id: proxyIds
-    });
+  async deleteProxy(params) {
+    const response = await getApiClient().post(
+      `${getLocalApiBase()}${API_ENDPOINTS.DELETE_PROXY}`,
+      buildRequestBodyFor("delete-proxy", params)
+    );
+    const { proxy_id } = params;
     if (response.data.code === 0) {
-      return `Proxies deleted successfully: ${proxyIds.join(", ")}`;
+      return `Proxies deleted successfully: ${proxy_id.join(", ")}`;
     }
     throw new Error(`Failed to delete proxies: ${response.data.msg}`);
   }
@@ -1131,7 +1689,7 @@ var import_path = __toESM(require("path"));
 var import_os = __toESM(require("os"));
 
 // ../core/src/utils/browserBase.ts
-var import_playwright = require("playwright");
+var import_playwright_core = require("playwright-core");
 var BrowserBase = class {
   browser;
   page;
@@ -1166,7 +1724,7 @@ var BrowserBase = class {
     }
   }
   async connectBrowserWithWs(wsUrl) {
-    this.browser = await import_playwright.chromium.connectOverCDP(wsUrl);
+    this.browser = await import_playwright_core.chromium.connectOverCDP(wsUrl);
     const defaultContext = this.browser.contexts()[0];
     this.page = defaultContext.pages()[0];
     await this.page.bringToFront().catch((error) => {
@@ -1242,9 +1800,9 @@ var userProxyConfigSchema = import_zod.z.object({
   proxy_type: import_zod.z.enum(["http", "https", "socks5", "no_proxy"]).optional(),
   proxy_host: import_zod.z.string().optional().describe("The proxy host of the browser, eg: 127.0.0.1"),
   proxy_port: import_zod.z.string().optional().describe("The proxy port of the browser, eg: 8080"),
-  proxy_user: import_zod.z.string().optional().describe("The proxy user of the browser, eg: user"),
-  proxy_password: import_zod.z.string().optional().describe("The proxy password of the browser, eg: password"),
-  proxy_url: import_zod.z.string().optional().describe("The proxy url of the browser, eg: http://127.0.0.1:8080"),
+  proxy_user: import_zod.z.string().optional().describe("The proxy user for proxy authentication, eg: user"),
+  proxy_password: import_zod.z.string().optional().describe("The proxy password for proxy authentication, eg: password"),
+  proxy_url: import_zod.z.string().optional().describe("This URL is used for dynamic proxy, only supports http/https/socks5 proxies. 1. By clicking this link, you can manually change the proxy IP address. 2. When multiple environments use the same proxy account, refreshing the IP will change the IP address of the same proxy account."),
   global_config: import_zod.z.enum(["0", "1"]).optional().describe("The global config of the browser, default is 0")
 }).describe("The user proxy config of the browser");
 var CHROME_VERSIONS = [
@@ -1285,9 +1843,10 @@ var CHROME_VERSIONS = [
   "142",
   "143",
   "144",
-  "ua_auto"
+  "ua_auto",
+  "latest"
 ];
-var FIREFOX_VERSIONS = ["100", "107", "114", "120", "123", "126", "129", "132", "135", "138", "141", "144", "ua_auto"];
+var FIREFOX_VERSIONS = ["100", "107", "114", "120", "123", "126", "129", "132", "135", "138", "141", "144", "ua_auto", "latest"];
 var ALL_KERNEL_VERSIONS = [.../* @__PURE__ */ new Set([...CHROME_VERSIONS, ...FIREFOX_VERSIONS])];
 var browserKernelConfigSchema = import_zod.z.object({
   version: import_zod.z.union(
@@ -1642,14 +2201,21 @@ var mediaDevicesNumSchema = import_zod.z.object({
   videoinput_num: import_zod.z.enum(DEVICE_COUNT_VALUES).describe("Number of cameras, 1-9"),
   audiooutput_num: import_zod.z.enum(DEVICE_COUNT_VALUES).describe("Number of speakers, 1-9")
 }).describe("Device counts when media_devices=2: audioinput_num, videoinput_num, audiooutput_num each 1-9.");
+var platformAccountSchema = import_zod.z.object({
+  domain_name: import_zod.z.string().min(1).describe("Platform domain name, eg: facebook.com"),
+  login_user: import_zod.z.string().min(1).describe("Platform login user, e.g. shop username or login email"),
+  password: import_zod.z.string().min(1).optional().describe("Optional platform account password"),
+  fakey: import_zod.z.string().min(1).optional().describe("2FA key for online 2FA code generators")
+}).strict().optional().describe("Structured platform account metadata keyed by Postman field name platform_account.");
+var nonEmptyStringArraySchema = import_zod.z.array(import_zod.z.string()).nonempty();
 var fingerprintConfigSchema = import_zod.z.object({
   automatic_timezone: import_zod.z.enum(["0", "1"]).optional().describe("Auto timezone by IP: 0 custom, 1 (default) by IP"),
   timezone: import_zod.z.string().optional().describe("Timezone when automatic_timezone=0, e.g. Asia/Shanghai"),
-  location_switch: import_zod.z.enum(["0", "1"]).optional().describe("Location by IP: 0 custom, 1 (default) by IP"),
+  location_switch: import_zod.z.enum(["0", "1"]).optional().describe("1: Generate location based on IP (default); 0: Specify location"),
   longitude: import_zod.z.number().min(-180).max(180).optional().describe("Custom longitude when location_switch=0, -180 to 180, up to 6 decimals"),
   latitude: import_zod.z.number().min(-90).max(90).optional().describe("Custom latitude when location_switch=0, -90 to 90, up to 6 decimals"),
   accuracy: import_zod.z.number().int().min(10).max(5e3).optional().describe("Location accuracy in meters when location_switch=0, 10-5000, default 1000"),
-  location: import_zod.z.enum(["ask", "allow", "block"]).optional().describe("Site location permission: ask (default), allow, block"),
+  location: import_zod.z.enum(["ask", "allow", "block"]).optional().describe("When the website requests to obtain your current location, the support: ask (default), allow, block; ask: ask (default), the same as the prompt of ordinary browsers; allow: always allow the website to get the location; block: always block the website from getting the location."),
   language_switch: import_zod.z.enum(["0", "1"]).optional().describe("Language by IP country: 0 custom, 1 (default) by IP"),
   language: import_zod.z.array(import_zod.z.string()).optional().describe('Custom languages when language_switch=0, e.g. ["en-US", "zh-CN"]'),
   page_language_switch: import_zod.z.enum(["0", "1"]).optional().describe("Match UI language to language: 0 off, 1 (default) on; Chrome 109+ Win / 119+ macOS, v2.6.72+"),
@@ -1665,7 +2231,7 @@ var fingerprintConfigSchema = import_zod.z.object({
   webgl_image: import_zod.z.enum(["0", "1"]).optional().describe("WebGL image fingerprint: 0 default, 1 (default) add noise"),
   webgl_config: webglConfigSchema.optional().describe("Custom WebGL metadata when webgl=2. Must include unmasked_vendor and unmasked_renderer (non-empty). webgpu.webgpu_switch: 0 Disabled, 1 WebGL based, 2 Real. V2.6.8.1+"),
   flash: import_zod.z.enum(["block", "allow"]).optional().describe("Flash: block (default) or allow"),
-  webrtc: import_zod.z.enum(["disabled", "forward", "proxy", "local"]).optional().describe("WebRTC: disabled (default), forward, proxy, local"),
+  webrtc: import_zod.z.enum(["disabled", "forward", "proxy", "local", "disableUDP"]).optional().describe("WebRTC: forward: forward, use proxy IP to cover real IP, used in proxy scene, more secure (need to upgrade to V2.6.8.6 or later version); proxy: replace, use proxy IP to cover real IP, used in proxy scene; local: real, the website will get the real IP; disabled: disabled (default), the website will not get the IP; disableUDP: disable UDP, disable non-proxy UDP traffic (only supported by Chrome kernel)."),
   audio: import_zod.z.enum(["0", "1"]).optional().describe("Audio fingerprint: 0 close, 1 (default) add noise"),
   do_not_track: import_zod.z.enum(["default", "true", "false"]).optional().describe("Do Not Track: default, true (open), false (close)"),
   hardware_concurrency: import_zod.z.enum(["2", "4", "6", "8", "16"]).optional().describe("CPU cores: 2, 4 (default if omitted), 6, 8, 16; omit to follow current computer"),
@@ -1680,7 +2246,7 @@ var fingerprintConfigSchema = import_zod.z.object({
   speech_switch: import_zod.z.enum(["0", "1"]).optional().describe("SpeechVoices: 0 use computer default, 1 replace with value. V3.11.10+"),
   mac_address_config: macAddressConfigSchema.optional().describe("MAC address: model 0/1/2, address when model=2. V4.3.9+"),
   gpu: import_zod.z.enum(["0", "1", "2"]).optional().describe("GPU: 0 follow Local settings - Hardware acceleration, 1 turn on, 2 turn off"),
-  browser_kernel_config: browserKernelConfigSchema.optional(),
+  browser_kernel_config: browserKernelConfigSchema.optional().default({ "version": "latest", "type": "chrome" }),
   random_ua: randomUaConfigSchema.optional().describe("Random UA config; ignored when ua (custom UA) is provided."),
   tls_switch: import_zod.z.enum(["0", "1"]).optional().describe("TLS custom list: 0 (default) off, 1 on"),
   tls: import_zod.z.string().optional().refine(
@@ -1702,127 +2268,156 @@ var fingerprintConfigSchema = import_zod.z.object({
     }
   }
 }).describe("Fingerprint config (fingerprint_config). All fields optional. See AdsPower Local API fingerprint_config.");
+var createProxyItemSchema = import_zod.z.object({
+  type: import_zod.z.enum(["http", "https", "ssh", "socks5"]).describe("Proxy type, support: http/https/ssh/socks5"),
+  host: import_zod.z.string().describe("Proxy host, support: ipV4, ipV6, eg: 192.168.0.1"),
+  port: import_zod.z.string().describe("Port, range: 0-65536, eg: 8000"),
+  user: import_zod.z.string().optional().describe("Proxy username, eg: user12345678"),
+  password: import_zod.z.string().optional().describe("Proxy password, eg: password"),
+  proxy_url: import_zod.z.string().optional().describe("URL used to refresh the proxy, eg: https://www.baidu.com/"),
+  remark: import_zod.z.string().optional().describe("Remark/description for the proxy"),
+  ipchecker: import_zod.z.enum(["ip2location", "ipapi", "ipfoxy"]).optional().describe("IP checker.")
+}).strict();
 var schemas = {
   createBrowserSchema: import_zod.z.object({
-    groupId: import_zod.z.string().regex(/^\d+$/, "Group ID must be a numeric string").describe('The group id of the browser, must be a numeric string (e.g., "123"). You can use the get-group-list tool to get the group list or create a new group, use 0 for Ungrouped'),
+    group_id: import_zod.z.string().regex(/^\d+$/, "Group ID must be a numeric string").describe('The group id of the browser, must be a numeric string (e.g., "123"). You can use the get-group-list tool to get the group list or create a new group, use 0 for Ungrouped'),
     username: import_zod.z.string().optional().describe("Platform account username"),
     password: import_zod.z.string().optional().describe("Platform account password"),
-    cookie: import_zod.z.string().optional().describe("Cookie data in JSON or Netscape format"),
+    cookie: import_zod.z.string().optional().describe(`Cookie data in JSON array string or Netscape format, eg: '[{"domain":".baidu.com","expirationDate":1724188800,"name":"BAIDUID","value":"xxxxxxxxxx"}]'`),
     fakey: import_zod.z.string().optional().describe("2FA key for online 2FA code generators"),
-    name: import_zod.z.string().max(100).optional().describe("Account name, max 100 characters"),
-    platform: import_zod.z.string().optional().describe("Platform domain, eg: facebook.com"),
-    remark: import_zod.z.string().optional().describe("Remarks to describe the account. Maximum 1500 characters."),
-    userProxyConfig: userProxyConfigSchema.default({ proxy_soft: "no_proxy" }).describe("Proxy configuration. If proxyid is provided, proxyid takes priority and this field is ignored. Defaults to no_proxy when neither proxyid nor a custom proxy is needed."),
-    proxyid: import_zod.z.string().optional().describe("Proxy profile ID. Takes priority over userProxyConfig when provided."),
-    repeatConfig: import_zod.z.array(import_zod.z.union([import_zod.z.literal(0), import_zod.z.literal(2), import_zod.z.literal(3), import_zod.z.literal(4)])).optional().describe("Account deduplication settings (0, 2, 3, or 4)"),
-    ignoreCookieError: import_zod.z.enum(["0", "1"]).optional().describe("Handle cookie verification failures: 0 (default) return data as-is, 1 filter out incorrectly formatted cookies"),
+    name: import_zod.z.string().max(100).optional().describe("Profile name, max 100 characters"),
+    platform: import_zod.z.string().optional().describe("Platform domain, eg: facebook.com, The platform account is only applicable to single account platform settings. If you need to configure multiple account platforms, please use platform_account instead."),
+    remark: import_zod.z.string().optional().describe("Remarks to describe the profile. Maximum 1500 characters."),
+    user_proxy_config: userProxyConfigSchema.default({ proxy_soft: "no_proxy" }).describe("Proxy configuration. If proxyid is provided, proxyid takes priority and this field is ignored. Defaults to no_proxy when neither proxyid nor a custom proxy is needed."),
+    proxyid: import_zod.z.string().optional().describe(" Already added proxy (proxy ID). user_proxy_config and proxyid cannot be empty at the same time. Takes priority over user_proxy_config when provided."),
+    repeat_config: import_zod.z.array(import_zod.z.union([import_zod.z.literal(0), import_zod.z.literal(2), import_zod.z.literal(3), import_zod.z.literal(4)])).optional().describe("Account deduplication settings (0, 2, 3, or 4), 0: allow duplicate (default), 2: deduplicate by account and password, 3: deduplicate by cookie, 4: deduplicate by c_user (c_user is Facebook's unique identifier)"),
+    ignore_cookie_error: import_zod.z.enum(["0", "1"]).optional().describe("Handle cookie verification failures: 0 (default) return data as-is, 1 filter out incorrectly formatted cookies"),
     tabs: import_zod.z.array(import_zod.z.string()).optional().describe('URLs to open on startup, eg: ["https://www.google.com"]'),
     ip: import_zod.z.string().optional().describe("IP address"),
     country: countryCodeSchema.optional().describe('Country/Region, ISO 3166-1 alpha-2 (lowercase). eg: "cn", "us"'),
     region: import_zod.z.string().optional().describe("Region"),
     city: import_zod.z.string().optional().describe("City"),
-    ipchecker: import_zod.z.enum(["ip2location", "ipapi"]).optional().describe("IP query channel"),
-    categoryId: import_zod.z.string().optional().describe("The category id of the browser, you can use the get-application-list tool to get the application list"),
-    profileTagIds: import_zod.z.array(import_zod.z.string()).max(30).optional().describe('Tag IDs to assign to the profile, max 30 tags per profile. Example: ["tag1","tag2"]'),
-    fingerprintConfig: fingerprintConfigSchema.optional().default({ random_ua: { ua_system_version: ["Windows"] } })
-  }),
+    ipchecker: import_zod.z.enum(["ip2location", "ipapi", "ipfoxy"]).optional().describe("IP query channel"),
+    category_id: import_zod.z.string().optional().describe("The category id of the browser, you can use the get-application-list tool to get the application list"),
+    profile_tag_ids: import_zod.z.array(import_zod.z.string()).max(30).optional().describe('Tag IDs to assign to the profile, max 30 tags per profile. Example: ["tag1","tag2"]'),
+    fingerprint_config: fingerprintConfigSchema.optional().default({ random_ua: { ua_system_version: ["Windows"] }, browser_kernel_config: { version: "latest", type: "chrome" } }),
+    platform_account: platformAccountSchema
+  }).strict(),
   updateBrowserSchema: import_zod.z.object({
     platform: import_zod.z.string().optional().describe("The platform of the browser, eg: facebook.com"),
     tabs: import_zod.z.array(import_zod.z.string()).optional().describe('The tabs of the browser, eg: ["https://www.google.com"]'),
-    cookie: import_zod.z.string().optional().describe("The cookie of the browser"),
+    cookie: import_zod.z.string().optional().describe(`Cookie data in JSON array string or Netscape format, eg: '[{"domain":".baidu.com","expirationDate":1724188800,"name":"BAIDUID","value":"xxxxxxxxxx"}]'`),
     username: import_zod.z.string().optional().describe('The username of the browser, eg: "user"'),
     password: import_zod.z.string().optional().describe('The password of the browser, eg: "password"'),
     fakey: import_zod.z.string().optional().describe("Enter the 2FA-key"),
-    ignoreCookieError: import_zod.z.enum(["0", "1"]).optional().describe("Specifies how to handle the case when cookie validation fails."),
-    groupId: import_zod.z.string().optional().describe('The group id of the browser, must be a numeric string (e.g., "123"). You can use the get-group-list tool to get the group list or create a new group'),
+    ignore_cookie_error: import_zod.z.enum(["0", "1"]).optional().describe("Specifies how to handle the case when cookie validation fails."),
+    group_id: import_zod.z.string().optional().describe('The group id of the browser, must be a numeric string (e.g., "123"). You can use the get-group-list tool to get the group list or create a new group'),
     name: import_zod.z.string().max(100).optional().describe('The Profile name of the browser, eg: "My Browser"'),
     remark: import_zod.z.string().max(1500).optional().describe("Profile remarks, maximum 1500 characters"),
     country: countryCodeSchema.optional().describe('The country of the browser, ISO 3166-1 alpha-2 (lowercase). eg: "cn", "us"'),
     region: import_zod.z.string().optional().describe("The region of the browser"),
     city: import_zod.z.string().optional().describe("The city of the browser"),
+    ipchecker: import_zod.z.enum(["ip2location", "ipapi", "ipfoxy"]).optional().describe("IP query channel"),
     ip: import_zod.z.string().optional().describe("The IP of the browser"),
-    categoryId: import_zod.z.string().optional().describe("The category id of the browser, you can use the get-application-list tool to get the application list"),
-    userProxyConfig: userProxyConfigSchema.optional(),
+    category_id: import_zod.z.string().optional().describe("The category id of the browser, you can use the get-application-list tool to get the application list"),
+    user_proxy_config: userProxyConfigSchema.optional(),
     proxyid: import_zod.z.string().optional().describe("Proxy ID"),
-    fingerprintConfig: fingerprintConfigSchema.optional(),
-    launchArgs: import_zod.z.string().optional().describe("Browser startup parameters"),
-    profileTagIds: import_zod.z.array(import_zod.z.string()).max(30).optional().describe('Tag IDs to set on the profile, max 30 tags per profile. Example: ["tag1","tag2"]'),
-    tagsUpdateType: import_zod.z.enum(["1", "2"]).optional().describe('How to apply profile_tag_ids: "1" (default) replace all existing tags; "2" append tags (truncated to 30 total if exceeded)'),
-    profileId: import_zod.z.string().describe("The profile id of the browser to update, it is required when you want to update the browser")
-  }),
-  openBrowserSchema: import_zod.z.object({
-    profileNo: import_zod.z.string().optional().describe("Priority will be given to user id when profile_id is filled."),
-    profileId: import_zod.z.string().describe("Unique profile ID, generated after creating profile. The profile id of the browser to open"),
-    ipTab: import_zod.z.enum(["0", "1"]).optional().describe("The ip tab of the browser, 0 is not use ip tab, 1 is use ip tab, default is 0"),
-    launchArgs: import_zod.z.string().optional().describe("The launch args of the browser, use chrome launch args, or vista url"),
-    clearCacheAfterClosing: import_zod.z.enum(["0", "1"]).optional().describe("The clear cache after closing of the browser, 0 is not clear cache after closing, 1 is clear cache after closing, default is 0"),
-    cdpMask: import_zod.z.enum(["0", "1"]).optional().describe("The cdp mask of the browser, 0 is not use cdp mask, 1 is use cdp mask, default is 0")
+    fingerprint_config: fingerprintConfigSchema.optional(),
+    launch_args: import_zod.z.string().optional().describe("Browser startup parameters"),
+    profile_tag_ids: import_zod.z.array(import_zod.z.string()).max(30).optional().describe('Tag IDs to set on the profile, max 30 tags per profile. Example: ["tag1","tag2"]'),
+    tags_update_type: import_zod.z.enum(["1", "2"]).optional().describe('How to apply profile_tag_ids: "1" (default) replace all existing tags; "2" append tags (truncated to 30 total if exceeded)'),
+    profile_id: import_zod.z.string().describe("The profile id of the browser to update, it is required when you want to update the browser"),
+    platform_account: platformAccountSchema
   }).strict(),
+  openBrowserSchema: import_zod.z.object({
+    profile_no: import_zod.z.string().optional().describe(
+      "Profile serial number (environment number). At least one of profile_id or profile_no is required; if both are provided, profile_id takes priority (AdsPower API). "
+    ),
+    profile_id: import_zod.z.string().optional().describe(
+      "Unique profile ID generated after creating a profile; identifies which browser to open. At least one of profile_id or profile_no is required; if both are provided, profile_id takes priority (AdsPower API). "
+    ),
+    ip_tab: import_zod.z.enum(["0", "1"]).optional().describe("The ip tab of the browser, 0 is not use ip tab, 1 is use ip tab, default is 0"),
+    launch_args: import_zod.z.union([import_zod.z.string(), import_zod.z.array(import_zod.z.string())]).optional().describe('The launch args of the browser, use chrome launch args, eg: ["--window-position=400,0","--blink-settings=imagesEnabled=false", "--disable-notifications"]'),
+    headless: import_zod.z.enum(["0", "1"]).optional().describe(
+      'Headless: "0" visible window, "1" headless. If omitted, the runtime may auto-set "1" when no graphical session is detected (Linux without DISPLAY/WAYLAND, or CI). Explicit "0"/"1" is always sent as-is.'
+    ),
+    last_opened_tabs: import_zod.z.enum(["0", "1"]).optional().describe("Whether to restore the last opened tabs."),
+    proxy_detection: import_zod.z.enum(["0", "1"]).optional().describe("Whether to enable proxy detection."),
+    password_filling: import_zod.z.enum(["0", "1"]).optional().describe("Whether to enable password auto-filling."),
+    password_saving: import_zod.z.enum(["0", "1"]).optional().describe("Whether to enable password saving."),
+    delete_cache: import_zod.z.enum(["0", "1"]).optional().describe("The clear cache after closing of the browser, 0 is not clear cache after closing, 1 is clear cache after closing, default is 0"),
+    cdp_mask: import_zod.z.enum(["0", "1"]).optional().describe("The cdp mask of the browser, 0 is not use cdp mask, 1 is use cdp mask, default is 0"),
+    device_scale: import_zod.z.string().optional().describe("Device scale factor passed to browser-profile/start.")
+  }).strict().refine((data) => data.profile_id || data.profile_no, {
+    message: "Either profile_id or profile_no must be provided"
+  }),
   closeBrowserSchema: import_zod.z.object({
-    profileId: import_zod.z.string().optional().describe("The profile id of the browser to stop, either profileId or profileNo must be provided"),
-    profileNo: import_zod.z.string().optional().describe("The profile number of the browser to stop, priority will be given to profileId when profileId is filled")
-  }).refine((data) => data.profileId || data.profileNo, {
-    message: "Either profileId or profileNo must be provided"
+    profile_id: import_zod.z.string().optional().describe("The profile id of the browser to stop, either profile_id or profile_no must be provided"),
+    profile_no: import_zod.z.string().optional().describe("The profile number of the browser to stop, priority will be given to profile_id when profile_id is filled")
+  }).strict().refine((data) => data.profile_id || data.profile_no, {
+    message: "Either profile_id or profile_no must be provided"
   }),
   deleteBrowserSchema: import_zod.z.object({
-    profileIds: import_zod.z.array(import_zod.z.string()).describe("The profile ids of the browsers to delete, it is required when you want to delete the browser")
+    profile_id: import_zod.z.array(import_zod.z.string()).describe("The profile ids of the browsers to delete, it is required when you want to delete the browser")
   }).strict(),
   getBrowserListSchema: import_zod.z.object({
-    groupId: import_zod.z.string().regex(/^\d+$/, "Group ID must be a numeric string").optional().describe("Query by group ID; searches all groups if empty"),
-    limit: import_zod.z.number().optional().describe("Profiles per page. Number of profiles returned per page, range 1 ~ 200, default is 50"),
-    page: import_zod.z.number().optional().describe("Page number for results, default is 1"),
-    profileId: import_zod.z.array(import_zod.z.string()).optional().describe('Query by profile ID. Example: ["h1yynkm","h1yynks"]'),
-    profileNo: import_zod.z.array(import_zod.z.string()).optional().describe('Query by profile number. Example: ["123","124"]'),
-    sortType: import_zod.z.enum(["profile_no", "last_open_time", "created_time"]).optional().describe("Sort results by: profile_no, last_open_time, or created_time"),
-    sortOrder: import_zod.z.enum(["asc", "desc"]).optional().describe('Sort order: "asc" (ascending) or "desc" (descending)'),
-    tag_ids: import_zod.z.array(import_zod.z.string()).optional().describe('Tag IDs to filter profiles by tags. Example: ["tag1","tag2"]'),
+    group_id: import_zod.z.string().regex(/^\d+$/, "Group ID must be a numeric string").optional().describe("Query by group ID; searches all groups if empty"),
+    limit: import_zod.z.number().min(1).max(200).optional().describe("Profiles per page. Number of profiles returned per page, range 1 ~ 200, default is 50"),
+    page: import_zod.z.number().min(1).optional().describe("Page number for results, default is 1"),
+    profile_id: nonEmptyStringArraySchema.optional().describe('Query by profile ID. Example: ["h1yynkm","h1yynks"]'),
+    profile_no: nonEmptyStringArraySchema.optional().describe('Query by profile number. Example: ["123","124"]'),
+    sort_type: import_zod.z.enum(["profile_no", "last_open_time", "created_time"]).optional().describe("Sort results by: profile_no, last_open_time, or created_time"),
+    sort_order: import_zod.z.enum(["asc", "desc"]).optional().describe('Sort order: "asc" (ascending) or "desc" (descending)'),
+    tag_ids: nonEmptyStringArraySchema.optional().describe('Tag IDs to filter profiles by tags. Example: ["tag1","tag2"]'),
     tags_filter: import_zod.z.enum(["include", "exclude"]).optional().describe('Tag matching mode: "include" (default) matches profiles with any of the tags, "exclude" matches profiles without the tags'),
     name: import_zod.z.string().optional().describe("Profile name keyword to search for"),
     name_filter: import_zod.z.enum(["include", "exclude"]).optional().describe('Name matching mode: "include" (default) matches profiles containing the name keyword, "exclude" matches profiles not containing the name keyword')
   }).strict(),
   moveBrowserSchema: import_zod.z.object({
-    groupId: import_zod.z.string().regex(/^\d+$/, "Group ID must be a numeric string").describe('The target group id, must be a numeric string (e.g., "123"). You can use the get-group-list tool to get the group list'),
-    userIds: import_zod.z.array(import_zod.z.string()).describe("The browser Profile ids to move")
+    group_id: import_zod.z.string().regex(/^\d+$/, "Group ID must be a numeric string").describe('The target group id, must be a numeric string (e.g., "123"). You can use the get-group-list tool to get the group list'),
+    user_ids: import_zod.z.array(import_zod.z.string()).describe("The browser Profile ids to move")
   }).strict(),
   getProfileCookiesSchema: import_zod.z.object({
-    profileId: import_zod.z.string().optional().describe("The profile id, either profileId or profileNo must be provided"),
-    profileNo: import_zod.z.string().optional().describe("The profile number, priority will be given to profileId when profileId is filled")
-  }).refine((data) => data.profileId || data.profileNo, {
-    message: "Either profileId or profileNo must be provided"
+    profile_id: import_zod.z.string().optional().describe("The profile id, either profile_id or profile_no must be provided"),
+    profile_no: import_zod.z.string().optional().describe("The profile number, priority will be given to profile_id when profile_id is filled")
+  }).strict().refine((data) => data.profile_id || data.profile_no, {
+    message: "Either profile_id or profile_no must be provided"
   }),
   getProfileUaSchema: import_zod.z.object({
-    profileId: import_zod.z.array(import_zod.z.string()).optional().describe("The profile id array, either profileId or profileNo must be provided"),
-    profileNo: import_zod.z.array(import_zod.z.string()).optional().describe("The profile number array, priority will be given to profileId when profileId is filled")
-  }).refine((data) => data.profileId && data.profileId.length > 0 || data.profileNo && data.profileNo.length > 0, {
-    message: "Either profileId or profileNo must be provided with at least one element"
+    profile_id: nonEmptyStringArraySchema.optional().describe("The profile id array, either profile_id or profile_no must be provided"),
+    profile_no: nonEmptyStringArraySchema.optional().describe("The profile number array, priority will be given to profile_id when profile_id is filled")
+  }).strict().refine((data) => data.profile_id && data.profile_id.length > 0 || data.profile_no && data.profile_no.length > 0, {
+    message: "Either profile_id or profile_no must be provided with at least one element"
   }),
   closeAllProfilesSchema: import_zod.z.object({}).strict(),
   newFingerprintSchema: import_zod.z.object({
-    profileId: import_zod.z.array(import_zod.z.string()).optional().describe("The profile id array, either profileId or profileNo must be provided"),
-    profileNo: import_zod.z.array(import_zod.z.string()).optional().describe("The profile number array, priority will be given to profileId when profileId is filled")
-  }).strict(),
+    profile_id: nonEmptyStringArraySchema.optional().describe("The profile id array, either profile_id or profile_no must be provided"),
+    profile_no: nonEmptyStringArraySchema.optional().describe("The profile number array, priority will be given to profile_id when profile_id is filled")
+  }).strict().refine((data) => data.profile_id && data.profile_id.length > 0 || data.profile_no && data.profile_no.length > 0, {
+    message: "Either profile_id or profile_no must be provided with at least one element"
+  }),
   deleteCacheV2Schema: import_zod.z.object({
-    profileIds: import_zod.z.array(import_zod.z.string()).describe("The profile ids array, it is required"),
+    profile_id: import_zod.z.array(import_zod.z.string()).describe("The profile ids array, it is required"),
     type: import_zod.z.array(import_zod.z.enum(["local_storage", "indexeddb", "extension_cache", "cookie", "history", "image_file"])).describe("Types of cache to clear, it is required")
   }).strict(),
   shareProfileSchema: import_zod.z.object({
-    profileIds: import_zod.z.array(import_zod.z.string()).describe("The profile ids array, it is required"),
+    profile_id: import_zod.z.array(import_zod.z.string()).describe("The profile ids array, it is required"),
     receiver: import_zod.z.string().describe("Receiver's account email or phone number (no area code), it is required"),
-    shareType: import_zod.z.number().int().optional().describe("Share type: 1 for email (default), 2 for phone number"),
+    share_type: import_zod.z.number().int().optional().describe("Share type: 1 for email (default), 2 for phone number"),
     content: import_zod.z.array(import_zod.z.enum(["name", "proxy", "remark", "tabs"])).optional().describe("Shared content")
   }).strict(),
   createGroupSchema: import_zod.z.object({
-    groupName: import_zod.z.string().describe("The name of the group to create"),
+    group_name: import_zod.z.string().describe("The name of the group to create"),
     remark: import_zod.z.string().optional().describe("The remark of the group")
   }).strict(),
   updateGroupSchema: import_zod.z.object({
-    groupId: import_zod.z.string().regex(/^\d+$/, "Group ID must be a numeric string").describe('The id of the group to update, must be a numeric string (e.g., "123"). You can use the get-group-list tool to get the group list'),
-    groupName: import_zod.z.string().describe("The new name of the group"),
+    group_id: import_zod.z.string().regex(/^\d+$/, "Group ID must be a numeric string").describe('The id of the group to update, must be a numeric string (e.g., "123"). You can use the get-group-list tool to get the group list'),
+    group_name: import_zod.z.string().describe("The new name of the group"),
     remark: import_zod.z.string().nullable().optional().describe("The new remark of the group")
   }).strict(),
   getGroupListSchema: import_zod.z.object({
-    groupName: import_zod.z.string().optional().describe("The name of the group to search, use like to search"),
-    size: import_zod.z.number().optional().describe("The size of the page, max is 100, default is 10"),
+    group_name: import_zod.z.string().optional().describe("The name of the group to search, use like to search"),
+    page_size: import_zod.z.number().optional().describe("The size of the page, max is 100, default is 10"),
     page: import_zod.z.number().optional().describe("The page of the group, default is 1")
   }).strict(),
   getApplicationListSchema: import_zod.z.object({
@@ -1831,46 +2426,38 @@ var schemas = {
     limit: import_zod.z.number().min(1).max(100).optional().describe("Default 1, how many values are returned per page, range 1 to 100")
   }).strict(),
   getBrowserActiveSchema: import_zod.z.object({
-    profileId: import_zod.z.string().optional().describe("The profile id, either profileId or profileNo must be provided"),
-    profileNo: import_zod.z.string().optional().describe("The profile number, priority will be given to profileId when profileId is filled")
-  }).refine((data) => data.profileId || data.profileNo, {
-    message: "Either profileId or profileNo must be provided"
+    profile_id: import_zod.z.string().optional().describe("The profile id, either profile_id or profile_no must be provided"),
+    profile_no: import_zod.z.string().optional().describe("The profile number, priority will be given to profile_id when profile_id is filled")
+  }).strict().refine((data) => data.profile_id || data.profile_no, {
+    message: "Either profile_id or profile_no must be provided"
   }),
   getCloudActiveSchema: import_zod.z.object({
-    userIds: import_zod.z.string().describe("Profile IDs string to check (split by comma, max 100 per request). Unique profile ID, generated after creating the profile.")
-  }).refine((data) => data.userIds.split(",").length <= 100, {
+    user_ids: import_zod.z.string().describe("Profile IDs string to check (split by comma, max 100 per request). Unique profile ID, generated after creating the profile.")
+  }).refine((data) => data.user_ids.split(",").length <= 100, {
     message: "The number of profile ids is too many, the maximum is 100"
   }),
-  createProxySchema: import_zod.z.object({
-    proxies: import_zod.z.array(import_zod.z.object({
-      type: import_zod.z.enum(["http", "https", "ssh", "socks5"]).describe("Proxy type, support: http/https/ssh/socks5"),
-      host: import_zod.z.string().describe("Proxy host, support: ipV4, ipV6, eg: 192.168.0.1"),
-      port: import_zod.z.string().describe("Port, range: 0-65536, eg: 8000"),
-      user: import_zod.z.string().optional().describe("Proxy username, eg: user12345678"),
-      password: import_zod.z.string().optional().describe("Proxy password, eg: password"),
-      proxy_url: import_zod.z.string().optional().describe("URL used to refresh the proxy, eg: https://www.baidu.com/"),
-      remark: import_zod.z.string().optional().describe("Remark/description for the proxy"),
-      ipchecker: import_zod.z.enum(["ipinfo", "ip2location", "ipapi", "ipfoxy"]).optional().describe("IP checker.")
-    }).strict()).describe("Array of proxy configurations to create")
+  createProxySchema: import_zod.z.array(createProxyItemSchema).describe("Top-level array of proxy configurations to create"),
+  createProxyMcpSchema: import_zod.z.object({
+    proxies: import_zod.z.array(createProxyItemSchema).describe("Compatibility wrapper for MCP create-proxy input. Core and CLI accept a top-level array.")
   }).strict(),
   updateProxySchema: import_zod.z.object({
-    proxyId: import_zod.z.string().describe("The unique id after the proxy is added"),
+    proxy_id: import_zod.z.string().describe("The unique id after the proxy is added"),
     type: import_zod.z.enum(["http", "https", "ssh", "socks5"]).optional().describe("Proxy type, support: http/https/ssh/socks5"),
     host: import_zod.z.string().optional().describe("Proxy host, support: ipV4, ipV6, eg: 192.168.0.1"),
     port: import_zod.z.string().optional().describe("Port, range: 0-65536, eg: 8000"),
     user: import_zod.z.string().optional().describe("Proxy username, eg: user12345678"),
     password: import_zod.z.string().optional().describe("Proxy password, eg: password"),
-    proxyUrl: import_zod.z.string().optional().describe("URL used to refresh the proxy, eg: https://www.baidu.com/"),
+    proxy_url: import_zod.z.string().optional().describe("URL used to refresh the proxy, eg: https://www.baidu.com/"),
     remark: import_zod.z.string().optional().describe("Remark/description for the proxy"),
     ipchecker: import_zod.z.enum(["ip2location", "ipapi", "ipfoxy"]).optional().describe("IP checker.")
   }).strict(),
   getProxyListSchema: import_zod.z.object({
     limit: import_zod.z.number().optional().describe("Profiles per page. Number of proxies returned per page, range 1 ~ 200, default is 50"),
     page: import_zod.z.number().optional().describe("Page number for results, default is 1"),
-    proxyId: import_zod.z.array(import_zod.z.string()).optional().describe('Query by proxy ID. Example: ["proxy1","proxy2"]')
+    proxy_id: nonEmptyStringArraySchema.optional().describe('Query by proxy ID. Single request can pass up to 100 proxy IDs. Example: ["proxy1","proxy2"]')
   }).strict(),
   deleteProxySchema: import_zod.z.object({
-    proxyIds: import_zod.z.array(import_zod.z.string()).describe("The proxy ids of the proxies to delete, it is required when you want to delete the proxy. The maximum is 100. ")
+    proxy_id: import_zod.z.array(import_zod.z.string()).describe("The proxy ids of the proxies to delete, it is required when you want to delete the proxy. The maximum is 100. ")
   }).strict(),
   getTagListSchema: import_zod.z.object({
     ids: import_zod.z.array(import_zod.z.string()).optional().describe('Tag IDs to query, max 100 per request. Example: ["tag1","tag2"]'),
@@ -1954,155 +2541,241 @@ var schemas = {
 var STATELESS_HANDLERS = {
   "open-browser": {
     fn: browserHandlers.openBrowser,
-    description: "Open the browser, both environment and profile mean browser"
+    description: buildCliCommandDescription(
+      "open-browser",
+      "Open the browser, both environment and profile mean browser"
+    )
   },
   "close-browser": {
     fn: browserHandlers.closeBrowser,
-    description: "Close the browser"
+    description: buildCliCommandDescription("close-browser", "Close the browser")
   },
   "create-browser": {
     fn: browserHandlers.createBrowser,
-    description: "Create a browser"
+    description: buildCliCommandDescription("create-browser", "Create a browser")
   },
   "update-browser": {
     fn: browserHandlers.updateBrowser,
-    description: "Update the browser"
+    description: buildCliCommandDescription("update-browser", "Update the browser")
   },
   "delete-browser": {
     fn: browserHandlers.deleteBrowser,
-    description: "Delete the browser"
+    description: buildCliCommandDescription("delete-browser", "Delete the browser")
   },
   "get-browser-list": {
     fn: browserHandlers.getBrowserList,
-    description: "Get the list of browsers"
+    description: buildCliCommandDescription("get-browser-list", "Get the list of browsers")
   },
   "get-opened-browser": {
     fn: browserHandlers.getOpenedBrowser,
-    description: "Get the list of opened browsers"
+    description: buildCliCommandDescription("get-opened-browser", "Get the list of opened browsers")
   },
   "move-browser": {
     fn: browserHandlers.moveBrowser,
-    description: "Move browsers to a group"
+    description: buildCliCommandDescription("move-browser", "Move browsers to a group")
   },
   "get-profile-cookies": {
     fn: browserHandlers.getProfileCookies,
-    description: "Query and return cookies of the specified profile. Only one profile can be queried per request."
+    description: buildCliCommandDescription(
+      "get-profile-cookies",
+      "Query and return cookies of the specified profile. Only one profile can be queried per request."
+    )
   },
   "get-profile-ua": {
     fn: browserHandlers.getProfileUa,
-    description: "Query and return the User-Agent of specified profiles. Up to 10 profiles can be queried per request."
+    description: buildCliCommandDescription(
+      "get-profile-ua",
+      "Query and return the User-Agent of specified profiles. Up to 10 profiles can be queried per request."
+    )
   },
   "close-all-profiles": {
     fn: browserHandlers.closeAllProfiles,
-    description: "Close all opened profiles on the current device"
+    description: buildCliCommandDescription(
+      "close-all-profiles",
+      "Close all opened profiles on the current device"
+    )
   },
   "new-fingerprint": {
     fn: browserHandlers.newFingerprint,
-    description: "Generate a new fingerprint for specified profiles. Up to 10 profiles are supported per request."
+    description: buildCliCommandDescription(
+      "new-fingerprint",
+      "Generate a new fingerprint for specified profiles. Up to 10 profiles are supported per request."
+    )
   },
   "delete-cache-v2": {
     fn: browserHandlers.deleteCacheV2,
-    description: "Clear local cache of specific profiles.For account security, please ensure that there are no open browsers on the device when using this interface."
+    description: buildCliCommandDescription(
+      "delete-cache-v2",
+      "Clear local cache of specific profiles.For account security, please ensure that there are no open browsers on the device when using this interface."
+    )
   },
   "share-profile": {
     fn: browserHandlers.shareProfile,
-    description: "Share profiles via account email or phone number. The maximum number of profiles that can be shared at one time is 200."
+    description: buildCliCommandDescription(
+      "share-profile",
+      "Share profiles via account email or phone number. The maximum number of profiles that can be shared at one time is 200."
+    )
   },
   "get-browser-active": {
     fn: browserHandlers.getBrowserActive,
-    description: "Get active browser profile information"
+    description: buildCliCommandDescription("get-browser-active", "Get active browser profile information")
   },
   "get-cloud-active": {
     fn: browserHandlers.getCloudActive,
-    description: 'Query the status of browser profiles by user_id, up to 100 profiles per request. If the team has enabled "Multi device mode," specific statuses cannot be retrieved and the response will indicate "Profile not opened."'
+    description: buildCliCommandDescription(
+      "get-cloud-active",
+      'Query the status of browser profiles by user_ids, up to 100 profiles per request. If the team has enabled "Multi device mode," specific statuses cannot be retrieved and the response will indicate "Profile not opened."'
+    )
   },
   "create-group": {
     fn: groupHandlers.createGroup,
-    description: "Create a browser group"
+    description: buildCliCommandDescription("create-group", "Create a browser group")
   },
   "update-group": {
     fn: groupHandlers.updateGroup,
-    description: "Update the browser group"
+    description: buildCliCommandDescription("update-group", "Update the browser group")
   },
   "get-group-list": {
     fn: groupHandlers.getGroupList,
-    description: "Get the list of groups"
+    description: buildCliCommandDescription("get-group-list", "Get the list of groups")
   },
   "check-status": {
     fn: applicationHandlers.checkStatus,
-    description: "Check the availability of the current device API interface (Connection Status)"
+    description: buildCliCommandDescription(
+      "check-status",
+      "Check the availability of the current device API interface (Connection Status)"
+    )
   },
   "get-application-list": {
     fn: applicationHandlers.getApplicationList,
-    description: "Get the list of applications (categories)"
+    description: buildCliCommandDescription(
+      "get-application-list",
+      "Get the list of applications (categories)"
+    )
   },
   "create-proxy": {
     fn: proxyHandlers.createProxy,
-    description: "Create the proxy"
+    description: buildCliCommandDescription("create-proxy", "Create the proxy")
   },
   "update-proxy": {
     fn: proxyHandlers.updateProxy,
-    description: "Update the proxy"
+    description: buildCliCommandDescription("update-proxy", "Update the proxy")
   },
   "get-proxy-list": {
     fn: proxyHandlers.getProxyList,
-    description: "Get the list of proxies"
+    description: buildCliCommandDescription("get-proxy-list", "Get the list of proxies")
   },
   "delete-proxy": {
     fn: proxyHandlers.deleteProxy,
-    description: "Delete the proxy"
+    description: buildCliCommandDescription("delete-proxy", "Delete the proxy")
   },
   "get-tag-list": {
     fn: tagHandlers.getTagList,
-    description: "Get the list of browser tags"
+    description: buildCliCommandDescription("get-tag-list", "Get the list of browser tags")
   },
   "create-tag": {
     fn: tagHandlers.createTag,
-    description: "Create browser tags (batch supported)"
+    description: buildCliCommandDescription("create-tag", "Create browser tags (batch supported)")
   },
   "update-tag": {
     fn: tagHandlers.updateTag,
-    description: "Update browser tags (batch supported)"
+    description: buildCliCommandDescription("update-tag", "Update browser tags (batch supported)")
   },
   "delete-tag": {
     fn: tagHandlers.deleteTag,
-    description: "Delete browser tags"
+    description: buildCliCommandDescription("delete-tag", "Delete browser tags")
   },
   "download-kernel": {
     fn: kernelHandlers.downloadKernel,
-    description: "Download or update a browser kernel version"
+    description: buildCliCommandDescription(
+      "download-kernel",
+      "Download or update a browser kernel version"
+    )
   },
   "get-kernel-list": {
     fn: kernelHandlers.getKernelList,
-    description: "Get browser kernel list by type or all"
+    description: buildCliCommandDescription("get-kernel-list", "Get browser kernel list by type or all")
   },
   "update-patch": {
     fn: patchHandlers.updatePatch,
-    description: "Update AdsPower to latest patch version"
+    description: buildCliCommandDescription("update-patch", "Update AdsPower to latest patch version")
   }
 };
 var SINGLE_PROFILE_ID_COMMANDS = {
-  "open-browser": "profileId",
-  "close-browser": "profileId",
-  "get-profile-cookies": "profileId",
-  "get-browser-active": "profileId"
+  "open-browser": "profile_id",
+  "close-browser": "profile_id",
+  "get-profile-cookies": "profile_id",
+  "get-browser-active": "profile_id"
 };
 var SINGLE_PROFILE_ID_ARRAY_COMMANDS = ["get-profile-ua", "new-fingerprint"];
+function resolveStatelessCommandArgs(commandName, params) {
+  let args = {};
+  if (!params) {
+    return { ok: true, args };
+  }
+  const trimmed = params.trim();
+  if (trimmed.startsWith("{")) {
+    try {
+      args = JSON.parse(params);
+      return { ok: true, args };
+    } catch {
+      return { ok: false, error: "Invalid JSON for command args" };
+    }
+  }
+  if (SINGLE_PROFILE_ID_COMMANDS[commandName]) {
+    if (!isNaN(Number(trimmed))) {
+      return { ok: true, args: { profile_no: trimmed } };
+    }
+    return { ok: true, args: { profile_id: trimmed } };
+  }
+  if (SINGLE_PROFILE_ID_ARRAY_COMMANDS.includes(commandName)) {
+    if (!isNaN(Number(trimmed))) {
+      return { ok: true, args: { profile_no: [trimmed] } };
+    }
+    return { ok: true, args: { profile_id: [trimmed] } };
+  }
+  try {
+    args = JSON.parse(params);
+    return { ok: true, args };
+  } catch {
+    return {
+      ok: false,
+      error: `Command requires JSON args (e.g. '{"key":"value"}') or use a supported shorthand`
+    };
+  }
+}
+
+// src/startConfig.ts
+var MISSING_API_KEY_ERROR = "error: required option '-k, --api-key <apiKey>' not specified";
+function resolveStartApiKey(optionApiKey, env = process.env) {
+  if (optionApiKey) {
+    return {
+      ok: true,
+      apiKey: optionApiKey
+    };
+  }
+  if (env.ADS_API_KEY) {
+    return {
+      ok: true,
+      apiKey: env.ADS_API_KEY
+    };
+  }
+  return {
+    ok: false,
+    error: MISSING_API_KEY_ERROR
+  };
+}
 
 // src/index.ts
 var program = new import_commander.Command();
 program.name("adspower-browser").description("CLI and runtime for adspower-browser").version(VERSION);
 program.command("start").description("Start the adspower runtime").option("-k, --api-key <apiKey>", "Set the API key for the adspower runtime").addOption(new import_commander.Option("--base-url <baseUrl>", "Set the base URL for the adspower runtime").hideHelp()).addOption(new import_commander.Option("--node-env <nodeEnv>", "Set the node environment for the adspower runtime").hideHelp()).action(async (options) => {
-  if (options.apiKey) {
-    store.setStoreValue("apiKey", options.apiKey);
-  } else {
-    const apiKey = process.env.ADS_API_KEY;
-    if (!apiKey) {
-      logError("error: required option '-k, --api-key <apiKey>' not specified");
-      process.exit(1);
-    }
-    store.setStoreValue("apiKey", "");
+  const resolvedApiKey = resolveStartApiKey(options.apiKey, process.env);
+  if (!resolvedApiKey.ok) {
+    logError(resolvedApiKey.error);
+    process.exit(1);
   }
+  store.setStoreValue("apiKey", resolvedApiKey.apiKey);
   if (options.baseUrl) {
     store.setStoreValue("baseUrl", options.baseUrl);
   }
@@ -2132,34 +2805,12 @@ for (const cmd of Object.keys(STATELESS_HANDLERS)) {
     }
     const { apiKey, port } = getApiKeyAndPort(options);
     updateConfig(apiKey, port);
-    let args = {};
-    if (params) {
-      const trimmed = params.trim();
-      if (trimmed.startsWith("{")) {
-        try {
-          args = JSON.parse(params);
-        } catch {
-          logError("Invalid JSON for command args");
-          return;
-        }
-      } else if (SINGLE_PROFILE_ID_COMMANDS[command.name()]) {
-        const key = SINGLE_PROFILE_ID_COMMANDS[command.name()];
-        if (!isNaN(Number(trimmed))) {
-          args = { profileNo: Number(trimmed) };
-        } else {
-          args = { profileId: trimmed };
-        }
-      } else if (SINGLE_PROFILE_ID_ARRAY_COMMANDS.includes(command.name())) {
-        args = { profileId: [trimmed] };
-      } else {
-        try {
-          args = JSON.parse(params);
-        } catch {
-          logError(`Command requires JSON args (e.g. '{"key":"value"}') or use a supported shorthand`);
-          return;
-        }
-      }
+    const resolved = resolveStatelessCommandArgs(command.name(), params);
+    if (!resolved.ok) {
+      logError(resolved.error);
+      return;
     }
+    const args = resolved.args;
     logSuccess(`Executing command: ${command.name()}, params: ${JSON.stringify(args)}`);
     const loading = createLoading(`Executing ${command.name()}...`);
     try {