lightshortcuts 1.0.9 → 1.1.0

package/bin/lsc.js

@@ -6,543 +6,732 @@ const { Command } = require("commander");
 const inquirer = require("inquirer");
 const program = new Command();
 const { LSC } = require("../index");
-const { merge, getZipFileList } = require("../lib/utils");
+const { merge, getZipFileList, pwdMd5, fmtTime } = require("../lib/utils");
 const fileExists = require("../lib/helpers/file-exists");
+const { createZip } = require("../lib/helpers/zip");
 
+const log = (message, ...args) => {
+  console.log(`[${fmtTime()}] ${message}`, ...args);
+};
+
+const error = (message, ...args) => {
+  console.error(`[${fmtTime()}] ${message}`, ...args);
+};
+
+const warn = (message, ...args) => {
+  console.warn(`[${fmtTime()}] ${message}`, ...args);
+};
+
+const info = (message, ...args) => {
+  console.info(`[${fmtTime()}] ${message}`, ...args);
+};
+
+// 主目录下登录配置文件
+let confPath = path.join(process.cwd(), "./lsc.config.json");
 // 读取发布配置文件
 const lscrcPath = path.join(
-    process.env.HOME || process.env.USERPROFILE,
-    ".lscrc.json"
+  process.cwd() || process.env.HOME || process.env.USERPROFILE,
+  ".lscrc.json",
 );
 
 const defaultConfig = require("../lib/defaults");
 const {
-    checkSession,
-    initAxiosConfig,
-    logout,
-    dealVersionList,
-    batchDealVersionList
+  submitLogin,
+  getCaptcha,
+  checkSession,
+  initAxiosConfig,
+  logout,
+  dealVersionList,
+  batchDealVersionList,
+  sendWechatWebhook,
 } = require("../lib/core/API");
-// 主目录下登录配置文件
-let confPath = path.join(process.cwd(), "./lsc.config.json");
 
