adspower-browser 2.0.2 → 2.0.4

package/README.MD

@@ -61,6 +61,61 @@ ads start
    - `ads open-browser '{"profile_id":"abc123","launch_args":"..."}'`
    - Commands with no params: omit `<arg>` or use `'{}'`.
 
+## Shell Tab Completion
+
+The CLI supports prefix tab completion for subcommands and common flags (`-k`, `-p`, etc.) via [`@bomb.sh/tab`](https://bomb.sh/docs/tab/). Enable it once in your shell:
+
+**macOS — zsh**
+
+```bash
+ads complete zsh > ~/.ads-completion.zsh
+echo 'source ~/.ads-completion.zsh' >> ~/.zshrc
+source ~/.ads-completion.zsh
+```
+
+**Linux — bash**
+
+```bash
+ads complete bash > ~/.ads-completion.bash
+echo 'source ~/.ads-completion.bash' >> ~/.bashrc
+source ~/.ads-completion.bash
+```
+
+On Linux login shells, ensure `~/.bashrc` is sourced (e.g. from `~/.bash_profile`).
+
+**Linux — zsh**
+
+```bash
+ads complete zsh > ~/.ads-completion.zsh
+echo 'source ~/.ads-completion.zsh' >> ~/.zshrc
+source ~/.ads-completion.zsh
+```
+
+**Windows — PowerShell**
+
+```powershell
+ads complete powershell > $HOME\.ads-completion.ps1
+if (-not (Test-Path $PROFILE)) { New-Item -Path $PROFILE -ItemType File -Force }
+Add-Content $PROFILE '. $HOME\.ads-completion.ps1'
+. $HOME\.ads-completion.ps1
+```
+
+**Windows — Git Bash**
+
+```bash
+ads complete bash > ~/.ads-completion.bash
+echo 'source ~/.ads-completion.bash' >> ~/.bashrc
+source ~/.ads-completion.bash
+```
+
+After setup on zsh/bash, `ads`, `adspower`, and `adspower-browser` share the same completions. On PowerShell and Git Bash, use `ads` for tab completion:
+
+```bash
+ads <Tab><Tab>      # list subcommands
+ads open-<Tab>      # complete to open-browser
+ads sta<Tab>        # complete to start / status
+```
+
 ## Essential Commands With CLI
 
 You can use `ads -h` or `ads <command> -h` to view the specific parameters.
@@ -149,4 +204,14 @@ ads download-kernel '{"kernel_type":"Chrome","kernel_version":"..."}'   # kernel
 
 ```bash
 ads update-patch '{"version_type":"stable"}'  # version_type?:stable|beta
+```
+
+## Use CLI in Docker
+
+copy the [`docker-compose.yml`](./docker-compose.yml)
+
+```bash
+docker-compose -f ./docker-compose.yml up -d
+
+docker-compose exec adspower-cli /bin/bash
 ```

package/cli/core/winHideChildProcess.js

@@ -0,0 +1,47 @@
+"use strict";
+
+// src/core/winHideChildProcess.js
+if (process.platform !== "win32") {
+  return;
+}
+var cp = require("child_process");
+function withWindowsHide(options) {
+  if (typeof options === "object" && options !== null && !Array.isArray(options)) {
+    if (options.windowsHide === false) {
+      return options;
+    }
+    return { ...options, windowsHide: true };
+  }
+  return { windowsHide: true };
+}
+function normalizeExecArgs(options, callback) {
+  if (typeof options === "function") {
+    return { options: { windowsHide: true }, callback: options };
+  }
+  return { options: withWindowsHide(options || {}), callback };
+}
+function normalizeSpawnArgs(args, options) {
+  if (Array.isArray(args)) {
+    return { args, options: withWindowsHide(options || {}) };
+  }
+  return { args: [], options: withWindowsHide(args || {}) };
+}
+var origExec = cp.exec.bind(cp);
+cp.exec = function exec(cmd, options, callback) {
+  const { options: opts, callback: cb } = normalizeExecArgs(options, callback);
+  return origExec(cmd, opts, cb);
+};
+var origExecSync = cp.execSync.bind(cp);
+cp.execSync = function execSync(cmd, options) {
+  return origExecSync(cmd, withWindowsHide(options || {}));
+};
+var origSpawn = cp.spawn.bind(cp);
+cp.spawn = function spawn(command, args, options) {
+  const normalized = normalizeSpawnArgs(args, options);
+  return origSpawn(command, normalized.args, normalized.options);
+};
+var origSpawnSync = cp.spawnSync.bind(cp);
+cp.spawnSync = function spawnSync(command, args, options) {
+  const normalized = normalizeSpawnArgs(args, options);
+  return origSpawnSync(command, normalized.args, normalized.options);
+};

package/cli/index.js

@@ -24,7 +24,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/index.ts
-var import_commander = require("commander");
+var import_commander2 = require("commander");
 
 // src/store/index.ts
 var Store = class {
@@ -93,6 +93,7 @@ var Store = class {
 var store = new Store();
 
 // src/core/start.ts
+var fs2 = __toESM(require("fs"));
 var path2 = __toESM(require("path"));
 var import_node_child_process2 = require("child_process");
 
@@ -105,7 +106,8 @@ var util = __toESM(require("util"));
 var import_node_child_process = require("child_process");
 var import_colors = require("colors");
 var import_fs_extra2 = require("fs-extra2");
-var VERSION = "1.0.0";
+var VERSION = (0, import_fs_extra2.readJsonSync)(path.join(__dirname, "../package.json")).version;
+var VERSION_FILE = "1.0.0";
 var toTerminalLink = (url, label) => {
   const text = label || url;
   return `\x1B]8;;${url}\x07${text}\x1B]8;;\x07`;
@@ -133,7 +135,7 @@ var browsersKill = async () => {
 };
 var taskKillBrowser = () => new Promise((resolve) => {
   const cmd = ["linux", "darwin"].includes(process.platform) ? 'pkill -u `whoami` -f "SunBrowser"' : "taskkill -PID SunBrowser.exe";
-  (0, import_node_child_process.exec)(cmd, (err) => {
+  (0, import_node_child_process.exec)(cmd, { windowsHide: true }, (err) => {
     if (err) {
     }
     resolve();
@@ -141,7 +143,7 @@ var taskKillBrowser = () => new Promise((resolve) => {
 });
 var taskKillFlowser = () => new Promise((resolve) => {
   const cmd = ["linux", "darwin"].includes(process.platform) ? 'pkill -u `whoami` -f "FlowerBrowser"' : "taskkill -PID FlowerBrowser.exe";
-  (0, import_node_child_process.exec)(cmd, (err) => {
+  (0, import_node_child_process.exec)(cmd, { windowsHide: true }, (err) => {
     if (err) {
     }
     resolve();
@@ -158,7 +160,7 @@ var getPidFileDir = () => {
   return dir;
 };
 var pidFileName = () => {
-  const md5 = crypto.createHash("md5").update(VERSION).digest("hex");
+  const md5 = crypto.createHash("md5").update(VERSION_FILE).digest("hex");
   return md5;
 };
 var writePidFile = (config2) => {
@@ -183,6 +185,7 @@ var isRunning = (pid) => {
     if (pid) {
       (0, import_node_child_process.exec)(
         util.format(process.platform === "win32" ? 'tasklist /fi "PID eq %s" | findstr /i "node.exe"' : 'ps -f -p %s | grep "node"', pid),
+        { windowsHide: true },
         function(err, stdout, stderr) {
           resolve(!err && !!stdout.toString().trim());
         }
@@ -285,45 +288,18 @@ var initSqlite3 = () => {
     logSuccess(`[i] SQLite file initialized successfully!`);
   }
 };
-var renderKernelProgress = (result) => {
-  const status = result.status || "pending";
-  const progress = ["completed", "installing"].includes(status) ? 100 : Math.max(0, Math.min(100, Number(result.progress) || 0));
-  if (!process.stdout.isTTY) {
-    logInfo(`Kernel progress: ${progress}% [${status}]`);
-    return;
-  }
-  const width = 30;
-  const filled = Math.round(progress / 100 * width);
-  const bar = `${"=".repeat(filled)}${"-".repeat(width - filled)}`;
-  process.stdout.write(`\r[${bar}] ${progress.toFixed(0).padStart(3, " ")}% ${status}     `);
-};
-var finishKernelProgress = () => {
-  if (process.stdout.isTTY) {
-    process.stdout.write("\n");
+
+// src/core/start.ts
+var getRuntimeExecArgv = () => {
+  if (process.platform !== "win32") {
+    return [];
   }
-};
-var trackKernelDownload = async (fnc, args) => {
-  while (true) {
-    const result = await fnc(args);
-    try {
-      const resultJson = JSON.parse(result.replace("Kernel download/update status: ", ""));
-      if (resultJson && resultJson.status && ["pending", "downloading", "completed", "installing", "failed"].includes(resultJson.status)) {
-        renderKernelProgress(resultJson);
-        if (["completed", "failed"].includes(resultJson.status)) {
-          finishKernelProgress();
-          return result;
-        }
-        await sleepTime(3e3);
-      } else {
-        return result;
-      }
-    } catch (error) {
-      return result;
-    }
+  const preload = path2.join(__dirname, "core/winHideChildProcess.js");
+  if (!fs2.existsSync(preload)) {
+    return [];
   }
+  return ["--require", preload];
 };
-
-// src/core/start.ts
 var getEnv = () => {
   const env = {
     ...process.env,
@@ -364,7 +340,8 @@ var startChild = (type) => {
         detached: true,
         windowsHide: true,
         // 隐藏子进程的控制台窗口
-        stdio: ["ignore", "ignore", "ignore", "ipc"]
+        stdio: ["ignore", "ignore", "ignore", "ipc"],
+        execArgv: getRuntimeExecArgv()
       };
       child = (0, import_node_child_process2.fork)(mainJs, [], forkOptions);
       ensureBrowserPath();
@@ -547,9 +524,6 @@ var getChildStatus = async () => {
   }
 };
 
-// src/index.ts
-var import_colors2 = require("colors");
-
 // ../core/src/constants/api.ts
 var import_axios = __toESM(require("axios"));
 
@@ -1401,39 +1375,33 @@ var browserHandlers = {
     const requestBody = buildRequestBodyFor("open-browser", resolvedParams);
     const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.START_BROWSER}`, requestBody);
     if (response.data.code === 0) {
-      const autoNote = didAutoSetHeadless ? "\n\u5DF2\u6839\u636E\u8FD0\u884C\u73AF\u5883\u81EA\u52A8\u4F7F\u7528 headless=1\uFF08\u65E0\u53EF\u7528\u56FE\u5F62\u4F1A\u8BDD\uFF09\u3002\nAuto-set headless=1 (no graphical session detected)." : "";
-      return `Browser opened successfully with: ${Object.entries(response.data.data).map(([key, value]) => {
-        if (value && typeof value === "object") {
-          return Object.entries(value).map(([key2, value2]) => `ws.${key2}: ${value2}`).join("\n");
-        }
-        return `${key}: ${value}`;
-      }).join("\n")}${autoNote}`;
+      return JSON.stringify(response.data.data, null, 2);
     }
-    throw new Error(`Failed to open browser: ${response.data.msg}`);
+    throw new Error(response.data.msg);
   },
   async closeBrowser(params) {
     const requestBody = buildRequestBodyFor("close-browser", params);
     const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.CLOSE_BROWSER}`, requestBody);
     if (response.data.code === 0) {
-      return "Browser closed successfully";
+      return JSON.stringify(response.data.data, null, 2);
     }
-    throw new Error(`Failed to close browser: ${response.data.msg}`);
+    throw new Error(response.data.msg);
   },
   async createBrowser(params) {
     const requestBody = buildRequestBodyFor("create-browser", params);
     const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.CREATE_BROWSER}`, requestBody);
     if (response.data.code === 0) {
-      return `Browser created successfully with: ${Object.entries(response.data.data).map(([key, value]) => `${key}: ${value}`).join("\n")}`;
+      return JSON.stringify(response.data.data, null, 2);
     }
-    throw new Error(`Failed to create browser: ${response.data.msg}`);
+    throw new Error(response.data.msg);
   },
   async updateBrowser(params) {
     const requestBody = buildRequestBodyFor("update-browser", params);
     const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.UPDATE_BROWSER}`, requestBody);
     if (response.data.code === 0) {
-      return `Browser updated successfully with: ${Object.entries(response.data.data || {}).map(([key, value]) => `${key}: ${value}`).join("\n")}`;
+      return JSON.stringify(response.data.data, null, 2);
     }
-    throw new Error(`Failed to update browser: ${response.data.msg}`);
+    throw new Error(response.data.msg);
   },
   async deleteBrowser(params) {
     const response = await getApiClient().post(
@@ -1441,64 +1409,63 @@ var browserHandlers = {
       buildRequestBodyFor("delete-browser", params)
     );
     if (response.data.code === 0) {
-      return `Browsers deleted successfully: ${params.profile_id.join(", ")}`;
+      return JSON.stringify(response.data.data, null, 2);
     }
-    throw new Error(`Failed to delete browsers: ${response.data.msg}`);
+    throw new Error(response.data.msg);
   },
   async getBrowserList(params) {
     const requestBody = buildRequestBodyFor("get-browser-list", params);
     const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.GET_BROWSER_LIST}`, requestBody);
     if (response.data.code === 0) {
-      return `Browser list: ${JSON.stringify(response.data.data.list, null, 2)}`;
+      return JSON.stringify(response.data.data, null, 2);
     }
-    throw new Error(`Failed to get browser list: ${response.data.msg}`);
+    throw new Error(response.data.msg);
   },
   async getOpenedBrowser() {
     const response = await getApiClient().get(`${getLocalApiBase()}${API_ENDPOINTS.GET_OPENED_BROWSER}`);
     if (response.data.code === 0) {
-      return `Opened browser list: ${JSON.stringify(response.data.data.list, null, 2)}`;
+      return JSON.stringify(response.data.data, null, 2);
     }
-    throw new Error(`Failed to get opened browsers: ${response.data.msg}`);
+    throw new Error(response.data.msg);
   },
   async moveBrowser(params) {
     const requestBody = buildRequestBodyFor("move-browser", params);
     const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.MOVE_BROWSER}`, requestBody);
-    const { group_id, user_ids } = params;
     if (response.data.code === 0) {
-      return `Browsers moved successfully to group ${group_id}: ${user_ids.join(", ")}`;
+      return JSON.stringify(response.data.data, null, 2);
     }
-    throw new Error(`Failed to move browsers: ${response.data.msg}`);
+    throw new Error(response.data.msg);
   },
   async getProfileCookies(params) {
     const query = buildQueryParamsFor("get-profile-cookies", params);
     const response = await getApiClient().get(`${getLocalApiBase()}${API_ENDPOINTS.GET_PROFILE_COOKIES}`, { params: query });
     if (response.data.code === 0) {
-      return `Profile cookies: ${JSON.stringify(response.data.data, null, 2)}`;
+      return JSON.stringify(response.data.data, null, 2);
     }
-    throw new Error(`Failed to get profile cookies: ${response.data.msg}`);
+    throw new Error(response.data.msg);
   },
   async getProfileUa(params) {
     const requestBody = buildRequestBodyFor("get-profile-ua", params);
     const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.GET_PROFILE_UA}`, requestBody);
     if (response.data.code === 0) {
-      return `Profile User-Agent: ${JSON.stringify(response.data.data, null, 2)}`;
+      return JSON.stringify(response.data.data, null, 2);
     }
-    throw new Error(`Failed to get profile User-Agent: ${response.data.msg}`);
+    throw new Error(response.data.msg);
   },
   async closeAllProfiles(_params) {
     const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.CLOSE_ALL_PROFILES}`, {});
-    if (response.data.code === 0) {
-      return "All profiles closed successfully";
+    if (response.data.data.code === 0) {
+      return JSON.stringify(response.data.data, null, 2);
     }
-    throw new Error(`Failed to close all profiles: ${response.data.msg}`);
+    throw new Error(response.data.data.msg);
   },
   async newFingerprint(params) {
     const requestBody = buildRequestBodyFor("new-fingerprint", params);
     const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.NEW_FINGERPRINT}`, requestBody);
     if (response.data.code === 0) {
-      return `New fingerprint created: ${JSON.stringify(response.data.data, null, 2)}`;
+      return JSON.stringify(response.data.data, null, 2);
     }
-    throw new Error(`Failed to create new fingerprint: ${response.data.msg}`);
+    throw new Error(response.data.msg);
   },
   async deleteCacheV2(params) {
     const response = await getApiClient().post(
@@ -1506,33 +1473,33 @@ var browserHandlers = {
       buildRequestBodyFor("delete-cache-v2", params)
     );
     if (response.data.code === 0) {
-      return `Cache deleted successfully for profiles: ${params.profile_id.join(", ")}`;
+      return JSON.stringify(response.data.data, null, 2);
     }
-    throw new Error(`Failed to delete cache: ${response.data.msg}`);
+    throw new Error(response.data.msg);
   },
   async shareProfile(params) {
     const requestBody = buildRequestBodyFor("share-profile", params);
     const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.SHARE_PROFILE}`, requestBody);
     if (response.data.code === 0) {
-      return `Profiles shared successfully: ${params.profile_id.join(", ")}`;
+      return JSON.stringify(response.data.data, null, 2);
     }
-    throw new Error(`Failed to share profiles: ${response.data.msg}`);
+    throw new Error(response.data.msg);
   },
   async getBrowserActive(params) {
     const query = buildQueryParamsFor("get-browser-active", params);
     const response = await getApiClient().get(`${getLocalApiBase()}${API_ENDPOINTS.GET_BROWSER_ACTIVE}`, { params: query });
     if (response.data.code === 0) {
-      return `Browser active info: ${JSON.stringify(response.data.data, null, 2)}`;
+      return JSON.stringify(response.data.data, null, 2);
     }
-    throw new Error(`Failed to get browser active: ${response.data.msg}`);
+    throw new Error(response.data.msg);
   },
   async getCloudActive(params) {
     const requestBody = buildRequestBodyFor("get-cloud-active", params);
     const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.GET_CLOUD_ACTIVE}`, requestBody);
     if (response.data.code === 0) {
-      return `Cloud active browsers: ${JSON.stringify(response.data.data, null, 2)}`;
+      return JSON.stringify(response.data.data, null, 2);
     }
-    throw new Error(`Failed to get cloud active browsers: ${response.data.msg}`);
+    throw new Error(response.data.msg);
   }
 };
 
@@ -1541,28 +1508,26 @@ var groupHandlers = {
   async createGroup(params) {
     const requestBody = buildRequestBodyFor("create-group", params);
     const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.CREATE_GROUP}`, requestBody);
-    const { group_name, remark } = params;
     if (response.data.code === 0) {
-      return `Group created successfully with name: ${group_name}${remark ? `, remark: ${remark}` : ""}`;
+      return JSON.stringify(response.data.data, null, 2);
     }
-    throw new Error(`Failed to create group: ${response.data.msg}`);
+    throw new Error(response.data.msg);
   },
   async updateGroup(params) {
     const requestBody = buildRequestBodyFor("update-group", params);
     const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.UPDATE_GROUP}`, requestBody);
-    const { group_id, group_name, remark } = params;
     if (response.data.code === 0) {
-      return `Group updated successfully with id: ${group_id}, name: ${group_name}${remark !== void 0 ? `, remark: ${remark === null ? "(cleared)" : remark}` : ""}`;
+      return JSON.stringify(response.data.data, null, 2);
     }
-    throw new Error(`Failed to update group: ${response.data.msg}`);
+    throw new Error(response.data.msg);
   },
   async getGroupList(params) {
     const query = buildQueryParamsFor("get-group-list", params);
     const response = await getApiClient().get(`${getLocalApiBase()}${API_ENDPOINTS.GET_GROUP_LIST}`, { params: query });
     if (response.data.code === 0) {
-      return `Group list: ${JSON.stringify(response.data.data.list, null, 2)}`;
+      return JSON.stringify(response.data.data, null, 2);
     }
-    throw new Error(`Failed to get group list: ${response.data.msg}`);
+    throw new Error(response.data.msg);
   }
 };
 
@@ -1570,12 +1535,12 @@ var groupHandlers = {
 var applicationHandlers = {
   async checkStatus() {
     const response = await getApiClient().get(`${getLocalApiBase()}${API_ENDPOINTS.STATUS}`);
-    return `Connection status: ${JSON.stringify(response.data, null, 2)}`;
+    return JSON.stringify(response.data, null, 2);
   },
   async getApplicationList(params) {
     const query = buildQueryParamsFor("get-application-list", params);
     const response = await getApiClient().get(`${getLocalApiBase()}${API_ENDPOINTS.GET_APPLICATION_LIST}`, { params: query });
-    return `Application list: ${JSON.stringify(response.data.data.list, null, 2)}`;
+    return JSON.stringify(response.data.data, null, 2);
   }
 };
 
@@ -1607,25 +1572,25 @@ var proxyHandlers = {
     const requestBody = params.map((proxy) => buildCreateProxyRequestBody(proxy));
     const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.CREATE_PROXY}`, requestBody);
     if (response.data.code === 0) {
-      return `Proxy created successfully with: ${Object.entries(response.data.data || {}).map(([key, value]) => `${key}: ${value}`).join("\n")}`;
+      return JSON.stringify(response.data.data, null, 2);
     }
-    throw new Error(`Failed to create proxy: ${response.data.msg}`);
+    throw new Error(response.data.msg);
   },
   async updateProxy(params) {
     const requestBody = buildRequestBodyFor("update-proxy", params);
     const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.UPDATE_PROXY}`, requestBody);
     if (response.data.code === 0) {
-      return `Proxy updated successfully with: ${Object.entries(response.data.data || {}).map(([key, value]) => `${key}: ${value}`).join("\n")}`;
+      return JSON.stringify(response.data.data, null, 2);
     }
-    throw new Error(`Failed to update proxy: ${response.data.msg}`);
+    throw new Error(response.data.msg);
   },
   async getProxyList(params) {
     const requestBody = buildRequestBodyFor("get-proxy-list", params);
     const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.GET_PROXY_LIST}`, requestBody);
     if (response.data.code === 0) {
-      return `Proxy list: ${JSON.stringify(response.data.data.list || response.data.data, null, 2)}`;
+      return JSON.stringify(response.data.data, null, 2);
     }
-    throw new Error(`Failed to get proxy list: ${response.data.msg}`);
+    throw new Error(response.data.msg);
   },
   async deleteProxy(params) {
     const response = await getApiClient().post(
@@ -1634,9 +1599,9 @@ var proxyHandlers = {
     );
     const { proxy_id } = params;
     if (response.data.code === 0) {
-      return `Proxies deleted successfully: ${proxy_id.join(", ")}`;
+      return JSON.stringify(response.data.data, null, 2);
     }
-    throw new Error(`Failed to delete proxies: ${response.data.msg}`);
+    throw new Error(response.data.msg);
   }
 };
 
@@ -1656,30 +1621,30 @@ var tagHandlers = {
     }
     const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.GET_TAG_LIST}`, requestBody);
     if (response.data.code === 0) {
-      return `Tag list: ${JSON.stringify(response.data.data.list || response.data.data, null, 2)}`;
+      return JSON.stringify(response.data.data, null, 2);
     }
-    throw new Error(`Failed to get tag list: ${response.data.msg}`);
+    throw new Error(response.data.msg);
   },
   async createTag({ tags }) {
     const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.CREATE_TAG}`, { tags });
     if (response.data.code === 0) {
-      return `Tags created successfully: ${JSON.stringify(response.data.data, null, 2)}`;
+      return JSON.stringify(response.data.data, null, 2);
     }
-    throw new Error(`Failed to create tags: ${response.data.msg}`);
+    throw new Error(response.data.msg);
   },
   async updateTag({ tags }) {
     const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.UPDATE_TAG}`, { tags });
     if (response.data.code === 0) {
-      return `Tags updated successfully: ${JSON.stringify(response.data.data, null, 2)}`;
+      return JSON.stringify(response.data.data, null, 2);
     }
-    throw new Error(`Failed to update tags: ${response.data.msg}`);
+    throw new Error(response.data.msg);
   },
   async deleteTag({ ids }) {
     const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.DELETE_TAG}`, { ids });
     if (response.data.code === 0) {
-      return `Tags deleted successfully: ${ids.join(", ")}`;
+      return JSON.stringify(response.data.data, null, 2);
     }
-    throw new Error(`Failed to delete tags: ${response.data.msg}`);
+    throw new Error(response.data.msg);
   }
 };
 
@@ -1748,9 +1713,9 @@ var kernelHandlers = {
       kernel_version
     });
     if (response.data.code === 0) {
-      return `Kernel download/update status: ${JSON.stringify(response.data.data, null, 2)}`;
+      return JSON.stringify(response.data.data, null, 2);
     }
-    throw new Error(`Failed to download/update kernel: ${response.data.msg}`);
+    throw new Error(response.data.msg);
   },
   async getKernelList({ kernel_type }) {
     const params = new URLSearchParams();
@@ -1759,9 +1724,9 @@ var kernelHandlers = {
     }
     const response = await getApiClient().get(`${getLocalApiBase()}${API_ENDPOINTS.GET_KERNEL_LIST}`, { params });
     if (response.data.code === 0) {
-      return `Kernel list: ${JSON.stringify(response.data.data.list || response.data.data, null, 2)}`;
+      return JSON.stringify(response.data.data, null, 2);
     }
-    throw new Error(`Failed to get kernel list: ${response.data.msg}`);
+    throw new Error(response.data.msg);
   }
 };
 
