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

package/README.md

@@ -1,14 +1,14 @@
 ## Neo 自定义组件开发工具
-neo-cmp-cli 是 Neo 自定义组件开发工具，基于 [AKFun](https://github.com/wibetter/akfun) 的工程能力，提供 初始化、编译构建、预览调试、热更新、多技术栈支持和一键发布等功能。
+neo-cmp-cli 是 Neo 自定义组件开发工具，基于 [AKFun](https://github.com/wibetter/akfun) 的工程能力，提供 初始化、编译构建、预览调试、热更新、多技术栈支持和发布等功能。
 
 ### 主要特性
 - **零配置**: 内置默认配置，开箱可用；
 - **多技术栈**: 支持 Vue2、React、React+TypeScript 自定义组件的调试、构建与发布；
-- **多构建场景**: 本地预览（含热更新/代理）、外链调试、库构建（UMD/ESM）；
+- **多构建场景**: 本地预览（含热更新/代理）、外链调试、库构建（UMD/ESM）、部署&发布；
 - **灵活可配**: 支持 构建入口、别名、代理、SASS 注入、ESLint/StyleLint、Babel/Loader/Plugin 扩展等配置；
 - **样式与规范**: 内置 Autoprefixer、Sass、PostCSS、ESLint、StyleLint；
-- **参数替换**: 支持基于 [params-replace-loader](https://www.npmjs.com/package/params-replace-loader) 的环境变量批量替换；
-- **一键发布**: 内置发布到 OSS 的能力，并支持自定义对象存储配置。
+- **发布至 CDN**: 内置发布到对象存储（OSS）的能力，支持自定义对象存储配置；
+- **发布至 NeoCRM 平台**: 支持一键发布到NeoCRM 平台的能力，需自行补充授权配置；
 
 ### 内置的自定义组件模板
 创建自定义组件时（执行初始化命令 neo init）可选用。
@@ -40,8 +40,8 @@ neo preview
 # 外链调试（在平台线上预览与调试）
 neo linkDebug
 
-# 构建并发布到 OSS（确保 package.json 的 name 唯一、version 不重复）
-neo publish2oss
+# 构建并发布到 NeoCRM（需自行添加授权配置，并确保 package.json 的 name 唯一、version 不重复）
+neo publish2neo
 ```
 
 ### 方法二：在现有业务项目中使用自定义组件开发工具
@@ -58,7 +58,7 @@ npm i neo-cmp-cli --save-dev
 ```bash
 "preview": "neo preview",
 "linkDebug": "neo linkDebug",
-"publish2oss": "neo publish2oss"
+"publish2neo": "neo publish2neo"
 ```
 ##### 3) 初始化配置文件
 ```bash
@@ -76,6 +76,7 @@ npm run publish2oss
 - **neo preview**: 本地预览自定义组件内容，默认支持热更新与接口代理。
 - **neo linkDebug**: 外链调试模式，在平台端页面设计器中调试自定义组件。
 - **neo publish2oss**: 构建并上传到对象存储（可自定义配置对象存储）。
+- **neo publish2neo**: 构建并发布到NeoCRM平台（需自行添加授权配置）。
 
 ## 开发须知
 #### 1）默认自动识别自定义组件
@@ -128,17 +129,50 @@ neo linkDebug
 ##### 3. 页面设计器开启 debug 模式后，左侧会展示 外部链接 管理面板
 将第 1 步生成的「外链脚本地址」添加进来，即可在此页面设计器 / 组件物料面板中看到对应自定义组件。
 
-#### 6）发布自定义组件
-执行 `neo publish2oss` 即可构建对应自定义组件，并自动将构建后资源上传到对象存储（OSS）中。  
+#### 6）发布自定义组件至 NeoCRM
+执行 `neo publish2neo` 即可构建并发布自定义组件至 NeoCRM 平台，其构建后资源也会上传到 NeoCRM 平台端提供的 CDN 中。  
 
 ##### 发布前请确保
 - **package.json 的 name 唯一**
 - **version 不重复**
-- 已按需配置对象存储参数（支持自定义）
+
+##### 需自行添加授权配置
+```javascript
+module.exports = {
+  publishCmp: {
+    neoBaseURL: 'https://crm-cd.xiaoshouyi.com', // 平台根地址（默认：https://crm.xiaoshouyi.com）
+    tokenAPI: 'https://login-cd.xiaoshouyi.com/auc/oauth2/token', // Token 获取接口地址（默认：https://login.xiaoshouyi.com/auc/oauth2/token）
+    // NeoCRM 授权配置
+    authorization: {
+      /**
+       * 客户端 ID 和 客户端秘钥 需通过 创建连接器 获取，
+       * 详细见：https://doc.xiaoshouyi.com / 创建连接器。
+       */
+      client_id: 'xx', // 客户端 ID，从创建连接器的客户端信息中获取（Client_Id）
+      client_secret: 'xxx', // 客户端秘钥，从创建连接器的客户端信息中获取（Client_Secret）
+      username: 'xx', // 用户在销售易系统中的用户名
+      /**
+       * password 为 用户在销售易系统中的账号密码加上 8 位安全令牌。
+       * 例如，用户密码为 123456，安全令牌为 ABCDEFGH，则 password 的值应为 123456ABCDEFGH。
+       * 如何获取 安全令牌请见：https://doc.xiaoshouyi.com / OAuth安全认证 / 密码模式 / 获取令牌。
+       */
+      password: 'xx xx' // 用户账户密码 + 8 位安全令牌
+    },
+  },
+}
+```
 
 ##### 支持发布指定自定义组件
 执行 `neo publish2oss --cmpType=xxCmp`
 
+#### 7）发布自定义组件至CDN
+执行 `neo publish2oss` 即可构建对应自定义组件，并自动将构建后资源上传到对象存储（OSS）中。  
+
+##### 发布前请确保
+- **package.json 的 name 唯一**
+- **version 不重复**
+- 可按需配置对象存储参数（支持自定义），默认使用内置对象存储配置。
+
 ##### 支持自定义对象存储配置
 ```javascript
 module.exports = {
@@ -159,6 +193,9 @@ module.exports = {
 }
 ```
 
+##### 支持发布指定自定义组件
+执行 `neo publish2oss --cmpType=xxCmp`
+
 ## 项目工程配置说明（neo.config.js）
 neo-cmp-cli 默认提供完整配置； 
 如需自定义，使用 `neo config init` 生成 `neo.config.js` 并按需修改。

package/package.json

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

package/src/cmpUtils/getCmpTypeByDir.js

@@ -0,0 +1,41 @@
+const fs = require('fs');
+const path = require('path');
+const { resolveToCurrentRoot } = require('../utils/pathUtils');
+/**
+ * 根据当前组件目录，获取所有组件类型
+ * @param {*} componentsBaseDir 自定义组件目录
+ * @returns 组件类型列表
+ */
+const getCmpTypeByDir = (componentsBaseDir = './src/components') => {
+  const componentsDir = resolveToCurrentRoot(componentsBaseDir);
+  if (!fs.existsSync(componentsDir)) {
+    console.error(`未找到自定义组件目录，请检查 ${componentsDir} 目录是否存在。`);
+    // 退出进程
+    process.exit(1);
+  }
+
+  try {
+    // 读取组件目录下的所有子目录
+    const dirs = fs.readdirSync(componentsDir);
+    const cmpTypes = [];
+
+    // 遍历所有目录，过滤出有效的组件类型
+    dirs.forEach((dir) => {
+      const dirPath = path.join(componentsDir, dir);
+      const stat = fs.statSync(dirPath);
+      
+      // 只处理目录，过滤掉隐藏目录和 node_modules
+      if (stat.isDirectory() && !dir.startsWith('.') && dir !== 'node_modules') {
+        cmpTypes.push(dir);
+      }
+    });
+
+    return cmpTypes;
+  } catch (error) {
+    console.error('获取组件类型失败（getCmpTypeByDir）:', error);
+    // 退出进程
+    process.exit(1);
+  }
+};
+
+module.exports = getCmpTypeByDir;

package/src/cmpUtils/publishCmp.js

@@ -83,9 +83,9 @@ function getFramework(_framework) {
  * 构建组件数据映射
  * @param {string} assetsRoot 构建产物的目录
  * @param {object} cmpInfo 自定义组件信息
- * @returns {object} 自定义组件数据（含自定义组件模型信息）
+ * @returns {Promise<object|null>} 自定义组件数据（含自定义组件模型信息）
  */
-const buildComponentData = (assetsRoot, cmpInfo) => {
+const buildComponentData = async (assetsRoot, cmpInfo) => {
   if (!cmpInfo || !cmpInfo.cmpType) {
     console.error('自定义组件信息或组件名称不能为空');
     return null;
@@ -94,64 +94,67 @@ const buildComponentData = (assetsRoot, cmpInfo) => {
   const { cmpType } = cmpInfo;
   
   if (!assetsRoot || !fs.existsSync(assetsRoot)) {
-    console.error(`未找到自定义组件资源目录: ${assetsRoot}`);
+    console.error(`未找到自定义组件目录: ${assetsRoot}`);
     return null;
   }
   const widgetName = _.camelCase(cmpType);
   const modelFile = path.join(assetsRoot, `${widgetName}Model.js`);
-  
-  let ModelClass = null;
+
+  // 为 Node.js 环境设置全局 window 对象（模型文件可能需要）
+  // 使用 globalThis 以确保在 Node.js 和浏览器环境中都能工作
+  const originalWindow = globalThis.window;
+  if (!globalThis.window) {
+    globalThis.window = {
+      console: console,
+      neoRequire: () => {},
+      postMessage: () => {},
+      // 可以添加其他常用的 window 属性
+    };
+  }
 
   try {
     // 加载自定义组件模型资源文件
     if (fs.existsSync(modelFile)) {
-      // 清除 require 缓存，确保每次都加载最新内容
-      const resolvedPath = require.resolve(modelFile);
-      if (require.cache[resolvedPath]) {
-        delete require.cache[resolvedPath];
-      }
-      const modelModule = require(modelFile);
+      let modelModule = require(modelFile);
       // 获取导出的模型类（可能是 default 导出或命名导出）
-      ModelClass = modelModule.default || modelModule;
-      // 如果是命名导出，尝试查找类名（例如 EntityCardListModel）
-      if (typeof ModelClass !== 'function' && typeof modelModule === 'object') {
-        // 查找所有导出的类
-        const exportedClasses = Object.values(modelModule).filter(
-          (item) => typeof item === 'function'
-        );
-        if (exportedClasses.length > 0) {
-          ModelClass = exportedClasses[0];
-        }
-      }
+      CatchCustomCmpModelClass = modelModule.default || modelModule;
     }
-    // 如果资源文件不存在，报错
     else {
       console.error(`未找到自定义组件模型文件，请检查以下路径是否存在：`, modelFile);
       return null;
     }
-
-    // 如果 ModelClass 是函数（类），则实例化
-    if (typeof ModelClass !== 'function') {
-      console.error(`模型文件 ${modelFile} 未导出有效的模型类`);
+    if (!window.NEOEditorCustomModels) {
+      console.error(`模型文件未导出有效模型方法（CatchCustomCmpModelClass），模型文件地址： ${modelFile} `);
       return null;
     }
 
+    const ModelClass = window.NEOEditorCustomModels[cmpType];
+    if (!ModelClass) {
+      console.error(`未找到自定义组件模型类（${cmpType}），模型文件地址： ${modelFile} `);
+      return null;
+    }
     // 实例化模型类
     const modelInstance = new ModelClass();
 
+    if (!modelInstance) {
+      console.error(`未找到自定义组件模型信息（${cmpType}），模型文件地址： ${modelFile} `);
+      return null;
+    }
+
     // 构建组件数据，合并模型实例的信息
     const curCmpInfo = {
       ...cmpInfo,
+      plugin: cmpInfo.modelAsset,
       version: currentPackageJson.version || '1.0.0',
       framework: currentPackageJson.framework ? getFramework(currentPackageJson.framework) : '0', // 0: React, 1: vue2, 2: jQuery, 3: vue3
       // 从模型实例中提取并设置组件信息
       label: modelInstance.label || cmpType,
       description: modelInstance.description || '',
-      componentCategory: modelInstance.tags || [],
+      componentCategory: (modelInstance.tags || []).join(','),
       icon: modelInstance.iconSrc,
-      defaultProps: modelInstance.defaultComProps || {},
-      previewProps: modelInstance.previewComProps || {},
-      propsSchema: modelInstance.propsSchema || [],
+      defaultProps: JSON.stringify(modelInstance.defaultComProps || {}),
+      previewProps: JSON.stringify(modelInstance.previewComProps || {}),
+      propsSchema: JSON.stringify(modelInstance.propsSchema || []),
       events: modelInstance.events || [],
       actions: modelInstance.actions || [],
       // 如果模型实例中有其他属性，也可以添加
@@ -160,11 +163,19 @@ const buildComponentData = (assetsRoot, cmpInfo) => {
       enableDuplicate: modelInstance.enableDuplicate !== undefined ? modelInstance.enableDuplicate : true
     };
 
+    console.log(`自定义组件模型信息（${cmpType}）:`, curCmpInfo);
     return curCmpInfo;
   } catch (error) {
     console.error(`自定义组件模型文件解析失败 (${modelFile || '未知路径'}):`, error.message);
     console.error(error.stack);
     return null;
+  } finally {
+    // 恢复原始的 window 对象（如果之前存在）
+    if (originalWindow === undefined) {
+      delete globalThis.window;
+    } else {
+      globalThis.window = originalWindow;
+    }
   }
 };
 
@@ -202,9 +213,9 @@ const publishCmp = async (config, cmpType) => {
 
     // 步骤 4: 构建组件数据
     spinner.text = '发布自定义组件：构建组件数据...';
-    const componentInfo = buildComponentData(config.assetsRoot, cmpInfo);
+    const componentInfo = await buildComponentData(config.assetsRoot, cmpInfo);
     if (!componentInfo) {
-      throw new Error('构建组件数据失败，无法继续发布');
+      throw new Error(`构建组件数据失败，未获取到自定义组件模型信息。（${cmpType}）`);
     }
 
     // 步骤 5: 保存组件信息
@@ -218,5 +229,4 @@ const publishCmp = async (config, cmpType) => {
   }
 };
 
-module.exports = publishCmp;
-
+module.exports = publishCmp;

package/src/config/default.config.js

@@ -34,8 +34,8 @@ const defaultNEOConfig = {
     template: resolveByDirname('../initData/defaultTemplate.html'), // 默认使用neo-widget提供的页面模板（会启动页面设计器）
     sassResources: [],
     babelPlugins: [
-      ['import', { libraryName: 'antd', style: 'css' }], // 配置 antd 的样式按需引入
-    ],
+      ['import', { libraryName: 'antd', style: 'css' }] // 配置 antd 的样式按需引入
+    ]
   },
   envParams: {
     // 项目系统环境变量

package/src/module/index.js

@@ -9,6 +9,7 @@ const inspect = require('./inspect.js'); // 输出当前项目配置文件
 const neoConfigInit = require('../utils/neoConfigInit.js');
 const { validateProjectName } = require('../utils/projectNameValidator.js');
 const mainAction = require('./main.js'); // 入口文件
+const getCmpTypeByDir = require('../cmpUtils/getCmpTypeByDir.js');
 
 // neo 的 package 文件
 const neoPackage = require('../../package.json');
@@ -168,16 +169,26 @@ yargs
       if (argv.cmpType) {
         mainAction.previewCmp(argv.cmpType);
       } else {
+        const cmpTypes = getCmpTypeByDir();
+        if (!cmpTypes.lenth || cmpTypes.length === 0) {
+          console.error('当前自定义组件目录中未找到自定义组件。（./src/components 目录下）');
+          process.exit(1);
+        }
+        const cmpTypeChoices = cmpTypes.map((cmpType) => ({
+          name: cmpType,
+          value: cmpType
+        }));
         const questions = [
           {
             name: 'cmpType',
-            type: 'input',
-            message: '请输入要预览的自定义组件名称:',
+            type: 'list',
+            message: '请选择要预览的自定义组件:',
+            choices: cmpTypeChoices
           }
         ];
         inquirer.prompt(questions).then((ans) => {
           if (!ans.cmpType) {
-            console.error('自定义组件名称不能为空。');
+            console.error('未选择要预览的自定义组件。');
             process.exit(1);
           }
           mainAction.previewCmp(ans.cmpType);
@@ -251,7 +262,34 @@ yargs
         .alias('h', 'help');
     },
     (argv) => {
-      mainAction.publish2oss(argv.cmpType); // 构建并发布脚本到oss
+      if (argv.cmpType) {
+        mainAction.publish2oss(argv.cmpType); // 构建并发布脚本到oss
+      } else {
+        const cmpTypes = getCmpTypeByDir();
+        if (!cmpTypes.lenth || cmpTypes.length === 0) {
+          console.error('当前自定义组件目录中未找到自定义组件。（./src/components 目录下）');
+          process.exit(1);
+        }
+        const cmpTypeChoices = cmpTypes.map((cmpType) => ({
+          name: cmpType,
+          value: cmpType
+        }));
+        const questions = [
+          {
+            name: 'cmpType',
+            type: 'list',
+            message: '请选择要发布的自定义组件:',
+            choices: cmpTypeChoices
+          }
+        ];
+        inquirer.prompt(questions).then((ans) => {
+          if (!ans.cmpType) {
+            console.error('未选择要发布的自定义组件。');
+            process.exit(1);
+          }
+          mainAction.publish2oss(ans.cmpType);
+        });
+      }
     }
   )
   .command(
@@ -271,16 +309,26 @@ yargs
       if (argv.cmpType) {
         mainAction.publishCmp(argv.cmpType); // 构建并发布组件到 NeoCRM
       } else {
+        const cmpTypes = getCmpTypeByDir();
+        if (!cmpTypes.lenth || cmpTypes.length === 0) {
+          console.error('当前自定义组件目录中未找到自定义组件。（./src/components 目录下）');
+          process.exit(1);
+        }
+        const cmpTypeChoices = cmpTypes.map((cmpType) => ({
+          name: cmpType,
+          value: cmpType
+        }));
         const questions = [
           {
             name: 'cmpType',
-            type: 'input',
-            message: '请输入要发布的自定义组件名称:'
+            type: 'list',
+            message: '请选择要发布的自定义组件:',
+            choices: cmpTypeChoices
           }
         ];
         inquirer.prompt(questions).then((ans) => {
           if (!ans.cmpType) {
-            console.error('自定义组件名称不能为空。');
+            console.error('未选择要发布的自定义组件。');
             process.exit(1);
           }
           mainAction.publishCmp(ans.cmpType);

package/src/neo/NeoUMDContent.js

@@ -0,0 +1,29 @@
+/**
+ * 内置 UMD 模块，用于在 Node cli 端加载自定义组件模型
+ * 特别说明：这个文件内容会通过 AddNeoRequirePlugin 插入的构建代码中。
+ */
+(function (root, factory) {
+  // AMD 环境检测
+  if (typeof define === 'function' && define.amd) {
+    define([], factory);
+  }
+  // CommonJS 环境检测
+  else if (typeof exports === 'object' && typeof exports.nodeName !== 'string') {
+    module.exports = factory();
+  }
+  // 浏览器全局变量
+  else {
+    root.NeoCustomCmpModel = factory();
+  }
+}(typeof self !== 'undefined' ? self : this, function () {
+  'use strict';
+  
+  const getCustomModels = (cmpType) => {
+    // 自定义组件模型列表
+    const NEOEditorCustomModels = window.NEOEditorCustomModels || {};
+    return NEOEditorCustomModels[cmpType] || {};
+  }
+  
+  // 导出模块
+  return getCustomModels;
+}));

package/src/neo/neoService.js

@@ -8,9 +8,9 @@ const updatePublishLog = require('../cmpUtils/updatePublishLog');
 // NeoCRM 平台默认 API 配置
 const NeoCrmAPI = {
   neoBaseURL: 'https://crm.xiaoshouyi.com', // 平台根地址
-  tokenAPI: 'https://login.crm.xiaoshouyi.com/auc/oauth2/token', // Token 获取接口地址
+  tokenAPI: 'https://login.xiaoshouyi.com/auc/oauth2/token', // Token 获取接口地址
   uploadAPI: '/rest/metadata/v3.0/ui/customComponents/actions/upload', // 文件上传接口地址
-  saveAPI: '/rest/metadata/v3.0/ui/customComponents/actions/saveComponent' // 组件信息保存接口地址
+  saveAPI: '/rest/metadata/v3.0/ui/customComponents/actions/saveOrUpdateComponent' // 创建或者保存接口地址
 };
 
 /**
@@ -101,29 +101,29 @@ class NeoService {
       console.info('使用缓存的 token');
       return this.tokenCache.token;
     }
+    console.info('获取 token...');
 
-    console.info('正在获取 token...');
+    // 构建表单数据格式的请求参数
+    const formData = new URLSearchParams();
+    formData.append('grant_type', 'password');
+    formData.append('client_id', this.authorization.client_id);
+    formData.append('client_secret', this.authorization.client_secret);
+    formData.append('username', this.authorization.username);
+    formData.append('password', this.authorization.password);
+
+    const tokenUrl = this.buildFullUrl(this.tokenAPI);
 
     try {
-      // 构建请求参数
-      const params = new URLSearchParams();
-      params.append('grant_type', 'password');
-      params.append('client_id', this.authorization.client_id);
-      params.append('client_secret', this.authorization.client_secret);
-      params.append('username', this.authorization.username);
-      params.append('password', this.authorization.password);
-
-      const tokenUrl = this.buildFullUrl(this.tokenAPI);
-      const response = await axios.post(tokenUrl, params, {
+      const response = await axios.post(tokenUrl, formData.toString(), {
         headers: {
           'Content-Type': 'application/x-www-form-urlencoded'
         }
       });
 
-      const { access_token, expires_in } = response.data;
+      const { access_token, expires_in } = response.data || {};
 
       if (!access_token) {
-        console.error('获取 token 失败：响应中未包含 access_token', response.data);
+        console.error('\n获取 token 失败：响应中未包含 access_token', response.data);
         process.exit(1);
       }
 
@@ -133,11 +133,11 @@ class NeoService {
         token: access_token,
         expiresAt: Date.now() + (expiresIn - 60) * 1000
       };
-
-      console.info('token 获取成功');
       return access_token;
     } catch (error) {
-      console.error('获取 token 失败:', error.message);
+      console.error('\n获取 token 失败:', error.message);
+      console.error('\ntoken 授权地址:', tokenUrl);
+      console.error('\ntoken 请求参数:', formData);
       if (error.response) {
         console.error('响应数据:', error.response.data);
       }
@@ -177,59 +177,155 @@ class NeoService {
    * 上传文件到 Neo 平台
    * @param {string} filePath 文件路径
    * @param {object} options 可选配置
-   * @param {string} options.fieldName 表单字段名，默认为 'file'
+   * @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}`);
     }
 
-    console.info('正在上传文件...');
+    // 检查文件状态
+    const fileStat = fs.statSync(filePath);
+    if (!fileStat.isFile()) {
+      throw new Error(`路径不是文件: ${filePath}`);
+    }
+
+    // 检查文件大小
+    const maxSize = options.maxSize || 50 * 1024 * 1024; // 默认 50MB
+    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);
+    console.info(`正在上传文件: ${fileName} (${fileSizeKB}KB)...`);
 
     try {
+      // 创建 FormData
       const formData = new FormData();
       const fieldName = options.fieldName || 'customComponentCode';
-      formData.append(fieldName, fs.createReadStream(filePath));
+      
+      // 使用文件流而不是读取整个文件到内存（对大文件更友好）
+      const fileContent = fs.createReadStream(filePath);
+
+      // 追加文件到 FormData，第三个参数指定文件名
+      formData.append(fieldName, fileContent, fileName);
 
+      // 构建完整的上传 API 地址
       const fullUploadAPI = this.uploadAPI();
-      const response = await axios.post(fullUploadAPI, formData, {
+
+      // 配置请求选项
+      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;
-      if (typeof response.data === 'string') {
-        resultData = response.data;
-      } else if (response.data && response.data.data) {
-        resultData = response.data.data;
-      } else if (response.data && response.data.code === 200) {
-        resultData = response.data.data;
-      } else {
-        resultData = response.data;
+      const responseData = response.data;
+
+      // 检查响应状态码
+      if (response.status !== 200 && response.status !== 201) {
+        throw new Error(`上传失败: HTTP ${response.status}`);
       }
 
-      if (response.data && response.data.code && response.data.code !== 200) {
-        throw new Error(`上传失败: ${response.data.message || '未知错误'}`);
+      // 处理不同的响应格式
+      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 || (typeof resultData !== 'string' && !resultData.url)) {
-        throw new Error(`返回的文件地址格式不正确: ${JSON.stringify(resultData)}`);
+      // 验证返回的文件地址
+      if (!resultData) {
+        throw new Error(`返回的文件地址为空`);
       }
 
-      const fileUrl = typeof resultData === 'string' ? resultData : resultData.url;
+      // 格式化文件 URL
+      let fileUrl;
+      if (typeof resultData === 'string') {
+        fileUrl = resultData;
+      } else if (resultData && typeof resultData === 'object' && resultData.url) {
+        fileUrl = resultData.url;
+      }
+      console.info(`\n文件上传成功: ${fileName} -> ${fileUrl}`);
       return fileUrl;
     } catch (error) {
-      console.error('上传文件失败:', error.message);
+      console.error(`\n上传文件失败: ${error.message}，`);
+      console.error(`文件路径: ${filePath}。\n`);
+      
+      // 输出详细的错误信息
       if (error.response) {
-        console.error('响应数据:', error.response.data);
+        const status = error.response.status;
+        const statusText = error.response.statusText;
+        const responseData = error.response.data;
+        const requestUrl = error.config?.url || this.uploadAPI();
+        
+        console.error(`\n========== 上传请求详情 ==========`);
+        console.error(`请求 URL: ${requestUrl}`);
+        console.error(`HTTP 状态码: ${status} ${statusText}`);
+        console.error(`响应数据:`, responseData);
+        console.error(`==================================\n`);
+        
+        if (status === 404) {
+          throw new Error(
+            `上传 API 不存在 (404): ${requestUrl}\n` +
+            `请检查 neo.config.js 中的 neoBaseURL 配置是否正确，或者 API 路径是否存在。\n` +
+            `当前配置的 API 路径: ${NeoCrmAPI.uploadAPI}`
+          );
+        }
+      } else if (error.request) {
+        console.error('请求已发送但未收到响应，请检查网络连接或代理配置。');
       }
+      
       throw error;
     }
   }
@@ -274,7 +370,7 @@ class NeoService {
         try {
           // 上传文件
           const fileUrl = await this.uploadFile(filePath);
-          
+
           if (file.indexOf('Model') > -1) {
             curCmpInfo.modelAsset = fileUrl;
           } else if (file.endsWith('.css')) {
@@ -282,16 +378,15 @@ class NeoService {
           } else {
             curCmpInfo.asset = fileUrl;
           }
-
         } catch (error) {
-          console.error(`文件上传失败（${file}）：\n`, error);
+          console.error(`文件上传失败（${file}）：\n`);
           process.exit(1);
         }
       }
     });
 
     await Promise.all(uploadPromises);
-    
+
     if (curCmpInfo && curCmpInfo.cmpType) {
       console.info('上传至 OSS 的文件信息：\n', curCmpInfo);
       // 更新发布日志
@@ -302,7 +397,6 @@ class NeoService {
 
   /**
    * 更新自定义组件
-   * @param {string} updateAPI 更新接口地址（相对或绝对路径）
    * @param {object} componentData 组件数据
    * @returns {Promise<object>} 更新结果
    */
@@ -317,24 +411,27 @@ class NeoService {
     console.info('正在更新自定义组件...');
 
     try {
-      const fullUpdateAPI = this.updateAPI();
+      const fullUpdateAPI = this.saveAPI();
       const response = await axios.post(fullUpdateAPI, componentData, {
         headers: {
           Authorization: `Bearer ${token}`,
+          'xsy-inner-source': 'bff',
           'Content-Type': 'application/json'
         }
       });
+      const {code, message} = response.data || {};
 
-      if (response.data && response.data.code && response.data.code !== 200) {
+      if (code && code !== 200) {
         throw new Error(`更新组件失败: ${response.data.message || '未知错误'}`);
       }
+      
 
-      console.info('组件更新成功:', response.data);
-      return response.data;
+      console.info(message ? `组件更新成功: ${message}。` : '组件更新成功。');
     } catch (error) {
-      console.error('更新组件失败:', error.message);
-      if (error.response) {
-        console.error('响应数据:', error.response.data);
+      if (error.message) {
+        console.error('更新组件失败:', error.message);
+      } else {
+        console.error('响应数据:', error);
       }
       process.exit(1);
     }
@@ -365,6 +462,7 @@ class NeoService {
         params,
         headers: {
           Authorization: `Bearer ${token}`,
+          'xsy-inner-source': 'bff',
           ...headers
         }
       });

package/src/neo/wrapperContent.js

@@ -1,6 +1,7 @@
 /**
  * 注入 neoRequire 函数
  * 备注：用于实现和 Neo 平台共享依赖
+ * 特别说明：这个文件只是用于说明 AddNeoRequirePlugin 中会插入的代码内容，实际内容内置在 AddNeoRequirePlugin 方法中。
  */
 (function(NeoCustomCmpFileFactory) {
   if (!window.neoRequire) {
@@ -12,4 +13,4 @@
    * 这里放自定义组件相关内容代码
    * 备注: 自定义组件代码中的 require 函数 已被替换成 neoRequire 函数（require === neoRequire）。
    */
-});
+});

package/src/plugins/AddNeoRequirePlugin.js

@@ -1,5 +1,6 @@
 const { ConcatSource } = require('webpack-sources');
-
+const fs = require('fs');
+const path = require('path');
 /**
  * 注入 neoRequire 函数
  * 备注：用于实现和 Neo 平台共享依赖
@@ -163,7 +164,9 @@ class AddNeoRequirePlugin {
 })(function(require) {
                 `;
 
-    const Footer = `})`;
+    // const NeoUMDContent = fs.readFileSync(path.join(__dirname, '../neo/NeoUMDContent.js'), 'utf8');
+    // const Footer = `}); \n${NeoUMDContent}`;
+    const Footer = `});`;
 
     // 创建新的资源
     const newSource = new ConcatSource(Header, content, Footer);

package/src/template/neo-custom-cmp-template/neo.config.js

@@ -129,7 +129,7 @@ module.exports = {
   publishCmp: {
     // 用于构建并发布至 NeoCRM 的相关配置
     neoBaseURL: 'https://crm-cd.xiaoshouyi.com', // 平台根地址（默认：https://crm.xiaoshouyi.com）
-    tokenAPI: 'https://login.crm-cd.xiaoshouyi.com/auc/oauth2/token', // Token 获取接口地址（默认：https://login.crm.xiaoshouyi.com/auc/oauth2/token）
+    tokenAPI: 'https://login-cd.xiaoshouyi.com/auc/oauth2/token', // Token 获取接口地址（默认：https://login.xiaoshouyi.com/auc/oauth2/token）
     // NeoCRM 授权配置
     authorization: {
       client_id: authConfig.client_id || 'xx', // 客户端 ID，从创建连接器的客户端信息中获取（Client_Id）

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

@@ -53,7 +53,7 @@
     "@types/react": "^16.9.11",
     "@types/react-dom": "^16.9.15",
     "@types/axios": "^0.14.0",
-    "neo-cmp-cli": "^1.5.0-beta.1",
+    "neo-cmp-cli": "^1.5.0-beta.3",
     "husky": "^4.2.5",
     "lint-staged": "^10.2.9",
     "prettier": "^2.0.5"

package/src/template/neo-custom-cmp-template/src/components/entity-detail/index.tsx

@@ -278,6 +278,14 @@ export default class EntityDetail extends React.PureComponent<
 
     return (
       <div className="entity-detail-container">
+        <img
+          src="https://custom-widget2.oss-cn-beijing.aliyuncs.com/img.png"
+          alt="logo"
+        />
+        <img
+          src="https://publicfront-1253467224.cos.ap-beijing.myqcloud.com/customComponent/crm-cd/tenant/3392331536784858/1761882606360/img.png"
+          alt="logo"
+        />
         {showTitle && (
           <div className="detail-header">
             <div className="header-content">