@tgebrowser/cli 1.1.0

package/README.MD

@@ -0,0 +1,87 @@
+# tgebrowser
+
+TgeBrowser automation CLI for AI agents.
+
+## Install CLI (npm)
+
+```bash
+npm install -g tgebrowser
+```
+
+## Install as Cursor / Agent Skill
+
+Skills live at the repo root. Install with:
+
+```bash
+npx skills add TgeBrowser/tgebrowser
+```
+
+- Project scope (default): skill goes to `.cursor/skills/tgebrowser/` (or your agent’s skills dir).
+- Global: add `-g` (e.g. `~/.cursor/skills/` for Cursor).
+
+## Usage with AI Agents
+
+Use the CLI in terminal or let the agent run it; the installed skill gives the agent context on when and how to call `tgebrowser` (environments, groups, proxies, etc.).
+
+
+## How to Run
+
+```bash
+tgebrowser [--port PORT] [--api-key KEY] <command> [<arg>]
+```
+
+**Two forms for `<arg>`:**
+
+1. **Single value (shorthand)** — for environment-related commands, pass one envId or userIndex.
+
+2. **JSON string** — full parameters for any command (recommended):
+   - `tgebrowser open-browser '{"envId":901,"args":["--headless"]}'`
+   - Commands with no params: omit `<arg>` or use `'{}'`.
+
+## Essential Commands
+
+### Browser environment – open/close
+
+```bash
+tgebrowser open-browser '{"envId":901,"args":["--headless"],"port":1111}'
+tgebrowser close-browser '{"envId":901}'
+```
+
+### Browser environment – create/update/delete/list
+
+```bash
+tgebrowser create-browser '{"browserName":"My Env","fingerprint":{"os":"Windows"}}'
+tgebrowser update-browser '{"envId":900,"browserName":"New Name"}'
+tgebrowser delete-browser '{"envId":900}'
+tgebrowser get-browser-list '{"current":1,"pageSize":20}'
+tgebrowser get-opened-browser
+```
+
+### Browser environment – cookies/UA/fingerprint/cache/active
+
+```bash
+tgebrowser get-profile-cookies '{"envId":900}'
+tgebrowser get-profile-ua '{"envId":900}'
+tgebrowser close-all-profiles
+tgebrowser new-fingerprint '{"envId":900}'
+tgebrowser delete-cache '{"envId":900}'
+tgebrowser get-browser-active '{}'
+```
+
+### Group
+
+```bash
+tgebrowser get-group-list '{"current":1,"pageSize":20}'
+```
+
+### Application (categories)
+
+```bash
+tgebrowser check-status                                # No params – API availability
+```
+
+### Proxy
+
+```bash
+tgebrowser get-proxy-list '{"current":1,"pageSize":20}'
+```

package/build/cli.js