@@ -1774,9 +1739,9 @@ var patchHandlers = {
     }
     const response = await getApiClient().post(`${getLocalApiBase()}${API_ENDPOINTS.UPDATE_PATCH}`, requestBody);
     if (response.data.code === 0) {
-      return `Patch update status: ${JSON.stringify(response.data.data, null, 2)}, message: ${response.data.msg}`;
+      return JSON.stringify(response.data.data, null, 2);
     }
-    throw new Error(`Failed to update patch: ${response.data.msg}`);
+    throw new Error(response.data.msg);
   }
 };
 
@@ -2537,167 +2502,258 @@ var schemas = {
 };
 
 // src/cli.ts
+function formatJsonValueForHelp(value, indent) {
+  const pad = "  ".repeat(indent);
+  const childPad = "  ".repeat(indent + 1);
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return "[]";
+    }
+    const lines2 = value.map((item) => `${childPad}${formatJsonValueForHelp(item, indent + 1)}`);
+    return `[
+${lines2.join(",\n")}
+${pad}]`;
+  }
+  const entries = Object.entries(value);
+  if (entries.length === 0) {
+    return "{}";
+  }
+  const lines = entries.map(([key, val]) => {
+    if (["enum", "oneOf", "required"].includes(key) && Array.isArray(val)) {
+      return `${childPad}${JSON.stringify(key)}: ${JSON.stringify(val)}`;
+    }
+    return `${childPad}${JSON.stringify(key)}: ${formatJsonValueForHelp(val, indent + 1)}`;
+  });
+  return `{
+${lines.join(",\n")}
+${pad}}`;
+}
+function formatSchemaPropertiesForHelp(properties) {
+  return formatJsonValueForHelp(properties, 0);
+}
+function schemaParamsDescription(schema, type) {
+  let paramStr = "view help: https://documenter.getpostman.com/view/45822952/2sB2x5JDXn\n";
+  switch (type) {
+    case "open-browser":
+      paramStr += `use cmd: "ads open-browser <profile_id>"
+or use params: "ads open-browser '{"profile_id":"..."}' "
+`;
+      break;
+    case "close-browser":
+      paramStr += `use cmd: "ads close-browser <profile_id>"
+or use params: "ads close-browser '{"profile_id":"..."}' "
+`;
+      break;
+    case "get-profile-cookies":
+      paramStr += `use cmd: "ads get-profile-cookies <profile_id>"
+or use params: "ads get-profile-cookies '{"profile_id":"..."}' "
+`;
+      break;
+    case "get-browser-active":
+      paramStr += `use cmd: "ads get-browser-active <profile_id>"
+or use params: "ads get-browser-active '{"profile_id":"..."}' "
+`;
+      break;
+  }
+  const _str = formatSchemaPropertiesForHelp(schema.toJSONSchema().properties);
+  return paramStr + _str;
+}
 var STATELESS_HANDLERS = {
   "open-browser": {
     fn: browserHandlers.openBrowser,
     description: buildCliCommandDescription(
       "open-browser",
       "Open the browser, both environment and profile mean browser"
-    )
+    ),
+    paramsDescription: schemaParamsDescription(schemas.openBrowserSchema, "open-browser")
   },
   "close-browser": {
     fn: browserHandlers.closeBrowser,
-    description: buildCliCommandDescription("close-browser", "Close the browser")
+    description: buildCliCommandDescription("close-browser", "Close the browser"),
+    paramsDescription: schemaParamsDescription(schemas.closeBrowserSchema, "close-browser")
   },
   "create-browser": {
     fn: browserHandlers.createBrowser,
-    description: buildCliCommandDescription("create-browser", "Create a browser")
+    description: buildCliCommandDescription("create-browser", "Create a browser"),
+    paramsDescription: schemaParamsDescription(schemas.createBrowserSchema, "create-browser")
   },
   "update-browser": {
     fn: browserHandlers.updateBrowser,
-    description: buildCliCommandDescription("update-browser", "Update the browser")
+    description: buildCliCommandDescription("update-browser", "Update the browser"),
+    paramsDescription: schemaParamsDescription(schemas.updateBrowserSchema, "update-browser")
   },
   "delete-browser": {
     fn: browserHandlers.deleteBrowser,
-    description: buildCliCommandDescription("delete-browser", "Delete the browser")
+    description: buildCliCommandDescription("delete-browser", "Delete the browser"),
+    paramsDescription: schemaParamsDescription(schemas.deleteBrowserSchema, "delete-browser")
   },
   "get-browser-list": {
     fn: browserHandlers.getBrowserList,
-    description: buildCliCommandDescription("get-browser-list", "Get the list of browsers")
+    description: buildCliCommandDescription("get-browser-list", "Get the list of browsers"),
+    paramsDescription: schemaParamsDescription(schemas.getBrowserListSchema, "get-browser-list")
   },
   "get-opened-browser": {
     fn: browserHandlers.getOpenedBrowser,
-    description: buildCliCommandDescription("get-opened-browser", "Get the list of opened browsers")
+    description: buildCliCommandDescription("get-opened-browser", "Get the list of opened browsers"),
+    paramsDescription: schemaParamsDescription(schemas.emptySchema, "get-opened-browser")
   },
   "move-browser": {
     fn: browserHandlers.moveBrowser,
-    description: buildCliCommandDescription("move-browser", "Move browsers to a group")
+    description: buildCliCommandDescription("move-browser", "Move browsers to a group"),
+    paramsDescription: schemaParamsDescription(schemas.moveBrowserSchema, "move-browser")
   },
   "get-profile-cookies": {
     fn: browserHandlers.getProfileCookies,
     description: buildCliCommandDescription(
       "get-profile-cookies",
       "Query and return cookies of the specified profile. Only one profile can be queried per request."
-    )
+    ),
+    paramsDescription: schemaParamsDescription(schemas.getProfileCookiesSchema, "get-profile-cookies")
   },
   "get-profile-ua": {
     fn: browserHandlers.getProfileUa,
     description: buildCliCommandDescription(
       "get-profile-ua",
       "Query and return the User-Agent of specified profiles. Up to 10 profiles can be queried per request."
-    )
+    ),
+    paramsDescription: schemaParamsDescription(schemas.getProfileUaSchema, "get-profile-ua")
   },
   "close-all-profiles": {
     fn: browserHandlers.closeAllProfiles,
     description: buildCliCommandDescription(
       "close-all-profiles",
       "Close all opened profiles on the current device"
-    )
+    ),
+    paramsDescription: schemaParamsDescription(schemas.closeAllProfilesSchema, "close-all-profiles")
   },
   "new-fingerprint": {
     fn: browserHandlers.newFingerprint,
     description: buildCliCommandDescription(
       "new-fingerprint",
       "Generate a new fingerprint for specified profiles. Up to 10 profiles are supported per request."
-    )
+    ),
+    paramsDescription: schemaParamsDescription(schemas.newFingerprintSchema, "new-fingerprint")
   },
   "delete-cache-v2": {
     fn: browserHandlers.deleteCacheV2,
     description: buildCliCommandDescription(
       "delete-cache-v2",
       "Clear local cache of specific profiles.For account security, please ensure that there are no open browsers on the device when using this interface."
-    )
+    ),
+    paramsDescription: schemaParamsDescription(schemas.deleteCacheV2Schema, "delete-cache-v2")
   },
   "share-profile": {
     fn: browserHandlers.shareProfile,
     description: buildCliCommandDescription(
       "share-profile",
       "Share profiles via account email or phone number. The maximum number of profiles that can be shared at one time is 200."
-    )
+    ),
+    paramsDescription: schemaParamsDescription(schemas.shareProfileSchema, "share-profile")
   },
   "get-browser-active": {
     fn: browserHandlers.getBrowserActive,
-    description: buildCliCommandDescription("get-browser-active", "Get active browser profile information")
+    description: buildCliCommandDescription("get-browser-active", "Get active browser profile information"),
+    paramsDescription: schemaParamsDescription(schemas.getBrowserActiveSchema, "get-browser-active")
   },
   "get-cloud-active": {
     fn: browserHandlers.getCloudActive,
     description: buildCliCommandDescription(
       "get-cloud-active",
       'Query the status of browser profiles by user_ids, up to 100 profiles per request. If the team has enabled "Multi device mode," specific statuses cannot be retrieved and the response will indicate "Profile not opened."'
-    )
+    ),
+    paramsDescription: schemaParamsDescription(schemas.getCloudActiveSchema, "get-cloud-active")
   },
   "create-group": {
     fn: groupHandlers.createGroup,
-    description: buildCliCommandDescription("create-group", "Create a browser group")
+    description: buildCliCommandDescription("create-group", "Create a browser group"),
+    paramsDescription: schemaParamsDescription(schemas.createGroupSchema, "create-group")
   },
   "update-group": {
     fn: groupHandlers.updateGroup,
-    description: buildCliCommandDescription("update-group", "Update the browser group")
+    description: buildCliCommandDescription("update-group", "Update the browser group"),
+    paramsDescription: schemaParamsDescription(schemas.updateGroupSchema, "update-group")
   },
   "get-group-list": {
     fn: groupHandlers.getGroupList,
-    description: buildCliCommandDescription("get-group-list", "Get the list of groups")
+    description: buildCliCommandDescription("get-group-list", "Get the list of groups"),
+    paramsDescription: schemaParamsDescription(schemas.getGroupListSchema, "get-group-list")
   },
   "check-status": {
     fn: applicationHandlers.checkStatus,
     description: buildCliCommandDescription(
       "check-status",
       "Check the availability of the current device API interface (Connection Status)"
-    )
+    ),
+    paramsDescription: schemaParamsDescription(schemas.emptySchema, "check-status")
   },
   "get-application-list": {
     fn: applicationHandlers.getApplicationList,
     description: buildCliCommandDescription(
       "get-application-list",
       "Get the list of applications (categories)"
-    )
+    ),
+    paramsDescription: schemaParamsDescription(schemas.getApplicationListSchema, "get-application-list")
   },
   "create-proxy": {
     fn: proxyHandlers.createProxy,
-    description: buildCliCommandDescription("create-proxy", "Create the proxy")
+    description: buildCliCommandDescription("create-proxy", "Create the proxy"),
+    paramsDescription: schemaParamsDescription(schemas.createProxySchema, "create-proxy")
   },
   "update-proxy": {
     fn: proxyHandlers.updateProxy,
-    description: buildCliCommandDescription("update-proxy", "Update the proxy")
+    description: buildCliCommandDescription("update-proxy", "Update the proxy"),
+    paramsDescription: schemaParamsDescription(schemas.updateProxySchema, "update-proxy")
   },
   "get-proxy-list": {
     fn: proxyHandlers.getProxyList,
-    description: buildCliCommandDescription("get-proxy-list", "Get the list of proxies")
+    description: buildCliCommandDescription("get-proxy-list", "Get the list of proxies"),
+    paramsDescription: schemaParamsDescription(schemas.getProxyListSchema, "get-proxy-list")
   },
   "delete-proxy": {
     fn: proxyHandlers.deleteProxy,
-    description: buildCliCommandDescription("delete-proxy", "Delete the proxy")
+    description: buildCliCommandDescription("delete-proxy", "Delete the proxy"),
+    paramsDescription: schemaParamsDescription(schemas.deleteProxySchema, "delete-proxy")
   },
   "get-tag-list": {
     fn: tagHandlers.getTagList,
-    description: buildCliCommandDescription("get-tag-list", "Get the list of browser tags")
+    description: buildCliCommandDescription("get-tag-list", "Get the list of browser tags"),
+    paramsDescription: schemaParamsDescription(schemas.getTagListSchema, "get-tag-list")
   },
   "create-tag": {
     fn: tagHandlers.createTag,
-    description: buildCliCommandDescription("create-tag", "Create browser tags (batch supported)")
+    description: buildCliCommandDescription("create-tag", "Create browser tags (batch supported)"),
+    paramsDescription: schemaParamsDescription(schemas.createTagSchema, "create-tag")
   },
   "update-tag": {
     fn: tagHandlers.updateTag,
-    description: buildCliCommandDescription("update-tag", "Update browser tags (batch supported)")
+    description: buildCliCommandDescription("update-tag", "Update browser tags (batch supported)"),
+    paramsDescription: schemaParamsDescription(schemas.updateTagSchema, "update-tag")
   },
   "delete-tag": {
     fn: tagHandlers.deleteTag,
-    description: buildCliCommandDescription("delete-tag", "Delete browser tags")
+    description: buildCliCommandDescription("delete-tag", "Delete browser tags"),
+    paramsDescription: schemaParamsDescription(schemas.deleteTagSchema, "delete-tag")
   },
   "download-kernel": {
     fn: kernelHandlers.downloadKernel,
     description: buildCliCommandDescription(
       "download-kernel",
       "Download or update a browser kernel version"
-    )
+    ),
+    paramsDescription: schemaParamsDescription(schemas.downloadKernelSchema, "download-kernel")
   },
   "get-kernel-list": {
     fn: kernelHandlers.getKernelList,
-    description: buildCliCommandDescription("get-kernel-list", "Get browser kernel list by type or all")
+    description: buildCliCommandDescription("get-kernel-list", "Get browser kernel list by type or all"),
+    paramsDescription: schemaParamsDescription(schemas.getKernelListSchema, "get-kernel-list")
   },
   "update-patch": {
     fn: patchHandlers.updatePatch,
-    description: buildCliCommandDescription("update-patch", "Update AdsPower to latest patch version")
+    description: buildCliCommandDescription("update-patch", "Update AdsPower to latest patch version"),
+    paramsDescription: schemaParamsDescription(schemas.updatePatchSchema, "update-patch")
   }
 };
 var SINGLE_PROFILE_ID_COMMANDS = {
@@ -2765,10 +2821,242 @@ function resolveStartApiKey(optionApiKey, env = process.env) {
   };
 }
 
