lightshortcuts 1.0.8 → 1.1.0

package/lib/core/api.js

@@ -0,0 +1,1134 @@
+"use strict";
+const axios = require("axios").default;
+const qs = require("qs");
+const { createReadStream, access, statSync, constants } = require("fs");
+const FormData = require("form-data");
+const { getPkgInfo, getCookieObj, fmtTime } = require("../utils");
+
+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);
+};
+const { ApiList } = require("./apiUrl");
+
+// 存储APP的离线包
+let allOfflinePkgLists = {};
+
+const initAxiosConfig = async function (lightBaseURL, token) {
+  axios.defaults.baseURL = lightBaseURL;
+  axios.defaults.headers["cookie"] = `token=${token}`;
+  axios.defaults.headers["User-Agent"] =
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36 Edg/143.8.8.8";
+  axios.defaults.timeout = 30000;
+};
+
+const retryWrapper = async function (fn, options = {}) {
+  const { maxRetries = 3, delay = 4000, retryMessage = "请求" } = options;
+
+  let lastError;
+
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      const result = await fn();
+      return result;
+    } catch (error) {
+      lastError = error;
+      log(
+        `第 ${i + 1} 次${retryMessage}失败，${i < maxRetries - 1 ? `${delay / 1000}秒后重试...` : "已达到最大重试次数"}`,
+      );
+
+      if (i < maxRetries - 1) {
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+  }
+
+  throw lastError;
+};
+
+// 添加请求拦截器
+axios.interceptors.request.use(
+  function (config) {
+    // 在发送请求之前做些什么
+    // log(config)
+    return config;
+  },
+  function (error) {
+    // 对请求错误做些什么
+    return Promise.reject(error);
+  },
+);
+
+// 添加响应拦截器
+axios.interceptors.response.use(
+  function (response) {
+    // 2xx 范围内的状态码都会触发该函数。
+    // log(response.data);
+    return response;
+  },
+  function (error) {
+    // 超出 2xx 范围的状态码都会触发该函数。
+    return Promise.reject(error);
+  },
+);
+
+// 通用的axios配置
+const getAxiosConfig = function (config = {}) {
+  return {
+    timeout: 30000,
+    headers: {
+      "User-Agent": axios.defaults.headers["User-Agent"],
+      Connection: "keep-alive",
+      ...config.headers,
+    },
+    ...config,
+  };
+};
+
+// 通用的错误处理函数
+const handleAxiosError = function (error, errorMessage = "请求失败") {
+  log(
+    `${errorMessage}：${error.response?.data?.data?.[0]?.error_info || error.message}`,
+  );
+  return Promise.reject(error);
+};
+
+// 通用的响应处理函数
+const handleAxiosResponse = function (
+  response,
+  successCallback,
+  errorCallback,
+) {
+  const { data } = response;
+  if (data.err_no === 0) {
+    return successCallback ? successCallback(data) : data;
+  } else {
+    return errorCallback ? errorCallback(data) : data;
+  }
+};
+
+//获取图形验证码,返回base64编码和其响应头cookie里面的captcha_id
+const getCaptcha = async function () {
+  return retryWrapper(
+    async () => {
+      try {
+        // 发送请求获取验证码图片
+        const res = await axios({
+          url: ApiList.getCaptcha,
+          method: "get",
+          responseType: "arraybuffer",
+          accept: "image/*",
+          ...getAxiosConfig(),
+        });
+
+        // 处理响应数据
+        const base64 = Buffer.from(res.data).toString("base64");
+        const captchaId = getCookieObj(res.headers["set-cookie"][0]).captcha_id;
+
+        // 调用ocrCaptcha识别验证码
+        const captchaText = await ocrCaptcha(base64);
+        log("识别验证码成功:", captchaText);
+
+        // 返回结果
+        return { captchaId, captchaText };
+      } catch (error) {
+        log("获取验证码失败:", error);
+        throw error;
+      }
+    },
+    {
+      maxRetries: 3,
+      delay: 4000,
+      retryMessage: "获取验证码",
+    },
+  );
+};
+//通过传入的图像验证码图片，经过识别之后返回文字验证码
+const ocrCaptcha = async function (base64) {
+  return retryWrapper(
+    async () => {
+      try {
+        // 发送OCR识别请求
+        const res = await axios({
+          url: `https://vv5s.com:18080/predict/base64`,
+          method: "post",
+          data: {
+            data: base64,
+          },
+          ...getAxiosConfig({
+            headers: {
+              "Content-Type": "application/json",
+            },
+          }),
+        });
+
+        // 处理响应数据
+        const responseData = res?.data;
+        log(`OCR识别响应: ${JSON.stringify(responseData)}`);
+        const captcha = responseData?.result;
+
+        // 返回识别结果
+        return captcha;
+      } catch (error) {
+        log("OCR识别失败:", error);
+        throw error;
+      }
+    },
+    {
+      maxRetries: 3,
+      delay: 1000,
+      retryMessage: "OCR识别",
+    },
+  );
+};
+//表单登录接受传入登录账号密码，返回token
+const submitLogin = async function (loginData = { account: "", password: "" }) {
+  return retryWrapper(
+    async () => {
+      // 校验登录账号密码是否为空
+      if (!loginData.account || !loginData.password) {
+        throw new Error("登录账号或密码不能为空");
+      }
+
+      // 获取验证码和captcha_id
+      const { captchaId, captchaText } = await getCaptcha();
+      warn("captchaId:", { captchaId, captchaText });
+
+      try {
+        // 发送登录请求
+        const res = await axios({
+          url: ApiList.submitLogin,
+          method: "post",
+          data: qs.stringify({
+            account: loginData.account,
+            password: loginData.password,
+            captcha: captchaText,
+          }),
+          ...getAxiosConfig({
+            headers: {
+              "Content-Type":
+                "application/x-www-form-urlencoded; charset=UTF-8",
+              Cookie: `captcha_id=${captchaId}`,
+              Authorization: "Light undefined",
+              DNT: "1",
+            },
+          }),
+        });
+
+        // 处理响应数据
+        const { data } = res;
+
+        if (data.user_token) {
+          // 登录成功，返回用户数据
+          // log("登录响应:", data.user_token, data.user?.identity_name);
+          return data;
+        } else {
+          // 登录失败，抛出错误
+          throw new Error(`登录失败: ${JSON.stringify(data)}`);
+        }
+      } catch (error) {
+        log(`登录失败，原因是：${error}`);
+        throw error;
+      }
+    },
+    {
+      maxRetries: 6,
+      delay: 3000,
+      retryMessage: "登录",
+    },
+  );
+};
+
+//校验会话有效性
+const checkSession = async function (token) {
+  return retryWrapper(
+    async () => {
+      try {
+        // 发送会话检查请求
+        const res = await axios.get(ApiList.checkSession, {
+          ...getAxiosConfig(),
+        });
+
+        // 处理响应数据
+        let { data } = res;
+
+        if (data.err_no === 0) {
+          log(`欢迎${data?.data?.user?.identity_name}，会话有效。`);
+          return true;
+        } else {
+          return false;
+        }
+      } catch (error) {
+        warn(`检查会话报错！${error}`);
+        throw error;
+      }
+    },
+    {
+      maxRetries: 3,
+      delay: 4000,
+      retryMessage: "检查会话",
+    },
+  );
+};
+
+// 注销会话
+const logout = async function (token) {
+  return retryWrapper(
+    async () => {
+      try {
+        // 发送注销请求
+        const res = await axios.get(ApiList.logout, {
+          ...getAxiosConfig(),
+        });
+
+        // 处理响应数据
+        let { data } = res;
+
+        if (data.err_no === 0) {
+          return true;
+        } else {
+          return false;
+        }
+      } catch (error) {
+        warn(
+          `注销会话报错，原因是：${error.response?.data?.data?.[0]?.error_info || error.message}`,
+        );
+        throw error;
+      }
+    },
+    {
+      maxRetries: 3,
+      delay: 4000,
+      retryMessage: "注销会话",
+    },
+  );
+};
+
+// 上传文件,__filePath:绝对路径
+const fileUpload = async function (__filePath, bizType = "h5_offline_src") {
+  return retryWrapper(
+    async () => {
+      try {
+        // 检查文件是否存在
+        await new Promise((resolve, reject) => {
+          access(__filePath, constants.F_OK, (err) => {
+            if (err) {
+              log(`文件${__filePath}不存在`);
+              reject(`文件${__filePath}不存在`);
+            } else {
+              resolve();
+            }
+          });
+        });
+
+        // 创建表单数据
+        const formData = new FormData();
+        formData.append("file", createReadStream(__filePath));
+
+        // 发送上传请求
+        const res = await axios.post(
+          `${ApiList.fileUpload}?bizType=${bizType}`,
+          formData,
+          {
+            ...getAxiosConfig({
+              headers: {
+                ...formData.getHeaders(),
+              },
+            }),
+          },
+        );
+
+        log("上传文件:", res.data);
+
+        // 处理响应数据
+        let { err_no, data, err_msg } = res.data;
+
+        if (err_no == 0) {
+          return data;
+        } else {
+          throw new Error(`上传失败: ${err_msg}`);
+        }
+      } catch (error) {
+        log(`上传文件失败: ${error}`);
+        throw error;
+      }
+    },
+    {
+      maxRetries: 3,
+      delay: 4000,
+      retryMessage: "上传文件",
+    },
+  );
+};
+
+// 查询APP下的离线包列表 √
+const queryOfflinePkgList = async function (ids = ["3542", "3543"]) {
+  // 获取单个APP的离线包列表
+  const getPkgListOf = async function (appid) {
+    return retryWrapper(
+      async () => {
+        try {
+          // 发送请求获取离线包列表
+          const res = await axios.get(
+            `${ApiList.queryOfflinePkgList}?app_id=${appid}`,
+            {
+              ...getAxiosConfig(),
+            },
+          );
+
+          // 处理响应数据
+          let { err_no, err_info, data } = res.data;
+
+          if (err_no == 0) {
+            allOfflinePkgLists[appid] = data;
+          } else {
+            log(`${appid}报错：${err_info}`);
+          }
+
+          return true;
+        } catch (error) {
+          log(`${appid}采集报错：${error}`);
+          throw error;
+        }
+      },
+      {
+        maxRetries: 6,
+        delay: 4000,
+        retryMessage: `获取${appid}离线包列表`,
+      },
+    );
+  };
+
+  // 批量查询
+  try {
+    await Promise.all(ids.map((appid) => getPkgListOf(appid)));
+
+    // 返回所有离线包列表
+    return allOfflinePkgLists;
+  } catch (error) {
+    log(`批量查询离线包列表失败：${error}`);
+    throw error;
+  }
+};
+
+// 同步APP的离线包列表，如果没有创建，则进行创建,以拉平两端离线包
+async function syncPkgList(ids = [], h5app_id) {
+  try {
+    // 获取所有APP的离线包列表
+    await queryOfflinePkgList(ids);
+
+    // 分析需要创建离线包的APP列表
+    let keys = Object.keys(allOfflinePkgLists);
+    let newAppPkgList = keys.reduce(
+      (acc, cur) => {
+        let a = allOfflinePkgLists[cur];
+        let b = a.filter((val) => val.h5app_id == h5app_id);
+
+        if (b.length > 0) {
+          acc.name = b[0].name;
+        } else {
+          acc.none.push(cur);
+        }
+
+        return acc;
+      },
+      { none: [], name: "" },
+    );
+
+    // 如果有需要创建离线包的APP，并且获取到了包名，则批量创建
+    if (newAppPkgList["none"].length > 0 && newAppPkgList["name"] != "") {
+      const results = await Promise.all(
+        newAppPkgList["none"].map((appId) => {
+          return addOfflineH5pkg(appId, h5app_id, newAppPkgList["name"]);
+        }),
+      );
+
+      log("同步离线包信息：", results);
+    }
+
+    return true;
+  } catch (error) {
+    log(`同步离线包列表失败：${error}`);
+    throw error;
+  }
+}
+
+//查询版本信息√
+const queryOfflineVersionlist = async function (app_id, h5app_id) {
+  try {
+    // 获取包信息
+    let t = await getPkgInfo(allOfflinePkgLists, app_id, h5app_id);
+    let { id } = t;
+
+    // 发送请求获取版本列表
+    let qovRes = await retryWrapper(
+      async () => {
+        return await axios.get(
+          `${ApiList.queryOfflineVersionlist}?app_id=${app_id}&pkg_id=${id}&page_no=1&page_size=10`,
+          {
+            ...getAxiosConfig(),
+          },
+        );
+      },
+      {
+        maxRetries: 3,
+        delay: 4000,
+        retryMessage: "查询版本信息",
+      },
+    );
+
+    return qovRes.data;
+  } catch (error) {
+    log(`查询版本信息失败：${error}`);
+    throw error;
+  }
+};
+
+// 如果未创建离线包，则创建之√
+const addOfflineH5pkg = async function (app_id, h5app_id, name) {
+  try {
+    // 检查是否已存在相同h5app_id的离线包
+    let copRes = await retryWrapper(
+      async () => {
+        return await axios.get(
+          `${ApiList.checkOfflinePkgid}?app_id=${app_id}&h5app_id=${h5app_id}`,
+          {
+            ...getAxiosConfig(),
+          },
+        );
+      },
+      {
+        maxRetries: 3,
+        delay: 4000,
+        retryMessage: "检查离线包ID",
+      },
+    );
+    let copFlag = copRes.data.data;
+
+    // 检查是否已存在相同名称的离线包
+    let conRes = await retryWrapper(
+      async () => {
+        return await axios.get(
+          `${ApiList.checkOfflinePkgname}?app_id=${app_id}&name=${encodeURI(name)}`,
+          {
+            ...getAxiosConfig(),
+          },
+        );
+      },
+      {
+        maxRetries: 3,
+        delay: 4000,
+        retryMessage: "检查离线包名称",
+      },
+    );
+    let conFlag = conRes.data.data;
+
+    // 如果已存在，则直接返回
+    if (copFlag || conFlag) {
+      log(`离线包已存在：${h5app_id}-${name}`);
+      return false;
+    } else {
+      // 创建新的离线包
+      let aofRes = await retryWrapper(
+        async () => {
+          return await axios({
+            method: "post",
+            url: ApiList.addOfflineH5pkg,
+            ...getAxiosConfig({
+              data: qs.stringify({
+                app_id,
+                h5app_id,
+                name,
+                pkg_type: 1,
+              }),
+            }),
+          });
+        },
+        {
+          maxRetries: 3,
+          delay: 4000,
+          retryMessage: "添加离线包",
+        },
+      );
+
+      let { err_no, data } = aofRes.data;
+      log(`添加离线包：${h5app_id}-${name}`, aofRes.data);
+
+      if (err_no == 0 && data == 1) {
+        // 创建成功，更新离线包列表
+        await queryOfflinePkgList([app_id]);
+        return true;
+      } else {
+        return false;
+      }
+    }
+  } catch (error) {
+    log(`添加离线包失败：${error}`);
+    throw error;
+  }
+};
+
+//创建离线发布版本 √
+const addOfflineVersion = async function (args) {
+  return retryWrapper(
+    async () => {
+      try {
+        // 发送创建版本请求
+        const res = await axios({
+          method: "post",
+          url: ApiList.addOfflineVersion,
+          ...getAxiosConfig({
+            data: qs.stringify(args),
+          }),
+        });
+
+        // 处理响应数据
+        // {"err_no":0,"err_info":"成功执行","data":1}
+        log("创建离线发布版本:", res.data);
+        const { err_no } = res.data;
+
+        if (err_no == 0) {
+          return true;
+        } else {
+          return false;
+        }
+      } catch (error) {
+        log(`创建离线发布版本报错:${error}`);
+        throw error;
+      }
+    },
+    {
+      maxRetries: 3,
+      delay: 3000,
+      retryMessage: "创建离线发布版本",
+    },
+  );
+};
+
+// 添加发布任务 √
+const addOfflineTask = async function (args) {
+  return retryWrapper(
+    async () => {
+      try {
+        // 发送添加任务请求
+        const res = await axios({
+          method: "post",
+          url: ApiList.addOfflineTask,
+          ...getAxiosConfig({
+            data: qs.stringify(args),
+          }),
+        });
+
+        // 处理响应数据
+        // {"err_no":0,"err_info":"成功执行","data":24303}
+        log("添加发布任务:", res.data);
+        const { err_no } = res.data;
+
+        if (err_no == 0) {
+          return true;
+        } else {
+          return false;
+        }
+      } catch (error) {
+        log(`添加发布任务报错:${error}`);
+        throw error;
+      }
+    },
+    {
+      maxRetries: 3,
+      delay: 3000,
+      retryMessage: "添加发布任务",
+    },
+  );
+};
+
+//查询某个版本的发布任务 √
+const queryOfflineTask = async function (args) {
+  return retryWrapper(
+    async () => {
+      try {
+        // 发送查询任务请求
+        const res = await axios.get(
+          `${ApiList.queryOfflineTask}?${qs.stringify(
+            args,
+          )}&page_no=1&page_size=5`,
+          {
+            ...getAxiosConfig(),
+          },
+        );
+
+        // 处理响应数据
+        const { err_no, data } = res.data;
+
+        if (err_no == 0) {
+          return data.list;
+        } else {
+          return [];
+        }
+      } catch (error) {
+        log(`获取指定版本下的发布任务列表报错:${error}`);
+        throw error;
+      }
+    },
+    {
+      maxRetries: 3,
+      delay: 5000,
+      retryMessage: "查询发布任务",
+    },
+  );
+};
+
+//更新发布任务状态√
+const updateOfflineTask = async function (uotArgs = {}) {
+  return retryWrapper(
+    async () => {
+      try {
+        // 发送更新任务状态请求
+        const res = await axios({
+          method: "post",
+          url: ApiList.updateOfflineTask,
+          ...getAxiosConfig({
+            data: qs.stringify(uotArgs),
+          }),
+        });
+
+        // 处理响应数据
+        const { err_no } = res.data;
+
+        if (err_no == 0) {
+          return true;
+        } else {
+          return false;
+        }
+      } catch (error) {
+        log(`更新发布任务状态报错:${error}`);
+        throw error;
+      }
+    },
+    {
+      maxRetries: 3,
+      delay: 4000,
+      retryMessage: "更新发布任务状态",
+    },
+  );
+};
+
+//查询执行发布任务状态成功与否接口，返回true或false
+const queryOfflineVersionDetail = async function ({ id, app_id }) {
+  try {
+    const res = await retryWrapper(
+      async () => {
+        return await axios.get(
+          `${ApiList.queryOfflineVersionDetail}?id=${id}&app_id=${app_id}`,
+          {
+            ...getAxiosConfig(),
+          },
+        );
+      },
+      {
+        maxRetries: 5,
+        delay: 3000,
+        retryMessage: "查询执行发布任务状态",
+      },
+    );
+
+    // 处理响应数据
+    const { err_no, data } = res.data;
+
+    if (err_no == 0) {
+      const { status } = data;
+      if (status == 4) {
+        // 状态4 表示任务执行成功
+        return true;
+      } else {
+        // 其他状态都认为是失败，则继续重试查询，直到状态为4或重试次数耗尽
+        log(`查询执行发布任务状态详情是:${status}`);
+        throw new Error(`查询执行发布任务状态详情是:${status}`);
+      }
+    } else {
+      return false;
+    }
+  } catch (error) {
+    log(`查询执行发布任务状态报错:${error}`);
+    throw error;
+  }
+};
+
+// 处理版本范围相互覆盖的离线包
+const dealVersionList = async function ({ app_id, pkg_id, status = 2, name }) {
+  if (pkg_id == null) {
+    return false;
+  }
+
+  try {
+    // 查询版本列表
+    let qovRes = await retryWrapper(
+      async () => {
+        return await axios.get(
+          `${ApiList.queryOfflineVersionlist}?app_id=${app_id}&pkg_id=${pkg_id}&page_no=1&page_size=30`,
+          {
+            ...getAxiosConfig(),
+          },
+        );
+      },
+      {
+        maxRetries: 3,
+        delay: 4000,
+        retryMessage: "查询版本列表",
+      },
+    );
+
+    let { list } = qovRes.data.data;
+    let versionList = [];
+
+    // 获取要下架的版本号ID
+    let toDoId = list.reduce((acc, cur) => {
+      let {
+        id,
+        ios_version_scope, //iOS端离线包兼容版本
+        android_version_scope, //Android端离线包兼容版本
+        harmony_version_scope, //Harmony端离线包兼容版本
+        status,
+        version,
+        release_type,
+      } = cur;
+
+      if (status == 1 && release_type == 0) {
+        const versionScope =
+          ios_version_scope || android_version_scope || harmony_version_scope;
+
+        if (versionList.includes(versionScope)) {
+          let o = acc[`${versionScope}`];
+          acc[`${versionScope}`] = [...o, { id, version }];
+        } else {
+          acc[`${versionScope}`] = [];
+          versionList.push(versionScope);
+        }
+      }
+
+      return acc;
+    }, {});
+
+    // 处理需要下架的版本
+    for (const key in toDoId) {
+      if (Object.hasOwnProperty.call(toDoId, key)) {
+        const vl = toDoId[key];
+
+        if (vl.length > 0) {
+          for (let index = 0; index < vl.length; index++) {
+            const val = vl[index];
+
+            try {
+              let t = await todoVersion(app_id, val.id);
+              let sm = { 0: "发布", 1: "暂停", 2: "下架" },
+                tips = sm[`${status}`];
+
+              log(
+                `${app_id}${name ? name : ""}版本范围：${key}，版本号：${
+                  val.version
+                },版本ID：${val.id},处理情况：${tips}${t ? "成功" : "失败"}`,
+              );
+            } catch (error) {
+              log(`处理版本${val.id}失败: ${error}`);
+            }
+          }
+        }
+      }
+    }
+  } catch (error) {
+    log(`处理版本列表失败: ${error}`);
+    return false;
+  }
+
+  // 内部函数：处理单个版本的下架操作
+  async function todoVersion(app_id, version_id) {
+    try {
+      // 查询版本对应的发布任务
+      const qot = await queryOfflineTask({ app_id, version_id });
+
+      // 筛选状态为0的任务ID
+      let tmp = qot.reduce((acc, cur) => {
+        if (cur.status == 0) {
+          acc = [...acc, cur.id];
+        }
+        return acc;
+      }, []);
+
+      let taskId = tmp[0];
+
+      // 执行下架操作
+      return await updateOfflineTask({
+        id: taskId,
+        status: 2,
+        app_id,
+      });
+    } catch (error) {
+      log(`处理单个版本失败: ${error}`);
+      return false;
+    }
+  }
+};
+
+// 批处理版本范围相互覆盖的离线包
+const batchDealVersionList = async function (ids, h5app_id, status = 2) {
+  try {
+    // 获取所有APP的离线包列表
+    const pkgLists = await queryOfflinePkgList(ids);
+
+    // 遍历每个APP的离线包列表
+    for (const key in pkgLists) {
+      if (Object.hasOwnProperty.call(pkgLists, key)) {
+        const ele = pkgLists[key];
+
+        // 遍历每个离线包
+        for (let index = 0; index < ele.length; index++) {
+          const f = ele[index];
+          let { app_id, pkg_id, name } = f;
+
+          // 如果有pkg_id，则处理版本列表
+          if (pkg_id != null) {
+            await dealVersionList({ app_id, pkg_id, status: 2, name });
+          }
+        }
+      }
+    }
+  } catch (error) {
+    log(`批量处理版本列表失败: ${error}`);
+  }
+};
+
+const sendWechatWebhook = async function (url, content) {
+  return retryWrapper(
+    async () => {
+      try {
+        // 发送企业微信消息
+        const res = await axios({
+          url: url,
+          method: "post",
+          data: {
+            msgtype: "text",
+            text: {
+              content: content,
+              mentioned_mobile_list: ["15019253060"],
+            },
+          },
+          ...getAxiosConfig({
+            headers: {
+              "Content-Type": "application/json",
+            },
+          }),
+        });
+
+        // 处理响应数据
+        const { data } = res;
+        log("企业微信消息发送响应:", data);
+
+        if (data.errcode === 0) {
+          return data;
+        } else {
+          throw new Error(`企业微信消息发送失败: ${data.errmsg}`);
+        }
+      } catch (error) {
+        log("企业微信消息发送失败:", error);
+        throw error;
+      }
+    },
+    {
+      maxRetries: 3,
+      delay: 4000,
+      retryMessage: "发送企业微信消息",
+    },
+  );
+};
+
+// 添加H5web包
+const addH5webPkg = async function (pkgData = {}) {
+  return retryWrapper(
+    async () => {
+      try {
+        // 发送添加H5web包请求
+        const res = await axios({
+          method: "post",
+          url: ApiList.addH5webPkg,
+          ...getAxiosConfig({
+            data: qs.stringify(pkgData),
+          }),
+        });
+
+        // 处理响应数据
+        log("添加H5web包:", res.data);
+        const { err_no, err_info, data } = res.data;
+
+        if (err_no == 0) {
+          return data;
+        } else {
+          throw new Error(`添加H5web包失败: ${err_info}`);
+        }
+      } catch (error) {
+        log(`添加H5web包报错:${error}`);
+        throw error;
+      }
+    },
+    {
+      maxRetries: 3,
+      delay: 3000,
+      retryMessage: "添加H5web包",
+    },
+  );
+};
+
+//以快捷发布方式发布H5应用包到对应产品下
+const releaseMuchVersion = async function (
+  comp_id,
+  comp_pkg_id,
+  version_desc = "此版本为快捷发布",
+) {
+  return retryWrapper(
+    async () => {
+      try {
+        // 准备请求数据
+        const reqData = {
+          comp_id,
+          comp_pkg_id,
+          version_desc,
+        };
+
+        // 发送发布H5web版本请求
+        const res = await axios({
+          method: "post",
+          url: ApiList.releaseMuchVersion,
+          ...getAxiosConfig({
+            data: qs.stringify(reqData),
+          }),
+        });
+
+        // 处理响应数据
+        // log("发布H5web版本:", res.data);
+        const { err_no, err_info, data } = res.data;
+
+        if (err_no == 0) {
+          log("发布H5web版本:", err_info);
+          return data;
+        } else {
+          throw new Error(`发布H5web版本: ${err_info}`);
+        }
+      } catch (error) {
+        log(`发布H5web版本报错:${error}`);
+        throw error;
+      }
+    },
+    {
+      maxRetries: 3,
+      delay: 3000,
+      retryMessage: "发布H5web版本",
+    },
+  );
+};
+//查询H5应用ID列表接口
+const queryCompList = async function (params = {}) {
+  try {
+    const { is_online = 1, page_size = 1000, page_no = 1, group = '', sort_prop = 'create_time', sort_order = 1 } = params;
+    
+    const res = await retryWrapper(
+      async () => {
+        return await axios.get(
+          `${ApiList.queryCompList}?is_online=${is_online}&page_size=${page_size}&page_no=${page_no}&group=${encodeURIComponent(group)}&sort_prop=${sort_prop}&sort_order=${sort_order}`,
+          {
+            ...getAxiosConfig(),
+          },
+        );
+      },
+      {
+        maxRetries: 3,
+        delay: 4000,
+        retryMessage: "查询H5应用ID列表",
+      },
+    );
+
+    // 处理响应数据
+    const { err_no, data } = res.data;
+
+    if (err_no == 0) {
+      return data.data;
+    } else {
+      return [];
+    }
+  } catch (error) {
+    log(`查询H5应用ID列表报错:${error}`);
+    throw error;
+  }
+};
+
+//获取APP列表接口
+const queryApp = async function (params = {}) {
+  try {
+    const { keywords = '' } = params;
+    
+    const res = await retryWrapper(
+      async () => {
+        return await axios.post(
+          ApiList.queryApp,
+          qs.stringify({ keywords }),
+          {
+            ...getAxiosConfig(),
+          },
+        );
+      },
+      {
+        maxRetries: 6,
+        delay: 3000,
+        retryMessage: "获取APP列表",
+      },
+    );
+    // 处理响应数据
+    const { err_no, data } = res.data;
+
+    if (err_no == 0) {
+      return data.app || [];
+    } else {
+      return [];
+    }
+  } catch (error) {
+    log(`获取APP列表报错:${error}`);
+    throw error;
+  }
+};
+
+module.exports = {
+  submitLogin,
+  ocrCaptcha,
+  getCaptcha,
+  allOfflinePkgLists,
+  logout,
+  checkSession,
+  fileUpload,
+  queryOfflinePkgList,
+  getPkgInfo,
+  queryOfflineVersionlist,
+  addOfflineH5pkg,
+  addOfflineVersion,
+  addOfflineTask,
+  queryOfflineTask,
+  updateOfflineTask,
+  syncPkgList,
+  initAxiosConfig,
+  dealVersionList,
+  batchDealVersionList,
+  sendWechatWebhook,
+  addH5webPkg,
+  releaseMuchVersion,
+  queryOfflineVersionDetail,
+  queryCompList,
+  queryApp,
+};