neo-cmp-cli 1.6.2 → 1.6.3

package/README.md

@@ -88,6 +88,11 @@ module.exports = {
 ```
 **详细使用说明**：请参考下方「[发布自定义组件至 NeoCRM](#6发布自定义组件至-neocrm)」章节。
 
+#### 8) 删除线上自定义组件
+执行 `neo deleteCmp` 即可从 NeoCRM 平台删除指定的自定义组件。  
+**删除前请确保**：已配置 NeoCRM 平台授权信息，且确认要删除的组件名称正确（删除操作不可恢复）。  
+**详细使用说明**：请参考下方「[删除线上自定义组件](#8删除线上自定义组件)」章节。
+
 ## 常用命令说明
 - **neo init**: 交互式创建自定义组件（支持 -t、--name）;
 - **neo createProject**: 创建自定义组件项目（支持 --name）;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neo-cmp-cli",
-  "version": "1.6.2",
+  "version": "1.6.3",
   "description": "前端脚手架：自定义组件开发工具，支持react 和 vue2.0技术栈。",
   "keywords": [
     "neo-cli",
@@ -14,7 +14,6 @@
   "main": "src/module/main.js",
   "scripts": {
     "neo": "neo",
-    "dev": "node ./test/demo.js",
     "format": "prettier --write \"src/**/**/*.{js,jsx,vue,tsx,ts,scss,less,json}\""
   },
   "files": [

package/src/module/index.js

@@ -12,7 +12,7 @@ const mainAction = require('./main.js'); // 入口文件
 const getCmpTypeByDir = require('../utils/cmpUtils/getCmpTypeByDir.js');
 const NeoService = require('../neo/neoService.js');
 const curConfig = require('../config/index'); // 获取当前项目根目录下的配置文件
-const hasNeoProject = require('../utils/hasNeoProject.js');
+const hasNeoProject = require('../utils/projectUtils/hasNeoProject.js');
 const consoleTag = require('../utils/neoParams').consoleTag;
 // neo 的 package 文件
 const neoPackage = require('../../package.json');
@@ -571,18 +571,50 @@ yargs
           default: 'auto',
           choices: ['cursor', 'vscode', 'code', 'auto']
         })
-        .option('path', {
-          alias: 'p',
-          describe: '要打开的项目路径，默认为当前目录'
+        .option('name', {
+          alias: 'n',
+          describe: '要打开的项目名称，默认为当前目录'
         })
         .alias('h', 'help');
     },
     (argv) => {
-      mainAction.openEditor(argv.editor, argv.path);
+      mainAction.openEditor(argv.editor, argv.name);
     }
   )
   .alias('h', 'help')
   .alias('v', 'version')
+  .strict()
+  .fail((msg, err, yargs) => {
+    console.error(chalk.red(`\n运行命令时发生错误: ${msg}。\n`));
+    console.log(titleTip('当前可用命令列表：'));
+    console.log('');
+    // 定义所有可用命令及其描述
+    const commands = [
+      { cmd: 'init [options]', desc: '根据模板创建一个自定义组件' },
+      // { cmd: 'config init', desc: '创建 neo.config.js 配置文件' },
+      { cmd: 'createProject [options]', desc: '创建自定义组件项目（含工程代码）' },
+      { cmd: 'createCmp [options]', desc: '创建自定义组件' },
+      { cmd: 'pullCmp [options]', desc: '拉取线上自定义组件' },
+      { cmd: 'deleteCmp [options]', desc: '删除线上自定义组件' },
+      { cmd: 'preview [options]', desc: '预览指定自定义组件（仅预览组件本身内容）' },
+      // { cmd: 'dev', desc: '开启本地调试模式' },
+      { cmd: 'linkDebug', desc: '开启外链调试模式（在线上页面设计器端调试）' },
+      // { cmd: 'build', desc: '构建生产环境代码' },
+      // { cmd: 'build2lib', desc: '构建 UMD 模块' },
+      // { cmd: 'build2esm', desc: '构建 ESM 模块' },
+      // { cmd: 'publish2oss [options]', desc: '发布到oss' },
+      { cmd: 'pushCmp [options]', desc: '构建并发布自定义组件到 NeoCRM 平台' },
+      // { cmd: 'inspect', desc: '输出当前配置文件' },
+      { cmd: 'open [options]', desc: '使用 Cursor 或 VSCode 打开项目' }
+    ];
+    commands.forEach(({ cmd, desc }) => {
+      console.log(`  ${chalk.cyan(cmd.padEnd(25))} ${desc}`);
+    });
+    console.log('');
+    console.log(`使用 ${chalk.cyan('neo <command> --help')} 查看具体命令的帮助信息。`);
+    console.log('');
+    process.exit(1);
+  })
   .help()
   .updateStrings({
     'Usage:': titleTip('Usage:'),

package/src/module/inspect.js

@@ -4,6 +4,7 @@ const fs = require('fs');
 const { getCurWebpackConfig } = require('akfun'); // 用于获取当前webpack配置的方法
 const curConfig = require('../config/index');
 const { consoleTag } = require('../utils/neoParams'); // 输出标记
+const { errorLog, successLog } = require('../utils/common');
 
 // 根据当前配置文件内容创建指定名称的文件
 const createConfigJs = function (fileName, fileCont) {
@@ -24,17 +25,17 @@ module.exports = (type) => {
   if (type === 'dev') {
     const devConfig = getCurWebpackConfig(type, curConfig);
     createConfigJs('current-neo-dev-config.js', devConfig);
-    spinner.succeed(`${consoleTag}当前配置数据已输出至 current-neo-dev-config.js中。`);
+    successLog(`当前配置数据已输出至 current-neo-dev-config.js中。`, spinner);
   } else if (type === 'lib') {
     const libraryConfig = getCurWebpackConfig(type, curConfig);
     createConfigJs('current-neo-build2lib-config.js', libraryConfig);
-    spinner.succeed(`${consoleTag}当前配置数据已输出至 current-neo-build2lib-config.js中。`);
+    successLog(`当前配置数据已输出至 current-neo-build2lib-config.js中。`, spinner);
   } else if (type === 'build') {
     const prodConfig = getCurWebpackConfig(type, curConfig);
     // 默认输出生产环境的配置文件
     createConfigJs('current-neo-build-config.js', prodConfig);
-    spinner.succeed(`${consoleTag}当前配置数据已输出至 current-neo-build-config.js。`);
+    successLog(`当前配置数据已输出至 current-neo-build-config.js。`, spinner);
   } else {
-    spinner.fail(`type 不能为空。`);
+    errorLog(`type 不能为空。`, spinner);
   }
 };

package/src/module/main.js

@@ -18,7 +18,7 @@ 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 openNeoProject = require('../utils/projectUtils/openNeoProject');
+const openProject = require('../utils/projectUtils/openProject');
 
 const getValue = (originValue, defaultValue) => {
   return originValue !== undefined ? originValue : defaultValue;
@@ -271,5 +271,5 @@ module.exports = {
   },
   build2esm: (fileName) => akfun.build2esm(fileName, curConfig, consoleTag), // 构建esm输出模块
   // 打开编辑器（Cursor 或 VSCode）
-  openEditor: openNeoProject
+  openEditor: openProject
 };

package/src/neo/neoService.js

@@ -6,7 +6,7 @@ const ora = require('ora');
 const _ = require('lodash');
 const { resolve } = require('akfun');
 const updatePublishLog = require('../utils/projectUtils/updatePublishLog');
-const { getFramework } = require('../utils/common');
+const { getFramework, errorLog, successLog } = require('../utils/common');
 
 // NeoCRM 平台默认 API 配置
 const NeoCrmAPI = {
@@ -123,7 +123,7 @@ class NeoService {
     const spinner = ora('获取 token...').start();
     // 检查缓存是否有效
     if (!this.isTokenExpired()) {
-      spinner.succeed('使用缓存的 token。');
+      successLog('使用缓存的 token。', spinner);
       return this.tokenCache.token;
     }
 
@@ -147,7 +147,7 @@ class NeoService {
       const { access_token, expires_in } = response.data || {};
 
       if (!access_token) {
-        spinner.fail('获取 token 失败（授权配置错误）：响应中未包含 access_token，', response.data);
+        errorLog('获取 token 失败（授权配置错误）：响应中未包含 access_token，' + JSON.stringify(response.data), spinner);
         process.exit(1);
       }
 
@@ -161,12 +161,12 @@ class NeoService {
       spinner.stop();
       return access_token;
     } catch (error) {
-      spinner.fail('获取 token 失败');
-      console.error('\n获取 token 失败:', error.message);
-      console.error('\ntoken 授权地址:', tokenUrl);
-      console.error('\ntoken 请求参数:', formData);
+      errorLog('获取 token 失败', spinner);
+      errorLog(`\n获取 token 失败: ${error.message}`);
+      errorLog(`\ntoken 授权地址: ${tokenUrl}`);
+      errorLog(`\ntoken 请求参数: ${formData}`);
       if (error.response) {
-        console.error('响应数据:', error.response.data);
+        errorLog(`响应数据: ${JSON.stringify(error.response.data)}`);
       }
       process.exit(1);
     }
@@ -197,10 +197,10 @@ class NeoService {
       const spinner = ora('token 已过期，正在刷新...').start();
       try {
         const token = await this.refreshToken();
-        spinner.succeed('token 刷新成功。');
+        successLog('token 刷新成功。', spinner);
         return token;
       } catch (error) {
-        spinner.fail('token 刷新失败。');
+        errorLog('token 刷新失败。', spinner);
         throw error;
       }
     }
@@ -334,10 +334,10 @@ class NeoService {
       } else if (resultData && typeof resultData === 'object' && resultData.url) {
         fileUrl = resultData.url;
       }
-      spinner.succeed(`文件上传成功: ${fileName} -> ${fileUrl}`);
+      successLog(`文件上传成功: ${fileName} -> ${fileUrl}`, spinner);
       return fileUrl;
     } catch (error) {
-      spinner.fail(`上传文件失败: ${error.message}, 文件路径: ${filePath}`);
+      errorLog(`上传文件失败: ${error.message}, 文件路径: ${filePath}`, spinner);
 
       // 输出详细的错误信息
       if (error.response) {
@@ -346,11 +346,11 @@ class NeoService {
         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`);