+// src/completion.ts
+var import_commander = __toESM(require("@bomb.sh/tab/commander"));
+var CLI_BIN_ALIASES = ["ads", "adspower", "adspower-browser"];
+function patchShellCompletionScript(shell, script) {
+  if (shell === "zsh") {
+    return script.replace(/^#compdef .+$/m, `#compdef ${CLI_BIN_ALIASES.join(" ")}`).replace(/^compdef _ads ads$/m, `compdef _ads ${CLI_BIN_ALIASES.join(" ")}`);
+  }
+  if (shell === "bash") {
+    return script.replace(
+      /^complete -F __ads_complete ads$/m,
+      `complete -F __ads_complete ${CLI_BIN_ALIASES.join(" ")}`
+    );
+  }
+  return script;
+}
+function setupShellCompletion(program2) {
+  program2.name("ads");
+  (0, import_commander.default)(program2);
+}
+function isShellCompletionRequest(argv = process.argv) {
+  const completionIndex = argv.indexOf("complete");
+  const dashDashIndex = argv.indexOf("--");
+  return completionIndex !== -1 && dashDashIndex !== -1 && dashDashIndex > completionIndex;
+}
+function wrapShellScriptOutput(shell) {
+  if (shell !== "zsh" && shell !== "bash") {
+    return () => {
+    };
+  }
+  const originalWrite = process.stdout.write.bind(process.stdout);
+  process.stdout.write = ((chunk, encoding, callback) => {
+    const text = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString(typeof encoding === "string" ? encoding : "utf8");
+    const patched = patchShellCompletionScript(shell, text);
+    if (typeof encoding === "function") {
+      return originalWrite(patched, encoding);
+    }
+    return originalWrite(
+      patched,
+      encoding,
+      callback
+    );
+  });
+  return () => {
+    process.stdout.write = originalWrite;
+  };
+}
+
+// src/handleAction.ts
+var readline = __toESM(require("readline/promises"));
+var import_colors2 = require("colors");
+var renderKernelProgress = (result) => {
+  const status = result.status || "pending";
+  const progress = ["completed", "installing"].includes(status) ? 100 : Math.max(0, Math.min(100, Number(result.progress) || 0));
+  if (!process.stdout.isTTY) {
+    logInfo(`Kernel progress: ${progress}% [${status}]`);
+    return;
+  }
+  const width = 30;
+  const filled = Math.round(progress / 100 * width);
+  const bar = `${"=".repeat(filled)}${"-".repeat(width - filled)}`;
+  process.stdout.write(`\r[${bar}] ${progress.toFixed(0).padStart(3, " ")}% ${status}     `);
+};
+var finishKernelProgress = () => {
+  if (process.stdout.isTTY) {
+    process.stdout.write("\n");
+  }
+};
+var trackKernelDownload = async (fnc, args) => {
+  while (true) {
+    const result = await fnc(args);
+    try {
+      const resultJson = JSON.parse(result);
+      if (resultJson && resultJson.status && ["pending", "downloading", "completed", "installing", "failed"].includes(resultJson.status)) {
+        renderKernelProgress(resultJson);
+        if (["completed", "failed"].includes(resultJson.status)) {
+          finishKernelProgress();
+          return result;
+        }
+        await sleepTime(3e3);
+      } else {
+        return result;
+      }
+    } catch (error) {
+      return result;
+    }
+  }
+};
+var handleAction = async (params, options, command, fnc) => {
+  const isRun = await hasRunning(options);
+  if (!isRun) {
+    logError("[!] Adspower runtime is not running");
+    const info = `[i] Please run "${(0, import_colors2.green)("adspower-browser start -k <apiKey>")}" to start the adspower runtime`;
+    console.log(info);
+    return;
+  }
+  const { apiKey, port } = getApiKeyAndPort(options);
+  updateConfig(apiKey, port);
+  const commandName = command.name();
+  const resolved = resolveStatelessCommandArgs(commandName, params);
+  if (!resolved.ok) {
+    logError(resolved.error);
+    return;
+  }
+  const args = resolved.args;
+  logSuccess(`Executing command: ${commandName}, params: ${JSON.stringify(args)}`);
+  const loading = createLoading(`Executing ${commandName}...`);
+  try {
+    if (commandName === "download-kernel") {
+      loading.stop();
+      const result = await trackKernelDownload(fnc, args);
+      const out = typeof result === "string" ? result : JSON.stringify(result, null, 2);
+      logInfo(`
+
+${out}
+
+`);
+    } else {
+      const result = await fnc(args);
+      const out = typeof result === "string" ? result : JSON.stringify(result, null, 2);
+      loading.stop();
+      logInfo(`
+
+${out}
+`);
+      if (commandName === "update-patch" && !out.includes("The client is already on the latest patch version. No update is required")) {
+        await sleepTime(1e3 * 60);
+        await restartChild();
+      }
+      return out;
+    }
+  } catch (error) {
+    loading.stop();
+    const msg = error instanceof Error ? error.message : JSON.stringify(error);
+    logError(`
+${msg}
+`);
+    await handleError(msg, commandName, params);
+  } finally {
+    loading.stop();
+  }
+};
+var handleError = async (msg, commandName, params) => {
+  if (commandName === "open-browser") {
+    if (msg.includes("ready,please to download!")) {
+      const reg = /(SunBrowser|FlowerBrowser) (\d+) is not ready,please to download!/;
+      const match = msg.match(reg);
+      if (match) {
+        const kernelType = match[1] === "FlowerBrowser" ? "Firefox" : "Chrome";
+        const kernelVersion = match[2];
+        if (kernelType && kernelVersion) {
+          const answer = await promptYesNo(`[?] Kernel ${match[1]} ${kernelVersion} is not ready. Download now?`);
+          if (answer === "y") {
+            const _params = { "kernel_type": kernelType, "kernel_version": kernelVersion };
+            await handleAction(
+              JSON.stringify(_params),
+              {},
+              { name: () => "download-kernel" },
+              STATELESS_HANDLERS["download-kernel"].fn
+            );
+            await sleepTime(1e3 * 3);
+            await handleAction(
+              params,
+              {},
+              { name: () => "open-browser" },
+              STATELESS_HANDLERS["open-browser"].fn
+            );
+          }
+        }
+      }
+    }
+  }
+  if (commandName === "close-browser") {
+    if (msg.includes("Profile does not exist")) {
+      const answer = await promptYesNo(`[?] Profile does not exist. Check all opened profiles?`);
+      if (answer === "y") {
+        const result = await handleAction(
+          "{}",
+          {},
+          { name: () => "get-opened-browser" },
+          STATELESS_HANDLERS["get-opened-browser"].fn
+        );
+        if (result) {
+          try {
+            const data = JSON.parse(result);
+            const userIds = data.list.map((item) => item.user_id);
+            if (userIds.length === 1) {
+              const answer2 = await promptYesNo(`[?] Only one opened profile. Close it now?`);
+              if (answer2 === "y") {
+                await handleAction(
+                  `{"profile_id":["${userIds[0]}"]}`,
+                  {},
+                  { name: () => "close-browser" },
+                  STATELESS_HANDLERS["close-browser"].fn
+                );
+              }
+            } else if (userIds.length > 1) {
+              logWarning(`[!] Closeable profiles: ${userIds.join(", ")}`);
+              logWarning(`[!] If you want to close all profiles, please enter "ads close-all-profiles"`);
+            }
+          } catch (error) {
+            console.error(error);
+          }
+        }
+      }
+    }
+  }
+};
+async function promptYesNo(question) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    logWarning("[!] Interactive prompt is unavailable in non-interactive mode.");
+    return null;
+  }
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    while (true) {
+      const answer = (await rl.question(`${question} [y/N]: `)).trim().toLowerCase();
+      if (answer === "y" || answer === "yes") {
+        return "y";
+      }
+      if (answer === "n" || answer === "no" || answer === "") {
+        return "n";
+      }
+      logWarning("[!] Please enter y or n.");
+    }
+  } finally {
+    rl.close();
+  }
+}
+
 // src/index.ts
