pangu-vis-cli 1.0.3 → 1.1.0

package/dist/index.js

@@ -1 +1,2220 @@
-"use strict";const{checkUpdate:e}=require("./renew"),r=require("./action"),{program:o}=require("commander"),{version:s}=require("../package.json"),i=require("chalk"),c=require("path"),{log:a,get_cli_config:n,exit:t}=require("./utils"),d=(e,r=[])=>{try{require(c.resolve(__dirname,e,"index.js"))(r,{})}catch(e){t(e?.message)}};r.forEach(r=>{(r.option?r.option.reduce((e,r)=>e.option(r),o):o).command(r.command).alias(r.alias).description(r.desc).action(async()=>{const o=process.argv.slice(3);if(await e(),"*"===r.command)a.err(r.desc);else if(r.isAuth){const[e]=await n();if(e.user)d(r.command,o);else{await require("./auth/index.js")()&&d(r.command,o)}}else d(r.command,o)})}),"-v"===process.argv[2]&&(console.log(s),t()),o.version(s).parse(process.argv),process.on("uncaughtException",function(e){console.log(i.bold.red("err："),i.bold.red(e?.message||"异常错误！")),process.exit(1)});
+#!/usr/bin/env node
+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 __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to4, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to4, key) && key !== except)
+        __defProp(to4, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to4;
+};
+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
+));
+
+// src/types/cli.ts
+var DEFAULT_CLI_CONFIG;
+var init_cli = __esm({
+  "src/types/cli.ts"() {
+    "use strict";
+    DEFAULT_CLI_CONFIG = {
+      autoRemove: true,
+      autoRemoveEs: true
+    };
+  }
+});
+
+// src/utils/config.ts
+import { homedir } from "node:os";
+import path from "node:path";
+import { to } from "await-to-js";
+import fs from "fs-extra";
+var DEFAULT_PRIVATE_SOURCE, getConfigDir, packagePath, getPackagePath, cli_config, privateSourceCache, set_update_log, get_update_log, getPrivateSource, filterValidConfigFields, set_cli_config, get_cli_config, setUpdateCheckTime, shouldCheckUpdate;
+var init_config = __esm({
+  "src/utils/config.ts"() {
+    "use strict";
+    init_cli();
+    DEFAULT_PRIVATE_SOURCE = "http://192.168.12.88:10000";
+    getConfigDir = () => {
+      const envConfigDir = process.env.PANGU_CONFIG_DIR;
+      if (envConfigDir && envConfigDir.trim() !== "") {
+        return path.resolve(envConfigDir);
+      }
+      return path.resolve(homedir(), ".pangu-vis-store");
+    };
+    packagePath = getConfigDir();
+    getPackagePath = () => getConfigDir();
+    cli_config = null;
+    privateSourceCache = null;
+    set_update_log = async (isExpired = false) => {
+      const time = Date.now() + 24 * 60 * 60 * 1e3;
+      await fs.outputJson(path.resolve(getPackagePath(), ".update_log"), {
+        time,
+        isExpired
+      });
+    };
+    get_update_log = async () => {
+      const [err, res] = await to(fs.readJson(path.resolve(getPackagePath(), ".update_log")));
+      if (err || !res) {
+        return { isExpired: true, time: 0 };
+      }
+      return res;
+    };
+    getPrivateSource = async () => {
+      if (privateSourceCache !== null) {
+        return privateSourceCache;
+      }
+      const envRegistry = process.env.PANGU_REGISTRY;
+      if (envRegistry?.startsWith("http")) {
+        privateSourceCache = envRegistry;
+        return privateSourceCache;
+      }
+      const [config2] = await get_cli_config();
+      if (config2.privateRegistry && typeof config2.privateRegistry === "string") {
+        privateSourceCache = config2.privateRegistry;
+        return privateSourceCache;
+      }
+      privateSourceCache = DEFAULT_PRIVATE_SOURCE;
+      return privateSourceCache;
+    };
+    filterValidConfigFields = (config2) => {
+      const result = {
+        autoRemove: typeof config2.autoRemove === "boolean" ? config2.autoRemove : DEFAULT_CLI_CONFIG.autoRemove,
+        autoRemoveEs: typeof config2.autoRemoveEs === "boolean" ? config2.autoRemoveEs : DEFAULT_CLI_CONFIG.autoRemoveEs
+      };
+      if (typeof config2.lastUpdateCheck === "number") {
+        result.lastUpdateCheck = config2.lastUpdateCheck;
+      }
+      if (typeof config2.privateRegistry === "string") {
+        result.privateRegistry = config2.privateRegistry;
+      }
+      return result;
+    };
+    set_cli_config = async (option) => {
+      const [old_cli_config, cli_config_path] = await get_cli_config();
+      cli_config = {
+        ...old_cli_config,
+        ...option
+      };
+      privateSourceCache = null;
+      await fs.outputJson(cli_config_path, cli_config);
+    };
+    get_cli_config = async () => {
+      const cli_config_path = path.resolve(getPackagePath(), ".cli_store");
+      if (cli_config !== null) {
+        return [cli_config, cli_config_path];
+      }
+      const [err, res] = await to(fs.readJson(cli_config_path));
+      if (err || !res) {
+        cli_config = DEFAULT_CLI_CONFIG;
+        return [cli_config, cli_config_path];
+      }
+      cli_config = filterValidConfigFields(res);
+      return [cli_config, cli_config_path];
+    };
+    setUpdateCheckTime = async () => {
+      const currentTimestamp = Date.now();
+      await set_cli_config({ lastUpdateCheck: currentTimestamp });
+    };
+    shouldCheckUpdate = async () => {
+      const [config2] = await get_cli_config();
+      if (!config2.lastUpdateCheck) {
+        return true;
+      }
+      const ONE_DAY_MS = 24 * 60 * 60 * 1e3;
+      const timeSinceLastCheck = Date.now() - config2.lastUpdateCheck;
+      return timeSinceLastCheck > ONE_DAY_MS;
+    };
+  }
+});
+
+// node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS({
+  "node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js"(exports, module) {
+    var p2 = process || {};
+    var argv = p2.argv || [];
+    var env = p2.env || {};
+    var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p2.platform === "win32" || (p2.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+    var formatter = (open, close, replace = open) => (input) => {
+      let string = "" + input, index = string.indexOf(close, open.length);
+      return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+    };
+    var replaceClose = (string, close, replace, index) => {
+      let result = "", cursor = 0;
+      do {
+        result += string.substring(cursor, index) + replace;
+        cursor = index + close.length;
+        index = string.indexOf(close, cursor);
+      } while (~index);
+      return result + string.substring(cursor);
+    };
+    var createColors = (enabled = isColorSupported) => {
+      let f = enabled ? formatter : () => String;
+      return {
+        isColorSupported: enabled,
+        reset: f("\x1B[0m", "\x1B[0m"),
+        bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+        dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+        italic: f("\x1B[3m", "\x1B[23m"),
+        underline: f("\x1B[4m", "\x1B[24m"),
+        inverse: f("\x1B[7m", "\x1B[27m"),
+        hidden: f("\x1B[8m", "\x1B[28m"),
+        strikethrough: f("\x1B[9m", "\x1B[29m"),
+        black: f("\x1B[30m", "\x1B[39m"),
+        red: f("\x1B[31m", "\x1B[39m"),
+        green: f("\x1B[32m", "\x1B[39m"),
+        yellow: f("\x1B[33m", "\x1B[39m"),
+        blue: f("\x1B[34m", "\x1B[39m"),
+        magenta: f("\x1B[35m", "\x1B[39m"),
+        cyan: f("\x1B[36m", "\x1B[39m"),
+        white: f("\x1B[37m", "\x1B[39m"),
+        gray: f("\x1B[90m", "\x1B[39m"),
+        bgBlack: f("\x1B[40m", "\x1B[49m"),
+        bgRed: f("\x1B[41m", "\x1B[49m"),
+        bgGreen: f("\x1B[42m", "\x1B[49m"),
+        bgYellow: f("\x1B[43m", "\x1B[49m"),
+        bgBlue: f("\x1B[44m", "\x1B[49m"),
+        bgMagenta: f("\x1B[45m", "\x1B[49m"),
+        bgCyan: f("\x1B[46m", "\x1B[49m"),
+        bgWhite: f("\x1B[47m", "\x1B[49m"),
+        blackBright: f("\x1B[90m", "\x1B[39m"),
+        redBright: f("\x1B[91m", "\x1B[39m"),
+        greenBright: f("\x1B[92m", "\x1B[39m"),
+        yellowBright: f("\x1B[93m", "\x1B[39m"),
+        blueBright: f("\x1B[94m", "\x1B[39m"),
+        magentaBright: f("\x1B[95m", "\x1B[39m"),
+        cyanBright: f("\x1B[96m", "\x1B[39m"),
+        whiteBright: f("\x1B[97m", "\x1B[39m"),
+        bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+        bgRedBright: f("\x1B[101m", "\x1B[49m"),
+        bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+        bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+        bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+        bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+        bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+        bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+      };
+    };
+    module.exports = createColors();
+    module.exports.createColors = createColors;
+  }
+});
+
+// src/utils/log.ts
+var import_picocolors, log, exit;
+var init_log = __esm({
+  "src/utils/log.ts"() {
+    "use strict";
+    import_picocolors = __toESM(require_picocolors(), 1);
+    log = {
+      /**
+       * 输出成功消息（绿色）
+       * @param message 消息文本
+       * @returns 无返回值
+       */
+      success(message) {
+        process.stdout.write(`${import_picocolors.default.green(message)}
+`);
+      },
+      /**
+       * 输出错误消息（红色加粗，写入 stderr）
+       * @param message 消息文本
+       * @returns 无返回值
+       */
+      err(message) {
+        process.stderr.write(`${import_picocolors.default.bold(import_picocolors.default.red(message))}
+`);
+      },
+      /**
+       * 输出提示消息（蓝色）
+       * @param message 消息文本
+       * @returns 无返回值
+       */
+      info(message) {
+        process.stdout.write(`${import_picocolors.default.blue(message)}
+`);
+      },
+      /**
+       * 输出警告消息（黄色）
+       * @param message 消息文本
+       * @returns 无返回值
+       */
+      warn(message) {
+        process.stdout.write(`${import_picocolors.default.yellow(message)}
+`);
+      },
+      /**
+       * 输出步骤消息（原色）
+       * @param message 消息文本
+       * @returns 无返回值
+       */
+      step(message) {
+        process.stdout.write(`${message}
+`);
+      },
+      /**
+       * 输出普通消息（原色）
+       * @param message 消息文本
+       * @returns 无返回值
+       */
+      message(message) {
+        process.stdout.write(`${message}
+`);
+      }
+    };
+    exit = (message) => {
+      if (message) {
+        log.message("");
+        log.err(message);
+      }
+      process.exit(1);
+    };
+  }
+});
+
+// src/utils/process.ts
+var process_exports = {};
+__export(process_exports, {
+  compareVersion: () => compareVersion,
+  detectPackageManager: () => detectPackageManager,
+  getCdRelativePath: () => getCdRelativePath,
+  getGitUser: () => getGitUser,
+  getPackageName: () => getPackageName,
+  get_plugin_latest_version: () => get_plugin_latest_version,
+  get_plugin_version: () => get_plugin_version,
+  runAsyncCmd: () => runAsyncCmd,
+  userInfo: () => userInfo,
+  wait: () => wait,
+  welcomeCli: () => welcomeCli
+});
+import path2 from "node:path";
+import { promisify } from "node:util";
+import { $ } from "execa";
+import figlet from "figlet";
+import _ from "lodash";
+var camelCase, upperFirst, detectPackageManager, userInfo, getPackageName, wait, welcomeCli, compareVersion, getCdRelativePath, runAsyncCmd, getGitUser, get_plugin_version, get_plugin_latest_version;
+var init_process = __esm({
+  "src/utils/process.ts"() {
+    "use strict";
+    init_log();
+    ({ camelCase, upperFirst } = _);
+    detectPackageManager = async () => {
+      try {
+        await $`nub --version`;
+        return "nub";
+      } catch {
+      }
+      try {
+        await $`pnpm --version`;
+        return "pnpm";
+      } catch {
+      }
+      return "npm";
+    };
+    userInfo = { user: "" };
+    getPackageName = (name) => upperFirst(camelCase(name));
+    wait = (seconds) => {
+      return new Promise((resolve) => setTimeout(resolve, seconds * 1e3));
+    };
+    welcomeCli = async () => {
+      const figletAsync = promisify(figlet);
+      const welcomeInfo = await figletAsync("Welcome   to   VisCli");
+      log.message("");
+      log.success(welcomeInfo || "Welcome to VisCli");
+    };
+    compareVersion = (v1, v2) => {
+      if (v1.startsWith("v")) v1 = v1.slice(1);
+      if (v2.startsWith("v")) v2 = v2.slice(1);
+      const arr1 = v1.split(".");
+      const arr2 = v2.split(".");
+      const len = Math.max(arr1.length, arr2.length);
+      while (arr1.length < len) arr1.push("0");
+      while (arr2.length < len) arr2.push("0");
+      for (let i = 0; i < len; i++) {
+        const num1 = parseInt(arr1[i] || "0", 10);
+        const num2 = parseInt(arr2[i] || "0", 10);
+        if (num1 > num2) return 1;
+        if (num1 < num2) return -1;
+      }
+      return 0;
+    };
+    getCdRelativePath = (currentPath, targetPath) => {
+      const absCurrent = path2.resolve(currentPath);
+      const absTarget = path2.resolve(targetPath);
+      const relativePath = path2.relative(absCurrent, absTarget);
+      return relativePath || "./";
+    };
+    runAsyncCmd = async (cmd, args = [], options = {}) => {
+      try {
+        const { cwd = process.cwd(), stdio = "inherit" } = options;
+        const result = await $({ cwd, stdio })`${cmd} ${args}`;
+        return {
+          success: true,
+          stdout: result.stdout || "",
+          stderr: result.stderr || "",
+          status: result.exitCode ?? null
+        };
+      } catch (err) {
+        const error = err;
+        log.err(`Command failed: ${error.message}`);
+        return {
+          success: false,
+          stdout: error.stdout || "",
+          stderr: error.stderr || error.message,
+          status: error.exitCode || null
+        };
+      }
+    };
+    getGitUser = async () => {
+      try {
+        const result = await $`git config user.name`;
+        userInfo.user = result.stdout.trim();
+        return userInfo.user;
+      } catch {
+        return "";
+      }
+    };
+    get_plugin_version = async (pluginName) => {
+      if (!pluginName) return "";
+      try {
+        const args = ["view", pluginName, "version"];
+        const result = await $`npm ${args}`;
+        return result.stdout.trim();
+      } catch {
+        return "";
+      }
+    };
+    get_plugin_latest_version = async (pluginName, defaultVersion = "") => {
+      if (!pluginName) return {};
+      const version2 = await get_plugin_version(pluginName) || defaultVersion;
+      return { [pluginName]: `^${version2}` };
+    };
+  }
+});
+
+// package.json
+var package_exports = {};
+__export(package_exports, {
+  default: () => package_default
+});
+var package_default;
+var init_package = __esm({
+  "package.json"() {
+    package_default = {
+      name: "pangu-vis-cli",
+      version: "1.1.0",
+      description: "vis-cli",
+      keywords: [
+        "pangu-vis",
+        "pangu-vis-cli",
+        "pv",
+        "pvis"
+      ],
+      license: "MIT",
+      author: "Jaxon",
+      bin: {
+        pv: "dist/index.js",
+        pvis: "dist/index.js"
+      },
+      files: [
+        "dist"
+      ],
+      type: "module",
+      main: "./dist/index.js",
+      publishConfig: {
+        registry: "https://registry.npmjs.org/"
+      },
+      scripts: {
+        build: "node scripts/build.mjs",
+        typecheck: "tsc --noEmit",
+        test: "vitest",
+        "test:run": "vitest run",
+        "test:coverage": "vitest run --coverage",
+        lint: "oxlint .",
+        "lint:fix": "oxlint . --fix",
+        format: "oxfmt .",
+        "format:check": "oxfmt --check .",
+        check: "oxlint . && oxfmt --check .",
+        "check:fix": "oxlint . --fix && oxfmt .",
+        prepare: "node scripts/build.mjs",
+        release: "standard-version",
+        "release:patch": "standard-version --release-as patch",
+        "release:minor": "standard-version --release-as minor",
+        "release:major": "standard-version --release-as major",
+        "release:beta": "standard-version --prerelease beta"
+      },
+      dependencies: {
+        "@clack/prompts": "^0.10.1",
+        "await-to-js": "^3.0.0",
+        clear: "^0.1.0",
+        commander: "^10.0.1",
+        dayjs: "^1.11.21",
+        execa: "^9.6.1",
+        figlet: "^1.11.0",
+        "fs-extra": "^11.3.6",
+        lodash: "^4.18.1",
+        picocolors: "^1.1.1",
+        tar: "^6.2.1",
+        zod: "^4.4.3"
+      },
+      devDependencies: {
+        "@types/clear": "^0.1.4",
+        "@types/fs-extra": "^11.0.4",
+        "@types/lodash": "^4.17.24",
+        "@types/node": "^20",
+        "@types/tar": "^6.1.0",
+        "@vitest/coverage-v8": "^4.1.9",
+        esbuild: "^0.25.12",
+        oxfmt: "^0.66.0",
+        oxlint: "^1.81.0",
+        "standard-version": "^9.5.0",
+        typescript: "7.0.2",
+        vitest: "^4.1.9",
+        zx: "^8.8.5"
+      },
+      engines: {
+        node: ">=20.19.0"
+      }
+    };
+  }
+});
+
+// src/utils/api.ts
+import { exec } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+import fs2 from "fs-extra";
+async function getUserNpmRegistry() {
+  if (userNpmRegistryCache !== null) {
+    return userNpmRegistryCache;
+  }
+  try {
+    const { stdout } = await execAsync("npm config get registry", {
+      timeout: 5e3
+    });
+    const registry = stdout.trim();
+    if (registry?.startsWith("http")) {
+      userNpmRegistryCache = registry;
+      return userNpmRegistryCache;
+    }
+    userNpmRegistryCache = DEFAULT_NPM_REGISTRY;
+    return userNpmRegistryCache;
+  } catch (_error) {
+    userNpmRegistryCache = DEFAULT_NPM_REGISTRY;
+    return userNpmRegistryCache;
+  }
+}
+async function checkNpmConnection() {
+  const privateRegistry = await getPrivateSource();
+  try {
+    const response = await fetch(privateRegistry, {
+      method: "GET",
+      signal: AbortSignal.timeout(5e3)
+    });
+    return response.ok;
+  } catch (_error) {
+    return false;
+  }
+}
+async function checkNpmConnectionState(options = {}) {
+  if (npmConnectionStateCache !== null) {
+    return npmConnectionStateCache;
+  }
+  const showSpinner = options.showSpinner ?? true;
+  const s = showSpinner ? (await Promise.resolve().then(() => (init_utils(), utils_exports))).spinner("\u6B63\u5728\u68C0\u6D4Bnpm\u6E90\uFF0C\u8BF7\u7A0D\u5019...") : null;
+  s?.start();
+  const state = await checkNpmConnection();
+  if (!s) {
+    npmConnectionStateCache = state;
+    return npmConnectionStateCache;
+  }
+  if (state) {
+    s.succeed("npm\u6E90\u68C0\u6D4B\u5B8C\u6210");
+  } else {
+    s.fail("npm\u6E90\u68C0\u6D4B\u5931\u8D25");
+  }
+  const { wait: wait2 } = await Promise.resolve().then(() => (init_process(), process_exports));
+  await wait2(0.1);
+  npmConnectionStateCache = state;
+  return npmConnectionStateCache;
+}
+async function getLatestVersion(packageName, defaultValue) {
+  try {
+    if (!packageName) {
+      return defaultValue;
+    }
+    const cacheKey = `${packageName}\0${defaultValue ?? ""}`;
+    if (latestVersionCache.has(cacheKey)) {
+      return latestVersionCache.get(cacheKey);
+    }
+    const registry = packageName.startsWith("@pangu/") ? await getPrivateSource() : await getUserNpmRegistry();
+    const registryUrl = `${registry}/${packageName}`;
+    const response = await fetch(registryUrl, {
+      method: "GET",
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (!response.ok) {
+      latestVersionCache.set(cacheKey, defaultValue);
+      return defaultValue;
+    }
+    const data = await response.json();
+    const latestVersion = data?.["dist-tags"]?.latest;
+    const result = latestVersion || defaultValue;
+    latestVersionCache.set(cacheKey, result);
+    return result;
+  } catch (_error) {
+    if (packageName) {
+      latestVersionCache.set(`${packageName}\0${defaultValue ?? ""}`, defaultValue);
+    }
+    return defaultValue;
+  }
+}
+async function get_plugin_latest_version2(packageName, defaultValue) {
+  if (!packageName) {
+    return {};
+  }
+  const latestVersion = await getLatestVersion(packageName, defaultValue);
+  if (!latestVersion) {
+    return {};
+  }
+  return {
+    [packageName]: `^${latestVersion}`
+  };
+}
+async function getCurrentVersion() {
+  try {
+    const { default: pkg } = await Promise.resolve().then(() => (init_package(), package_exports));
+    return pkg.version || "0.0.0";
+  } catch (_importError) {
+    try {
+      const packageJsonPath = new URL("../../package.json", import.meta.url).pathname;
+      const pkg = await fs2.readJson(packageJsonPath);
+      return pkg.version || "0.0.0";
+    } catch (_readError) {
+      return "0.0.0";
+    }
+  }
+}
+var execAsync, DEFAULT_NPM_REGISTRY, userNpmRegistryCache, npmConnectionStateCache, latestVersionCache;
+var init_api = __esm({
+  "src/utils/api.ts"() {
+    "use strict";
+    init_config();
+    execAsync = promisify2(exec);
+    DEFAULT_NPM_REGISTRY = "https://registry.npmjs.org";
+    userNpmRegistryCache = null;
+    npmConnectionStateCache = null;
+    latestVersionCache = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/utils/error.ts
+function handleCliError(error, exitFn) {
+  const exitHandler = exitFn ?? ((message) => {
+    if (message) {
+      log.err(message);
+    }
+    process.exit(1);
+  });
+  if (error.isUserError()) {
+    exitHandler(error.message);
+  } else {
+    throw error;
+  }
+}
+async function wrapAsyncOperation(operation, errorMessage) {
+  try {
+    return await operation();
+  } catch (error) {
+    const originalError = error instanceof Error ? error : new Error(String(error));
+    throw CliError.operation(errorMessage, originalError);
+  }
+}
+function assertValidation(condition, message) {
+  if (!condition) {
+    throw CliError.validation(message);
+  }
+}
+var CliErrorType, CliError;
+var init_error = __esm({
+  "src/utils/error.ts"() {
+    "use strict";
+    init_log();
+    CliErrorType = /* @__PURE__ */ ((CliErrorType2) => {
+      CliErrorType2["USER_INPUT"] = "USER_INPUT";
+      CliErrorType2["OPERATION"] = "OPERATION";
+      CliErrorType2["VALIDATION"] = "VALIDATION";
+      CliErrorType2["CANCEL"] = "CANCEL";
+      return CliErrorType2;
+    })(CliErrorType || {});
+    CliError = class _CliError extends Error {
+      /** 错误分类，决定后续处理策略 */
+      type;
+      /** 被包装的原始错误，未包装时为 undefined */
+      originalError;
+      /**
+       * 构造 CLI 错误
+       * @param type 错误分类
+       * @param message 错误消息
+       * @param originalError 被包装的原始错误
+       * @returns 无返回值
+       */
+      constructor(type, message, originalError) {
+        super(message);
+        this.name = "CliError";
+        this.type = type;
+        this.originalError = originalError;
+        Object.setPrototypeOf(this, _CliError.prototype);
+      }
+      /**
+       * 创建用户输入错误
+       * 用于用户提供的输入不符合要求的情况
+       * @param message 错误消息
+       * @returns 「CliError」实例
+       */
+      static userInput(message) {
+        return new _CliError("USER_INPUT" /* USER_INPUT */, message);
+      }
+      /**
+       * 创建验证错误
+       * 用于用户输入验证失败的情况
+       * @param message 错误消息
+       * @returns 「CliError」实例
+       */
+      static validation(message) {
+        return new _CliError("VALIDATION" /* VALIDATION */, message);
+      }
+      /**
+       * 创建操作失败错误
+       * 用于 CLI 操作执行失败的情况
+       * @param message 错误消息
+       * @param originalError 原始错误对象
+       * @returns 「CliError」实例
+       */
+      static operation(message, originalError) {
+        return new _CliError("OPERATION" /* OPERATION */, message, originalError);
+      }
+      /**
+       * 创建取消错误
+       * 用于用户主动取消操作的情况
+       * @param message 错误消息（默认为“操作已取消”）
+       * @returns 「CliError」实例
+       */
+      static cancel(message = "\u64CD\u4F5C\u5DF2\u53D6\u6D88") {
+        return new _CliError("CANCEL" /* CANCEL */, message);
+      }
+      /**
+       * 判断是否为用户输入类错误
+       * @returns 是否为用户输入类错误（含验证与取消）
+       */
+      isUserError() {
+        return this.type === "USER_INPUT" /* USER_INPUT */ || this.type === "VALIDATION" /* VALIDATION */ || this.type === "CANCEL" /* CANCEL */;
+      }
+      /**
+       * 判断是否为操作失败类错误
+       * @returns 是否为操作失败类错误
+       */
+      isOperationError() {
+        return this.type === "OPERATION" /* OPERATION */;
+      }
+    };
+  }
+});
+
+// src/utils/git.ts
+import path3 from "node:path";
+import { $ as $2 } from "execa";
+import fs3 from "fs-extra";
+var RAW_CHART_MODULE_REMOTES, normalizeGitRemoteUrl, CHART_MODULE_REMOTE_ALLOWLIST, isChartModuleRemoteUrl, hasChartModuleLayout, getGitRepoRoot, REMOTE_URL_PATTERN, getGitRemoteUrls, detectChartModuleByGit;
+var init_git = __esm({
+  "src/utils/git.ts"() {
+    "use strict";
+    RAW_CHART_MODULE_REMOTES = [
+      "http://192.168.12.86:65535/pangu/thfea/ui/chart-module.git",
+      "https://gitlab.pangutech.dev/pangu/ui/pangu-roof-web/component/pangu-roof-chart.git"
+    ];
+    normalizeGitRemoteUrl = (url) => {
+      const trimmed = url.trim();
+      if (!trimmed) {
+        return "";
+      }
+      let body = trimmed;
+      let scheme = "";
+      const schemeMatch = /^(?<scheme>[a-zA-Z][a-zA-Z0-9+.-]*):\/\//.exec(trimmed);
+      if (schemeMatch?.groups?.scheme) {
+        scheme = schemeMatch.groups.scheme.toLowerCase();
+        body = trimmed.slice(schemeMatch[0].length);
+      }
+      let hostPort = "";
+      let pathPart = "";
+      if (scheme) {
+        const slashIndex = body.indexOf("/");
+        const authority = slashIndex === -1 ? body : body.slice(0, slashIndex);
+        hostPort = authority.includes("@") ? authority.slice(authority.lastIndexOf("@") + 1) : authority;
+        pathPart = slashIndex === -1 ? "" : body.slice(slashIndex);
+      } else {
+        const colonIndex = body.indexOf(":");
+        const slashIndex = body.indexOf("/");
+        if (colonIndex > 0 && (slashIndex === -1 || colonIndex < slashIndex)) {
+          const afterColon = body.slice(colonIndex + 1);
+          const hostSeg = body.slice(0, colonIndex);
+          const bareHost = hostSeg.includes("@") ? hostSeg.slice(hostSeg.lastIndexOf("@") + 1) : hostSeg;
+          const portForm = /^(?<port>\d+)\/(?<rest>.*)$/.exec(afterColon);
+          if (portForm?.groups?.port) {
+            hostPort = `${bareHost}:${portForm.groups.port}`;
+            pathPart = `/${portForm.groups.rest}`;
+          } else if (/^\d+$/.test(afterColon)) {
+            hostPort = `${bareHost}:${afterColon}`;
+            pathPart = "";
+          } else {
+            hostPort = bareHost;
+            pathPart = `/${afterColon}`;
+          }
+        } else {
+          hostPort = slashIndex === -1 ? body : body.slice(0, slashIndex);
+          if (hostPort.includes("@")) {
+            hostPort = hostPort.slice(hostPort.lastIndexOf("@") + 1);
+          }
+          pathPart = slashIndex === -1 ? "" : body.slice(slashIndex);
+        }
+      }
+      let port = "";
+      const hostColon = hostPort.lastIndexOf(":");
+      if (hostColon !== -1) {
+        const candidate = hostPort.slice(hostColon + 1);
+        if (/^\d+$/.test(candidate)) {
+          const defaultPorts = { http: "80", https: "443", ssh: "22" };
+          hostPort = hostPort.slice(0, hostColon);
+          if (candidate !== defaultPorts[scheme]) {
+            port = candidate;
+          }
+        }
+      }
+      let cleanPath = pathPart;
+      if (cleanPath.endsWith("/")) {
+        cleanPath = cleanPath.slice(0, -1);
+      }
+      if (cleanPath.toLowerCase().endsWith(".git")) {
+        cleanPath = cleanPath.slice(0, -4);
+      }
+      cleanPath = cleanPath.toLowerCase();
+      return `${hostPort.toLowerCase()}${port ? `:${port}` : ""}${cleanPath}`;
+    };
+    CHART_MODULE_REMOTE_ALLOWLIST = RAW_CHART_MODULE_REMOTES.map(normalizeGitRemoteUrl);
+    isChartModuleRemoteUrl = (url) => {
+      return CHART_MODULE_REMOTE_ALLOWLIST.includes(normalizeGitRemoteUrl(url));
+    };
+    hasChartModuleLayout = async (dir) => {
+      const [pkgExists, componentsExists, tailoredExists] = await Promise.all([
+        fs3.pathExists(path3.join(dir, "package.json")),
+        fs3.pathExists(path3.join(dir, "packages", "components")),
+        fs3.pathExists(path3.join(dir, "packages", "tailored"))
+      ]);
+      return pkgExists && componentsExists && tailoredExists;
+    };
+    getGitRepoRoot = async (cwd) => {
+      try {
+        const result = await $2({
+          cwd: cwd ?? process.cwd(),
+          reject: false,
+          timeout: 5e3
+        })`git rev-parse --show-toplevel`;
+        const root = (result.stdout ?? "").trim();
+        return root || null;
+      } catch {
+        return null;
+      }
+    };
+    REMOTE_URL_PATTERN = /^remote\..*\.url$/.source;
+    getGitRemoteUrls = async (cwd) => {
+      try {
+        const result = await $2({
+          cwd: cwd ?? process.cwd(),
+          reject: false,
+          timeout: 5e3
+        })`git config --get-regexp ${REMOTE_URL_PATTERN}`;
+        const stdout = (result.stdout ?? "").trim();
+        if (!stdout) {
+          return [];
+        }
+        return stdout.split("\n").map((line) => line.slice(line.indexOf(" ") + 1).trim()).filter(Boolean);
+      } catch {
+        return [];
+      }
+    };
+    detectChartModuleByGit = async () => {
+      const root = await getGitRepoRoot();
+      if (!root) {
+        return false;
+      }
+      const remotes = await getGitRemoteUrls();
+      if (!remotes.some(isChartModuleRemoteUrl)) {
+        return false;
+      }
+      if (!await hasChartModuleLayout(root)) {
+        if (process.env.DEBUG === "true") {
+          console.debug(
+            `[detectChartModuleByGit] remote \u547D\u4E2D\u767D\u540D\u5355\u4F46\u76EE\u5F55\u5E03\u5C40\u6821\u9A8C\u672A\u901A\u8FC7\uFF0C\u964D\u7EA7\u7ED3\u6784\u626B\u63CF: ${root}`
+          );
+        }
+        return false;
+      }
+      return { root };
+    };
+  }
+});
+
+// src/utils/fs.ts
+import path4 from "node:path";
+import { to as to2 } from "await-to-js";
+import fs4 from "fs-extra";
+import _2 from "lodash";
+import tar from "tar";
+var mergeWith, isArray, getPath, buildTarHandler, filterFile, scanDirHandle, updatePackageJson, outputVueName, isChartModuleRoot, scanFileFindChart, cachedScanResult, cachedScanRoot, scanAllDirectories, clearScanCache;
+var init_fs = __esm({
+  "src/utils/fs.ts"() {
+    "use strict";
+    init_log();
+    init_git();
+    ({ mergeWith, isArray } = _2);
+    getPath = (targetPath) => {
+      const cwd = process.cwd();
+      if (targetPath.includes(cwd)) {
+        return targetPath;
+      }
+      return path4.resolve(cwd, targetPath);
+    };
+    buildTarHandler = async (targetPath, name, distPath = null, distName = null) => {
+      targetPath = getPath(targetPath);
+      if (distPath) {
+        distPath = getPath(distPath);
+        await fs4.ensureDir(distPath);
+      }
+      return new Promise((resolve, reject) => {
+        const options = {
+          gzip: true,
+          cwd: targetPath,
+          sync: true
+        };
+        const list = typeof name === "string" ? [name] : name;
+        const tarName = distName || (typeof name === "string" ? name : `tar_${Date.now()}`);
+        const writeStream = fs4.createWriteStream(`${distPath || targetPath}/${tarName}.tar.gz`);
+        const tarStream = tar.c(options, list);
+        tarStream.pipe(writeStream).on("finish", resolve).on("error", reject);
+        tarStream.on("error", reject);
+        writeStream.on("error", reject);
+      });
+    };
+    filterFile = async (dirPath, ignoreFiles = [".git", ".vscode", ".DS_Store", ".idea"]) => {
+      const dir = dirPath || process.cwd();
+      const res = await fs4.pathExists(dir);
+      if (res) {
+        const isDir = await fs4.stat(dir);
+        if (isDir.isDirectory()) {
+          const [err, resDir] = await to2(fs4.readdir(dir));
+          if (err) {
+            return exit(err.message);
+          }
+          await Promise.all(resDir.map((v) => filterFile(path4.resolve(dir, v), ignoreFiles)));
+        } else {
+          for (const ignoreFile of ignoreFiles) {
+            if (dir.includes(ignoreFile)) {
+              await fs4.remove(dir);
+              return;
+            }
+          }
+        }
+      }
+    };
+    scanDirHandle = async (dir, ignorePattern) => {
+      const list = [];
+      const exists = await fs4.pathExists(dir);
+      if (exists) {
+        const stats = await fs4.stat(dir);
+        if (stats.isDirectory()) {
+          const [err, resDir] = await to2(fs4.readdir(dir));
+          if (err) {
+            exit(err.message);
+            return list;
+          }
+          for (const item of resDir) {
+            const itemPath = path4.resolve(dir, item);
+            const itemStats = await fs4.stat(itemPath);
+            if (itemStats.isDirectory()) {
+              if (ignorePattern && ignorePattern.length > 0) {
+                const shouldIgnore = ignorePattern.some((pattern) => item.startsWith(pattern));
+                if (!shouldIgnore) {
+                  list.push(item);
+                }
+              } else {
+                list.push(item);
+              }
+            }
+          }
+        }
+      }
+      return list;
+    };
+    updatePackageJson = async (fPath, option) => {
+      const p2 = path4.join(fPath, "package.json");
+      const [err, res] = await to2(fs4.readJson(p2));
+      if (err) {
+        exit(err?.message);
+      } else if (res) {
+        mergeWith(res, option, (objValue, srcValue) => {
+          if (isArray(objValue)) {
+            return objValue.concat(srcValue);
+          }
+          return void 0;
+        });
+        await fs4.outputJson(p2, res, { spaces: 2, EOL: "\n" });
+      }
+    };
+    outputVueName = async (p2, name) => {
+      const str = `
+<script setup>
+  import { defineProps, defineEmits, defineOptions } from 'vue';
+  defineProps({
+    styled: Object,
+    data: Object,
+    width: Number,
+    height: Number,
+    events: Array,
+    option: Object
+  });
+  defineEmits(['message']);
+  defineOptions({
+    name: '${name}'
+  })
+</script>`;
+      await fs4.appendFile(p2, str);
+      return;
+    };
+    isChartModuleRoot = async (dir, packageName) => {
+      if (typeof packageName !== "string" || !packageName.includes("pangu")) {
+        return false;
+      }
+      const [componentsExists, tailoredExists] = await Promise.all([
+        fs4.pathExists(path4.join(dir, "packages", "components")),
+        fs4.pathExists(path4.join(dir, "packages", "tailored"))
+      ]);
+      return componentsExists && tailoredExists;
+    };
+    scanFileFindChart = async (maxDepth = 1) => {
+      try {
+        const gitHit = await detectChartModuleByGit();
+        if (gitHit) {
+          return gitHit;
+        }
+      } catch {
+      }
+      for (let i = 0; i < maxDepth; i++) {
+        let relativePath = "./";
+        if (i > 0) {
+          relativePath += "../".repeat(i);
+        }
+        const cwd = path4.resolve(process.cwd(), relativePath);
+        const packageJsonPath = path4.resolve(cwd, "package.json");
+        if (await fs4.pathExists(packageJsonPath)) {
+          try {
+            const pkg = await fs4.readJson(packageJsonPath);
+            if (await isChartModuleRoot(cwd, pkg.name)) {
+              return { root: cwd };
+            }
+          } catch (error) {
+            if (process.env.DEBUG === "true") {
+              console.debug(
+                `[scanFileFindChart] Failed to read package.json at ${packageJsonPath}:`,
+                error
+              );
+            }
+          }
+        }
+      }
+      return false;
+    };
+    cachedScanResult = null;
+    cachedScanRoot = null;
+    scanAllDirectories = async (chartModuleRoot, ignorePattern) => {
+      if (cachedScanResult && cachedScanRoot === chartModuleRoot) {
+        return cachedScanResult;
+      }
+      const [rootList, packList, componentList, tailoredList] = await Promise.all([
+        scanDirHandle(chartModuleRoot, ignorePattern),
+        scanDirHandle(path4.join(chartModuleRoot, "packages"), ignorePattern),
+        scanDirHandle(path4.join(chartModuleRoot, "packages", "components"), ignorePattern),
+        scanDirHandle(path4.join(chartModuleRoot, "packages", "tailored"), ignorePattern)
+      ]);
+      cachedScanResult = {
+        rootList,
+        packList,
+        componentList,
+        tailoredList
+      };
+      cachedScanRoot = chartModuleRoot;
+      return cachedScanResult;
+    };
+    clearScanCache = () => {
+      cachedScanResult = null;
+      cachedScanRoot = null;
+    };
+  }
+});
+
+// src/utils/index.ts
+var utils_exports = {};
+__export(utils_exports, {
+  CliError: () => CliError,
+  CliErrorType: () => CliErrorType,
+  assertValidation: () => assertValidation,
+  buildTarHandler: () => buildTarHandler,
+  checkNpmConnectionState: () => checkNpmConnectionState,
+  checkUpdate: () => checkUpdate,
+  clearScanCache: () => clearScanCache,
+  compareVersion: () => compareVersion,
+  confirmPrompt: () => confirmPrompt,
+  detectPackageManager: () => detectPackageManager,
+  exit: () => exit,
+  filterFile: () => filterFile,
+  getCdRelativePath: () => getCdRelativePath,
+  getCurrentVersion: () => getCurrentVersion,
+  getGitUser: () => getGitUser,
+  getLatestVersion: () => getLatestVersion,
+  getPackageName: () => getPackageName,
+  getPath: () => getPath,
+  getPrivateSource: () => getPrivateSource,
+  get_cli_config: () => get_cli_config,
+  get_plugin_latest_version: () => get_plugin_latest_version2,
+  get_update_log: () => get_update_log,
+  groupPrompts: () => groupPrompts,
+  handleCancel: () => handleCancel,
+  handleCliError: () => handleCliError,
+  intro: () => intro2,
+  log: () => log,
+  multiselectPrompt: () => multiselectPrompt,
+  note: () => note2,
+  outputVueName: () => outputVueName,
+  outro: () => outro2,
+  packagePath: () => packagePath,
+  passwordPrompt: () => passwordPrompt,
+  progress: () => progress,
+  prompt: () => prompt,
+  runAsyncCmd: () => runAsyncCmd,
+  scanAllDirectories: () => scanAllDirectories,
+  scanDirHandle: () => scanDirHandle,
+  scanFileFindChart: () => scanFileFindChart,
+  selectPrompt: () => selectPrompt,
+  setUpdateCheckTime: () => setUpdateCheckTime,
+  set_cli_config: () => set_cli_config,
+  set_update_log: () => set_update_log,
+  shouldCheckUpdate: () => shouldCheckUpdate,
+  spinner: () => spinner2,
+  textPrompt: () => textPrompt,
+  togglePrompt: () => togglePrompt,
+  updatePackageJson: () => updatePackageJson,
+  userInfo: () => userInfo,
+  wait: () => wait,
+  welcomeCli: () => welcomeCli,
+  wrapAsyncOperation: () => wrapAsyncOperation
+});
+import * as p from "@clack/prompts";
+async function textPrompt(options) {
+  return promptUntilValid("text", options);
+}
+async function passwordPrompt(options) {
+  return promptUntilValid("password", options);
+}
+async function confirmPrompt(options) {
+  const confirmOptions = {
+    message: options.message,
+    initialValue: options.initialValue ?? false
+  };
+  const result = await p.confirm(confirmOptions);
+  return handleCancel(result);
+}
+async function selectPrompt(options) {
+  const mappedOptions = options.options.map((o) => ({
+    value: o.value,
+    label: o.label ?? o.value,
+    ...o.hint !== void 0 && { hint: o.hint }
+  }));
+  const result = await p.select({
+    message: options.message,
+    options: mappedOptions
+  });
+  return handleCancel(result);
+}
+async function multiselectPrompt(options) {
+  const mappedOptions = options.options.map((o) => ({
+    value: o.value,
+    label: o.label ?? o.value,
+    ...o.hint !== void 0 && { hint: o.hint }
+  }));
+  const result = await p.multiselect({
+    message: options.message,
+    options: mappedOptions,
+    initialValues: options.initialValues ?? [],
+    required: options.required ?? false
+  });
+  return handleCancel(result);
+}
+async function togglePrompt(options) {
+  const result = await p.confirm({
+    message: `${options.message} (${options.active}/${options.inactive})`,
+    initialValue: options.initialValue ?? false
+  });
+  return handleCancel(result);
+}
+async function groupPrompts(prompts) {
+  const results = await p.group(prompts, {
+    onCancel: () => {
+      exit("\u64CD\u4F5C\u5DF2\u53D6\u6D88");
+    }
+  });
+  return results;
+}
+async function prompt(list) {
+  const promptFunctions = {};
+  for (const item of list) {
+    promptFunctions[item.name] = async () => {
+      const handler = promptHandlers[item.type];
+      if (handler) {
+        return handler(item);
+      }
+      return item.initial;
+    };
+  }
+  return groupPrompts(promptFunctions);
+}
+async function progress(items, handler, options) {
+  if (options?.showProgress && items.length > 0) {
+    const s = spinner2(options?.title ?? "\u5904\u7406\u4E2D...");
+    s.start();
+    for (let i = 0; i < items.length; i++) {
+      const item = items[i];
+      if (item !== void 0) {
+        await handler(item, i);
+      }
+      s.message(`\u5904\u7406 ${i + 1}/${items.length}`);
+    }
+    s.succeed("\u5904\u7406\u5B8C\u6210");
+  } else {
+    for (let i = 0; i < items.length; i++) {
+      const item = items[i];
+      if (item !== void 0) {
+        await handler(item, i);
+      }
+    }
+  }
+}
+var import_picocolors2, spinner2, intro2, outro2, note2, handleCancel, normalizeValidationResult, validatePromptValue, promptUntilValid, promptHandlers, checkUpdate;
+var init_utils = __esm({
+  "src/utils/index.ts"() {
+    "use strict";
+    init_api();
+    init_process();
+    init_config();
+    init_error();
+    init_fs();
+    init_log();
+    import_picocolors2 = __toESM(require_picocolors(), 1);
+    init_api();
+    init_config();
+    init_log();
+    spinner2 = (message) => {
+      const s = p.spinner();
+      if (message) s.start(message);
+      return {
+        start: (msg) => s.start(msg),
+        stop: (msg, code) => s.stop(msg, code),
+        succeed: (msg) => s.stop(msg, 0),
+        fail: (msg) => s.stop(msg, 1),
+        warn: (msg) => s.stop(msg, 2),
+        info: (msg) => s.stop(msg, 3),
+        message: (msg) => s.message(msg)
+      };
+    };
+    intro2 = (title) => p.intro(import_picocolors2.default.bgCyan(import_picocolors2.default.black(` ${title} `)));
+    outro2 = (message) => {
+      if (message) p.outro(import_picocolors2.default.green(message));
+      else p.outro();
+    };
+    note2 = (message, title) => p.note(message, title);
+    handleCancel = (result) => {
+      if (typeof result === "symbol") {
+        exit("\u64CD\u4F5C\u5DF2\u53D6\u6D88");
+      }
+      return result;
+    };
+    normalizeValidationResult = async (result) => {
+      if (result === true) return void 0;
+      if (result === false) return "\u9A8C\u8BC1\u5931\u8D25";
+      return result;
+    };
+    validatePromptValue = async (value, validate) => {
+      if (!validate) return void 0;
+      return normalizeValidationResult(await validate(value));
+    };
+    promptUntilValid = async (type, options) => {
+      while (true) {
+        const promptOptions = {
+          message: options.message
+        };
+        if (options.initialValue !== void 0) {
+          promptOptions.initialValue = options.initialValue;
+        }
+        const result = type === "text" ? await p.text(promptOptions) : await p.password({ message: options.message });
+        const value = handleCancel(result);
+        const validationMessage = await validatePromptValue(value, options.validate);
+        if (validationMessage === void 0) {
+          return value;
+        }
+        log.warn(validationMessage);
+      }
+    };
+    promptHandlers = {
+      /** 处理 text 类型：适配旧字段后转调「textPrompt」 */
+      text: async (item) => {
+        const textOpts = {
+          message: item.message
+        };
+        if (item.initial !== void 0) textOpts.initialValue = item.initial;
+        if (item.validate !== void 0) {
+          textOpts.validate = async (value) => {
+            const result = await item.validate?.(value);
+            return normalizeValidationResult(result);
+          };
+        }
+        return textPrompt(textOpts);
+      },
+      /** 处理 password 类型：适配旧字段后转调「passwordPrompt」 */
+      password: async (item) => {
+        const pwdOpts = {
+          message: item.message
+        };
+        if (item.validate !== void 0) {
+          pwdOpts.validate = async (value) => {
+            const result = await item.validate?.(value);
+            return normalizeValidationResult(result);
+          };
+        }
+        return passwordPrompt(pwdOpts);
+      },
+      /** 处理 select 类型：将旧 choices 映射为选项列表 */
+      select: async (item) => {
+        const selectOptions = {
+          message: item.message,
+          options: (item.choices ?? []).map((c) => ({
+            value: c.value,
+            label: c.title
+          }))
+        };
+        if (typeof item.initial === "string") {
+          selectOptions.initialValue = item.initial;
+        }
+        return selectPrompt(selectOptions);
+      },
+      /** 处理 toggle 类型：补齐两态文案的缺省值 */
+      toggle: async (item) => {
+        const toggleOptions = {
+          message: item.message,
+          active: item.active ?? "yes",
+          inactive: item.inactive ?? "no"
+        };
+        if (typeof item.initial === "boolean") {
+          toggleOptions.initialValue = item.initial;
+        }
+        return togglePrompt(toggleOptions);
+      },
+      /** 处理 confirm 类型：布尔初始值透传给确认提示 */
+      confirm: async (item) => {
+        const confirmOptions = {
+          message: item.message
+        };
+        if (typeof item.initial === "boolean") {
+          confirmOptions.initialValue = item.initial;
+        }
+        return confirmPrompt(confirmOptions);
+      },
+      /** 处理 multiselect 类型：旧 choices 映射为多选项列表 */
+      multiselect: async (item) => {
+        const multiselectOptions = {
+          message: item.message,
+          options: (item.choices ?? []).map((c) => ({
+            value: c.value,
+            label: c.title
+          })),
+          required: false
+        };
+        if (Array.isArray(item.initial)) {
+          multiselectOptions.initialValues = item.initial;
+        }
+        return multiselectPrompt(multiselectOptions);
+      }
+    };
+    checkUpdate = async (forceCheck = false) => {
+      try {
+        if (!forceCheck) {
+          const shouldCheck = await shouldCheckUpdate();
+          if (!shouldCheck) {
+            return null;
+          }
+        }
+        const latestVersion = await getLatestVersion("pangu-vis-cli");
+        if (!latestVersion) {
+          return null;
+        }
+        const currentVersion = await getCurrentVersion();
+        await setUpdateCheckTime();
+        const hasUpdate = latestVersion !== currentVersion;
+        return {
+          hasUpdate,
+          currentVersion,
+          latestVersion
+        };
+      } catch (_error) {
+        return null;
+      }
+    };
+  }
+});
+
+// src/schemas/chart-type.ts
+import { z } from "zod";
+var chartTypeSchema, chartTypeLabels;
+var init_chart_type = __esm({
+  "src/schemas/chart-type.ts"() {
+    "use strict";
+    chartTypeSchema = z.enum(
+      [
+        "line",
+        // 折线图
+        "bar",
+        // 柱状图
+        "pie",
+        // 饼图
+        "form",
+        // 表格
+        "other",
+        // 其他
+        "map",
+        // 地图
+        "text",
+        // 文本
+        "indicator",
+        // 指标
+        "interaction"
+        // 交互
+      ],
+      {
+        error: "\u56FE\u8868\u7C7B\u578B\u5FC5\u987B\u662F\u6709\u6548\u7684\u679A\u4E3E\u503C"
+      }
+    );
+    chartTypeLabels = {
+      line: "\u6298\u7EBF\u56FE",
+      bar: "\u67F1\u72B6\u56FE",
+      pie: "\u997C\u56FE",
+      form: "\u8868\u683C",
+      other: "\u5176\u4ED6",
+      map: "\u5730\u56FE",
+      text: "\u6587\u672C",
+      indicator: "\u6307\u6807",
+      interaction: "\u4EA4\u4E92"
+    };
+  }
+});
+
+// src/schemas/config.ts
+import { z as z2 } from "zod";
+var cliConfigSchema, cliConfigUpdateSchema;
+var init_config2 = __esm({
+  "src/schemas/config.ts"() {
+    "use strict";
+    cliConfigSchema = z2.object({
+      // 自动删除打包目录
+      autoRemove: z2.boolean({
+        error: "autoRemove \u5FC5\u987B\u662F\u5E03\u5C14\u503C"
+      }).default(true),
+      // 自动移除 es 目录
+      autoRemoveEs: z2.boolean({
+        error: "autoRemoveEs \u5FC5\u987B\u662F\u5E03\u5C14\u503C"
+      }).default(true),
+      // 上次检查 CLI 版本更新的时间戳
+      lastUpdateCheck: z2.number().optional(),
+      // 私有 npm 源地址
+      privateRegistry: z2.string().optional()
+    });
+    cliConfigUpdateSchema = cliConfigSchema.partial();
+  }
+});
+
+// src/schemas/project-name.ts
+import { z as z3 } from "zod";
+function formatProjectNameError(error) {
+  const issues = error.issues;
+  if (issues.length === 0) return "\u672A\u77E5\u9519\u8BEF";
+  return issues.map((issue) => issue.message).join("; ");
+}
+function validateProjectName(name) {
+  const result = projectNameSchema.safeParse(name);
+  if (result.success) {
+    return true;
+  }
+  return formatProjectNameError(result.error);
+}
+var projectNameSchema;
+var init_project_name = __esm({
+  "src/schemas/project-name.ts"() {
+    "use strict";
+    projectNameSchema = z3.string({
+      error: "\u9879\u76EE\u540D\u5FC5\u987B\u662F\u5B57\u7B26\u4E32"
+    }).regex(/^[a-z][a-z0-9_]*$/, {
+      message: "\u5305\u540D\u53EA\u5141\u8BB8\u4EE5\u5C0F\u5199\u82F1\u6587\u5B57\u6BCD\u5F00\u5934\uFF0C\u53EA\u5141\u8BB8\u4F7F\u7528\u5C0F\u5199\u82F1\u6587\u5B57\u6BCD\u3001\u6570\u5B57\u548C\u4E0B\u5212\u7EBF"
+    }).min(1, {
+      message: "\u9879\u76EE\u540D\u4E0D\u80FD\u4E3A\u7A7A"
+    }).max(100, {
+      message: "\u9879\u76EE\u540D\u957F\u5EA6\u4E0D\u80FD\u8D85\u8FC7100\u4E2A\u5B57\u7B26"
+    });
+  }
+});
+
+// src/schemas/index.ts
+var init_schemas = __esm({
+  "src/schemas/index.ts"() {
+    "use strict";
+    init_error();
+    init_chart_type();
+    init_config2();
+    init_project_name();
+  }
+});
+
+// src/create/chart.ts
+import path5 from "node:path";
+import fs5 from "fs-extra";
+async function renameIfExists(from, to4) {
+  if (await fs5.pathExists(from)) {
+    await fs5.rename(from, to4);
+  }
+}
+async function applyTypeScriptFileNames(projectPath) {
+  const srcPath = path5.resolve(projectPath, "src");
+  await renameIfExists(
+    path5.resolve(projectPath, "render.js"),
+    path5.resolve(projectPath, "render.ts")
+  );
+  await renameIfExists(path5.resolve(srcPath, "config.js"), path5.resolve(srcPath, "config.ts"));
+  await renameIfExists(path5.resolve(srcPath, "data.js"), path5.resolve(srcPath, "data.ts"));
+  await renameIfExists(path5.resolve(srcPath, "style.js"), path5.resolve(srcPath, "style.ts"));
+  await fs5.remove(path5.resolve(projectPath, "jsconfig.json"));
+}
+async function getStandaloneDependencyVersion(packageName, defaultVersion, shouldCheckLatest) {
+  if (!packageName) {
+    return {};
+  }
+  if (!shouldCheckLatest) {
+    return {
+      [packageName]: `^${defaultVersion}`
+    };
+  }
+  return get_plugin_latest_version2(packageName, defaultVersion);
+}
+async function handleChartTemplate(options) {
+  const { projectName, projectPath, chartModule, author, chartType, chartId, isTs } = options;
+  const isInner = await checkNpmConnectionState({ showSpinner: false });
+  await fs5.outputJson(
+    path5.resolve(projectPath, "public", "base.json"),
+    {
+      name: projectName,
+      label: projectName,
+      desc: "Custom Chart",
+      version: "1.0.0",
+      width: 480,
+      height: 240,
+      type: chartType || "other",
+      author,
+      id: chartId
+    },
+    { spaces: 2, EOL: "\n" }
+  );
+  await fs5.appendFile(
+    path5.resolve(projectPath, "index.js"),
+    `
+export const ${getPackageName(projectName)} = component`
+  );
+  await outputVueName(path5.resolve(projectPath, "src", "index.vue"), projectName);
+  await updatePackageJson(projectPath, {
+    name: projectName,
+    author
+  });
+  if (chartModule) {
+    await updatePackageJson(projectPath, {
+      name: projectName,
+      author,
+      devDependencies: {
+        "@chart/utils": "workspace:*"
+      }
+    });
+  } else {
+    const STANDALONE_DEV_DEPENDENCIES = async () => {
+      return {
+        ...await getStandaloneDependencyVersion("pangu-chart-cli", "1.0.2", isInner),
+        ...await getStandaloneDependencyVersion(
+          isInner ? "@pangu/vchart-config" : "",
+          "1.1.0",
+          isInner
+        ),
+        ...await getStandaloneDependencyVersion(
+          isInner ? "" : "pangu-vchart-theme",
+          "1.0.2",
+          isInner
+        ),
+        "@vitejs/plugin-vue": "3.2.0",
+        sass: "1.69.7",
+        vite: "4.5.5",
+        "vite-plugin-compression": "0.5.1",
+        "vite-plugin-banner": "0.7.1"
+      };
+    };
+    const STANDALONE_DEPENDENCIES = {
+      vue: "~3.3.13",
+      "yann-i18n": "1.0.7"
+    };
+    await updatePackageJson(projectPath, {
+      name: projectName,
+      author,
+      devDependencies: await STANDALONE_DEV_DEPENDENCIES(),
+      dependencies: STANDALONE_DEPENDENCIES
+    });
+    if (!isInner) {
+      await fs5.writeFile(
+        path5.resolve(projectPath, "example/App.vue"),
+        `<script setup>
+   import { computed } from 'vue'
+   import ChartInfo from '../index'
+   import base from '../public/base.json'
+   import { createTheme } from 'pangu-vchart-theme'
+   const { component: Chart, data, style } = ChartInfo
+   const layerBoxStyle = computed(() => {
+     return {
+       width: base.width + 'px',
+       height: base.height + 'px'
+     }
+   })
+
+   const chartData = computed(() => {
+     return typeof data === 'function' ? data('zh') : data
+   })
+
+   const chartStyle = computed(() => {
+     return typeof style === 'function' ? style(createTheme()) : style
+   })
+   </script>
+
+   <template>
+     <div class="box">
+       <!-- \u56FE\u8868\u76D2\u5B50 -->
+       <div class="layerBox" :style="layerBoxStyle">
+         <!-- \u56FE\u8868\u5177\u4F53\u5185\u5BB9 -->
+         <div class="layerMain">
+           <!-- \u4E0A\u9762\u90A3\u4E9Bdiv\u4E0D\u7528\u53BB\u7BA1\uFF0C\u5E73\u53F0\u4F1A\u81EA\u52A8\u751F\u6210 -->
+           <Chart
+             :width="base.width"
+             :height="base.height"
+             :data="chartData"
+             :styled="chartStyle"
+             :events="events"
+           />
+         </div>
+       </div>
+     </div>
+   </template>
+   <style scoped lang="scss">
+   .box {
+     width: 100vw;
+     height: 100vh;
+     background-color: #242424;
+     position: fixed;
+     left: 0;
+     top: 0;
+     display: flex;
+     align-items: center;
+     flex-direction: column;
+     justify-content: center;
+     z-index: 10;
+     .takeBtn {
+       margin-top: 15px;
+     }
+     .layerBox {
+       position: relative;
+       display: flex;
+       flex-direction: column;
+       background: #2a2a34;
+       border-radius: 12px;
+       padding: 15px;
+
+       .layerMain {
+         flex: 1;
+         display: flex;
+         align-items: center;
+         justify-content: center;
+       }
+     }
+   }
+   </style>
+   `
+      );
+      await fs5.writeFile(
+        path5.resolve(projectPath, ".npmrc"),
+        `registry=https://registry.npmmirror.com/
+   strict-peer-dependencies=false`
+      );
+    }
+  }
+  if (isTs) {
+    await applyTypeScriptFileNames(projectPath);
+  }
+}
+var init_chart = __esm({
+  "src/create/chart.ts"() {
+    "use strict";
+    init_utils();
+  }
+});
+
+// src/create/index.ts
+var create_exports = {};
+__export(create_exports, {
+  default: () => create,
+  resolveTemplatePath: () => resolveTemplatePath
+});
+import path6 from "node:path";
+import { fileURLToPath } from "node:url";
+import clear from "clear";
+import { $ as $3 } from "execa";
+import fs6 from "fs-extra";
+async function resolveTemplatePath(templateName, baseDir = __dirname) {
+  const candidates = Array.from(new Set(getTemplatePathCandidates(templateName, baseDir)));
+  for (const candidate of candidates) {
+    if (await fs6.pathExists(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(`\u6A21\u677F\u76EE\u5F55\u4E0D\u5B58\u5728: ${templateName}
+\u5DF2\u5C1D\u8BD5:
+${candidates.join("\n")}`);
+}
+async function create(commandList = []) {
+  intro2("\u521B\u5EFA\u56FE\u8868\u9879\u76EE");
+  const templateType = "chart";
+  const ChartModule = await scanFileFindChart();
+  const answers = await groupPrompts({
+    chartType: async () => selectPrompt({
+      message: "\u8BF7\u9009\u62E9\u56FE\u8868\u7C7B\u578B:",
+      options: CHART_TYPES,
+      initialValue: "other"
+    }),
+    isTs: async () => togglePrompt({
+      message: "\u662F\u5426\u4F7F\u7528 TypeScript?",
+      active: "yes",
+      inactive: "no",
+      initialValue: false
+    })
+  });
+  const { chartType, isTs } = answers;
+  const chartTypeValidation = chartTypeSchema.safeParse(chartType);
+  if (!chartTypeValidation.success) {
+    exit(`\u65E0\u6548\u7684\u56FE\u8868\u7C7B\u578B: ${chartType}`);
+    return;
+  }
+  const validatedChartType = chartTypeValidation.data;
+  const checkRepeat = async (str) => {
+    const ignorePattern = [".", "_"];
+    if (ChartModule) {
+      const { rootList, packList, componentList, tailoredList } = await scanAllDirectories(
+        ChartModule.root,
+        ignorePattern
+      );
+      if (rootList.includes(str) || packList.includes(str) || componentList.includes(str) || tailoredList.includes(str)) {
+        return true;
+      }
+    } else {
+      const list = await scanDirHandle(process.cwd(), ignorePattern);
+      if (list.includes(str)) {
+        return true;
+      }
+    }
+    return false;
+  };
+  log.info("\u63A8\u8350\u6DFB\u52A0\u81EA\u5B9A\u4E49\u524D\u7F00\u4EE5\u9632\u6B62\u548C\u5176\u4ED6\u56FE\u8868\u540D\u91CD\u590D\u5E76\u4E14\u4FBF\u4E8E\u540E\u671F\u7EDF\u4E00\u7BA1\u7406");
+  const projectName = await textPrompt({
+    message: "\u8BF7\u8F93\u5165\u56FE\u8868\u540D:",
+    placeholder: commandList[0] || "custom_chart",
+    initialValue: commandList[0] || "custom_chart",
+    validate: async (val) => {
+      const validationResult = validateProjectName(val);
+      if (validationResult !== true) {
+        return validationResult;
+      }
+      const state = await checkRepeat(val);
+      if (state) {
+        return "\u5305\u540D\u91CD\u590D";
+      }
+      return void 0;
+    }
+  });
+  let templatePath;
+  let tsTemplatePath = null;
+  try {
+    templatePath = await resolveTemplatePath(templateType);
+    tsTemplatePath = isTs ? await resolveTemplatePath("ts") : null;
+  } catch (err) {
+    exit(err instanceof Error ? err.message : String(err));
+    return;
+  }
+  const createSpinner = spinner2();
+  createSpinner.start("\u521B\u5EFA\u9879\u76EE...");
+  const cwd = process.cwd();
+  const projectPath = ChartModule ? cwd.includes("tailored") ? path6.join(ChartModule.root, "packages", "tailored", projectName) : path6.join(ChartModule.root, "packages", "components", projectName) : path6.join(cwd, projectName);
+  await fs6.ensureDir(projectPath);
+  await fs6.copy(templatePath, projectPath);
+  if (tsTemplatePath) {
+    await fs6.copy(tsTemplatePath, projectPath);
+  }
+  await handleChartTemplate({
+    projectName,
+    projectPath,
+    chartModule: ChartModule,
+    author: await getGitUser(),
+    chartType: validatedChartType,
+    chartId: Date.now(),
+    isTs
+  });
+  createSpinner.succeed("\u9879\u76EE\u521B\u5EFA\u5B8C\u6210.");
+  await wait(0.1);
+  const installSpinner = spinner2();
+  installSpinner.start("\u5B89\u88C5\u4F9D\u8D56...");
+  try {
+    await $3({ cwd: projectPath })`pnpm install`;
+    installSpinner.succeed("\u4F9D\u8D56\u5B89\u88C5\u5B8C\u6210.");
+  } catch (err) {
+    installSpinner.fail("\u4F9D\u8D56\u5B89\u88C5\u5931\u8D25\uFF0C\u8BF7\u624B\u52A8\u8FD0\u884C pnpm install");
+    log.err(String(err));
+  }
+  await wait(0.1);
+  installSpinner.stop();
+  clear();
+  await welcomeCli();
+  log.message(import_picocolors3.default.cyan("\n\u5B8C\u6210. \u73B0\u5728\u53EF\u4EE5\u6267\u884C:\n"));
+  const cdPath = getCdRelativePath(process.cwd(), projectPath);
+  log.success(`  cd ${cdPath}`);
+  log.success(`  pnpm dev`);
+  log.message("");
+  clearScanCache();
+  outro2(import_picocolors3.default.green(`\u56FE\u8868 "${projectName}" \u521B\u5EFA\u6210\u529F!`));
+}
+var import_picocolors3, __filename, __dirname, getTemplatePathCandidates, CHART_TYPES;
+var init_create = __esm({
+  "src/create/index.ts"() {
+    "use strict";
+    import_picocolors3 = __toESM(require_picocolors(), 1);
+    init_schemas();
+    init_utils();
+    init_chart();
+    __filename = fileURLToPath(import.meta.url);
+    __dirname = path6.dirname(__filename);
+    getTemplatePathCandidates = (templateName, baseDir) => [
+      path6.resolve(baseDir, "../../template", templateName),
+      path6.resolve(baseDir, "../template", templateName),
+      path6.resolve(baseDir, "template", templateName)
+    ];
+    CHART_TYPES = Object.entries(chartTypeLabels).map(([value, label]) => ({
+      value,
+      label,
+      ...value === "other" ? { hint: "\u63A8\u8350" } : {}
+    }));
+  }
+});
+
+// src/utils/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  getCommandArgs: () => getCommandArgs
+});
+var getCommandArgs;
+var init_cli2 = __esm({
+  "src/utils/cli.ts"() {
+    "use strict";
+    getCommandArgs = () => process.argv.slice(3);
+  }
+});
+
+// src/dev/index.ts
+var dev_exports = {};
+__export(dev_exports, {
+  default: () => dev
+});
+import { $ as $4 } from "execa";
+import fs7 from "fs-extra";
+import { join } from "node:path";
+async function dev() {
+  const cwd = process.cwd();
+  const packageJsonPath = join(cwd, "package.json");
+  if (!await fs7.pathExists(packageJsonPath)) {
+    exit("\u672A\u627E\u5230 package.json \u6587\u4EF6\uFF0C\u8BF7\u786E\u4FDD\u5728\u9879\u76EE\u6839\u76EE\u5F55\u6267\u884C\u6B64\u547D\u4EE4");
+    return;
+  }
+  let packageJson;
+  try {
+    packageJson = await fs7.readJson(packageJsonPath);
+  } catch (_error) {
+    exit("package.json \u6587\u4EF6\u683C\u5F0F\u9519\u8BEF\uFF0C\u65E0\u6CD5\u89E3\u6790");
+    return;
+  }
+  if (!packageJson.scripts?.dev) {
+    log.info('\u793A\u4F8B\uFF1A{"scripts": {"dev": "vite"}}');
+    exit("package.json \u4E2D\u672A\u5B9A\u4E49 dev \u811A\u672C\uFF0C\u8BF7\u5148\u6DFB\u52A0 dev \u811A\u672C");
+    return;
+  }
+  log.info(`\u6B63\u5728\u6267\u884C dev \u811A\u672C\uFF1A${packageJson.scripts.dev}`);
+  let interrupted = false;
+  const onSigint = () => {
+    interrupted = true;
+  };
+  process.on("SIGINT", onSigint);
+  try {
+    const pm = await detectPackageManager();
+    await $4({ cwd, stdio: "inherit" })`${pm} run dev`;
+    process.removeListener("SIGINT", onSigint);
+    if (interrupted) {
+      log.info("\u5DF2\u4E2D\u65AD");
+      process.exit(0);
+    }
+  } catch (error) {
+    process.removeListener("SIGINT", onSigint);
+    if (interrupted) {
+      log.info("\u5DF2\u4E2D\u65AD");
+      process.exit(0);
+    }
+    const commandError = error;
+    if (commandError.stderr || commandError.message) {
+      exit(`dev \u811A\u672C\u6267\u884C\u5931\u8D25\uFF1A${commandError.stderr || commandError.message}`);
+    } else {
+      exit(`dev \u811A\u672C\u6267\u884C\u5931\u8D25\uFF0C\u9000\u51FA\u7801\uFF1A${commandError.exitCode}`);
+    }
+  }
+}
+var init_dev = __esm({
+  "src/dev/index.ts"() {
+    "use strict";
+    init_utils();
+  }
+});
+
+// src/build/index.ts
+var build_exports = {};
+__export(build_exports, {
+  buildPathHandler: () => buildPathHandler,
+  default: () => build,
+  versionHandle: () => versionHandle
+});
+import path7 from "node:path";
+import fs8 from "fs-extra";
+import { to as to3 } from "await-to-js";
+async function build(commandList = []) {
+  intro2("\u5355\u4E2A\u56FE\u8868\u6253\u5305");
+  const targetArg = commandList[0]?.trim();
+  if (targetArg) {
+    await buildPack(getPath(targetArg));
+  } else {
+    await buildPack(process.cwd());
+  }
+  outro2("\u56FE\u8868\u6253\u5305\u5B8C\u6210");
+}
+var versionHandle, buildPathHandler, buildPack;
+var init_build = __esm({
+  "src/build/index.ts"() {
+    "use strict";
+    init_utils();
+    versionHandle = async (dir) => {
+      const basePath = path7.resolve(dir, "public", "base.json");
+      const packagePath2 = path7.resolve(dir, "package.json");
+      const [baseErr, baseJson] = await to3(fs8.readJson(basePath));
+      if (baseErr || !baseJson) {
+        exit("\u627E\u4E0D\u5230 base.json \u6587\u4EF6\u6216\u5185\u5BB9\u65E0\u6548");
+      }
+      const [pkgErr, pkgJson] = await to3(fs8.readJson(packagePath2));
+      if (pkgErr || !pkgJson) {
+        exit("\u627E\u4E0D\u5230 package.json \u6587\u4EF6\u6216\u5185\u5BB9\u65E0\u6548");
+      }
+      const state = compareVersion(baseJson.version ?? "0.0.0", pkgJson.version ?? "0.0.0");
+      let version2 = baseJson.version ?? "0.0.0";
+      if (state === 1) {
+        pkgJson.version = baseJson.version;
+        await fs8.outputJson(packagePath2, pkgJson, { spaces: 2, EOL: "\n" });
+      } else if (state === -1) {
+        version2 = pkgJson.version;
+        baseJson.version = pkgJson.version;
+        await fs8.outputJson(basePath, baseJson, { spaces: 2, EOL: "\n" });
+      }
+      return { name: baseJson.name, version: version2 };
+    };
+    buildPathHandler = async (dir) => {
+      const result = await runAsyncCmd("pnpm", ["build"], {
+        cwd: dir,
+        stdio: "inherit"
+      });
+      if (!result.success) {
+        exit("pnpm build \u6267\u884C\u5931\u8D25");
+      }
+    };
+    buildPack = async (dir) => {
+      if (!await fs8.pathExists(path7.resolve(dir, "package.json"))) {
+        exit("\u627E\u4E0D\u5230\u76EE\u5F55");
+      }
+      const { name, version: version2 } = await versionHandle(dir);
+      log.info("\u5F00\u59CB\u6267\u884C\u56FE\u8868\u6784\u5EFA...");
+      await buildPathHandler(dir);
+      const packageName = name.split("/").at(-1) ?? name;
+      const packName = `${packageName}_v${version2}`;
+      const targetPath = path7.resolve(dir, packName);
+      const [config2] = await get_cli_config();
+      if (config2.autoRemoveEs) {
+        await fs8.remove(path7.resolve(targetPath, "es"));
+      }
+      await filterFile(targetPath);
+      const packTarPath = `${targetPath}.tar.gz`;
+      await fs8.remove(packTarPath);
+      log.info("\u6B63\u5728\u538B\u7F29 tar \u5305...");
+      const [tarErr] = await to3(buildTarHandler(dir, packName));
+      if (tarErr) {
+        exit(`tar \u6253\u5305\u5931\u8D25: ${tarErr.message}`);
+      }
+      if (config2.autoRemove) {
+        await fs8.remove(targetPath);
+      }
+      log.success(`\u6253\u5305\u5B8C\u6210: ${packTarPath}`);
+    };
+  }
+});
+
+// src/config/index.ts
+var config_exports = {};
+__export(config_exports, {
+  default: () => config
+});
+async function config(_commandList = []) {
+  intro2("CLI \u914D\u7F6E");
+  const [cli_config_info] = await get_cli_config();
+  const getValue = (key, defaultValue) => {
+    return cli_config_info[key] ?? defaultValue;
+  };
+  const s = spinner2();
+  s.start("\u52A0\u8F7D\u914D\u7F6E");
+  const autoRemove = await togglePrompt({
+    message: "\u6253\u5305\u540E\u662F\u5426\u81EA\u52A8\u5220\u9664\u6253\u5305\u76EE\u5F55?",
+    active: "yes",
+    inactive: "no",
+    initialValue: getValue("autoRemove", true)
+  });
+  const autoRemoveEs = await togglePrompt({
+    message: "\u6253\u5305\u540E\u662F\u5426\u79FB\u9664es\u76EE\u5F55?",
+    active: "yes",
+    inactive: "no",
+    initialValue: getValue("autoRemoveEs", true)
+  });
+  s.stop();
+  const saveSpinner = spinner2();
+  saveSpinner.start("\u6B63\u5728\u4FDD\u5B58\u914D\u7F6E...");
+  await set_cli_config({
+    autoRemove,
+    autoRemoveEs
+  });
+  saveSpinner.succeed("\u914D\u7F6E\u4FDD\u5B58\u6210\u529F!");
+  log.step("\u5F53\u524D\u914D\u7F6E:");
+  log.message(`  \u81EA\u52A8\u5220\u9664\u6253\u5305\u76EE\u5F55: ${autoRemove ? "\u662F" : "\u5426"}`);
+  log.message(`  \u79FB\u9664es\u76EE\u5F55: ${autoRemoveEs ? "\u662F" : "\u5426"}`);
+  outro2("\u914D\u7F6E\u5B8C\u6210!");
+}
+var init_config3 = __esm({
+  "src/config/index.ts"() {
+    "use strict";
+    init_utils();
+  }
+});
+
+// src/update/index.ts
+var update_exports = {};
+__export(update_exports, {
+  default: () => update
+});
+import { execa } from "execa";
+async function update() {
+  intro2("\u66F4\u65B0 CLI");
+  const checkSpinner = spinner2();
+  checkSpinner.start("\u68C0\u67E5\u66F4\u65B0...");
+  const result = await checkUpdate(true);
+  if (result === null) {
+    checkSpinner.fail("\u68C0\u67E5\u66F4\u65B0\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u7F51\u7EDC\u8FDE\u63A5");
+  } else if (!result.hasUpdate) {
+    checkSpinner.succeed(`\u5F53\u524D\u5DF2\u662F\u6700\u65B0\u7248\u672C ${result.currentVersion}`);
+  } else {
+    checkSpinner.stop();
+    log.info(`\u53D1\u73B0\u65B0\u7248\u672C ${result.latestVersion}\uFF0C\u5F53\u524D\u7248\u672C ${result.currentVersion}`);
+    const confirmed = await togglePrompt({
+      message: `\u662F\u5426\u5B89\u88C5 ${result.latestVersion}\uFF1F`,
+      active: "yes",
+      inactive: "no",
+      initialValue: true
+    });
+    if (!confirmed) {
+      log.info("\u5DF2\u8DF3\u8FC7\u66F4\u65B0\uFF0C\u53EF\u7A0D\u540E\u8FD0\u884C 'pvis update' \u518D\u8BD5");
+      outro2("\u5B8C\u6210");
+      return;
+    }
+    const installSpinner = spinner2();
+    installSpinner.start("\u6B63\u5728\u5B89\u88C5\u66F4\u65B0...");
+    const pm = await detectPackageManager();
+    try {
+      await execa(pm, ["install", "-g", "pangu-vis-cli@latest"]);
+      installSpinner.succeed("\u66F4\u65B0\u6210\u529F\uFF01");
+    } catch (_error) {
+      installSpinner.fail("\u81EA\u52A8\u66F4\u65B0\u5931\u8D25");
+      log.warn(`\u8BF7\u624B\u52A8\u6267\u884C: ${pm} install -g pangu-vis-cli@latest`);
+    }
+  }
+  outro2("\u5B8C\u6210");
+}
+var init_update = __esm({
+  "src/update/index.ts"() {
+    "use strict";
+    init_utils();
+  }
+});
+
+// src/index.ts
+import { readFileSync } from "node:fs";
+import { program } from "commander";
+
+// src/commands/definitions.ts
+init_utils();
+var commandDefinitions = [
+  {
+    name: "create",
+    alias: "c",
+    description: "\u521B\u5EFA\u56FE\u8868\u5305",
+    action: async () => {
+      const { default: createCommand } = await Promise.resolve().then(() => (init_create(), create_exports));
+      const { getCommandArgs: getCommandArgs2 } = await Promise.resolve().then(() => (init_cli2(), cli_exports));
+      await createCommand(getCommandArgs2());
+    }
+  },
+  {
+    name: "dev",
+    alias: "d",
+    description: "\u542F\u52A8\u5F00\u53D1\u670D\u52A1\u5668",
+    action: async () => {
+      const { default: devCommand } = await Promise.resolve().then(() => (init_dev(), dev_exports));
+      await devCommand();
+    }
+  },
+  {
+    name: "build",
+    alias: "b",
+    description: "\u5355\u4E2A\u56FE\u8868\u6253\u5305",
+    action: async () => {
+      const { default: buildCommand } = await Promise.resolve().then(() => (init_build(), build_exports));
+      const { getCommandArgs: getCommandArgs2 } = await Promise.resolve().then(() => (init_cli2(), cli_exports));
+      await buildCommand(getCommandArgs2());
+    }
+  },
+  {
+    name: "config",
+    alias: "set",
+    description: "CLI\u914D\u7F6E",
+    action: async () => {
+      const { default: configCommand } = await Promise.resolve().then(() => (init_config3(), config_exports));
+      const { getCommandArgs: getCommandArgs2 } = await Promise.resolve().then(() => (init_cli2(), cli_exports));
+      await configCommand(getCommandArgs2());
+    }
+  },
+  {
+    name: "update",
+    alias: "up",
+    description: "\u66F4\u65B0CLI",
+    skipUpdateCheck: true,
+    action: async () => {
+      const { default: updateCommand } = await Promise.resolve().then(() => (init_update(), update_exports));
+      await updateCommand();
+    }
+  }
+];
+function registerCommands(program2, checkUpdateFn) {
+  for (const cmdDef of commandDefinitions) {
+    const cmd = program2.command(cmdDef.name);
+    if (cmdDef.alias) {
+      cmd.alias(cmdDef.alias);
+    }
+    cmd.description(cmdDef.description);
+    if (cmdDef.options) {
+      for (const opt of cmdDef.options) {
+        if (opt.description) {
+          cmd.option(opt.flags, opt.description);
+        } else {
+          cmd.option(opt.flags);
+        }
+      }
+    }
+    cmd.action(async () => {
+      if (!cmdDef.skipUpdateCheck) {
+        await checkUpdateFn();
+      }
+      await cmdDef.action();
+    });
+  }
+  program2.command("*").description("command not found").action(() => {
+    log.err("command not found");
+  });
+}
+
+// src/index.ts
+init_utils();
+var { version } = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
+async function checkAndNotifyUpdate() {
+  try {
+    const result = await checkUpdate(false);
+    if (result?.hasUpdate) {
+      log.warn(`\u53D1\u73B0\u65B0\u7248\u672C ${result.latestVersion}\uFF0C\u8FD0\u884C 'pvis update' \u66F4\u65B0`);
+    }
+  } catch {
+  }
+}
+registerCommands(program, checkAndNotifyUpdate);
+if (process.argv[2] === "-v") {
+  console.log(version);
+  process.exit(0);
+}
+program.version(version).parse(process.argv);
+process.on("uncaughtException", (err) => {
+  log.err(`\u9519\u8BEF\uFF1A${err?.message || "\u5F02\u5E38\u9519\u8BEF\uFF01"}`);
+  exit();
+});