+        errorLog(`\n========== 上传请求详情 ==========`);
+        errorLog(`请求 URL: ${requestUrl}`);
+        errorLog(`HTTP 状态码: ${status} ${statusText}`);
+        errorLog(`响应数据: ${JSON.stringify(responseData)}`);
+        errorLog(`==================================\n`);
 
         if (status === 404) {
           throw new Error(
@@ -360,7 +360,7 @@ class NeoService {
           );
         }
       } else if (error.request) {
-        console.error('请求已发送但未收到响应，请检查网络连接或代理配置。');
+        errorLog('请求已发送但未收到响应，请检查网络连接或代理配置。');
       }
 
       throw error;
@@ -375,11 +375,11 @@ class NeoService {
    */
   async publish2oss(cmpType, fileExtensions = ['.js', '.css', '.zip']) {
     if (!cmpType) {
-      console.error(`自定义组件名称不能为空: ${cmpType}`);
+      errorLog(`自定义组件名称不能为空: ${cmpType}`);
       return;
     }
     if (!fs.existsSync(this.assetsRoot)) {
-      console.error(`未找到自定义组件资源目录: ${this.assetsRoot}`);
+      errorLog(`未找到自定义组件资源目录: ${this.assetsRoot}`);
       return;
     }
 
@@ -419,7 +419,7 @@ class NeoService {
             curCmpInfo.asset = fileUrl;
           }
         } catch (error) {
-          console.error(`文件上传失败（${file}）：\n`);
+          errorLog(`文件上传失败（${file}）：\n`);
           process.exit(1);
         }
       }
