daodou-command 1.0.0

package/lib/utils/proxy-manager.js

@@ -0,0 +1,364 @@
+const axios = require('axios');
+const cheerio = require('cheerio');
+const { HttpProxyAgent } = require('http-proxy-agent');
+const chalk = require('chalk');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { ConfigManager } = require('./config');
+
+/**
+ * 代理管理器类
+ * 从 free-proxy-list.net 获取代理列表并实现轮换
+ */
+class ProxyManager {
+  constructor() {
+    this.proxies = [];
+    this.currentIndex = 0;
+    this.failedProxies = new Set();
+    this.lastFetchTime = 0;
+    this.fetchInterval = 30 * 60 * 1000; // 30分钟更新一次
+    
+    // 缓存文件路径
+    this.cacheDir = path.join(os.homedir(), '.daodou');
+    this.cacheFile = path.join(this.cacheDir, 'proxy-cache.json');
+    this.failedProxiesFile = path.join(this.cacheDir, 'failed-proxies.json');
+    
+    // 配置管理器
+    this.configManager = new ConfigManager();
+    this.config = this.configManager.getLangConfig();
+    
+    // 确保缓存目录存在
+    this.ensureCacheDir();
+  }
+
+  /**
+   * 获取代理列表URL
+   */
+  getProxyListUrl() {
+    return this.config?.proxyListUrl || 'https://free-proxy-list.net/';
+  }
+
+  /**
+   * 获取代理测试URL
+   */
+  getProxyTestUrl() {
+    return this.config?.proxyTestUrl || 'https://httpbin.org/ip';
+  }
+
+  /**
+   * 确保缓存目录存在
+   */
+  ensureCacheDir() {
+    if (!fs.existsSync(this.cacheDir)) {
+      fs.mkdirSync(this.cacheDir, { recursive: true });
+    }
+  }
+
+  /**
+   * 从缓存文件加载代理列表
+   * @returns {Promise<Array>} 代理列表
+   */
+  async loadFromCache() {
+    try {
+      if (!fs.existsSync(this.cacheFile)) {
+        return [];
+      }
+
+      const cacheData = JSON.parse(fs.readFileSync(this.cacheFile, 'utf8'));
+      const now = Date.now();
+      
+      // 检查缓存是否过期
+      if (now - cacheData.timestamp > this.fetchInterval) {
+        console.log(chalk.yellow('⚠️ 代理缓存已过期，需要重新获取'));
+        return [];
+      }
+
+      console.log(chalk.blue(`📁 从缓存加载 ${cacheData.proxies.length} 个代理服务器`));
+      return cacheData.proxies || [];
+    } catch (error) {
+      console.log(chalk.red(`❌ 加载代理缓存失败: ${error.message}`));
+      return [];
+    }
+  }
+
+  /**
+   * 保存代理列表到缓存文件
+   * @param {Array} proxies 代理列表
+   */
+  async saveToCache(proxies) {
+    try {
+      const cacheData = {
+        timestamp: Date.now(),
+        proxies: proxies
+      };
+      
+      fs.writeFileSync(this.cacheFile, JSON.stringify(cacheData, null, 2));
+      console.log(chalk.green(`💾 已缓存 ${proxies.length} 个代理服务器到 ${this.cacheFile}`));
+    } catch (error) {
+      console.log(chalk.red(`❌ 保存代理缓存失败: ${error.message}`));
+    }
+  }
+
+  /**
+   * 从缓存文件加载失败的代理列表
+   */
+  loadFailedProxies() {
+    try {
+      if (!fs.existsSync(this.failedProxiesFile)) {
+        return new Set();
+      }
+
+      const failedProxies = JSON.parse(fs.readFileSync(this.failedProxiesFile, 'utf8'));
+      return new Set(failedProxies || []);
+    } catch (error) {
+      console.log(chalk.red(`❌ 加载失败代理列表失败: ${error.message}`));
+      return new Set();
+    }
+  }
+
+  /**
+   * 保存失败的代理列表到缓存文件
+   */
+  saveFailedProxies() {
+    try {
+      const failedProxies = Array.from(this.failedProxies);
+      fs.writeFileSync(this.failedProxiesFile, JSON.stringify(failedProxies, null, 2));
+    } catch (error) {
+      console.log(chalk.red(`❌ 保存失败代理列表失败: ${error.message}`));
+    }
+  }
+
+  /**
+   * 从 free-proxy-list.net 获取代理列表
+   * @returns {Promise<Array>} 代理列表
+   */
+  async fetchProxies() {
+    try {
+      console.log(chalk.blue('🔍 正在获取代理服务器列表...'));
+      
+      const response = await axios.get(this.getProxyListUrl(), {
+        timeout: 10000,
+        headers: {
+          'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+        }
+      });
+
+      const $ = cheerio.load(response.data);
+      const proxies = [];
+
+      // 解析表格数据
+      $('table.table-striped tbody tr').each((index, element) => {
+        const $row = $(element);
+        const cells = $row.find('td');
+        
+        if (cells.length >= 8) {
+          const ip = $(cells[0]).text().trim();
+          const port = $(cells[1]).text().trim();
+          const code = $(cells[2]).text().trim();
+          const country = $(cells[3]).text().trim();
+          const anonymity = $(cells[4]).text().trim();
+          const google = $(cells[5]).text().trim();
+          const https = $(cells[6]).text().trim();
+          const lastChecked = $(cells[7]).text().trim();
+
+          // 过滤条件：Anonymity = "anonymous" 且 Google ≠ "no"
+          if (anonymity === 'anonymous' && google !== 'no') {
+            proxies.push({
+              ip,
+              port: parseInt(port),
+              code,
+              country,
+              anonymity,
+              google,
+              https: https === 'yes',
+              lastChecked,
+              url: `http://${ip}:${port}`
+            });
+          }
+        }
+      });
+
+      console.log(chalk.green(`✅ 获取到 ${proxies.length} 个符合条件的代理服务器`));
+      
+      // 保存到缓存
+      await this.saveToCache(proxies);
+      
+      return proxies;
+
+    } catch (error) {
+      console.log(chalk.red(`❌ 获取代理列表失败: ${error.message}`));
+      return [];
+    }
+  }
+
+  /**
+   * 获取可用的代理列表
+   * @returns {Promise<Array>} 可用的代理列表
+   */
+  async getAvailableProxies() {
+    // 如果代理列表为空，尝试从缓存加载
+    if (this.proxies.length === 0) {
+      this.proxies = await this.loadFromCache();
+      this.failedProxies = this.loadFailedProxies();
+    }
+
+    // 如果缓存中没有代理或缓存为空，重新获取
+    if (this.proxies.length === 0) {
+      this.proxies = await this.fetchProxies();
+      this.failedProxies.clear();
+    }
+
+    // 过滤掉失败的代理
+    const availableProxies = this.proxies.filter(proxy => 
+      !this.failedProxies.has(proxy.url)
+    );
+
+    return availableProxies;
+  }
+
+  /**
+   * 获取下一个可用的代理
+   * @returns {Promise<Object|null>} 代理对象或null
+   */
+  async getNextProxy() {
+    const availableProxies = await this.getAvailableProxies();
+    
+    if (availableProxies.length === 0) {
+      console.log(chalk.yellow('⚠️ 没有可用的代理服务器'));
+      return null;
+    }
+
+    // 轮换选择代理
+    const proxy = availableProxies[this.currentIndex % availableProxies.length];
+    this.currentIndex++;
+
+    return proxy;
+  }
+
+  /**
+   * 标记代理为失败
+   * @param {string} proxyUrl 代理URL
+   */
+  markProxyFailed(proxyUrl) {
+    this.failedProxies.add(proxyUrl);
+    
+    // 从代理列表中移除失败的代理
+    this.proxies = this.proxies.filter(proxy => proxy.url !== proxyUrl);
+    
+    // 保存失败代理列表和更新后的代理列表
+    this.saveFailedProxies();
+    this.saveToCache(this.proxies);
+    
+    console.log(chalk.yellow(`⚠️ 代理 ${proxyUrl} 已从列表中移除`));
+  }
+
+  /**
+   * 创建代理代理
+   * @param {Object} proxy 代理对象
+   * @returns {HttpProxyAgent} 代理代理
+   */
+  createProxyAgent(proxy) {
+    if (!proxy) return null;
+    
+    try {
+      return new HttpProxyAgent(proxy.url);
+    } catch (error) {
+      console.log(chalk.red(`❌ 创建代理代理失败: ${error.message}`));
+      return null;
+    }
+  }
+
+  /**
+   * 测试代理是否可用
+   * @param {Object} proxy 代理对象
+   * @returns {Promise<boolean>} 是否可用
+   */
+  async testProxy(proxy) {
+    if (!proxy) return false;
+
+    try {
+      const agent = this.createProxyAgent(proxy);
+      if (!agent) return false;
+
+      const response = await axios.get(this.getProxyTestUrl(), {
+        httpAgent: agent,
+        httpsAgent: agent,
+        timeout: 5000
+      });
+
+      return response.status === 200;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * 获取统计信息
+   * @returns {Object} 统计信息
+   */
+  getStats() {
+    return {
+      totalProxies: this.proxies.length,
+      failedProxies: this.failedProxies.size,
+      availableProxies: this.proxies.length - this.failedProxies.size,
+      currentIndex: this.currentIndex,
+      cacheFile: this.cacheFile,
+      failedProxiesFile: this.failedProxiesFile
+    };
+  }
+
+  /**
+   * 清理缓存文件
+   */
+  clearCache() {
+    try {
+      if (fs.existsSync(this.cacheFile)) {
+        fs.unlinkSync(this.cacheFile);
+        console.log(chalk.green(`🗑️ 已清理代理缓存文件: ${this.cacheFile}`));
+      }
+      if (fs.existsSync(this.failedProxiesFile)) {
+        fs.unlinkSync(this.failedProxiesFile);
+        console.log(chalk.green(`🗑️ 已清理失败代理缓存文件: ${this.failedProxiesFile}`));
+      }
+    } catch (error) {
+      console.log(chalk.red(`❌ 清理缓存失败: ${error.message}`));
+    }
+  }
+
+  /**
+   * 强制刷新代理列表（忽略缓存）
+   * @returns {Promise<Array>} 新的代理列表
+   */
+  async forceRefresh() {
+    console.log(chalk.blue('🔄 强制刷新代理列表...'));
+    this.proxies = await this.fetchProxies();
+    this.failedProxies.clear();
+    this.currentIndex = 0;
+    return this.proxies;
+  }
+
+  /**
+   * 检查是否还有可用代理
+   * @returns {boolean} 是否还有可用代理
+   */
+  hasAvailableProxies() {
+    const availableProxies = this.proxies.filter(proxy => 
+      !this.failedProxies.has(proxy.url)
+    );
+    return availableProxies.length > 0;
+  }
+
+  /**
+   * 获取可用代理数量
+   * @returns {number} 可用代理数量
+   */
+  getAvailableProxyCount() {
+    const availableProxies = this.proxies.filter(proxy => 
+      !this.failedProxies.has(proxy.url)
+    );
+    return availableProxies.length;
+  }
+}
+
+module.exports = ProxyManager;

package/lib/utils/translation.js

@@ -0,0 +1,199 @@
+const { translate } = require('@vitalets/google-translate-api');
+const chalk = require('chalk');
+const ProxyManager = require('./proxy-manager');
+
+/**
+ * 翻译服务类
+ * 处理 Google Translate API 调用和重试机制
+ */
+class TranslationService {
+  constructor() {
+    this.maxRetries = 3;
+    this.retryDelay = 1000; // 1秒
+    this.proxyManager = new ProxyManager();
+    this.currentProxy = null;
+  }
+
+  /**
+   * 翻译文本（支持多代理轮换）
+   * @param {string} text - 要翻译的文本
+   * @param {string} targetLang - 目标语言代码
+   * @param {string} sourceLang - 源语言代码，默认为 'en'
+   * @returns {Promise<{success: boolean, result: string, error: string}>}
+   */
+  async translateText(text, targetLang, sourceLang = 'en') {
+    console.log(chalk.blue(`  🌐 步骤 2/4: 开始翻译 "${text}"...`));
+    
+    // 首先尝试直连（不使用代理）
+    console.log(chalk.gray(`  🔗 尝试直连翻译...`));
+    try {
+      const result = await translate(text, {
+        from: sourceLang,
+        to: targetLang
+      });
+
+      console.log(chalk.green(`  🔄 步骤 3/4: 翻译完成 "${text}" -> "${result.text}"`));
+      
+      return {
+        success: true,
+        result: result.text,
+        error: null
+      };
+    } catch (error) {
+      console.log(chalk.yellow(`  ⚠️ 直连失败: ${error.message}`));
+      console.log(chalk.blue(`  🔄 开始使用代理轮换...`));
+    }
+
+    // 直连失败，开始代理轮换
+    const availableProxies = await this.proxyManager.getAvailableProxies();
+    
+    if (availableProxies.length === 0) {
+      console.log(chalk.red(`  ❌ 没有可用的代理服务器`));
+      return {
+        success: false,
+        result: null,
+        error: '没有可用的代理服务器'
+      };
+    }
+
+    // 轮询所有可用代理
+    let proxyIndex = 0;
+    while (proxyIndex < availableProxies.length) {
+      const proxy = availableProxies[proxyIndex];
+      const remainingProxies = this.proxyManager.getAvailableProxyCount();
+      
+      console.log(chalk.gray(`  🔗 使用代理: ${proxy.ip}:${proxy.port} (${proxy.country}) [${proxyIndex + 1}/${availableProxies.length}] (剩余: ${remainingProxies})`));
+      
+      // 对每个代理尝试3次
+      let proxySuccess = false;
+      for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
+        try {
+          const agent = this.proxyManager.createProxyAgent(proxy);
+          if (!agent) {
+            console.log(chalk.red(`  ❌ 创建代理代理失败`));
+            break;
+          }
+          
+          const result = await translate(text, {
+            from: sourceLang,
+            to: targetLang,
+            fetchOptions: { agent }
+          });
+
+          console.log(chalk.green(`  🔄 步骤 3/4: 翻译完成 "${text}" -> "${result.text}"`));
+          
+          return {
+            success: true,
+            result: result.text,
+            error: null
+          };
+
+        } catch (error) {
+          console.log(chalk.red(`  ❌ 代理 ${proxy.ip}:${proxy.port} 失败 (${attempt}/${this.maxRetries}): ${error.message}`));
+          
+          if (attempt < this.maxRetries) {
+            await this.delay(this.retryDelay * attempt);
+          }
+        }
+      }
+      
+      // 如果这个代理3次都失败了，标记为失败并从列表中移除
+      if (!proxySuccess) {
+        console.log(chalk.yellow(`  ⚠️ 代理 ${proxy.ip}:${proxy.port} 已失败3次，从列表中移除`));
+        this.proxyManager.markProxyFailed(proxy.url);
+        
+        // 检查是否还有可用代理
+        if (!this.proxyManager.hasAvailableProxies()) {
+          console.log(chalk.red(`  ❌ 所有代理都已失败，无法继续翻译`));
+          break;
+        }
+        
+        // 重新获取可用代理列表（因为可能有代理被移除）
+        const newAvailableProxies = await this.proxyManager.getAvailableProxies();
+        if (newAvailableProxies.length === 0) {
+          console.log(chalk.red(`  ❌ 没有可用的代理服务器`));
+          break;
+        }
+        
+        // 更新可用代理列表
+        availableProxies.length = 0;
+        availableProxies.push(...newAvailableProxies);
+      }
+      
+      proxyIndex++;
+    }
+
+    // 所有代理都失败了
+    console.log(chalk.red(`  ❌ 所有代理都失败了，跳过该语言`));
+    return {
+      success: false,
+      result: null,
+      error: '所有代理都失败了'
+    };
+  }
+
+  /**
+   * 延迟函数
+   * @param {number} ms - 延迟毫秒数
+   */
+  delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  /**
+   * 检查是否为默认语言
+   * @param {string} lang - 语言代码
+   * @param {string} defaultLang - 默认语言代码
+   * @returns {boolean}
+   */
+  isDefaultLanguage(lang, defaultLang) {
+    return lang === defaultLang;
+  }
+
+  /**
+   * 获取语言显示名称
+   * @param {string} langCode - 语言代码
+   * @returns {string}
+   */
+  getLanguageDisplayName(langCode) {
+    const languageNames = {
+      'en': 'English',
+      'zh': '中文',
+      'ja': '日本語',
+      'fr': 'Français',
+      'de': 'Deutsch',
+      'es': 'Español',
+      'it': 'Italiano',
+      'pt': 'Português',
+      'ru': 'Русский',
+      'ko': '한국어',
+      'ar': 'العربية',
+      'hi': 'हिन्दी'
+    };
+    
+    return languageNames[langCode] || langCode.toUpperCase();
+  }
+
+  /**
+   * 获取代理统计信息
+   * @returns {Object} 统计信息
+   */
+  getProxyStats() {
+    return this.proxyManager.getStats();
+  }
+
+  /**
+   * 显示代理统计信息
+   */
+  showProxyStats() {
+    const stats = this.getProxyStats();
+    console.log(chalk.blue('\n📊 代理服务器统计:'));
+    console.log(chalk.gray(`  总代理数: ${stats.totalProxies}`));
+    console.log(chalk.green(`  可用代理: ${stats.availableProxies}`));
+    console.log(chalk.red(`  失败代理: ${stats.failedProxies}`));
+    console.log(chalk.gray(`  缓存文件: ${stats.cacheFile}`));
+    console.log(chalk.gray(`  失败代理文件: ${stats.failedProxiesFile}`));
+  }
+}
+
+module.exports = TranslationService;

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "daodou-command",
+  "version": "1.0.0",
+  "description": "刀豆命令行工具 - 自动化构建和部署",
+  "main": "index.js",
+  "bin": {
+    "dao": "bin/daodou.js"
+  },
+  "scripts": {
+    "start": "node ./bin/daodou.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "刀豆"
+  ],
+  "author": "刀豆团队",
+  "license": "MIT",
+  "dependencies": {
+    "@vitalets/google-translate-api": "^9.2.1",
+    "axios": "^1.12.0",
+    "chalk": "^4.1.2",
+    "cheerio": "^1.1.2",
+    "commander": "^11.1.0",
+    "http-proxy-agent": "^7.0.2",
+    "inquirer": "^8.2.6",
+    "json5": "^2.2.3",
+    "ora": "^5.4.1",
+    "puppeteer": "^24.12.1",
+    "simple-git": "^3.20.0",
+    "ws": "^8.14.2"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}