daodou-command 1.3.0 → 1.4.1

package/lib/translation/engines/microsoft/MicrosoftTranslator.js

@@ -0,0 +1,190 @@
+/**
+ * 微软翻译引擎实现
+ * 基于Edge浏览器认证的免费翻译服务
+ */
+const BaseTranslator = require('../BaseTranslator');
+const MicrosoftTranslatorService = require('./services/TranslatorService');
+const { LANG_CODES, TEXT_TYPES } = require('./types');
+
+class MicrosoftTranslator extends BaseTranslator {
+  constructor(config = {}) {
+    super(config);
+    this.name = 'Microsoft Translator';
+    this.priority = 1; // 最高优先级
+    this.intervalLimit = 1000; // 1秒间隔限制
+    this.contentLengthLimit = 50000; // 50KB内容长度限制
+    
+    // 初始化翻译服务
+    this.service = new MicrosoftTranslatorService();
+  }
+
+  /**
+   * 获取翻译器名称
+   */
+  getName() {
+    return this.name;
+  }
+
+  /**
+   * 获取优先级
+   */
+  getPriority() {
+    return this.priority;
+  }
+
+  /**
+   * 检查翻译器是否可用
+   */
+  async isAvailable() {
+    try {
+      // 尝试获取访问令牌来检查服务是否可用
+      await this.service.httpClient.authService.getAccessToken();
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * 翻译文本
+   */
+  async translate(text, sourceLang, targetLang, options = {}) {
+    if (!text || !targetLang) {
+      throw new Error('文本和目标语言不能为空');
+    }
+
+    return await this.withRetry(async () => {
+      // 语言代码转换
+      const msSourceLang = this.convertLangCode(sourceLang);
+      const msTargetLang = this.convertLangCode(targetLang);
+      
+      // 执行翻译
+      const result = await this.service.translate(text, msSourceLang, msTargetLang, TEXT_TYPES.PLAIN);
+      
+      if (!result || !result.translations || result.translations.length === 0) {
+        throw new Error('翻译结果为空');
+      }
+
+      const translation = result.translations[0];
+      const detectedLang = result.detectedLanguage?.language || sourceLang;
+      
+      return {
+        text: translation.text || text,
+        sourceLang: detectedLang,
+        targetLang: targetLang,
+        engine: this.name,
+        success: true,
+        confidence: translation.confidence || 1.0,
+        alternatives: []
+      };
+    });
+  }
+
+  /**
+   * 翻译HTML文档
+   */
+  async translateHtml(htmlContent, sourceLang, targetLang, options = {}) {
+    if (!htmlContent || !targetLang) {
+      throw new Error('HTML内容和目标语言不能为空');
+    }
+
+    return await this.withRetry(async () => {
+      // 语言代码转换
+      const msSourceLang = this.convertLangCode(sourceLang);
+      const msTargetLang = this.convertLangCode(targetLang);
+      
+      // 执行HTML翻译
+      const result = await this.service.translate(htmlContent, msSourceLang, msTargetLang, TEXT_TYPES.HTML);
+      
+      if (!result || !result.translations || result.translations.length === 0) {
+        throw new Error('HTML翻译结果为空');
+      }
+
+      const translation = result.translations[0];
+      const detectedLang = result.detectedLanguage?.language || sourceLang;
+      
+      return {
+        text: translation.text || htmlContent,
+        sourceLang: detectedLang,
+        targetLang: targetLang,
+        engine: this.name,
+        success: true,
+        confidence: translation.confidence || 1.0,
+        alternatives: []
+      };
+    });
+  }
+
+  /**
+   * 获取支持的语言列表
+   */
+  async getSupportedLanguages() {
+    try {
+      const languages = await this.service.getSupportedLanguages();
+      return Object.keys(languages);
+    } catch (error) {
+      // 返回默认支持的语言列表
+      return Object.values(LANG_CODES);
+    }
+  }
+
+  /**
+   * 语言代码转换
+   * 将标准语言代码转换为微软翻译API支持的语言代码
+   */
+  convertLangCode(langCode) {
+    const langMap = {
+      'zh': LANG_CODES.CHINESE_SIMPLIFIED,
+      'zh-CN': LANG_CODES.CHINESE_SIMPLIFIED,
+      'zh-TW': LANG_CODES.CHINESE_TRADITIONAL,
+      'en': LANG_CODES.ENGLISH,
+      'ja': LANG_CODES.JAPANESE,
+      'ko': LANG_CODES.KOREAN,
+      'fr': LANG_CODES.FRENCH,
+      'de': LANG_CODES.GERMAN,
+      'es': LANG_CODES.SPANISH,
+      'it': LANG_CODES.ITALIAN,
+      'pt': LANG_CODES.PORTUGUESE,
+      'ru': LANG_CODES.RUSSIAN,
+      'ar': LANG_CODES.ARABIC,
+      'th': LANG_CODES.THAI,
+      'vi': LANG_CODES.VIETNAMESE,
+      'auto': LANG_CODES.AUTO
+    };
+
+    return langMap[langCode] || langCode;
+  }
+
+  /**
+   * 翻译文档
+   */
+  async translateDocumentation(text, sourceLang, targetLang, options = {}) {
+    try {
+      const msSourceLang = this.convertLangCode(sourceLang);
+      const msTargetLang = this.convertLangCode(targetLang);
+      
+      const result = await this.service.translate(text, msSourceLang, msTargetLang, TEXT_TYPES.HTML);
+      
+      if (!result || !result.translations || result.translations.length === 0) {
+        throw new Error('文档翻译结果为空');
+      }
+
+      const translation = result.translations[0];
+      const detectedLang = result.detectedLanguage?.language || sourceLang;
+      
+      return {
+        text: translation.text || text,
+        sourceLang: detectedLang,
+        targetLang: targetLang,
+        engine: this.name,
+        success: true,
+        confidence: translation.confidence || 1.0,
+        alternatives: []
+      };
+    } catch (error) {
+      throw new Error(`微软翻译文档失败: ${error.message}`);
+    }
+  }
+}
+
+module.exports = MicrosoftTranslator;

package/lib/translation/engines/microsoft/index.js

@@ -0,0 +1,6 @@
+/**
+ * 微软翻译引擎入口
+ */
+const MicrosoftTranslator = require('./MicrosoftTranslator');
+
+module.exports = MicrosoftTranslator;

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

@@ -0,0 +1,166 @@
+/**
+ * Edge浏览器认证服务
+ * 模拟Edge浏览器的认证机制，获取免费的微软翻译API访问令牌
+ */
+const axios = require('axios');
+
+class MicrosoftEdgeAuthService {
+  constructor() {
+    this.accessToken = null;
+    this.expireAt = -1;
+    this.tokenPromise = null;
+    
+    // 常量定义
+    this.TIMEOUT = 60 * 1000; // 1分钟超时
+    this.PRE_EXPIRATION = 2 * 60 * 1000; // 提前2分钟刷新
+    this.DEFAULT_EXPIRATION = 10 * 60 * 1000; // 默认10分钟过期
+    this.AUTH_URL = 'https://edge.microsoft.com/translate/auth';
+    this.JWT_REGEX = /^[a-zA-Z0-9\-_]+(\.[a-zA-Z0-9\-_]+){2}$/;
+  }
+
+  /**
+   * 获取有效的访问令牌
+   * @returns {Promise<string>} 访问令牌
+   */
+  async getAccessToken() {
+    // 检查当前令牌是否仍然有效
+    const validToken = this.getValidAccessToken();
+    if (validToken) {
+      return validToken;
+    }
+
+    // 获取新的令牌
+    const promise = this.getTokenPromise();
+    try {
+      const token = await promise;
+      if (!token) {
+        throw new Error('无法获取访问令牌');
+      }
+      return token;
+    } catch (error) {
+      this.clearTokenPromise(promise);
+      throw new Error(`认证失败: ${error.message}`);
+    }
+  }
+
+  /**
+   * 获取有效的访问令牌（同步检查）
+   * @returns {string|null} 有效的访问令牌或null
+   */
+  getValidAccessToken() {
+    if (this.accessToken && Date.now() < this.expireAt) {
+      return this.accessToken;
+    }
+    return null;
+  }
+
+  /**
+   * 更新访问令牌
+   * @param {string} token 新的访问令牌
+   */
+  updateAccessToken(token) {
+    const expirationTime = this.getExpirationTimeFromToken(token);
+    console.log(`更新访问令牌: ********, 过期时间: ${new Date(expirationTime)}`);
+    
+    this.accessToken = token;
+    this.expireAt = expirationTime - this.PRE_EXPIRATION;
+    this.tokenPromise = null;
+  }
+
+  /**
+   * 获取令牌Promise
+   * @returns {Promise<string>} 令牌Promise
+   */
+  getTokenPromise() {
+    if (this.tokenPromise) {
+      return this.tokenPromise;
+    }
+
+    const promise = this.fetchAccessToken();
+    this.tokenPromise = promise;
+    return promise;
+  }
+
+  /**
+   * 从Edge认证服务获取访问令牌
+   * @returns {Promise<string>} 访问令牌
+   */
+  async fetchAccessToken() {
+    try {
+      const response = await axios.get(this.AUTH_URL, {
+        headers: {
+          'Accept': '*/*',
+          'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 Edg/120.0.0.0'
+        },
+        timeout: this.TIMEOUT
+      });
+
+      const token = response.data;
+      
+      // 验证JWT格式
+      if (!this.JWT_REGEX.test(token)) {
+        throw new Error('认证失败: 无效的令牌格式');
+      }
+
+      this.updateAccessToken(token);
+      return token;
+    } catch (error) {
+      console.warn('获取访问令牌失败:', error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * 清除令牌Promise
+   * @param {Promise} whosePromise 要清除的Promise
+   */
+  clearTokenPromise(whosePromise) {
+    if (whosePromise === this.tokenPromise) {
+      this.tokenPromise = null;
+    }
+  }
+
+  /**
+   * 从JWT令牌中提取过期时间
+   * @param {string} token JWT令牌
+   * @returns {number} 过期时间戳（毫秒）
+   */
+  getExpirationTimeFromToken(token) {
+    try {
+      const parts = token.split('.');
+      if (parts.length !== 3) {
+        throw new Error('无效的JWT格式');
+      }
+
+      const payload = parts[1];
+      const decoded = Buffer.from(payload, 'base64url').toString('utf-8');
+      const parsed = JSON.parse(decoded);
+      
+      // JWT的exp字段是秒，需要转换为毫秒
+      return parsed.exp * 1000;
+    } catch (error) {
+      console.warn('解析JWT令牌失败:', error.message);
+      // 返回默认过期时间
+      return Date.now() + this.DEFAULT_EXPIRATION - this.PRE_EXPIRATION / 2;
+    }
+  }
+}
+
+// 单例实例
+let instance = null;
+
+/**
+ * 获取MicrosoftEdgeAuthService单例实例
+ * @returns {MicrosoftEdgeAuthService} 服务实例
+ */
+function getAuthService() {
+  if (!instance) {
+    instance = new MicrosoftEdgeAuthService();
+  }
+  return instance;
+}
+
+module.exports = {
+  MicrosoftEdgeAuthService,
+  getAuthService
+};

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

@@ -0,0 +1,93 @@
+/**
+ * 微软翻译API客户端
+ * 处理与微软翻译API的所有HTTP通信
+ */
+const axios = require('axios');
+const { getAuthService } = require('./EdgeAuthService');
+
+class MicrosoftHttpClient {
+  constructor() {
+    this.baseURL = 'https://api.cognitive.microsofttranslator.com';
+    this.apiVersion = '3.0';
+    this.authService = getAuthService();
+  }
+
+  /**
+   * 发送POST请求到微软翻译API
+   * @param {string} endpoint API端点
+   * @param {any} data 请求数据
+   * @param {Object} options 请求选项
+   * @returns {Promise<any>} API响应
+   */
+  async post(endpoint, data, options = {}) {
+    try {
+      const token = await this.authService.getAccessToken();
+      const url = `${this.baseURL}${endpoint}?api-version=${this.apiVersion}`;
+      
+      const response = await axios.post(url, data, {
+        headers: {
+          'Authorization': `Bearer ${token}`,
+          'Content-Type': 'application/json',
+          'Accept': 'application/json',
+          'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+        },
+        params: {
+          ...options.params
+        },
+        timeout: 30000,
+        ...options
+      });
+
+      return response.data;
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+
+  /**
+   * 处理API错误
+   * @param {Error} error 错误对象
+   */
+  handleError(error) {
+    if (error.response) {
+      const status = error.response.status;
+      const statusText = error.response.statusText;
+      const errorData = error.response.data;
+      
+      console.error(`API请求失败: ${status} ${statusText}`, errorData);
+      
+      let message = `${status} ${statusText}`;
+      let code = status;
+      
+      if (errorData && errorData.error) {
+        message += ` - ${errorData.error.message || errorData.error}`;
+        code = errorData.error.code || status;
+      }
+      
+      throw new Error(`微软翻译API错误: ${message} (代码: ${code})`);
+    } else if (error.request) {
+      console.error('网络请求失败:', error.message);
+      throw new Error(`网络请求失败: ${error.message}`);
+    } else {
+      console.error('请求配置错误:', error.message);
+      throw new Error(`请求配置错误: ${error.message}`);
+    }
+  }
+
+  /**
+   * 构建查询参数
+   * @param {Object} params 参数对象
+   * @returns {string} 查询字符串
+   */
+  buildQueryString(params) {
+    const searchParams = new URLSearchParams();
+    Object.entries(params).forEach(([key, value]) => {
+      if (value !== undefined && value !== null) {
+        searchParams.append(key, value);
+      }
+    });
+    return searchParams.toString();
+  }
+}
+
+module.exports = MicrosoftHttpClient;

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

@@ -0,0 +1,167 @@
+/**
+ * 微软翻译服务
+ * 提供翻译、词典查询、示例查询等功能
+ */
+const MicrosoftHttpClient = require('./HttpClient');
+
+// 文本类型枚举
+const TEXT_TYPES = {
+  PLAIN: 'Plain',
+  HTML: 'Html'
+};
+
+// 错误代码
+const ERROR_CODES = {
+  INVALID_LANGUAGE_PAIR: 400023,
+  CONTENT_TOO_LONG: 400050,
+  AUTHENTICATION_FAILED: 401000,
+  QUOTA_EXCEEDED: 403000,
+  SERVICE_UNAVAILABLE: 503000
+};
+
+class MicrosoftTranslatorService {
+  constructor() {
+    this.httpClient = new MicrosoftHttpClient();
+    this.MAX_DICT_INPUT_TEXT_LENGTH = 100;
+    this.MAX_DICT_EXAMPLE_INPUT_ITEM_COUNT = 10;
+  }
+
+  /**
+   * 翻译文本
+   * @param {string} text 要翻译的文本
+   * @param {string} from 源语言代码
+   * @param {string} to 目标语言代码
+   * @param {string} textType 文本类型 (Plain 或 Html)
+   * @returns {Promise<Object>} 翻译结果
+   */
+  async translate(text, from, to, textType = TEXT_TYPES.PLAIN) {
+    const params = {
+      to: to,
+      textType: textType
+    };
+
+    // 如果不是自动检测，添加源语言参数
+    if (from !== 'auto') {
+      params.from = from;
+    }
+
+    const data = [{ text: text }];
+    
+    try {
+      const response = await this.httpClient.post('/translate', data, { params });
+      return response[0] || null;
+    } catch (error) {
+      if (error.message.includes('400050')) {
+        throw new Error('内容过长，无法翻译');
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * 检查文本是否可以查询词典
+   * @param {string} text 要检查的文本
+   * @returns {boolean} 是否可以查询词典
+   */
+  canLookupDictionary(text) {
+    return text.length <= this.MAX_DICT_INPUT_TEXT_LENGTH && 
+           text.split('').some(char => !char.match(/\s/));
+  }
+
+  /**
+   * 词典查询
+   * @param {string} text 要查询的文本
+   * @param {string} from 源语言代码
+   * @param {string} to 目标语言代码
+   * @returns {Promise<Object>} 词典查询结果
+   */
+  async dictionaryLookup(text, from, to) {
+    const params = {
+      from: from,
+      to: to
+    };
+
+    const data = [{ text: text }];
+    
+    try {
+      const response = await this.httpClient.post('/dictionary/lookup', data, { params });
+      return response[0];
+    } catch (error) {
+      if (error.message.includes('400023')) {
+        console.warn('不支持的语言对:', from, '->', to);
+        return null;
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * 词典示例查询
+   * @param {Object} dictionaryLookup 词典查询结果
+   * @param {string} from 源语言代码
+   * @param {string} to 目标语言代码
+   * @returns {Promise<Array>} 示例列表
+   */
+  async dictionaryExamples(dictionaryLookup, from, to) {
+    if (!dictionaryLookup || !dictionaryLookup.translations) {
+      return [];
+    }
+
+    // 按置信度排序，取前几个翻译
+    const sortedTranslations = dictionaryLookup.translations
+      .sort((a, b) => b.confidence - a.confidence)
+      .filter(translation => translation.normalizedTarget.length <= this.MAX_DICT_INPUT_TEXT_LENGTH)
+      .slice(0, this.MAX_DICT_EXAMPLE_INPUT_ITEM_COUNT);
+
+    if (sortedTranslations.length === 0) {
+      return [];
+    }
+
+    const request = sortedTranslations.map(translation => ({
+      text: dictionaryLookup.normalizedSource,
+      translation: translation.normalizedTarget
+    }));
+
+    const params = {
+      from: from,
+      to: to
+    };
+
+    try {
+      const response = await this.httpClient.post('/dictionary/examples', request, { params });
+      return response;
+    } catch (error) {
+      console.warn('获取词典示例失败:', error.message);
+      return [];
+    }
+  }
+
+  /**
+   * 检查语言是否支持
+   * @param {string} language 语言代码
+   * @returns {boolean} 是否支持
+   */
+  isLanguageSupported(language) {
+    // 这里可以添加语言支持检查逻辑
+    // 暂时返回true，实际使用时应该检查微软API支持的语言列表
+    return true;
+  }
+
+  /**
+   * 获取支持的语言列表
+   * @returns {Promise<Array>} 支持的语言列表
+   */
+  async getSupportedLanguages() {
+    try {
+      const response = await this.httpClient.post('/languages', {}, {
+        params: { scope: 'translation' }
+      });
+      return response.translation || {};
+    } catch (error) {
+      console.warn('获取支持语言列表失败:', error.message);
+      return {};
+    }
+  }
+}
+
+module.exports = MicrosoftTranslatorService;