@@ -468,11 +468,11 @@ class NeoService {
       spinner.clear();
       spinner.stop();
     } catch (error) {
-      spinner.fail('更新组件失败。');
+      errorLog('更新组件失败。', spinner);
       if (error.message) {
-        console.error('更新组件失败:', error.message);
+        errorLog(`更新组件失败: ${error.message}`);
       } else {
-        console.error('响应数据:', error);
+        errorLog(`响应数据: ${JSON.stringify(error)}`);
       }
       process.exit(1);
     }
@@ -518,9 +518,9 @@ class NeoService {
       this.updateCustomCmpList(response.data.data || []);
     } catch (error) {
       if (error.message) {
-        console.error('获取自定义组件列表失败:', error.message);
+        errorLog(`获取自定义组件列表失败: ${error.message}`);
       } else {
-        console.error('响应数据:', error);
+        errorLog(`响应数据: ${JSON.stringify(error)}`);
       }
       process.exit(1);
     }
@@ -624,9 +624,9 @@ class NeoService {
 
       return response.data;
     } catch (error) {
-      console.error(`请求失败 [${method} ${api}]:`, error.message);
+      errorLog(`请求失败 [${method} ${api}]: ${error.message}`);
       if (error.response) {
-        console.error('响应数据:', error.response.data);
+        errorLog(`响应数据: ${JSON.stringify(error.response.data)}`);
       }
       throw error;
     }

package/src/oss/publish2oss.js

@@ -6,6 +6,7 @@ const ora = require('ora');
 const { catchCurPackageJson } = require('../utils/pathUtils');
 const getConfigObj = require('../utils/getConfigObj');
 const updatePublishLog = require('../utils/projectUtils/updatePublishLog');
+const { errorLog, warningLog, successLog } = require('../utils/common');
 
 // 获取当前项目的package文件
 const currentPackageJsonDir = catchCurPackageJson();