-program.version("0.0.8");
+program.version("1.1.0");
 
 // 登录并保存token
 let lightBaseURL = "";
 let loginQuestions = [
-    {
-        type: "list",
-        message: "现在配置的环境是？",
-        name: "env",
-        choices: [
-            { key: 0, value: "dev", name: "测试环境", checked: true },
-            { key: 1, value: "prod", name: "生产环境" },
-        ],
+  {
+    type: "list",
+    message: "现在配置的环境是？",
+    name: "env",
+    choices: [
+      { key: 0, value: "dev", name: "测试环境", checked: true },
+      { key: 1, value: "prod", name: "生产环境" },
+    ],
+  },
+  {
+    type: "input",
+    message: "请输入API前缀地址：",
+    name: "lightBaseURL",
+    default: () => lightBaseURL || defaultConfig.lightBaseURL,
+    validate: async (url) => {
+      lightBaseURL = url;
+      return /^https?:\/\//.test(lightBaseURL);
     },
-    {
-        type: "input",
-        message: "请输入API前缀地址：",
-        name: "lightBaseURL",
-        default: () => lightBaseURL || defaultConfig.lightBaseURL,
-        validate: async (url) => {
-            lightBaseURL = url;
-            return true;
-        },
+    filter: (url) => url.trim(),
+  },
+  {
+    type: "input",
+    message: "请输入手机号或邮箱：",
+    name: "account",
+    validate: async (account) => {
+      return (
+        /^[a-zA-Z0-9_.-]+@[a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)*\.[a-zA-Z0-9]{2,6}$|^1[3456789]\d{9}$/.test(
+          account,
+        ) && account.length > 0
+      );
     },
-    {
-        type: "input",
-        message: "请输入token：",
-        name: "token",
-        validate: async (token) => {
-            return await validSession(lightBaseURL, token);
-        },
-        validatingText: "正在校验token的有效性...",
+    filter: (account) => account.trim(),
+  },
+  {
+    type: "input",
+    message: "请输入密码：",
+    name: "rawPassword",
+    validate: async (rawPassword, answers) => {
+      if (rawPassword.length === 0) {
+        return false;
+      }
+      await initAxiosConfig(lightBaseURL, "No token");
+      let ps = pwdMd5(rawPassword, answers.account);
+      const { user_token } = await submitLogin({
+        account: answers.account,
+        password: ps,
+      });
+      if (user_token) {
+        answers.token = user_token;
+        answers.password = ps;
+        return true;
+      } else {
+        error("登录失败");
+        return false;
+      }
+    },
+    validatingText: "正在校验密码的有效性...",
+  },
+  // 企微推送启用问题
+  {
+    type: "confirm",
+    name: "enableWecomPush",
+    message: "是否启用企微推送？",
+    default: false,
+  },
+  // 企微链接问题（仅在启用时显示）
+  {
+    type: "input",
+    name: "wecomWebhook",
+    message: "请输入企微机器人Webhook链接：",
+    when: (answers) => answers.enableWecomPush,
+    validate: async (input) => {
+      try {
+        const result = await sendWechatWebhook(
+          input,
+          "为离线包发布配置企微机器人链接成功！",
+        );
+        log("配置机器人链接响应:", result);
+        return true;
+      } catch (error) {
+        error("配置机器人链接失败:", error);
+        return false;
+      }
     },
+    filter: (input) => input.trim(),
+  },
 ];
 //校验是否已经登录
 const loginAction = async function (env) {
-    fileExists(lscrcPath)
-        .then(async (res) => {
-            // 是否需要交互处理
-            let needLoginProcessF = true;
-            if (res) {
-                // 存在文件
-                let lscRc = require(lscrcPath);
-                if (
-                    lscRc[`${env}`] &&
-                    lscRc[`${env}`].lightBaseURL &&
-                    lscRc[`${env}`].token
-                ) {
-                    lightBaseURL = lscRc[`${env}`].lightBaseURL;
-                    // console.log(lightBaseURL);
-                    let res = await validSession(
-                        lscRc[`${env}`].lightBaseURL,
-                        lscRc[`${env}`].token
-                    );
-                    if (!res) {
-                        // 已有API链接
-                        // loginQuestions.shift();
-                        console.log(lscRc[`${env}`]);
-                        console.log("\n");
-                    } else {
-                        // token仍有效
-                        console.log(`已登录，当前通道：${env}`);
-                        needLoginProcessF = false;
-                    }
-                } else {
-                    needLoginProcessF = true;
-                }
+  fileExists(lscrcPath)
+    .then(async (res) => {
+      // 是否需要交互处理
+      let needLoginProcessF = true;
+      if (res) {
+        // 存在登录配置文件
+        log("存在登录配置文件");
+        let lscRc = require(lscrcPath);
+        // log(lscRc);
+        let { lightBaseURL, token, account, password } = lscRc[`${env}`];
+        if (lscRc[`${env}`] && lightBaseURL && token && account && password) {
+          // 提取登录配置文件字段，校验token是否有效
+          // lightBaseURL = lscRc[`${env}`].lightBaseURL;
+          log("检查会话有效性...");
+          await initAxiosConfig(lightBaseURL, token);
+          let validSessionRes = await validSession(lightBaseURL, token);
+          if (!validSessionRes) {
+            // 会话已过期或者无效，重新登录
+            await log("会话已过期或者无效，自动重新登录");
+            // 自动登录
+            let autoLoginRes = await submitLogin({
+              account,
+              password,
+            });
+            // log("登录响应:", res);
+            if (autoLoginRes.user_token) {
+              log(
+                `登录成功欢迎${autoLoginRes.user?.identity_name}`,
+                autoLoginRes.user_token,
+              );
+              //更新当前发布配置里面的token
+              lscRc[`${env}`].token = autoLoginRes.user_token;
+              //写入配置文件
+              // log("更新登录配置文件");
+              await writeConfig(lscRc, lscrcPath);
+              // log("登录配置已更新");
             } else {
-                // 不存在文件
-                needLoginProcessF = true;
+              error("登录失败");
             }
-            if (needLoginProcessF) {
-                inquirer.prompt(loginQuestions).then(async (answers) => {
-                    // let lscRc = require(lscrcPath);
-                    // lscRc.currentEnv = env;
-                    let { lightBaseURL, token, env } = answers;
-                    // await writeConfig(answers, lscrcPath);
+            // 已有API链接
+            // loginQuestions.shift();
+            // log(lscRc[`${env}`]);
+            // log("\n");
+          } else {
+            // token仍有效
+            log(`已登录，当前通道：${env}`);
+            needLoginProcessF = false;
+          }
 
-                    let lscRc = {};
-                    let fef = await fileExists(lscrcPath);
+          // 无需交互式登录处理
+          return;
+        } else {
+          needLoginProcessF = true;
+        }
+      } else {
+        // 不存在文件
+        needLoginProcessF = true;
+      }
+      if (needLoginProcessF) {
+        // 交互式登录处理
+        inquirer.prompt(loginQuestions).then(async (answers) => {
+          // let lscRc = require(lscrcPath);
+          // lscRc.currentEnv = env;
+          // log(`交互式登录问题：${JSON.stringify(answers)}`);
+          let { lightBaseURL, token, env, account, password, wecomWebhook } =
+            answers;
+          // await writeConfig(answers, lscrcPath);
 
-                    if (fef) {
-                        lscRc = require(lscrcPath);
-                    }
-                    lscRc.currentEnv = env;
-                    lscRc[`${env}`] = { lightBaseURL, token };
+          let lscRc = {};
+          let fef = await fileExists(lscrcPath);
 
-                    await writeConfig(lscRc, lscrcPath);
-                    // console.log(JSON.stringify(lscRc));
-                    return true;
-                });
-            }
-        })
-        .catch((err) => {
-            console.log(err);
-            return false;
+          if (fef) {
+            lscRc = require(lscrcPath);
+          }
+          lscRc.currentEnv = env;
+          lscRc[`${env}`] = {
+            lightBaseURL,
+            token,
+            account,
+            password,
+            wecomWebhook,
+          };
+
+          await writeConfig(lscRc, lscrcPath);
+          // log(JSON.stringify(lscRc));
+          return true;
         });
+      }
+    })
+    .catch((err) => {
+      log(err);
+      return false;
+    });
 };
 program
-    .command("login")
-    .description("登录会话")
-    .option("-e, --env <type>", "选择管控台的环境")
-    .action(async (opts) => {
-        let { env } = opts;
-        if (env == undefined) {
-            // 没传环境变量参数
-            let fef = await fileExists(lscrcPath);
-            if (fef) {
-                let { currentEnv } = require(lscrcPath);
-                if (currentEnv) {
-                    env = currentEnv;
-                } else {
-                    env = "dev";
-                }
-            } else {
-                env = "dev";
-            }
+  .command("login")
+  .description("登录会话")
+  .option("-e, --env <type>", "选择管控台的环境")
+  .action(async (opts) => {
+    let { env } = opts;
+    if (env == undefined) {
+      // 没传环境变量参数
+      let fef = await fileExists(lscrcPath);
+      if (fef) {
+        try {
+          let { currentEnv } = require(lscrcPath);
+          if (currentEnv) {
+            env = currentEnv;
+          } else {
+            env = "dev";
+          }
+        } catch (error) {
+          log(
+            `🔥🔥🔥读取登录配置文件失败:${error},请检查文件格式是否正确，或者删掉掉${lscrcPath}文件，使用lsc login重新登录!`,
+          );
         }
-        await loginAction(env);
-    });
+      } else {
+        env = "dev";
+      }
+    }
+    await loginAction(env);
+  });
+//获取MD5密码
+program
+  .command("md5")
+  .description("获取MD5密码")
+  .option("-p, --password <type>", "输入密码")
+  .option("-e, --email <type>", "输入邮箱")
+  .action(async (opts) => {
+    let { password, email } = opts;
+    //如何没有密码或者邮箱，通过交互式输入
+    if (!password || !email) {
+      inquirer
+        .prompt([
+          {
+            type: "input",
+            name: "password",
+            message: "请输入密码:",
+          },
+          {
+            type: "input",
+            name: "email",
+            message: "请输入邮箱:",
+          },
+        ])
+        .then((answers) => {
+          password = answers.password;
+          email = answers.email;
+          log("密码MD5:", pwdMd5(password, email));
+        });
+    } else {
+      log("密码MD5:", pwdMd5(password, email));
+    }
+  });
 
 // 注销会话
 program
-    .command("logout")
-    .description("注销会话")
-    .option("-e, --env <type>", "选择管控台的环境")
-    .option("-l, --link <link>", "注销指定管控台链接")
-    .option("-t, --token <token>", "注销指定token")
-    .action(async (opts) => {
-        let { env, link, token } = opts;
-        let baseUrl, authToken;
-        if (env == undefined) {
-            // 没传env环境变量参数
-            let fef = await fileExists(lscrcPath);
-            if (fef) {
-                // 有本地会话配置，读取本地会话
-                let r = require(lscrcPath);
-                if (r.currentEnv) {
-                    // 有本地会话
-                    env = r.currentEnv;
-                    //如果传入url,token则用传入的，否则用本地的；
-                    baseUrl = link ? link : r[`${env}`].lightBaseURL;
-                    authToken = token ? token : r[`${env}`].token;
-                } else {
-                    console.log("不存在本地会话，请传入url,token");
-                }
-            } else {
-                // 不存在本地会话时
-                console.log("不存在本地会话，请传入url,token");
-            }
-        }
-        if (baseUrl && authToken) {
-            await initAxiosConfig(baseUrl, authToken);
-            let f = await logout(token);
-            console.log(`注销${f ? "成功" : "失败"}`);
+  .command("logout")
+  .description("注销会话")
+  .option("-e, --env <type>", "选择管控台的环境")
+  .option("-l, --link <link>", "注销指定管控台链接")
+  .option("-t, --token <token>", "注销指定token")
+  .action(async (opts) => {
+    let { env, link, token } = opts;
+    let baseUrl, authToken;
+    if (env == undefined) {
+      // 没传env环境变量参数
+      let fef = await fileExists(lscrcPath);
+      if (fef) {
+        // 有本地会话配置，读取本地会话
+        let r = require(lscrcPath);
+        if (r.currentEnv) {
+          // 有本地会话
+          env = r.currentEnv;
+          //如果传入url,token则用传入的，否则用本地的；
+          baseUrl = link ? link : r[`${env}`].lightBaseURL;
+          authToken = token ? token : r[`${env}`].token;
         } else {
-            console.log("不存在本地会话，请传入url,token");
+          log("不存在本地会话，请传入url,token");
         }
-    });
+      } else {
+        // 不存在本地会话时
+        log("不存在本地会话，请传入url,token");
+      }
+    }
+    if (baseUrl && authToken) {
+      await initAxiosConfig(baseUrl, authToken);
+      let f = await logout(token);
+      log(`注销${f ? "成功" : "失败"}`);
+    } else {
+      log("不存在本地会话，请传入url,token");
+    }
+  });
 
 // 设置当前发布版本
 program
-    .command("use <name>")
-    .description("设置当前发布版本")
-    .action(async (opts) => {
-        let fef = await fileExists(lscrcPath);
-        if (fef) {
-            let lscRc = require(lscrcPath);
-            lscRc.currentEnv = opts;
-            if (lscRc[`${opts}`]) {
-                await writeConfig(lscRc, lscrcPath);
-            } else {
-                console.log("不存在的离线包环境，请先进行登录：lsc login");
+  .command("use <name>")
+  .description("设置当前发布环境")
+  .action(async (opts) => {
+    let fef = await fileExists(lscrcPath);
+    if (fef) {
+      let lscRc = require(lscrcPath);
+      lscRc.currentEnv = opts;
+      if (lscRc[`${opts}`]) {
+        await writeConfig(lscRc, lscrcPath);
+      } else {
+        log("不存在的离线包环境，请先进行登录：lsc login");
+      }
+    } else {
+      log("登录文件不存在，请先进行登录：lsc login");
+    }
+  });
+
+program
+  .command("config")
+  .description("交互式配置离线包发布参数")
+  .action(function () {
+    let initConfig = {},
+      initAnswers = {};
+    inquirer
+      .prompt([
+        {
+          type: "input",
+          message: "请输入离线包id：",
+          name: "pkgid",
+        },
+        {
+          type: "input",
+          message: "请指定离线包发布版本号：",
+          name: "set_pkg_version",
+          default: "1.0.1",
+        },
+        {
+          type: "input",
+          message: "APP版本iOS版本范围：",
+          name: "ios_version_scope",
+          default: "7.0.7",
+        },
+        {
+          type: "input",
+          message: "APP版本Android版本范围：",
+          name: "android_version_scope",
+          default: "7.0.7.0",
+        },
+        {
+          type: "input",
+          message: "APP版本Harmony版本范围：",
+          name: "harmony_version_scope",
+          default: "1.0.1",
+        },
+        {
+          type: "checkbox",
+          message: "请选择发布的APP：",
+          name: "publish_app_arr",
+          choices: [
+            {
+              key: "3542",
+              value: "3542",
+              name: "开发版",
+              checked: true,
+            },
+            {
+              key: "3543",
+              value: "3543",
+              name: "仿真版",
+              checked: true,
+            },
+          ],
+          validate(answer) {
+            if (answer.length < 1) {
+              return "请至少选择一项";
             }
+            return true;
+          },
+        },
+        {
+          type: "input",
+          message: "离线包压缩包存放相对位置：",
+          name: "pkg_dir",
+          default: "./dist/",
+        },
+        {
+          type: "input",
+          message: "离线包名称：",
+          name: "pkg_zip_name",
+          default: "dist.zip",
+        },
+        {
+          type: "list",
+          message: "是否处理上一版本离线包？",
+          name: "task_status",
+          choices: [
+            { key: 0, value: 0, name: "保留", checked: true },
+            { key: 1, value: 1, name: "暂停" },
+            { key: 2, value: 2, name: "结束" },
+          ],
+        },
+        {
+          type: "input",
+          message: "发布日志：",
+          name: "release_desc",
+          default: "功能更新",
+          when: (answers) => {
+            initAnswers = Object.assign({}, answers);
+            // log("initAnswers",initAnswers);
+            return true;
+          },
+        },
+        // {
+        //     type: "input",
+        //     message: "请输入API前缀地址：",
+        //     name: "lightBaseURL",
+        //     default: "https://xxx.xxx.xxx/lightadmin/pas-api",
+        //     when: (answers) => {
+        //         initAnswers = Object.assign({}, answers);
+        //         // log("initAnswers",initAnswers);
+        //         return true;
+        //     },
+        // },
+        {
+          type: "confirm",
+          message: "是否使用以上配置？",
+          name: "useConfig",
+          default: true,
+        },
+        {
+          type: "confirm",
+          message: "是否保存配置？",
+          name: "saveConfig",
+          default: true,
+          when: function (answers) {
+            return answers.useConfig;
+          },
+        },
+      ])
+      .then((asw) => {
+        let { useConfig, saveConfig } = asw;
+        if (useConfig) {
+          let totalConfig = {
+            ...initAnswers,
+            apps_name: defaultConfig.publishInfo.apps_name,
+          };
+          if (saveConfig) {
+            // 保存配置
+            writeConfig(totalConfig);
+          }
+          log(totalConfig);
         } else {
-            console.log("登录文件不存在，请先进行登录：lsc login");
+          log("已结束！");
         }
-    });
-
-program
-    .command("config")
-    .description("交互式配置离线包发布参数")
-    .action(function () {
-        let initConfig = {},
-            initAnswers = {};
-        inquirer
-            .prompt([
-                // {
-                //     type: "input",
-                //     message: "请输入token：",
-                //     name: "token",
-                // },
-                {
-                    type: "input",
-                    message: "请输入离线包id：",
-                    name: "pkgid",
-                },
-                {
-                    type: "input",
-                    message: "请指定离线包发布版本号：",
-                    name: "set_pkg_version",
-                    default: "1.0.1",
-                },
-                {
-                    type: "input",
-                    message: "APP版本iOS版本范围：",
-                    name: "ios_version_scope",
-                    default: "7.0.6",
-                },
-                {
-                    type: "input",
-                    message: "APP版本Android版本范围：",
-                    name: "android_version_scope",
-                    default: "7.0.6.0",
-                },
-                {
-                    type: "checkbox",
-                    message: "请选择发布的APP：",
-                    name: "publish_app_arr",
-                    choices: [
-                        {
-                            key: "3577",
-                            value: "3592",
-                            name: "开发版_iOS",
-                            checked: true,
-                        },
-                        {
-                            key: "3577",
-                            value: "3577",
-                            name: "开发版_安卓",
-                            checked: true,
-                        },
-                    ],
-                    validate(answer) {
-                        if (answer.length < 1) {
-                            return "请至少选择一项";
-                        }
-                        return true;
-                    },
-                },
-                {
-                    type: "input",
-                    message: "离线包压缩包存放相对位置：",
-                    name: "pkg_dir",
-                    default: "./dist/",
-                },
-                {
-                    type: "input",
-                    message: "离线包名称：",
-                    name: "pkg_zip_name",
-                    default: "dist.zip",
-                },
-                {
-                    type: "list",
-                    message: "是否处理上一版本离线包？",
-                    name: "task_status",
-                    choices: [
-                        { key: 0, value: 0, name: "保留", checked: true },
-                        { key: 1, value: 1, name: "暂停" },
-                        { key: 2, value: 2, name: "结束" },
-                    ],
-                },
-                {
-                    type: "input",
-                    message: "发布日志：",
-                    name: "release_desc",
-                    default: "功能更新",
-                    when: (answers) => {
-                        initAnswers = Object.assign({}, answers);
-                        // console.log("initAnswers",initAnswers);
-                        return true;
-                    },
-                },
-                // {
-                //     type: "input",
-                //     message: "请输入API前缀地址：",
-                //     name: "lightBaseURL",
-                //     default: "https://xxx.xxx.xxx/lightadmin/pas-api",
-                //     when: (answers) => {
-                //         initAnswers = Object.assign({}, answers);
-                //         // console.log("initAnswers",initAnswers);
-                //         return true;
-                //     },
-                // },
-                {
-                    type: "confirm",
-                    message: "是否使用以上配置？",
-                    name: "useConfig",
-                    default: true,
-                },
-                {
-                    type: "confirm",
-                    message: "是否保存配置？",
-                    name: "saveConfig",
-                    default: true,
-                    when: function (answers) {
-                        return answers.useConfig;
-                    },
-                },
-            ])
-            .then((asw) => {
-                let { useConfig, saveConfig } = asw;
-                if (useConfig) {
-                    let totalConfig = {
-                        ...initAnswers,
-                        apps_name: defaultConfig.publishInfo.apps_name,
-                    };
-                    if (saveConfig) {
-                        // 保存配置
-                        writeConfig(totalConfig);
-                    }
-                    console.log(totalConfig);
-                } else {
-                    console.log("已结束！");
-                }
-            });
-    });
+      });
+  });
 
 // 初始化配置模板
 const initConfAction = function () {
-    fileExists(confPath).then((res) => {
-        if (res) {
-            console.log("注意，配置文件已经存在！！！内容如下：");
-            console.log(require(confPath));
-            // 存在配置文件，唤起交互输入
-            inquirer
-                .prompt([
-                    {
-                        type: "confirm",
-                        message: "是否重新初始化？",
-                        name: "initConfig",
-                        default: false,
-                    },
-                ])
-                .then((answer) => {
-                    if (answer.initConfig) {
-                        let mergeConf = Object.assign(
-                            defaultConfig.publishInfo
-                        );
-                        writeConfig(mergeConf, confPath);
-                    } else {
-                        console.log("配置无变化");
-                    }
-                });
-        } else {
-            writeConfig(defaultConfig);
-        }
-    });
+  fileExists(confPath).then((res) => {
+    if (res) {
+      log("注意，配置文件已经存在！！！内容如下：");
+      log(require(confPath));
+      // 存在配置文件，唤起交互输入
+      inquirer
+        .prompt([
+          {
+            type: "confirm",
+            message: "是否重新初始化？",
+            name: "initConfig",
+            default: false,
+          },
+        ])
+        .then((answer) => {
+          if (answer.initConfig) {
+            let mergeConf = Object.assign(defaultConfig.publishInfo);
+            writeConfig(mergeConf, confPath);
+          } else {
+            log("配置无变化");
+          }
+        });
+    } else {
+      writeConfig(defaultConfig);
+    }
+  });
 };
 program
-    .command("init")
-    .description("快速初始化配置模板")
-    .action(function () {
-        initConfAction();
-    });
+  .command("init")
+  .description("快速初始化配置模板")
+  .action(function () {
+    initConfAction();
+  });
 
 // 单项目发布
 program
-    .command("publish")
-    .alias("p")
-    .description("发布离线包")
-    .action(async () => {
-        let feLscF = await fileExists(lscrcPath),
-            feConF = await fileExists(confPath);
-        //是否存在配置文件
-        if (feLscF && feConF) {
-            const lscRC = require(lscrcPath),
-                { currentEnv } = lscRC,
-                { lightBaseURL, token } = lscRC[`${currentEnv}`];
-            const publishConfArgs = require(confPath);
+  .command("publish")
+  .alias("p")
+  .description("发布离线包")
+  .action(async () => {
+    let feLscF = await fileExists(lscrcPath),
+      feConF = await fileExists(confPath);
+    //是否存在配置文件
+    if (feLscF && feConF) {
+      const lscRC = require(lscrcPath),
+        { currentEnv } = lscRC,
+        { lightBaseURL, token, wecomWebhook } = lscRC[`${currentEnv}`];
+      const publishConfArgs = require(confPath);
 
-            if (publishConfArgs.publishInfo) {
-                console.log(
-                    "温馨提示：程序已升级！\n请使用命令lsc config 或 lsc init 重新生成发布配置"
-                );
-                return;
-            }
+      if (publishConfArgs.publishInfo) {
+        log(
+          "温馨提示：程序已升级！\n请使用命令lsc config 或 lsc init 重新生成发布配置",
+        );
+        return;
+      }
 
-            try {
-                // let lscConfig = require(confPath);
-                let totalConfig = {
-                    publishInfo: { ...publishConfArgs, token },
-                    lightBaseURL,
-                };
-                // console.log("发布配置：\n", totalConfig);
-                LSC(totalConfig);
-            } catch (error) {
-                console.log("主程序异常", error);
-            }
-        } else {
-            // 不存在配置文件，唤起交互输入
-            let t = "",
-                f = "";
-            if (!feLscF) {
-                f = "登录";
-                t = "lsc login";
-            }
-            if (!feConF) {
-                f = "离线包发布";
-                t = "lsc config 或 lsc init";
-            }
-            console.log(`不存在${f}配置文件，请使用命令创建：${t}`);
-        }
-    });
+      try {
+        // let lscConfig = require(confPath);
+        let totalConfig = {
+          publishInfo: { ...publishConfArgs, token },
+          lightBaseURL,
+          wecomWebhook,
+        };
+        // log("发布配置：\n", totalConfig);
+        LSC(totalConfig);
+      } catch (error) {
+        log("主程序异常", error);
+      }
+    } else {
+      // 不存在配置文件，唤起交互输入
+      let t = "",
+        f = "";
+      if (!feLscF) {
+        f = "登录";
+        t = "lsc login";
+      }
+      if (!feConF) {
+        f = "离线包发布";
+        t = "lsc config 或 lsc init";
+      }
+      log(`不存在${f}配置文件，请使用命令创建：${t}`);
+    }
+  });
 
 // 批量离线包发布.已经包名作为pkgid
 program
-    .command("batch")
-    .description("发布离线包")
-    .alias("b")
-    .action(async function () {
-        const lscRC = require(lscrcPath),
-            { currentEnv } = lscRC,
-            { lightBaseURL, token } = lscRC[`${currentEnv}`];
-        const publishConfArgs = require(confPath);
+  .command("batch")
+  .description("发布离线包")
+  .alias("b")
+  .action(async function () {
+    const lscRC = require(lscrcPath),
+      { currentEnv } = lscRC,
+      { lightBaseURL, token } = lscRC[`${currentEnv}`];
+    const publishConfArgs = require(confPath);
 
-        let currPath = path.join(process.cwd(), publishConfArgs.pkg_dir);
-        let zipLists = await getZipFileList(currPath);
-        for (let i = 0; i < zipLists.length; i++) {
-            const e = zipLists[i],
-                s = e.split("."),
-                pkgid = s[0];
-            let totalConfig = {
-                publishInfo: { ...publishConfArgs, token },
-                lightBaseURL,
-            };
-            let batchConfig = merge(totalConfig, {
-                publishInfo: { pkgid, pkg_zip_name: e },
-            });
-            // console.log("batchConfig\n", batchConfig);
-            await LSC(batchConfig);
-        }
-    });
+    let currPath = path.join(process.cwd(), publishConfArgs.pkg_dir);
+    let zipLists = await getZipFileList(currPath);
+    for (let i = 0; i < zipLists.length; i++) {
+      const e = zipLists[i],
+        s = e.split("."),
+        pkgid = s[0];
+      let totalConfig = {
+        publishInfo: { ...publishConfArgs, token },
+        lightBaseURL,
+      };
+      let batchConfig = merge(totalConfig, {
+        publishInfo: { pkgid, pkg_zip_name: e },
+      });
+      // log("batchConfig\n", batchConfig);
+      await LSC(batchConfig);
+    }
+  });
 
 // 处理离线包兼容版本相互重叠的情况
 program
-    .command("deal version")
-    .description("处理离线包兼容版本相互重叠的情况，谨慎使用！")
-    .action(async function () {
-        let dv = [
-            {
-                type: "input",
-                message: "请输入app_id：",
-                name: "app_id",
-                default:3592
-            },
-            {
-                type: "input",
-                message: "请输入pkg_id：",
-                name: "pkg_id",
-                default:2307
-            },
-        ];
-        inquirer.prompt(dv).then(async function (aws) {
-            const {app_id, pkg_id} = aws;
-            let f = await fileExists(lscrcPath);
-            if (f) {
-                let lscRc = require(lscrcPath),
-                    { currentEnv } = lscRc;
-                const { lightBaseURL, token } = lscRc[`${currentEnv}`];
-                await initAxiosConfig(lightBaseURL, token);
-                await dealVersionList({app_id, pkg_id});
-            } else {
-                console.log("登录文件不存在，请先进行登录：lsc login");
-            }
-        });
+  .command("deal version")
+  .description("处理离线包兼容版本相互重叠的情况，谨慎使用！")
+  .action(async function () {
+    let dv = [
+      {
+        type: "input",
+        message: "请输入app_id：",
+        name: "app_id",
+        default: 3592,
+      },
+      {
+        type: "input",
+        message: "请输入pkg_id：",
+        name: "pkg_id",
+        default: 2307,
+      },
+    ];
+    inquirer.prompt(dv).then(async function (aws) {
+      const { app_id, pkg_id } = aws;
+      let f = await fileExists(lscrcPath);
+      if (f) {
+        let lscRc = require(lscrcPath),
+          { currentEnv } = lscRc;
+        const { lightBaseURL, token } = lscRc[`${currentEnv}`];
+        await initAxiosConfig(lightBaseURL, token);
+        await dealVersionList({ app_id, pkg_id });
+      } else {
+        log("登录文件不存在，请先进行登录：lsc login");
+      }
     });
+  });
 
 // 处理离线包兼容版本相互重叠的情况
 program
-    .command("clean all")
-    .description("批量处理离线包兼容版本相互重叠的情况，谨慎使用！")
-    .action(async function () {
-        console.log("批量处理离线包兼容版本相互重叠的情况，谨慎使用！")
-        let dv = [
-            {
-                type: "input",
-                message: "请输入app_id列表，以逗号分隔：",
-                name: "app_id",
-                default:"3592,3577,3580,3562"
-            }
-        ];
-        inquirer.prompt(dv).then(async function (aws) {
-            const {app_id} = aws;
-            console.log((app_id+'').split(','));
-            let ids = (app_id+'').split(',');
-            let f = await fileExists(lscrcPath);
-            if (f) {
-                let lscRc = require(lscrcPath),
-                    { currentEnv } = lscRc;
-                const { lightBaseURL, token } = lscRc[`${currentEnv}`];
-                await initAxiosConfig(lightBaseURL, token);
-                await batchDealVersionList(ids);
-            } else {
-                console.log("登录文件不存在，请先进行登录：lsc login");
-            }
-        });
+  .command("clean all")
+  .description("批量处理离线包兼容版本相互重叠的情况，谨慎使用！")
+  .action(async function () {
+    log("批量处理离线包兼容版本相互重叠的情况，谨慎使用！");
+    let dv = [
+      {
+        type: "input",
+        message: "请输入app_id列表，以逗号分隔：",
+        name: "app_id",
+        default: "3592,3577,3580,3562",
+      },
+    ];
+    inquirer.prompt(dv).then(async function (aws) {
+      const { app_id } = aws;
+      log((app_id + "").split(","));
+      let ids = (app_id + "").split(",");
+      let f = await fileExists(lscrcPath);
+      if (f) {
+        let lscRc = require(lscrcPath),
+          { currentEnv } = lscRc;
+        const { lightBaseURL, token } = lscRc[`${currentEnv}`];
+        await initAxiosConfig(lightBaseURL, token);
+        await batchDealVersionList(ids);
+      } else {
+        log("登录文件不存在，请先进行登录：lsc login");
+      }
     });
+  });
+
+//打印当前地址
+program
+  .command("pwd")
+  .alias("dir")
+  .description("打印当前地址")
+  .action(async function () {
+    console.log(process.cwd());
+  });
+
+// 默认压缩当前dist目录下的所有文件（不包括自身生成的zip文件）压缩成一个zip文件
+//支持传入dist目录路径--dir参数指定dist目录路径
+program
+  .command("zip")
+  .description(
+    "将dist或指定目录下的所有文件（不包括自身生成的zip文件）压缩成一个zip文件",
+  )
+  .option("--dir <distDir>", "指定dist绝对路径")
+  //指定输出zip文件路径--output参数指定输出zip文件路径
+  .option("--output <outputZipFile>", "指定输出zip文件路径")
+  //指定zip文件名--zipFilename参数指定zip文件名
+  .option("--zn <zipFilename>", "指定zip文件名")
+  .action(async function (cmd) {
+    log("压缩dist目录下的所有文件（不包括自身生成的zip文件）压缩成一个zip文件");
+    try {
+      let lscConfig = require(path.join(process.cwd(), "./lsc.config.json"));
+      await createZip({
+        sourceFolder: cmd.dir || path.join(process.cwd(), lscConfig.pkg_dir),
+        outputZipFile:
+          cmd.output || path.join(process.cwd(), lscConfig.pkg_dir),
+        zipFilename: cmd.zn || lscConfig.pkg_zip_name,
+      });
+    } catch (e) {
+      throw new Error(
+        `压缩发生异常: ${e.message}，请先使用lsc config或lsc init创建`,
+      );
+    }
+  });
 
 async function writeConfig(configArgs, path = "./lsc.config.json") {
-    // 写入文件内容（如果文件不存在会创建一个文件）
-    writeFile(path, JSON.stringify(configArgs), { flag: "w" }, function (err) {
-        if (err) {
-            throw err;
-        }
-        console.log("已更新");
-    });
+  // 写入文件内容（如果文件不存在会创建一个文件）
+  writeFile(path, JSON.stringify(configArgs), { flag: "w" }, function (err) {
+    log("写入配置文件...");
+    // log(configArgs);
+    if (err) {
+      throw err;
+    }
+    log("写入配置文件成功");
+  });
 }
 
 // 查询会话的有效性
 async function validSession(lightBaseURL, token) {
+  try {
     await initAxiosConfig(lightBaseURL, token);
     let f = await checkSession(token);
-    if (!f) {
-        await console.log("\n会话已过期或者无效，请重新确认：", f, "\n");
-    }
     return f;
+  } catch (e) {
+    return false;
+  }
 }
 
 program.parse(process.argv);