-var program = new import_commander.Command();
-program.name("adspower-browser").description("CLI and runtime for adspower-browser").version(VERSION);
-program.command("start").description("Start the adspower runtime").option("-k, --api-key <apiKey>", "Set the API key for the adspower runtime").addOption(new import_commander.Option("--base-url <baseUrl>", "Set the base URL for the adspower runtime").hideHelp()).addOption(new import_commander.Option("--node-env <nodeEnv>", "Set the node environment for the adspower runtime").hideHelp()).action(async (options) => {
+var program = new import_commander2.Command();
+program.description("CLI and runtime for adspower-browser").version(VERSION);
+program.command("start").description("Start the adspower runtime").option("-k, --api-key <apiKey>", "Set the API key for the adspower runtime").addOption(new import_commander2.Option("--base-url <baseUrl>", "Set the base URL for the adspower runtime").hideHelp()).addOption(new import_commander2.Option("--node-env <nodeEnv>", "Set the node environment for the adspower runtime").hideHelp()).action(async (options) => {
   const resolvedApiKey = resolveStartApiKey(options.apiKey, process.env);
   if (!resolvedApiKey.ok) {
     logError(resolvedApiKey.error);
@@ -2794,53 +3082,19 @@ program.command("status").description("Get the status of the adspower runtime").
 });
 for (const cmd of Object.keys(STATELESS_HANDLERS)) {
   const fnc = STATELESS_HANDLERS[cmd].fn;
-  program.command(`${cmd} [params]`).description(STATELESS_HANDLERS[cmd].description).option("-k, --api-key <apiKey>", "Set the API key for the adspower runtime").option("-p, --port <port>", "Set the port for the adspower runtime").action(async (params, options, command) => {
-    const isRun = await hasRunning(options);
-    if (!isRun) {
-      logError("[!] Adspower runtime is not running");
-      const info = `[i] Please run "${(0, import_colors2.green)("adspower-browser start -k <apiKey>")}" to start the adspower runtime`;
-      console.log(info);
-      return;
-    }
-    const { apiKey, port } = getApiKeyAndPort(options);
-    updateConfig(apiKey, port);
-    const resolved = resolveStatelessCommandArgs(command.name(), params);
-    if (!resolved.ok) {
-      logError(resolved.error);
-      return;
-    }
-    const args = resolved.args;
-    logSuccess(`Executing command: ${command.name()}, params: ${JSON.stringify(args)}`);
-    const loading = createLoading(`Executing ${command.name()}...`);
-    try {
-      if (command.name() === "download-kernel") {
-        loading.stop();
-        const result = await trackKernelDownload(fnc, args);
-        const out = typeof result === "string" ? result : JSON.stringify(result, null, 2);
-        logInfo(`
-
-${out}
-
-`);
-      } else {
-        const result = await fnc(args);
-        const out = typeof result === "string" ? result : JSON.stringify(result, null, 2);
-        logInfo(`
-
-${out}
-`);
-        if (command.name() === "update-patch" && !out.includes("The client is already on the latest patch version. No update is required")) {
-          loading.stop();
-          await sleepTime(1e3 * 60);
-          await restartChild();
-        }
-      }
-    } finally {
-      loading.stop();
-    }
+  program.command(`${cmd}`).description(STATELESS_HANDLERS[cmd].description).option("-k, --api-key <apiKey>", "Set the API key for the adspower runtime").option("-p, --port <port>", "Set the port for the adspower runtime").argument("[params]", STATELESS_HANDLERS[cmd].paramsDescription).action(async (params, options, command) => {
+    await handleAction(params, options, command, fnc);
   });
 }
-program.parseAsync(process.argv).catch((error) => {
-  console.error(error);
-  process.exit(1);
-});
+setupShellCompletion(program);
+var shellScriptArg = process.argv[2] === "complete" ? process.argv[3] : void 0;
+var restoreStdout = wrapShellScriptOutput(shellScriptArg);
+if (isShellCompletionRequest()) {
+  program.parse(process.argv);
+  restoreStdout();
+} else {
+  program.parseAsync(process.argv).catch((error) => {
+    console.error(error);
+    process.exit(1);
+  }).finally(restoreStdout);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adspower-browser",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "main": "cli/index.js",
   "type": "commonjs",
   "bin": {
@@ -13,12 +13,13 @@
     "adspower": "node cli/index.js"
   },
   "dependencies": {
+    "@bomb.sh/tab": "^0.0.15",
     "axios": "^1.8.4",
     "colors": "^1.4.0",
     "commander": "^14.0.3",
     "fs-extra2": "^1.0.1",
     "playwright-core": "^1.51.1",
-    "zod": "^3.24.2"
+    "zod": "^4.4.3"
   },
   "devDependencies": {
     "@adspower/local-api-core": "workspace:*",