daodou-command 1.4.8 → 1.4.9

package/lib/commands/lang.js

@@ -19,152 +19,106 @@ class LangCommand {
    */
   async add(key, value, options = {}) {
     if (!key) {
-      console.error(chalk.red('❌ 请提供键名'));
+      console.error(chalk.red('  ✖ 请提供键名'));
       process.exit(1);
     }
 
-    // 如果没有指定 value，则使用 key 作为 value
     const finalValue = value || key;
-
     const defaultLang = this.config.defaultLang || 'en';
     const dir = options.dir || this.config.defaultDir || './public/locales';
     const fileName = this.config.fileName || 'common.json';
 
-    console.log(chalk.blue('🔧 多语言文件管理工具启动中...\n'));
+    console.log('');
+    console.log(chalk.bold('  🌐 多语言管理工具'));
+    console.log(chalk.dim('  ─────────────────────────'));
 
     try {
-      // 获取语言列表
       const languages = await this.getLanguages(dir, options.lang);
-      
+
       if (languages.length === 0) {
-        console.log(chalk.yellow('⚠️ 未找到任何语言目录'));
+        console.log(chalk.yellow('  ⚠ 未找到任何语言目录'));
         return;
       }
 
-      console.log(chalk.green(`✅ 发现语言: ${languages.join(', ')}\n`));
-
-      // 开始翻译流程
-      console.log(chalk.blue('🌐 开始翻译流程...'));
-      console.log(chalk.blue(`📊 进度: 0/${languages.length} 语言完成\n`));
+      console.log('  ' + chalk.dim('键名') + '  ' + chalk.cyan(key));
+      console.log('  ' + chalk.dim('原文') + '  ' + chalk.cyan(finalValue));
+      console.log('  ' + chalk.dim('语言') + '  ' + chalk.cyan(languages.join(', ')));
+      console.log(chalk.dim('  ─────────────────────────'));
+      console.log('');
 
-      // 统计变量
       let successCount = 0;
       let skipCount = 0;
       let failCount = 0;
       const results = {};
 
-      // 顺序处理每个语言
       for (let i = 0; i < languages.length; i++) {
         const langCode = languages[i];
         const filePath = path.join(dir, langCode, fileName);
-        
-        // 显示分隔线
-        console.log(chalk.gray('────────────────────────────────────────'));
-        
-        // 显示当前处理的语言
         const isDefault = this.translationService.isDefaultLanguage(langCode, defaultLang);
-        const langDisplay = isDefault ? `${langCode} (默认语言)` : langCode;
-        console.log(chalk.blue(`📝 正在处理语言: ${langDisplay}`));
+        const langLabel = isDefault ? `${langCode} ${chalk.dim('(默认)')}` : langCode;
+        const spinner = ora({ text: `${langLabel} 处理中...`, indent: 2 }).start();
 
         try {
-          // 步骤 1: 检查 key 是否存在
-          console.log(chalk.blue(`  🔍 步骤 1/${isDefault ? '3' : '4'}: 检查 key "${key}" 是否存在...`));
-          
-          if (fs.existsSync(filePath)) {
-            const fileContent = fs.readFileSync(filePath, 'utf8');
-            const data = JSON.parse(fileContent);
-            
-            if (data[key] !== undefined) {
-              console.log(chalk.yellow(`  ⚠️ key "${key}" 已存在，跳过该语言`));
-              console.log(chalk.gray(`  📄 结果: 跳过`));
-              results[langCode] = { status: 'skipped', reason: 'key 已存在' };
-              skipCount++;
-              continue;
-            }
-          } else {
-            console.log(chalk.yellow(`  ⚠️ 文件 ${filePath} 不存在，跳过该语言`));
-            console.log(chalk.gray(`  📄 结果: 跳过`));
+          if (!fs.existsSync(filePath)) {
+            spinner.warn(`${langLabel} ${chalk.dim('文件不存在，跳过')}`);
             results[langCode] = { status: 'skipped', reason: '文件不存在' };
             skipCount++;
             continue;
           }
 
-          console.log(chalk.green(`  ✅ key "${key}" 不存在，可以添加`));
+          const fileContent = fs.readFileSync(filePath, 'utf8');
+          const data = JSON.parse(fileContent);
+
+          if (data[key] !== undefined) {
+            spinner.warn(`${langLabel} ${chalk.dim('key 已存在，跳过')}`);
+            results[langCode] = { status: 'skipped', reason: 'key 已存在' };
+            skipCount++;
+            continue;
+          }
 
           let translatedValue = finalValue;
 
-          if (isDefault) {
-            // 默认语言直接写入
-            console.log(chalk.blue(`  ⚡ 步骤 2/3: 默认语言直接写入...`));
-            console.log(chalk.green(`  ✅ 步骤 3/3: 成功写入文件`));
-            console.log(chalk.gray(`  📄 结果: "${key}": "${translatedValue}"`));
-          } else {
-            // 其他语言需要翻译
+          if (!isDefault) {
+            spinner.text = `${langLabel} 翻译中...`;
             const translationResult = await this.translationService.translateText(finalValue, langCode, defaultLang);
-            
             if (translationResult.success) {
               translatedValue = translationResult.result;
-              console.log(chalk.green(`  ✅ 步骤 4/4: 成功写入文件`));
-              console.log(chalk.gray(`  📄 结果: "${key}": "${translatedValue}"`));
             } else {
-              console.log(chalk.gray(`  📄 结果: 跳过`));
+              spinner.fail(`${langLabel} ${chalk.dim('翻译失败')}`);
               results[langCode] = { status: 'skipped', reason: '翻译失败' };
               skipCount++;
               continue;
             }
           }
 
-          // 写入文件
           await this.langFileManager.addKey(filePath, key, translatedValue);
-          
-          results[langCode] = { 
-            status: 'success', 
-            value: translatedValue,
-            originalValue: finalValue
-          };
-          successCount++;
+          spinner.succeed(`${langLabel} ${chalk.dim(translatedValue)}`);
 
+          results[langCode] = { status: 'success', value: translatedValue, originalValue: finalValue };
+          successCount++;
         } catch (error) {
-          console.log(chalk.red(`  ❌ 处理失败: ${error.message}`));
-          console.log(chalk.gray(`  📄 结果: 失败`));
+          spinner.fail(`${langLabel} ${chalk.dim(error.message)}`);
           results[langCode] = { status: 'failed', error: error.message };
           failCount++;
         }
 
-        // 显示进度
-        console.log(chalk.blue(`📊 进度: ${i + 1}/${languages.length} 语言完成`));
-
-        // 等待 0.5 秒后处理下一个语言（除了最后一个）
-        if (i < languages.length - 1) {
-          console.log(chalk.gray('\n⏳ 等待 0.5s 后处理下一个语言...\n'));
+        if (i < languages.length - 1 && !isDefault) {
           await this.translationService.delay(500);
         }
       }
 
-      // 显示最终结果
-      console.log(chalk.gray('\n────────────────────────────────────────'));
-      console.log(chalk.green('🎉 翻译流程完成！\n'));
-
-      console.log(chalk.blue('📊 最终统计:'));
-      console.log(chalk.green(`  ✅ 成功: ${successCount} 个语言`));
-      console.log(chalk.yellow(`  ⏭️ 跳过: ${skipCount} 个语言`));
-      console.log(chalk.red(`  ❌ 失败: ${failCount} 个语言`));
-
-
-      console.log(chalk.blue('\n📋 翻译结果汇总:'));
-      console.log(chalk.gray(`原文: "${finalValue}"`));
-      for (const [lang, result] of Object.entries(results)) {
-        if (result.status === 'success') {
-          console.log(chalk.green(`  ${lang}: ${result.value}`));
-        } else if (result.status === 'skipped') {
-          console.log(chalk.yellow(`  ${lang}: 跳过 (${result.reason})`));
-        } else {
-          console.log(chalk.red(`  ${lang}: 失败 (${result.error})`));
-        }
-      }
+      // 统计
+      console.log('');
+      console.log(chalk.dim('  ─────────────────────────'));
+      const parts = [];
+      if (successCount > 0) parts.push(chalk.green(`${successCount} 成功`));
+      if (skipCount > 0) parts.push(chalk.yellow(`${skipCount} 跳过`));
+      if (failCount > 0) parts.push(chalk.red(`${failCount} 失败`));
+      console.log('  ' + parts.join(chalk.dim(' / ')));
+      console.log('');
 
     } catch (error) {
-      console.error(chalk.red('❌ 操作失败:'), error.message);
+      console.error(chalk.red('  ✖ ' + error.message));
       process.exit(1);
     }
   }
@@ -174,59 +128,66 @@ class LangCommand {
    */
   async remove(key, options = {}) {
     if (!key) {
-      console.error(chalk.red('❌ 请提供键名'));
+      console.error(chalk.red('  ✖ 请提供键名'));
       process.exit(1);
     }
 
-    const lang = options.lang || this.config.defaultLang || 'en';
     const dir = options.dir || this.config.defaultDir || './public/locales';
     const fileName = this.config.fileName || 'common.json';
 
-    console.log(chalk.blue('🔧 多语言文件管理工具启动中...\n'));
+    console.log('');
+    console.log(chalk.bold('  🌐 多语言管理工具'));
+    console.log(chalk.dim('  ─────────────────────────'));
+    console.log('  ' + chalk.dim('操作') + '  ' + chalk.cyan('删除'));
+    console.log('  ' + chalk.dim('键名') + '  ' + chalk.cyan(key));
 
     try {
-      // 获取语言列表
       const languages = await this.getLanguages(dir, options.lang);
-      
+
       if (languages.length === 0) {
-        console.log(chalk.yellow('⚠️ 未找到任何语言目录'));
+        console.log(chalk.yellow('  ⚠ 未找到任何语言目录'));
         return;
       }
 
-      console.log(chalk.green(`✅ 发现语言: ${languages.join(', ')}\n`));
+      console.log('  ' + chalk.dim('语言') + '  ' + chalk.cyan(languages.join(', ')));
+      console.log(chalk.dim('  ─────────────────────────'));
+      console.log('');
 
-      // 批量处理每个语言
       let successCount = 0;
       let skipCount = 0;
 
       for (const langCode of languages) {
         const filePath = path.join(dir, langCode, fileName);
-        
+        const spinner = ora({ text: `${langCode} 处理中...`, indent: 2 }).start();
+
         try {
           const result = await this.langFileManager.removeKey(filePath, key);
           if (result.success) {
-            console.log(chalk.green(`✅ 成功删除 "${key}" 从 ${langCode}`));
+            spinner.succeed(`${langCode} ${chalk.dim('已删除')}`);
             successCount++;
           } else if (result.notFound) {
-            console.log(chalk.yellow(`⚠️ 跳过 "${key}" 在 ${langCode} (未找到)`));
+            spinner.warn(`${langCode} ${chalk.dim('未找到，跳过')}`);
             skipCount++;
           }
         } catch (error) {
-          if (error.message.includes('目录不存在')) {
-            console.log(chalk.yellow(`⚠️ 跳过 ${langCode} (目录不存在)`));
-          } else if (error.message.includes('文件不存在')) {
-            console.log(chalk.yellow(`⚠️ 跳过 ${langCode} (文件不存在)`));
+          if (error.message.includes('目录不存在') || error.message.includes('文件不存在')) {
+            spinner.warn(`${langCode} ${chalk.dim('文件不存在，跳过')}`);
           } else {
-            console.log(chalk.red(`❌ 处理 ${langCode} 失败: ${error.message}`));
+            spinner.fail(`${langCode} ${chalk.dim(error.message)}`);
           }
         }
       }
 
-      // 显示统计结果
-      console.log(chalk.blue(`\n📊 处理完成: 成功 ${successCount} 个, 跳过 ${skipCount} 个`));
+      console.log('');
+      console.log(chalk.dim('  ─────────────────────────'));
+      const parts = [];
+      if (successCount > 0) parts.push(chalk.green(`${successCount} 删除`));
+      if (skipCount > 0) parts.push(chalk.yellow(`${skipCount} 跳过`));
+      console.log('  ' + parts.join(chalk.dim(' / ')));
+      console.log('');
 
     } catch (error) {
-      console.error(chalk.red('❌ 操作失败:'), error.message);
+      console.error(chalk.red('  ✖ ' + error.message));
       process.exit(1);
     }
   }
@@ -235,28 +196,23 @@ class LangCommand {
    * 获取语言列表
    */
   async getLanguages(dir, specifiedLang) {
-    // 如果指定了语言，只处理该语言
     if (specifiedLang) {
       return [specifiedLang];
     }
 
-    // 否则扫描目录下的所有语言文件夹
     try {
       if (!fs.existsSync(dir)) {
-        console.log(chalk.yellow(`⚠️ 目录不存在: ${dir}`));
+        console.log(chalk.yellow(`  ⚠ 目录不存在: ${dir}`));
         return [];
       }
 
       const items = fs.readdirSync(dir);
-      const languages = items.filter(item => {
+      return items.filter(item => {
         const itemPath = path.join(dir, item);
         return fs.statSync(itemPath).isDirectory();
       });
-
-      console.log(chalk.blue(`🔍 扫描目录 ${dir}: 发现 ${languages.length} 个语言`));
-      return languages;
     } catch (error) {
-      console.log(chalk.red(`❌ 扫描目录失败: ${error.message}`));
+      console.log(chalk.red(`  ✖ 扫描目录失败: ${error.message}`));
       return [];
     }
   }

package/lib/commands/upgrade.js

@@ -6,7 +6,6 @@ const packageJson = require('../../package.json');
 
 /**
  * 获取npm上的最新版本号
- * @returns {Promise<string>} 最新版本号
  */
 async function getLatestVersion() {
   try {
@@ -21,7 +20,6 @@ async function getLatestVersion() {
 
 /**
  * 获取当前安装的版本号
- * @returns {string} 当前版本号
  */
 function getCurrentVersion() {
   return packageJson.version;
@@ -29,117 +27,79 @@ function getCurrentVersion() {
 
 /**
  * 比较版本号
- * @param {string} current 当前版本
- * @param {string} latest 最新版本
- * @returns {boolean} 是否有更新
  */
 function hasUpdate(current, latest) {
   const currentParts = current.split('.').map(Number);
   const latestParts = latest.split('.').map(Number);
-  
+
   for (let i = 0; i < Math.max(currentParts.length, latestParts.length); i++) {
     const currentPart = currentParts[i] || 0;
     const latestPart = latestParts[i] || 0;
-    
-    if (latestPart > currentPart) {
-      return true;
-    } else if (latestPart < currentPart) {
-      return false;
-    }
-  }
-  
-  return false;
-}
 
-/**
- * 执行npm更新
- * @param {string} version 要更新的版本
- */
-function updatePackage(version) {
-  try {
-    console.log(chalk.blue(`正在更新到版本 ${version}...`));
-    execSync(`npm install -g ${packageJson.name}@${version} --force`, { 
-      stdio: 'inherit',
-      timeout: 300000 // 5分钟超时
-    });
-    console.log(chalk.green(`✅ 成功更新到版本 ${version}`));
-  } catch (error) {
-    throw new Error(`更新失败: ${error.message}`);
+    if (latestPart > currentPart) return true;
+    if (latestPart < currentPart) return false;
   }
-}
 
-/**
- * 显示更新信息
- * @param {string} current 当前版本
- * @param {string} latest 最新版本
- * @param {boolean} hasUpdateAvailable 是否有更新
- */
-function displayUpdateInfo(current, latest, hasUpdateAvailable) {
-  console.log(chalk.cyan('📦 daodou-command 版本信息:'));
-  console.log(`   当前版本: ${chalk.yellow(current)}`);
-  console.log(`   最新版本: ${chalk.yellow(latest)}`);
-  
-  if (hasUpdateAvailable) {
-    console.log(chalk.red('   ⚠️  有新版本可用！'));
-    console.log(chalk.gray('   使用 "dao update" 命令进行更新'));
-  } else {
-    console.log(chalk.green('   ✅ 已是最新版本'));
-  }
+  return false;
 }
 
 /**
  * 执行更新命令
- * @param {Object} options 命令选项
  */
 async function execute(options) {
-  const spinner = ora('检查更新中...').start();
-  
+  console.log('');
+  console.log(chalk.bold('  🔄 版本更新'));
+  console.log(chalk.dim('  ─────────────────────────'));
+
+  const spinner = ora({ text: '检查最新版本...', indent: 2 }).start();
+
   try {
-    // 获取版本信息
     const currentVersion = getCurrentVersion();
     const latestVersion = await getLatestVersion();
-    const hasUpdateAvailable = hasUpdate(currentVersion, latestVersion);
-    
-    spinner.stop();
-    
-    // 显示版本信息
-    displayUpdateInfo(currentVersion, latestVersion, hasUpdateAvailable);
-    
-    // 如果只是检查版本，直接返回
+    const updateAvailable = hasUpdate(currentVersion, latestVersion);
+
+    spinner.succeed('版本检查完成');
+
+    console.log('');
+    console.log('  ' + chalk.dim('当前') + '  v' + currentVersion);
+    console.log('  ' + chalk.dim('最新') + '  v' + latestVersion);
+    console.log(chalk.dim('  ─────────────────────────'));
+
     if (options.check) {
+      if (updateAvailable) {
+        console.log('');
+        console.log(chalk.yellow('  ⚠ 有新版本可用，运行 ') + chalk.cyan('dao upgrade') + chalk.yellow(' 更新'));
+      } else {
+        console.log(chalk.green('  ✔ 已是最新版本'));
+      }
+      console.log('');
       return;
     }
-    
-    // 如果没有更新且不是强制更新，提示用户
-    if (!hasUpdateAvailable && !options.force) {
-      console.log(chalk.gray('   无需更新'));
+
+    if (!updateAvailable && !options.force) {
+      console.log(chalk.green('  ✔ 已是最新版本'));
+      console.log('');
       return;
     }
-    
-    // 如果有更新或强制更新，执行更新
-    if (hasUpdateAvailable || options.force) {
-      console.log(); // 空行
-      
-      if (options.force && !hasUpdateAvailable) {
-        console.log(chalk.yellow('⚠️  强制更新到当前版本'));
-      }
-      
-      updatePackage(latestVersion);
-      
-      // 验证更新结果
-      console.log(chalk.blue('验证更新结果...'));
-      try {
-        const { execSync } = require('child_process');
-        const newVersion = execSync('dao --version', { encoding: 'utf8' }).trim();
-        console.log(chalk.green(`✅ 更新完成！当前版本: ${newVersion}`));
-      } catch (error) {
-        console.log(chalk.yellow('⚠️  更新完成，但无法验证版本号'));
-      }
+
+    if (options.force && !updateAvailable) {
+      console.log(chalk.yellow('  ⚠ 强制重新安装'));
+    }
+
+    console.log('');
+    const installSpinner = ora({ text: `安装 v${latestVersion}...`, indent: 2 }).start();
+    try {
+      execSync(`npm install -g ${packageJson.name}@${latestVersion} --force`, {
+        stdio: 'pipe',
+        timeout: 300000
+      });
+      installSpinner.succeed(`已更新到 v${latestVersion}`);
+    } catch (error) {
+      installSpinner.fail('安装失败 ' + chalk.dim(error.message));
     }
-    
+    console.log('');
   } catch (error) {
-    spinner.stop();
-    throw error;
+    spinner.fail('检查失败 ' + chalk.dim(error.message));
   }
 }
 

package/lib/translation/TranslationService.js

@@ -4,7 +4,6 @@
  */
 const { getEnginesByPriority, getEnabledEngines } = require('./engines');
 const { ConfigManager } = require('../utils/config');
-const chalk = require('chalk');
 
 class TranslationService {
   constructor() {
@@ -39,24 +38,17 @@ class TranslationService {
     // 按优先级尝试各个引擎
     for (const engine of this.engines) {
       try {
-        console.log(chalk.blue(`尝试使用 ${engine.getName()} 翻译...`));
-        
-        // 检查引擎是否可用
         const isAvailable = await engine.isAvailable();
         if (!isAvailable) {
-          console.log(chalk.yellow(`${engine.getName()} 不可用，跳过`));
           continue;
         }
 
-        // 执行翻译
         const result = await engine.translate(text, sourceLang, targetLang, options);
-        
+
         if (result.success) {
-          console.log(chalk.green(`翻译成功，使用引擎: ${engine.getName()}`));
           return result;
         }
       } catch (error) {
-        console.log(chalk.red(`${engine.getName()} 翻译失败: ${error.message}`));
         lastError = error;
         continue;
       }
@@ -80,10 +72,9 @@ class TranslationService {
     
     if (microsoftEngine && await microsoftEngine.isAvailable()) {
       try {
-        console.log(chalk.blue('使用微软翻译文档功能...'));
         return await microsoftEngine.translateDocumentation(text, sourceLang, targetLang, options);
       } catch (error) {
-        console.log(chalk.yellow('微软文档翻译失败，回退到普通翻译'));
+        // 回退到普通翻译
       }
     }
 
@@ -105,27 +96,18 @@ class TranslationService {
     // 按优先级尝试各个引擎
     for (const engine of this.engines) {
       try {
-        console.log(chalk.blue(`尝试使用 ${engine.getName()} 翻译HTML...`));
-        
-        // 检查引擎是否可用
         if (!(await engine.isAvailable())) {
-          console.log(chalk.yellow(`引擎 ${engine.getName()} 不可用，跳过`));
           continue;
         }
-        
-        // 执行HTML翻译
+
         const result = await engine.translateHtml(htmlContent, sourceLang, targetLang, options);
-        
+
         if (result && result.success) {
-          console.log(chalk.green(`HTML翻译成功，使用引擎: ${engine.getName()}`));
           return result;
         }
-        
       } catch (error) {
         lastError = error;
-        console.log(chalk.red(`引擎 ${engine.getName()} HTML翻译失败: ${error.message}`));
-        
-        // 如果是内容长度限制错误，直接抛出，不尝试其他引擎
+
         if (error.message.includes('内容过长') || error.message.includes('Content too long')) {
           throw error;
         }
@@ -148,7 +130,7 @@ class TranslationService {
         const languages = await engine.getSupportedLanguages();
         languages.forEach(lang => allLanguages.add(lang));
       } catch (error) {
-        console.log(chalk.yellow(`获取 ${engine.getName()} 支持语言失败: ${error.message}`));
+        // 获取失败不影响其他引擎
       }
     }
 

package/lib/translation/engines/microsoft/services/EdgeAuthService.js

@@ -60,8 +60,6 @@ class MicrosoftEdgeAuthService {
    */
   updateAccessToken(token) {
     const expirationTime = this.getExpirationTimeFromToken(token);
-    console.log(`更新访问令牌: ********, 过期时间: ${new Date(expirationTime)}`);
-    
     this.accessToken = token;
     this.expireAt = expirationTime - this.PRE_EXPIRATION;
     this.tokenPromise = null;

package/lib/utils/translation.js

@@ -20,20 +20,14 @@ class TranslationService {
    * @returns {Promise<{success: boolean, result: string, error: string}>}
    */
   async translateText(text, targetLang, sourceLang = 'en') {
-    console.log(chalk.blue(`  🌐 步骤 2/4: 开始翻译 "${text}"...`));
-    
     try {
       const result = await this.translationService.translate(text, sourceLang, targetLang);
-      
-      console.log(chalk.green(`  🔄 步骤 3/4: 翻译完成 "${text}" -> "${result.text}"`));
-      
       return {
         success: true,
         result: result.text,
         error: null
       };
     } catch (error) {
-      console.log(chalk.red(`  ❌ 翻译失败: ${error.message}`));
       return {
         success: false,
         result: null,
@@ -50,20 +44,14 @@ class TranslationService {
    * @returns {Promise<{success: boolean, result: string, error: string}>}
    */
   async translateHtml(htmlContent, targetLang, sourceLang = 'en') {
-    console.log(chalk.blue(`  🌐 步骤 2/4: 开始翻译HTML内容...`));
-    
     try {
       const result = await this.translationService.translateHtml(htmlContent, sourceLang, targetLang);
-      
-      console.log(chalk.green(`  🔄 步骤 3/4: HTML翻译完成`));
-      
       return {
         success: true,
         result: result.text,
         error: null
       };
     } catch (error) {
-      console.log(chalk.red(`  ❌ HTML翻译失败: ${error.message}`));
       return {
         success: false,
         result: null,
@@ -128,10 +116,11 @@ class TranslationService {
    */
   async showEngineStatus() {
     const status = await this.getEngineStatus();
-    console.log(chalk.blue('\n🔧 翻译引擎状态:'));
+    console.log('');
+    console.log(chalk.dim('  翻译引擎状态:'));
     status.forEach(engine => {
-      const statusColor = engine.available ? chalk.green : chalk.red;
-      console.log(chalk.gray(`  ${engine.name} (优先级: ${engine.priority}): ${statusColor(engine.status)}`));
+      const icon = engine.available ? chalk.green('✔') : chalk.red('✖');
+      console.log(`  ${icon} ${engine.name} ${chalk.dim(`(优先级 ${engine.priority})`)}`);
     });
   }
 }