adspower-browser 1.0.0

package/build/cli.js

@@ -0,0 +1,1024 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../core/src/constants/api.ts
+var import_axios = __toESM(require("axios"));
+
+// ../core/src/constants/config.ts
+function parseArgs() {
+  const args = process.argv;
+  let port;
+  let apiKey;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--port" && i + 1 < args.length) {
+      port = args[i + 1];
+    }
+    if (args[i] === "--api-key" && i + 1 < args.length) {
+      apiKey = args[i + 1];
+    }
+  }
+  return {
+    port: port || process.env.PORT || "50325",
+    apiKey: apiKey || process.env.API_KEY
+  };
+}
+var config = parseArgs();
+var PORT = config.port;
+var API_KEY = config.apiKey;
+
+// ../core/src/constants/api.ts
+var LOCAL_API_BASE = `http://127.0.0.1:${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"
+};
+var apiClient = import_axios.default.create({
+  headers: API_KEY ? { "Authorization": `Bearer ${API_KEY}` } : {}
+});
+
+// ../core/src/utils/requestBuilder.ts
+function buildRequestBody(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"
+  };
+  Object.entries(basicFields).forEach(([paramKey, key]) => {
+    const value = params[paramKey];
+    if (value !== void 0) {
+      requestBody[key] = value;
+    }
+  });
+  if (params.userProxyConfig) {
+    const proxyConfig = buildNestedConfig(params.userProxyConfig);
+    if (Object.keys(proxyConfig).length > 0) {
+      requestBody.user_proxy_config = proxyConfig;
+    }
+  }
+  if (params.fingerprintConfig) {
+    const fpConfig = buildNestedConfig(params.fingerprintConfig);
+    if (Object.keys(fpConfig).length > 0) {
+      requestBody.fingerprint_config = fpConfig;
+    }
+  }
+  return requestBody;
+}
+function buildNestedConfig(config2) {
+  const result = {};
+  Object.entries(config2).forEach(([key, value]) => {
+    if (value !== void 0) {
+      if (typeof value === "object" && value !== null) {
+        const nestedConfig = buildNestedConfig(value);
+        if (Object.keys(nestedConfig).length > 0) {
+          result[key] = nestedConfig;
+        }
+      } else {
+        result[key] = value;
+      }
+    }
+  });
+  return result;
+}
+
+// ../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;
+    }
+    const response = await apiClient.post(`${LOCAL_API_BASE}${API_ENDPOINTS.START_BROWSER}`, requestBody);
+    if (response.data.code === 0) {
+      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")}`;
+    }
+    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;
+    }
+    const response = await apiClient.post(`${LOCAL_API_BASE}${API_ENDPOINTS.CLOSE_BROWSER}`, requestBody);
+    if (response.data.code === 0) {
+      return "Browser closed successfully";
+    }
+    throw new Error(`Failed to close browser: ${response.data.msg}`);
+  },
+  async createBrowser(params) {
+    const requestBody = buildRequestBody(params);
+    const response = await apiClient.post(`${LOCAL_API_BASE}${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")}`;
+    }
+    throw new Error(`Failed to create browser: ${response.data.msg}`);
+  },
+  async updateBrowser(params) {
+    const requestBody = buildRequestBody(params);
+    const response = await apiClient.post(`${LOCAL_API_BASE}${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 apiClient.post(`${LOCAL_API_BASE}${API_ENDPOINTS.DELETE_BROWSER}`, {
+      profile_id: profileIds
+    });
+    if (response.data.code === 0) {
+      return `Browsers deleted successfully: ${profileIds.join(", ")}`;
+    }
+    throw new Error(`Failed to delete browsers: ${response.data.msg}`);
+  },
+  async getBrowserList(params) {
+    const { groupId, limit, page, profileId, profileNo, sortType, sortOrder } = 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;
+    }
+    const response = await apiClient.post(`${LOCAL_API_BASE}${API_ENDPOINTS.GET_BROWSER_LIST}`, requestBody);
+    if (response.data.code === 0) {
+      return `Browser list: ${JSON.stringify(response.data.data.list, null, 2)}`;
+    }
+    throw new Error(`Failed to get browser list: ${response.data.msg}`);
+  },
+  async getOpenedBrowser() {
+    const response = await apiClient.get(`${LOCAL_API_BASE}${API_ENDPOINTS.GET_OPENED_BROWSER}`);
+    if (response.data.code === 0) {
+      return `Opened browser list: ${JSON.stringify(response.data.data.list, null, 2)}`;
+    }
+    throw new Error(`Failed to get opened browsers: ${response.data.msg}`);
+  },
+  async moveBrowser({ groupId, userIds }) {
+    const response = await apiClient.post(`${LOCAL_API_BASE}${API_ENDPOINTS.MOVE_BROWSER}`, {
+      group_id: groupId,
+      user_ids: userIds
+    });
+    if (response.data.code === 0) {
+      return `Browsers moved successfully to group ${groupId}: ${userIds.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 apiClient.get(`${LOCAL_API_BASE}${API_ENDPOINTS.GET_PROFILE_COOKIES}`, { params });
+    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;
+    }
+    const response = await apiClient.post(`${LOCAL_API_BASE}${API_ENDPOINTS.GET_PROFILE_UA}`, requestBody);
+    if (response.data.code === 0) {
+      return `Profile User-Agent: ${JSON.stringify(response.data.data, null, 2)}`;
+    }
+    throw new Error(`Failed to get profile User-Agent: ${response.data.msg}`);
+  },
+  async closeAllProfiles(_params) {
+    const response = await apiClient.post(`${LOCAL_API_BASE}${API_ENDPOINTS.CLOSE_ALL_PROFILES}`, {});
+    if (response.data.code === 0) {
+      return "All profiles closed successfully";
+    }
+    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;
+    }
+    const response = await apiClient.post(`${LOCAL_API_BASE}${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 apiClient.post(`${LOCAL_API_BASE}${API_ENDPOINTS.DELETE_CACHE_V2}`, {
+      profile_id: profileIds,
+      type
+    });
+    if (response.data.code === 0) {
+      return `Cache deleted successfully for profiles: ${profileIds.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;
+    }
+    const response = await apiClient.post(`${LOCAL_API_BASE}${API_ENDPOINTS.SHARE_PROFILE}`, requestBody);
+    if (response.data.code === 0) {
+      return `Profiles shared successfully: ${profileIds.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 apiClient.get(`${LOCAL_API_BASE}${API_ENDPOINTS.GET_BROWSER_ACTIVE}`, { params });
+    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 apiClient.post(`${LOCAL_API_BASE}${API_ENDPOINTS.GET_CLOUD_ACTIVE}`, {
+      user_ids: userIds
+    });
+    if (response.data.code === 0) {
+      return `Cloud active browsers: ${JSON.stringify(response.data.data, null, 2)}`;
+    }
+    throw new Error(`Failed to get cloud active browsers: ${response.data.msg}`);
+  }
+};
+
+// ../core/src/handlers/group.ts
+var groupHandlers = {
+  async createGroup({ groupName, remark }) {
+    const requestBody = {
+      group_name: groupName
+    };
+    if (remark !== void 0) {
+      requestBody.remark = remark;
+    }
+    const response = await apiClient.post(`${LOCAL_API_BASE}${API_ENDPOINTS.CREATE_GROUP}`, requestBody);
+    if (response.data.code === 0) {
+      return `Group created successfully with name: ${groupName}${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;
+    }
+    const response = await apiClient.post(`${LOCAL_API_BASE}${API_ENDPOINTS.UPDATE_GROUP}`, requestBody);
+    if (response.data.code === 0) {
+      return `Group updated successfully with id: ${groupId}, name: ${groupName}${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());
+    }
+    const response = await apiClient.get(`${LOCAL_API_BASE}${API_ENDPOINTS.GET_GROUP_LIST}`, { params });
+    return `Group list: ${JSON.stringify(response.data.data.list, null, 2)}`;
+  }
+};
+
+// ../core/src/handlers/application.ts
+var applicationHandlers = {
+  async checkStatus() {
+    const response = await apiClient.get(`${LOCAL_API_BASE}${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 apiClient.get(`${LOCAL_API_BASE}${API_ENDPOINTS.GET_APPLICATION_LIST}`, { params });
+    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;
+  requestBody.host = proxy.host;
+  requestBody.port = proxy.port;
+  if (proxy.user !== void 0) {
+    requestBody.user = proxy.user;
+  }
+  if (proxy.password !== void 0) {
+    requestBody.password = proxy.password;
+  }
+  if (proxy.proxy_url !== void 0) {
+    requestBody.proxy_url = proxy.proxy_url;
+  }
+  if (proxy.remark !== void 0) {
+    requestBody.remark = proxy.remark;
+  }
+  if (proxy.ipchecker !== void 0) {
+    requestBody.ipchecker = proxy.ipchecker;
+  }
+  return requestBody;
+}
+var proxyHandlers = {
+  async createProxy(params) {
+    const requestBody = params.proxies.map((proxy) => buildCreateProxyRequestBody(proxy));
+    const response = await apiClient.post(`${LOCAL_API_BASE}${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")}`;
+    }
+    throw new Error(`Failed to create proxy: ${response.data.msg}`);
+  },
+  async updateProxy(params) {
+    const requestBody = buildProxyRequestBody(params);
+    const response = await apiClient.post(`${LOCAL_API_BASE}${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")}`;
+    }
+    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 response = await apiClient.post(`${LOCAL_API_BASE}${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 apiClient.post(`${LOCAL_API_BASE}${API_ENDPOINTS.DELETE_PROXY}`, {
+      proxy_id: proxyIds
+    });
+    if (response.data.code === 0) {
+      return `Proxies deleted successfully: ${proxyIds.join(", ")}`;
+    }
+    throw new Error(`Failed to delete proxies: ${response.data.msg}`);
+  }
+};
+
+// ../core/src/handlers/automation.ts
+var import_path = __toESM(require("path"));
+var import_os = __toESM(require("os"));
+
+// ../core/src/utils/browserBase.ts
+var import_playwright = require("playwright");
+var BrowserBase = class {
+  browser;
+  page;
+  screenshots;
+  constructor() {
+    this.browser = null;
+    this.page = null;
+    this.screenshots = /* @__PURE__ */ new Map();
+  }
+  get browserInstance() {
+    return this.browser;
+  }
+  get pageInstance() {
+    return this.page;
+  }
+  set pageInstance(page) {
+    this.page = page;
+  }
+  get screenshotsInstance() {
+    return this.screenshots;
+  }
+  checkConnected() {
+    const error = new Error("Browser not connected, please connect browser first");
+    if (!this.browser) {
+      throw error;
+    }
+    if (!this.browser.isConnected()) {
+      throw error;
+    }
+    if (!this.page) {
+      throw error;
+    }
+  }
+  async connectBrowserWithWs(wsUrl) {
+    this.browser = await import_playwright.chromium.connectOverCDP(wsUrl);
+    const defaultContext = this.browser.contexts()[0];
+    this.page = defaultContext.pages()[0];
+    await this.page.bringToFront().catch((error) => {
+      console.error("Failed to bring page to front", error);
+    });
+  }
+  async resetBrowser() {
+    this.browser = null;
+    this.page = null;
+  }
+};
+var browserBase_default = new BrowserBase();
+
+// ../core/src/handlers/automation.ts
+var defaultDownloadsPath = import_path.default.join(import_os.default.homedir(), "Downloads");
+
+// ../core/src/types/schemas.ts
+var import_zod = require("zod");
+var userProxyConfigSchema = import_zod.z.object({
+  proxy_soft: import_zod.z.enum([
+    "brightdata",
+    "brightauto",
+    "oxylabsauto",
+    "922S5auto",
+    "ipideeauto",
+    "ipfoxyauto",
+    "922S5auth",
+    "kookauto",
+    "ssh",
+    "other",
+    "no_proxy"
+  ]).describe("The proxy soft of the browser"),
+  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"),
+  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 = [
+  "92",
+  "99",
+  "102",
+  "105",
+  "108",
+  "111",
+  "114",
+  "115",
+  "116",
+  "117",
+  "118",
+  "119",
+  "120",
+  "121",
+  "122",
+  "123",
+  "124",
+  "125",
+  "126",
+  "127",
+  "128",
+  "129",
+  "130",
+  "131",
+  "132",
+  "133",
+  "134",
+  "135",
+  "136",
+  "137",
+  "138",
+  "139",
+  "140",
+  "141",
+  "142",
+  "143",
+  "144",
+  "ua_auto"
+];
+var FIREFOX_VERSIONS = ["100", "107", "114", "120", "123", "126", "129", "132", "135", "138", "141", "144", "ua_auto"];
+var ALL_KERNEL_VERSIONS = [.../* @__PURE__ */ new Set([...CHROME_VERSIONS, ...FIREFOX_VERSIONS])];
+var browserKernelConfigSchema = import_zod.z.object({
+  version: import_zod.z.union(
+    ALL_KERNEL_VERSIONS.map((v) => import_zod.z.literal(v))
+  ).optional().describe("The version of the browser, must match type: chrome 92\u2013143 or ua_auto, firefox 100,107,114,120,123,126,129,132,135,138,141,144 or ua_auto; default is ua_auto"),
+  type: import_zod.z.enum(["chrome", "firefox"]).optional().describe("The type of the browser, default is chrome")
+}).optional().superRefine((data, ctx) => {
+  if (!data) return;
+  const type = data.type ?? "chrome";
+  const version = data.version;
+  if (version === void 0) return;
+  const validForChrome = CHROME_VERSIONS.includes(version);
+  const validForFirefox = FIREFOX_VERSIONS.includes(version);
+  if (type === "chrome" && !validForChrome) {
+    ctx.addIssue({ code: import_zod.z.ZodIssueCode.custom, message: `Chrome does not support version "${version}". Supported: ${CHROME_VERSIONS.join(", ")}` });
+  }
+  if (type === "firefox" && !validForFirefox) {
+    ctx.addIssue({ code: import_zod.z.ZodIssueCode.custom, message: `Firefox does not support version "${version}". Supported: ${FIREFOX_VERSIONS.join(", ")}` });
+  }
+}).describe("The browser kernel config of the browser, default is version: ua_auto, type: chrome");
+var randomUaConfigSchema = import_zod.z.object({
+  ua_version: import_zod.z.array(import_zod.z.string()).optional(),
+  ua_system_version: import_zod.z.array(
+    import_zod.z.enum([
+      "Android 9",
+      "Android 10",
+      "Android 11",
+      "Android 12",
+      "Android 13",
+      "Android 14",
+      "Android 15",
+      "iOS 14",
+      "iOS 15",
+      "iOS 16",
+      "iOS 17",
+      "iOS 18",
+      "Windows 7",
+      "Windows 8",
+      "Windows 10",
+      "Windows 11",
+      "Mac OS X 10",
+      "Mac OS X 11",
+      "Mac OS X 12",
+      "Mac OS X 13",
+      "Mac OS X 14",
+      "Mac OS X 15",
+      "Mac OS X",
+      "Windows",
+      "iOS",
+      "Android",
+      "Linux"
+    ])
+  ).optional().describe(
+    'UA system version. Mac OS X / Windows / iOS / Android / Linux = random any version of that system; omit to random across all systems. e.g. ["Android 9", "iOS 14"] or ["Android", "Mac OS X"]'
+  )
+}).optional().describe("The random ua config of the browser, default is ua_version: [], ua_system_version: []");
+var fingerprintConfigSchema = import_zod.z.object({
+  automatic_timezone: import_zod.z.enum(["0", "1"]).optional().describe("The automatic timezone of the browser, default is 0"),
+  timezone: import_zod.z.string().optional().describe("The timezone of the browser, eg: Asia/Shanghai"),
+  language: import_zod.z.array(import_zod.z.string()).optional().describe('The language of the browser, eg: ["en-US", "zh-CN"]'),
+  flash: import_zod.z.enum(["block", "allow"]).optional().describe("The flash of the browser, default is disabled"),
+  fonts: import_zod.z.array(import_zod.z.string()).optional().describe('The fonts of the browser, eg: ["Arial", "Times New Roman"]'),
+  webrtc: import_zod.z.enum(["disabled", "forward", "proxy", "local"]).optional().describe("The webrtc of the browser, default is disabled"),
+  browser_kernel_config: browserKernelConfigSchema,
+  random_ua: randomUaConfigSchema,
+  tls_switch: import_zod.z.enum(["0", "1"]).optional().describe("The tls switch of the browser, default is 0"),
+  tls: import_zod.z.string().optional().describe('The tls of the browser, if tls_switch is 1, you can set the tls of the browser, eg: "0xC02C,0xC030"')
+}).optional().describe('The fingerprint config of the browser, default is automatic_timezone: 0, timezone: "", language: [], flash: "", fonts: [], webrtc: disabled, browser_kernel_config: ua_auto, random_ua: ua_version: [], ua_system_version: [], tls_switch: 0, tls: ""');
+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'),
+    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"),
+    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.optional().describe("Either user_proxy_config or proxyid must be provided. Only one is required."),
+    proxyid: import_zod.z.string().optional().describe("Either user_proxy_config or proxyid must be provided. Only one is required."),
+    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"),
+    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: import_zod.z.string().optional().describe('Country/Region, eg: "CN"'),
+    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"),
+    fingerprintConfig: fingerprintConfigSchema.optional()
+  }).refine((data) => data.userProxyConfig || data.proxyid, {
+    message: "Either userProxyConfig or proxyid must be provided"
+  }).refine((data) => data.username || data.password || data.cookie || data.fakey, {
+    message: "At least one account information field (username, password, cookie, or fakey) must be provided"
+  }),
+  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"),
+    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'),
+    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: import_zod.z.string().optional().describe('The country of the browser, eg: "CN"'),
+    region: import_zod.z.string().optional().describe("The region of the browser"),
+    city: import_zod.z.string().optional().describe("The city of the browser"),
+    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(),
+    proxyid: import_zod.z.string().optional().describe("Proxy ID"),
+    fingerprintConfig: fingerprintConfigSchema.optional(),
+    launchArgs: import_zod.z.string().optional().describe("Browser startup parameters"),
+    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")
+  }).strict(),
+  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"
+  }),
+  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")
+  }).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)')
+  }).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")
+  }).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"
+  }),
+  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"
+  }),
+  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(),
+  deleteCacheV2Schema: import_zod.z.object({
+    profileIds: 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"),
+    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"),
+    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"),
+    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"),
+    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"),
+    page: import_zod.z.number().optional().describe("The page of the group, default is 1")
+  }).strict(),
+  getApplicationListSchema: import_zod.z.object({
+    category_id: import_zod.z.string().optional().describe("Extension category_id"),
+    page: import_zod.z.number().optional().describe("Page number, default 1"),
+    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"
+  }),
+  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, {
+    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", "ipidea"]).optional().describe("IP checker.")
+    }).strict()).describe("Array of proxy configurations to create")
+  }).strict(),
+  updateProxySchema: import_zod.z.object({
+    proxyId: 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/"),
+    remark: import_zod.z.string().optional().describe("Remark/description for the proxy"),
+    ipchecker: import_zod.z.enum(["ip2location", "ipapi", "ipfoxy", "ipidea"]).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"]')
+  }).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. ")
+  }).strict(),
+  emptySchema: import_zod.z.object({}).strict(),
+  createAutomationSchema: import_zod.z.object({
+    userId: import_zod.z.string().optional().describe("The browser id of the browser to connect"),
+    serialNumber: import_zod.z.string().optional().describe("The serial number of the browser to connect"),
+    wsUrl: import_zod.z.string().describe("The ws url of the browser, get from the open-browser tool content `ws.puppeteer`")
+  }).strict(),
+  navigateSchema: import_zod.z.object({
+    url: import_zod.z.string().describe("The url to navigate to")
+  }).strict(),
+  screenshotSchema: import_zod.z.object({
+    savePath: import_zod.z.string().optional().describe("The path to save the screenshot"),
+    isFullPage: import_zod.z.boolean().optional().describe("The is full page of the screenshot")
+  }).strict(),
+  clickElementSchema: import_zod.z.object({
+    selector: import_zod.z.string().describe("The selector of the element to click, find from the page source code")
+  }).strict(),
+  fillInputSchema: import_zod.z.object({
+    selector: import_zod.z.string().describe("The selector of the input to fill, find from the page source code"),
+    text: import_zod.z.string().describe("The text to fill in the input")
+  }).strict(),
+  selectOptionSchema: import_zod.z.object({
+    selector: import_zod.z.string().describe("The selector of the option to select, find from the page source code"),
+    value: import_zod.z.string().describe("The value of the option to select")
+  }).strict(),
+  hoverElementSchema: import_zod.z.object({
+    selector: import_zod.z.string().describe("The selector of the element to hover, find from the page source code")
+  }).strict(),
+  scrollElementSchema: import_zod.z.object({
+    selector: import_zod.z.string().describe("The selector of the element to scroll, find from the page source code")
+  }).strict(),
+  pressKeySchema: import_zod.z.object({
+    key: import_zod.z.string().describe('The key to press, eg: "Enter"'),
+    selector: import_zod.z.string().optional().describe("The selector of the element to press the key, find from the page source code")
+  }).strict(),
+  evaluateScriptSchema: import_zod.z.object({
+    script: import_zod.z.string().describe(`The script to evaluate, eg: "document.querySelector('#username').value = 'test'"`)
+  }).strict(),
+  dragElementSchema: import_zod.z.object({
+    selector: import_zod.z.string().describe("The selector of the element to drag, find from the page source code"),
+    targetSelector: import_zod.z.string().describe("The selector of the element to drag to, find from the page source code")
+  }).strict(),
+  iframeClickElementSchema: import_zod.z.object({
+    selector: import_zod.z.string().describe("The selector of the element to click, find from the page source code"),
+    iframeSelector: import_zod.z.string().describe("The selector of the iframe to click, find from the page source code")
+  }).strict()
+};
+
+// src/cli.ts
+var STATELESS_HANDLERS = {
+  "open-browser": browserHandlers.openBrowser,
+  "close-browser": browserHandlers.closeBrowser,
+  "create-browser": browserHandlers.createBrowser,
+  "update-browser": browserHandlers.updateBrowser,
+  "delete-browser": browserHandlers.deleteBrowser,
+  "get-browser-list": browserHandlers.getBrowserList,
+  "get-opened-browser": browserHandlers.getOpenedBrowser,
+  "move-browser": browserHandlers.moveBrowser,
+  "get-profile-cookies": browserHandlers.getProfileCookies,
+  "get-profile-ua": browserHandlers.getProfileUa,
+  "close-all-profiles": browserHandlers.closeAllProfiles,
+  "new-fingerprint": browserHandlers.newFingerprint,
+  "delete-cache-v2": browserHandlers.deleteCacheV2,
+  "share-profile": browserHandlers.shareProfile,
+  "get-browser-active": browserHandlers.getBrowserActive,
+  "get-cloud-active": browserHandlers.getCloudActive,
+  "create-group": groupHandlers.createGroup,
+  "update-group": groupHandlers.updateGroup,
+  "get-group-list": groupHandlers.getGroupList,
+  "check-status": applicationHandlers.checkStatus,
+  "get-application-list": applicationHandlers.getApplicationList,
+  "create-proxy": proxyHandlers.createProxy,
+  "update-proxy": proxyHandlers.updateProxy,
+  "get-proxy-list": proxyHandlers.getProxyList,
+  "delete-proxy": proxyHandlers.deleteProxy
+};
+var SINGLE_PROFILE_ID_COMMANDS = {
+  "open-browser": "profileId",
+  "close-browser": "profileId",
+  "get-profile-cookies": "profileId",
+  "get-browser-active": "profileId"
+};
+var SINGLE_PROFILE_ID_ARRAY_COMMANDS = ["get-profile-ua", "new-fingerprint"];
+function parseArgv(argv) {
+  let i = 0;
+  while (i < argv.length) {
+    if (argv[i] === "--port" || argv[i] === "--api-key") {
+      i += 2;
+      continue;
+    }
+    break;
+  }
+  const command = argv[i];
+  const arg = argv[i + 1];
+  if (!command || !STATELESS_HANDLERS[command]) {
+    throw new Error(`Unknown or unsupported command: ${command || "(missing)"}. Supported: ${Object.keys(STATELESS_HANDLERS).join(", ")}`);
+  }
+  let args = {};
+  if (arg) {
+    const trimmed = arg.trim();
+    if (trimmed.startsWith("{")) {
+      try {
+        args = JSON.parse(arg);
+      } catch {
+        throw new Error("Invalid JSON for command args");
+      }
+    } else if (SINGLE_PROFILE_ID_COMMANDS[command]) {
+      const key = SINGLE_PROFILE_ID_COMMANDS[command];
+      args = { [key]: trimmed };
+    } else if (SINGLE_PROFILE_ID_ARRAY_COMMANDS.includes(command)) {
+      args = { profileId: [trimmed] };
+    } else {
+      try {
+        args = JSON.parse(arg);
+      } catch {
+        throw new Error(`Command requires JSON args (e.g. '{"key":"value"}') or use a supported shorthand`);
+      }
+    }
+  }
+  return { command, args };
+}
+async function main() {
+  const argv = process.argv.slice(2);
+  try {
+    const { command, args } = parseArgv(argv);
+    const handler = STATELESS_HANDLERS[command];
+    const result = await handler(args);
+    const out = typeof result === "string" ? result : JSON.stringify(result, null, 2);
+    process.stdout.write(out + "\n");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(msg + "\n");
+    process.exit(1);
+  }
+}
+main();