neo-cmp-cli 1.6.0-beta.8 → 1.6.1-beta.1

package/LICENSE

@@ -0,0 +1,4 @@
+MIT License
+
+Copyright (c) 2024 wibetter
+

package/README.md

@@ -8,12 +8,12 @@ neo-cmp-cli 是 Neo 自定义组件开发工具，基于 [AKFun](https://github.
 - **灵活可配**: 支持 构建入口、别名、代理、SASS 注入、ESLint/StyleLint、Babel/Loader/Plugin 扩展等配置；
 - **样式与规范**: 内置 Autoprefixer、Sass、PostCSS、ESLint、StyleLint；
 - **发布至 CDN**: 内置发布到对象存储（OSS）的能力，支持自定义对象存储配置；
-- **发布至 NeoCRM 平台**: 支持一键发布到NeoCRM 平台的能力，需自行补充授权配置；
+- **发布至 NeoCRM 平台**: 支持一键发布到NeoCRM 平台的能力，需自行补充授权配置。
 
 ### 内置的自定义组件模板
 创建自定义组件时（执行初始化命令 neo init）可选用。
-- **React 模板**: [react-custom-cmp-template](https://github.com/wibetter/react-custom-cmp-template) 
 - **React + TS 模板**: [react-ts-custom-cmp-template](https://github.com/wibetter/react-ts-custom-cmp-template) 内置信息卡片列表展示组件示例
+- **React 模板(非 TS)**: [react-custom-cmp-template](https://github.com/wibetter/react-custom-cmp-template) 
 - **Antd 模板**: [antd-custom-cmp-template](https://github.com/wibetter/antd-custom-cmp-template) 内置 Antd UI 组件实现的数据仪表板展示组件示例
 - **Neo 模板**: [neo-custom-cmp-template](https://github.com/wibetter/neo-custom-cmp-template) 支持使用平台实体数据源（内置平台实体数据对象的增删改查示例组件）
 - **Echarts 模板**: [echarts-custom-cmp-template](https://github.com/wibetter/echarts-custom-cmp-template) Echarts 图表自定义组件（含 高德地图展示组件示例）
@@ -63,10 +63,10 @@ neo linkDebug
 需在NeoCRM / 页面设计器端启动 debug 模式，并添加控制台输出的外链脚本地址，方可在页面设计器端使用当前自定义组件。
 
 #### 7) 构建并发布到 NeoCRM
-```bash
-neo pushCmp
-```
-##### 需自行添加授权配置，并确保 package.json 的 name 唯一、version 不重复。
+执行 `neo pushCmp` 即可构建并发布自定义组件至 NeoCRM 平台。  
+**发布前请确保**：`package.json` 的 `name` 唯一、`version` 不重复，并已配置 NeoCRM 平台授权信息。
+
+##### 需自行添加授权配置
 ```javascript
 module.exports = {
   neoConfig: {
@@ -86,9 +86,7 @@ module.exports = {
   },
 }
 ```
-1、客户端 ID 和 客户端秘钥 需通过 创建连接器 获取，获取方式见：[https://doc.xiaoshouyi.com](https://doc.xiaoshouyi.com) / 创建连接器；
-2、如何获取 安全令牌 见：[https://doc.xiaoshouyi.com](https://doc.xiaoshouyi.com) / OAuth安全认证 / 密码模式 / 获取令牌；
-3、发布成功后即可在 NeoCRM 对应租户环境的页面设计器和表单设计器中使用此自定义组件。
+**详细使用说明**：请参考下方「[发布自定义组件至 NeoCRM](#6发布自定义组件至-neocrm)」章节。
 
 ## 常用命令说明
 - **neo init**: 交互式创建自定义组件（支持 -t、--name）;
@@ -97,7 +95,9 @@ module.exports = {
 - **neo preview**: 本地预览自定义组件内容（支持 --name），默认支持热更新与接口代理;
 - **neo linkDebug**: 外链调试模式，在平台端页面设计器中调试自定义组件;
 - **neo publish2oss**: 构建并上传到对象存储（支持 --name，可自定义配置对象存储）;
-- **neo pushCmp**: 构建并发布到NeoCRM平台（支持 --name，需自行添加授权配置）。
+- **neo pushCmp**: 构建并发布到NeoCRM平台（支持 --name，需自行添加授权配置）；
+- **neo pullCmp**: 拉取线上自定义组件（NeoCRM平台）至当前项目（支持 --name，需自行添加授权配置）；
+- **neo deleteCmp**: 删除线上自定义组件（NeoCRM平台）（支持 --name，需自行添加授权配置）。
 
 ## 开发须知
 #### 1）默认自动识别自定义组件
@@ -153,11 +153,26 @@ neo linkDebug
 #### 6）发布自定义组件至 NeoCRM
 执行 `neo pushCmp` 即可构建并发布自定义组件至 NeoCRM 平台，其构建后资源也会上传到 NeoCRM 平台端提供的 CDN 中。  
 
+##### 使用方式
+```bash
+# 方式一：交互式选择要发布的自定义组件
+neo pushCmp
+
+# 方式二：直接指定要发布的自定义组件名称
+neo pushCmp --name=xxCmp
+# 或
+neo pushCmp -n xxCmp
+```
+
 ##### 发布前请确保
-- **package.json 的 name 唯一**
-- **version 不重复**
+- **package.json 的 name 唯一**：确保当前项目的 `package.json` 中的 `name` 字段在 NeoCRM 平台中唯一
+- **version 不重复**：每次发布时，请更新 `package.json` 中的 `version` 字段，确保版本号不重复
+- **已配置 NeoCRM 平台授权信息**：在 `neo.config.js` 中配置 `neoConfig.auth`
+- **自定义组件已正确构建**：确保组件代码可以正常构建，且 `dist` 目录下有对应的构建产物
+- **组件模型文件存在**：确保组件目录下有 `model.ts` 或 `model.js` 文件，且正确导出了模型类
 
 ##### 需自行添加授权配置
+在项目根目录的 `neo.config.js` 文件中添加 NeoCRM 平台授权配置：
 ```javascript
 module.exports = {
   neoConfig: {
@@ -181,13 +196,87 @@ module.exports = {
 }
 ```
 
-##### 支持发布指定自定义组件
-执行 `neo pushCmp --name=xxCmp`
+##### 授权配置获取方式
+1. **客户端 ID 和客户端秘钥**：需通过创建连接器获取
+   - 访问 [销售易文档中心](https://doc.xiaoshouyi.com) / 创建连接器
+   - 创建连接器后，从客户端信息中获取 `Client_Id` 和 `Client_Secret`
+2. **安全令牌**：如何获取安全令牌
+   - 访问 [销售易文档中心](https://doc.xiaoshouyi.com) / OAuth安全认证 / 密码模式 / 获取令牌
+   - 按照文档说明获取 8 位安全令牌
+   - `password` 字段 = 用户账户密码 + 8 位安全令牌（直接拼接，无空格或分隔符）
+
+##### 注意事项
+- **版本管理**：每次发布前务必更新 `package.json` 中的 `version` 字段，避免版本冲突
+- **组件名称唯一性**：确保 `package.json` 中的 `name` 字段在平台中唯一
+- **模型文件要求**：组件必须包含有效的模型文件（`model.ts` 或 `model.js`），且正确导出模型类
+- **技术栈一致性**：确保组件使用的技术栈与项目配置一致（React、React+TS、Vue2 等）
+- **构建产物完整性**：确保 `dist` 目录下包含组件的 JS 文件和模型文件（`xxCmp.js` 和 `xxCmpModel.js`）
+- **网络连接**：发布过程需要网络连接，确保可以访问 NeoCRM 平台和 OSS 服务
+
+##### 常见问题
+
+**Q: 发布失败，提示"未找到 NeoCRM 平台授权配置"**  
+A: 请检查 `neo.config.js` 文件中是否配置了 `neoConfig.auth`，确保所有授权字段都已正确填写。
+
+**Q: 发布失败，提示"未找到自定义组件模型文件"**  
+A: 请确保组件目录下有 `model.ts` 或 `model.js` 文件，且构建后在 `dist` 目录下生成了对应的 `xxCmpModel.js` 文件。
+
+**Q: 发布失败，提示"获取 token 失败（授权配置错误）"**  
+A: 请检查 `neo.config.js` 文件中是否配置了 `neoConfig.auth`，确保所有授权字段都已正确填写。
 
 ##### 线上 NeoCRM 端使用
 发布成功后，即可在对应租户环境下的页面设计器和表单设计器中使用此自定义组件。
 
-#### 7）发布自定义组件至CDN
+#### 7）拉取线上自定义组件至本地项目
+执行 `neo pullCmp` 即可从 NeoCRM 平台拉取自定义组件源码到当前项目。  
+该命令会将线上自定义组件的源码下载并解析到当前项目的 `src/components` 目录下。
+
+##### 使用方式
+```bash
+# 方式一：交互式选择要拉取的自定义组件
+neo pullCmp
+
+# 方式二：直接指定要拉取的自定义组件名称
+neo pullCmp --name=xxCmp
+# 或
+neo pullCmp -n xxCmp
+```
+
+##### 拉取前请确保
+- **已配置 NeoCRM 平台授权信息**（neo.config.js 中的 neoConfig.auth）
+- **当前项目目录中不存在同名自定义组件**（`./src/components` 目录下）
+- **拉取的组件与当前项目技术栈一致**（React、React+TS、Vue2 等）
+
+##### 注意事项
+- 拉取的自定义组件会覆盖本地同名组件，请谨慎操作
+- 如果组件源码中包含新增的依赖包，拉取完成后会提示执行 `npm install` 或 `yarn install`
+- zip 源文件会保留在 `.neo-cli/zip-source` 目录下，可手动删除
+
+#### 8）删除线上自定义组件
+执行 `neo deleteCmp` 即可从 NeoCRM 平台删除指定的自定义组件。  
+该命令会删除平台上的自定义组件，删除后该组件将无法在页面设计器和表单设计器中使用。
+
+##### 使用方式
+```bash
+# 方式一：交互式选择要删除的自定义组件
+neo deleteCmp
+
+# 方式二：直接指定要删除的自定义组件名称
+neo deleteCmp --name=xxCmp
+# 或
+neo deleteCmp -n xxCmp
+```
+
+##### 删除前请确保
+- **已配置 NeoCRM 平台授权信息**（neo.config.js 中的 neoConfig.auth）
+- **确认要删除的组件名称正确**，删除操作不可恢复
+
+##### 注意事项
+- **删除操作不可恢复**：删除后的自定义组件将无法恢复，请谨慎操作
+- **影响范围**：删除组件后，所有使用该组件的页面和表单将受到影响，请确保没有正在使用的场景
+- **建议先备份**：删除前建议先使用 `neo pullCmp` 拉取组件源码到本地进行备份
+
+#### 9）发布自定义组件至CDN
 执行 `neo publish2oss` 即可构建对应自定义组件，并自动将构建后资源上传到对象存储（OSS）中。  
 备注：请优先使用 neo pushCmp。
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neo-cmp-cli",
-  "version": "1.6.0-beta.8",
+  "version": "1.6.1-beta.1",
   "description": "前端脚手架：自定义组件开发工具，支持react 和 vue2.0技术栈。",
   "keywords": [
     "neo-cli",

package/src/module/index.js

@@ -252,15 +252,15 @@ yargs
       } else {
         // 创建 neoService 实例
         const neoService = new NeoService(curConfig.neoConfig);
-        const spinner = ora('正在获取自定义组件列表...').start();
+        const spinner = ora('正在拉取线上自定义组件列表...').start();
         const cmpList = await neoService.getCustomCmpList();
         if (cmpList.length === 0) {
           console.error('当前租户暂无任何自定义组件。');
           process.exit(1);
         }
-        spinner.succeed('自定义组件列表获取成功。');
+        spinner.stop('线上自定义组件列表拉取成功。');
         const cmpTypeChoices = cmpList.map((cmpItem) => ({
-          name: cmpItem.label,
+          name: `${cmpItem.label}（${cmpItem.cmpType}）`,
           value: cmpItem.cmpType
         }));
         const questions = [
@@ -282,6 +282,55 @@ yargs
       }
     }
   )
+  .command(
+    'deleteCmp [options]',
+    '删除线上自定义组件',
+    (yargs) => {
+      yargs
+        .reset()
+        .usage(titleTip('Usage') + ': $0 deleteCmp [options]')
+        .option('name', {
+          alias: 'n',
+          describe: '自定义组件名称'
+        })
+        .alias('h', 'help');
+    },
+    async (argv) => {
+      if (argv.name) {
+        mainAction.deleteCmp(argv.name);
+      } else {
+        // 创建 neoService 实例
+        const neoService = new NeoService(curConfig.neoConfig);
+        const spinner = ora('正在获取线上自定义组件列表...').start();
+        const cmpList = await neoService.getCustomCmpList();
+        if (cmpList.length === 0) {
+          console.error('当前租户暂无任何自定义组件。');
+          process.exit(1);
+        }
+        spinner.stop('线上自定义组件列表获取成功。');
+        const cmpTypeChoices = cmpList.map((cmpItem) => ({
+          name: `${cmpItem.label}（${cmpItem.cmpType}）`,
+          value: cmpItem.cmpType
+        }));
+        const questions = [
+          {
+            name: 'cmpType',
+            type: 'list',
+            message: '请选择要删除的自定义组件:',
+            choices: cmpTypeChoices
+          }
+        ];
+        inquirer.prompt(questions).then((ans) => {
+          if (!ans.cmpType) {
+            console.error('自定义组件名称不能为空。');
+            process.exit(1);
+          } else {
+            mainAction.deleteCmp(ans.cmpType, neoService);
+          }
+        });
+      }
+    }
+  )
   .command(
     'preview [options]',
     '预览指定自定义组件（仅预览组件本身内容）',

package/src/module/main.js

@@ -17,6 +17,7 @@ const createCommonModulesCode = require('../utils/cmpUtils/createCommonModulesCo
 const createCmpByTemplate = require('../utils/cmpUtils/createCmpByTemplate');
 const createCmpProjectByTemplate = require('../utils/projectUtils/createCmpProjectByTemplate');
 const pullCmp = require('../utils/cmpUtils/pullCmp');
+const deleteCmp = require('../utils/cmpUtils/deleteCmp');
 
 const getValue = (originValue, defaultValue) => {
   return originValue !== undefined ? originValue : defaultValue;
@@ -263,5 +264,9 @@ module.exports = {
   pullCmp: (cmpType, neoService) => {
     pullCmp(cmpType, curConfig.neoConfig, neoService);
   },
+  // 从 NeoCRM 平台删除组件
+  deleteCmp: (cmpType, neoService) => {
+    deleteCmp(cmpType, curConfig.neoConfig, neoService);
+  },
   build2esm: (fileName) => akfun.build2esm(fileName, curConfig, consoleTag) // 构建esm输出模块
 };

package/src/neo/neoService.js

@@ -16,7 +16,8 @@ const NeoCrmAPI = {
   delete: '/rest/metadata/v3.0/ui/customComponents',
   query: '/rest/metadata/v3.0/ui/customComponents/actions/queryCustomComponents', // 带分页
   queryAll: '/rest/metadata/v3.0/ui/customComponents/actions/queryAllCustomComponents', // 不带分页
-  saveAPI: '/rest/metadata/v3.0/ui/customComponents/actions/saveOrUpdateComponent' // 创建或者保存接口地址
+  saveAPI: '/rest/metadata/v3.0/ui/customComponents/actions/saveOrUpdateComponent', // 创建或者保存接口地址
+  deleteAPI: '/rest/metadata/v3.0/ui/customComponents'
 };
 
 const cmpFields = [
@@ -157,9 +158,11 @@ class NeoService {
         token: access_token,
         expiresAt: Date.now() + (expiresIn - 60) * 1000
       };
-      spinner.succeed('token 获取成功。');
+      spinner.clear();
+      spinner.stop();
       return access_token;
     } catch (error) {
+      spinner.fail('获取 token 失败');
       console.error('\n获取 token 失败:', error.message);
       console.error('\ntoken 授权地址:', tokenUrl);
       console.error('\ntoken 请求参数:', formData);
@@ -193,9 +196,14 @@ class NeoService {
       return await this.getToken();
     } else if (this.isTokenExpired()) {
       const spinner = ora('token 已过期，正在刷新...').start();
-      const token = await this.refreshToken();
-      spinner.succeed('token 刷新成功。');
-      return token;
+      try {
+        const token = await this.refreshToken();
+        spinner.succeed('token 刷新成功。');
+        return token;
+      } catch (error) {
+        spinner.fail('token 刷新失败。');
+        throw error;
+      }
     }
     return this.tokenCache.token;
   }
@@ -458,7 +466,8 @@ class NeoService {
         throw new Error(`更新组件失败: ${response.data.message || '未知错误'}`);
       }
 
-      spinner.succeed('组件更新成功。');
+      spinner.clear();
+      spinner.stop();
     } catch (error) {
       spinner.fail('更新组件失败。');
       if (error.message) {
@@ -519,6 +528,38 @@ class NeoService {
 
     return this.cmpList || [];
   }
+  
+  /**
+   * 删除自定义组件
+   * @param {*} cmpType 自定义组件类型
+   * @returns {Promise<object>} 删除结果
+   */
+  async deleteCustomComponent(cmpType) {
+    // 确保 token 有效
+    const token = await this.ensureValidToken();
+
+    if (!cmpType) {
+      throw new Error('自定义组件名称不能为空。');
+    }
+
+    let fullDeleteAPI = this.buildFullUrl(NeoCrmAPI.deleteAPI);
+    fullDeleteAPI += `?cmpType=${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) {
+      throw new Error(`删除自定义组件失败: ${message || '未知错误'}`);
+    }
+
+    return response.data;
+  }
 
   // 获取指定框架的自定义组件列表
   getCmpListByFramework(framework) {

package/src/template/antd-custom-cmp-template/package.json

@@ -48,7 +48,7 @@
     "@commitlint/config-conventional": "^9.1.1",
     "@types/react": "^16.9.11",
     "@types/react-dom": "^16.9.15",
-    "neo-cmp-cli": "^1.5.6",
+    "neo-cmp-cli": "^1.6.1",
     "husky": "^4.2.5",
     "lint-staged": "^10.2.9",
     "prettier": "^2.0.5"

package/src/template/echarts-custom-cmp-template/package.json

@@ -48,7 +48,7 @@
     "@commitlint/config-conventional": "^9.1.1",
     "@types/react": "^16.9.11",
     "@types/react-dom": "^16.9.15",
-    "neo-cmp-cli": "^1.5.6",
+    "neo-cmp-cli": "^1.6.1",
     "husky": "^4.2.5",
     "lint-staged": "^10.2.9",
     "prettier": "^2.0.5",

package/src/template/empty-custom-cmp-template/package.json

@@ -46,7 +46,7 @@
     "@commitlint/config-conventional": "^9.1.1",
     "@types/react": "^16.9.11",
     "@types/react-dom": "^16.9.15",
-    "neo-cmp-cli": "^1.5.6",
+    "neo-cmp-cli": "^1.6.1",
     "husky": "^4.2.5",
     "lint-staged": "^10.2.9",
     "prettier": "^2.0.5"

package/src/template/react-custom-cmp-template/package.json

@@ -45,7 +45,7 @@
   "devDependencies": {
     "@commitlint/cli": "^8.3.5",
     "@commitlint/config-conventional": "^9.1.1",
-    "neo-cmp-cli": "^1.5.6",
+    "neo-cmp-cli": "^1.6.1",
     "husky": "^4.2.5",
     "lint-staged": "^10.2.9",
     "prettier": "^2.0.5"

package/src/template/react-ts-custom-cmp-template/package.json

@@ -47,7 +47,7 @@
     "@commitlint/config-conventional": "^9.1.1",
     "@types/react": "^16.9.11",
     "@types/react-dom": "^16.9.15",
-    "neo-cmp-cli": "^1.5.6",
+    "neo-cmp-cli": "^1.6.1",
     "husky": "^4.2.5",
     "lint-staged": "^10.2.9",
     "prettier": "^2.0.5"

package/src/template/vue2-custom-cmp-template/package.json

@@ -45,7 +45,7 @@
   "devDependencies": {
     "@commitlint/cli": "^8.3.5",
     "@commitlint/config-conventional": "^9.1.1",
-    "neo-cmp-cli": "^1.5.6",
+    "neo-cmp-cli": "^1.6.1",
     "husky": "^4.2.5",
     "lint-staged": "^10.2.9",
     "prettier": "^2.0.5",

package/src/utils/cmpUtils/createCmpByZip.js

@@ -3,10 +3,86 @@ const path = require('path');
 const axios = require('axios');
 const ora = require('ora');
 const AdmZip = require('adm-zip');
+const _ = require('lodash');
 const { consoleTag } = require('../neoParams'); // 输出标记
 const hasCmpTypeByDir = require('./hasCmpTypeByDir');
 const hasNeoProject = require('../projectUtils/hasNeoProject');
 
+/**
+ * 将配置对象格式化为 JavaScript 代码字符串
+ * @param {*} obj 配置对象
+ * @param {number} indent 缩进级别
+ * @param {string} fileDir 配置文件所在目录路径，用于将绝对路径转换回相对路径（resolve() 基于 __dirname）
+ * @returns {string} 格式化后的字符串
+ */
+function formatConfigObject(obj, indent = 0, fileDir = '') {
+  const indentStr = '  '.repeat(indent);
+  const nextIndentStr = '  '.repeat(indent + 1);
+
+  if (obj === null) {
+    return 'null';
+  }
+
+  if (obj === undefined) {
+    return 'undefined';
+  }
+
+  if (typeof obj === 'string') {
+    // 尝试将绝对路径转换回 resolve() 调用
+    if (fileDir && path.isAbsolute(obj)) {
+      try {
+        const relativePath = path.relative(fileDir, obj).replace(/\\/g, '/');
+        // 如果路径看起来像是通过 resolve() 生成的，转换回 resolve() 调用
+        // 排除包含 .. 的路径（这些可能是外部路径）
+        if (relativePath && !relativePath.startsWith('..') && relativePath !== '') {
+          // 确保路径使用正斜杠，并添加 ./ 前缀（如果需要）
+          const normalizedPath = relativePath.startsWith('.') ? relativePath : './' + relativePath;
+          return `resolve(${JSON.stringify(normalizedPath)})`;
+        }
+      } catch (e) {
+        // 如果路径转换失败，继续使用原始字符串
+      }
+    }
+    // 检查是否包含 resolve() 或 auth. 调用（从原始文件中提取的）
+    if (obj.includes('resolve(') || obj.includes('auth.')) {
+      return obj;
+    }
+    // 转义字符串中的特殊字符
+    return JSON.stringify(obj);
+  }
+
+  if (typeof obj === 'number' || typeof obj === 'boolean') {
+    return String(obj);
+  }
+
+  if (Array.isArray(obj)) {
+    if (obj.length === 0) {
+      return '[]';
+    }
+    const items = obj.map((item) => {
+      const formatted = formatConfigObject(item, indent + 1, fileDir);
+      return nextIndentStr + formatted;
+    });
+    return '[\n' + items.join(',\n') + '\n' + indentStr + ']';
+  }
+
+  if (typeof obj === 'object') {
+    const keys = Object.keys(obj);
+    if (keys.length === 0) {
+      return '{}';
+    }
+    const items = keys.map((key) => {
+      const value = obj[key];
+      const formattedValue = formatConfigObject(value, indent + 1, fileDir);
+      return nextIndentStr + key + ': ' + formattedValue;
+    });
+    return '{\n' + items.join(',\n') + '\n' + indentStr + '}';
+  }
+
+  // 对于函数或其他类型，尝试转换为字符串
+  return String(obj);
+}
+
 /**
  * 从 zip 包中创建自定义组件
  * @param {*} cmpZipUrl 自定义组件源码文件地址（zip包地址）
@@ -14,7 +90,7 @@ const hasNeoProject = require('../projectUtils/hasNeoProject');
  * @param {*} componentBaseDir 自定义组件目录
  */
 module.exports = async function (cmpZipUrl, cmpName, componentBaseDir = './src/components') {
-  const finalCmpName = cmpName || 'neoCustomCmp';
+  const finalCmpName = cmpName;
 
   if (!hasNeoProject()) {
     console.error(
@@ -31,36 +107,75 @@ module.exports = async function (cmpZipUrl, cmpName, componentBaseDir = './src/c
   // 创建临时目录
   const tempDir = path.join(process.cwd(), '.neo-cli', 'zip-source');
 
+  const spinner = ora(`${consoleTag}正在下载组件源码...`).start();
+
   // 下载源码文件并解析到 src/components 目录下
   try {
     await fs.ensureDir(tempDir); // 如果目录不存在，会自动创建（包括所有必要的父目录）
 
-    // 下载 zip 文件
-    const spinner = ora(`${consoleTag}正在下载组件源码...`).start();
     const zipFilePath = path.join(tempDir, `${finalCmpName}.zip`);
 
-    const response = await axios({
-      url: cmpZipUrl,
-      method: 'GET',
-      responseType: 'arraybuffer'
-    });
+    // 检查是否存在同名 zip 包，如果存在则先删除
+    if (await fs.pathExists(zipFilePath)) {
+      await fs.remove(zipFilePath);
+    }
+
+    // 下载 zip 文件
+    let response;
+    try {
+      response = await axios({
+        url: cmpZipUrl,
+        method: 'GET',
+        responseType: 'arraybuffer',
+        timeout: 60000, // 60秒超时
+        maxContentLength: Infinity,
+        maxBodyLength: Infinity
+      });
+    } catch (axiosError) {
+      spinner.fail(`${consoleTag}下载文件失败:`, axiosError.message);
+      throw axiosError;
+    }
 
     // 保存 zip 文件到临时目录
-    await fs.writeFile(zipFilePath, response.data);
+    try {
+      let buffer;
+      // 处理不同的数据类型
+      if (Buffer.isBuffer(response.data)) {
+        // 如果已经是 Buffer，直接使用
+        buffer = response.data;
+      } else if (response.data instanceof ArrayBuffer) {
+        // 如果是 ArrayBuffer，转换为 Buffer
+        buffer = Buffer.from(response.data);
+      } else if (response.data.buffer instanceof ArrayBuffer) {
+        // 如果是 TypedArray (如 Uint8Array)，使用其 buffer
+        buffer = Buffer.from(response.data.buffer);
+      } else {
+        // 尝试直接转换
+        buffer = Buffer.from(response.data);
+      }
+
+      await fs.writeFile(zipFilePath, buffer);
+    } catch (writeError) {
+      spinner.fail(`${consoleTag}读取组件源码文件失败:`, writeError.message);
+      throw writeError;
+    }
 
     // 解压 zip 文件
-    spinner.text(`${consoleTag}正在解压组件源码...`);
+    spinner.info(`${consoleTag}正在解压组件源码...`);
+
     const zip = new AdmZip(zipFilePath);
+    // 解压后的目录名称为组件名称：.neo-cli/zip-source/xxCmp
     const extractPath = path.join(tempDir, finalCmpName);
-    zip.extractAllTo(extractPath, true);
+    zip.extractAllTo(extractPath, true); // 解压到临时目录
 
     // 查找解压后的 src/components 目录
     const cmpSourcePath = path.join(extractPath, componentBaseDir, finalCmpName);
 
     if (!fs.existsSync(cmpSourcePath)) {
-      spinner.stopAndFail(`${consoleTag}解压后的 zip 包中未找到 ${finalCmpName} 组件源码目录。`);
-      await fs.remove(tempDir);
-      process.exit(1);
+      spinner.fail(`${consoleTag}解压后的 zip 包中未找到 ${finalCmpName} 组件源码目录。`);
+      // 只删除解压目录，保留 zip 源文件
+      await fs.remove(extractPath);
+      return false;
     }
 
     // 确保目标目录存在
@@ -68,22 +183,167 @@ module.exports = async function (cmpZipUrl, cmpName, componentBaseDir = './src/c
     await fs.ensureDir(targetComponentsDir);
 
     // 复制 src/components 目录下的所有内容到目标目录
-    await fs
-      .copy(cmpSourcePath, targetComponentsDir)
-      .catch((err) => spinner.stopAndFail(`${consoleTag}自定义组件模板下载失败：`, err));
+    try {
+      await fs.copy(cmpSourcePath, targetComponentsDir);
+    } catch (err) {
+      spinner.fail(`${consoleTag}自定义组件模板下载失败：${err.message || err}`);
+      // 只删除解压目录，保留 zip 源文件
+      await fs.remove(extractPath);
+      return false;
+    }
+
+    // 处理源码中其他文件
+    try {
+      // 标准化 componentBaseDir，去掉开头的 ./ 并统一路径分隔符
+      const normalizedComponentBaseDir = componentBaseDir.replace(/^\.\//, '').replace(/\\/g, '/');
+
+      /**
+       * 递归复制文件，排除 componentBaseDir 目录
+       * @param {string} sourceDir 源目录
+       * @param {string} targetRoot 目标根目录（项目根目录）
+       * @param {string} excludeDir 要排除的目录（相对于源目录）
+       */
+      const copyOtherFiles = async (sourceDir, targetRoot, excludeDir) => {
+        const items = await fs.readdir(sourceDir);
+
+        for (const item of items) {
+          const sourcePath = path.join(sourceDir, item); // 当前源文件路径
+          const stat = await fs.stat(sourcePath); // 当前源文件状态
+          const fileName = path.basename(sourcePath); // 当前源文件名称
+
+          // 计算相对于解压根目录的路径
+          const relativePath = path.relative(extractPath, sourcePath);
+          const normalizedRelativePath = relativePath.replace(/\\/g, '/');
+
+          // 跳过 componentBaseDir 目录及其子目录
+          if (
+            normalizedRelativePath.startsWith(excludeDir + '/') ||
+            normalizedRelativePath === excludeDir
+          ) {
+            continue;
+          }
+
+          const targetPath = path.join(targetRoot, relativePath); // 目标文件路径
+
+          if (stat.isDirectory()) {
+            // 如果是目录，递归处理
+            await copyOtherFiles(sourcePath, targetRoot, excludeDir);
+          } else if (stat.isFile()) {
+            // 如果是文件，检查目标文件是否存在
+            const targetExists = await fs.pathExists(targetPath);
+            if (!targetExists) {
+              // 确保目标目录存在
+              await fs.ensureDir(path.dirname(targetPath));
+              // 复制文件
+              await fs.copy(sourcePath, targetPath);
+            } else if (fileName === 'package.json') {
+              // 处理 package.json 文件（当目标文件已存在时）
+              const sourcePackageJson = await fs.readJson(sourcePath);
+              const targetPackageJson = await fs.readJson(targetPath);
 
-    // 清理临时目录
-    await fs.remove(tempDir);
+              const newPackageJsonDeps = _.omit(
+                sourcePackageJson.dependencies,
+                targetPackageJson.dependencies
+              );
+              const newDeps = Object.keys(newPackageJsonDeps);
+              if (newDeps.length > 0) {
+                console.warn(
+                  `${consoleTag}检测到 package.json 中新增了 ${
+                    newDeps.length
+                  } 个依赖包：${newDeps.join(', ')}`
+                );
+                console.warn(
+                  `${consoleTag}为确保组件正常运行，请执行以下命令安装依赖：npm install 或 yarn install`
+                );
+              }
+              // 合并 package.json：将源文件的配置合并到目标文件中
+              // 注意：_.merge 会修改第一个参数，所以先克隆目标对象
+              const mergedPackageJson = _.merge({}, sourcePackageJson, targetPackageJson);
+              await fs.writeJson(targetPath, mergedPackageJson, { spaces: 2 });
+            } else if (fileName === 'neo.config.js') {
+              // 处理 neo.config.js 文件（当目标文件已存在时）
+              try {
+                // 清除 require 缓存，确保读取最新内容
+                const sourceResolvedPath = require.resolve(sourcePath);
+                const targetResolvedPath = require.resolve(targetPath);
+                delete require.cache[sourceResolvedPath];
+                delete require.cache[targetResolvedPath];
+
+                // 读取源文件和目标文件的原始内容
+                const sourceContent = await fs.readFile(sourcePath, 'utf8');
+                const targetContent = await fs.readFile(targetPath, 'utf8');
+
+                // 读取源文件和目标文件的配置对象（函数调用会被执行）
+                const sourceConfig = require(sourcePath);
+                const targetConfig = require(targetPath);
+
+                // 合并配置：源配置合并到目标配置（目标配置优先级更高）
+                const mergedConfig = _.merge({}, sourceConfig, targetConfig);
+
+                // 提取目标文件的头部（module.exports 之前的内容）
+                const moduleExportMatch = targetContent.match(/^([\s\S]*?)(module\.exports\s*=\s*\{[\s\S]*\};?\s*)$/);
+                let fileHeader = '';
+                if (moduleExportMatch) {
+                  fileHeader = moduleExportMatch[1];
+                } else {
+                  // 如果没有找到 module.exports，尝试提取到最后一个大括号之前的内容
+                  const lastBraceIndex = targetContent.lastIndexOf('module.exports');
+                  if (lastBraceIndex > 0) {
+                    fileHeader = targetContent.substring(0, lastBraceIndex);
+                  } else {
+                    // 如果都没有找到，使用默认头部
+                    fileHeader = "'use strict';\nconst path = require('path');\n\n// 统一路径解析\nfunction resolve(dir) {\n  return path.resolve(__dirname, dir);\n}\n\n";
+                  }
+                }
+
+                // 获取目标文件的目录，用于路径转换（resolve() 基于 __dirname）
+                const targetFileDir = path.dirname(targetPath);
+
+                // 将合并后的配置对象转换为格式化的字符串
+                const configString = formatConfigObject(mergedConfig, 0, targetFileDir);
+
+                // 组合完整的文件内容
+                const mergedContent = fileHeader + 'module.exports = ' + configString + ';\n';
+
+                // 写回文件
+                await fs.writeFile(targetPath, mergedContent, 'utf8');
+              } catch (configError) {
+                spinner.warn(
+                  `${consoleTag}合并 neo.config.js 配置文件时出现警告：${configError.message || configError}`
+                );
+              }
+            } else if (fileName === 'tsconfig.json') {
+              // 处理 tsconfig.json 文件（当目标文件已存在时）
+              const sourceTsconfigJson = await fs.readJson(sourcePath);
+              // 先判断 targetPath 是否存在，如果存在则合并，否则直接写入
+              if (await fs.pathExists(targetPath)) {
+                const targetTsconfigJson = _.merge({}, sourceTsconfigJson, targetTsconfigJson);
+                await fs.writeJson(targetPath, targetTsconfigJson, { spaces: 2 });
+              } else {
+                await fs.writeJson(targetPath, sourceTsconfigJson, { spaces: 2 });
+              }
+            }
+          }
+        }
+      };
+      // 开始处理源码中其他文件
+      await copyOtherFiles(extractPath, process.cwd(), normalizedComponentBaseDir);
+    } catch (err) {
+      spinner.warn(`${consoleTag}处理源码文件出现警告：${err.message || err}`);
+    }
+
+    // 清理解压目录，保留 zip 源文件
+    await fs.remove(extractPath);
     spinner.succeed(`${consoleTag}已成功从 zip 包解析自定义组件（${finalCmpName}）!`);
 
     return true;
   } catch (error) {
-    spinner.stopAndFail(
-      `${consoleTag}从 zip 包创建自定义组件失败（${finalCmpName}）：`,
-      error.message
-    );
-    // 清理临时目录
-    await fs.remove(tempDir);
+    spinner.fail(`${consoleTag}从 zip 包创建自定义组件失败（${finalCmpName}）：`, error);
+    // 清理解压目录，保留 zip 源文件
+    const extractPath = path.join(tempDir, finalCmpName);
+    if (await fs.pathExists(extractPath)) {
+      await fs.remove(extractPath);
+    }
 
     return false;
   }

package/src/utils/cmpUtils/deleteCmp.js

@@ -0,0 +1,63 @@
+const ora = require('ora');
+const NeoService = require('../../neo/neoService');
+
+/**
+ * 从 NeoCRM 删除自定义组件
+ * @param {string} cmpType 自定义组件类型
+ * @param {object} authConfig 授权配置
+ * @param {object} _neoService 可选的 NeoService 实例（用于复用已获取的组件列表）
+ *
+ * 删除流程说明
+ * 1. 获取当前租户下的自定义组件列表
+ * 2. 验证组件是否存在
+ * 3. 调用删除 API 删除组件
+ */
+const deleteCmp = async (cmpType, authConfig, _neoService) => {
+  if (!authConfig) {
+    console.error('未找到 NeoCRM 平台授权配置（neo.config.js / authConfig）。');
+    return;
+  }
+
+  const spinner = ora('正在删除组件...').start();
+
+  try {
+    let neoService = _neoService;
+    let cmpList = [];
+    let cmpInfo = null;
+
+    if (_neoService) {
+      // 使用传入的 neoService 实例
+      cmpList = _neoService.cmpList || [];
+    } else {
+      // 创建新的 neoService 实例
+      neoService = new NeoService(authConfig);
+
+      // 获取自定义组件列表
+      spinner.info('正在获取自定义组件列表...');
+      cmpList = await neoService.getCustomCmpList();
+    }
+
+    if (cmpList.length === 0) {
+      spinner.fail('删除失败，当前租户暂无任何自定义组件。');
+      process.exit(1);
+    }
+
+    // 获取自定义组件信息
+    cmpInfo = neoService.getCmpInfoByCmpType(cmpType);
+    if (!cmpInfo) {
+      spinner.fail(`删除失败，当前租户不存在${cmpType}自定义组件。`);
+      process.exit(1);
+    }
+
+    // 调用删除 API
+    spinner.info(`正在删除${cmpType}自定义组件...`);
+    await neoService.deleteCustomComponent(cmpType);
+    spinner.succeed(`已成功删除${cmpType}自定义组件！\n`);
+  } catch (error) {
+    spinner.fail(`删除自定义组件失败: ${error.message}`);
+    process.exit(1);
+  }
+};
+
+module.exports = deleteCmp;
+

package/src/utils/cmpUtils/pullCmp.js

@@ -16,6 +16,14 @@ const framework = getFramework(currentPackageJson.framework);
  * 从 NeoCRM 拉取自定义组件
  * @param {string} cmpType 自定义组件类型
  * @param {object} authConfig 授权配置
+ *
+ * 拉取流程说明
+ * 1. 获取当前租户下的自定义组件列表
+ * 2. 验证组件是否存在、是否已存在本地、技术栈是否一致
+ * 3. 下载组件源码 zip 包到临时目录（`.neo-cli/zip-source`）
+ * 4. 解压并解析组件源码到 `src/components` 目录
+ * 5. 合并 `package.json` 中的依赖配置（如有新增依赖会提示安装）
+ * 6. 清理解压目录，保留 zip 源文件（便于后续问题排查）
  */
 const pullCmp = async (cmpType, authConfig, _neoService) => {
   if (!authConfig) {
@@ -52,26 +60,26 @@ const pullCmp = async (cmpType, authConfig, _neoService) => {
     }
 
     if (cmpList.length === 0) {
-      spinner.stopAndFail('拉取失败，当前租户暂无任何自定义组件。');
+      spinner.fail('拉取失败，当前租户暂无任何自定义组件。');
       process.exit(1);
     }
 
     // 获取自定义组件信息
     cmpInfo = neoService.getCmpInfoByCmpType(cmpType);
     if (!cmpInfo) {
-      spinner.stopAndFail(`拉取失败，当前租户不存在${cmpType}自定义组件。`);
+      spinner.fail(`拉取失败，当前租户不存在${cmpType}自定义组件。`);
       process.exit(1);
     }
 
     // 判断拉取的组件和当前项目是否为同一技术栈
     if (cmpInfo.framework !== framework) {
-      spinner.stopAndFail(`拉取失败，${cmpType}自定义组件与当前项目技术栈不一致。`);
+      spinner.fail(`拉取失败，${cmpType}自定义组件与当前项目技术栈不一致。`);
       process.exit(1);
     }
 
     // 获取当前源码
     if (!cmpInfo.codeLib) {
-      spinner.stopAndFail(`拉取失败，${cmpType}自定义组件未记录对应的源码文件。`);
+      spinner.fail(`拉取失败，${cmpType}自定义组件未记录对应的源码文件。`);
       process.exit(1);
     }
 
@@ -81,7 +89,7 @@ const pullCmp = async (cmpType, authConfig, _neoService) => {
     // 将zip 包里面的自定义组件源码解析到 src/components 目录下
     const cmpResult = await createCmpByZip(codeLib, cmpType, './src/components');
     if (!cmpResult) {
-      spinner.stopAndFail(`拉取失败，${cmpType}自定义组件源码解析失败，请检查源码文件是否正确。`);
+      spinner.fail(`拉取失败，${cmpType}自定义组件源码解析失败，请检查源码文件是否正确。`);
       process.exit(1);
     }
 

package/src/utils/cmpUtils/pushCmp.js

@@ -82,7 +82,7 @@ const buildComponentData = async (assetsRoot, cmpInfo) => {
       plugin: cmpInfo.modelAsset,
       version: currentPackageJson.version || '1.0.0',
       // 技术栈标识: 从 package.json / framework 字段获取，没有则默认 为 react ts 技术栈
-      framework: currentPackageJson.framework ? getFramework(currentPackageJson.framework) : '0', // 0: React, 1: vue2, 2: jQuery, 3: vue3
+      framework: currentPackageJson.framework ? getFramework(currentPackageJson.framework) : 0, // 0: React, 1: vue2, 2: jQuery, 3: vue3
       // 从模型实例中提取并设置组件信息
       label: modelInstance.label || cmpType,
       description: modelInstance.description || '',
@@ -121,6 +121,12 @@ const buildComponentData = async (assetsRoot, cmpInfo) => {
  * 发布组件到 NeoCRM
  * @param {object} config 配置信息
  * @param {string} cmpType 自定义组件类型
+ *
+ * 发布流程说明
+ * 1. 打包源码文件：将自定义组件源码打包成 zip 文件
+ * 2. 上传构建产物到 OSS：将构建后的资源文件上传到 NeoCRM 平台提供的 CDN
+ * 3. 构建组件数据：从组件模型文件中提取组件信息
+ * 4. 保存组件信息到 NeoCRM 平台：将组件信息保存到平台数据库
  */
 const pushCmp = async (config, cmpType) => {
   const { auth: credentials } = config;

package/src/utils/common.js

@@ -5,7 +5,7 @@ const { consoleTag } = require('./neoParams');
  * 0: React, 1: vue2, 2: jQuery, 3: vue3
  */
 function getFramework(_framework) {
-  let defaultFramework = '0'; // 默认 React 技术栈
+  let defaultFramework = 0; // 默认 React 技术栈
   if (!_framework) {
     return defaultFramework;
   }
@@ -13,32 +13,32 @@ function getFramework(_framework) {
   switch (curFramework) {
     case 'jquery':
     case 'jq':
-      curFramework = '2';
+      curFramework = 2;
       break;
     case 'vue2':
     case 'vue 2':
     case 'vue2.0':
     case 'vue 2.0':
-      curFramework = '1';
+      curFramework = 1;
       break;
     case 'vue':
     case 'vue3':
     case 'vue 3':
     case 'vue3.0':
     case 'vue 3.0':
-      curFramework = '3';
+      curFramework = 3;
       console.error(`${consoleTag} 暂不支持 vue3.0 技术栈。`);
       break;
     case 'react-js':
       console.error(`${consoleTag} 暂不支持 react-js 技术栈。`);
-      curFramework = '0';
+      curFramework = 0;
       break;
     case 'react':
     case 'react-ts':
-      curFramework = '0';
+      curFramework = 0;
       break;
     default:
-      curFramework = '0';
+      curFramework = 0;
   }
   return curFramework;
 }

package/test/demo2.js

@@ -0,0 +1,3 @@
+const createCmpByZip = require('../src/utils/cmpUtils/createCmpByZip');
+
+createCmpByZip('https://publicfront-1253467224.cos.ap-beijing.myqcloud.com/customComponent/crm-cd/tenant/3256219432312412/1762331900697/entityDetailSource.zip', 'entity-detail');