neo-cmp-cli 1.8.6-beta.2 → 1.8.6-beta.5

package/dist/neo/neoService.js

@@ -0,0 +1,1246 @@
+'use strict';
+
+var require$$0$1 = require('axios');
+var require$$1$1 = require('form-data');
+var require$$0$2 = require('node:fs');
+var require$$1 = require('node:path');
+var require$$3 = require('ora');
+var require$$2 = require('lodash');
+var require$$0 = require('akfun');
+var neoLogin = require('../_virtual/neoLogin.js');
+var updatePublishLog$1 = require('../utils/projectUtils/updatePublishLog.js');
+var common = require('../utils/common.js');
+var _extends = require('../node_modules/@babel/runtime/helpers/esm/extends.js');
+var asyncToGenerator = require('../node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js');
+var index = require('../_virtual/index.js');
+
+var axios = require$$0$1;
+var FormData = require$$1$1;
+var fs = require$$0$2;
+var path = require$$1;
+var ora = require$$3;
+var _ = require$$2;
+var _require = require$$0,
+  resolve = _require.resolve;
+var NeoLoginService = neoLogin;
+var updatePublishLog = updatePublishLog$1.__require();
+var _require2 = common.__require(),
+  getFramework = _require2.getFramework,
+  errorLog = _require2.errorLog,
+  successLog = _require2.successLog;
+
+// NeoCRM 平台默认 API 配置
+var NeoCrmAPI = {
+  neoBaseURL: 'https://crm.xiaoshouyi.com',
+  // 平台根地址
+  loginAPI: 'https://login-cd.xiaoshouyi.com/auc/oauth2/auth',
+  // code 获取接口地址
+  tokenAPI: 'https://login.xiaoshouyi.com/auc/oauth2/token',
+  // Token 获取接口地址
+  delete: '/rest/metadata/v3.0/ui/customComponents',
+  saveAPI: '/rest/metadata/v3.0/ui/customComponents/actions/saveOrUpdateComponent',
+  // 创建或者保存接口地址
+  queryAll: '/rest/metadata/v3.0/ui/components/filter?custom=true',
+  // 不带分页
+  getCodeLibAPI: function getCodeLibAPI(cmpType) {
+    return "/rest/metadata/v3.0/ui/customComponents/" + cmpType + "/codeLib";
+  },
+  // 组件源码下载
+
+  uploadAPI: '/rest/metadata/v3.0/ui/customComponents/actions/upload',
+  // 文件上传接口地址（已废弃）
+  query: '/rest/metadata/v3.0/ui/customComponents/actions/queryCustomComponents' // 带分页（暂未使用）
+  // queryAll_v1: '/rest/metadata/v3.0/ui/customComponents/actions/queryAllCustomComponents', // 不带分页（已废弃）
+};
+var cmpFields = ['cmpType', 'label', 'componentCategory', 'description', 'framework', 'icon', 'iconUrl', 'orderNo', 'version', 'propsSchema', 'defaultProps', 'previewProps', 'events', 'functions', 'asset', 'modelAsset', 'cssAsset', 'codeLib'];
+
+/**
+ * Neo 平台服务类
+ * 提供 token 管理、文件上传、组件更新等功能
+ */
+var NeoService = /*#__PURE__*/function () {
+  /**
+   * 初始化 Neo 服务
+   * @param {object} config 配置信息
+   * @param {string} config.authType 授权类型，可选值：oauth2（默认）、password
+   * @param {string} config.neoBaseURL Neo 平台根地址
+   * @param {string} config.tokenAPI Token 获取接口地址
+   * @param {string} config.loginURL OAuth2 登录授权 URL（OAuth2 模式需要）
+   * @param {object} config.auth 授权信息
+   * @param {string} config.auth.client_id 客户端 ID
+   * @param {string} config.auth.client_secret 客户端密钥
+   * @param {string} config.auth.username 用户名（password 模式需要）
+   * @param {string} config.auth.password 密码（password 模式需要）
+   */
+  function NeoService(config) {
+    if (config === void 0) {
+      config = {};
+    }
+    var _ref = config || {},
+      assetsRoot = _ref.assetsRoot,
+      neoBaseURL = _ref.neoBaseURL,
+      tokenAPI = _ref.tokenAPI,
+      loginURL = _ref.loginURL,
+      auth = _ref.auth,
+      authType = _ref.authType;
+
+    // 设置授权类型，默认为 oauth2
+    this.authType = authType || 'oauth2';
+    if (this.authType === 'password' && !auth) {
+      errorLog('密码授权模式时，neo.config.js / neoConfig / auth 配置不能为空');
+      process.exit(1);
+    }
+
+    // 根据授权类型验证必需的配置项
+    if (this.authType === 'password') {
+      if (!auth.client_id || !auth.client_secret || !auth.username || !auth.password) {
+        errorLog('neo.config.js / neoConfig / auth 配置不完整（password 模式），需要包含 client_id、client_secret、username、password');
+        process.exit(1);
+      }
+    } else if (this.authType === 'oauth2') {
+      if (!loginURL || !tokenAPI) {
+        errorLog('neo.config.js / neoConfig 配置不完整（oauth2 模式），需要包含 loginURL、tokenAPI 配置。');
+        process.exit(1);
+      }
+    } else {
+      errorLog("\u4E0D\u652F\u6301\u7684\u6388\u6743\u7C7B\u578B: " + this.authType + "\uFF0C\u53EF\u9009\u503C\uFF1Aoauth2\u3001password");
+      process.exit(1);
+    }
+    this.assetsRoot = assetsRoot || resolve('dist');
+    this.neoBaseURL = neoBaseURL || NeoCrmAPI.neoBaseURL;
+    this.tokenAPI = tokenAPI || NeoCrmAPI.tokenAPI;
+    this.loginURL = loginURL || NeoCrmAPI.loginAPI;
+    this.auth = auth;
+    this.cmpList = [];
+    this.cmpInfoMap = {};
+
+    // Token 缓存
+    this.tokenCache = {
+      token: null,
+      expiresAt: null
+    };
+  }
+
+  /**
+   * 构建完整的 API URL
+   * @param {string} url 相对或绝对 URL
+   * @returns {string} 完整的 URL
+   */
+  var _proto = NeoService.prototype;
+  _proto.buildFullUrl = function buildFullUrl(url) {
+    if (url.startsWith('http://') || url.startsWith('https://')) {
+      return url;
+    }
+    return "" + this.neoBaseURL + url;
+  }
+
+  // 获取文件上传接口地址
+  ;
+  _proto.uploadAPI = function uploadAPI() {
+    return this.buildFullUrl(NeoCrmAPI.uploadAPI);
+  }
+
+  // 获取组件信息保存接口地址
+  ;
+  _proto.saveAPI = function saveAPI() {
+    return this.buildFullUrl(NeoCrmAPI.saveAPI);
+  }
+
+  /**
+   * 检查 token 是否过期
+   * @returns {boolean} true 表示已过期，false 表示未过期
+   */;
+  _proto.isTokenExpired = function isTokenExpired() {
+    if (!this.tokenCache.token || !this.tokenCache.expiresAt) {
+      return true;
+    }
+    // 提前 60 秒判断为过期，避免边缘情况
+    return Date.now() >= this.tokenCache.expiresAt;
+  }
+
+  /**
+   * 获取 token（含授权信息、租户信息）
+   * 根据 authType 自动选择授权模式：oauth2 或 password
+   * @returns {Promise<string>} token
+   */;
+  _proto.getToken =
+  /*#__PURE__*/
+  function () {
+    var _getToken = asyncToGenerator(/*#__PURE__*/index.mark(function _callee() {
+      return index.wrap(function (_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            if (this.isTokenExpired()) {
+              _context.next = 1;
+              break;
+            }
+            return _context.abrupt("return", this.tokenCache.token);
+          case 1:
+            if (!(this.authType === 'oauth2')) {
+              _context.next = 3;
+              break;
+            }
+            _context.next = 2;
+            return this.getTokenByOAuth2();
+          case 2:
+            return _context.abrupt("return", _context.sent);
+          case 3:
+            _context.next = 4;
+            return this.getTokenByPassword();
+          case 4:
+            return _context.abrupt("return", _context.sent);
+          case 5:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, this);
+    }));
+    function getToken() {
+      return _getToken.apply(this, arguments);
+    }
+    return getToken;
+  }()
+  /**
+   * 使用密码模式获取 token
+   * @returns {Promise<string>} token
+   */
+  ;
+  _proto.getTokenByPassword =
+  /*#__PURE__*/
+  function () {
+    var _getTokenByPassword = asyncToGenerator(/*#__PURE__*/index.mark(function _callee2() {
+      var spinner, formData, tokenUrl, response, _ref2, access_token, expires_in, expiresIn, _t;
+      return index.wrap(function (_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            spinner = ora('获取 token（密码模式）...').start(); // 检查缓存是否有效
+            if (this.isTokenExpired()) {
+              _context2.next = 1;
+              break;
+            }
+            successLog('使用缓存的 token。', spinner);
+            return _context2.abrupt("return", this.tokenCache.token);
+          case 1:
+            // 构建表单数据格式的请求参数
+            formData = new URLSearchParams();
+            formData.append('grant_type', 'password');
+            formData.append('client_id', this.auth.client_id);
+            formData.append('client_secret', this.auth.client_secret);
+            formData.append('username', this.auth.username);
+            formData.append('password', this.auth.password);
+            tokenUrl = this.buildFullUrl(this.tokenAPI);
+            _context2.prev = 2;
+            _context2.next = 3;
+            return axios.post(tokenUrl, formData.toString(), {
+              headers: {
+                'Content-Type': 'application/x-www-form-urlencoded'
+              }
+            });
+          case 3:
+            response = _context2.sent;
+            _ref2 = response.data || {}, access_token = _ref2.access_token, expires_in = _ref2.expires_in;
+            if (!access_token) {
+              errorLog('获取 token 失败（授权配置错误）：响应中未包含 access_token，' + JSON.stringify(response.data), spinner);
+              process.exit(1);
+            }
+
+            // 缓存 token（提前 60 秒过期，避免边缘情况）
+            expiresIn = parseInt(expires_in) || 3600; // 默认 1 小时
+            this.tokenCache = {
+              token: access_token,
+              expiresAt: Date.now() + (expiresIn - 60) * 1000
+            };
+            spinner.clear();
+            spinner.stop();
+            return _context2.abrupt("return", access_token);
+          case 4:
+            _context2.prev = 4;
+            _t = _context2["catch"](2);
+            errorLog('获取 token 失败', spinner);
+            errorLog("\n\u83B7\u53D6 token \u5931\u8D25: " + _t.message);
+            errorLog("\ntoken \u6388\u6743\u5730\u5740: " + tokenUrl);
+            errorLog("\ntoken \u8BF7\u6C42\u53C2\u6570: " + formData);
+            if (_t.response) {
+              errorLog("\u54CD\u5E94\u6570\u636E: " + JSON.stringify(_t.response.data));
+            }
+            process.exit(1);
+          case 5:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2, this, [[2, 4]]);
+    }));
+    function getTokenByPassword() {
+      return _getTokenByPassword.apply(this, arguments);
+    }
+    return getTokenByPassword;
+  }()
+  /**
+   * 获取 OAuth2 授权码模式的 token
+   * @returns {Promise<string>} token
+   */
+  ;
+  _proto.getTokenByOAuth2 =
+  /*#__PURE__*/
+  function () {
+    var _getTokenByOAuth = asyncToGenerator(/*#__PURE__*/index.mark(function _callee3() {
+      var spinner, oauth2Config, loginService, accessToken, _t2;
+      return index.wrap(function (_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            spinner = ora('获取 token（OAuth2 模式）...').start();
+            _context3.prev = 1;
+            // 构建 OAuth2 配置
+            oauth2Config = {
+              loginURL: this.loginURL,
+              tokenAPI: this.tokenAPI
+            };
+            loginService = new NeoLoginService(oauth2Config);
+            _context3.next = 2;
+            return loginService.getAccessToken();
+          case 2:
+            accessToken = _context3.sent;
+            // 缓存 token（OAuth2 模式下的 token 有效期由 NeoLoginService 管理）
+            // 这里我们设置一个较长的过期时间，实际过期检查由 NeoLoginService 内部处理
+            this.tokenCache = {
+              token: accessToken,
+              expiresAt: Date.now() + 7200 * 1000 // 默认 2 小时，实际由 NeoLoginService 管理
+            };
+            spinner.clear();
+            spinner.stop();
+            return _context3.abrupt("return", accessToken);
+          case 3:
+            _context3.prev = 3;
+            _t2 = _context3["catch"](1);
+            errorLog('获取 token 失败（OAuth2 模式）', spinner);
+            errorLog("\n\u83B7\u53D6 token \u5931\u8D25: " + _t2.message);
+            if (_t2.response) {
+              errorLog("\u54CD\u5E94\u6570\u636E: " + JSON.stringify(_t2.response.data));
+            }
+            process.exit(1);
+          case 4:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3, this, [[1, 3]]);
+    }));
+    function getTokenByOAuth2() {
+      return _getTokenByOAuth.apply(this, arguments);
+    }
+    return getTokenByOAuth2;
+  }()
+  /**
+   * 刷新 token
+   * @returns {Promise<string>} 新的 token
+   */
+  ;
+  _proto.refreshToken =
+  /*#__PURE__*/
+  function () {
+    var _refreshToken = asyncToGenerator(/*#__PURE__*/index.mark(function _callee4() {
+      return index.wrap(function (_context4) {
+        while (1) switch (_context4.prev = _context4.next) {
+          case 0:
+            // 清除缓存，强制获取新 token
+            this.tokenCache = {
+              token: null,
+              expiresAt: null
+            };
+            _context4.next = 1;
+            return this.getToken();
+          case 1:
+            return _context4.abrupt("return", _context4.sent);
+          case 2:
+          case "end":
+            return _context4.stop();
+        }
+      }, _callee4, this);
+    }));
+    function refreshToken() {
+      return _refreshToken.apply(this, arguments);
+    }
+    return refreshToken;
+  }()
+  /**
+   * 确保 token 有效，如果过期则自动刷新
+   * @returns {Promise<string>} 有效的 token
+   */
+  ;
+  _proto.ensureValidToken =
+  /*#__PURE__*/
+  function () {
+    var _ensureValidToken = asyncToGenerator(/*#__PURE__*/index.mark(function _callee5() {
+      var spinner, token, _t3;
+      return index.wrap(function (_context5) {
+        while (1) switch (_context5.prev = _context5.next) {
+          case 0:
+            if (this.tokenCache.token) {
+              _context5.next = 2;
+              break;
+            }
+            _context5.next = 1;
+            return this.getToken();
+          case 1:
+            return _context5.abrupt("return", _context5.sent);
+          case 2:
+            if (!this.isTokenExpired()) {
+              _context5.next = 6;
+              break;
+            }
+            spinner = ora('token 已过期，正在刷新...').start();
+            _context5.prev = 3;
+            _context5.next = 4;
+            return this.refreshToken();
+          case 4:
+            token = _context5.sent;
+            successLog('token 刷新成功。', spinner);
+            return _context5.abrupt("return", token);
+          case 5:
+            _context5.prev = 5;
+            _t3 = _context5["catch"](3);
+            errorLog('token 刷新失败。', spinner);
+            throw _t3;
+          case 6:
+            return _context5.abrupt("return", this.tokenCache.token);
+          case 7:
+          case "end":
+            return _context5.stop();
+        }
+      }, _callee5, this, [[3, 5]]);
+    }));
+    function ensureValidToken() {
+      return _ensureValidToken.apply(this, arguments);
+    }
+    return ensureValidToken;
+  }()
+  /**
+   * 上传文件到 Neo 平台（已废弃）
+   * 备注：已废弃，改为 保存时直接上传组件资源文件
+   * @param {string} filePath 文件路径
+   * @param {object} options 可选配置
+   * @param {string} options.fieldName 表单字段名，默认为 'customComponentCode'
+   * @param {number} options.maxSize 最大文件大小（字节），默认 50MB
+   * @param {number} options.timeout 超时时间（毫秒），默认 60000
+   * @returns {Promise<string>} CDN 地址或文件 URL
+   */
+  ;
+  _proto.uploadFile =
+  /*#__PURE__*/
+  function () {
+    var _uploadFile = asyncToGenerator(/*#__PURE__*/index.mark(function _callee6(filePath, options) {
+      var token, fileStat, maxSize, sizeMB, maxSizeMB, fileName, fileSizeKB, spinner, formData, fieldName, fileContent, fullUploadAPI, timeout, requestConfig, response, resultData, responseData, errorMsg, fileUrl, _error$config, status, statusText, _responseData, requestUrl, _t4;
+      return index.wrap(function (_context6) {
+        while (1) switch (_context6.prev = _context6.next) {
+          case 0:
+            if (options === void 0) {
+              options = {};
+            }
+            _context6.next = 1;
+            return this.ensureValidToken();
+          case 1:
+            token = _context6.sent;
+            if (!(!filePath || typeof filePath !== 'string')) {
+              _context6.next = 2;
+              break;
+            }
+            throw new Error("\u6587\u4EF6\u8DEF\u5F84\u65E0\u6548: " + filePath);
+          case 2:
+            if (fs.existsSync(filePath)) {
+              _context6.next = 3;
+              break;
+            }
+            throw new Error("\u6587\u4EF6\u4E0D\u5B58\u5728: " + filePath);
+          case 3:
+            // 检查文件状态
+            fileStat = fs.statSync(filePath);
+            if (fileStat.isFile()) {
+              _context6.next = 4;
+              break;
+            }
+            throw new Error("\u8DEF\u5F84\u4E0D\u662F\u6587\u4EF6: " + filePath);
+          case 4:
+            // 检查文件大小
+            maxSize = options.maxSize || 5 * 1024 * 1024; // 默认 5MB
+            if (!(fileStat.size > maxSize)) {
+              _context6.next = 5;
+              break;
+            }
+            sizeMB = (fileStat.size / 1024 / 1024).toFixed(2);
+            maxSizeMB = (maxSize / 1024 / 1024).toFixed(2);
+            throw new Error("\u6587\u4EF6\u5927\u5C0F\u8D85\u8FC7\u9650\u5236: " + sizeMB + "MB > " + maxSizeMB + "MB");
+          case 5:
+            if (!(fileStat.size === 0)) {
+              _context6.next = 6;
+              break;
+            }
+            throw new Error("\u6587\u4EF6\u4E3A\u7A7A: " + filePath);
+          case 6:
+            fileName = path.basename(filePath);
+            fileSizeKB = (fileStat.size / 1024).toFixed(2);
+            spinner = ora("\u6B63\u5728\u4E0A\u4F20\u6587\u4EF6: " + fileName + " (" + fileSizeKB + "KB)...").start();
+            _context6.prev = 7;
+            // 创建 FormData
+            formData = new FormData();
+            fieldName = options.fieldName || 'customComponentCode'; // 使用文件流而不是读取整个文件到内存（对大文件更友好）
+            fileContent = fs.createReadStream(filePath); // 追加文件到 FormData，第三个参数指定文件名
+            formData.append(fieldName, fileContent, fileName);
+
+            // 构建完整的上传 API 地址
+            fullUploadAPI = this.uploadAPI(); // 配置请求选项
+            timeout = options.timeout || 60000; // 默认 60 秒
+            requestConfig = {
+              headers: _extends({
+                Authorization: "Bearer " + token,
+                'xsy-inner-source': 'bff'
+              }, formData.getHeaders()),
+              timeout: timeout,
+              // 确保 axios 正确处理大文件和流
+              maxContentLength: Infinity,
+              // 不限制响应内容长度
+              maxBodyLength: Infinity // 不限制请求体长度（适用于文件上传）
+            }; // 发送上传请求
+            _context6.next = 8;
+            return axios.post(fullUploadAPI, formData, requestConfig);
+          case 8:
+            response = _context6.sent;
+            responseData = response.data; // 检查响应状态码
+            if (!(response.status !== 200 && response.status !== 201)) {
+              _context6.next = 9;
+              break;
+            }
+            throw new Error("\u4E0A\u4F20\u5931\u8D25: HTTP " + response.status);
+          case 9:
+            if (!(typeof responseData === 'string')) {
+              _context6.next = 10;
+              break;
+            }
+            // 如果响应是字符串，直接使用
+            resultData = responseData.trim();
+            _context6.next = 13;
+            break;
+          case 10:
+            if (!(responseData && typeof responseData === 'object')) {
+              _context6.next = 12;
+              break;
+            }
+            if (!(responseData.code !== undefined && responseData.code !== 200 && responseData.code !== 0)) {
+              _context6.next = 11;
+              break;
+            }
+            errorMsg = responseData.message || responseData.msg || '未知错误';
+            throw new Error("\u4E0A\u4F20\u5931\u8D25: " + errorMsg + " (code: " + responseData.code + ")");
+          case 11:
+            // 提取数据
+            if (responseData.data !== undefined) {
+              resultData = responseData.data;
+            } else if (responseData.url !== undefined) {
+              resultData = responseData.url;
+            } else if (responseData.fileUrl !== undefined) {
+              resultData = responseData.fileUrl;
+            } else {
+              resultData = responseData;
+            }
+            _context6.next = 13;
+            break;
+          case 12:
+            throw new Error("\u54CD\u5E94\u6570\u636E\u683C\u5F0F\u4E0D\u6B63\u786E: " + typeof responseData);
+          case 13:
+            if (resultData) {
+              _context6.next = 14;
+              break;
+            }
+            throw new Error("\u8FD4\u56DE\u7684\u6587\u4EF6\u5730\u5740\u4E3A\u7A7A");
+          case 14:
+            if (typeof resultData === 'string') {
+              fileUrl = resultData;
+            } else if (resultData && typeof resultData === 'object' && resultData.url) {
+              fileUrl = resultData.url;
+            }
+            successLog("\u6587\u4EF6\u4E0A\u4F20\u6210\u529F: " + fileName + " -> " + fileUrl, spinner);
+            return _context6.abrupt("return", fileUrl);
+          case 15:
+            _context6.prev = 15;
+            _t4 = _context6["catch"](7);
+            errorLog("\u4E0A\u4F20\u6587\u4EF6\u5931\u8D25: " + _t4.message + ", \u6587\u4EF6\u8DEF\u5F84: " + filePath, spinner);
+
+            // 输出详细的错误信息
+            if (!_t4.response) {
+              _context6.next = 17;
+              break;
+            }
+            status = _t4.response.status;
+            statusText = _t4.response.statusText;
+            _responseData = _t4.response.data;
+            requestUrl = ((_error$config = _t4.config) == null ? void 0 : _error$config.url) || this.uploadAPI();
+            errorLog("\n========== \u4E0A\u4F20\u8BF7\u6C42\u8BE6\u60C5 ==========");
+            errorLog("\u8BF7\u6C42 URL: " + requestUrl);
+            errorLog("HTTP \u72B6\u6001\u7801: " + status + " " + statusText);
+            errorLog("\u54CD\u5E94\u6570\u636E: " + JSON.stringify(_responseData));
+            errorLog("==================================\n");
+            if (!(status === 404)) {
+              _context6.next = 16;
+              break;
+            }
+            throw new Error("\u4E0A\u4F20 API \u4E0D\u5B58\u5728 (404): " + requestUrl + "\n" + "\u8BF7\u68C0\u67E5 neo.config.js \u4E2D\u7684 neoBaseURL \u914D\u7F6E\u662F\u5426\u6B63\u786E\uFF0C\u6216\u8005 API \u8DEF\u5F84\u662F\u5426\u5B58\u5728\u3002\n" + ("\u5F53\u524D\u914D\u7F6E\u7684 API \u8DEF\u5F84: " + NeoCrmAPI.uploadAPI));
+          case 16:
+            _context6.next = 18;
+            break;
+          case 17:
+            if (_t4.request) {
+              errorLog('请求已发送但未收到响应，请检查网络连接或代理配置。');
+            }
+          case 18:
+            throw _t4;
+          case 19:
+          case "end":
+            return _context6.stop();
+        }
+      }, _callee6, this, [[7, 15]]);
+    }));
+    function uploadFile(_x, _x2) {
+      return _uploadFile.apply(this, arguments);
+    }
+    return uploadFile;
+  }()
+  /**
+   * 将构建产物上传到 NeoCRM 平台端（已废弃）
+   * 备注：已废弃，改为 保存时直接上传组件资源文件
+   *
+   * @param {object} cmpType 自定义组件名称
+   * @param {array} fileExtensions 需要上传的文件类型，默认 ['.js', '.css', '.zip']
+   */
+  ;
+  _proto.publish2oss =
+  /*#__PURE__*/
+  function () {
+    var _publish2oss = asyncToGenerator(/*#__PURE__*/index.mark(function _callee8(cmpType, fileExtensions) {
+      var _this = this;
+      var curCmpInfo, files, uploadPromises;
+      return index.wrap(function (_context8) {
+        while (1) switch (_context8.prev = _context8.next) {
+          case 0:
+            if (fileExtensions === void 0) {
+              fileExtensions = ['.js', '.css', '.zip'];
+            }
+            if (cmpType) {
+              _context8.next = 1;
+              break;
+            }
+            errorLog("\u81EA\u5B9A\u4E49\u7EC4\u4EF6\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A: " + cmpType);
+            return _context8.abrupt("return");
+          case 1:
+            if (fs.existsSync(this.assetsRoot)) {
+              _context8.next = 2;
+              break;
+            }
+            errorLog("\u672A\u627E\u5230\u81EA\u5B9A\u4E49\u7EC4\u4EF6\u8D44\u6E90\u76EE\u5F55: " + this.assetsRoot);
+            return _context8.abrupt("return");
+          case 2:
+            // 当前组件信息
+            curCmpInfo = {
+              cmpType: cmpType
+            };
+            files = fs.readdirSync(this.assetsRoot); // 读取构建目录下的所有文件
+            // 并行上传所有指定类型的文件
+            uploadPromises = files.map(/*#__PURE__*/function () {
+              var _ref3 = asyncToGenerator(/*#__PURE__*/index.mark(function _callee7(file) {
+                var filePath, fileStat, fileInfo, widgetName, fileUrl;
+                return index.wrap(function (_context7) {
+                  while (1) switch (_context7.prev = _context7.next) {
+                    case 0:
+                      filePath = path.join(_this.assetsRoot, file); // 获取文件状态
+                      fileStat = fs.statSync(filePath); // 检查文件扩展名
+                      // const fileExt = path.extname(file);
+                      fileInfo = path.parse(filePath);
+                      if (!(fileStat.isFile() && fileExtensions.includes(fileInfo.ext))) {
+                        _context7.next = 4;
+                        break;
+                      }
+                      widgetName = _.camelCase(cmpType);
+                      if (!(file.indexOf(widgetName) < 0)) {
+                        _context7.next = 1;
+                        break;
+                      }
+                      return _context7.abrupt("return");
+                    case 1:
+                      _context7.prev = 1;
+                      _context7.next = 2;
+                      return _this.uploadFile(filePath);
+                    case 2:
+                      fileUrl = _context7.sent;
+                      if (file.indexOf('Model') > -1) {
+                        curCmpInfo.modelAsset = fileUrl;
+                      } else if (file.endsWith('.css')) {
+                        curCmpInfo.cssAsset = fileUrl;
+                      } else if (file.endsWith('.zip')) {
+                        curCmpInfo.codeLib = fileUrl;
+                      } else {
+                        curCmpInfo.asset = fileUrl;
+                      }
+                      _context7.next = 4;
+                      break;
+                    case 3:
+                      _context7.prev = 3;
+                      _context7["catch"](1);
+                      errorLog("\u6587\u4EF6\u4E0A\u4F20\u5931\u8D25\uFF08" + file + "\uFF09\uFF1A\n");
+                      process.exit(1);
+                    case 4:
+                    case "end":
+                      return _context7.stop();
+                  }
+                }, _callee7, null, [[1, 3]]);
+              }));
+              return function (_x5) {
+                return _ref3.apply(this, arguments);
+              };
+            }());
+            _context8.next = 3;
+            return Promise.all(uploadPromises);
+          case 3:
+            if (curCmpInfo && curCmpInfo.cmpType) {
+              console.info('上传至 OSS 的文件信息：\n', curCmpInfo);
+              // 更新发布日志
+              updatePublishLog(curCmpInfo);
+            }
+            return _context8.abrupt("return", curCmpInfo);
+          case 4:
+          case "end":
+            return _context8.stop();
+        }
+      }, _callee8, this);
+    }));
+    function publish2oss(_x3, _x4) {
+      return _publish2oss.apply(this, arguments);
+    }
+    return publish2oss;
+  }()
+  /**
+   * 处理组件构建产物
+   *
+   * @param {object} cmpType 自定义组件名称
+   * @param {array} fileExtensions 需要处理的文件类型，默认 ['.js', '.css', '.zip']
+   */
+  ;
+  _proto.getCmpAssets =
+  /*#__PURE__*/
+  function () {
+    var _getCmpAssets = asyncToGenerator(/*#__PURE__*/index.mark(function _callee9(cmpType, fileExtensions) {
+      var _this2 = this;
+      var curCmpInfo, files;
+      return index.wrap(function (_context9) {
+        while (1) switch (_context9.prev = _context9.next) {
+          case 0:
+            if (fileExtensions === void 0) {
+              fileExtensions = ['.js', '.css', '.zip'];
+            }
+            if (cmpType) {
+              _context9.next = 1;
+              break;
+            }
+            errorLog("\u81EA\u5B9A\u4E49\u7EC4\u4EF6\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A: " + cmpType);
+            return _context9.abrupt("return");
+          case 1:
+            if (fs.existsSync(this.assetsRoot)) {
+              _context9.next = 2;
+              break;
+            }
+            errorLog("\u672A\u627E\u5230\u81EA\u5B9A\u4E49\u7EC4\u4EF6\u8D44\u6E90\u76EE\u5F55: " + this.assetsRoot);
+            return _context9.abrupt("return");
+          case 2:
+            // 当前组件信息
+            curCmpInfo = {
+              cmpType: cmpType
+            };
+            files = fs.readdirSync(this.assetsRoot); // 读取构建目录下的所有文件
+            // 处理构建产物目录下所有指定类型的文件
+            files.forEach(function (file) {
+              var filePath = path.join(_this2.assetsRoot, file);
+              // 获取文件状态
+              var fileStat = fs.statSync(filePath);
+              // 检查文件扩展名
+              // const fileExt = path.extname(file);
+              var fileInfo = path.parse(filePath);
+              if (fileStat.isFile() && fileExtensions.includes(fileInfo.ext)) {
+                var widgetName = _.camelCase(cmpType);
+                if (file.indexOf(widgetName) < 0) {
+                  return;
+                }
+
+                // 检查文件大小
+                var maxSize = 5 * 1024 * 1024; // 默认 5MB
+                if (fileStat.size > maxSize) {
+                  var sizeMB = (fileStat.size / 1024 / 1024).toFixed(2);
+                  var maxSizeMB = (maxSize / 1024 / 1024).toFixed(2);
+                  throw new Error(file + " \u6587\u4EF6\u5927\u5C0F\u8D85\u8FC7\u9650\u5236: " + sizeMB + "MB > " + maxSizeMB + "MB");
+                }
+                var fileContent = fs.createReadStream(filePath);
+                var _fileInfo = {
+                  fileContent: fileContent,
+                  fileName: file,
+                  fileSize: fileStat.size
+                };
+                if (file.indexOf('Model') > -1) {
+                  // 使用文件流而不是读取整个文件到内存（对大文件更友好）
+                  curCmpInfo.modelAssetFile = _fileInfo;
+                } else if (file.endsWith('.css')) {
+                  curCmpInfo.cssAssetFile = _fileInfo;
+                } else if (file.endsWith('.zip')) {
+                  curCmpInfo.codeLibFile = _fileInfo;
+                } else {
+                  curCmpInfo.assetFile = _fileInfo;
+                }
+              }
+            });
+            return _context9.abrupt("return", curCmpInfo);
+          case 3:
+          case "end":
+            return _context9.stop();
+        }
+      }, _callee9, this);
+    }));
+    function getCmpAssets(_x6, _x7) {
+      return _getCmpAssets.apply(this, arguments);
+    }
+    return getCmpAssets;
+  }()
+  /**
+   * 更新自定义组件
+   * @param {object} componentData 组件数据
+   * @returns {Promise<object>} 更新结果
+   */
+  ;
+  _proto.updateCustomComponent =
+  /*#__PURE__*/
+  function () {
+    var _updateCustomComponent = asyncToGenerator(/*#__PURE__*/index.mark(function _callee0(componentData) {
+      var token, spinner, fullUpdateAPI, formData, response, _ref4, code, _t6;
+      return index.wrap(function (_context0) {
+        while (1) switch (_context0.prev = _context0.next) {
+          case 0:
+            _context0.next = 1;
+            return this.ensureValidToken();
+          case 1:
+            token = _context0.sent;
+            if (componentData) {
+              _context0.next = 2;
+              break;
+            }
+            throw new Error('componentData 不能为空');
+          case 2:
+            spinner = ora('正在保存自定义组件信息...').start();
+            _context0.prev = 3;
+            fullUpdateAPI = this.saveAPI(); // 创建 FormData
+            formData = new FormData(); // 处理 componentData 中的 fileInfo 文件
+            if (componentData.assetFile) {
+              formData.append('assetFile', componentData.assetFile.fileContent, componentData.assetFile.fileName);
+            }
+            if (componentData.modelAssetFile) {
+              formData.append('modelAssetFile', componentData.modelAssetFile.fileContent, componentData.modelAssetFile.fileName);
+            }
+            if (componentData.cssAssetFile) {
+              formData.append('cssAssetFile', componentData.cssAssetFile.fileContent, componentData.cssAssetFile.fileName);
+            }
+            if (componentData.codeLibFile) {
+              formData.append('codeLibFile', componentData.codeLibFile.fileContent, componentData.codeLibFile.fileName);
+            }
+
+            // 将 componentData 中组件基本信息
+            formData.append('component', JSON.stringify(_.omit(componentData, ['assetFile', 'modelAssetFile', 'cssAssetFile', 'codeLibFile'])));
+            _context0.next = 4;
+            return axios.post(fullUpdateAPI, formData, {
+              headers: _extends({
+                Authorization: "Bearer " + token,
+                'xsy-inner-source': 'bff'
+              }, formData.getHeaders()),
+              timeout: 120000,
+              // 默认 60 秒
+              // 确保 axios 正确处理大文件和流
+              maxContentLength: Infinity,
+              // 不限制响应内容长度
+              maxBodyLength: Infinity // 不限制请求体长度（适用于文件上传）
+            });
+          case 4:
+            response = _context0.sent;
+            _ref4 = response.data || {}, code = _ref4.code, _ref4.message;
+            if (code && code !== 200) {
+              errorLog("\u4FDD\u5B58\u81EA\u5B9A\u4E49\u7EC4\u4EF6\u4FE1\u606F\u5931\u8D25: " + (response.data.message || '未知错误'));
+              process.exit(1);
+            }
+            spinner.clear();
+            spinner.stop();
+            _context0.next = 6;
+            break;
+          case 5:
+            _context0.prev = 5;
+            _t6 = _context0["catch"](3);
+            if (_t6.message) {
+              errorLog("\u4FDD\u5B58\u81EA\u5B9A\u4E49\u7EC4\u4EF6\u4FE1\u606F\u5931\u8D25: " + _t6.message, spinner);
+            } else {
+              errorLog("\u4FDD\u5B58\u81EA\u5B9A\u4E49\u7EC4\u4EF6\u4FE1\u606F\u5931\u8D25: " + JSON.stringify(_t6), spinner);
+            }
+            process.exit(1);
+          case 6:
+          case "end":
+            return _context0.stop();
+        }
+      }, _callee0, this, [[3, 5]]);
+    }));
+    function updateCustomComponent(_x8) {
+      return _updateCustomComponent.apply(this, arguments);
+    }
+    return updateCustomComponent;
+  }()
+  /**
+   * 获取线上自定义组件列表
+   * @returns {Promise<array>} 自定义组件列表
+   */
+  ;
+  _proto.getCustomCmpList =
+  /*#__PURE__*/
+  function () {
+    var _getCustomCmpList = asyncToGenerator(/*#__PURE__*/index.mark(function _callee1() {
+      var token, queryAllAPI, response, _ref5, code, message, _t7;
+      return index.wrap(function (_context1) {
+        while (1) switch (_context1.prev = _context1.next) {
+          case 0:
+            _context1.next = 1;
+            return this.ensureValidToken();
+          case 1:
+            token = _context1.sent;
+            _context1.prev = 2;
+            queryAllAPI = this.buildFullUrl(NeoCrmAPI.queryAll);
+            queryAllAPI += "&fields=" + cmpFields.join(',');
+            _context1.next = 3;
+            return axios.get(queryAllAPI, {
+              headers: {
+                Authorization: "Bearer " + token,
+                'xsy-inner-source': 'bff',
+                'Content-Type': 'application/json'
+              }
+            });
+          case 3:
+            response = _context1.sent;
+            _ref5 = response.data || {}, code = _ref5.code, message = _ref5.message;
+            if (code && code !== 200) {
+              errorLog("\u83B7\u53D6\u81EA\u5B9A\u4E49\u7EC4\u4EF6\u5217\u8868\u5931\u8D25: " + (message || '未知错误'));
+              process.exit(1);
+            }
+            this.updateCustomCmpList(response.data.data || []);
+            _context1.next = 5;
+            break;
+          case 4:
+            _context1.prev = 4;
+            _t7 = _context1["catch"](2);
+            if (_t7.message) {
+              errorLog("\u83B7\u53D6\u81EA\u5B9A\u4E49\u7EC4\u4EF6\u5217\u8868\u5931\u8D25: " + _t7.message);
+            } else {
+              errorLog("\u54CD\u5E94\u6570\u636E: " + JSON.stringify(_t7));
+            }
+            process.exit(1);
+          case 5:
+            return _context1.abrupt("return", this.cmpList || []);
+          case 6:
+          case "end":
+            return _context1.stop();
+        }
+      }, _callee1, this, [[2, 4]]);
+    }));
+    function getCustomCmpList() {
+      return _getCustomCmpList.apply(this, arguments);
+    }
+    return getCustomCmpList;
+  }()
+  /**
+   * 获取自定义组件源码文件地址
+   * @param {string} cmpType 自定义组件名称
+   * @returns {string} 源码文件地址
+   */
+  ;
+  _proto.getCodeLibByCmpType = function getCodeLibByCmpType(cmpType) {
+    if (!cmpType) {
+      return null;
+    }
+    return this.buildFullUrl(NeoCrmAPI.getCodeLibAPI(cmpType));
+  }
+
+  /**
+   * 删除自定义组件
+   * @param {*} cmpType 自定义组件类型
+   * @returns {Promise<object>} 删除结果
+   */;
+  _proto.deleteCmp =
+  /*#__PURE__*/
+  function () {
+    var _deleteCmp = asyncToGenerator(/*#__PURE__*/index.mark(function _callee10(cmpType) {
+      var token, fullDeleteAPI, response, _ref6, code, message;
+      return index.wrap(function (_context10) {
+        while (1) switch (_context10.prev = _context10.next) {
+          case 0:
+            _context10.next = 1;
+            return this.ensureValidToken();
+          case 1:
+            token = _context10.sent;
+            if (!cmpType) {
+              errorLog('自定义组件名称不能为空。');
+              process.exit(1);
+            }
+            fullDeleteAPI = this.buildFullUrl(NeoCrmAPI.delete);
+            fullDeleteAPI += "/" + cmpType;
+            _context10.next = 2;
+            return axios.delete(fullDeleteAPI, {
+              headers: {
+                Authorization: "Bearer " + token,
+                'xsy-inner-source': 'bff',
+                'Content-Type': 'application/json'
+              }
+            });
+          case 2:
+            response = _context10.sent;
+            _ref6 = response.data || {}, code = _ref6.code, message = _ref6.message;
+            if (code && code !== 200) {
+              errorLog("\u5220\u9664\u81EA\u5B9A\u4E49\u7EC4\u4EF6\u5931\u8D25: " + (message || '未知错误'));
+              process.exit(1);
+            }
+            return _context10.abrupt("return", response.data);
+          case 3:
+          case "end":
+            return _context10.stop();
+        }
+      }, _callee10, this);
+    }));
+    function deleteCmp(_x9) {
+      return _deleteCmp.apply(this, arguments);
+    }
+    return deleteCmp;
+  }() // 获取指定框架的自定义组件列表
+  ;
+  _proto.getCmpListByFramework = function getCmpListByFramework(framework) {
+    if (!framework) {
+      return this.cmpList;
+    }
+    var curFramework = getFramework(framework);
+    return this.cmpList.filter(function (cmp) {
+      return cmp.framework === curFramework;
+    });
+  }
+
+  // 获取自定义组件信息
+  ;
+  _proto.getCmpInfoByCmpType = function getCmpInfoByCmpType(cmpType) {
+    if (!cmpType) {
+      return null;
+    }
+    return this.cmpInfoMap[cmpType] || null;
+  }
+
+  // 更新自定义组件 Map
+  ;
+  _proto.updateCustomCmpList = function updateCustomCmpList(cmpList) {
+    var _this3 = this;
+    if (!cmpList || !Array.isArray(cmpList)) {
+      return;
+    }
+    this.cmpList = cmpList;
+    cmpList.forEach(function (cmp) {
+      _this3.cmpInfoMap[cmp.cmpType] = cmp;
+    });
+  }
+
+  /**
+   * 通用请求方法（确保 token 有效）
+   * @param {string} method HTTP 方法
+   * @param {string} api API 地址（相对或绝对路径）
+   * @param {object} options 请求选项
+   * @param {object} options.data 请求数据
+   * @param {object} options.headers 额外的请求头
+   * @param {object} options.params 查询参数
+   * @returns {Promise<object>} 响应数据
+   */;
+  _proto.request =
+  /*#__PURE__*/
+  function () {
+    var _request = asyncToGenerator(/*#__PURE__*/index.mark(function _callee11(method, api, options) {
+      var token, _options, data, _options$headers, headers, params, fullAPI, response, _t8;
+      return index.wrap(function (_context11) {
+        while (1) switch (_context11.prev = _context11.next) {
+          case 0:
+            if (options === void 0) {
+              options = {};
+            }
+            _context11.next = 1;
+            return this.ensureValidToken();
+          case 1:
+            token = _context11.sent;
+            _options = options, data = _options.data, _options$headers = _options.headers, headers = _options$headers === void 0 ? {} : _options$headers, params = _options.params;
+            fullAPI = this.buildFullUrl(api);
+            _context11.prev = 2;
+            _context11.next = 3;
+            return axios({
+              method: method,
+              url: fullAPI,
+              data: data,
+              params: params,
+              headers: _extends({
+                Authorization: "Bearer " + token,
+                'xsy-inner-source': 'bff'
+              }, headers)
+            });
+          case 3:
+            response = _context11.sent;
+            if (!(response.data && response.data.code && response.data.code !== 200)) {
+              _context11.next = 4;
+              break;
+            }
+            throw new Error("\u8BF7\u6C42\u5931\u8D25: " + (response.data.message || '未知错误'));
+          case 4:
+            return _context11.abrupt("return", response.data);
+          case 5:
+            _context11.prev = 5;
+            _t8 = _context11["catch"](2);
+            errorLog("\u8BF7\u6C42\u5931\u8D25 [" + method + " " + api + "]: " + _t8.message);
+            if (_t8.response) {
+              errorLog("\u54CD\u5E94\u6570\u636E: " + JSON.stringify(_t8.response.data));
+            }
+            throw _t8;
+          case 6:
+          case "end":
+            return _context11.stop();
+        }
+      }, _callee11, this, [[2, 5]]);
+    }));
+    function request(_x0, _x1, _x10) {
+      return _request.apply(this, arguments);
+    }
+    return request;
+  }()
+  /**
+   * GET 请求
+   * @param {string} api API 地址
+   * @param {object} options 请求选项
+   * @returns {Promise<object>} 响应数据
+   */
+  ;
+  _proto.get =
+  /*#__PURE__*/
+  function () {
+    var _get = asyncToGenerator(/*#__PURE__*/index.mark(function _callee12(api, options) {
+      return index.wrap(function (_context12) {
+        while (1) switch (_context12.prev = _context12.next) {
+          case 0:
+            if (options === void 0) {
+              options = {};
+            }
+            _context12.next = 1;
+            return this.request('GET', api, options);
+          case 1:
+            return _context12.abrupt("return", _context12.sent);
+          case 2:
+          case "end":
+            return _context12.stop();
+        }
+      }, _callee12, this);
+    }));
+    function get(_x11, _x12) {
+      return _get.apply(this, arguments);
+    }
+    return get;
+  }()
+  /**
+   * POST 请求
+   * @param {string} api API 地址
+   * @param {object} options 请求选项
+   * @returns {Promise<object>} 响应数据
+   */
+  ;
+  _proto.post =
+  /*#__PURE__*/
+  function () {
+    var _post = asyncToGenerator(/*#__PURE__*/index.mark(function _callee13(api, options) {
+      return index.wrap(function (_context13) {
+        while (1) switch (_context13.prev = _context13.next) {
+          case 0:
+            if (options === void 0) {
+              options = {};
+            }
+            _context13.next = 1;
+            return this.request('POST', api, options);
+          case 1:
+            return _context13.abrupt("return", _context13.sent);
+          case 2:
+          case "end":
+            return _context13.stop();
+        }
+      }, _callee13, this);
+    }));
+    function post(_x13, _x14) {
+      return _post.apply(this, arguments);
+    }
+    return post;
+  }()
+  /**
+   * PUT 请求
+   * @param {string} api API 地址
+   * @param {object} options 请求选项
+   * @returns {Promise<object>} 响应数据
+   */
+  ;
+  _proto.put =
+  /*#__PURE__*/
+  function () {
+    var _put = asyncToGenerator(/*#__PURE__*/index.mark(function _callee14(api, options) {
+      return index.wrap(function (_context14) {
+        while (1) switch (_context14.prev = _context14.next) {
+          case 0:
+            if (options === void 0) {
+              options = {};
+            }
+            _context14.next = 1;
+            return this.request('PUT', api, options);
+          case 1:
+            return _context14.abrupt("return", _context14.sent);
+          case 2:
+          case "end":
+            return _context14.stop();
+        }
+      }, _callee14, this);
+    }));
+    function put(_x15, _x16) {
+      return _put.apply(this, arguments);
+    }
+    return put;
+  }()
+  /**
+   * DELETE 请求
+   * @param {string} api API 地址
+   * @param {object} options 请求选项
+   * @returns {Promise<object>} 响应数据
+   */
+  ;
+  _proto.delete =
+  /*#__PURE__*/
+  function () {
+    var _delete2 = asyncToGenerator(/*#__PURE__*/index.mark(function _callee15(api, options) {
+      return index.wrap(function (_context15) {
+        while (1) switch (_context15.prev = _context15.next) {
+          case 0:
+            if (options === void 0) {
+              options = {};
+            }
+            _context15.next = 1;
+            return this.request('DELETE', api, options);
+          case 1:
+            return _context15.abrupt("return", _context15.sent);
+          case 2:
+          case "end":
+            return _context15.stop();
+        }
+      }, _callee15, this);
+    }));
+    function _delete(_x17, _x18) {
+      return _delete2.apply(this, arguments);
+    }
+    return _delete;
+  }();
+  return NeoService;
+}();
+module.exports = NeoService;