@@ -0,0 +1,1212 @@
+#!/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 __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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
+));
+
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports2, module2) {
+    module2.exports = {
+      name: "tgebrowser",
+      version: "1.1.0",
+      main: "build/cli.js",
+      type: "commonjs",
+      bin: {
+        tgebrowser: "./build/cli.js"
+      },
+      scripts: {
+        build: "tsup",
+        tgebrowser: "node build/cli.js"
+      },
+      dependencies: {
+        axios: "^1.8.4",
+        playwright: "^1.51.1",
+        zod: "^3.24.2"
+      },
+      devDependencies: {
+        "@tgebrowser/core": "workspace:*",
+        "@types/node": "^22.13.13",
+        typescript: "^5.8.2",
+        tsup: "^8.5.1"
+      },
+      engines: {
+        node: ">=18.0.0"
+      },
+      files: [
+        "build"
+      ],
+      description: "TgeBrowser Local API CLI and Cursor/agent skill for browser environments, groups, proxies.",
+      keywords: ["tgebrowser", "browser", "cursor", "skill", "agent-skills", "automation"],
+      repository: {
+        type: "git",
+        url: "https://github.com/tgebrowser/tgebrowser.git",
+        directory: "packages/tgebrowser-cli"
+      },
+      bugs: { url: "https://github.com/tgebrowser/tgebrowser/issues" },
+      homepage: "https://github.com/tgebrowser/tgebrowser/tree/main/packages/tgebrowser#readme"
+    };
+  }
+});
+
+// ../core/src/client.ts
+var import_axios = __toESM(require("axios"));
+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 || "50326",
+    apiKey: apiKey || process.env.API_KEY
+  };
+}
+var config = parseArgs();
+var PORT = config.port;
+var API_KEY = config.apiKey;
+var BASE_URL = `http://127.0.0.1:${PORT}`;
+var ENDPOINTS = {
+  STATUS: "/api/status",
+  START_BROWSER: "/api/browser/start",
+  CLOSE_BROWSER: "/api/browser/stop",
+  CREATE_BROWSER: "/api/browser/create",
+  UPDATE_BROWSER: "/api/browser/update",
+  DELETE_BROWSER: "/api/browser/delete",
+  BATCH_DELETE_BROWSER: "/api/browser/delete/batch",
+  GET_BROWSER_LIST: "/api/browser/list",
+  GET_BROWSER_DETAIL: "/api/browser/detail",
+  CLOSE_ALL_PROFILES: "/api/browser/stop-all",
+  DELETE_CACHE_V2: "/api/browser/cache/delete",
+  BATCH_DELETE_CACHE: "/api/browser/batch/delete-cache",
+  GET_OPENED_BROWSER: "/api/browser/open/list",
+  GET_MOBILE_DEVICES: "/api/browser/mobile-devices",
+  WINDOW_SORT: "/api/windowbounds/sort",
+  WINDOW_SORT_CUSTOM: "/api/windowbounds/sort/custom",
+  GET_GROUP_LIST: "/api/groups/list",
+  CREATE_GROUP: "/api/groups",
+  UPDATE_GROUP: (groupId) => `/api/groups/${groupId}`,
+  DELETE_GROUP: (groupId) => `/api/groups/${groupId}`,
+  GET_PROXY_LIST: "/api/proxies/list",
+  CREATE_PROXY: "/api/proxies",
+  UPDATE_PROXY: (proxyId) => `/api/proxies/${proxyId}`,
+  DELETE_PROXY: (proxyId) => `/api/proxies/${proxyId}`,
+  WINDOW_HIDE: "/api/window/hide",
+  WINDOW_SHOW: "/api/window/show",
+  UPDATE_COOKIE: "/api/browser/cookie/update",
+  BATCH_UPDATE: "/api/browser/batch/update"
+};
+var apiClient = import_axios.default.create({
+  baseURL: BASE_URL,
+  timeout: 1e4,
+  headers: {
+    "Content-Type": "application/json",
+    ...API_KEY ? { "Authorization": `Bearer ${API_KEY}` } : {}
+  }
+});
+
+// ../core/src/profile/actions.ts
+function assertSuccess(data, action) {
+  if (data && data.success) return;
+  const message = data && typeof data.message === "string" ? data.message : "Unknown error";
+  throw new Error(`Failed to ${action}: ${message}`);
+}
+function buildBody(params) {
+  const body = {};
+  for (const [key, value] of Object.entries(params)) {
+    if (value === void 0) continue;
+    if (Array.isArray(value)) {
+      const mapped = value.map((item) => item && typeof item === "object" ? buildBody(item) : item).filter((v) => v !== void 0);
+      if (mapped.length > 0) body[key] = mapped;
+    } else if (value && typeof value === "object") {
+      body[key] = buildBody(value);
+    } else {
+      body[key] = value;
+    }
+  }
+  return body;
+}
+var profileActions = {
+  async open({ envId, userIndex, args, port }) {
+    const body = {};
+    if (envId !== void 0) body.envId = envId;
+    if (userIndex !== void 0) body.userIndex = userIndex;
+    if (args && args.length > 0) body.args = args;
+    if (port !== void 0) body.port = port;
+    const response = await apiClient.post(ENDPOINTS.START_BROWSER, body);
+    assertSuccess(response.data, "open browser");
+    const info = response.data.data || {};
+    const wsUrl = typeof info.ws === "object" ? info.ws?.puppeteer ?? info.ws?.selenium ?? JSON.stringify(info.ws) : info.ws;
+    return `Browser started: envId=${info.envId}, userIndex=${info.userIndex}, ws=${wsUrl}, http=${info.http}, port=${info.port}
+
+To automate this browser, use connect-browser-with-ws with wsUrl="${wsUrl}"`;
+  },
+  async close({ envId, userIndex }) {
+    const body = {};
+    if (envId !== void 0) body.envId = envId;
+    if (userIndex !== void 0) body.userIndex = userIndex;
+    const response = await apiClient.post(ENDPOINTS.CLOSE_BROWSER, body);
+    assertSuccess(response.data, "close browser");
+    return "Browser closed successfully";
+  },
+  async create(params) {
+    const response = await apiClient.post(ENDPOINTS.CREATE_BROWSER, buildBody(params));
+    assertSuccess(response.data, "create browser");
+    const info = response.data.data || {};
+    return `Browser created: envId=${info.envId}, userIndex=${info.userIndex}`;
+  },
+  async update(params) {
+    const response = await apiClient.post(ENDPOINTS.UPDATE_BROWSER, buildBody(params));
+    assertSuccess(response.data, "update browser");
+    const info = response.data.data || {};
+    return `Browser updated: envId=${info.envId ?? params.envId}`;
+  },
+  async delete({ envId, userIndex }) {
+    const body = {};
+    if (envId !== void 0) body.envId = envId;
+    if (userIndex !== void 0) body.userIndex = userIndex;
+    const response = await apiClient.post(ENDPOINTS.DELETE_BROWSER, body);
+    assertSuccess(response.data, "delete browser");
+    return `Browser deleted: envId=${body.envId ?? ""} userIndex=${body.userIndex ?? ""}`;
+  },
+  async list(params) {
+    const searchParams = {};
+    if (params.current !== void 0) searchParams.current = params.current.toString();
+    if (params.pageSize !== void 0) searchParams.pageSize = params.pageSize.toString();
+    if (params.keyword) searchParams.keyword = params.keyword;
+    if (params.groupId !== void 0) searchParams.groupId = params.groupId.toString();
+    const response = await apiClient.get(ENDPOINTS.GET_BROWSER_LIST, { params: searchParams });
+    assertSuccess(response.data, "get browser list");
+    const raw = response.data.data || {};
+    const summary = {
+      total: raw.total,
+      current: raw.current,
+      pageSize: raw.pageSize,
+      list: (raw.list || []).map((item) => ({
+        envId: item.envId,
+        userIndex: item.userIndex,
+        browserName: item.browserName,
+        groupId: item.groupId,
+        remark: item.remark,
+        lastOpenedTime: item.lastOpenedTime
+      }))
+    };
+    return `Browser list: ${JSON.stringify(summary, null, 2)}`;
+  },
+  async openedList() {
+    const response = await apiClient.get(ENDPOINTS.GET_OPENED_BROWSER);
+    assertSuccess(response.data, "get opened browsers");
+    return `Opened browser list: ${JSON.stringify(response.data.data, null, 2)}`;
+  },
+  async getCookies({ envId, userIndex }) {
+    const body = {};
+    if (envId !== void 0) body.envId = envId;
+    if (userIndex !== void 0) body.userIndex = userIndex;
+    const response = await apiClient.post(ENDPOINTS.GET_BROWSER_DETAIL, body);
+    assertSuccess(response.data, "get profile cookies");
+    return `Profile cookies: ${JSON.stringify(response.data.data?.cookie, null, 2)}`;
+  },
+  async getUa({ envId, userIndex }) {
+    const body = {};
+    if (envId !== void 0) body.envId = envId;
+    if (userIndex !== void 0) body.userIndex = userIndex;
+    const response = await apiClient.post(ENDPOINTS.GET_BROWSER_DETAIL, body);
+    assertSuccess(response.data, "get profile User-Agent");
+    const ua = response.data.data?.fingerprint?.userAgent;
+    return `Profile User-Agent: ${ua ?? ""}`;
+  },
+  async closeAll() {
+    const response = await apiClient.post(ENDPOINTS.CLOSE_ALL_PROFILES, {});
+    assertSuccess(response.data, "close all browsers");
+    return "All browsers stopped successfully";
+  },
+  async newFingerprint({ envId, userIndex }) {
+    const body = {};
+    if (envId !== void 0) body.envId = envId;
+    if (userIndex !== void 0) body.userIndex = userIndex;
+    body.fingerprint = { randomFingerprint: true };
+    const response = await apiClient.post(ENDPOINTS.UPDATE_BROWSER, body);
+    assertSuccess(response.data, "refresh fingerprint");
+    return `Fingerprint updated for envId=${body.envId ?? ""} userIndex=${body.userIndex ?? ""}`;
+  },
+  async deleteCache({ envId, userIndex }) {
+    const body = {};
+    if (envId !== void 0) body.envId = envId;
+    if (userIndex !== void 0) body.userIndex = userIndex;
+    const response = await apiClient.post(ENDPOINTS.DELETE_CACHE_V2, body);
+    assertSuccess(response.data, "delete cache");
+    return `Cache deleted for envId=${body.envId ?? ""} userIndex=${body.userIndex ?? ""}`;
+  },
+  async getActive(_params) {
+    const response = await apiClient.get(ENDPOINTS.GET_OPENED_BROWSER);
+    assertSuccess(response.data, "get active browsers");
+    return `Active browsers: ${JSON.stringify(response.data.data, null, 2)}`;
+  },
+  async batchDelete({ envIds, userIndexes, permanent }) {
+    const body = {};
+    if (envIds && envIds.length > 0) body.envIds = envIds;
+    if (userIndexes && userIndexes.length > 0) body.userIndexes = userIndexes;
+    if (permanent !== void 0) body.permanent = permanent;
+    const response = await apiClient.post(ENDPOINTS.BATCH_DELETE_BROWSER, body);
+    assertSuccess(response.data, "batch delete browsers");
+    const info = response.data.data || {};
+    return `Batch delete result: total=${info.total}, deleted=${JSON.stringify(info.deleted)}, failed=${JSON.stringify(info.failed)}`;
+  },
+  async batchDeleteCache({ envIds, userIndexes }) {
+    const body = {};
+    if (envIds && envIds.length > 0) body.envIds = envIds;
+    if (userIndexes && userIndexes.length > 0) body.userIndexes = userIndexes;
+    const response = await apiClient.post(ENDPOINTS.BATCH_DELETE_CACHE, body);
+    assertSuccess(response.data, "batch delete cache");
+    const info = response.data.data || {};
+    return `Batch delete cache result: total=${info.total}, success=${info.success}, failed=${info.failed}`;
+  },
+  async getMobileDevices({ os: os2 }) {
+    const params = {};
+    if (os2) params.os = os2;
+    const response = await apiClient.get(ENDPOINTS.GET_MOBILE_DEVICES, { params });
+    assertSuccess(response.data, "get mobile devices");
+    return `Mobile devices: ${JSON.stringify(response.data.data, null, 2)}`;
+  },
+  async getDetail({ envId, userIndex }) {
+    const body = {};
+    if (envId !== void 0) body.envId = envId;
+    if (userIndex !== void 0) body.userIndex = userIndex;
+    const response = await apiClient.post(ENDPOINTS.GET_BROWSER_DETAIL, body);
+    assertSuccess(response.data, "get browser detail");
+    return `Browser detail: ${JSON.stringify(response.data.data, null, 2)}`;
+  },
+  async updateCookie({ envId, userIndex, cookie }) {
+    const body = { cookie };
+    if (envId !== void 0) body.envId = envId;
+    if (userIndex !== void 0) body.userIndex = userIndex;
+    const response = await apiClient.post(ENDPOINTS.UPDATE_COOKIE, body);
+    assertSuccess(response.data, "update cookie");
+    return `Cookie updated for envId=${body.envId ?? ""} userIndex=${body.userIndex ?? ""}`;
+  },
+  async batchUpdate({ envIds, field, value }) {
+    const response = await apiClient.put(ENDPOINTS.BATCH_UPDATE, { envIds, field, value });
+    assertSuccess(response.data, "batch update");
+    const info = response.data.data || {};
+    return `Batch update result: total=${info.total}, success=${info.success}, failed=${info.failed}`;
+  }
+};
+
+// ../core/src/profile/schema.ts
+var import_zod = require("zod");
+var CHROME_VERSIONS = [
+  "133",
+  "135",
+  "137",
+  "139",
+  "141",
+  "143",
+  "ua_auto"
+];
+var TLS_CIPHER_SUITES = {
+  TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384: "0xC02C",
+  TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384: "0xC030",
+  TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256: "0xC02B",
+  TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256: "0xC02F",
+  TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256: "0xCCA9",
+  TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256: "0xCCA8",
+  TLS_DHE_RSA_WITH_AES_256_GCM_SHA384: "0x009F",
+  TLS_DHE_RSA_WITH_AES_128_GCM_SHA256: "0x009E",
+  TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384: "0xC024",
+  TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384: "0xC028",
+  TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA: "0xC00A",
+  TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA: "0xC014",
+  TLS_DHE_RSA_WITH_AES_256_CBC_SHA256: "0x006B",
+  TLS_DHE_RSA_WITH_AES_256_CBC_SHA: "0x0039",
+  TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256: "0xC023",
+  TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256: "0xC027",
+  TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA: "0xC009",
+  TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA: "0xC013",
+  TLS_DHE_RSA_WITH_AES_128_CBC_SHA256: "0x0067",
+  TLS_DHE_RSA_WITH_AES_128_CBC_SHA: "0x0033",
+  TLS_RSA_WITH_AES_256_GCM_SHA384: "0x009D",
+  TLS_RSA_WITH_AES_128_GCM_SHA256: "0x009C",
+  TLS_RSA_WITH_AES_256_CBC_SHA256: "0x003D",
+  TLS_RSA_WITH_AES_128_CBC_SHA256: "0x003C",
+  TLS_RSA_WITH_AES_256_CBC_SHA: "0x0035",
+  TLS_RSA_WITH_AES_128_CBC_SHA: "0x002F",
+  TLS_AES_128_CCM_8_SHA256: "0x1305",
+  TLS_AES_128_CCM_SHA256: "0x1304"
+};
+var TLS_HEX_CODES = Object.values(TLS_CIPHER_SUITES);
+var browserKernelConfigSchema = import_zod.z.object({
+  version: import_zod.z.union(
+    CHROME_VERSIONS.map((v) => import_zod.z.literal(v))
+  ).optional().describe("The version of the browser, supported: 133, 135, 137, 139, 141, 143, ua_auto"),
+  type: import_zod.z.literal("chrome").optional().describe("The type of the browser, only chrome is supported")
+}).optional().superRefine((data, ctx) => {
+  if (!data) return;
+  const version = data.version;
+  if (version === void 0) return;
+  if (!CHROME_VERSIONS.includes(version)) {
+    ctx.addIssue({ code: import_zod.z.ZodIssueCode.custom, message: `Unsupported version "${version}". Supported: ${CHROME_VERSIONS.join(", ")}` });
+  }
+});
+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()
+}).optional();
+var webglConfigSchema = import_zod.z.object({
+  unmasked_vendor: import_zod.z.string().describe("WebGL vendor string. Required when webgl=2."),
+  unmasked_renderer: import_zod.z.string().describe("WebGL renderer string. Required when webgl=2."),
+  webgpu: import_zod.z.object({
+    webgpu_switch: import_zod.z.enum(["0", "1", "2"])
+  }).optional()
+});
+var macAddressConfigSchema = import_zod.z.object({
+  model: import_zod.z.enum(["0", "1", "2"]),
+  address: import_zod.z.string().optional()
+});
+var mediaDevicesNumSchema = import_zod.z.object({
+  audioinput_num: import_zod.z.string().regex(/^[1-9]$/),
+  videoinput_num: import_zod.z.string().regex(/^[1-9]$/),
+  audiooutput_num: import_zod.z.string().regex(/^[1-9]$/)
+});
+var sharedFingerprintFields = {
+  mobileDeviceId: import_zod.z.number().optional(),
+  platformVersion: import_zod.z.number().optional(),
+  kernel: import_zod.z.string().optional(),
+  userAgent: import_zod.z.string().optional(),
+  webrtc: import_zod.z.string().optional(),
+  resolution: import_zod.z.string().optional(),
+  windowWidth: import_zod.z.number().optional(),
+  windowHeight: import_zod.z.number().optional(),
+  language: import_zod.z.string().optional(),
+  languageBaseIp: import_zod.z.boolean().optional(),
+  uiLanguage: import_zod.z.string().optional(),
+  uiLanguageBaseIp: import_zod.z.boolean().optional(),
+  timezone: import_zod.z.string().optional(),
+  timezoneBaseIp: import_zod.z.boolean().optional(),
+  geolocationBaseIp: import_zod.z.boolean().optional(),
+  lng: import_zod.z.string().optional(),
+  lat: import_zod.z.string().optional(),
+  canvas: import_zod.z.boolean().optional(),
+  audioContext: import_zod.z.boolean().optional(),
+  speechVoices: import_zod.z.boolean().optional(),
+  clientRects: import_zod.z.boolean().optional(),
+  fonts: import_zod.z.array(import_zod.z.string()).optional(),
+  disableTLS: import_zod.z.array(import_zod.z.string()).optional(),
+  ram: import_zod.z.number().optional(),
+  cpu: import_zod.z.number().optional(),
+  hardwareAcceleration: import_zod.z.boolean().optional(),
+  disableSandbox: import_zod.z.boolean().optional(),
+  startupParams: import_zod.z.string().optional(),
+  deviceName: import_zod.z.string().optional(),
+  deviceMedia: import_zod.z.boolean().optional(),
+  portScanProtection: import_zod.z.string().optional(),
+  randomFingerprint: import_zod.z.boolean().optional(),
+  blockLargeImages: import_zod.z.boolean().optional(),
+  maxImageKB: import_zod.z.number().optional(),
+  syncCookies: import_zod.z.boolean().optional(),
+  clearCacheOnStart: import_zod.z.boolean().optional(),
+  clearCachePreserveExtensionsOnStart: import_zod.z.boolean().optional(),
+  clearCookiesOnStart: import_zod.z.boolean().optional(),
+  clearHistoryOnStart: import_zod.z.boolean().optional(),
+  disableMediaAutoplay: import_zod.z.boolean().optional(),
+  muteAllMedia: import_zod.z.boolean().optional(),
+  disableGoogleTranslate: import_zod.z.boolean().optional(),
+  disableSavePasswordPrompt: import_zod.z.boolean().optional(),
+  disableNotifications: import_zod.z.boolean().optional(),
+  blockClipboardRead: import_zod.z.boolean().optional(),
+  stopOnNetworkIssue: import_zod.z.boolean().optional(),
+  stopOnIPChange: import_zod.z.boolean().optional(),
+  stopOnCountryChange: import_zod.z.boolean().optional()
+};
+var sharedProxyFields = {
+  host: import_zod.z.string().optional(),
+  port: import_zod.z.number().optional(),
+  username: import_zod.z.string().optional(),
+  password: import_zod.z.string().optional(),
+  timezone: import_zod.z.string().optional(),
+  proxyId: import_zod.z.number().optional()
+};
+var startInfoSchema = import_zod.z.object({
+  startPage: import_zod.z.object({
+    mode: import_zod.z.string().optional(),
+    value: import_zod.z.array(import_zod.z.string()).optional()
+  }).optional(),
+  otherConfig: import_zod.z.object({
+    openConfigPage: import_zod.z.boolean().optional(),
+    checkPage: import_zod.z.boolean().optional(),
+    extensionTab: import_zod.z.boolean().optional()
+  }).optional()
+}).optional();
+var profileSchemas = {
+  create: import_zod.z.object({
+    browserName: import_zod.z.string().describe("Environment name"),
+    groupId: import_zod.z.number().optional().describe("Group id of the environment"),
+    remark: import_zod.z.string().optional().describe("Remark for the environment"),
+    proxy: import_zod.z.object({
+      protocol: import_zod.z.string().describe("Proxy protocol, e.g. http, socks5, direct"),
+      ...sharedProxyFields
+    }).optional(),
+    fingerprint: import_zod.z.object({
+      os: import_zod.z.string().describe("Operating system, e.g. Windows, macOS, Android, iOS"),
+      ...sharedFingerprintFields
+    }).optional(),
+    startInfo: startInfoSchema,
+    Cookie: import_zod.z.any().optional()
+  }),
+  update: import_zod.z.object({
+    envId: import_zod.z.number().describe("Environment id to update"),
+    browserName: import_zod.z.string().describe("Environment name"),
+    groupId: import_zod.z.number().optional().describe("Group id"),
+    remark: import_zod.z.string().optional().describe("Remark"),
+    proxy: import_zod.z.object({
+      protocol: import_zod.z.string().optional(),
+      ipChecker: import_zod.z.string().optional(),
+      ...sharedProxyFields
+    }).optional(),
+    fingerprint: import_zod.z.object({
+      os: import_zod.z.string().optional(),
+      ...sharedFingerprintFields
+    }).optional(),
+    Cookie: import_zod.z.any().optional(),
+    startInfo: startInfoSchema
+  }),
+  open: import_zod.z.object({
+    envId: import_zod.z.number().optional().describe("Environment id to start"),
+    userIndex: import_zod.z.number().optional().describe("Environment index to start"),
+    args: import_zod.z.array(import_zod.z.string()).optional().describe("Extra browser args"),
+    port: import_zod.z.number().optional().describe("Custom remote debugging port")
+  }).refine((data) => data.envId !== void 0 || data.userIndex !== void 0, {
+    message: "Either envId or userIndex must be provided"
+  }),
+  close: import_zod.z.object({
+    envId: import_zod.z.number().optional().describe("Environment id to stop"),
+    userIndex: import_zod.z.number().optional().describe("Environment index to stop")
+  }).refine((data) => data.envId !== void 0 || data.userIndex !== void 0, {
+    message: "Either envId or userIndex must be provided"
+  }),
+  delete: import_zod.z.object({
+    envId: import_zod.z.number().optional().describe("Environment id to delete"),
+    userIndex: import_zod.z.number().optional().describe("Environment index to delete")
+  }).refine((data) => data.envId !== void 0 || data.userIndex !== void 0, {
+    message: "Either envId or userIndex must be provided"
+  }),
+  list: import_zod.z.object({
+    current: import_zod.z.number().optional().describe("Current page"),
+    pageSize: import_zod.z.number().optional().describe("Page size"),
+    keyword: import_zod.z.string().optional().describe("Search keyword"),
+    groupId: import_zod.z.number().optional().describe("Group id")
+  }).strict(),
+  cookies: import_zod.z.object({
+    envId: import_zod.z.number().optional().describe("Environment id"),
+    userIndex: import_zod.z.number().optional().describe("Environment index")
+  }).refine((data) => data.envId !== void 0 || data.userIndex !== void 0, {
+    message: "Either envId or userIndex must be provided"
+  }),
+  ua: import_zod.z.object({
+    envId: import_zod.z.number().optional().describe("Environment id"),
+    userIndex: import_zod.z.number().optional().describe("Environment index")
+  }).refine((data) => data.envId !== void 0 || data.userIndex !== void 0, {
+    message: "Either envId or userIndex must be provided"
+  }),
+  closeAll: import_zod.z.object({}).strict(),
+  newFingerprint: import_zod.z.object({
+    envId: import_zod.z.number().optional().describe("Environment id"),
+    userIndex: import_zod.z.number().optional().describe("Environment index")
+  }).refine((data) => data.envId !== void 0 || data.userIndex !== void 0, {
+    message: "Either envId or userIndex must be provided"
+  }),
+  deleteCache: import_zod.z.object({
+    envId: import_zod.z.number().optional().describe("Environment id"),
+    userIndex: import_zod.z.number().optional().describe("Environment index")
+  }).refine((data) => data.envId !== void 0 || data.userIndex !== void 0, {
+    message: "Either envId or userIndex must be provided"
+  }),
+  active: import_zod.z.object({
+    profileId: import_zod.z.string().optional().describe("The profile id"),
+    profileNo: import_zod.z.string().optional().describe("The profile number")
+  }).refine((data) => data.profileId || data.profileNo, {
+    message: "Either profileId or profileNo must be provided"
+  }),
+  openedList: import_zod.z.object({}).strict(),
+  batchDelete: import_zod.z.object({
+    envIds: import_zod.z.array(import_zod.z.number().int().positive()).optional().describe("Array of environment ids to delete"),
+    userIndexes: import_zod.z.array(import_zod.z.number().int().min(1)).optional().describe("Array of environment indexes to delete"),
+    permanent: import_zod.z.boolean().optional().describe("true=hard delete, false=soft delete (default)")
+  }).refine((data) => data.envIds && data.envIds.length > 0 || data.userIndexes && data.userIndexes.length > 0, {
+    message: "Either envIds or userIndexes must be provided"
+  }),
+  batchDeleteCache: import_zod.z.object({
+    envIds: import_zod.z.array(import_zod.z.number().int().positive()).optional().describe("Array of environment ids"),
+    userIndexes: import_zod.z.array(import_zod.z.number().int().min(1)).optional().describe("Array of environment indexes")
+  }).refine((data) => data.envIds && data.envIds.length > 0 || data.userIndexes && data.userIndexes.length > 0, {
+    message: "Either envIds or userIndexes must be provided"
+  }),
+  mobileDevices: import_zod.z.object({
+    os: import_zod.z.enum(["Android", "iOS"]).optional().describe("Filter by OS: Android or iOS")
+  }).strict(),
+  detail: import_zod.z.object({
+    envId: import_zod.z.number().int().positive().optional().describe("Environment id"),
+    userIndex: import_zod.z.number().int().min(1).optional().describe("Environment index")
+  }).refine((data) => data.envId !== void 0 || data.userIndex !== void 0, {
+    message: "Either envId or userIndex must be provided"
+  }),
+  updateCookie: import_zod.z.object({
+    envId: import_zod.z.number().int().positive().optional().describe("Environment id"),
+    userIndex: import_zod.z.number().int().min(1).optional().describe("Environment index"),
+    cookie: import_zod.z.string().describe("Cookie string. Empty string or null clears the cookie.")
+  }).refine((data) => data.envId !== void 0 || data.userIndex !== void 0, {
+    message: "Either envId or userIndex must be provided"
+  }),
+  batchUpdate: import_zod.z.object({
+    envIds: import_zod.z.array(import_zod.z.number().int().positive()).describe("Array of environment ids"),
+    field: import_zod.z.string().describe('Field name to update, e.g. "browserName", "remark", "fingerprint"'),
+    value: import_zod.z.any().describe("New value for the field")
+  })
+};
+
+// ../core/src/automation/actions.ts
+var import_path = __toESM(require("path"));
+var import_os = __toESM(require("os"));
+
+// ../core/src/automation/session.ts
+var import_playwright = require("playwright");
+var BrowserSession = 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 connectWithWs(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 reset() {
+    this.browser = null;
+    this.page = null;
+  }
+};
+var session_default = new BrowserSession();
+
+// ../core/src/automation/actions.ts
+var defaultDownloadsPath = import_path.default.join(import_os.default.homedir(), "Downloads");
+
+// ../core/src/automation/schema.ts
+var import_zod2 = require("zod");
+var automationSchemas = {
+  connect: import_zod2.z.object({
+    userId: import_zod2.z.string().optional().describe("The browser id of the browser to connect"),
+    serialNumber: import_zod2.z.string().optional().describe("The serial number of the browser to connect"),
+    wsUrl: import_zod2.z.string().describe("The ws url of the browser, get from the open-browser tool content `ws.puppeteer`")
+  }).strict(),
+  navigate: import_zod2.z.object({ url: import_zod2.z.string().describe("The url to navigate to") }).strict(),
+  screenshot: import_zod2.z.object({
+    savePath: import_zod2.z.string().optional().describe("The path to save the screenshot"),
+    isFullPage: import_zod2.z.boolean().optional().describe("The is full page of the screenshot")
+  }).strict(),
+  clickElement: import_zod2.z.object({ selector: import_zod2.z.string().describe("The selector of the element to click, find from the page source code") }).strict(),
+  fillInput: import_zod2.z.object({
+    selector: import_zod2.z.string().describe("The selector of the input to fill, find from the page source code"),
+    text: import_zod2.z.string().describe("The text to fill in the input")
+  }).strict(),
+  selectOption: import_zod2.z.object({
+    selector: import_zod2.z.string().describe("The selector of the option to select, find from the page source code"),
+    value: import_zod2.z.string().describe("The value of the option to select")
+  }).strict(),
+  hoverElement: import_zod2.z.object({ selector: import_zod2.z.string().describe("The selector of the element to hover, find from the page source code") }).strict(),
+  scrollElement: import_zod2.z.object({ selector: import_zod2.z.string().describe("The selector of the element to scroll, find from the page source code") }).strict(),
+  pressKey: import_zod2.z.object({
+    key: import_zod2.z.string().describe('The key to press, eg: "Enter"'),
+    selector: import_zod2.z.string().optional().describe("The selector of the element to press the key, find from the page source code")
+  }).strict(),
+  evaluateScript: import_zod2.z.object({ script: import_zod2.z.string().describe("The script to evaluate") }).strict(),
+  dragElement: import_zod2.z.object({
+    selector: import_zod2.z.string().describe("The selector of the element to drag, find from the page source code"),
+    targetSelector: import_zod2.z.string().describe("The selector of the element to drag to, find from the page source code")
+  }).strict(),
+  iframeClickElement: import_zod2.z.object({
+    selector: import_zod2.z.string().describe("The selector of the element to click, find from the page source code"),
+    iframeSelector: import_zod2.z.string().describe("The selector of the iframe to click, find from the page source code")
+  }).strict(),
+  empty: import_zod2.z.object({}).strict()
+};
+
+// ../core/src/group/actions.ts
+function assertSuccess2(data, action) {
+  if (data && data.success) return;
+  const message = data && typeof data.message === "string" ? data.message : "Unknown error";
+  throw new Error(`Failed to ${action}: ${message}`);
+}
+var groupActions = {
+  async list({ current, pageSize }) {
+    const params = {};
+    if (current !== void 0) params.current = current.toString();
+    if (pageSize !== void 0) params.pageSize = pageSize.toString();
+    const response = await apiClient.get(ENDPOINTS.GET_GROUP_LIST, { params });
+    assertSuccess2(response.data, "get group list");
+    return `Group list: ${JSON.stringify(response.data.data, null, 2)}`;
+  },
+  async create({ name }) {
+    const response = await apiClient.post(ENDPOINTS.CREATE_GROUP, { name });
+    assertSuccess2(response.data, "create group");
+    return `Group created: ${JSON.stringify(response.data.data, null, 2)}`;
+  },
+  async update({ groupId, name }) {
+    const response = await apiClient.put(ENDPOINTS.UPDATE_GROUP(groupId), { name });
+    assertSuccess2(response.data, "update group");
+    return `Group updated: groupId=${groupId}`;
+  },
+  async delete({ groupId }) {
+    const response = await apiClient.delete(ENDPOINTS.DELETE_GROUP(groupId));
+    assertSuccess2(response.data, "delete group");
+    return `Group deleted: groupId=${groupId}`;
+  }
+};
+
+// ../core/src/group/schema.ts
+var import_zod3 = require("zod");
+var groupSchemas = {
+  list: import_zod3.z.object({
+    current: import_zod3.z.number().optional().describe("Current page"),
+    pageSize: import_zod3.z.number().optional().describe("Page size")
+  }).strict(),
+  create: import_zod3.z.object({
+    name: import_zod3.z.string().describe("Group name")
+  }).strict(),
+  update: import_zod3.z.object({
+    groupId: import_zod3.z.number().int().positive().describe("Group id to update"),
+    name: import_zod3.z.string().describe("New group name")
+  }).strict(),
+  delete: import_zod3.z.object({
+    groupId: import_zod3.z.number().int().positive().describe("Group id to delete")
+  }).strict()
+};
+
+// ../core/src/proxy/actions.ts
+function assertSuccess3(data, action) {
+  if (data && data.success) return;
+  const message = data && typeof data.message === "string" ? data.message : "Unknown error";
+  throw new Error(`Failed to ${action}: ${message}`);
+}
+var proxyActions = {
+  async list({ current, pageSize }) {
+    const params = {};
+    if (current !== void 0) params.current = current.toString();
+    if (pageSize !== void 0) params.pageSize = pageSize.toString();
+    const response = await apiClient.get(ENDPOINTS.GET_PROXY_LIST, { params });
+    assertSuccess3(response.data, "get proxy list");
+    return `Proxy list: ${JSON.stringify(response.data.data, null, 2)}`;
+  },
+  async create(params) {
+    const response = await apiClient.post(ENDPOINTS.CREATE_PROXY, params);
+    assertSuccess3(response.data, "create proxy");
+    return `Proxy created: ${JSON.stringify(response.data.data, null, 2)}`;
+  },
+  async update({ proxyId, ...rest }) {
+    const response = await apiClient.put(ENDPOINTS.UPDATE_PROXY(proxyId), rest);
+    assertSuccess3(response.data, "update proxy");
+    return `Proxy updated: proxyId=${proxyId}`;
+  },
+  async delete({ proxyId }) {
+    const response = await apiClient.delete(ENDPOINTS.DELETE_PROXY(proxyId));
+    assertSuccess3(response.data, "delete proxy");
+    return `Proxy deleted: proxyId=${proxyId}`;
+  }
+};
+
+// ../core/src/proxy/schema.ts
+var import_zod4 = require("zod");
+var proxySchemas = {
+  list: import_zod4.z.object({
+    current: import_zod4.z.number().optional().describe("Current page"),
+    pageSize: import_zod4.z.number().optional().describe("Page size")
+  }).strict(),
+  create: import_zod4.z.object({
+    protocol: import_zod4.z.enum(["http", "socks5"]).describe("Proxy protocol: http or socks5"),
+    host: import_zod4.z.string().optional().describe("Proxy host (required for http/socks5)"),
+    port: import_zod4.z.number().optional().describe("Proxy port (required for http/socks5)"),
+    username: import_zod4.z.string().optional().describe("Proxy username"),
+    password: import_zod4.z.string().optional().describe("Proxy password"),
+    ipChecker: import_zod4.z.enum(["iptrush", "ip234", "ipinfo", "ipapi"]).optional().describe("IP checker service")
+  }).strict(),
+  update: import_zod4.z.object({
+    proxyId: import_zod4.z.number().int().positive().describe("Proxy id to update"),
+    protocol: import_zod4.z.enum(["http", "socks5"]).optional().describe("Proxy protocol"),
+    host: import_zod4.z.string().optional().describe("Proxy host"),
+    port: import_zod4.z.number().optional().describe("Proxy port"),
+    username: import_zod4.z.string().optional().describe("Proxy username"),
+    password: import_zod4.z.string().optional().describe("Proxy password"),
+    ipChecker: import_zod4.z.enum(["iptrush", "ip234", "ipinfo", "ipapi"]).optional().describe("IP checker service")
+  }).strict(),
+  delete: import_zod4.z.object({
+    proxyId: import_zod4.z.number().int().positive().describe("Proxy id to delete")
+  }).strict()
+};
+
+// ../core/src/system/actions.ts
+function assertSuccess4(data, action) {
+  if (data && data.success) return;
+  const message = data && typeof data.message === "string" ? data.message : "Unknown error";
+  throw new Error(`Failed to ${action}: ${message}`);
+}
+var systemActions = {
+  async checkStatus() {
+    const response = await apiClient.get(ENDPOINTS.STATUS);
+    return `Connection status: ${JSON.stringify(response.data, null, 2)}`;
+  },
+  async windowSort({ envIds }) {
+    const body = {};
+    if (envIds && envIds.length > 0) body.envIds = envIds;
+    const response = await apiClient.post(ENDPOINTS.WINDOW_SORT, body);
+    assertSuccess4(response.data, "sort windows");
+    return `Window sort result: ${response.data.message || JSON.stringify(response.data.data)}`;
+  },
+  async windowSortCustom(params) {
+    const response = await apiClient.post(ENDPOINTS.WINDOW_SORT_CUSTOM, params);
+    assertSuccess4(response.data, "custom sort windows");
+    return `Custom window sort result: ${response.data.message || JSON.stringify(response.data.data)}`;
+  },
+  async windowHide() {
+    const response = await apiClient.post(ENDPOINTS.WINDOW_HIDE, {});
+    assertSuccess4(response.data, "hide window");
+    return `Window hidden: ${JSON.stringify(response.data.data)}`;
+  },
+  async windowShow() {
+    const response = await apiClient.post(ENDPOINTS.WINDOW_SHOW, {});
+    assertSuccess4(response.data, "show window");
+    return `Window shown: ${JSON.stringify(response.data.data)}`;
+  }
+};
+
+// ../core/src/system/schema.ts
+var import_zod5 = require("zod");
+var systemSchemas = {
+  windowSort: import_zod5.z.object({
+    envIds: import_zod5.z.array(import_zod5.z.number().int().positive()).optional().describe("Target environment ids to sort. If omitted, sorts all open windows.")
+  }).strict(),
+  windowSortCustom: import_zod5.z.object({
+    type: import_zod5.z.enum(["box", "diagonal"]).describe("Layout type: box (grid) or diagonal"),
+    width: import_zod5.z.number().positive().describe("Window width"),
+    height: import_zod5.z.number().positive().describe("Window height"),
+    col: import_zod5.z.number().int().positive().describe("Column count"),
+    startX: import_zod5.z.number().describe("Starting X coordinate"),
+    startY: import_zod5.z.number().describe("Starting Y coordinate"),
+    spaceX: import_zod5.z.number().describe("Horizontal spacing between windows"),
+    spaceY: import_zod5.z.number().describe("Vertical spacing between windows"),
+    offsetX: import_zod5.z.number().describe("X offset"),
+    offsetY: import_zod5.z.number().describe("Y offset"),
+    envIds: import_zod5.z.array(import_zod5.z.number().int().positive()).optional().describe("Target environment ids"),
+    minWindowCount: import_zod5.z.number().int().positive().optional().describe("Minimum number of windows to trigger sort")
+  }).strict()
+};
+
+// src/cli.ts
+var COMMANDS = {
+  // ─ Browser Environment ───────────────────────────────
+  "env-list": {
+    handler: profileActions.list,
+    desc: "Query environment list (paginated)"
+  },
+  "env-open-list": {
+    handler: profileActions.openedList,
+    desc: "Query open/running environments"
+  },
+  "env-create": {
+    handler: profileActions.create,
+    desc: "Create a new browser environment"
+  },
+  "env-update": {
+    handler: profileActions.update,
+    desc: "Update an environment"
+  },
+  "env-delete": {
+    handler: profileActions.delete,
+    desc: "Delete an environment",
+    shorthandKey: "envId"
+  },
+  "env-delete-batch": {
+    handler: profileActions.batchDelete,
+    desc: "Batch delete environments"
+  },
+  "env-detail": {
+    handler: profileActions.getDetail,
+    desc: "Get environment detail",
+    shorthandKey: "envId"
+  },
+  "get-cookies": {
+    handler: profileActions.getCookies,
+    desc: "Get environment cookies",
+    shorthandKey: "envId"
+  },
+  "env-ua": {
+    handler: profileActions.getUa,
+    desc: "Get environment User-Agent",
+    shorthandKey: "envId"
+  },
+  "env-fingerprint": {
+    handler: profileActions.newFingerprint,
+    desc: "Refresh environment fingerprint",
+    shorthandKey: "envId"
+  },
+  "env-mobile-devices": {
+    handler: profileActions.getMobileDevices,
+    desc: "Query mobile device list"
+  },
+  "update-cookie": {
+    handler: profileActions.updateCookie,
+    desc: "Update environment cookie"
+  },
+  "batch-update": {
+    handler: profileActions.batchUpdate,
+    desc: "Batch update a field across environments"
+  },
+  // ─ Browser Control ───────────────────────────────────
+  "start-browser": {
+    handler: profileActions.open,
+    desc: "Start/open a browser environment",
+    shorthandKey: "envId"
+  },
+  "stop-browser": {
+    handler: profileActions.close,
+    desc: "Stop a browser environment",
+    shorthandKey: "envId"
+  },
+  "stop-all-browsers": {
+    handler: profileActions.closeAll,
+    desc: "Stop all running environments"
+  },
+  "browser-active": {
+    handler: profileActions.getActive,
+    desc: "Get active browser info",
+    shorthandKey: "envId"
+  },
+  // ─ Cache ─────────────────────────────────────────────
+  "clear-cache": {
+    handler: profileActions.deleteCache,
+    desc: "Clear environment local cache",
+    shorthandKey: "envId"
+  },
+  "clear-cache-batch": {
+    handler: profileActions.batchDeleteCache,
+    desc: "Batch clear environment caches"
+  },
+  // ─ Groups ────────────────────────────────────────────
+  "group-list": {
+    handler: groupActions.list,
+    desc: "Query group list"
+  },
+  "group-create": {
+    handler: groupActions.create,
+    desc: "Create a group"
+  },
+  "group-update": {
+    handler: groupActions.update,
+    desc: "Update a group"
+  },
+  "group-delete": {
+    handler: groupActions.delete,
+    desc: "Delete a group"
+  },
+  // ─ Proxies ───────────────────────────────────────────
+  "proxy-list": {
+    handler: proxyActions.list,
+    desc: "Query proxy list"
+  },
+  "proxy-create": {
+    handler: proxyActions.create,
+    desc: "Create a proxy"
+  },
+  "proxy-update": {
+    handler: proxyActions.update,
+    desc: "Update a proxy"
+  },
+  "proxy-delete": {
+    handler: proxyActions.delete,
+    desc: "Delete a proxy"
+  },
+  // ─ System ────────────────────────────────────────────
+  "check-status": {
+    handler: systemActions.checkStatus,
+    desc: "Check API connection status"
+  },
+  "window-sort": {
+    handler: systemActions.windowSort,
+    desc: "Auto-layout browser windows"
+  },
+  "window-sort-custom": {
+    handler: systemActions.windowSortCustom,
+    desc: "Custom window layout"
+  },
+  "window-hide": {
+    handler: systemActions.windowHide,
+    desc: "Hide app window and tray"
+  },
+  "window-show": {
+    handler: systemActions.windowShow,
+    desc: "Show app window and tray"
+  }
+};
+function parseValue(s) {
+  s = s.trim();
+  if (s === "true") return true;
+  if (s === "false") return false;
+  if (s === "null") return null;
+  if (s.startsWith("{") && s.endsWith("}") || s.startsWith("[") && s.endsWith("]")) {
+    try {
+      return JSON.parse(s);
+    } catch {
+    }
+  }
+  if (!isNaN(Number(s)) && s !== "") return Number(s);
+  return s;
+}
+function parseArgs2(argv) {
+  const globalOpts = {};
+  let i = 0;
+  while (i < argv.length) {
+    const arg = argv[i];
+    if (arg === "--port" || arg === "--api-key" || arg === "--host" || arg === "--timeout") {
+      globalOpts[arg] = argv[i + 1] || "";
+      i += 2;
+      continue;
+    }
+    if (arg === "-p") {
+      globalOpts["--port"] = argv[i + 1] || "";
+      i += 2;
+      continue;
+    }
+    if (arg === "-j") {
+      globalOpts["--json"] = argv[i + 1] || "";
+      i += 2;
+      continue;
+    }
+    if (arg === "--json-stdin") {
+      globalOpts["--json-stdin"] = "true";
+      i++;
+      continue;
+    }
+    if (arg === "-h" || arg === "--help") {
+      globalOpts["--help"] = "true";
+      i++;
+      continue;
+    }
+    if (arg === "-V" || arg === "--version") {
+      globalOpts["--version"] = "true";
+      i++;
+      continue;
+    }
+    break;
+  }
+  const command = argv[i] || "";
+  const rest = argv.slice(i + 1);
+  if (globalOpts["--help"] || command === "help") {
+    const helpCmd = command === "help" ? rest[0] : void 0;
+    printHelp(helpCmd);
+    process.exit(0);
+  }
+  if (globalOpts["--version"] || command === "--version") {
+    const pkg = require_package();
+    console.log(`tgebrowser v${pkg.version}`);
+    process.exit(0);
+  }
+  if (!command || !COMMANDS[command]) {
+    printHelp();
+    process.exit(1);
+  }
+  let args = {};
+  if (globalOpts["--json"]) {
+    try {
+      args = JSON.parse(globalOpts["--json"]);
+    } catch {
+      throw new Error("Invalid JSON in --json");
+    }
+  } else if (globalOpts["--json-stdin"]) {
+    const input = require("fs").readFileSync(0, "utf-8");
+    try {
+      args = JSON.parse(input);
+    } catch {
+      throw new Error("Invalid JSON from stdin");
+    }
+  } else if (rest.length > 0) {
+    const first = rest[0].trim();
+    if (first.startsWith("{")) {
+      try {
+        args = JSON.parse(first);
+      } catch {
+        throw new Error("Invalid JSON argument");
+      }
+    } else if (first.includes("=")) {
+      for (const arg of rest) {
+        const eqIdx = arg.indexOf("=");
+        if (eqIdx > 0) {
+          args[arg.slice(0, eqIdx)] = parseValue(arg.slice(eqIdx + 1));
+        }
+      }
+    } else if (COMMANDS[command].shorthandKey) {
+      args[COMMANDS[command].shorthandKey] = parseValue(first);
+    } else {
+      for (const arg of rest) {
+        const eqIdx = arg.indexOf("=");
+        if (eqIdx > 0) {
+          args[arg.slice(0, eqIdx)] = parseValue(arg.slice(eqIdx + 1));
+        }
+      }
+    }
+  }
+  return { command, args, globalOpts };
+}
+function printHelp(cmd) {
+  if (cmd) {
+    const def = COMMANDS[cmd];
+    if (!def) {
+      console.error(`Unknown command: ${cmd}`);
+      process.exit(1);
+    }
+    console.log(`Command: ${cmd}`);
+    console.log(`Description: ${def.desc}`);
+    console.log();
+    console.log("Usage:");
+    console.log(`  tgebrowser ${cmd} [key=value ...]`);
+    console.log(`  tgebrowser ${cmd} --json '{...}'`);
+    return;
+  }
+  const categories = [
+    { name: "Browser Environment", cmds: ["env-list", "env-open-list", "env-create", "env-update", "env-delete", "env-delete-batch", "env-detail", "get-cookies", "update-cookie", "env-ua", "env-fingerprint", "env-mobile-devices", "batch-update"] },
+    { name: "Browser Control", cmds: ["start-browser", "stop-browser", "stop-all-browsers", "browser-active"] },
+    { name: "Cache", cmds: ["clear-cache", "clear-cache-batch"] },
+    { name: "Groups", cmds: ["group-list", "group-create", "group-update", "group-delete"] },
+    { name: "Proxies", cmds: ["proxy-list", "proxy-create", "proxy-update", "proxy-delete"] },
+    { name: "System", cmds: ["check-status", "window-sort", "window-sort-custom", "window-hide", "window-show"] }
+  ];
+  console.log("TgeBrowser CLI - Command line tool for TgeBrowser Local API");
+  console.log();
+  console.log("Usage:");
+  console.log("  tgebrowser [options] <command> [key=value ...]");
+  console.log("  tgebrowser [options] <command> --json '{...}'");
+  console.log("  tgebrowser [options] <command> --json-stdin");
+  console.log();
+  console.log("Options:");
+  console.log("  -p, --port <n>             Local API port");
+  console.log("      --api-key <key>        Local API authentication key");
+  console.log("      --timeout <seconds>    HTTP timeout in seconds (default: 30)");
+  console.log("  -j, --json <json>          JSON request body");
+  console.log("      --json-stdin           Read JSON from stdin");
+  console.log("  -h, --help                 Show help");
+  console.log("  -V, --version              Show version");
+  console.log();
+  for (const cat of categories) {
+    console.log(`  ${cat.name}:`);
+    for (const cmd2 of cat.cmds) {
+      const def = COMMANDS[cmd2];
+      if (def) console.log(`    ${cmd2.padEnd(24)} ${def.desc}`);
+    }
+    console.log();
+  }
+  console.log("Examples:");
+  console.log("  tgebrowser env-list");
+  console.log("  tgebrowser env-list current=1 pageSize=20");
+  console.log("  tgebrowser start-browser envId=1");
+  console.log(`  tgebrowser env-create --json '{"browserName":"test","fingerprint":{"os":"Windows"}}'`);
+  console.log('  tgebrowser --api-key "your-key" env-list');
+  console.log("  tgebrowser help start-browser");
+}
+async function main() {
+  const argv = process.argv.slice(2);
+  if (argv.length === 0) {
+    printHelp();
+    return;
+  }
+  const { command, args, globalOpts } = parseArgs2(argv);
+  if (globalOpts["--port"]) process.env.TGEBROWSER_PORT = globalOpts["--port"];
+  if (globalOpts["--api-key"]) process.env.TGEBROWSER_API_KEY = globalOpts["--api-key"];
+  const handler = COMMANDS[command].handler;
+  const result = await handler(args);
+  const out = typeof result === "string" ? result : JSON.stringify(result, null, 2);
+  process.stdout.write(out + "\n");
+}
+main().catch((err) => {
+  const msg = err instanceof Error ? err.message : String(err);
+  process.stderr.write(msg + "\n");
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@tgebrowser/cli",
+  "version": "1.1.0",
+  "main": "build/cli.js",
+  "type": "commonjs",
+  "bin": {
+    "tgebrowser": "./build/cli.js",
+    "tge-cli": "./build/cli.js"
+  },
+  "scripts": {
+    "build": "tsup",
+    "tgebrowser": "node build/cli.js"
+  },
+  "dependencies": {
+    "axios": "^1.8.4",
+    "playwright": "^1.51.1",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@tgebrowser/core": "workspace:*",
+    "@types/node": "^22.13.13",
+    "typescript": "^5.8.2",
+    "tsup": "^8.5.1"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "build"
+  ],
+  "description": "TgeBrowser Local API CLI and Cursor/agent skill for browser environments, groups, proxies.",
+  "keywords": ["tgebrowser", "browser", "cursor", "skill", "agent-skills", "automation"],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tgebrowser/tgebrowser.git",
+    "directory": "packages/tgebrowser-cli"
+  },
+  "bugs": { "url": "https://github.com/tgebrowser/tgebrowser/issues" },
+  "homepage": "https://github.com/tgebrowser/tgebrowser/tree/main/packages/tgebrowser#readme"
+}