neo-cmp-cli 1.8.7 → 1.8.9

package/dist/neo/neoService.js

@@ -0,0 +1,898 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const require$$0$1 = require('axios');
+const require$$1$1 = require('form-data');
+const require$$0$2 = require('node:fs');
+const require$$1 = require('node:path');
+const require$$3 = require('ora');
+const require$$2 = require('lodash');
+const require$$0 = require('akfun');
+const neoLogin = require('./neoLogin.js');
+const updatePublishLog = require('../utils/projectUtils/updatePublishLog.js');
+const common = require('../utils/common.js');
+
+var neoService;
+var hasRequiredNeoService;
+
+function requireNeoService () {
+	if (hasRequiredNeoService) return neoService;
+	hasRequiredNeoService = 1;
+	const axios = require$$0$1;
+	const FormData = require$$1$1;
+	const fs = require$$0$2;
+	const path = require$$1;
+	const ora = require$$3;
+	const _ = require$$2;
+	const { resolve } = require$$0;
+	const NeoLoginService = neoLogin.__require();
+	const updatePublishLog$1 = updatePublishLog.__require();
+	const { getFramework, errorLog, successLog } = common.__require();
+
+	// NeoCRM 平台默认 API 配置
+	const 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: (cmpType) => `/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', // 不带分页（已废弃）
+	};
+
+	const cmpFields = [
+	  'cmpType',
+	  'label',
+	  'componentCategory',
+	  'description',
+	  'framework',
+	  'icon',
+	  'iconUrl',
+	  'orderNo',
+	  'version',
+	  'propsSchema',
+	  'defaultProps',
+	  'previewProps',
+	  'events',
+	  'functions',
+	  'asset',
+	  'modelAsset',
+	  'cssAsset',
+	  'codeLib'
+	];
+
+	/**
+	 * Neo 平台服务类
+	 * 提供 token 管理、文件上传、组件更新等功能
+	 */
+	class NeoService {
+	  /**
+	   * 初始化 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 模式需要）
+	   */
+	  constructor(config = {}) {
+	    const { assetsRoot, neoBaseURL, tokenAPI, loginURL, auth, authType } = config || {};
+
+	    // 设置授权类型，默认为 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(`不支持的授权类型: ${this.authType}，可选值：oauth2、password`);
+	      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
+	   */
+	  buildFullUrl(url) {
+	    if (url.startsWith('http://') || url.startsWith('https://')) {
+	      return url;
+	    }
+	    return `${this.neoBaseURL}${url}`;
+	  }
+
+	  // 获取文件上传接口地址
+	  uploadAPI() {
+	    return this.buildFullUrl(NeoCrmAPI.uploadAPI);
+	  }
+
+	  // 获取组件信息保存接口地址
+	  saveAPI() {
+	    return this.buildFullUrl(NeoCrmAPI.saveAPI);
+	  }
+
+	  /**
+	   * 检查 token 是否过期
+	   * @returns {boolean} true 表示已过期，false 表示未过期
+	   */
+	  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
+	   */
+	  async getToken() {
+	    // 检查缓存是否有效
+	    if (!this.isTokenExpired()) {
+	      return this.tokenCache.token;
+	    }
+
+	    // 根据授权类型选择对应的获取方式
+	    if (this.authType === 'oauth2') {
+	      return await this.getTokenByOAuth2();
+	    } else {
+	      return await this.getTokenByPassword();
+	    }
+	  }
+
+	  /**
+	   * 使用密码模式获取 token
+	   * @returns {Promise<string>} token
+	   */
+	  async getTokenByPassword() {
+	    const spinner = ora('获取 token（密码模式）...').start();
+
+	    // 检查缓存是否有效
+	    if (!this.isTokenExpired()) {
+	      successLog('使用缓存的 token。', spinner);
+	      return this.tokenCache.token;
+	    }
+
+	    // 构建表单数据格式的请求参数
+	    const 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);
+
+	    const tokenUrl = this.buildFullUrl(this.tokenAPI);
+
+	    try {
+	      const response = await axios.post(tokenUrl, formData.toString(), {
+	        headers: {
+	          'Content-Type': 'application/x-www-form-urlencoded'
+	        }
+	      });
+
+	      const { access_token, expires_in } = response.data || {};
+
+	      if (!access_token) {
+	        errorLog(
+	          '获取 token 失败（授权配置错误）：响应中未包含 access_token，' +
+	            JSON.stringify(response.data),
+	          spinner
+	        );
+	        process.exit(1);
+	      }
+
+	      // 缓存 token（提前 60 秒过期，避免边缘情况）
+	      const expiresIn = parseInt(expires_in) || 3600; // 默认 1 小时
+	      this.tokenCache = {
+	        token: access_token,
+	        expiresAt: Date.now() + (expiresIn - 60) * 1000
+	      };
+	      spinner.clear();
+	      spinner.stop();
+	      return access_token;
+	    } catch (error) {
+	      errorLog('获取 token 失败', spinner);
+	      errorLog(`\n获取 token 失败: ${error.message}`);
+	      errorLog(`\ntoken 授权地址: ${tokenUrl}`);
+	      errorLog(`\ntoken 请求参数: ${formData}`);
+	      if (error.response) {
+	        errorLog(`响应数据: ${JSON.stringify(error.response.data)}`);
+	      }
+	      process.exit(1);
+	    }
+	  }
+
+	  /**
+	   * 获取 OAuth2 授权码模式的 token
+	   * @returns {Promise<string>} token
+	   */
+	  async getTokenByOAuth2() {
+	    const spinner = ora('获取 token（OAuth2 模式）...').start();
+
+	    try {
+	      // 构建 OAuth2 配置
+	      const oauth2Config = {
+	        loginURL: this.loginURL,
+	        tokenAPI: this.tokenAPI
+	      };
+
+	      const loginService = new NeoLoginService(oauth2Config);
+	      const accessToken = await loginService.getAccessToken();
+
+	      // 缓存 token（OAuth2 模式下的 token 有效期由 NeoLoginService 管理）
+	      // 这里我们设置一个较长的过期时间，实际过期检查由 NeoLoginService 内部处理
+	      this.tokenCache = {
+	        token: accessToken,
+	        expiresAt: Date.now() + 7200 * 1000 // 默认 2 小时，实际由 NeoLoginService 管理
+	      };
+
+	      spinner.clear();
+	      spinner.stop();
+	      return accessToken;
+	    } catch (error) {
+	      errorLog('获取 token 失败（OAuth2 模式）', spinner);
+	      errorLog(`\n获取 token 失败: ${error.message}`);
+	      if (error.response) {
+	        errorLog(`响应数据: ${JSON.stringify(error.response.data)}`);
+	      }
+	      process.exit(1);
+	    }
+	  }
+
+	  /**
+	   * 刷新 token
+	   * @returns {Promise<string>} 新的 token
+	   */
+	  async refreshToken() {
+	    // 清除缓存，强制获取新 token
+	    this.tokenCache = {
+	      token: null,
+	      expiresAt: null
+	    };
+
+	    return await this.getToken();
+	  }
+
+	  /**
+	   * 确保 token 有效，如果过期则自动刷新
+	   * @returns {Promise<string>} 有效的 token
+	   */
+	  async ensureValidToken() {
+	    if (!this.tokenCache.token) {
+	      return await this.getToken();
+	    } else if (this.isTokenExpired()) {
+	      const spinner = ora('token 已过期，正在刷新...').start();
+	      try {
+	        const token = await this.refreshToken();
+	        successLog('token 刷新成功。', spinner);
+	        return token;
+	      } catch (error) {
+	        errorLog('token 刷新失败。', spinner);
+	        throw error;
+	      }
+	    }
+	    return this.tokenCache.token;
+	  }
+
+	  /**
+	   * 上传文件到 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
+	   */
+	  async uploadFile(filePath, options = {}) {
+	    // 确保 token 有效
+	    const token = await this.ensureValidToken();
+
+	    // 验证文件路径
+	    if (!filePath || typeof filePath !== 'string') {
+	      throw new Error(`文件路径无效: ${filePath}`);
+	    }
+
+	    // 检查文件是否存在
+	    if (!fs.existsSync(filePath)) {
+	      throw new Error(`文件不存在: ${filePath}`);
+	    }
+
+	    // 检查文件状态
+	    const fileStat = fs.statSync(filePath);
+	    if (!fileStat.isFile()) {
+	      throw new Error(`路径不是文件: ${filePath}`);
+	    }
+
+	    // 检查文件大小
+	    const maxSize = options.maxSize || 5 * 1024 * 1024; // 默认 5MB
+	    if (fileStat.size > maxSize) {
+	      const sizeMB = (fileStat.size / 1024 / 1024).toFixed(2);
+	      const maxSizeMB = (maxSize / 1024 / 1024).toFixed(2);
+	      throw new Error(`文件大小超过限制: ${sizeMB}MB > ${maxSizeMB}MB`);
+	    }
+
+	    if (fileStat.size === 0) {
+	      throw new Error(`文件为空: ${filePath}`);
+	    }
+
+	    const fileName = path.basename(filePath);
+	    const fileSizeKB = (fileStat.size / 1024).toFixed(2);
+	    const spinner = ora(`正在上传文件: ${fileName} (${fileSizeKB}KB)...`).start();
+
+	    try {
+	      // 创建 FormData
+	      const formData = new FormData();
+	      const fieldName = options.fieldName || 'customComponentCode';
+
+	      // 使用文件流而不是读取整个文件到内存（对大文件更友好）
+	      const fileContent = fs.createReadStream(filePath);
+
+	      // 追加文件到 FormData，第三个参数指定文件名
+	      formData.append(fieldName, fileContent, fileName);
+
+	      // 构建完整的上传 API 地址
+	      const fullUploadAPI = this.uploadAPI();
+
+	      // 配置请求选项
+	      const timeout = options.timeout || 60000; // 默认 60 秒
+	      const requestConfig = {
+	        headers: {
+	          Authorization: `Bearer ${token}`,
+	          'xsy-inner-source': 'bff',
+	          // 无需手动设置 Content-Type，formData.getHeaders() 会自动设置正确的 multipart/form-data 和 boundary
+	          ...formData.getHeaders()
+	        },
+	        timeout,
+	        // 确保 axios 正确处理大文件和流
+	        maxContentLength: Infinity, // 不限制响应内容长度
+	        maxBodyLength: Infinity // 不限制请求体长度（适用于文件上传）
+	      };
+
+	      // 发送上传请求
+	      const response = await axios.post(fullUploadAPI, formData, requestConfig);
+
+	      // 处理响应数据
+	      let resultData;
+	      const responseData = response.data;
+
+	      // 检查响应状态码
+	      if (response.status !== 200 && response.status !== 201) {
+	        throw new Error(`上传失败: HTTP ${response.status}`);
+	      }
+
+	      // 处理不同的响应格式
+	      if (typeof responseData === 'string') {
+	        // 如果响应是字符串，直接使用
+	        resultData = responseData.trim();
+	      } else if (responseData && typeof responseData === 'object') {
+	        // 检查是否有错误码
+	        if (
+	          responseData.code !== undefined &&
+	          responseData.code !== 200 &&
+	          responseData.code !== 0
+	        ) {
+	          const errorMsg = responseData.message || responseData.msg || '未知错误';
+	          throw new Error(`上传失败: ${errorMsg} (code: ${responseData.code})`);
+	        }
+
+	        // 提取数据
+	        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;
+	        }
+	      } else {
+	        throw new Error(`响应数据格式不正确: ${typeof responseData}`);
+	      }
+
+	      // 验证返回的文件地址
+	      if (!resultData) {
+	        throw new Error(`返回的文件地址为空`);
+	      }
+
+	      // 格式化文件 URL
+	      let fileUrl;
+	      if (typeof resultData === 'string') {
+	        fileUrl = resultData;
+	      } else if (resultData && typeof resultData === 'object' && resultData.url) {
+	        fileUrl = resultData.url;
+	      }
+	      successLog(`文件上传成功: ${fileName} -> ${fileUrl}`, spinner);
+	      return fileUrl;
+	    } catch (error) {
+	      errorLog(`上传文件失败: ${error.message}, 文件路径: ${filePath}`, spinner);
+
+	      // 输出详细的错误信息
+	      if (error.response) {
+	        const status = error.response.status;
+	        const statusText = error.response.statusText;
+	        const responseData = error.response.data;
+	        const requestUrl = error.config?.url || this.uploadAPI();
+
+	        errorLog(`\n========== 上传请求详情 ==========`);
+	        errorLog(`请求 URL: ${requestUrl}`);
+	        errorLog(`HTTP 状态码: ${status} ${statusText}`);
+	        errorLog(`响应数据: ${JSON.stringify(responseData)}`);
+	        errorLog(`==================================\n`);
+
+	        if (status === 404) {
+	          throw new Error(
+	            `上传 API 不存在 (404): ${requestUrl}\n` +
+	              `请检查 neo.config.js 中的 neoBaseURL 配置是否正确，或者 API 路径是否存在。\n` +
+	              `当前配置的 API 路径: ${NeoCrmAPI.uploadAPI}`
+	          );
+	        }
+	      } else if (error.request) {
+	        errorLog('请求已发送但未收到响应，请检查网络连接或代理配置。');
+	      }
+
+	      throw error;
+	    }
+	  }
+
+	  /**
+	   * 将构建产物上传到 NeoCRM 平台端（已废弃）
+	   * 备注：已废弃，改为 保存时直接上传组件资源文件
+	   *
+	   * @param {object} cmpType 自定义组件名称
+	   * @param {array} fileExtensions 需要上传的文件类型，默认 ['.js', '.css', '.zip']
+	   */
+	  async publish2oss(cmpType, fileExtensions = ['.js', '.css', '.zip']) {
+	    if (!cmpType) {
+	      errorLog(`自定义组件名称不能为空: ${cmpType}`);
+	      return;
+	    }
+	    if (!fs.existsSync(this.assetsRoot)) {
+	      errorLog(`未找到自定义组件资源目录: ${this.assetsRoot}`);
+	      return;
+	    }
+
+	    // 当前组件信息
+	    const curCmpInfo = {
+	      cmpType
+	    };
+
+	    const files = fs.readdirSync(this.assetsRoot); // 读取构建目录下的所有文件
+
+	    // 并行上传所有指定类型的文件
+	    const uploadPromises = files.map(async (file) => {
+	      const filePath = path.join(this.assetsRoot, file);
+	      // 获取文件状态
+	      const fileStat = fs.statSync(filePath);
+	      // 检查文件扩展名
+	      // const fileExt = path.extname(file);
+	      const fileInfo = path.parse(filePath);
+	      if (fileStat.isFile() && fileExtensions.includes(fileInfo.ext)) {
+	        let widgetName = _.camelCase(cmpType);
+
+	        if (file.indexOf(widgetName) < 0) {
+	          return;
+	        }
+
+	        try {
+	          // 上传文件
+	          const fileUrl = await this.uploadFile(filePath);
+
+	          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;
+	          }
+	        } catch (error) {
+	          errorLog(`文件上传失败（${file}）：\n`);
+	          process.exit(1);
+	        }
+	      }
+	    });
+
+	    await Promise.all(uploadPromises);
+
+	    if (curCmpInfo && curCmpInfo.cmpType) {
+	      console.info('上传至 OSS 的文件信息：\n', curCmpInfo);
+	      // 更新发布日志
+	      updatePublishLog$1(curCmpInfo);
+	    }
+	    return curCmpInfo;
+	  }
+
+	  /**
+	   * 处理组件构建产物
+	   *
+	   * @param {object} cmpType 自定义组件名称
+	   * @param {array} fileExtensions 需要处理的文件类型，默认 ['.js', '.css', '.zip']
+	   */
+	  async getCmpAssets(cmpType, fileExtensions = ['.js', '.css', '.zip']) {
+	    if (!cmpType) {
+	      errorLog(`自定义组件名称不能为空: ${cmpType}`);
+	      return;
+	    }
+	    if (!fs.existsSync(this.assetsRoot)) {
+	      errorLog(`未找到自定义组件资源目录: ${this.assetsRoot}`);
+	      return;
+	    }
+
+	    // 当前组件信息
+	    const curCmpInfo = {
+	      cmpType
+	    };
+
+	    const files = fs.readdirSync(this.assetsRoot); // 读取构建目录下的所有文件
+
+	    // 处理构建产物目录下所有指定类型的文件
+	    files.forEach((file) => {
+	      const filePath = path.join(this.assetsRoot, file);
+	      // 获取文件状态
+	      const fileStat = fs.statSync(filePath);
+	      // 检查文件扩展名
+	      // const fileExt = path.extname(file);
+	      const fileInfo = path.parse(filePath);
+	      if (fileStat.isFile() && fileExtensions.includes(fileInfo.ext)) {
+	        let widgetName = _.camelCase(cmpType);
+
+	        if (file.indexOf(widgetName) < 0) {
+	          return;
+	        }
+
+	        // 检查文件大小
+	        const maxSize = 5 * 1024 * 1024; // 默认 5MB
+	        if (fileStat.size > maxSize) {
+	          const sizeMB = (fileStat.size / 1024 / 1024).toFixed(2);
+	          const maxSizeMB = (maxSize / 1024 / 1024).toFixed(2);
+	          throw new Error(`${file} 文件大小超过限制: ${sizeMB}MB > ${maxSizeMB}MB`);
+	        }
+
+	        const fileContent = fs.createReadStream(filePath);
+	        const fileInfo = {
+	          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 curCmpInfo;
+	  }
+
+	  /**
+	   * 更新自定义组件
+	   * @param {object} componentData 组件数据
+	   * @returns {Promise<object>} 更新结果
+	   */
+	  async updateCustomComponent(componentData) {
+	    // 确保 token 有效
+	    const token = await this.ensureValidToken();
+
+	    if (!componentData) {
+	      throw new Error('componentData 不能为空');
+	    }
+
+	    const spinner = ora('正在保存自定义组件信息...').start();
+
+	    try {
+	      const fullUpdateAPI = this.saveAPI();
+
+	      // 创建 FormData
+	      const 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'])));
+
+	      const response = await axios.post(fullUpdateAPI, formData, {
+	        headers: {
+	          Authorization: `Bearer ${token}`,
+	          'xsy-inner-source': 'bff',
+	          // 无需手动设置 Content-Type，formData.getHeaders() 会自动设置正确的 multipart/form-data 和 boundary
+	          ...formData.getHeaders()
+	        },
+	        timeout: 120000, // 默认 60 秒
+	        // 确保 axios 正确处理大文件和流
+	        maxContentLength: Infinity, // 不限制响应内容长度
+	        maxBodyLength: Infinity // 不限制请求体长度（适用于文件上传）
+	      });
+	      const { code, message } = response.data || {};
+
+	      if (code && code !== 200) {
+	        errorLog(`保存自定义组件信息失败: ${response.data.message || '未知错误'}`);
+	        process.exit(1);
+	      }
+
+	      spinner.clear();
+	      spinner.stop();
+	    } catch (error) {
+	      if (error.message) {
+	        errorLog(`保存自定义组件信息失败: ${error.message}`, spinner);
+	      } else {
+	        errorLog(`保存自定义组件信息失败: ${JSON.stringify(error)}`, spinner);
+	      }
+	      process.exit(1);
+	    }
+	  }
+
+	  /**
+	   * 获取线上自定义组件列表
+	   * @returns {Promise<array>} 自定义组件列表
+	   */
+	  async getCustomCmpList() {
+	    // 确保 token 有效
+	    const token = await this.ensureValidToken();
+
+	    /*
+	    // 如果自定义组件列表已存在，则直接返回
+	    if (this.cmpList && this.cmpList.length > 0) {
+	      return this.cmpList;
+	    }
+	    */
+
+	    try {
+	      let queryAllAPI = this.buildFullUrl(NeoCrmAPI.queryAll);
+	      queryAllAPI += `&fields=${cmpFields.join(',')}`;
+	      const response = await axios.get(
+	        queryAllAPI,
+	        {
+	          headers: {
+	            Authorization: `Bearer ${token}`,
+	            'xsy-inner-source': 'bff',
+	            'Content-Type': 'application/json'
+	          }
+	        }
+	      );
+	      const { code, message } = response.data || {};
+
+	      if (code && code !== 200) {
+	        errorLog(`获取自定义组件列表失败: ${message || '未知错误'}`);
+	        process.exit(1);
+	      }
+
+	      this.updateCustomCmpList(response.data.data || []);
+	    } catch (error) {
+	      if (error.message) {
+	        errorLog(`获取自定义组件列表失败: ${error.message}`);
+	      } else {
+	        errorLog(`响应数据: ${JSON.stringify(error)}`);
+	      }
+	      process.exit(1);
+	    }
+
+	    return this.cmpList || [];
+	  }
+
+	  /**
+	   * 获取自定义组件源码文件地址
+	   * @param {string} cmpType 自定义组件名称
+	   * @returns {string} 源码文件地址
+	   */
+	  getCodeLibByCmpType(cmpType) {
+	    if (!cmpType) {
+	      return null;
+	    }	    return this.buildFullUrl(NeoCrmAPI.getCodeLibAPI(cmpType));
+	  }
+
+	  
+
+	  /**
+	   * 删除自定义组件
+	   * @param {*} cmpType 自定义组件类型
+	   * @returns {Promise<object>} 删除结果
+	   */
+	  async deleteCmp(cmpType) {
+	    // 确保 token 有效
+	    const token = await this.ensureValidToken();
+
+	    if (!cmpType) {
+	      errorLog('自定义组件名称不能为空。');
+	      process.exit(1);
+	    }
+
+	    let fullDeleteAPI = this.buildFullUrl(NeoCrmAPI.delete);
+	    fullDeleteAPI += `/${cmpType}`;
+
+	    const response = await axios.delete(fullDeleteAPI, {
+	      headers: {
+	        Authorization: `Bearer ${token}`,
+	        'xsy-inner-source': 'bff',
+	        'Content-Type': 'application/json'
+	      }
+	    });
+	    const { code, message } = response.data || {};
+
+	    if (code && code !== 200) {
+	      errorLog(`删除自定义组件失败: ${message || '未知错误'}`);
+	      process.exit(1);
+	    }
+
+	    return response.data;
+	  }
+
+	  // 获取指定框架的自定义组件列表
+	  getCmpListByFramework(framework) {
+	    if (!framework) {
+	      return this.cmpList;
+	    }
+	    const curFramework = getFramework(framework);
+	    return this.cmpList.filter((cmp) => cmp.framework === curFramework);
+	  }
+
+	  // 获取自定义组件信息
+	  getCmpInfoByCmpType(cmpType) {
+	    if (!cmpType) {
+	      return null;
+	    }
+	    return this.cmpInfoMap[cmpType] || null;
+	  }
+
+	  // 更新自定义组件 Map
+	  updateCustomCmpList(cmpList) {
+	    if (!cmpList || !Array.isArray(cmpList)) {
+	      return;
+	    }
+	    this.cmpList = cmpList;
+	    cmpList.forEach((cmp) => {
+	      this.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>} 响应数据
+	   */
+	  async request(method, api, options = {}) {
+	    // 确保 token 有效
+	    const token = await this.ensureValidToken();
+
+	    const { data, headers = {}, params } = options;
+	    const fullAPI = this.buildFullUrl(api);
+
+	    try {
+	      const response = await axios({
+	        method,
+	        url: fullAPI,
+	        data,
+	        params,
+	        headers: {
+	          Authorization: `Bearer ${token}`,
+	          'xsy-inner-source': 'bff',
+	          ...headers
+	        }
+	      });
+
+	      if (response.data && response.data.code && response.data.code !== 200) {
+	        throw new Error(`请求失败: ${response.data.message || '未知错误'}`);
+	      }
+
+	      return response.data;
+	    } catch (error) {
+	      errorLog(`请求失败 [${method} ${api}]: ${error.message}`);
+	      if (error.response) {
+	        errorLog(`响应数据: ${JSON.stringify(error.response.data)}`);
+	      }
+	      throw error;
+	    }
+	  }
+
+	  /**
+	   * GET 请求
+	   * @param {string} api API 地址
+	   * @param {object} options 请求选项
+	   * @returns {Promise<object>} 响应数据
+	   */
+	  async get(api, options = {}) {
+	    return await this.request('GET', api, options);
+	  }
+
+	  /**
+	   * POST 请求
+	   * @param {string} api API 地址
+	   * @param {object} options 请求选项
+	   * @returns {Promise<object>} 响应数据
+	   */
+	  async post(api, options = {}) {
+	    return await this.request('POST', api, options);
+	  }
+
+	  /**
+	   * PUT 请求
+	   * @param {string} api API 地址
+	   * @param {object} options 请求选项
+	   * @returns {Promise<object>} 响应数据
+	   */
+	  async put(api, options = {}) {
+	    return await this.request('PUT', api, options);
+	  }
+
+	  /**
+	   * DELETE 请求
+	   * @param {string} api API 地址
+	   * @param {object} options 请求选项
+	   * @returns {Promise<object>} 响应数据
+	   */
+	  async delete(api, options = {}) {
+	    return await this.request('DELETE', api, options);
+	  }
+	}
+
+	neoService = NeoService;
+	return neoService;
+}
+
+exports.__require = requireNeoService;