i18-fe-automator-beta 2.0.6 → 2.1.0

package/dist/commonjs/index.js

@@ -6,10 +6,11 @@ var inquirer = require('inquirer');
 var commander = require('commander');
 var request = require('request');
 var glob = require('glob');
+var chalk = require('chalk');
+var CheckboxPrompt = require('inquirer/lib/prompts/checkbox.js');
 var md5$1 = require('js-md5');
 var CryptoJS = require('crypto-js');
 var ora = require('ora');
-var chalk = require('chalk');
 var xlsx = require('node-xlsx');
 var url = require('url');
 var path = require('path');
@@ -49,215 +50,437 @@ function _interopNamespaceDefault(e) {
 
 var espree__namespace = /*#__PURE__*/_interopNamespaceDefault(espree);
 
-function Loading() {
-  this.spinner = ora();
+// "全选"选项的value，与普通文件选项区分
+const SELECT_ALL = "__all__";
+
+/**
+ * 带全选联动的checkbox prompt：
+ * - 勾选/取消"全选"，其他选项全部同步勾选/取消
+ * - 取消任一普通选项，"全选"自动取消；所有普通选项勾满后，"全选"自动勾上
+ */
+class CheckboxAllPrompt extends CheckboxPrompt {
+  getAllChoice() {
+    return this.opt.choices.find(
+      (choice) => choice.type !== "separator" && choice.value === SELECT_ALL
+    );
+  }
+
+  getItemChoices() {
+    return this.opt.choices.filter(
+      (choice) =>
+        choice.type !== "separator" &&
+        choice.value !== SELECT_ALL &&
+        !choice.disabled
+    );
+  }
+
+  // 根据普通选项的勾选情况同步"全选"状态
+  syncAllChoice() {
+    const allChoice = this.getAllChoice();
+    if (!allChoice) return;
+    const items = this.getItemChoices();
+    allChoice.checked = items.length > 0 && items.every((item) => item.checked);
+  }
+
+  // 覆写toggleChoice: 空格键和数字键选择都会经过这里，统一处理联动
+  toggleChoice(index) {
+    const choice = this.opt.choices.getChoice(index);
+    if (choice && choice.value === SELECT_ALL) {
+      // 切换"全选"：所有普通选项与全选状态保持一致
+      const checked = !choice.checked;
+      choice.checked = checked;
+      this.getItemChoices().forEach((item) => {
+        item.checked = checked;
+      });
+    } else {
+      super.toggleChoice(index);
+      this.syncAllChoice();
+    }
+  }
+
+  // 按a全选/按i反选后，同步"全选"勾选状态
+  onAllKey() {
+    super.onAllKey();
+    this.syncAllChoice();
+  }
+
+  onInverseKey() {
+    super.onInverseKey();
+    this.syncAllChoice();
+  }
 }
+
+function Loading() {
+  this.spinner = ora();
+}
 var Loading$1 = new Loading().spinner;
 
-//加密
-function encrypt(word, keyStr) {
-  keyStr = keyStr ? keyStr : "abcdefgabcdefg12";
-  var key = CryptoJS.enc.Utf8.parse(keyStr); //Latin1 w8m31+Yy/Nw6thPsMpO5fg==
-  var srcs = CryptoJS.enc.Utf8.parse(word);
-  var encrypted = CryptoJS.AES.encrypt(srcs, key, {
-    mode: CryptoJS.mode.ECB,
-    padding: CryptoJS.pad.Pkcs7,
-  });
-  return encrypted.toString();
+//加密
+function encrypt(word, keyStr) {
+  keyStr = keyStr ? keyStr : "abcdefgabcdefg12";
+  var key = CryptoJS.enc.Utf8.parse(keyStr); //Latin1 w8m31+Yy/Nw6thPsMpO5fg==
+  var srcs = CryptoJS.enc.Utf8.parse(word);
+  var encrypted = CryptoJS.AES.encrypt(srcs, key, {
+    mode: CryptoJS.mode.ECB,
+    padding: CryptoJS.pad.Pkcs7,
+  });
+  return encrypted.toString();
+}
+
+function login(data) {
+  data.password = encrypt(md5$1(data.password));
+  const env=data.env;
+  Loading$1.start(`${env}: 登录中...`);
+  return new Promise((resolve, reject) => {
+    request(
+      {
+        url: `https://${
+          env === "pro" ? "" : `${env}-`
+        }hxjf.hongxinshop.com/sys/login`,
+        method: "POST",
+        json: true,
+        body: data,
+      },
+      function (error, response, body) {
+        const res = body || {};
+        if (!error && res.code == 200) {
+          Loading$1.succeed(`${env}: 登录成功`);
+          const access_token = res.data.access_token;
+          resolve(access_token);
+        } else {
+          Loading$1.fail(`${env}: 登录失败`);
+          reject(error || res.msg || "未知错误");
+        }
+      }
+    );
+  });
 }
 
-function login(data) {
-  data.password = encrypt(md5$1(data.password));
-  const env=data.env;
-  Loading$1.start(`${env}: 登录中...`);
-  return new Promise((resolve, reject) => {
-    request(
-      {
-        url: `https://${
-          env === "pro" ? "" : `${env}-`
-        }hxjf.hongxinshop.com/sys/login`,
-        method: "POST",
-        json: true,
-        body: data,
-      },
-      function (error, response, body) {
-        const res = body;
-        if (!error && res.code == 200) {
-          Loading$1.succeed(`${env}: 登录成功`);
-          const access_token = res.data.access_token;
-          resolve(access_token);
-        } else {
-          Loading$1.fail(`${env}: 登录失败`);
-          console.log(chalk.red(error || res.msg));
-        }
-      }
-    );
-  });
+function importExcel({ uploadFilePath, token, env }) {
+  Loading$1.start(`${env}: 导入文件中...`);
+  const stream = fs.createReadStream(uploadFilePath);
+  return new Promise((resolve, reject) => {
+    request(
+      {
+        url: `https://${
+          env === "pro" ? "" : `${env}-`
+        }hxjf.hongxinshop.com/vue-api/api-globalization/api/i18n/importLangExcel`,
+        method: "POST",
+        headers: {
+          contentType: "multipart/form-data",
+          Authorization: `Bearer ${token}`,
+          "x-request-vaildate": "open",
+        },
+        formData: {
+          file: stream,
+        },
+      },
+      function (error, response, body) {
+        let res = {};
+        try {
+          res = JSON.parse(body);
+        } catch (e) {
+          // body非json(如网络错误)
+        }
+        if (!error && res.code == 200) {
+          Loading$1.succeed(`${env}: 导入文件成功`);
+          resolve(true);
+        } else {
+          Loading$1.fail(`${env}: 导入文件失败`);
+          reject(
+            error || (res.data ? JSON.stringify(res.data) : res.msg) || "未知错误"
+          );
+        }
+      }
+    );
+  });
+}
+function readExcel({ uploadFilePath }) {
+  return new Promise((resolve, reject) => {
+    // 读取文件
+    const workSheetsFromFile = xlsx.parse(uploadFilePath);
+    const data = workSheetsFromFile[0].data;
+    //   获取第一行
+    const titleList = data[0];
+    //   获取项目所在的列
+    let projectIndex;
+    if (titleList.indexOf("项目") > -1) {
+      projectIndex = titleList.indexOf("项目");
+    } else if (titleList.indexOf("project") > -1) {
+      projectIndex = titleList.indexOf("project");
+    }
+    if (!projectIndex && projectIndex !== 0) {
+      reject(new Error(`${uploadFilePath} 请检查文件是否包含项目/project列`));
+      return;
+    }
+    // 获取数据
+    const list = data.slice(1);
+    const set = new Set();
+    list.forEach((item) => {
+      if (item[projectIndex]) {
+        set.add(item[projectIndex]);
+      }
+    });
+    // 判断set是否为空
+    if (set.size === 0) {
+      reject(new Error(`${uploadFilePath} 请检查文件是否包含项目数据`));
+      return;
+    }
+    resolve([...set]);
+  });
+}
+
+function uploadExcel({ data, token, env }) {
+  Loading$1.start(`${env}: 导入项目 ${data.projectList.join()}`);
+  return new Promise((resolve, reject) => {
+    request(
+      {
+        url: `https://${
+          env === "pro" ? "" : `${env}-`
+        }hxjf.hongxinshop.com/vue-api/api-globalization/api/i18n/uploadI18nLangForFront`,
+        method: "POST",
+        json: true,
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "x-request-vaildate": "open",
+        },
+        body: data,
+      },
+      function (error, response, body) {
+        const res = body || {};
+        if (!error && res.code == 200) {
+          Loading$1.succeed(`${env}: 导入项目成功`);
+          resolve(true);
+        } else {
+          Loading$1.fail(`${env}: 导入项目失败`);
+          reject(error || res.msg || res.message || "未知错误");
+        }
+      }
+    );
+  });
 }
 
-function importExcel({ uploadFilePath, token, env }) {
-  Loading$1.start(`${env}: 导入文件中...`);
-  const stream = fs.createReadStream(uploadFilePath);
-  return new Promise((resolve, reject) => {
-    request(
-      {
-        url: `https://${
-          env === "pro" ? "" : `${env}-`
-        }hxjf.hongxinshop.com/vue-api/api-globalization/api/i18n/importLangExcel`,
-        method: "POST",
-        headers: {
-          contentType: "multipart/form-data",
-          Authorization: `Bearer ${token}`,
-          "x-request-vaildate": "open",
-        },
-        formData: {
-          file: stream,
-        },
-      },
-      function (error, response, body) {
-        const res = JSON.parse(body);
-        if (!error && res.code == 200) {
-          Loading$1.succeed(`${env}: 导入文件成功`);
-          resolve(true);
-        } else {
-          Loading$1.fail(`${env}: 导入文件失败`);
-          console.log(
-            chalk.red(error || (res.data ? JSON.stringify(res.data) : res.msg))
-          );
-        }
-      }
-    );
-  });
+//  获取命令行所在的目录
+function getRunCliPath({ directory = false, root = false } = {}) {
+  const __filename = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href)));
+  const __dirname = path.dirname(__filename);
+  if (root) {
+    return path.resolve(__dirname, "../");
+  }
+  return directory ? __dirname : __filename;
+}
+
+// 获取package.json
+function getPackageJson() {
+  const packageJson = JSON.parse(
+    fs.readFileSync(path.resolve(getRunCliPath({ root: true }), "../package.json"))
+  );
+  return packageJson;
+}
+// 判断是否存在该路径
+function isExistPath(path) {
+  return fs.existsSync(path);
+}
+
+// 写入缓存
+function writeCache(key, value) {
+  fs.writeFileSync(getRunCliPath({ root: true }) + "/.cache/" + key, value);
+}
+// 读取缓存
+function readCache(key) {
+  return fs.readFileSync(getRunCliPath({ root: true }) + "/.cache/" + key);
 }
-function readExcel({ uploadFilePath }) {
-  return new Promise((resolve, reject) => {
-    // 读取文件
-    const workSheetsFromFile = xlsx.parse(uploadFilePath);
-    const data = workSheetsFromFile[0].data;
-    //   获取第一行
-    const titleList = data[0];
-    //   获取项目所在的列
-    let projectIndex;
-    if (titleList.indexOf("项目") > -1) {
-      projectIndex = titleList.indexOf("项目");
-    } else if (titleList.indexOf("project") > -1) {
-      projectIndex = titleList.indexOf("project");
-    }
-    if (!projectIndex && projectIndex !== 0) {
-      console.log(chalk.red("请检查文件是否包含项目/project列"));
-      return;
-    }
-    // 获取数据
-    const list = data.slice(1);
-    const set = new Set();
-    list.forEach((item) => {
-      if (item[projectIndex]) {
-        set.add(item[projectIndex]);
-      }
-    });
-    // 判断set是否为空
-    if (set.size === 0) {
-      console.log(chalk.red("请检查文件是否包含项目数据"));
-      return;
+
+// 确保 .cache 目录存在
+function ensureCacheDir() {
+  const cacheDir = getRunCliPath({ root: true }) + "/.cache";
+  if (!isExistPath(cacheDir)) {
+    fs.mkdirSync(cacheDir);
+  }
+}
+
+// 读取凭据缓存
+function readSecretCache(cacheKey) {
+  const cacheFilePath = getRunCliPath({ root: true }) + "/.cache/" + cacheKey;
+  if (isExistPath(cacheFilePath)) {
+    try {
+      return JSON.parse(readCache(cacheKey));
+    } catch (error) {
+      return {};
     }
-    resolve([...set]);
-  });
+  }
+  return {};
 }
 
-function uploadExcel({ data, token, env }) {
-  Loading$1.start(`${env}: 导入项目 ${data.projectList.join()}`);
-  return new Promise((resolve, reject) => {
-    request(
-      {
-        url: `https://${
-          env === "pro" ? "" : `${env}-`
-        }hxjf.hongxinshop.com/vue-api/api-globalization/api/i18n/uploadI18nLangForFront`,
-        method: "POST",
-        json: true,
-        headers: {
-          Authorization: `Bearer ${token}`,
-          "x-request-vaildate": "open",
-        },
-        body: data,
-      },
-      function (error, response, body) {
-        const res = body;
-        if (!error && res.code == 200) {
-          Loading$1.succeed(`${env}: 导入项目成功`);
-          resolve(true);
-        } else {
-          Loading$1.fail(`${env}: 导入项目失败`);
-          console.log(chalk.red(error || res.msg || res.message));
-        }
-      }
+// 校验参数值, 不合法则红字提示合法值并退出
+function validateChoice(value, validList, optionName) {
+  if (!validList.includes(value)) {
+    console.log(
+      chalk.red(
+        `参数 ${optionName} 的值 "${value}" 不合法, 可选值: ${validList.join(
+          " | "
+        )}`
+      )
     );
-  });
+    process.exit(1);
+  }
+  return value;
 }
 
-//  获取命令行所在的目录
-function getRunCliPath({ directory = false, root = false } = {}) {
-  const __filename = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href)));
-  const __dirname = path.dirname(__filename);
-  if (root) {
-    return path.resolve(__dirname, "../");
+// CLI 参数 > 交互询问
+async function askOrUse(cliValue, question) {
+  if (cliValue !== undefined && cliValue !== "") {
+    return cliValue;
   }
-  return directory ? __dirname : __filename;
+  const answers = await inquirer.prompt([question]);
+  return answers[question.name];
 }
 
-// 获取package.json
-function getPackageJson() {
-  const packageJson = JSON.parse(
-    fs.readFileSync(path.resolve(getRunCliPath({ root: true }), "../package.json"))
+/**
+ * 凭据解析: CLI 参数 > --cache 缓存 > 交互(展示缓存默认值)
+ * 解析成功后统一回写缓存(与现状"输入即缓存"一致)
+ * @param questions   inquirer 问题数组(含 default/validate), default 会被缓存值覆盖
+ * @param cliValues   CLI 参数值 { 字段名: 值 }
+ * @param useCache    是否走 --cache
+ * @param cacheKey    缓存键(baidu/sass/sass_pro)
+ * @param extraCache  回写缓存时额外携带的字段(如 baidu 的 type)
+ */
+async function resolveSecretQuestions({
+  questions,
+  cliValues = {},
+  useCache = false,
+  cacheKey,
+  extraCache = {},
+}) {
+  ensureCacheDir();
+  const cacheSecret = readSecretCache(cacheKey);
+  const resolved = {};
+  const pendingQuestions = [];
+  questions.forEach((question) => {
+    const { name } = question;
+    const cliValue = cliValues[name];
+    if (cliValue !== undefined && cliValue !== "") {
+      resolved[name] = cliValue;
+      return;
+    }
+    if (useCache && cacheSecret[name]) {
+      resolved[name] = cacheSecret[name];
+      return;
+    }
+    // 未解析的字段进入交互, 默认值优先用缓存
+    pendingQuestions.push({
+      ...question,
+      default: cacheSecret[name] ?? question.default,
+    });
+  });
+  if (pendingQuestions.length) {
+    const answers = await inquirer.prompt(pendingQuestions);
+    Object.assign(resolved, answers);
+  }
+  writeCache(
+    cacheKey,
+    JSON.stringify({
+      ...extraCache,
+      ...resolved,
+    })
   );
-  return packageJson;
-}
-// 判断是否存在该路径
-function isExistPath(path) {
-  return fs.existsSync(path);
-}
-
-// 写入缓存
-function writeCache(key, value) {
-  fs.writeFileSync(getRunCliPath({ root: true }) + "/.cache/" + key, value);
-}
-// 读取缓存
-function readCache(key) {
-  return fs.readFileSync(getRunCliPath({ root: true }) + "/.cache/" + key);
+  return resolved;
 }
 
 const sleep = (time) =>
   new Promise((resolve = 2000) => {
     setTimeout(() => resolve, time);
   });
-async function upload$1() {
-  const SECRET_NAME = "sass";
-  const SECRET_NAME_PRO = "sass_pro";
-  let cacheSecret = {};
-  let cacheSecretPro = {};
-  if (!isExistPath(getRunCliPath({ root: true }) + "/.cache")) {
-    fs.mkdirSync(getRunCliPath({ root: true }) + "/.cache");
+// 上传翻译包(支持 --env/--files/--username/--password/--cache 一键, 参数齐全时跳过确认/选择)
+async function upload$1(cliOpts = {}) {
+  // 空字符串视为未传(与askOrUse语义一致)
+  const cliEnv = cliOpts.env || undefined;
+  const cliFiles = cliOpts.files || undefined;
+  const cliUsername = cliOpts.username || undefined;
+  const cliPassword = cliOpts.password || undefined;
+  const cache = Boolean(cliOpts.cache);
+  const oneClick = cliEnv !== undefined && cliFiles !== undefined;
+  // CLI参数校验前置(快速失败, 不进交互)
+  if (cliEnv !== undefined) {
+    const envArr = cliEnv
+      .split(",")
+      .map((item) => item.trim())
+      .filter(Boolean);
+    if (envArr.length === 1) {
+      if (!["mit", "sit", "uat", "pro"].includes(envArr[0])) {
+        console.log(
+          chalk.red(
+            `参数 --env 的值 "${cliEnv}" 不合法, 可选值: mit | sit | uat | pro, 多环境逗号分隔(仅mit/sit/uat, pro须单独传)`
+          )
+        );
+        process.exit(1);
+      }
+    } else {
+      const invalid = envArr.filter(
+        (item) => !["mit", "sit", "uat"].includes(item)
+      );
+      if (invalid.length) {
+        console.log(
+          chalk.red(
+            `多环境仅支持 mit | sit | uat 逗号分隔, 不支持: ${invalid.join(
+              " | "
+            )} (pro须单独传)`
+          )
+        );
+        process.exit(1);
+      }
+    }
   }
-  const cacheFilePath =
-    getRunCliPath({ root: true }) + "/.cache/" + SECRET_NAME;
-  const cacheFilePathPro =
-    getRunCliPath({ root: true }) + "/.cache/" + SECRET_NAME_PRO;
-  if (isExistPath(cacheFilePath)) {
-    cacheSecret = JSON.parse(readCache(SECRET_NAME));
+  const excelChoices = fs
+    .readdirSync("./")
+    .filter((item) => item.indexOf(".xlsx") > -1 || item.indexOf(".xls") > -1);
+  if (excelChoices.length === 0) {
+    console.log(chalk.red("当前目录下没有excel文件(.xlsx/.xls)"));
+    process.exit(1);
   }
-  if (isExistPath(cacheFilePathPro)) {
-    cacheSecretPro = JSON.parse(readCache(SECRET_NAME_PRO));
+  let cliFileArr;
+  if (cliFiles !== undefined) {
+    if (cliFiles === "all") {
+      cliFileArr = excelChoices;
+    } else {
+      cliFileArr = cliFiles
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean);
+      const invalid = cliFileArr.filter((item) => !excelChoices.includes(item));
+      if (invalid.length) {
+        console.log(
+          chalk.red(`当前目录不存在excel文件: ${invalid.join(", ")}`)
+        );
+        process.exit(1);
+      }
+    }
   }
-  // 是否上传
-  inquirer
-    .prompt([
+  // 1.是否上传(一键模式跳过, 选否属用户主动取消, exit 0)
+  if (!oneClick) {
+    const { isUpload } = await inquirer.prompt([
       {
         message: "是否上传到sass平台",
-        name: "upload",
+        name: "isUpload",
         type: "confirm",
         default: true,
       },
+    ]);
+    if (!isUpload) {
+      return;
+    }
+  }
+  // 2.选择环境(CLI参数 > 交互)
+  let envValue;
+  if (cliEnv !== undefined) {
+    envValue = cliEnv
+      .split(",")
+      .map((item) => item.trim())
+      .filter(Boolean)
+      .join(",");
+  } else {
+    const res = await inquirer.prompt([
       {
-        // 选择环境
         message: "请选择环境",
         name: "env",
         type: "rawlist",
@@ -278,10 +501,6 @@ async function upload$1() {
             name: "pro",
             value: "pro",
           },
-          //   {
-          //     name: "一键发布pro(mit->sit->uat->pro)",
-          //     value: "topro",
-          //   },
           {
             name: "一键发布uat(mit->sit->uat)",
             value: "to-mit,sit,uat",
@@ -291,9 +510,6 @@ async function upload$1() {
             value: "to-mit,sit",
           },
         ],
-        when: function (res) {
-          return res.upload;
-        },
         validate: function (val) {
           if (val.length > 0) {
             return true;
@@ -301,357 +517,366 @@ async function upload$1() {
           return "请选择环境";
         },
       },
+    ]);
+    envValue = res.env;
+  }
+  let envList = [];
+  if (envValue.indexOf("to") > -1) {
+    envList = envValue.replace("to-", "").split(",");
+  } else {
+    envList = [envValue];
+  }
+  const isPro = envList.length === 1 && envList[0] === "pro";
+  // 3.凭据: CLI参数 > --cache缓存 > 交互(展示缓存默认值), 解析后回写缓存
+  const secret = await resolveSecretQuestions({
+    questions: [
       {
-        message: "请输入域账号",
+        message: isPro ? "请输入生产域账号" : "请输入域账号",
         name: "username",
-        // 当upload为true时，展示
-        when: function (res) {
-          return res.upload && res.env !== "pro";
-        },
-        default: cacheSecret.username,
         // 必填
         validate: function (val) {
           if (val) {
             return true;
           }
-          return "请输入域账号";
+          return isPro ? "请输入生产域账号" : "请输入域账号";
         },
       },
       {
-        message: "请输入域密码",
+        message: isPro ? "请输入生产域密码" : "请输入域密码",
         name: "password",
-        default: cacheSecret.password,
-        when: function (res) {
-          return res.upload && res.env !== "pro";
-        },
-        // 必填
-        validate: function (val) {
-          if (val) {
-            return true;
-          }
-          return "请输入域密码";
-        },
-      },
-      {
-        message: "请输入生产域账号",
-        name: "username",
-        // 当upload为true时，展示
-        when: function (res) {
-          return res.upload && res.env === "pro";
-        },
-        default: cacheSecretPro.username,
         // 必填
         validate: function (val) {
           if (val) {
             return true;
           }
-          return "请输入生产域账号";
+          return isPro ? "请输入生产域密码" : "请输入域密码";
         },
       },
+    ],
+    cliValues: { username: cliUsername, password: cliPassword },
+    useCache: cache,
+    cacheKey: isPro ? "sass_pro" : "sass",
+  });
+  const { username, password } = secret;
+  // 4.选择上传文件(CLI参数 > 交互, 交互带全选联动)
+  let excelFileNames;
+  if (cliFileArr !== undefined) {
+    excelFileNames = cliFileArr;
+  } else {
+    inquirer.registerPrompt("checkbox-all", CheckboxAllPrompt);
+    // 选项拼接序号，与数字键选择对应(按1选全选，按2选第一个文件...)
+    const promptChoices = [
+      { name: "全选", value: SELECT_ALL, short: "全选" },
+      ...excelChoices.map((file) => ({ name: file, value: file, short: file })),
+    ].map((choice, index) => ({
+      ...choice,
+      name: `${index + 1}. ${choice.name}`,
+    }));
+    const res = await inquirer.prompt([
       {
-        message: "请输入生产域密码",
-        name: "password",
-        default: cacheSecretPro.password,
-        when: function (res) {
-          return res.upload && res.env === "pro";
-        },
-        // 必填
+        type: "checkbox-all",
+        name: "excelFileNames",
+        message: "请选择要上传的excel文件(可多选)",
+        choices: promptChoices,
         validate: function (val) {
-          if (val) {
+          if (val.length > 0) {
             return true;
           }
-          return "请输入生产域密码";
+          return "请选择要上传的excel文件";
         },
       },
-    ])
-    .then(async (res) => {
-      const { upload, env, username, password } = res;
-      let envList = [];
-      if (env.indexOf("to") > -1) {
-        envList = env.replace("to-", "").split(",");
-      } else {
-        envList = [env];
-      }
-      if (upload) {
-        writeCache(
-          env === "pro" ? "sass_pro" : "sass",
-          JSON.stringify({
-            username,
-            password,
-          })
-        );
-        // 上传逻辑
-        // 1.获取上传文件路径
-        const choices = fs
-          .readdirSync("./")
-          .filter((item) => item.indexOf(".xlsx") > -1 || item.indexOf(".xls") > -1);
-        //  2. 选择上传文件
-        inquirer
-          .prompt([
-            {
-              type: "rawlist",
-              name: "excelFileName",
-              message: "请选择要上传的excel文件",
-              choices,
-              validate: function (val) {
-                if (val) {
-                  return true;
-                }
-                return "请选择项目";
-              },
-            },
-          ])
-          .then(async (res) => {
-            const { excelFileName } = res;
-            // 2.读取excel
-            const uploadFilePath = "./" + excelFileName;
-            const projectList = await readExcel({ uploadFilePath });
-            for (const env of envList) {
-              // 1.登录
-              const token = await login({
-                env,
-                username,
-                password,
-              });
-              // 2.导入excel
-              await importExcel({
-                uploadFilePath,
-                token,
-                env,
-              });
-              sleep(2000);
-              // 3.上传
-              await uploadExcel({
-                data: {
-                  projectList,
-                },
-                token,
-                env,
-              });
-              console.log(`🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀${env} 成功`);
-            }
-            // // 4.给export.xls文件名拼接上 已上传环境, 便于知道上传过的环境
-            // const newUploadFilePath = uploadFilePath.replace(".xlsx", `${uploadFilePath.indexOf('-') > -1 ? ',' : '-'}${envList.join()}.xlsx`)
-            // fs.renameSync(
-            //   uploadFilePath,
-            //   newUploadFilePath
-            // );
-          });
-      }
-    });
-}
-
-// 百度翻译接口
-async function translateFn(item, str, groupIndex, config) {
-  const { appid, key, from, to } = config;
-  const q = str;
-  const salt = Math.random();
-  const sign = md5(appid + q + salt + key);
-  const query = querystring.stringify({
-    q,
-    appid,
-    salt,
-    from,
-    to,
-    sign,
-  });
-  const url = "http://api.fanyi.baidu.com/api/trans/vip/translate?" + query;
-  return new Promise((resolve, reject) => {
-    // 自动翻译延时，必须大于 1000 ms，否则调用百度翻译 API 会失败
-    throttle(() => {
-      console.log(chalk.green(`正在翻译第${groupIndex}组数据`));
-      return request(url, function (_error, response, body) {
-        const resBody = JSON.parse(body);
-        if (resBody.trans_result) {
-          console.log(`ok`);
-          let result = resBody.trans_result || [];
-          item.forEach((item1, index1) => {
-            if (
-              result[index1] &&
-              result[index1].src === item1.from // 去除前后空格,原[ 执行人: ]翻译变成[执行人:]
-            ) {
-              item1.to = result[index1].dst;
-            }
-          });
-          resolve(true);
-        } else {
-          console.log(chalk.red(`error: ${body}`));
-          resolve(true);
-        }
-      });
-    });
-  });
-}
-
-function translate(allArr, config) {
-  let groupArr = []; // 分组后的数组
-  let newAllArr = []; // 分组后的数组还原成所有数组
-  let str = "";
-  let cutArr = [];
-  console.log(chalk.green(`共有${allArr.length}条数据需要翻译`));
-  replaceHtmlTag(allArr);
-  allArr.forEach((item, index) => {
-    if (str.length > 2000) {
-      groupArr.push(cutArr);
-      str = "";
-      cutArr = [];
+    ]);
+    excelFileNames = res.excelFileNames;
+    // 勾选了全选则上传所有文件
+    if (excelFileNames.includes(SELECT_ALL)) {
+      excelFileNames = excelChoices;
     }
-    str += item.from + "\n";
-    cutArr.push(item);
-  });
-  if (cutArr.length > 0) {
-    Array.prototype.push.apply(groupArr, [cutArr]);
-  } else {
-    groupArr = allArr;
   }
-  console.log(chalk.green(`共有${groupArr.length}组数据需要翻译`));
-  const task = groupArr.map(async (item, index) => {
-    let str = "";
-    item.forEach((item1, index1) => {
-      // 去除换行空格
-      str += item1.from.replace(/\n/g, "") + "\n";
-    });
-    return translateFn(item, str, index + 1, config);
-  });
-  Promise.allSettled(task).then(async (res) => {
-    console.log(chalk.green("任务执行完毕"));
-    groupArr.forEach((item, index) => {
-      Array.prototype.push.apply(newAllArr, item);
-    });
-    config.originData.forEach((row, index) => {
-      if (index > 0) {
-        let {tagMap,to}= newAllArr[index - 1];
-        // 用占位符还原
-        // const toStr=
-        for (const key in tagMap) {
-          const value = tagMap[key];
-          to=to.replace(`<${key}>`, value);
-        }
-        row[config.toIndex] = to;
-      }
-    });
-    const buffer = xlsx.build([{ data: config.originData }]);
-    fs.writeFileSync(`./${config.excelFileName}`, buffer, "binary");
-    console.log(chalk.green(`更新文件成功`));
-  });
-}
-// 节流函数
-const delay = 2000;
-const throttle = (function (delay = 1500) {
-  const wait = [];
-  let canCall = true;
-  return function throttle(callback) {
-    if (!canCall) {
-      if (callback) wait.push(callback);
-      return;
+  // 环境外层循环(每个环境只登录一次)，文件内层循环批量上传
+  const failList = [];
+  for (const env of envList) {
+    // 1.登录
+    let token;
+    try {
+      token = await login({
+        env,
+        username,
+        password,
+      });
+    } catch (e) {
+      console.log(chalk.red(`${env} 登录失败: ${e.message || e}`));
+      failList.push(`${env} 登录`);
+      continue;
     }
-
-    callback();
-    canCall = false;
-    setTimeout(() => {
-      canCall = true;
-      if (wait.length) {
-        throttle(wait.shift());
+    for (const excelFileName of excelFileNames) {
+      const uploadFilePath = "./" + excelFileName;
+      try {
+        // 2.读取excel
+        const projectList = await readExcel({ uploadFilePath });
+        // 3.导入excel
+        await importExcel({
+          uploadFilePath,
+          token,
+          env,
+        });
+        await sleep(2000);
+        // 4.上传
+        await uploadExcel({
+          data: {
+            projectList,
+          },
+          token,
+          env,
+        });
+        console.log(
+          `🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀${env} ${excelFileName} 成功`
+        );
+      } catch (e) {
+        console.log(
+          chalk.red(`${env} ${excelFileName} 失败: ${e.message || e}`)
+        );
+        failList.push(`${env} ${excelFileName}`);
       }
-    }, delay);
-  };
-})(delay);
-// md5加密
-function md5(str) {
-  const md5 = crypto.createHash("md5");
-  md5.update(str);
-  return md5.digest("hex");
-}
-function replaceHtmlTag(arr) {
-  arr.forEach((item) => {
-    const str = item.from;
-    const { convertedText, tagMap } = convertHTMLToPlaceholders(str);
-    item.origin = str;
-    item.from = convertedText;
-    item.tagMap = tagMap;
-  });
-}
-/**
- * 将HTML字符串转换为占位符格式，并存储标签映射
- * @param {string} html - 输入的HTML字符串
- * @param {string} prefix - 占位符前缀，默认为'N'
- * @returns {Object} 包含转换后文本和标签映射的对象
- */
-function convertHTMLToPlaceholders(html, prefix = "N") {
-  // 存储结果的标签映射对象
-  const tagMap = {};
-  let counter = 1;
-
-  // 使用正则表达式匹配所有HTML标签
-  // 包括自闭和标签和普通标签
-  const tagRegex = /<(\/)?([a-zA-Z][a-zA-Z0-9]*)(\s[^>]*)?(\/)?>/g;
-
-  // 先找出所有标签
-  const tags = [];
-  let match;
-  while ((match = tagRegex.exec(html)) !== null) {
-    tags.push({
-      fullMatch: match[0],
-      isClosing: match[1] === "/",
-      tagName: match[2],
-      attributes: match[3] || "",
-      isSelfClosing: match[4] === "/",
-      startIndex: match.index,
-      endIndex: match.index + match[0].length,
-    });
-  }
-
-  // 按出现顺序排序
-  tags.sort((a, b) => a.startIndex - b.startIndex);
-
-  // 处理标签和文本
-  let currentIndex = 0;
-  let resultText = "";
-
-  tags.forEach((tag) => {
-    // 添加标签前的文本
-    const textBeforeTag = html.substring(currentIndex, tag.startIndex);
-    if (textBeforeTag) {
-      resultText += textBeforeTag;
     }
-
-    // 生成占位符
-    const placeholder = `<${prefix}${counter}>`;
-
-    // 存储到映射对象
-    const key = `${prefix}${counter}`;
-    tagMap[key] = tag.fullMatch;
-
-    // 添加到结果文本
-    resultText += placeholder;
-
-    // 更新计数器
-    counter++;
-    currentIndex = tag.endIndex;
-  });
-
-  // 添加最后一个标签后的文本
-  const remainingText = html.substring(currentIndex);
-  if (remainingText) {
-    resultText += remainingText;
   }
-
-  return {
-    convertedText: resultText,
-    tagMap,
-  };
+  // 汇总失败项(登录失败也计入, 统一失败退出码1)
+  if (failList.length > 0) {
+    console.log(
+      chalk.red(`\n以下 ${failList.length} 项上传失败，请检查:\n- ${failList.join("\n- ")}`)
+    );
+    process.exit(1);
+  }
 }
-// let str = `<div class="translate">apple<p class="aa test">test</p>word</div>`;
+
+// 百度翻译接口
+async function translateFn(item, str, groupIndex, config) {
+  const { appid, key, from, to } = config;
+  const q = str;
+  const salt = Math.random();
+  const sign = md5(appid + q + salt + key);
+  const query = querystring.stringify({
+    q,
+    appid,
+    salt,
+    from,
+    to,
+    sign,
+  });
+  const url = "http://api.fanyi.baidu.com/api/trans/vip/translate?" + query;
+  return new Promise((resolve, reject) => {
+    // 自动翻译延时，必须大于 1000 ms，否则调用百度翻译 API 会失败
+    throttle(() => {
+      console.log(chalk.green(`正在翻译第${groupIndex}组数据`));
+      return request(url, function (_error, response, body) {
+        const resBody = JSON.parse(body);
+        if (resBody.trans_result) {
+          console.log(`ok`);
+          let result = resBody.trans_result || [];
+          item.forEach((item1, index1) => {
+            if (
+              result[index1] &&
+              result[index1].src === item1.from // 去除前后空格,原[ 执行人: ]翻译变成[执行人:]
+            ) {
+              item1.to = result[index1].dst;
+            }
+          });
+          resolve(true);
+        } else {
+          console.log(chalk.red(`error: ${body}`));
+          resolve(true);
+        }
+      });
+    });
+  });
+}
+
+function translate(allArr, config) {
+  let groupArr = []; // 分组后的数组
+  let newAllArr = []; // 分组后的数组还原成所有数组
+  let str = "";
+  let cutArr = [];
+  console.log(chalk.green(`共有${allArr.length}条数据需要翻译`));
+  replaceHtmlTag(allArr);
+  allArr.forEach((item, index) => {
+    if (str.length > 2000) {
+      groupArr.push(cutArr);
+      str = "";
+      cutArr = [];
+    }
+    str += item.from + "\n";
+    cutArr.push(item);
+  });
+  if (cutArr.length > 0) {
+    Array.prototype.push.apply(groupArr, [cutArr]);
+  } else {
+    groupArr = allArr;
+  }
+  console.log(chalk.green(`共有${groupArr.length}组数据需要翻译`));
+  const task = groupArr.map(async (item, index) => {
+    let str = "";
+    item.forEach((item1, index1) => {
+      // 去除换行空格
+      str += item1.from.replace(/\n/g, "") + "\n";
+    });
+    return translateFn(item, str, index + 1, config);
+  });
+  Promise.allSettled(task).then(async (res) => {
+    console.log(chalk.green("任务执行完毕"));
+    groupArr.forEach((item, index) => {
+      Array.prototype.push.apply(newAllArr, item);
+    });
+    config.originData.forEach((row, index) => {
+      if (index > 0) {
+        let {tagMap,to}= newAllArr[index - 1];
+        // 用占位符还原
+        // const toStr=
+        for (const key in tagMap) {
+          const value = tagMap[key];
+          to=to.replace(`<${key}>`, value);
+        }
+        row[config.toIndex] = to;
+      }
+    });
+    const buffer = xlsx.build([{ data: config.originData }]);
+    fs.writeFileSync(`./${config.excelFileName}`, buffer, "binary");
+    console.log(chalk.green(`更新文件成功`));
+  });
+}
+// 节流函数
+const delay = 2000;
+const throttle = (function (delay = 1500) {
+  const wait = [];
+  let canCall = true;
+  return function throttle(callback) {
+    if (!canCall) {
+      if (callback) wait.push(callback);
+      return;
+    }
+
+    callback();
+    canCall = false;
+    setTimeout(() => {
+      canCall = true;
+      if (wait.length) {
+        throttle(wait.shift());
+      }
+    }, delay);
+  };
+})(delay);
+// md5加密
+function md5(str) {
+  const md5 = crypto.createHash("md5");
+  md5.update(str);
+  return md5.digest("hex");
+}
+function replaceHtmlTag(arr) {
+  arr.forEach((item) => {
+    const str = item.from;
+    const { convertedText, tagMap } = convertHTMLToPlaceholders(str);
+    item.origin = str;
+    item.from = convertedText;
+    item.tagMap = tagMap;
+  });
+}
+/**
+ * 将HTML字符串转换为占位符格式，并存储标签映射
+ * @param {string} html - 输入的HTML字符串
+ * @param {string} prefix - 占位符前缀，默认为'N'
+ * @returns {Object} 包含转换后文本和标签映射的对象
+ */
+function convertHTMLToPlaceholders(html, prefix = "N") {
+  // 存储结果的标签映射对象
+  const tagMap = {};
+  let counter = 1;
+
+  // 使用正则表达式匹配所有HTML标签
+  // 包括自闭和标签和普通标签
+  const tagRegex = /<(\/)?([a-zA-Z][a-zA-Z0-9]*)(\s[^>]*)?(\/)?>/g;
+
+  // 先找出所有标签
+  const tags = [];
+  let match;
+  while ((match = tagRegex.exec(html)) !== null) {
+    tags.push({
+      fullMatch: match[0],
+      isClosing: match[1] === "/",
+      tagName: match[2],
+      attributes: match[3] || "",
+      isSelfClosing: match[4] === "/",
+      startIndex: match.index,
+      endIndex: match.index + match[0].length,
+    });
+  }
+
+  // 按出现顺序排序
+  tags.sort((a, b) => a.startIndex - b.startIndex);
+
+  // 处理标签和文本
+  let currentIndex = 0;
+  let resultText = "";
+
+  tags.forEach((tag) => {
+    // 添加标签前的文本
+    const textBeforeTag = html.substring(currentIndex, tag.startIndex);
+    if (textBeforeTag) {
+      resultText += textBeforeTag;
+    }
+
+    // 生成占位符
+    const placeholder = `<${prefix}${counter}>`;
+
+    // 存储到映射对象
+    const key = `${prefix}${counter}`;
+    tagMap[key] = tag.fullMatch;
+
+    // 添加到结果文本
+    resultText += placeholder;
+
+    // 更新计数器
+    counter++;
+    currentIndex = tag.endIndex;
+  });
+
+  // 添加最后一个标签后的文本
+  const remainingText = html.substring(currentIndex);
+  if (remainingText) {
+    resultText += remainingText;
+  }
+
+  return {
+    convertedText: resultText,
+    tagMap,
+  };
+}
+// let str = `<div class="translate">apple<p class="aa test">test</p>word</div>`;
 // console.log(convertHTMLToPlaceholders(str));
 
-function excelFn () {
-  // 1.获取上传文件路径
+// 翻译excel指定列语言(支持 --file/--lang/--appid/--key/--cache 一键, file+lang齐全时跳过选择)
+async function excelFn(cliOpts = {}) {
+  // 空字符串视为未传(与askOrUse语义一致)
+  const cliFile = cliOpts.file || undefined;
+  const cliLang = cliOpts.lang || undefined;
+  const cliAppid = cliOpts.appid || undefined;
+  const cliKey = cliOpts.key || undefined;
+  const cache = Boolean(cliOpts.cache);
+  // 1.获取excel文件列表, CLI传入file先校验存在性(快速失败, 不进交互)
   const choices = fs
     .readdirSync("./")
     .filter((item) => item.indexOf(".xlsx") > -1 || item.indexOf(".xls") > -1);
-  //  2. 选择上传文件
-  inquirer
-    .prompt([
+  if (choices.length === 0) {
+    console.log(chalk.red("当前目录下没有excel文件(.xlsx/.xls)"));
+    process.exit(1);
+  }
+  if (cliFile !== undefined && !choices.includes(cliFile)) {
+    console.log(chalk.red(`当前目录不存在excel文件: ${cliFile}`));
+    process.exit(1);
+  }
+  // 2.选择excel文件(CLI参数 > 交互)
+  let excelFileName;
+  if (cliFile !== undefined) {
+    excelFileName = cliFile;
+  } else {
+    const res = await inquirer.prompt([
       {
         type: "rawlist",
         name: "excelFileName",
@@ -664,131 +889,116 @@ function excelFn () {
           return "请选择项目";
         },
       },
-    ])
-    .then(async (res) => {
-      const { excelFileName } = res;
-      // 2.读取excel
-      const uploadFilePath = "./" + excelFileName;
-      const workSheetsFromFile = xlsx.parse(uploadFilePath);
-      const data = workSheetsFromFile[0].data;
-      //   获取第一行
-      const titleList = data[0];
-      const zhIndex = titleList.findIndex((item) => item === "zhCn");
-      const enIndex = titleList.findIndex((item) => item === "en");
-      const languageList = titleList.slice(enIndex);
-      const { language } = await inquirer.prompt([
-        {
-          type: "rawlist",
-          name: "language",
-          message: `请选择要翻译的语言\n${chalk.red("注意:\n")}${chalk.green(
-            "1. 英文基于中文翻译\n2. 非英文基于英文翻译"
-          )}`,
-          choices: languageList,
-          validate: function (val) {
-            if (val) {
-              return true;
-            }
-            return "请选择";
-          },
+    ]);
+    excelFileName = res.excelFileName;
+  }
+  // 3.读取excel
+  const uploadFilePath = "./" + excelFileName;
+  const workSheetsFromFile = xlsx.parse(uploadFilePath);
+  const data = workSheetsFromFile[0].data;
+  // 获取第一行
+  const titleList = data[0];
+  const zhIndex = titleList.findIndex((item) => item === "zhCn");
+  const enIndex = titleList.findIndex((item) => item === "en");
+  const languageList = titleList.slice(enIndex);
+  // 4.选择语言列(CLI参数 > 交互), CLI传入先校验在该excel语言列中(快速失败)
+  let language;
+  if (cliLang !== undefined) {
+    if (!languageList.includes(cliLang)) {
+      console.log(
+        chalk.red(
+          `参数 --lang 的值 "${cliLang}" 不在该excel的语言列中, 可选值: ${languageList.join(
+            " | "
+          )}`
+        )
+      );
+      process.exit(1);
+    }
+    language = cliLang;
+  } else {
+    const res = await inquirer.prompt([
+      {
+        type: "rawlist",
+        name: "language",
+        message: `请选择要翻译的语言\n${chalk.red("注意:\n")}${chalk.green(
+          "1. 英文基于中文翻译\n2. 非英文基于英文翻译"
+        )}`,
+        choices: languageList,
+        validate: function (val) {
+          if (val) {
+            return true;
+          }
+          return "请选择";
         },
-        {
-          type: "confirm", // 获取上一个选中结果
-          name: "isTranslate",
-          message: ({ language }) => {
-            return `是否翻译${chalk.red(language)}`;
-          },
-          default: true,
-          prefix: "Y", // 添加前缀符号
+      },
+      {
+        type: "confirm", // 获取上一个选中结果
+        name: "isTranslate",
+        message: ({ language }) => {
+          return `是否翻译${chalk.red(language)}`;
         },
-      ]);
-      const content = data.slice(1);
-      const zhArr = content.map((row) => {
-        return {
-          from: row[zhIndex],
-        };
-      });
-      const enArr = content.map((row) => {
-        return {
-          from: row[enIndex],
-        };
-      });
-      let transArr = language === "en" ? zhArr : enArr;
-      await inquirer
-        .prompt([
-          {
-            message: "请选择翻译接口",
-            name: "type",
-            type: "list",
-            choices: [
-              {
-                name: "百度翻译",
-                value: "baidu",
-              },
-            ],
-          },
-        ])
-        .then((res) => {
-          const { type } = res;
-          let cacheSecret = {};
-          if (!isExistPath(getRunCliPath({ root: true }) + "/.cache")) {
-            fs.mkdirSync(getRunCliPath({ root: true }) + "/.cache");
+        default: true,
+        prefix: "Y", // 添加前缀符号
+      },
+    ]);
+    language = res.language;
+  }
+  const content = data.slice(1);
+  const zhArr = content.map((row) => {
+    return {
+      from: row[zhIndex],
+    };
+  });
+  const enArr = content.map((row) => {
+    return {
+      from: row[enIndex],
+    };
+  });
+  let transArr = language === "en" ? zhArr : enArr;
+  // 5.凭据: CLI参数 > --cache缓存 > 交互(展示缓存默认值), 翻译接口当前仅百度, 一键时自动选择
+  const secret = await resolveSecretQuestions({
+    questions: [
+      {
+        message: "请输入百度翻译的appid",
+        name: "appid",
+        // 必填
+        validate: function (val) {
+          if (val) {
+            return true;
           }
-          const cacheFilePath =
-            getRunCliPath({ root: true }) + "/.cache/" + res.type;
-          if (isExistPath(cacheFilePath)) {
-            const cache = JSON.parse(readCache(res.type));
-            cacheSecret = cache;
+          return "请输入百度翻译的appid";
+        },
+      },
+      {
+        message: "请输入百度翻译的key",
+        name: "key",
+        // 必填
+        validate: function (val) {
+          if (val) {
+            return true;
           }
-          const question = [
-            {
-              message: "请输入百度翻译的appid",
-              name: "appid",
-              default: cacheSecret.appid,
-              // 必填
-              validate: function (val) {
-                if (val) {
-                  return true;
-                }
-                return "请输入百度翻译的appid";
-              },
-            },
-            {
-              message: "请输入百度翻译的key",
-              name: "key",
-              default: cacheSecret.key,
-              // 必填
-              validate: function (val) {
-                if (val) {
-                  return true;
-                }
-                return "请输入百度翻译的key";
-              },
-            },
-          ];
-          inquirer.prompt(question).then((res) => {
-            writeCache(
-              type,
-              JSON.stringify({
-                type,
-                ...res,
-              })
-            );
-            const { appid, key } = res;
-            const baiduLang = {
-              vi: "vie", // 越南语
-            };
-            translate(transArr, {
-              originData: data,
-              excelFileName,
-              appid,
-              key,
-              from: language === "en" ? "zh" : "en",
-              to: baiduLang[language] || language,
-              toIndex: titleList.findIndex((item) => item === language),
-            });
-          });
-        });
-    });
+          return "请输入百度翻译的key";
+        },
+      },
+    ],
+    cliValues: { appid: cliAppid, key: cliKey },
+    useCache: cache,
+    cacheKey: "baidu",
+    extraCache: { type: "baidu" },
+  });
+  const { appid, key } = secret;
+  const baiduLang = {
+    vi: "vie", // 越南语
+  };
+  translate(transArr, {
+    originData: data,
+    excelFileName,
+    appid,
+    key,
+    from: language === "en" ? "zh" : "en",
+    to: baiduLang[language] || language,
+    toIndex: titleList.findIndex((item) => item === language),
+  });
 }
 
 // 获取应用list
@@ -825,7 +1035,41 @@ function getApplicationList({ appName, env, token }) {
             })
           );
         } else {
-          console.log(chalk.red(error || JSON.stringify(res.data)));
+          const errorData = error || JSON.stringify(res.data);
+          console.log(chalk.red(errorData));
+          reject(errorData);
+        }
+      }
+    );
+  });
+}
+// 获取应用配置
+function getApplicationConfig({ appId, env, token }) {
+  Loading$1.start(`获取应用配置中...`);
+  return new Promise((resolve, reject) => {
+    request(
+      {
+        url: `https://${
+          env === "pro" ? "" : `${env}-`
+        }hxjf.hongxinshop.com/api-u/api/saas/app/info`,
+        method: "POST",
+        json: true,
+        body: { id: appId },
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "x-request-vaildate": "open",
+        },
+      },
+      function (error, response, body) {
+        const res = body;
+        if (!error && res.code == 200) {
+          Loading$1.succeed(`获取应用配置成功`);
+          resolve(res.data);
+        } else {
+          Loading$1.fail(`获取应用配置失败`);
+          const errorData = error || JSON.stringify(res.data);
+          console.log(chalk.red(errorData));
+          reject(errorData);
         }
       }
     );
@@ -855,7 +1099,9 @@ function getApplicationButtonConfig({ appId, env, token }) {
           resolve(res.data);
         } else {
           Loading$1.fail(`获取${env}环境按钮权限配置失败`);
-          console.log(chalk.red(error || JSON.stringify(res.data)));
+          const errorData = error || JSON.stringify(res.data);
+          console.log(chalk.red(errorData));
+          reject(errorData);
         }
       }
     );
@@ -914,15 +1160,64 @@ function addApplicationButtonConfig({ data, env, token }) {
           resolve(true);
         } else {
           Loading$1.fail(`${data.code}`);
-          console.log(chalk.red(error || JSON.stringify(res.data)));
+          const errorData = error || JSON.stringify(res.data);
+          console.log(chalk.red(errorData));
+          reject(errorData);
         }
       }
     );
   });
 }
-async function syncSassConfig() {
-  inquirer
-    .prompt([
+// -sass 入口: 功能路由(--action 显式指定 > --from/--to 推断同步 > --permission-* 推断新增 > 菜单)
+async function sassMain(rawCliOpts = {}) {
+  // 空字符串视为未传(与askOrUse语义一致)
+  const sassOpts = {
+    ...rawCliOpts,
+    action: rawCliOpts.action || undefined,
+    from: rawCliOpts.from || undefined,
+    to: rawCliOpts.to || undefined,
+    app: rawCliOpts.app || undefined,
+    env: rawCliOpts.env || undefined,
+    permissionName: rawCliOpts.permissionName || undefined,
+    permissionCode: rawCliOpts.permissionCode || undefined,
+  };
+  const { action, from, to, permissionName, permissionCode } = sassOpts;
+  if (action !== undefined) {
+    validateChoice(action, ["sync", "permission"], "--action");
+    return action === "permission"
+      ? addSassPermission(sassOpts)
+      : syncSassFlow(sassOpts);
+  }
+  if (from !== undefined || to !== undefined) {
+    return syncSassFlow(sassOpts);
+  }
+  if (permissionName !== undefined || permissionCode !== undefined) {
+    return addSassPermission(sassOpts);
+  }
+  const { menuAction } = await inquirer.prompt([
+    {
+      message: "请选择功能",
+      name: "menuAction",
+      type: "list",
+      choices: [
+        { name: "同步按钮权限配置", value: "sync" },
+        { name: "新增按钮权限", value: "permission" },
+      ],
+    },
+  ]);
+  return menuAction === "permission"
+    ? addSassPermission(sassOpts)
+    : syncSassFlow(sassOpts);
+}
+
+// 同步流程(支持 --from/--to/--app 一键, 参数齐全时跳过使用须知)
+async function syncSassFlow(cliOpts) {
+  const { from: cliFrom, to: cliTo, app: cliApp } = cliOpts;
+  const envList = ["mit", "sit", "uat"];
+  const oneClick =
+    cliFrom !== undefined && cliTo !== undefined && cliApp !== undefined;
+  if (!oneClick) {
+    const { notice } = await inquirer.prompt([
       {
         message: `使用须知:
         ${chalk.green(`
@@ -935,1121 +1230,1350 @@ async function syncSassConfig() {
         type: "confirm",
         default: false,
       },
-      {
-        message: "请选择从哪个环境同步配置",
-        name: "from",
-        type: "list",
-        choices: ["mit", "sit", "uat"],
-        when: (answers) => answers.notice,
-      },
-      {
-        message: "请选择同步至哪个环境",
-        name: "to",
-        type: "list",
-        when: (answers) => answers.notice,
-        choices: (answers) => {
-          const list = ["mit", "sit", "uat"];
-          return list.filter((item) => item !== answers.from);
-        },
-      },
-    ])
-    .then(async (answers) => {
-      const { from, to,notice } = answers;
-      if(!notice){
-        return
-        }
-      const token = await login({
-        env: from,
-        username: "superAdmin",
-        password: "admin1",
-      });
-      const { inputAppName } = await inquirer.prompt([
-        {
-          message: "请输入应用名称关键字",
-          name: "inputAppName",
-          type: "input",
-          validate: function (value) {
-            if (value) {
-              return true;
-            }
-            return "请输入应用名称";
-          },
-        },
-      ]);
-      const applicationList = await getApplicationList({
-        env: from,
-        token,
-        appName: inputAppName,
-      });
-      const { appName } = await inquirer.prompt([
-        {
-          message: "请选择应用名称",
-          name: "appName",
-          type: "rawlist",
-          choices: applicationList,
-        },
-      ]);
-      const appId = applicationList.find((item) => item.name === appName).id;
-      //   let appConfig = await getApplicationConfig({ appId, env: from, token });
-      const fromButtonList = await getApplicationButtonConfig({
-        appId,
-        env: from,
-        token,
-      });
-      if (!fromButtonList.length) {
-        return console.log(chalk.red("按钮权限配置为空,无法同步"));
-      }
-      console.log(`开始同步到${to}🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀`);
-      const toToken = await login({
-        env: to,
-        username: "superAdmin",
-        password: "admin1",
-      });
-      const toApplicationList = await getApplicationList({
-        env: to,
-        token: toToken,
-        appName,
-      });
-      if (!toApplicationList.length) {
-        return console.log(chalk.red(`${to}环境不存在该应用`));
-      }
-      const toAppId = toApplicationList[0].id;
-      const toButtonList = await getApplicationButtonConfig({
-        appId: toAppId,
-        env: to,
-        token: toToken,
-      });
-      try {
-        if (toButtonList.length) {
-          const deleteButtonPromiseList = toButtonList.map((item) => {
-            return deleteApplicationButtonConfig({
-              data: {
-                id: item.id,
-                ver: item.ver,
-              },
-              env: to,
-              token: toToken,
-            });
-          });
-          Loading$1.start(`删除${to}环境按钮权限配置中...`);
-          await Promise.all(deleteButtonPromiseList);
-          Loading$1.succeed(`删除${to}环境按钮权限配置成功`);
-        }
-      } catch (error) {
-        console.log(chalk.red(`删除${to}环境按钮权限配置失败`));
-      } finally {
-        for (const item of fromButtonList) {
-          const { code, name, visitConf } = item;
-          await addApplicationButtonConfig({
-            env: to,
-            token: toToken,
-            data: {
-              code1: code.split(":")[0],
-              code,
-              name,
-              visitConf,
-              ascriptionApp: toAppId,
-            },
-          });
-        }
-        console.log(chalk.green("同步成功"));
-      }
-    });
-}
-
-/**
- * @fileoverview 不要单独中文
- * @author ypf
- */
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('eslint').Rule.RuleModule} */
-
-// 判断字符串是否是中文
-const isChinese = (str) => {
-  return /[\u4e00-\u9fa5]+/.test(str);
-};
-//去除特殊字符，包含空格
-function trimSpecial(string = "", formatter) {
-  // const pattern =
-  //   /[`~!@#$^\-&*()=|{}':;',\\\[\]\.<>\/?~！@#￥……&*（）——|{}【】'；：""'。，、？\s]/g;
-  // return string.replace(pattern, "");
-  // console.log(string);
-  // 获取开头空白符的位置
-  const startIdx = string.search(/\S/) - 1;
-  // 获取结尾空白符的位置
-  const endIdx = string.search(/\S\s*$/) + 1;
-  // 获取开头和结尾的字符串
-  const startStr = string.slice(0, startIdx + 1);
-  const endStr = string.slice(endIdx);
-  // 获取中间的字符串
-  const middle = string.slice(startIdx + 1, endIdx);
-  // 取出中间字符串的换行符
-  const middleStr = middle.replace(/\n/g, "");
-  return startStr + formatter(middleStr) + endStr;
-}
-// 判断当前节点是否已经翻译过
-function isTranslate(node) {
-  if (
-    node.parent?.parent?.parent?.type === "CallExpression" &&
-    node.parent?.parent?.parent?.callee?.name === "$hxt"
-  ) {
-    return true;
+    ]);
+    if (!notice) {
+      return;
+    }
   }
-  // console不翻译
-  if (
-    node.parent.type === "CallExpression" &&
-    node.parent.callee?.object?.name === "console"
-  ) {
-    return true;
+  if (cliFrom !== undefined) {
+    validateChoice(cliFrom, envList, "--from");
   }
-
-  return false;
-}
-
-// 空key
-const emptyKeyRules = (context) => {
-  return {
-    CallExpression(node) {
-      if (node.callee.name === "$hxt") {
-        const properties = node.arguments[0]?.properties || [];
-        // 如果属性是key且值为空
-        const result = properties.some((item) => {
-          // 去除key空格
-          const key = item.key.name.replace(/\s/g, "");
-          if (key === "key") {
-            // 去除value空格
-            // value是模版字符串
-            let value = "";
-            if (item.value.type === "TemplateLiteral") {
-              value = item.value.quasis[0].value.raw.replace(/\s/g, "");
-            } else if (item.value.type === "Literal") {
-              value = item.value.value.replace(/\s/g, "");
-            }
-            if (value === "") {
-              return true;
-            }
-          }
-        });
-        if (result) {
-          context.report({
-            node: node,
-            messageId: "noSingleChinese",
-            data: {
-              raw: chalk.green("key为空"),
-            },
-            fix: (fixer) => {},
-          });
-        }
+  const from = await askOrUse(cliFrom, {
+    message: "请选择从哪个环境同步配置",
+    name: "from",
+    type: "list",
+    choices: envList,
+  });
+  if (cliTo !== undefined) {
+    validateChoice(cliTo, envList, "--to");
+    if (cliTo === from) {
+      console.log(chalk.red("参数 --to 的值须不同于 --from"));
+      process.exit(1);
+    }
+  }
+  const to = await askOrUse(cliTo, {
+    message: "请选择同步至哪个环境",
+    name: "to",
+    type: "list",
+    choices: envList.filter((item) => item !== from),
+  });
+  let token;
+  try {
+    token = await login({
+      env: from,
+      username: "superAdmin",
+      password: "admin1",
+    });
+  } catch (e) {
+    console.log(chalk.red(`${from} 登录失败: ${e.message || e}`));
+    process.exit(1);
+  }
+  const inputAppName = await askOrUse(cliApp, {
+    message: "请输入应用名称关键字",
+    name: "inputAppName",
+    type: "input",
+    validate: function (value) {
+      if (value) {
+        return true;
       }
+      return "请输入应用名称";
     },
-  };
-};
-var noSingleChineseRule = {
-  meta: {
-    type: "suggestion", // `problem`, `suggestion`, or `layout`
-    docs: {
-      description: "不要单独中文",
-      recommended: false,
-      url: null, // URL to the documentation page for this rule
+  });
+  let applicationList;
+  try {
+    applicationList = await getApplicationList({
+      env: from,
+      token,
+      appName: inputAppName,
+    });
+  } catch (e) {
+    console.log(chalk.red(`查询${from}环境应用列表失败: ${e.message || e}`));
+    process.exit(1);
+  }
+  const { appName } = await inquirer.prompt([
+    {
+      message: "请选择应用名称",
+      name: "appName",
+      type: "rawlist",
+      choices: applicationList,
     },
-    fixable: "code", // Or `code` or `whitespace`
-    schema: [], // Add a schema if the rule has options
-    messages: {
-      noSingleChinese: "不要单独中文: {{raw}}",
-    }, // Add messageId and message
-  },
-  create(context) {
-    const sourceCode = context.sourceCode;
-    context.filename;
-    // console.log(filename,999999)
-    return context.parserServices.defineTemplateBodyVisitor(
-      // Event handlers for <template>.
-      {
-        // 纯字符串,如 测试
-        VText(node) {
-          // 如果是中文,替换为 {{ $hxt({key:'',desc:'中文'})}}
-          if (!isTranslate(node)) {
-            if (isChinese(node.value)) {
-              context.report({
-                node,
-                messageId: "noSingleChinese",
-                data: {
-                  raw: chalk.green(node.value),
-                },
-                // message: `VText`,
-                fix: (fixer) => {
-                  return fixer.replaceText(
-                    node,
-                    trimSpecial(node.value, (middle) => {
-                      return "{{ $hxt({key:'',desc:'" + middle + "'})}}";
-                    })
-                  );
-                },
-              });
-            }
-          }
-        },
-        // 纯字符串,如 {{ mini ? '测试' : `开启` }}中的测试
-        // 纯字符串,如 {{test('测试')}}中的测试
-        Literal(node) {
-          if (!isTranslate(node)) {
-            if (isChinese(node.value)) {
-              context.report({
-                node,
-                messageId: "noSingleChinese",
-                data: {
-                  raw: chalk.green(node.value),
-                },
-                // message: `Literal`,
-                fix: (fixer) => {
-                  // console.log(1111, node);
-                  return fixer.replaceText(
-                    node,
-                    trimSpecial(node.value, (middle) => {
-                      return "$hxt({key:'',desc:'" + middle + "'})";
-                    })
-                  );
-                },
-              });
-            }
-          }
-        },
-        // 模版字符串,
-        // 如{{ mini ? '测试' : `开启` }}中的开启
-        // 如{{ mini ? `${a}测试` : "开启" }}中的${a}测试
-        // 如{{`111`}}
-        // 如<p :a="`${a}册书`">
-        TemplateLiteral(node) {
-          if (!isTranslate(node)) {
-            const textSource = sourceCode.getText(node);
-            let text = textSource;
-            // 删除$符号
-            text = text.replace(/\${/g, "{");
-            if (isChinese(text)) {
-              // 获取expressions的文本
-              const expressionsText = node.expressions.map((item) => {
-                return sourceCode.getText(item);
-              });
-              let expressionStr = "";
-              if (expressionsText.length) {
-                expressionsText.forEach((item, index) => {
-                  const key = `slot${index + 1}`;
-                  text = text.replace(item, `${key}`);
-                  expressionStr += `${key}:${item},`;
-                });
-                // 删除最后一个逗号
-                expressionStr = `{${expressionStr.slice(0, -1)}}`;
-              }
-              if (!isChinese(text)) {
-                return;
-              }
-              context.report({
-                node,
-                data: {
-                  raw: chalk.green(textSource),
-                },
-                messageId: "noSingleChinese",
-                // message: `TemplateLiteral`,
-                fix: (fixer) => {
-                  return fixer.replaceText(
-                    node,
-                    trimSpecial(text, (middle) => {
-                      return `$hxt({key:'',desc:${middle}}${
-                        expressionStr ? `,${expressionStr}` : ""
-                      })`;
-                    })
-                  );
-                },
-              });
-            }
-          }
-        },
-        // 如<p title="1">
-        VLiteral(node) {
-          if (!isTranslate(node)) {
-            if (isChinese(node.value)) {
-              context.report({
-                node,
-                messageId: "noSingleChinese",
-                // message: `VLiteral`,
-                data: {
-                  raw: chalk.green(node.value),
-                },
-
-                fix: (fixer) => {
-                  // 父节点需要改为冒号方式
-                  const parentNode = node.parent;
-                  if (parentNode.type === "VAttribute") {
-                    const key = parentNode.key;
-                    return fixer.replaceText(
-                      parentNode,
-                      ":" +
-                        key.name +
-                        "=" +
-                        '"' +
-                        trimSpecial(node.value, (middle) => {
-                          return "$hxt({key:'',desc:'" + middle + "'})";
-                        }) +
-                        '"'
-                    );
-                  }
-                },
-              });
-            }
-          }
-        },
-        // 如 <p v-permission="测试">中的测试
-        Identifier(node) {
-          if (
-            !isTranslate(node) &&
-            node.parent.type === "VExpressionContainer"
-          ) {
-            if (isChinese(node.name)) {
-              context.report({
-                node,
-                messageId: "noSingleChinese",
-                // message: `Identifier`,
-                data: {
-                  raw: chalk.green(node.name),
-                },
-                fix: (fixer) => {
-                  return fixer.replaceText(
-                    node,
-                    trimSpecial(node.name, (middle) => {
-                      return "$hxt({key:'',desc:'" + middle + "'})";
-                    })
-                  );
-                },
-              });
-            }
-          }
-        },
-        ...emptyKeyRules(context),
-      },
-      // Event handlers for <script> or scripts. (optional)
-      {
-        JSXText(node) {
-          if (!isTranslate(node)) {
-            if (isChinese(node.value)) {
-              context.report({
-                node,
-                messageId: "noSingleChinese",
-                data: {
-                  raw: chalk.green(node.value),
-                },
-                fix: (fixer) => {
-                  return fixer.replaceText(
-                    node,
-                    trimSpecial(node.value, (middle) => {
-                      return "{ $hxt({key:'',desc:'" + middle + "'})}";
-                    })
-                  );
-                },
-              });
-            }
-          }
-        },
-        TemplateLiteral(node) {
-          if (!isTranslate(node)) {
-            const textSource = sourceCode.getText(node);
-            let text = textSource;
-            // 删除$符号
-            text = text.replace(/\${/g, "{");
-            if (isChinese(text)) {
-              // 获取expressions的文本
-              const expressionsText = node.expressions.map((item) => {
-                return sourceCode.getText(item);
-              });
-              // console.log(expressionsText,111)
-              let expressionStr = "";
-              if (expressionsText.length) {
-                expressionsText.forEach((item, index) => {
-                  const key = `slot${index + 1}`;
-                  text = text.replace(item, `${key}`);
-                  expressionStr += `${key}:${item},`;
-                });
-                // 删除最后一个逗号
-                expressionStr = `{${expressionStr.slice(0, -1)}}`;
-              }
-              if (!isChinese(text)) {
-                return;
-              }
-              context.report({
-                node,
-                messageId: "noSingleChinese",
-                data: {
-                  raw: chalk.green(textSource),
-                },
-                // message: `TemplateLiteral`,
-                fix: (fixer) => {
-                  //  return console.log(text,expressionStr)
-                  // trimSpecial(text, (middle) => {
-                  //   return `$hxt({key:'',desc:${middle}}${
-                  //     expressionStr ? `,${expressionStr}` : ""
-                  //   })`;
-                  // })
-                  // return
-                  return fixer.replaceText(
-                    node,
-                    trimSpecial(text, (middle) => {
-                      return `$hxt({key:'',desc:${middle}}${
-                        expressionStr ? `,${expressionStr}` : ""
-                      })`;
-                    })
-                  );
-                },
-              });
-            }
-          }
-        },
-        Literal(node) {
-          // 如果正则忽略
-          if (node.regex) return;
-          if (!isTranslate(node)) {
-            if (isChinese(node.value)) {
-              // 增加{}包裹  render(){return <p title={'测试'} title="测试" title={`${1}测试`}>内容 {`测试`}</p>} 中的内容
-              if (node.parent.type === "JSXAttribute") {
-                context.report({
-                  node,
-                  messageId: "noSingleChinese",
-                  data: {
-                    raw: chalk.green(node.value),
-                  },
-                  fix: (fixer) => {
-                    return fixer.replaceText(
-                      node,
-                      trimSpecial(node.value, (middle) => {
-                        return "{$hxt({key:'',desc:'" + middle + "'})}";
-                      })
-                    );
-                  },
-                });
-              } else {
-                context.report({
-                  node,
-                  messageId: "noSingleChinese",
-                  data: {
-                    raw: chalk.green(node.value),
-                  },
-                  fix: (fixer) => {
-                    return fixer.replaceText(
-                      node,
-                      trimSpecial(node.value, (middle) => {
-                        return "$hxt({key:'',desc:'" + middle + "'})";
-                      })
-                    );
-                  },
-                });
-              }
-            }
-          }
-        },
-        ...emptyKeyRules(context),
-      }
+  ]);
+  const appId = applicationList.find((item) => item.name === appName).id;
+  let fromButtonList;
+  try {
+    fromButtonList = await getApplicationButtonConfig({
+      appId,
+      env: from,
+      token,
+    });
+  } catch (e) {
+    console.log(
+      chalk.red(`获取${from}环境按钮权限配置失败: ${e.message || e}`)
     );
-  },
-};
-
-/**
- * @fileoverview 不能单独金额
- * @author ypf
- */
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('eslint').Rule.RuleModule} */
-const inputTagNameList = [
-  "el-input",
-  "ElInput",
-  "hx-input",
-  "HxInput",
-  "van-field",
-  "VanField",
-  "hxmb-field",
-  "HxmbField",
-]; // input标签
-const formTagNameList = ["hx-form", "HxForm", "HxmForm", "hxmb-form"]; // form标签
-// 匹配金额名
-const currencyList = [
-  // "currency",
-  "total",
-  "price",
-  "amount",
-];
-// 价格后缀过滤
-const notIncludeCurrencySuffixList = [
-  "code",
-  "type",
-  "no",
-  "status",
-  "name",
-  "sort",
-  "source",
-  "qty",
-];
-// 关键字属性
-const keyPropList = ["prop", "name", "id", "key"];
-const hasCurrencyName = (str) => {
-  return currencyList.some((item) => {
-    str = str.toLowerCase();
-    const suffix = str.split(item)[1]?.toLowerCase();
-    if (str.includes(item)) {
-      if(suffix){
-        return !notIncludeCurrencySuffixList.some((item) =>
-          suffix.includes(item)
-        );
-      }
-      return true
+    process.exit(1);
+  }
+  if (!fromButtonList.length) {
+    console.log(chalk.red("按钮权限配置为空,无法同步"));
+    process.exit(1);
+  }
+  console.log(`开始同步到${to}🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀`);
+  let toToken;
+  try {
+    toToken = await login({
+      env: to,
+      username: "superAdmin",
+      password: "admin1",
+    });
+  } catch (e) {
+    console.log(chalk.red(`${to} 登录失败: ${e.message || e}`));
+    process.exit(1);
+  }
+  let toApplicationList;
+  try {
+    toApplicationList = await getApplicationList({
+      env: to,
+      token: toToken,
+      appName,
+    });
+  } catch (e) {
+    console.log(chalk.red(`查询${to}环境应用列表失败: ${e.message || e}`));
+    process.exit(1);
+  }
+  if (!toApplicationList.length) {
+    console.log(chalk.red(`${to}环境不存在该应用`));
+    process.exit(1);
+  }
+  const toAppId = toApplicationList[0].id;
+  let toButtonList;
+  try {
+    toButtonList = await getApplicationButtonConfig({
+      appId: toAppId,
+      env: to,
+      token: toToken,
+    });
+  } catch (e) {
+    console.log(chalk.red(`获取${to}环境按钮权限配置失败: ${e.message || e}`));
+    process.exit(1);
+  }
+  try {
+    if (toButtonList.length) {
+      const deleteButtonPromiseList = toButtonList.map((item) => {
+        return deleteApplicationButtonConfig({
+          data: {
+            id: item.id,
+            ver: item.ver,
+          },
+          env: to,
+          token: toToken,
+        });
+      });
+      Loading$1.start(`删除${to}环境按钮权限配置中...`);
+      await Promise.all(deleteButtonPromiseList);
+      Loading$1.succeed(`删除${to}环境按钮权限配置成功`);
     }
-    return false;
-  });
-};
-var noSingleCurrencyRule = {
-  meta: {
-    type: "suggestion", // `problem`, `suggestion`, or `layout`
-    docs: {
-      description: "不能单独金额",
-      recommended: false,
-      url: null, // URL to the documentation page for this rule
-    },
-    fixable: null, // Or `code` or `whitespace`
-    schema: [], // Add a schema if the rule has options
-    messages: {
-      noSingleCurrency: "不要单独币种: {{raw}}",
-    }, // Add messageId and message
-  },
-
-  create(context) {
-    const sourceCode = context.sourceCode;
-    // 获取路径
-    const filename = context.filename;
-    return context.parserServices.defineTemplateBodyVisitor(
-      // Event handlers for <template>.
-      {
-        //  模版标签, 如<el-input >
-        VElement(node) {
-          const tagName = node.rawName;
-          if (inputTagNameList.indexOf(tagName) > -1) {
-            const attrs = node.startTag.attributes;
-            // 遍历找到v-model 属性
-            attrs.some((attr) => {
-              const attrTextSource = sourceCode.getText(attr);
-              if (attr.key?.name?.name === "model") {
-                const textSource = sourceCode.getText(attr.value);
-                // 如果包含currency、price、amount，则报错
-                if (hasCurrencyName(textSource)) {
-                  context.report({
-                    node,
-                    data: {
-                      raw:
-                        chalk.red(`Template|<${tagName}> `) +
-                        chalk.green(attrTextSource),
-                    },
-                    messageId: "noSingleCurrency",
-                    // message: `TemplateLiteral`,
-                    fix: (fixer) => {},
-                  });
-                }
-              }
-              return false;
-            });
-          }
-        },
-      },
-      // Event handlers for <script> or scripts. (optional)
-      {
-        // jsx 标签,如 render() { return <el-input /> } 中的<el-input />
-        //  <el-form formItemList=[]>中的formItemList
-        JSXElement(node) {
-          // console.log(node,'node')
-          const tagName = node?.openingElement?.name?.name;
-          // input
-          if (inputTagNameList.indexOf(tagName) > -1) {
-            // 遍历找到vModel 属性
-            const attrs = node.openingElement.attributes;
-            attrs.some((attr) => {
-              const attrTextSource = sourceCode.getText(attr);
-              // console.log(attrTextSource,'attrTextSource')
-              if (attr.name.name === "vModel") {
-                const textSource = sourceCode.getText(attr.value);
-                // 如果包含币种
-                if (hasCurrencyName(textSource)) {
-                  context.report({
-                    node,
-                    data: {
-                      raw:
-                        chalk.red(`JSX|<${tagName}> `) +
-                        chalk.green(attrTextSource),
-                    },
-                    messageId: "noSingleCurrency",
-                    // message: `TemplateLiteral`,
-                    fix: (fixer) => {},
-                  });
-                }
-              }
-            });
-          }
-          // form
-          if (formTagNameList.indexOf(tagName)) {
-            const attrs = node.openingElement.attributes;
-            // 遍历找到formItemList 属性
-            attrs.some((attr) => {
-              sourceCode.getText(attr);
-              // 是formItemList
-              if (attr?.name?.name === "formItemList") {
-                // 且值是数组
-                if (attr?.value?.expression?.type === "ArrayExpression") {
-                  // 遍历数组
-                  attr.value.expression.elements.forEach((item) => {
-                    (item.properties || []).some((item) => {
-                      const attrTextSource = sourceCode.getText(item);
-                      if (keyPropList.indexOf(item.key.name) > -1) {
-                        const textSource = sourceCode.getText(item.value);
-                        if (item?.value?.type === "CallExpression") return;
-                        // 如果包含币种
-                        if (hasCurrencyName(textSource)) {
-                          context.report({
-                            node,
-                            data: {
-                              raw:
-                                chalk.red(`JSX|${tagName}|${attr.name.name} `) +
-                                chalk.green(`${attrTextSource}`),
-                            },
-                            messageId: "noSingleCurrency",
-                            // message: `TemplateLiteral`,
-                            fix: (fixer) => {},
-                          });
-                        }
-                      }
-                    });
-                  });
-                }
-              }
-            });
-          }
-        },
-        // [{prop:'price'}]
-        ArrayExpression(node) {
-          // 不检测路由文件
-          if (filename.includes("src/router")) return;
-          // 是数组且不是jsx属性上的数组(上面已经检测过了,否则会出现2条错误)
-          if (node.parent?.parent?.type === "JSXAttribute") return;
-          (node.elements || []).forEach((item) => {
-            // 数组里面是对象
-            if (item?.type === "ObjectExpression") {
-              (item.properties || []).forEach((item) => {
-                const attrTextSource = sourceCode.getText(item);
-                if (keyPropList.indexOf(item?.key?.name) > -1) {
-                  if (item?.value?.type === "CallExpression") return;
-                  const textSource = sourceCode.getText(item.value);
-                  // 如果包含币种
-                  if (hasCurrencyName(textSource)) {
-                    context.report({
-                      node,
-                      data: {
-                        raw:
-                          chalk.red(`JSX|[{}] `) +
-                          chalk.green(`${attrTextSource}`),
-                      },
-                      messageId: "noSingleCurrency",
-                    });
-                  }
-                }
-              });
-            }
-          });
-        },
+  } catch (error) {
+    console.log(chalk.red(`删除${to}环境按钮权限配置失败`));
+  } finally {
+    try {
+      for (const item of fromButtonList) {
+        const { code, name, visitConf } = item;
+        await addApplicationButtonConfig({
+          env: to,
+          token: toToken,
+          data: {
+            code1: code.split(":")[0],
+            code,
+            name,
+            visitConf,
+            ascriptionApp: toAppId,
+          },
+        });
       }
-    );
-  },
-};
-
-/**
- * @fileoverview 不能单独金额
- * @author ypf
- */
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
+      console.log(chalk.green("同步成功"));
+    } catch (e) {
+      console.log(chalk.red(`同步失败: ${e.message || e}`));
+      process.exit(1);
+    }
+  }
+}
 
-/** @type {import('eslint').Rule.RuleModule} */
-const tagNameList = ["hx-search-list-page", "HxSearchListPage"];
-const attrNameList = ["custom-column-module", "customColumnModule"];
-const moduleArr = [];
-const getModuleArr = () => moduleArr;
-const addModule = (moduleObj) => {
-  const isExist= moduleArr.some((item) => {
-    return item.module === moduleObj.module
+// 新增按钮权限流程(支持 --env/--app/--permission-name/--permission-code 一键, 参数齐全时免确认)
+async function addSassPermission(cliOpts = {}) {
+  const {
+    env: cliEnv,
+    app: cliApp,
+    permissionName: cliPermissionName,
+    permissionCode: cliPermissionCode,
+  } = cliOpts;
+  const envList = ["mit", "sit", "uat"];
+  const oneClick =
+    cliEnv !== undefined &&
+    cliApp !== undefined &&
+    cliPermissionName !== undefined &&
+    cliPermissionCode !== undefined;
+  // CLI传入的权限编码含:时快速失败(code以:为分隔符,含:会产生歧义,且避免登录查询后才报错)
+  if (cliPermissionCode !== undefined && cliPermissionCode.includes(":")) {
+    console.log(chalk.red("参数 --permission-code 的值不允许包含 :"));
+    process.exit(1);
+  }
+  if (cliEnv !== undefined) {
+    validateChoice(cliEnv, envList, "--env");
+  }
+  const env = await askOrUse(cliEnv, {
+    message: "请选择环境",
+    name: "env",
+    type: "list",
+    choices: envList,
   });
-  if(!isExist){
-    moduleArr.push(moduleObj);
+  let token;
+  try {
+    token = await login({
+      env,
+      username: "superAdmin",
+      password: "admin1",
+    });
+  } catch (e) {
+    console.log(chalk.red(`${env} 登录失败: ${e.message || e}`));
+    process.exit(1);
   }
-};
-
-var noSingleCustomColumnModule = {
-  meta: {
-    type: "suggestion", // `problem`, `suggestion`, or `layout`
-    docs: {
-      description: "不能单独自定义列",
-      recommended: false,
-      url: null, // URL to the documentation page for this rule
-    },
-    fixable: null, // Or `code` or `whitespace`
-    schema: [], // Add a schema if the rule has options
-    messages: {}, // Add messageId and message
-  },
-
-  create(context) {
-    const sourceCode = context.sourceCode;
-    // 获取路径
-    const fullPathName = context.filename;
-    const cwd = context.cwd;
-    const getPath = (loc = {}) => {
-      const location = `${loc.start?.line}:${loc.start?.column} `;
-      return location + fullPathName.replace(cwd, "");
-    };
-    return context.parserServices.defineTemplateBodyVisitor(
-      // Event handlers for <template>.
-      {
-        //  模版标签,
-        VElement(node) {
-          const tagName = node.rawName;
-          if (tagNameList.indexOf(tagName) > -1) {
-            const attrs = node.startTag.attributes;
-            attrs.some((attr) => {
-              sourceCode.getText(attr);
-              if (
-                attrNameList.includes(attr.key?.argument?.rawName) &&
-                attr.value?.expression?.type === "Literal"
-              ) {
-                const value = attr.value.expression.value;
-                addModule({
-                  module: value,
-                  path: getPath(attr.loc),
-                });
-              } else if (
-                attrNameList.includes(attr.key?.rawName) &&
-                attr.value.type === "VLiteral"
-              ) {
-                const value = attr.value.value;
-                addModule({
-                  module: +value,
-                  path: getPath(attr.loc),
-                });
-              } else if (
-                attrNameList.includes(attr.key?.argument?.rawName) ||
-                attrNameList.includes(attr.key?.rawName)
-              ) {
-                addModule({
-                  module: sourceCode.getText(attr.value.expression),
-                  path: getPath(attr.loc),
-                  isDynamics: true, // 变量
-                });
-              }
-              return false;
-            });
-          }
-        },
-      },
-      // Event handlers for <script> or scripts. (optional)
-      {
-        JSXElement(node) {
-          const tagName = node?.openingElement?.name?.name;
-          if (tagNameList.indexOf(tagName) > -1) {
-            // 遍历找到customColumnModule 属性
-            const attrs = node.openingElement.attributes;
-            attrs.some((attr) => {
-              sourceCode.getText(attr);
-              if (attrNameList.includes(attr?.name?.name)) {
-                if (attr.value?.expression?.type === "Literal") {
-                  const value = attr.value.expression.value;
-                  addModule({
-                    module: value,
-                    path: getPath(attr.loc),
-                  });
-                } else {
-                  addModule({
-                    module: sourceCode.getText(attr.value.expression),
-                    path: getPath(attr.loc),
-                    isDynamics: true, // 变量
-                  });
-                }
-              }
-            });
-          }
-        },
-        // $customColumnDialog
-        CallExpression(node) {
-          if (node.callee?.property?.name === "$customColumnDialog") {
-            const property = node.arguments[0]?.properties[0];
-            if (property.key.name === "module") {
-              if (property.value.type === "Literal") {
-                addModule({
-                  module: property.value.value,
-                  path: getPath(property.loc),
-                });
-              } else if (property.value.type === "ConditionalExpression") {
-                getConditionValue(property.value.consequent, moduleArr,getPath);
-                getConditionValue(property.value.alternate, moduleArr,getPath);
-              }
-            }
-          }
-        },
+  const inputAppName = await askOrUse(cliApp, {
+    message: "请输入要新增按钮权限的应用名称",
+    name: "inputAppName",
+    type: "input",
+    validate: function (value) {
+      if (value) {
+        return true;
       }
-    );
-  },
-};
-
-function getConditionValue(node, moduleArr,getPath) {
-  if (node.type === "Literal") {
-    addModule({
-      module: node.value,
-      path: getPath(node.loc),
+      return "请输入应用名称";
+    },
+  });
+  let applicationList;
+  try {
+    applicationList = await getApplicationList({
+      env,
+      token,
+      appName: inputAppName,
     });
-  }else if (node.type === "ConditionalExpression") {
-    getConditionValue(node.consequent, moduleArr,getPath);
-    getConditionValue(node.alternate, moduleArr,getPath);
+  } catch (e) {
+    console.log(chalk.red(`查询${env}环境应用列表失败: ${e.message || e}`));
+    process.exit(1);
   }
-}
-
-/**
- * @fileoverview 国际化
- * @author ypf
- */
-const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href)));
-const VueESlintParserPath = require$1.resolve('vue-eslint-parser');
-const meta = {
-  name: "eslint-plugin-i18n"};
-var i18n = {
-  rules: {
-    "no-single-chinese": noSingleChineseRule,
-    "no-single-currency": noSingleCurrencyRule,
-    "no-single-customColumnModule": noSingleCustomColumnModule,
-  },
-  processors: {},
-  configs: {
-    recommended: {
-      // 插件
-      plugins: [
-        "i18n", // 可以省略eslint-plugin-
-      ],
-      rules: {
-        "i18n/no-single-chinese": "warn",
-        "i18n/no-single-currency": "warn",
-        "i18n/no-single-customColumnModule": "warn",
-      },
-      // parser: "vue-eslint-parser",
-      parser: VueESlintParserPath, // 文档中是只能字符串
-      parserOptions: {
-        ecmaVersion: "latest", // 指定你想要使用的 ECMAScript 版本
-        sourceType: "module", // 支持脚本类型为模块,否则不支持import/export
-        ecmaFeatures: {
-          jsx: true,
-        },
-        parser: {
-          js: espree__namespace,
-          jsx: espree__namespace, // 支持jsx语法
-          ts: tsParser,
-          tsx: tsParser,
+  if (!applicationList.length) {
+    console.log(chalk.red(`${env}环境未找到该应用`));
+    process.exit(1);
+  }
+  let appId;
+  let appName;
+  if (applicationList.length === 1) {
+    appId = applicationList[0].id;
+    appName = applicationList[0].name;
+    console.log(chalk.gray(`唯一匹配,已自动选中: ${appName}`));
+  } else {
+    // 一键模式下优先精确匹配CLI传入的应用名称(应用列表是关键字模糊查询结果)
+    const exactMatch = oneClick
+      ? applicationList.find((item) => item.name === cliApp)
+      : undefined;
+    if (exactMatch) {
+      appId = exactMatch.id;
+      appName = exactMatch.name;
+      console.log(chalk.gray(`精确匹配,已自动选中: ${appName}`));
+    } else {
+      const res = await inquirer.prompt([
+        {
+          message: "请选择应用名称",
+          name: "appName",
+          type: "rawlist",
+          choices: applicationList,
         },
+      ]);
+      appId = applicationList.find(
+        (item) => item.name === res.appName
+      ).id;
+      appName = res.appName;
+    }
+  }
+  let appConfig;
+  try {
+    appConfig = await getApplicationConfig({ appId, env, token });
+  } catch (e) {
+    console.log(chalk.red(`获取应用配置失败: ${e.message || e}`));
+    process.exit(1);
+  }
+  // CLI传入的权限名称/编码仅第一圈消费, 后续圈次走交互输入
+  let cliName = cliPermissionName;
+  let cliCode = cliPermissionCode;
+  let goOn = true;
+  while (goOn) {
+    const permissionName = await askOrUse(cliName, {
+      message: "请输入权限名称",
+      name: "permissionName",
+      type: "input",
+      validate: function (value) {
+        if (value) {
+          return true;
+        }
+        return "请输入权限名称";
       },
-    },
-  },
-};
-
-// https://www.npmjs.com/package/text-table?activeTab=readme
-
-function table (rows_, opts) {
-  if (!opts) opts = {};
-  var hsep = opts.hsep === undefined ? "  " : opts.hsep;
-  var align = opts.align || [];
-  var stringLength =
-    opts.stringLength ||
-    function (s) {
-      return String(s).length;
-    };
-  var dotsizes = reduce(
-    rows_,
-    function (acc, row) {
-      forEach(row, function (c, ix) {
-        var n = dotindex(c);
-        if (!acc[ix] || n > acc[ix]) acc[ix] = n;
-      });
-      return acc;
-    },
-    []
-  );
-
-  var rows = map(rows_, function (row) {
-    return map(row, function (c_, ix) {
-      var c = String(c_);
-      if (align[ix] === ".") {
-        var index = dotindex(c);
-        var size =
-          dotsizes[ix] + (/\./.test(c) ? 1 : 2) - (stringLength(c) - index);
-        return c + Array(size).join(" ");
-      } else return c;
     });
-  });
-
-  var sizes = reduce(
-    rows,
-    function (acc, row) {
-      forEach(row, function (c, ix) {
-        var n = stringLength(c);
-        if (!acc[ix] || n > acc[ix]) acc[ix] = n;
-      });
-      return acc;
-    },
-    []
-  );
-
-  return map(rows, function (row) {
-    return map(row, function (c, ix) {
-      var n = sizes[ix] - stringLength(c) || 0;
-      var s = Array(Math.max(n + 1, 1)).join(" ");
-      if (align[ix] === "r" || align[ix] === ".") {
-        return s + c;
-      }
-      if (align[ix] === "c") {
-        return (
-          Array(Math.ceil(n / 2 + 1)).join(" ") +
-          c +
-          Array(Math.floor(n / 2 + 1)).join(" ")
+    const permissionCode = await askOrUse(cliCode, {
+      message: "请输入权限编码",
+      name: "permissionCode",
+      type: "input",
+      validate: function (value) {
+        if (!value) {
+          return "请输入权限编码";
+        }
+        if (value.includes(":")) {
+          return "权限编码不允许包含 :";
+        }
+        return true;
+      },
+    });
+    cliName = undefined;
+    cliCode = undefined;
+    const data = {
+      code1: appConfig.code,
+      name: permissionName,
+      visitConf: permissionCode,
+      ascriptionApp: appConfig.id,
+      code: `${appConfig.code}:${permissionCode}`,
+    };
+    let confirmed = true;
+    if (!oneClick) {
+      const { confirmAdd } = await inquirer.prompt([
+        {
+          message: `确认新增按钮权限? ${chalk.cyan(
+            `${data.name} (${data.code})`
+          )}`,
+          name: "confirmAdd",
+          type: "confirm",
+          default: true,
+        },
+      ]);
+      confirmed = confirmAdd;
+    }
+    if (confirmed) {
+      try {
+        await addApplicationButtonConfig({ data, env, token });
+        console.log(
+          chalk.green(
+            `新增按钮权限成功: ${appName} - ${data.name} (${data.code})`
+          )
         );
+      } catch (e) {
+        console.log(chalk.red(`新增按钮权限失败: ${e.message || e}`));
+        process.exit(1);
       }
-
-      return c + s;
-    })
-      .join(hsep)
-      .replace(/\s+$/, "");
-  }).join("\n");
-}
-
-function dotindex(c) {
-  var m = /\.[^.]*$/.exec(c);
-  return m ? m.index + 1 : c.length;
-}
-
-function reduce(xs, f, init) {
-  if (xs.reduce) return xs.reduce(f, init);
-  var i = 0;
-  var acc = arguments.length >= 3 ? init : xs[i++];
-  for (; i < xs.length; i++) {
-    f(acc, xs[i], i);
-  }
-  return acc;
-}
-
-function forEach(xs, f) {
-  if (xs.forEach) return xs.forEach(f);
-  for (var i = 0; i < xs.length; i++) {
-    f.call(xs, xs[i], i);
+    }
+    if (oneClick) {
+      goOn = false;
+    } else {
+      const { continueAdd } = await inquirer.prompt([
+        {
+          message: "是否继续为该应用添加按钮权限?",
+          name: "continueAdd",
+          type: "confirm",
+          default: false,
+        },
+      ]);
+      goOn = continueAdd;
+    }
   }
 }
 
-function map(xs, f) {
-  if (xs.map) return xs.map(f);
-  var res = [];
-  for (var i = 0; i < xs.length; i++) {
-    res.push(f.call(xs, xs[i], i));
-  }
-  return res;
-}
+/**
+ * @fileoverview 不要单独中文
+ * @author ypf
+ */
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('eslint').Rule.RuleModule} */
+
+// 判断字符串是否是中文
+const isChinese = (str) => {
+  return /[\u4e00-\u9fa5]+/.test(str);
+};
+//去除特殊字符，包含空格
+function trimSpecial(string = "", formatter) {
+  // const pattern =
+  //   /[`~!@#$^\-&*()=|{}':;',\\\[\]\.<>\/?~！@#￥……&*（）——|{}【】'；：""'。，、？\s]/g;
+  // return string.replace(pattern, "");
+  // console.log(string);
+  // 获取开头空白符的位置
+  const startIdx = string.search(/\S/) - 1;
+  // 获取结尾空白符的位置
+  const endIdx = string.search(/\S\s*$/) + 1;
+  // 获取开头和结尾的字符串
+  const startStr = string.slice(0, startIdx + 1);
+  const endStr = string.slice(endIdx);
+  // 获取中间的字符串
+  const middle = string.slice(startIdx + 1, endIdx);
+  // 取出中间字符串的换行符
+  const middleStr = middle.replace(/\n/g, "");
+  return startStr + formatter(middleStr) + endStr;
+}
+// 判断当前节点是否已经翻译过
+function isTranslate(node) {
+  if (
+    node.parent?.parent?.parent?.type === "CallExpression" &&
+    node.parent?.parent?.parent?.callee?.name === "$hxt"
+  ) {
+    return true;
+  }
+  // console不翻译
+  if (
+    node.parent.type === "CallExpression" &&
+    node.parent.callee?.object?.name === "console"
+  ) {
+    return true;
+  }
+
+  return false;
+}
+
+// 空key
+const emptyKeyRules = (context) => {
+  return {
+    CallExpression(node) {
+      if (node.callee.name === "$hxt") {
+        const properties = node.arguments[0]?.properties || [];
+        // 如果属性是key且值为空
+        const result = properties.some((item) => {
+          // 去除key空格
+          const key = item.key.name.replace(/\s/g, "");
+          if (key === "key") {
+            // 去除value空格
+            // value是模版字符串
+            let value = "";
+            if (item.value.type === "TemplateLiteral") {
+              value = item.value.quasis[0].value.raw.replace(/\s/g, "");
+            } else if (item.value.type === "Literal") {
+              value = item.value.value.replace(/\s/g, "");
+            }
+            if (value === "") {
+              return true;
+            }
+          }
+        });
+        if (result) {
+          context.report({
+            node: node,
+            messageId: "noSingleChinese",
+            data: {
+              raw: chalk.green("key为空"),
+            },
+            fix: (fixer) => {},
+          });
+        }
+      }
+    },
+  };
+};
+var noSingleChineseRule = {
+  meta: {
+    type: "suggestion", // `problem`, `suggestion`, or `layout`
+    docs: {
+      description: "不要单独中文",
+      recommended: false,
+      url: null, // URL to the documentation page for this rule
+    },
+    fixable: "code", // Or `code` or `whitespace`
+    schema: [], // Add a schema if the rule has options
+    messages: {
+      noSingleChinese: "不要单独中文: {{raw}}",
+    }, // Add messageId and message
+  },
+  create(context) {
+    const sourceCode = context.sourceCode;
+    context.filename;
+    // console.log(filename,999999)
+    return context.parserServices.defineTemplateBodyVisitor(
+      // Event handlers for <template>.
+      {
+        // 纯字符串,如 测试
+        VText(node) {
+          // 如果是中文,替换为 {{ $hxt({key:'',desc:'中文'})}}
+          if (!isTranslate(node)) {
+            if (isChinese(node.value)) {
+              context.report({
+                node,
+                messageId: "noSingleChinese",
+                data: {
+                  raw: chalk.green(node.value),
+                },
+                // message: `VText`,
+                fix: (fixer) => {
+                  return fixer.replaceText(
+                    node,
+                    trimSpecial(node.value, (middle) => {
+                      return "{{ $hxt({key:'',desc:'" + middle + "'})}}";
+                    })
+                  );
+                },
+              });
+            }
+          }
+        },
+        // 纯字符串,如 {{ mini ? '测试' : `开启` }}中的测试
+        // 纯字符串,如 {{test('测试')}}中的测试
+        Literal(node) {
+          if (!isTranslate(node)) {
+            if (isChinese(node.value)) {
+              context.report({
+                node,
+                messageId: "noSingleChinese",
+                data: {
+                  raw: chalk.green(node.value),
+                },
+                // message: `Literal`,
+                fix: (fixer) => {
+                  // console.log(1111, node);
+                  return fixer.replaceText(
+                    node,
+                    trimSpecial(node.value, (middle) => {
+                      return "$hxt({key:'',desc:'" + middle + "'})";
+                    })
+                  );
+                },
+              });
+            }
+          }
+        },
+        // 模版字符串,
+        // 如{{ mini ? '测试' : `开启` }}中的开启
+        // 如{{ mini ? `${a}测试` : "开启" }}中的${a}测试
+        // 如{{`111`}}
+        // 如<p :a="`${a}册书`">
+        TemplateLiteral(node) {
+          if (!isTranslate(node)) {
+            const textSource = sourceCode.getText(node);
+            let text = textSource;
+            // 删除$符号
+            text = text.replace(/\${/g, "{");
+            if (isChinese(text)) {
+              // 获取expressions的文本
+              const expressionsText = node.expressions.map((item) => {
+                return sourceCode.getText(item);
+              });
+              let expressionStr = "";
+              if (expressionsText.length) {
+                expressionsText.forEach((item, index) => {
+                  const key = `slot${index + 1}`;
+                  text = text.replace(item, `${key}`);
+                  expressionStr += `${key}:${item},`;
+                });
+                // 删除最后一个逗号
+                expressionStr = `{${expressionStr.slice(0, -1)}}`;
+              }
+              if (!isChinese(text)) {
+                return;
+              }
+              context.report({
+                node,
+                data: {
+                  raw: chalk.green(textSource),
+                },
+                messageId: "noSingleChinese",
+                // message: `TemplateLiteral`,
+                fix: (fixer) => {
+                  return fixer.replaceText(
+                    node,
+                    trimSpecial(text, (middle) => {
+                      return `$hxt({key:'',desc:${middle}}${
+                        expressionStr ? `,${expressionStr}` : ""
+                      })`;
+                    })
+                  );
+                },
+              });
+            }
+          }
+        },
+        // 如<p title="1">
+        VLiteral(node) {
+          if (!isTranslate(node)) {
+            if (isChinese(node.value)) {
+              context.report({
+                node,
+                messageId: "noSingleChinese",
+                // message: `VLiteral`,
+                data: {
+                  raw: chalk.green(node.value),
+                },
+
+                fix: (fixer) => {
+                  // 父节点需要改为冒号方式
+                  const parentNode = node.parent;
+                  if (parentNode.type === "VAttribute") {
+                    const key = parentNode.key;
+                    return fixer.replaceText(
+                      parentNode,
+                      ":" +
+                        key.name +
+                        "=" +
+                        '"' +
+                        trimSpecial(node.value, (middle) => {
+                          return "$hxt({key:'',desc:'" + middle + "'})";
+                        }) +
+                        '"'
+                    );
+                  }
+                },
+              });
+            }
+          }
+        },
+        // 如 <p v-permission="测试">中的测试
+        Identifier(node) {
+          if (
+            !isTranslate(node) &&
+            node.parent.type === "VExpressionContainer"
+          ) {
+            if (isChinese(node.name)) {
+              context.report({
+                node,
+                messageId: "noSingleChinese",
+                // message: `Identifier`,
+                data: {
+                  raw: chalk.green(node.name),
+                },
+                fix: (fixer) => {
+                  return fixer.replaceText(
+                    node,
+                    trimSpecial(node.name, (middle) => {
+                      return "$hxt({key:'',desc:'" + middle + "'})";
+                    })
+                  );
+                },
+              });
+            }
+          }
+        },
+        ...emptyKeyRules(context),
+      },
+      // Event handlers for <script> or scripts. (optional)
+      {
+        JSXText(node) {
+          if (!isTranslate(node)) {
+            if (isChinese(node.value)) {
+              context.report({
+                node,
+                messageId: "noSingleChinese",
+                data: {
+                  raw: chalk.green(node.value),
+                },
+                fix: (fixer) => {
+                  return fixer.replaceText(
+                    node,
+                    trimSpecial(node.value, (middle) => {
+                      return "{ $hxt({key:'',desc:'" + middle + "'})}";
+                    })
+                  );
+                },
+              });
+            }
+          }
+        },
+        TemplateLiteral(node) {
+          if (!isTranslate(node)) {
+            const textSource = sourceCode.getText(node);
+            let text = textSource;
+            // 删除$符号
+            text = text.replace(/\${/g, "{");
+            if (isChinese(text)) {
+              // 获取expressions的文本
+              const expressionsText = node.expressions.map((item) => {
+                return sourceCode.getText(item);
+              });
+              // console.log(expressionsText,111)
+              let expressionStr = "";
+              if (expressionsText.length) {
+                expressionsText.forEach((item, index) => {
+                  const key = `slot${index + 1}`;
+                  text = text.replace(item, `${key}`);
+                  expressionStr += `${key}:${item},`;
+                });
+                // 删除最后一个逗号
+                expressionStr = `{${expressionStr.slice(0, -1)}}`;
+              }
+              if (!isChinese(text)) {
+                return;
+              }
+              context.report({
+                node,
+                messageId: "noSingleChinese",
+                data: {
+                  raw: chalk.green(textSource),
+                },
+                // message: `TemplateLiteral`,
+                fix: (fixer) => {
+                  //  return console.log(text,expressionStr)
+                  // trimSpecial(text, (middle) => {
+                  //   return `$hxt({key:'',desc:${middle}}${
+                  //     expressionStr ? `,${expressionStr}` : ""
+                  //   })`;
+                  // })
+                  // return
+                  return fixer.replaceText(
+                    node,
+                    trimSpecial(text, (middle) => {
+                      return `$hxt({key:'',desc:${middle}}${
+                        expressionStr ? `,${expressionStr}` : ""
+                      })`;
+                    })
+                  );
+                },
+              });
+            }
+          }
+        },
+        Literal(node) {
+          // 如果正则忽略
+          if (node.regex) return;
+          if (!isTranslate(node)) {
+            if (isChinese(node.value)) {
+              // 增加{}包裹  render(){return <p title={'测试'} title="测试" title={`${1}测试`}>内容 {`测试`}</p>} 中的内容
+              if (node.parent.type === "JSXAttribute") {
+                context.report({
+                  node,
+                  messageId: "noSingleChinese",
+                  data: {
+                    raw: chalk.green(node.value),
+                  },
+                  fix: (fixer) => {
+                    return fixer.replaceText(
+                      node,
+                      trimSpecial(node.value, (middle) => {
+                        return "{$hxt({key:'',desc:'" + middle + "'})}";
+                      })
+                    );
+                  },
+                });
+              } else {
+                context.report({
+                  node,
+                  messageId: "noSingleChinese",
+                  data: {
+                    raw: chalk.green(node.value),
+                  },
+                  fix: (fixer) => {
+                    return fixer.replaceText(
+                      node,
+                      trimSpecial(node.value, (middle) => {
+                        return "$hxt({key:'',desc:'" + middle + "'})";
+                      })
+                    );
+                  },
+                });
+              }
+            }
+          }
+        },
+        ...emptyKeyRules(context),
+      }
+    );
+  },
+};
 
-//------------------------------------------------------------------------------
+/**
+ * @fileoverview 不能单独金额
+ * @author ypf
+ */
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('eslint').Rule.RuleModule} */
+const inputTagNameList = [
+  "el-input",
+  "ElInput",
+  "hx-input",
+  "HxInput",
+  "van-field",
+  "VanField",
+  "hxmb-field",
+  "HxmbField",
+]; // input标签
+const formTagNameList = ["hx-form", "HxForm", "HxmForm", "hxmb-form"]; // form标签
+// 匹配金额名
+const currencyList = [
+  // "currency",
+  "total",
+  "price",
+  "amount",
+];
+// 价格后缀过滤
+const notIncludeCurrencySuffixList = [
+  "code",
+  "type",
+  "no",
+  "status",
+  "name",
+  "sort",
+  "source",
+  "qty",
+];
+// 关键字属性
+const keyPropList = ["prop", "name", "id", "key"];
+const hasCurrencyName = (str) => {
+  return currencyList.some((item) => {
+    str = str.toLowerCase();
+    const suffix = str.split(item)[1]?.toLowerCase();
+    if (str.includes(item)) {
+      if(suffix){
+        return !notIncludeCurrencySuffixList.some((item) =>
+          suffix.includes(item)
+        );
+      }
+      return true
+    }
+    return false;
+  });
+};
+var noSingleCurrencyRule = {
+  meta: {
+    type: "suggestion", // `problem`, `suggestion`, or `layout`
+    docs: {
+      description: "不能单独金额",
+      recommended: false,
+      url: null, // URL to the documentation page for this rule
+    },
+    fixable: null, // Or `code` or `whitespace`
+    schema: [], // Add a schema if the rule has options
+    messages: {
+      noSingleCurrency: "不要单独币种: {{raw}}",
+    }, // Add messageId and message
+  },
+
+  create(context) {
+    const sourceCode = context.sourceCode;
+    // 获取路径
+    const filename = context.filename;
+    return context.parserServices.defineTemplateBodyVisitor(
+      // Event handlers for <template>.
+      {
+        //  模版标签, 如<el-input >
+        VElement(node) {
+          const tagName = node.rawName;
+          if (inputTagNameList.indexOf(tagName) > -1) {
+            const attrs = node.startTag.attributes;
+            // 遍历找到v-model 属性
+            attrs.some((attr) => {
+              const attrTextSource = sourceCode.getText(attr);
+              if (attr.key?.name?.name === "model") {
+                const textSource = sourceCode.getText(attr.value);
+                // 如果包含currency、price、amount，则报错
+                if (hasCurrencyName(textSource)) {
+                  context.report({
+                    node,
+                    data: {
+                      raw:
+                        chalk.red(`Template|<${tagName}> `) +
+                        chalk.green(attrTextSource),
+                    },
+                    messageId: "noSingleCurrency",
+                    // message: `TemplateLiteral`,
+                    fix: (fixer) => {},
+                  });
+                }
+              }
+              return false;
+            });
+          }
+        },
+      },
+      // Event handlers for <script> or scripts. (optional)
+      {
+        // jsx 标签,如 render() { return <el-input /> } 中的<el-input />
+        //  <el-form formItemList=[]>中的formItemList
+        JSXElement(node) {
+          // console.log(node,'node')
+          const tagName = node?.openingElement?.name?.name;
+          // input
+          if (inputTagNameList.indexOf(tagName) > -1) {
+            // 遍历找到vModel 属性
+            const attrs = node.openingElement.attributes;
+            attrs.some((attr) => {
+              const attrTextSource = sourceCode.getText(attr);
+              // console.log(attrTextSource,'attrTextSource')
+              if (attr.name.name === "vModel") {
+                const textSource = sourceCode.getText(attr.value);
+                // 如果包含币种
+                if (hasCurrencyName(textSource)) {
+                  context.report({
+                    node,
+                    data: {
+                      raw:
+                        chalk.red(`JSX|<${tagName}> `) +
+                        chalk.green(attrTextSource),
+                    },
+                    messageId: "noSingleCurrency",
+                    // message: `TemplateLiteral`,
+                    fix: (fixer) => {},
+                  });
+                }
+              }
+            });
+          }
+          // form
+          if (formTagNameList.indexOf(tagName)) {
+            const attrs = node.openingElement.attributes;
+            // 遍历找到formItemList 属性
+            attrs.some((attr) => {
+              sourceCode.getText(attr);
+              // 是formItemList
+              if (attr?.name?.name === "formItemList") {
+                // 且值是数组
+                if (attr?.value?.expression?.type === "ArrayExpression") {
+                  // 遍历数组
+                  attr.value.expression.elements.forEach((item) => {
+                    (item.properties || []).some((item) => {
+                      const attrTextSource = sourceCode.getText(item);
+                      if (keyPropList.indexOf(item.key.name) > -1) {
+                        const textSource = sourceCode.getText(item.value);
+                        if (item?.value?.type === "CallExpression") return;
+                        // 如果包含币种
+                        if (hasCurrencyName(textSource)) {
+                          context.report({
+                            node,
+                            data: {
+                              raw:
+                                chalk.red(`JSX|${tagName}|${attr.name.name} `) +
+                                chalk.green(`${attrTextSource}`),
+                            },
+                            messageId: "noSingleCurrency",
+                            // message: `TemplateLiteral`,
+                            fix: (fixer) => {},
+                          });
+                        }
+                      }
+                    });
+                  });
+                }
+              }
+            });
+          }
+        },
+        // [{prop:'price'}]
+        ArrayExpression(node) {
+          // 不检测路由文件
+          if (filename.includes("src/router")) return;
+          // 是数组且不是jsx属性上的数组(上面已经检测过了,否则会出现2条错误)
+          if (node.parent?.parent?.type === "JSXAttribute") return;
+          (node.elements || []).forEach((item) => {
+            // 数组里面是对象
+            if (item?.type === "ObjectExpression") {
+              (item.properties || []).forEach((item) => {
+                const attrTextSource = sourceCode.getText(item);
+                if (keyPropList.indexOf(item?.key?.name) > -1) {
+                  if (item?.value?.type === "CallExpression") return;
+                  const textSource = sourceCode.getText(item.value);
+                  // 如果包含币种
+                  if (hasCurrencyName(textSource)) {
+                    context.report({
+                      node,
+                      data: {
+                        raw:
+                          chalk.red(`JSX|[{}] `) +
+                          chalk.green(`${attrTextSource}`),
+                      },
+                      messageId: "noSingleCurrency",
+                    });
+                  }
+                }
+              });
+            }
+          });
+        },
+      }
+    );
+  },
+};
 
-/**
- * Given a word and a count, append an s if count is not one.
- * @param {string} word A word in its singular form.
- * @param {int} count A number controlling whether word should be pluralized.
- * @returns {string} The original word with an s on the end if count is not one.
- */
-function pluralize(word, count) {
-    return (count === 1 ? word : `${word}s`);
+/**
+ * @fileoverview 不能单独金额
+ * @author ypf
+ */
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('eslint').Rule.RuleModule} */
+const tagNameList = ["hx-search-list-page", "HxSearchListPage"];
+const attrNameList = ["custom-column-module", "customColumnModule"];
+const moduleArr = [];
+const getModuleArr = () => moduleArr;
+const addModule = (moduleObj) => {
+  const isExist= moduleArr.some((item) => {
+    return item.module === moduleObj.module
+  });
+  if(!isExist){
+    moduleArr.push(moduleObj);
+  }
+};
+
+var noSingleCustomColumnModule = {
+  meta: {
+    type: "suggestion", // `problem`, `suggestion`, or `layout`
+    docs: {
+      description: "不能单独自定义列",
+      recommended: false,
+      url: null, // URL to the documentation page for this rule
+    },
+    fixable: null, // Or `code` or `whitespace`
+    schema: [], // Add a schema if the rule has options
+    messages: {}, // Add messageId and message
+  },
+
+  create(context) {
+    const sourceCode = context.sourceCode;
+    // 获取路径
+    const fullPathName = context.filename;
+    const cwd = context.cwd;
+    const getPath = (loc = {}) => {
+      const location = `${loc.start?.line}:${loc.start?.column} `;
+      return location + fullPathName.replace(cwd, "");
+    };
+    return context.parserServices.defineTemplateBodyVisitor(
+      // Event handlers for <template>.
+      {
+        //  模版标签,
+        VElement(node) {
+          const tagName = node.rawName;
+          if (tagNameList.indexOf(tagName) > -1) {
+            const attrs = node.startTag.attributes;
+            attrs.some((attr) => {
+              sourceCode.getText(attr);
+              if (
+                attrNameList.includes(attr.key?.argument?.rawName) &&
+                attr.value?.expression?.type === "Literal"
+              ) {
+                const value = attr.value.expression.value;
+                addModule({
+                  module: value,
+                  path: getPath(attr.loc),
+                });
+              } else if (
+                attrNameList.includes(attr.key?.rawName) &&
+                attr.value.type === "VLiteral"
+              ) {
+                const value = attr.value.value;
+                addModule({
+                  module: +value,
+                  path: getPath(attr.loc),
+                });
+              } else if (
+                attrNameList.includes(attr.key?.argument?.rawName) ||
+                attrNameList.includes(attr.key?.rawName)
+              ) {
+                addModule({
+                  module: sourceCode.getText(attr.value.expression),
+                  path: getPath(attr.loc),
+                  isDynamics: true, // 变量
+                });
+              }
+              return false;
+            });
+          }
+        },
+      },
+      // Event handlers for <script> or scripts. (optional)
+      {
+        JSXElement(node) {
+          const tagName = node?.openingElement?.name?.name;
+          if (tagNameList.indexOf(tagName) > -1) {
+            // 遍历找到customColumnModule 属性
+            const attrs = node.openingElement.attributes;
+            attrs.some((attr) => {
+              sourceCode.getText(attr);
+              if (attrNameList.includes(attr?.name?.name)) {
+                if (attr.value?.expression?.type === "Literal") {
+                  const value = attr.value.expression.value;
+                  addModule({
+                    module: value,
+                    path: getPath(attr.loc),
+                  });
+                } else {
+                  addModule({
+                    module: sourceCode.getText(attr.value.expression),
+                    path: getPath(attr.loc),
+                    isDynamics: true, // 变量
+                  });
+                }
+              }
+            });
+          }
+        },
+        // $customColumnDialog
+        CallExpression(node) {
+          if (node.callee?.property?.name === "$customColumnDialog") {
+            const property = node.arguments[0]?.properties[0];
+            if (property.key.name === "module") {
+              if (property.value.type === "Literal") {
+                addModule({
+                  module: property.value.value,
+                  path: getPath(property.loc),
+                });
+              } else if (property.value.type === "ConditionalExpression") {
+                getConditionValue(property.value.consequent, moduleArr,getPath);
+                getConditionValue(property.value.alternate, moduleArr,getPath);
+              }
+            }
+          }
+        },
+      }
+    );
+  },
+};
+
+function getConditionValue(node, moduleArr,getPath) {
+  if (node.type === "Literal") {
+    addModule({
+      module: node.value,
+      path: getPath(node.loc),
+    });
+  }else if (node.type === "ConditionalExpression") {
+    getConditionValue(node.consequent, moduleArr,getPath);
+    getConditionValue(node.alternate, moduleArr,getPath);
+  }
 }
 
-//------------------------------------------------------------------------------
-// Public Interface
-//------------------------------------------------------------------------------
-
-function stylish(results) {
-
-    let output = "\n",
-        errorCount = 0,
-        warningCount = 0,
-        fixableErrorCount = 0,
-        fixableWarningCount = 0,
-        summaryColor = "yellow";
-    results.forEach(result => {
-        const messages = result.messages;
-
-        if (messages.length === 0) {
-            return;
-        }
-
-        errorCount += result.errorCount;
-        warningCount += result.warningCount;
-        fixableErrorCount += result.fixableErrorCount;
-        fixableWarningCount += result.fixableWarningCount;
-
-        output += `${chalk.underline(result.filePath)}\n`;
-
-        output += `${table(
-            messages.map(message => {
-                let messageType;
-
-                if (message.fatal || message.severity === 2) {
-                    messageType = chalk.red("error");
-                    summaryColor = "red";
-                } else {
-                    messageType = chalk.yellow("warning");
-                }
-
-                return [
-                    "",
-                    message.line || 0,
-                    message.column || 0,
-                    messageType,
-                    message.message.replace(/([^ ])\.$/u, "$1"),
-                    chalk.dim(message.ruleId || "")
-                ];
-            }),
-            {
-                align: ["", "r", "l"],
-                stringLength(str) {
-                    return stripAnsi(str).length;
-                }
-            }
-        ).split("\n").map(el => el.replace(/(\d+)\s+(\d+)/u, (m, p1, p2) => chalk.dim(`${p1}:${p2}`))).join("\n")}\n\n`;
-    });
-
-    const total = errorCount + warningCount;
-
-    if (total > 0) {
-        output += chalk[summaryColor].bold([
-            "\u2716 ", total, pluralize(" problem", total),
-            " (", errorCount, pluralize(" error", errorCount), ", ",
-            warningCount, pluralize(" warning", warningCount), ")\n"
-        ].join(""));
+/**
+ * @fileoverview 国际化
+ * @author ypf
+ */
+const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href)));
+const VueESlintParserPath = require$1.resolve('vue-eslint-parser');
+const meta = {
+  name: "eslint-plugin-i18n"};
+var i18n = {
+  rules: {
+    "no-single-chinese": noSingleChineseRule,
+    "no-single-currency": noSingleCurrencyRule,
+    "no-single-customColumnModule": noSingleCustomColumnModule,
+  },
+  processors: {},
+  configs: {
+    recommended: {
+      // 插件
+      plugins: [
+        "i18n", // 可以省略eslint-plugin-
+      ],
+      rules: {
+        "i18n/no-single-chinese": "warn",
+        "i18n/no-single-currency": "warn",
+        "i18n/no-single-customColumnModule": "warn",
+      },
+      // parser: "vue-eslint-parser",
+      parser: VueESlintParserPath, // 文档中是只能字符串
+      parserOptions: {
+        ecmaVersion: "latest", // 指定你想要使用的 ECMAScript 版本
+        sourceType: "module", // 支持脚本类型为模块,否则不支持import/export
+        ecmaFeatures: {
+          jsx: true,
+        },
+        parser: {
+          js: espree__namespace,
+          jsx: espree__namespace, // 支持jsx语法
+          ts: tsParser,
+          tsx: tsParser,
+        },
+      },
+    },
+  },
+};
 
-        if (fixableErrorCount > 0 || fixableWarningCount > 0) {
-            output += chalk[summaryColor].bold([
-                "  ", fixableErrorCount, pluralize(" error", fixableErrorCount), " and ",
-                fixableWarningCount, pluralize(" warning", fixableWarningCount),
-                " potentially fixable with the `--fix` option.\n"
-            ].join(""));
-        }
-    }
+// https://www.npmjs.com/package/text-table?activeTab=readme
+
+function table (rows_, opts) {
+  if (!opts) opts = {};
+  var hsep = opts.hsep === undefined ? "  " : opts.hsep;
+  var align = opts.align || [];
+  var stringLength =
+    opts.stringLength ||
+    function (s) {
+      return String(s).length;
+    };
+  var dotsizes = reduce(
+    rows_,
+    function (acc, row) {
+      forEach(row, function (c, ix) {
+        var n = dotindex(c);
+        if (!acc[ix] || n > acc[ix]) acc[ix] = n;
+      });
+      return acc;
+    },
+    []
+  );
+
+  var rows = map(rows_, function (row) {
+    return map(row, function (c_, ix) {
+      var c = String(c_);
+      if (align[ix] === ".") {
+        var index = dotindex(c);
+        var size =
+          dotsizes[ix] + (/\./.test(c) ? 1 : 2) - (stringLength(c) - index);
+        return c + Array(size).join(" ");
+      } else return c;
+    });
+  });
+
+  var sizes = reduce(
+    rows,
+    function (acc, row) {
+      forEach(row, function (c, ix) {
+        var n = stringLength(c);
+        if (!acc[ix] || n > acc[ix]) acc[ix] = n;
+      });
+      return acc;
+    },
+    []
+  );
+
+  return map(rows, function (row) {
+    return map(row, function (c, ix) {
+      var n = sizes[ix] - stringLength(c) || 0;
+      var s = Array(Math.max(n + 1, 1)).join(" ");
+      if (align[ix] === "r" || align[ix] === ".") {
+        return s + c;
+      }
+      if (align[ix] === "c") {
+        return (
+          Array(Math.ceil(n / 2 + 1)).join(" ") +
+          c +
+          Array(Math.floor(n / 2 + 1)).join(" ")
+        );
+      }
+
+      return c + s;
+    })
+      .join(hsep)
+      .replace(/\s+$/, "");
+  }).join("\n");
+}
+
+function dotindex(c) {
+  var m = /\.[^.]*$/.exec(c);
+  return m ? m.index + 1 : c.length;
+}
+
+function reduce(xs, f, init) {
+  if (xs.reduce) return xs.reduce(f, init);
+  var i = 0;
+  var acc = arguments.length >= 3 ? init : xs[i++];
+  for (; i < xs.length; i++) {
+    f(acc, xs[i], i);
+  }
+  return acc;
+}
+
+function forEach(xs, f) {
+  if (xs.forEach) return xs.forEach(f);
+  for (var i = 0; i < xs.length; i++) {
+    f.call(xs, xs[i], i);
+  }
+}
+
+function map(xs, f) {
+  if (xs.map) return xs.map(f);
+  var res = [];
+  for (var i = 0; i < xs.length; i++) {
+    res.push(f.call(xs, xs[i], i));
+  }
+  return res;
+}
 
-    // Resets output color, for prevent change on top level
-    return total > 0 ? chalk.reset(output) : "";
+//------------------------------------------------------------------------------
+
+/**
+ * Given a word and a count, append an s if count is not one.
+ * @param {string} word A word in its singular form.
+ * @param {int} count A number controlling whether word should be pluralized.
+ * @returns {string} The original word with an s on the end if count is not one.
+ */
+function pluralize(word, count) {
+    return (count === 1 ? word : `${word}s`);
+}
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+function stylish(results) {
+
+    let output = "\n",
+        errorCount = 0,
+        warningCount = 0,
+        fixableErrorCount = 0,
+        fixableWarningCount = 0,
+        summaryColor = "yellow";
+    results.forEach(result => {
+        const messages = result.messages;
+
+        if (messages.length === 0) {
+            return;
+        }
+
+        errorCount += result.errorCount;
+        warningCount += result.warningCount;
+        fixableErrorCount += result.fixableErrorCount;
+        fixableWarningCount += result.fixableWarningCount;
+
+        output += `${chalk.underline(result.filePath)}\n`;
+
+        output += `${table(
+            messages.map(message => {
+                let messageType;
+
+                if (message.fatal || message.severity === 2) {
+                    messageType = chalk.red("error");
+                    summaryColor = "red";
+                } else {
+                    messageType = chalk.yellow("warning");
+                }
+
+                return [
+                    "",
+                    message.line || 0,
+                    message.column || 0,
+                    messageType,
+                    message.message.replace(/([^ ])\.$/u, "$1"),
+                    chalk.dim(message.ruleId || "")
+                ];
+            }),
+            {
+                align: ["", "r", "l"],
+                stringLength(str) {
+                    return stripAnsi(str).length;
+                }
+            }
+        ).split("\n").map(el => el.replace(/(\d+)\s+(\d+)/u, (m, p1, p2) => chalk.dim(`${p1}:${p2}`))).join("\n")}\n\n`;
+    });
+
+    const total = errorCount + warningCount;
+
+    if (total > 0) {
+        output += chalk[summaryColor].bold([
+            "\u2716 ", total, pluralize(" problem", total),
+            " (", errorCount, pluralize(" error", errorCount), ", ",
+            warningCount, pluralize(" warning", warningCount), ")\n"
+        ].join(""));
+
+        if (fixableErrorCount > 0 || fixableWarningCount > 0) {
+            output += chalk[summaryColor].bold([
+                "  ", fixableErrorCount, pluralize(" error", fixableErrorCount), " and ",
+                fixableWarningCount, pluralize(" warning", fixableWarningCount),
+                " potentially fixable with the `--fix` option.\n"
+            ].join(""));
+        }
+    }
+
+    // Resets output color, for prevent change on top level
+    return total > 0 ? chalk.reset(output) : "";
 }
 
 async function lint$1(patterns, fix, rule, hook = {}) {
@@ -2148,24 +2672,34 @@ async function lint$1(patterns, fix, rule, hook = {}) {
 const condition = {
   currency: hasCurrencyName,
 };
-async function customColumnModule (lintc, fix, rule, parentRule) {
-  const { way } = await inquirer.prompt([
-    {
-      message: "请选择检测自定义列方式",
-      name: "way",
-      type: "list",
-      choices: [
-        {
-          name: "自动检测HxSearchListPage、this.$customColumnDialog的自定义列ID",
-          value: "normal",
-        },
-        {
-          name: "自定义输入",
-          value: "input",
-        },
-      ],
-    },
-  ]);
+// 自定义列检测(支持 --way/--column-id 一键, CLI参数 > 交互)
+async function customColumnModule (lintc, fix, rule, parentRule, cliOpts = {}) {
+  // 空字符串视为未传(与askOrUse语义一致)
+  const cliWay = cliOpts.way || undefined;
+  const cliColumnId = cliOpts.columnId || undefined;
+  // CLI参数校验前置(快速失败, 不进交互)
+  if (cliWay !== undefined) {
+    validateChoice(cliWay, ["normal", "input"], "--way");
+  }
+  if (cliColumnId !== undefined && cliWay !== "input") {
+    console.log(chalk.red("参数 --column-id 须搭配 --way input 使用"));
+    process.exit(1);
+  }
+  const way = await askOrUse(cliWay, {
+    message: "请选择检测自定义列方式",
+    name: "way",
+    type: "list",
+    choices: [
+      {
+        name: "自动检测HxSearchListPage、this.$customColumnDialog的自定义列ID",
+        value: "normal",
+      },
+      {
+        name: "自定义输入",
+        value: "input",
+      },
+    ],
+  });
   if (way === "normal") {
     lint$1(lintc, fix, "customColumnModule", {
       lintFilesAfter: (results, Loading) => {
@@ -2182,14 +2716,29 @@ async function customColumnModule (lintc, fix, rule, parentRule) {
       },
     });
   } else if (way === "input") {
-    const { customColumnId } = await inquirer.prompt([
-      {
-        message: "请输入自定义列ID,格式为xx,xx,xx",
-        name: "customColumnId",
-        type: "input",
-      },
-    ]);
-    const moduleArr = customColumnId.split(",").map((item) => {
+    // CLI传入直接用, 否则交互输入
+    let customColumnId;
+    if (cliColumnId !== undefined) {
+      customColumnId = cliColumnId;
+    } else {
+      const res = await inquirer.prompt([
+        {
+          message: "请输入自定义列ID,格式为xx,xx,xx",
+          name: "customColumnId",
+          type: "input",
+        },
+      ]);
+      customColumnId = res.customColumnId;
+    }
+    const columnArr = customColumnId
+      .split(",")
+      .map((item) => item.trim())
+      .filter(Boolean);
+    if (!columnArr.length) {
+      console.log(chalk.red("自定义列ID不能为空"));
+      process.exit(1);
+    }
+    const moduleArr = columnArr.map((item) => {
       return {
         module: item,
         path: "NA",
@@ -2200,11 +2749,17 @@ async function customColumnModule (lintc, fix, rule, parentRule) {
 }
 
 async function getColumn(moduleArr = [], dynamicsArr = [], parentRule) {
-  const token = await login({
-    env: "sit",
-    username: "superAdmin",
-    password: "admin1",
-  });
+  let token;
+  try {
+    token = await login({
+      env: "sit",
+      username: "superAdmin",
+      password: "admin1",
+    });
+  } catch (e) {
+    console.log(chalk.red(`登录失败: ${e.message || e}`));
+    return;
+  }
   const requestArr = moduleArr.map(({ module, path }) =>
     request$1({
       url: `http://sit-hxjf.hongxinshop.com/api-item/api/customizedColumns/find`,
@@ -2396,8 +2951,8 @@ function getGitChangedFiles() {
       .filter((f) => fs.existsSync(f));
     return allFiles;
   } catch (error) {
-    console.log(chalk.red("获取git修改文件失败，请确保在git仓库中运行"));
-    return [];
+    // git命令失败(如不在git仓库中运行)属于使用错误, 以退出码1结束
+    exitError("获取git修改文件失败，请确保在git仓库中运行");
   }
 }
 // const spinner = ora();
@@ -2411,7 +2966,7 @@ commander.program.option("-i, --input <type>", "翻译空key");
 // 上传翻译
 commander.program.option("-u, --upload", "上传翻译包");
 // 同步sass应用权限配置
-commander.program.option("-sass, --sass", "同步sass按钮权限配置");
+commander.program.option("-sass, --sass", "sass按钮权限配置(同步/新增)");
 // 检测未$hxt中文
 commander.program.option("-lint, --lint <patterns>", "检测未$hxt的中文");
 // 检测配置项
@@ -2420,10 +2975,66 @@ commander.program.option("-lintc, --lintc <patterns>", "检测指定配置规则
 commander.program.option("--fix", "修复lint检出的错误");
 // 翻译excel指定列语言
 commander.program.option("-excel, --excel", "翻译excel指定列语言");
+// 一键执行选择参数(取值优先级: CLI参数 > --cache凭据缓存 > 交互询问)
+commander.program.option("--cache", "凭据静默走缓存(百度appid/key、域账号密码), 缓存缺失时回退交互");
+commander.program.option("--env <env>", "上传环境: mit|sit|uat|pro, 多环境逗号分隔(仅mit/sit/uat, pro须单独传); sass新增时单选mit|sit|uat");
+commander.program.option("--username <name>", "域账号(env为pro时为生产域账号)");
+commander.program.option("--password <pwd>", "域密码(明文会进shell历史, 日常建议用--cache)");
+commander.program.option("--files <files>", "上传的excel文件, 逗号分隔或all(全部), 如 --files \"a.xlsx,b.xlsx\"");
+commander.program.option("--appid <appid>", "百度翻译appid");
+commander.program.option("--key <key>", "百度翻译key");
+commander.program.option("--merge", "翻译结果合并至export.xlsx(默认覆盖)");
+commander.program.option("--from <env>", "sass同步源环境: mit|sit|uat");
+commander.program.option("--to <env>", "sass同步目标环境: mit|sit|uat(须不同于--from)");
+commander.program.option("--app <name>", "sass应用名称关键字(同步/新增)");
+commander.program.option("--action <action>", "sass功能: sync(同步按钮权限) | permission(新增按钮权限)");
+commander.program.option("--permission-name <name>", "sass按钮权限名称(须搭配 --action permission)");
+commander.program.option("--permission-code <code>", "sass按钮权限编码(须搭配 --action permission)");
+commander.program.option("--rule <rule>", "lintc检查规则: currency");
+commander.program.option("--scene <scene>", "lintc检查场景: currency|customColumnModule");
+commander.program.option("--way <way>", "自定义列检测方式: normal|input");
+commander.program.option("--column-id <ids>", "自定义列ID, 逗号分隔(way=input时), 如 --column-id \"a,b,c\"");
+commander.program.option("--file <name>", "excel翻译的文件名");
+commander.program.option("--lang <lang>", "excel翻译的语言列(如en、vi)");
+// help追加的一键执行示例(命令绿色, 说明灰色, 按最长命令对齐)
+const helpExamples = [
+  ["fe-it-beta -u --env sit --files all --cache", "上传全部excel到sit, 账号密码走缓存"],
+  ["fe-it-beta -u --env sit --files all --username xxx --cache", "账号用传的, 其余凭据走缓存(可混合)"],
+  ['fe-it-beta -u --env "mit,sit,uat" --files export.xlsx --cache', ""],
+  ["fe-it-beta -i src --cache", "翻译空key, 凭据走缓存, 覆盖export.xlsx"],
+  ["fe-it-beta -i src --appid x --key y --merge", "翻译并合并至export.xlsx"],
+  ["fe-it-beta -lint src --fix", "检测并自动修复"],
+  [
+    'fe-it-beta -lintc src --rule currency --scene customColumnModule --way input --column-id "a,b,c"',
+    "",
+  ],
+  ["fe-it-beta -sass --from mit --to sit --app 应用名", "传同步参数直通同步流程"],
+  [
+    "fe-it-beta -sass --action permission --env mit --app 应用名 --permission-name 权限名 --permission-code 编码",
+    "一键新增按钮权限(参数齐全免确认)",
+  ],
+  ["fe-it-beta -excel --file export.xlsx --lang vi --cache", ""],
+];
+commander.program.addHelpText(
+  "after",
+  "\n" +
+    chalk.bold("一键执行示例") +
+    " " +
+    chalk.gray("(注意: PowerShell下含逗号的参数值需加引号)") +
+    ":\n" +
+    helpExamples
+      .map(([cmd, desc]) => {
+        // 说明列固定从62列起, 超长命令后接2空格
+        const pad = " ".repeat(Math.max(2, 62 - cmd.length));
+        return "  " + chalk.green(cmd) + (desc ? chalk.gray(pad + desc) : "");
+      })
+      .join("\n")
+);
 commander.program.parse(process.argv);
 
 // 判断命令参数
 const { input, sass, upload, lint, lintc, fix, excel } = commander.program.opts();
+const cliOpts = commander.program.opts();
 const rules = [
   {
     message: "请选择检查规则",
@@ -2455,9 +3066,9 @@ const rules = [
   },
 ];
 if (sass) {
-  syncSassConfig();
+  sassMain(cliOpts);
 } else if (upload) {
-  upload$1();
+  upload$1(cliOpts);
 } else if (lint !== undefined) {
   // 必须传入路径
   if (!lint || !lint.trim()) {
@@ -2479,24 +3090,46 @@ if (sass) {
   }
   lint$1(lintPatterns, fix);
 } else if (lintc) {
-  inquirer.prompt(rules).then(async ({ rule }) => {
-    const parentRule = rule;
-    if (rule === "currency") {
-      const ruleChoice = rules.find((item) => item.name === "rule");
-      const currencySubChoice = ruleChoice.choices.find(
-        (item) => item.value === "currency"
-      ).children;
-      const { scene } = await inquirer.prompt(currencySubChoice);
-      rule = scene;
-      if (rule === "customColumnModule") {
-        return customColumnModule(lintc, fix, rule, parentRule);
-      }
-    }
-    lint$1(lintc, fix, rule);
-  });
+  runLintc().catch((error) => console.error(error));
 } else if (excel) {
-  excelFn();
+  excelFn(cliOpts);
 } else {
+  runTranslate().catch((error) => console.error(error));
+}
+
+// lintc分支(支持 --rule/--scene 一键执行)
+async function runLintc() {
+  const ruleQuestion = rules.find((item) => item.name === "rule");
+  const ruleValues = ruleQuestion.choices.map((item) => item.value);
+  if (cliOpts.rule !== undefined) {
+    validateChoice(cliOpts.rule, ruleValues, "--rule");
+  }
+  const parentRule = await askOrUse(cliOpts.rule, ruleQuestion);
+  if (parentRule === "currency") {
+    const currencySubChoice = ruleQuestion.choices.find(
+      (item) => item.value === "currency"
+    ).children;
+    const sceneValues = currencySubChoice[0].choices.map((item) => item.value);
+    if (cliOpts.scene !== undefined) {
+      validateChoice(cliOpts.scene, sceneValues, "--scene");
+    }
+    const scene = await askOrUse(cliOpts.scene, currencySubChoice[0]);
+    if (scene === "customColumnModule") {
+      return customColumnModule(lintc, fix, scene, parentRule, cliOpts);
+    }
+    lint$1(lintc, fix, scene);
+  }
+}
+
+// 默认翻译分支(支持 --appid/--key/--merge/--cache 一键执行)
+async function runTranslate() {
+  // 前置守卫: 必须传入 -i 路径
+  if (!input || !String(input).trim()) {
+    console.log(chalk.red("请传入要翻译的路径 -i <path>"));
+    process.exit(1);
+  }
+  const { cache, appid, key, merge } = cliOpts;
+  const oneClick = Boolean(cache || appid || key || merge);
   let projectName = "请在package.json中配置name字段(项目名称)";
   const projectPath = "./package.json";
   const isExist = isExistPath(projectPath);
@@ -2504,91 +3137,77 @@ if (sass) {
     const str = fs.readFileSync(projectPath, "utf-8").toString();
     projectName = JSON.parse(str).name;
   }
-  inquirer
-    .prompt([
+  if (!oneClick) {
+    const { isProjectName } = await inquirer.prompt([
       {
         message: `请确认package.json中项目名称是否是${projectName}`,
         name: "isProjectName",
         type: "confirm",
         default: true,
       },
-    ])
-    .then((res) => {
-      if (res.isProjectName) {
-        inquirer
-          .prompt([
-            {
-              message: "请选择翻译接口",
-              name: "type",
-              type: "list",
-              choices: [
-                {
-                  name: "百度翻译",
-                  value: "baidu",
-                },
-              ],
-            },
-          ])
-          .then((res) => {
-            const { type } = res;
-            let cacheSecret = {};
-            if (!isExistPath(getRunCliPath({ root: true }) + "/.cache")) {
-              fs.mkdirSync(getRunCliPath({ root: true }) + "/.cache");
-            }
-            const cacheFilePath =
-              getRunCliPath({ root: true }) + "/.cache/" + res.type;
-            if (isExistPath(cacheFilePath)) {
-              const cache = JSON.parse(readCache(res.type));
-              cacheSecret = cache;
-            }
-            const question = [
-              {
-                message: "请输入百度翻译的appid",
-                name: "appid",
-                default: cacheSecret.appid,
-                // 必填
-                validate: function (val) {
-                  if (val) {
-                    return true;
-                  }
-                  return "请输入百度翻译的appid";
-                },
-              },
-              {
-                message: "请输入百度翻译的key",
-                name: "key",
-                default: cacheSecret.key,
-                // 必填
-                validate: function (val) {
-                  if (val) {
-                    return true;
-                  }
-                  return "请输入百度翻译的key";
-                },
-              },
-            ];
-            inquirer.prompt(question).then((res) => {
-              writeCache(
-                type,
-                JSON.stringify({
-                  type,
-                  ...res,
-                })
-              );
-              const { appid, key } = res;
-              const isLintFix = fix;
-              translateUtil(appid, key, projectName, isLintFix);
-            });
-          });
-      } else {
-        console.log(
-          chalk.red("请在package.json中配置正确的name字段(项目名称)")
-        );
-      }
-    });
+    ]);
+    if (!isProjectName) {
+      console.log(
+        chalk.red("请在package.json中配置正确的name字段(项目名称)")
+      );
+      process.exit(1);
+    }
+  }
+  // 翻译接口(当前仅百度, 一键执行时自动选择)
+  let type = "baidu";
+  if (!oneClick) {
+    const res = await inquirer.prompt([
+      {
+        message: "请选择翻译接口",
+        name: "type",
+        type: "list",
+        choices: [
+          {
+            name: "百度翻译",
+            value: "baidu",
+          },
+        ],
+      },
+    ]);
+    type = res.type;
+  }
+  // 凭据: CLI参数 > --cache缓存 > 交互
+  const secret = await resolveSecretQuestions({
+    questions: [
+      {
+        message: "请输入百度翻译的appid",
+        name: "appid",
+        // 必填
+        validate: function (val) {
+          if (val) {
+            return true;
+          }
+          return "请输入百度翻译的appid";
+        },
+      },
+      {
+        message: "请输入百度翻译的key",
+        name: "key",
+        // 必填
+        validate: function (val) {
+          if (val) {
+            return true;
+          }
+          return "请输入百度翻译的key";
+        },
+      },
+    ],
+    cliValues: { appid, key },
+    useCache: Boolean(cache),
+    cacheKey: type,
+    extraCache: { type },
+  });
+  // isMerge预决定: --merge为true, 一键执行默认false(覆盖), 否则翻译完成后交互询问
+  const isMergeDecision = merge ? true : oneClick ? false : null;
+  translateUtil(secret.appid, secret.key, projectName, fix, isMergeDecision);
 }
 
-function translateUtil(appid, key, projectName, isLintFix) {
+function translateUtil(appid, key, projectName, isLintFix, isMergeDecision) {
   const { input } = commander.program.opts();
   // 支持逗号分隔的多个路径(来自 -lint git 的多文件场景)
   const inputPaths = String(input)
@@ -2736,14 +3355,19 @@ function translateUtil(appid, key, projectName, isLintFix) {
         });
         exportData.push(rowArr);
       });
-      const { isMerge } = await inquirer.prompt([
-        {
-          message: `是否合并至export.xlsx,默认${chalk.red("否,直接覆盖")}`,
-          name: "isMerge",
-          type: "confirm",
-          default: false,
-        },
-      ]);
+      // isMergeDecision: true/false为预决定值(一键执行), null表示仍需交互询问
+      let isMerge = isMergeDecision;
+      if (isMerge === null || isMerge === undefined) {
+        const res = await inquirer.prompt([
+          {
+            message: `是否合并至export.xlsx,默认${chalk.red("否,直接覆盖")}`,
+            name: "isMerge",
+            type: "confirm",
+            default: false,
+          },
+        ]);
+        isMerge = res.isMerge;
+      }
       try {
         if (isMerge) {
           const str = xlsx.parse(fs.readFileSync("./export.xlsx"));