@@ -185,7 +186,7 @@ async function uploadSingleFile(bosClient, filePath, objectKey, ossType, ossConf
     // 上传文件
     const result = await bosClient.upload(objectKey, filePath);
     const ossPath = getFilePath(ossType, ossConfig.bucket, objectKey);
-    spinner.succeed(`文件上传成功: ${fileName} -> ${ossPath}`);
+    successLog(`文件上传成功: ${fileName} -> ${ossPath}`, spinner);
 
     return {
       success: true,
@@ -197,17 +198,17 @@ async function uploadSingleFile(bosClient, filePath, objectKey, ossType, ossConf
       resultMsg: result
     };
   } catch (error) {
-    spinner.fail(`文件上传失败: ${fileName}`);
+    errorLog(`文件上传失败: ${fileName}`, spinner);
 
     // 输出详细的错误信息
-    console.error(`\n========== 上传文件详情 ==========`);
-    console.error(`文件路径: ${filePath}`);
-    console.error(`OSS 对象键: ${objectKey}`);
-    console.error(`错误信息: ${error.message}`);
+    errorLog(`\n========== 上传文件详情 ==========`);
+    errorLog(`文件路径: ${filePath}`);
+    errorLog(`OSS 对象键: ${objectKey}`);
+    errorLog(`错误信息: ${error.message}`);
     if (error.stack) {
-      console.error(`错误堆栈:`, error.stack);
+      errorLog(`错误堆栈: ${error.stack}`);
     }
-    console.error(`==================================\n`);
+    errorLog(`==================================\n`);
 
     return {
       success: false,
@@ -231,44 +232,44 @@ async function uploadSingleFile(bosClient, filePath, objectKey, ossType, ossConf
 const publish2oss = async (ossType, ossConfig, assetsRoot, fileExtensions = ['.js', '.css']) => {
   // 参数验证
   if (ossType !== 'baidu' && ossType !== 'ali') {
-    console.error(`不支持的oss类型: ${ossType}`);
+    errorLog(`不支持的oss类型: ${ossType}`);
     return;
   }
 
   if (!ossConfig) {
-    console.error('ossConfig 不能为空');
+    errorLog('ossConfig 不能为空');
     return;
   }
 
   if (!assetsRoot) {
-    console.error('assetsRoot 不能为空');
+    errorLog('assetsRoot 不能为空');
     return;
   }
 
   // 检查目录是否存在
   if (!fs.existsSync(assetsRoot)) {
-    console.error(`assetsRoot 不存在: ${assetsRoot}`);
+    errorLog(`assetsRoot 不存在: ${assetsRoot}`);
     return;
   }
 
   // 检查目录是否为目录
   const assetsRootStat = fs.statSync(assetsRoot);
   if (!assetsRootStat.isDirectory()) {
-    console.error(`assetsRoot 不是目录: ${assetsRoot}`);
+    errorLog(`assetsRoot 不是目录: ${assetsRoot}`);
     return;
   }
 
   // 创建 OSS 客户端
   const bosClient = getBosClient(ossType, ossConfig);
   if (!bosClient) {
-    console.error(`无法创建 OSS 客户端，请检查 ossType 和 ossConfig 配置`);
+    errorLog(`无法创建 OSS 客户端，请检查 ossType 和 ossConfig 配置`);
     return;
   }
 
   // 读取构建目录下的所有文件
   const files = fs.readdirSync(assetsRoot);
   if (files.length === 0) {
-    console.warn(`构建目录为空: ${assetsRoot}`);
+    warningLog(`构建目录为空: ${assetsRoot}`);
     return;
   }
 
@@ -286,7 +287,7 @@ const publish2oss = async (ossType, ossConfig, assetsRoot, fileExtensions = ['.j
         const fileInfo = path.parse(filePath);
         return fileExtensions.includes(fileInfo.ext);
       } catch (error) {
-        console.warn(`无法读取文件状态: ${filePath}`, error.message);
+        warningLog(`无法读取文件状态: ${filePath} - ${error.message}`);
         return false;
       }
     });
@@ -296,7 +297,7 @@ const publish2oss = async (ossType, ossConfig, assetsRoot, fileExtensions = ['.j
       return;
     }
 
-    spinner.succeed(`找到 ${filesToUpload.length} 个文件需要上传`);
+    successLog(`找到 ${filesToUpload.length} 个文件需要上传`, spinner);
 
     // 并行上传所有指定类型的文件
     const uploadPromises = filesToUpload.map(async (file) => {
@@ -320,7 +321,7 @@ const publish2oss = async (ossType, ossConfig, assetsRoot, fileExtensions = ['.j
       // 更新发布日志
       updatePublishLog(widgetFilesMap);
     } else {
-      console.warn('未生成有效的文件上传结果');
+      warningLog('未生成有效的文件上传结果');
     }
 
     // 统计上传结果
@@ -328,18 +329,18 @@ const publish2oss = async (ossType, ossConfig, assetsRoot, fileExtensions = ['.j
     const failCount = validResults.filter((r) => r && !r.success).length;
 
     if (failCount > 0) {
-      console.warn(`\n上传完成：成功 ${succeedCount} 个，失败 ${failCount} 个`);
+      warningLog(`\n上传完成：成功 ${succeedCount} 个，失败 ${failCount} 个`);
     } else {
       console.info(`\n✅ 所有文件上传成功！共 ${succeedCount} 个文件`);
     }
   } catch (error) {
-    spinner.fail('批量上传文件异常');
-    console.error('\n========== 批量上传异常 ==========');
-    console.error('错误信息:', error.message);
+    errorLog('批量上传文件异常', spinner);
+    errorLog('\n========== 批量上传异常 ==========');
+    errorLog(`错误信息: ${error.message}`);
     if (error.stack) {
-      console.error('错误堆栈:', error.stack);
+      errorLog(`错误堆栈: ${error.stack}`);
     }
-    console.error('==================================\n');
+    errorLog('==================================\n');
     throw error;
   }
 };

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.6.2",
+    "neo-cmp-cli": "^1.6.3",
     "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.6.2",
+    "neo-cmp-cli": "^1.6.3",
     "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.6.2",
+    "neo-cmp-cli": "^1.6.3",
     "husky": "^4.2.5",
     "lint-staged": "^10.2.9",
     "prettier": "^2.0.5"

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

@@ -52,7 +52,7 @@
     "@types/react": "^16.9.11",
     "@types/react-dom": "^16.9.15",
     "@types/axios": "^0.14.0",
-    "neo-cmp-cli": "^1.6.2",
+    "neo-cmp-cli": "^1.6.3",
     "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.6.2",
+    "neo-cmp-cli": "^1.6.3",
     "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.6.2",
+    "neo-cmp-cli": "^1.6.3",
     "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.6.2",
+    "neo-cmp-cli": "^1.6.3",
     "husky": "^4.2.5",
     "lint-staged": "^10.2.9",
     "prettier": "^2.0.5",

package/src/utils/autoEntryRootDir.js

@@ -1,5 +1,6 @@
 const path = require('path');
 const fs = require('fs');
+const openProject = require('./projectUtils/openProject');
 
 /**
  * 自动进入指定项目的根目录
@@ -71,7 +72,7 @@ module.exports = function (projectPath, options = {}) {
     console.log(`   您需要手动执行上述命令才能进入刚创建的自定义组件项目（${projectName}）。\n`);
 
     // 自动打开 IDE编辑器
-    openNeoProject('auto', projectName);
+    openProject('auto', projectName);
   }
 
   return success;

package/src/utils/cmpUtils/createCmpByZip.js

@@ -7,6 +7,7 @@ const _ = require('lodash');
 const { consoleTag } = require('../neoParams'); // 输出标记
 const hasCmpTypeByDir = require('./hasCmpTypeByDir');
 const hasNeoProject = require('../projectUtils/hasNeoProject');
+const { errorLog, warningLog, successLog, parseTsConfigWithTypeScript } = require('../common');
 
 /**
  * 检查对象键名是否需要加引号
@@ -117,14 +118,14 @@ module.exports = async function (cmpZipUrl, cmpName, componentBaseDir = './src/c
   const finalCmpName = cmpName;
 
   if (!hasNeoProject()) {
-    console.error(
-      `${consoleTag}当前（${process.cwd()}）还不是自定义组件项目，请先创建一个自定义组件项目（neo init / neo createProject）。`
+    errorLog(
+      `当前（${process.cwd()}）还不是自定义组件项目，请先创建一个自定义组件项目（neo init / neo createProject）。`
     );
     process.exit(1);
   }
 
   if (hasCmpTypeByDir(finalCmpName)) {
-    console.error(`${consoleTag}当前项目已经存在${finalCmpName}自定义组件。`);
+    errorLog(`当前项目已经存在${finalCmpName}自定义组件。`);
     process.exit(1);
   }
 
@@ -156,7 +157,7 @@ module.exports = async function (cmpZipUrl, cmpName, componentBaseDir = './src/c
         maxBodyLength: Infinity
       });
     } catch (axiosError) {
-      spinner.fail(`${consoleTag}下载文件失败:`, axiosError.message);
+      errorLog(`下载文件失败: ${axiosError.message}`, spinner);
       throw axiosError;
     }
 
@@ -180,7 +181,7 @@ module.exports = async function (cmpZipUrl, cmpName, componentBaseDir = './src/c
 
       await fs.writeFile(zipFilePath, buffer);
     } catch (writeError) {
-      spinner.fail(`${consoleTag}读取组件源码文件失败:`, writeError.message);
+      errorLog(`读取组件源码文件失败: ${writeError.message}`, spinner);
       throw writeError;
     }
 
@@ -196,7 +197,7 @@ module.exports = async function (cmpZipUrl, cmpName, componentBaseDir = './src/c
     const cmpSourcePath = path.join(extractPath, componentBaseDir, finalCmpName);
 
     if (!fs.existsSync(cmpSourcePath)) {
-      spinner.fail(`${consoleTag}解压后的 zip 包中未找到 ${finalCmpName} 组件源码目录。`);
+      errorLog(`解压后的 zip 包中未找到 ${finalCmpName} 组件源码目录。`, spinner);
       // 只删除解压目录，保留 zip 源文件
       await fs.remove(extractPath);
       return false;
@@ -210,7 +211,7 @@ module.exports = async function (cmpZipUrl, cmpName, componentBaseDir = './src/c
     try {
       await fs.copy(cmpSourcePath, targetComponentsDir);
     } catch (err) {
-      spinner.fail(`${consoleTag}自定义组件模板下载失败：${err.message || err}`);
+      errorLog(`自定义组件模板下载失败：${err.message || err}`, spinner);
       // 只删除解压目录，保留 zip 源文件
       await fs.remove(extractPath);
       return false;
@@ -271,13 +272,13 @@ module.exports = async function (cmpZipUrl, cmpName, componentBaseDir = './src/c
               );
               const newDeps = Object.keys(newPackageJsonDeps);
               if (newDeps.length > 0) {
-                console.warn(
-                  `${consoleTag}检测到 package.json 中新增了 ${
+                warningLog(
+                  `检测到 package.json 中新增了 ${
                     newDeps.length
                   } 个依赖包：${newDeps.join(', ')}`
                 );
-                console.warn(
-                  `${consoleTag}为确保组件正常运行，请执行以下命令安装依赖：npm install 或 yarn install`
+                warningLog(
+                  `为确保组件正常运行，请执行以下命令安装依赖：npm install 或 yarn install`
                 );
               }
               // 合并 package.json：将源文件的配置合并到目标文件中
@@ -344,10 +345,10 @@ module.exports = async function (cmpZipUrl, cmpName, componentBaseDir = './src/c
             } else if (fileName === 'tsconfig.json') {
               // 处理 tsconfig.json 文件（当目标文件已存在时）
               try {
-                const sourceTsconfigJson = await fs.readJson(sourcePath);
+                const sourceTsconfigJson = parseTsConfigWithTypeScript(sourcePath);
                 // 先判断 targetPath 是否存在，如果存在则合并，否则直接写入
                 if (await fs.pathExists(targetPath)) {
-                  const targetTsconfigJson = await fs.readJson(targetPath);
+                  const targetTsconfigJson = parseTsConfigWithTypeScript(targetPath);
                   // 合并配置：源配置合并到目标配置（目标配置优先级更高）
                   const mergedTsconfigJson = _.merge({}, sourceTsconfigJson, targetTsconfigJson);
                   // 使用 writeJson 写入，确保 JSON 格式正确（所有键名都会被正确序列化）
@@ -374,11 +375,11 @@ module.exports = async function (cmpZipUrl, cmpName, componentBaseDir = './src/c
 
     // 清理解压目录，保留 zip 源文件
     await fs.remove(extractPath);
-    spinner.succeed(`${consoleTag}已成功从 zip 包解析自定义组件（${finalCmpName}）!`);
+    successLog(`已成功从 zip 包解析自定义组件（${finalCmpName}）!`, spinner);
 
     return true;
   } catch (error) {
-    spinner.fail(`${consoleTag}从 zip 包创建自定义组件失败（${finalCmpName}）：`, error);
+    errorLog(`从 zip 包创建自定义组件失败（${finalCmpName}）：${error.message || error}`, spinner);
     // 清理解压目录，保留 zip 源文件
     const extractPath = path.join(tempDir, finalCmpName);
     if (await fs.pathExists(extractPath)) {

package/src/utils/cmpUtils/deleteCmp.js

@@ -1,5 +1,6 @@
 const ora = require('ora');
 const NeoService = require('../../neo/neoService');
+const { errorLog, successLog } = require('../common');
 
 /**
  * 从 NeoCRM 删除自定义组件
@@ -14,7 +15,7 @@ const NeoService = require('../../neo/neoService');
  */
 const deleteCmp = async (cmpType, authConfig, _neoService) => {
   if (!authConfig) {
-    console.error('未找到 NeoCRM 平台授权配置（neo.config.js / authConfig）。');
+    errorLog('未找到 NeoCRM 平台授权配置（neo.config.js / authConfig）。');
     return;
   }
 
@@ -38,23 +39,23 @@ const deleteCmp = async (cmpType, authConfig, _neoService) => {
     }
 
     if (cmpList.length === 0) {
-      spinner.fail('删除失败，当前租户暂无任何自定义组件。');
+      errorLog('删除失败，当前租户暂无任何自定义组件。', spinner);
       process.exit(1);
     }
 
     // 获取自定义组件信息
     cmpInfo = neoService.getCmpInfoByCmpType(cmpType);
     if (!cmpInfo) {
-      spinner.fail(`删除失败，当前租户不存在${cmpType}自定义组件。`);
+      errorLog(`删除失败，当前租户不存在${cmpType}自定义组件。`, spinner);
       process.exit(1);
     }
 
     // 调用删除 API
     spinner.info(`正在删除${cmpType}自定义组件...`);
     await neoService.deleteCmp(cmpType);
-    spinner.succeed(`已成功删除${cmpType}自定义组件！\n`);
+    successLog(`已成功删除${cmpType}自定义组件！\n`, spinner);
   } catch (error) {
-    spinner.fail(`删除自定义组件失败: ${error.message}`);
+    errorLog(`删除自定义组件失败: ${error.message}`, spinner);
     process.exit(1);
   }
 };

package/src/utils/cmpUtils/pullCmp.js

@@ -3,7 +3,7 @@ const { catchCurPackageJson } = require('../pathUtils');
 const getConfigObj = require('../getConfigObj');
 const ora = require('ora');
 const NeoService = require('../../neo/neoService');
-const { getFramework } = require('../common');
+const { getFramework, errorLog, successLog } = require('../common');
 const getCmpTypeByDir = require('./getCmpTypeByDir.js');
 const createCmpByZip = require('./createCmpByZip.js');
 
@@ -27,13 +27,13 @@ const framework = getFramework(currentPackageJson.framework);
  */
 const pullCmp = async (cmpType, authConfig, _neoService) => {
   if (!authConfig) {
-    console.error('未找到 NeoCRM 平台授权配置（neo.config.js / authConfig）。');
+    errorLog('未找到 NeoCRM 平台授权配置（neo.config.js / authConfig）。');
     return;
   }
 
   const cmpTypes = getCmpTypeByDir(); // 获取当前项目目录中已存在的自定义组件类型
   if (cmpTypes.indexOf(cmpType) > -1) {
-    console.error(`当前项目目录中已存在${cmpType}自定义组件。（./src/components 目录下）`);
+    errorLog(`当前项目目录中已存在${cmpType}自定义组件。（./src/components 目录下）`);
     process.exit(1);
   }
 
@@ -60,26 +60,26 @@ const pullCmp = async (cmpType, authConfig, _neoService) => {
     }
 
     if (cmpList.length === 0) {
-      spinner.fail('拉取失败，当前租户暂无任何自定义组件。');
+      errorLog('拉取失败，当前租户暂无任何自定义组件。', spinner);
       process.exit(1);
     }
 
     // 获取自定义组件信息
     cmpInfo = neoService.getCmpInfoByCmpType(cmpType);
     if (!cmpInfo) {
-      spinner.fail(`拉取失败，当前租户不存在${cmpType}自定义组件。`);
+      errorLog(`拉取失败，当前租户不存在${cmpType}自定义组件。`, spinner);
       process.exit(1);
     }
 
     // 判断拉取的组件和当前项目是否为同一技术栈
     if (cmpInfo.framework !== framework) {
-      spinner.fail(`拉取失败，${cmpType}自定义组件与当前项目技术栈不一致。`);
+      errorLog(`拉取失败，${cmpType}自定义组件与当前项目技术栈不一致。`, spinner);
       process.exit(1);
     }
 
     // 获取当前源码
     if (!cmpInfo.codeLib) {
-      spinner.fail(`拉取失败，${cmpType}自定义组件未记录对应的源码文件。`);
+      errorLog(`拉取失败，${cmpType}自定义组件未记录对应的源码文件。`, spinner);
       process.exit(1);
     }
 
@@ -89,13 +89,13 @@ const pullCmp = async (cmpType, authConfig, _neoService) => {
     // 将zip 包里面的自定义组件源码解析到 src/components 目录下
     const cmpResult = await createCmpByZip(codeLib, cmpType, './src/components');
     if (!cmpResult) {
-      spinner.fail(`拉取失败，${cmpType}自定义组件源码解析失败，请检查源码文件是否正确。`);
+      errorLog(`拉取失败，${cmpType}自定义组件源码解析失败，请检查源码文件是否正确。`, spinner);
       process.exit(1);
     }
 
-    spinner.succeed(`已成功拉取${cmpType}自定义组件！\n`);
+    successLog(`已成功拉取${cmpType}自定义组件！\n`, spinner);
   } catch (error) {
-    spinner.fail(`拉取自定义组件失败: ${error.message}`);
+    errorLog(`拉取自定义组件失败: ${error.message}`, spinner);
     throw error;
   }
 };

package/src/utils/cmpUtils/pushCmp.js

@@ -5,7 +5,7 @@ const { catchCurPackageJson } = require('../pathUtils');
 const getConfigObj = require('../getConfigObj');
 const ora = require('ora');
 const NeoService = require('../../neo/neoService');
-const { getFramework } = require('../common');
+const { getFramework, errorLog, successLog } = require('../common');
 const createCmpProjectZip = require('../projectUtils/createCmpProjectZip');
 
 // 获取当前项目的package文件
@@ -20,14 +20,14 @@ const currentPackageJson = getConfigObj(currentPackageJsonDir);
  */
 const buildComponentData = async (assetsRoot, cmpInfo) => {
   if (!cmpInfo || !cmpInfo.cmpType) {
-    console.error('自定义组件信息或组件名称不能为空');
+    errorLog('自定义组件信息或组件名称不能为空');
     return null;
   }
 
   const { cmpType } = cmpInfo;
 
   if (!assetsRoot || !fs.existsSync(assetsRoot)) {
-    console.error(`未找到自定义组件目录: ${assetsRoot}`);
+    errorLog(`未找到自定义组件目录: ${assetsRoot}`);
     return null;
   }
   const widgetName = _.camelCase(cmpType);
@@ -53,11 +53,11 @@ const buildComponentData = async (assetsRoot, cmpInfo) => {
       // 获取导出的模型类（可能是 default 导出或命名导出）
       // const CatchCustomCmpModelClass = modelModule.default || modelModule;
     } else {
-      console.error(`未找到自定义组件模型文件，请检查以下路径是否存在：`, modelFile);
+      errorLog(`未找到自定义组件模型文件，请检查以下路径是否存在：${modelFile}`);
       return null;
     }
     if (!globalThis.window || !globalThis.window.NEOEditorCustomModels) {
-      console.error(
+      errorLog(
         `模型文件未导出有效模型方法（CatchCustomCmpModelClass），模型文件地址： ${modelFile} `
       );
       return null;
@@ -65,14 +65,14 @@ const buildComponentData = async (assetsRoot, cmpInfo) => {
 
     const ModelClass = globalThis.window.NEOEditorCustomModels[cmpType];
     if (!ModelClass) {
-      console.error(`未找到自定义组件模型类（${cmpType}），模型文件地址： ${modelFile} `);
+      errorLog(`未找到自定义组件模型类（${cmpType}），模型文件地址： ${modelFile} `);
       return null;
     }
     // 实例化模型类
     const modelInstance = new ModelClass();
 
     if (!modelInstance) {
-      console.error(`未找到自定义组件模型信息（${cmpType}），模型文件地址： ${modelFile} `);
+      errorLog(`未找到自定义组件模型信息（${cmpType}），模型文件地址： ${modelFile} `);
       return null;
     }
 
@@ -104,8 +104,8 @@ const buildComponentData = async (assetsRoot, cmpInfo) => {
     console.log(`自定义组件模型信息（${cmpType}）:`, curCmpInfo);
     return curCmpInfo;
   } catch (error) {
-    console.error(`自定义组件模型文件解析失败 (${modelFile || '未知路径'}):`, error.message);
-    console.error(error.stack);
+    errorLog(`自定义组件模型文件解析失败 (${modelFile || '未知路径'}): ${error.message}`);
+    errorLog(error.stack);
     return null;
   } finally {
     // 恢复原始的 window 对象（如果之前存在）
@@ -132,7 +132,7 @@ const pushCmp = async (config, cmpType) => {
   const { auth: credentials } = config;
 
   if (!credentials) {
-    console.error('未找到 NeoCRM 平台授权配置（neo.config.js / neoConfig）');
+    errorLog('未找到 NeoCRM 平台授权配置（neo.config.js / neoConfig）');
     return;
   }
 
@@ -150,12 +150,12 @@ const pushCmp = async (config, cmpType) => {
     try {
       zipPath = createCmpProjectZip(cmpType, process.cwd(), config.assetsRoot);
       if (!zipPath) {
-        spinner.fail('[1/4] 源码文件打包失败，未返回 zip 文件路径。');
+        errorLog('[1/4] 源码文件打包失败，未返回 zip 文件路径。', spinner);
       } else {
-        spinner.succeed(`[1/4] 源码文件打包完成: ${path.basename(zipPath)}。`);
+        successLog(`[1/4] 源码文件打包完成: ${path.basename(zipPath)}。`, spinner);
       }
     } catch (error) {
-      spinner.fail(`[1/4] 源码文件打包失败。`);
+      errorLog(`[1/4] 源码文件打包失败。`, spinner);
     }
 
     // 步骤 3: 上传构建后资源文件
@@ -164,12 +164,12 @@ const pushCmp = async (config, cmpType) => {
     try {
       cmpInfo = await neoService.publish2oss(cmpType);
       if (!cmpInfo || !cmpInfo.cmpType) {
-        spinner.fail('[2/4] 上传构建产物失败，未获取到组件信息。');
+        errorLog('[2/4] 上传构建产物失败，未获取到组件信息。', spinner);
       } else {
-        spinner.succeed(`[2/4] 构建产物上传完成。`);
+        successLog(`[2/4] 构建产物上传完成。`, spinner);
       }
     } catch (error) {
-      spinner.fail(`[2/4] 构建产物上传失败。`);
+      errorLog(`[2/4] 构建产物上传失败。`, spinner);
     }
 
     // 步骤 4: 构建组件数据
@@ -178,21 +178,21 @@ const pushCmp = async (config, cmpType) => {
     try {
       componentInfo = await buildComponentData(config.assetsRoot, cmpInfo);
       if (!componentInfo) {
-        spinner.fail(`[3/4] 未获取到自定义组件模型信息（${cmpType}）。`);
+        errorLog(`[3/4] 未获取到自定义组件模型信息（${cmpType}）。`, spinner);
       } else {
-        spinner.succeed(`[3/4] 组件数据构建完成。`);
+        successLog(`[3/4] 组件数据构建完成。`, spinner);
       }
     } catch (error) {
-      spinner.fail(`[3/4] 组件数据构建失败: `, error.message);
+      errorLog(`[3/4] 组件数据构建失败: ${error.message}`, spinner);
     }
 
     // 步骤 5: 保存组件信息
     spinner.start(`[4/4] 保存组件信息到 NeoCRM 平台...`);
     try {
       await neoService.updateCustomComponent(componentInfo);
-      spinner.succeed(`[4/4] 组件信息保存成功`);
+      successLog(`[4/4] 组件信息保存成功`, spinner);
     } catch (error) {
-      spinner.fail(`[4/4] 组件信息保存失败`);
+      errorLog(`[4/4] 组件信息保存失败`, spinner);
     }
 
     // 最终成功提示
@@ -203,11 +203,11 @@ const pushCmp = async (config, cmpType) => {
     try {
       // ora 的 spinner 对象可能没有 isSpinning 属性，使用 try-catch 安全访问
       if (spinner && spinner.isSpinning) {
-        spinner.fail(`❌ 自定义组件发布失败: ${error.message}`);
+        errorLog(`❌ 自定义组件发布失败: ${error.message}`, spinner);
       }
     } catch {
       // 如果访问失败或 spinner 已停止，直接输出错误信息
-      console.error(`\n❌ 自定义组件发布失败: ${error.message}`);
+      errorLog(`\n❌ 自定义组件发布失败: ${error.message}`);
     }
     throw error;
   }

package/src/utils/common.js

@@ -1,4 +1,7 @@
+const chalk = require('chalk');
+const ts = require('typescript');
 const { consoleTag } = require('./neoParams');
+
 /**
  * 获取技术栈标识
  * 目的：兼容用户非标准写法
@@ -27,10 +30,10 @@ function getFramework(_framework) {
     case 'vue3.0':
     case 'vue 3.0':
       curFramework = 3;
-      console.error(`${consoleTag} 暂不支持 vue3.0 技术栈。`);
+      errorLog('暂不支持 vue3.0 技术栈。');
       break;
     case 'react-js':
-      console.error(`${consoleTag} 暂不支持 react-js 技术栈。`);
+      errorLog('暂不支持 react-js 技术栈。');
       curFramework = 0;
       break;
     case 'react':
@@ -43,6 +46,62 @@ function getFramework(_framework) {
   return curFramework;
 }
 
+// 输出红色字体的错误日志
+function errorLog(message, spinner) {
+  const errorMessage = `${consoleTag} ${chalk.red(message)}`;
+  if (spinner) {
+    spinner.fail(errorMessage);
+  } else { 
+    console.error(errorMessage);
+  }
+}
+
+// 输出黄色字体的警告日志
+function warningLog(message) {
+  const warningMessage = `${consoleTag} ${chalk.yellow(message)}`;
+  if (spinner) {
+    spinner.warn(warningMessage);
+  } else {
+    console.warn(warningMessage);
+  }
+}
+
+// 输出绿色字体的成功日志
+function successLog(message) {
+  const successMessage = `${consoleTag} ${chalk.green(message)}`;
+  if (spinner) {
+    spinner.succeed(successMessage);
+  } else {
+    console.log(successMessage);
+  }
+}
+
+/**
+ * 使用 TypeScript 官方 API 解析 tsconfig.json（推荐）
+ * 需要安装: npm install typescript --save-dev
+ * 优点: 官方支持，能正确处理 extends、注释等所有特性
+ */
+function parseTsConfigWithTypeScript(configPath) {
+  try {
+    const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+    
+    if (configFile.error) {
+      throw new Error(`解析 tsconfig.json 失败: ${configFile.error.messageText}`);
+    }
+    
+    return configFile.config;
+  } catch (error) {
+    if (error.code === 'MODULE_NOT_FOUND') {
+      throw new Error('请先安装 typescript: npm install typescript --save-dev');
+    }
+    throw error;
+  }
+}
+
 module.exports = {
-  getFramework
+  getFramework,
+  errorLog,
+  warningLog,
+  successLog,
+  parseTsConfigWithTypeScript
 };

package/src/utils/projectUtils/openProject.js

@@ -1,6 +1,8 @@
 const path = require('path');
 const { exec } = require('child_process');
 const ora = require('ora');
+const { consoleTag } = require('../neoParams');
+const { errorLog } = require('../common');
 
 /**
  * 打开自定义组件项目
@@ -45,7 +47,7 @@ module.exports = function (editorType, targetPath) {
   }
 
   if (commands.length === 0) {
-    console.error(`${consoleTag}不支持的操作系统: ${process.platform}`);
+    errorLog(`不支持的操作系统: ${process.platform}`);
     process.exit(1);
   }
 
@@ -54,14 +56,10 @@ module.exports = function (editorType, targetPath) {
   // 尝试执行命令列表中的第一个可用命令
   const tryCommand = (index) => {
     if (index >= commands.length) {
-      spinner.fail(
-        `${consoleTag}无法打开编辑器，已尝试所有可用方式。\n 请确保已安装 Cursor 或 Visual Studio Code 并将其添加到系统 PATH 中。`
+      errorLog(
+        `无法打开编辑器，已尝试所有可用方式。\n 请确保已安装 Cursor 或 Visual Studio Code 并将其添加到系统 PATH 中。`,
+        spinner
       );
-      if (isMac) {
-        console.error(
-          `${consoleTag}macOS 提示: 如果已安装编辑器，请确保在编辑器中通过 Command+Shift+P 执行 "Shell Command: Install 'code' command in PATH" 或类似命令。`
-        );
-      }
       process.exit(1);
     }
 

package/test/demo3.js

@@ -1,3 +1,3 @@
 const openEditor = require('../src/module/main').openEditor;
 
-openEditor('cursor', '/Users/liudan/neo-custom-widget/neo-cmp-cli/src/template/antd-custom-cmp-template'); 
+openEditor('auto', 'src');

package/test/deprecate-versions.js

@@ -0,0 +1,30 @@
+const { execSync } = require('child_process');
+
+// 所有需要废弃的版本（1.6.2 之前的所有版本）
+const versionsToDeprecate = ["1.6.2-beta.5"];
+
+const packageName = 'neo-cmp-cli';
+const deprecateMessage = '此版本为开发中版本（存在 bug），请升级到最新版本。';
+
+console.log(`开始标记 ${versionsToDeprecate.length} 个版本为废弃状态...\n`);
+
+let successCount = 0;
+let failCount = 0;
+
+versionsToDeprecate.forEach((version, index) => {
+  try {
+    const command = `npm deprecate ${packageName}@${version} "${deprecateMessage}"`;
+    console.log(`[${index + 1}/${versionsToDeprecate.length}] 正在标记 ${version}...`);
+    execSync(command, { stdio: 'inherit' });
+    successCount++;
+    console.log(`✓ ${version} 已成功标记\n`);
+  } catch (error) {
+    failCount++;
+    console.error(`✗ ${version} 标记失败: ${error.message}\n`);
+  }
+});
+
+console.log('\n========================================');
+console.log(`完成！成功: ${successCount}, 失败: ${failCount}`);
+console.log('========================================');
+