Upload 16 files

.env.example

@@ -6,8 +6,8 @@ NOTION_COOKIE="cookie1|cookie2"
 PROXY_AUTH_TOKEN="sk-text"
 # （可选）代理地址
 PROXY_URL=""
-# （可选）是否使用本地代理池，启用前确保没有设置其它代理，否则速度会减慢或者出现其它问题，目前不推荐启用
-USE_NATIVE_PROXY_POOL=false
+# （可选）是否使用本地代理池，启用前确保没有设置其它代理，否则速度会减慢或者出现其它问题，推荐启用
+USE_NATIVE_PROXY_POOL=true
 
 # （可选）代理国家，支持us uk jp de fr ca
 PROXY_COUNTRY="us"

src/ProxyPool.js

@@ -9,15 +9,15 @@ class ProxyPool {
    * @param {Object} options - 配置选项
    * @param {number} options.targetCount - 目标代理数量，默认20
    * @param {number} options.batchSize - 每次获取的代理数量，默认20
-   * @param {number} options.testTimeout - 测试代理超时时间(毫秒)，默认3000
-   * @param {number} options.requestTimeout - 请求目标网站超时时间(毫秒)，默认5000
+   * @param {number} options.testTimeout - 测试代理超时时间(毫秒)，默认5000
+   * @param {number} options.requestTimeout - 请求目标网站超时时间(毫秒)，默认10000
    * @param {string} options.targetUrl - 目标网站URL，默认'https://www.notion.so'
-   * @param {number} options.concurrentRequests - 并发请求数量，默认15
+   * @param {number} options.concurrentRequests - 并发请求数量，默认10
    * @param {number} options.minThreshold - 可用代理数量低于此阈值时自动补充，默认5
    * @param {number} options.checkInterval - 检查代理池状态的时间间隔(毫秒)，默认30000
    * @param {string} options.proxyProtocol - 代理协议，默认'http'
-   * @param {number} options.maxRefillAttempts - 最大补充尝试次数，默认50
-   * @param {number} options.retryDelay - 重试延迟(毫秒)，默认500
+   * @param {number} options.maxRefillAttempts - 最大补充尝试次数，默认20
+   * @param {number} options.retryDelay - 重试延迟(毫秒)，默认1000
    * @param {boolean} options.useCache - 是否使用缓存，默认true
    * @param {number} options.cacheExpiry - 缓存过期时间(毫秒)，默认3600000 (1小时)
    * @param {string} options.logLevel - 日志级别，可选值：'debug', 'info', 'warn', 'error', 'none'，默认'info'
@@ -27,15 +27,15 @@ class ProxyPool {
     // 配置参数
     this.targetCount = options.targetCount || 20;
     this.batchSize = options.batchSize || 20;
-    this.testTimeout = options.testTimeout || 3000; // 减少测试超时时间
-    this.requestTimeout = options.requestTimeout || 5000; // 减少请求超时时间
+    this.testTimeout = options.testTimeout || 5000;
+    this.requestTimeout = options.requestTimeout || 10000;
     this.targetUrl = options.targetUrl || 'https://www.notion.so';
-    this.concurrentRequests = options.concurrentRequests || 15; // 增加默认并发请求数
+    this.concurrentRequests = options.concurrentRequests || 10;
     this.minThreshold = options.minThreshold || 5;
     this.checkInterval = options.checkInterval || 30000; // 默认30秒检查一次
     this.proxyProtocol = options.proxyProtocol || 'http';
-    this.maxRefillAttempts = options.maxRefillAttempts || 50; // 增加最大尝试次数
-    this.retryDelay = options.retryDelay || 500; // 减少重试延迟
+    this.maxRefillAttempts = options.maxRefillAttempts || 30; // 减少最大尝试次数
+    this.retryDelay = options.retryDelay || 1000; // 减少重试延迟
     this.useCache = options.useCache !== undefined ? options.useCache : true;
     this.cacheExpiry = options.cacheExpiry || 3600000; // 默认1小时
     this.logLevel = options.logLevel || 'info'; // 默认日志级别为info
@@ -237,7 +237,7 @@ class ProxyPool {
         
         // 计算本次需要获取的批次大小
         const remainingNeeded = this.targetCount - this.availableProxies.length;
-        const batchSizeNeeded = Math.max(remainingNeeded * 2, 10); // 获取更多代理以提高成功率，至少10个
+        const batchSizeNeeded = remainingNeeded; // 获取更多代理以提高成功率
         
         // 获取代理
         const proxies = await this.getProxiesFromProvider(batchSizeNeeded);
@@ -253,7 +253,6 @@ class ProxyPool {
         
         if (newProxies.length === 0) {
           this.log('debug', '所有获取的代理都已存在，继续获取新代理...');
-          // 减少等待时间，立即继续尝试
           continue;
         }
         
@@ -275,9 +274,9 @@ class ProxyPool {
           break;
         }
         
-        // 如果还没补充到足够的代理，减少等待时间再继续
+        // 如果还没补充到足够的代理，等待一段时间再继续
         if (this.availableProxies.length < this.targetCount) {
-          await new Promise(resolve => setTimeout(resolve, 500)); // 减少等待时间到500毫秒
+          await new Promise(resolve => setTimeout(resolve, this.retryDelay));
         }
       }
     } catch (error) {
@@ -427,36 +426,18 @@ class ProxyPool {
   async getProxiesFromProvider(count = null) {
     try {
       const requestCount = count || this.batchSize;
-      // 限制单次请求数量最大为10
+      // 限制请求数量最大为10
       const actualCount = Math.min(requestCount, 10);
+      const url = `https://proxy.doudouzi.me/random/${this.proxyCountry}?number=${actualCount}&protocol=${this.proxyProtocol}&type=json`;
+      this.log('debug', `正在获取代理，URL: ${url}`);
       
-      // 计算需要发送的请求数量，以获取足够的代理
-      const requestsNeeded = Math.ceil(requestCount / 1); // 假设每次请求只返回1个代理
-      const maxParallelRequests = 5; // 最大并行请求数
-      const actualRequests = Math.min(requestsNeeded, maxParallelRequests);
-      
-      this.log('debug', `需要 ${requestCount} 个代理，将发送 ${actualRequests} 个并行请求`);
-      
-      // 并行发送多个请求
-      const requestPromises = [];
-      for (let i = 0; i < actualRequests; i++) {
-        const url = `https://proxy.doudouzi.me/random/${this.proxyCountry}?number=${actualCount}&protocol=${this.proxyProtocol}&type=json`;
-        requestPromises.push(
-          axios.get(url, { 
-            timeout: 10000,
-            validateStatus: status => true
-          })
-        );
-      }
-      
-      // 等待所有请求完成
-      const responses = await Promise.all(requestPromises);
-      
-      // 处理所有响应，合并代理列表
-      let proxies = [];
+      const response = await axios.get(url, { 
+        timeout: 10000,
+        validateStatus: status => true
+      });
       
-      for (const response of responses) {
-        if (!response.data) continue;
+      if (response.data) {
+        let proxies = [];
         
         // 处理不同的返回格式
         if (typeof response.data === 'string') {
@@ -502,10 +483,13 @@ class ProxyPool {
             }
           }
         }
+        
+        this.log('debug', `成功获取 ${proxies.length} 个代理`);
+        return proxies;
+      } else {
+        this.log('error', '获取代理失败: 返回数据格式不正确');
+        return [];
       }
-      
-      this.log('debug', `成功获取 ${proxies.length} 个代理`);
-      return proxies;
     } catch (error) {
       this.log('error', '获取代理出错:', error.message);
       return [];
@@ -522,7 +506,7 @@ class ProxyPool {
     const remainingNeeded = this.targetCount - this.availableProxies.length;
     
     // 增加并发数以加快处理速度
-    const concurrentRequests = Math.min(this.concurrentRequests * 3, 30); // 增加到最多30个并发请求
+    const concurrentRequests = Math.min(this.concurrentRequests * 2, 20);
     
     // 分批处理代理
     for (let i = 0; i < proxies.length; i += concurrentRequests) {
@@ -602,9 +586,9 @@ class ProxyPool {
           'Connection': 'keep-alive',
           'Upgrade-Insecure-Requests': '1'
         },
-        timeout: Math.min(this.requestTimeout, 5000), // 减少超时时间，最多5秒
+        timeout: this.requestTimeout,
         validateStatus: status => true,
-        maxRedirects: 5, // 减少最大重定向次数
+        maxRedirects: 10,
         followRedirect: true
       });
       
@@ -738,12 +722,10 @@ async function example() {
     minThreshold: 3,           // 当可用代理少于3个时，自动补充
     checkInterval: 60000,      // 每60秒检查一次
     targetUrl: 'https://www.notion.so',
-    concurrentRequests: 20,    // 增加并发请求数
+    concurrentRequests: 15,    // 增加并发请求数
     useCache: true,            // 启用缓存
-    maxRefillAttempts: 50,     // 增加最大尝试次数
-    retryDelay: 500,           // 减少重试延迟
-    testTimeout: 3000,         // 减少测试超时时间
-    requestTimeout: 5000,      // 减少请求超时时间
+    maxRefillAttempts: 15,     // 减少最大尝试次数
+    retryDelay: 1000,          // 减少重试延迟
     logLevel: 'info',          // 设置日志级别
     showProgressBar: true      // 启用进度条
   });

src/ProxyServer.js

@@ -1,169 +1,205 @@
-import { spawn } from 'child_process';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-import fs from 'fs';
-import os from 'os';
-import dotenv from 'dotenv';
-import chalk from 'chalk';
-
-// 获取当前文件的目录路径
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-// 加载环境变量
-dotenv.config({ path: join(dirname(__dirname), '.env') });
-
-// 日志配置
-const logger = {
-  info: (message) => console.log(chalk.blue(`[ProxyServer] ${message}`)),
-  error: (message) => console.error(chalk.red(`[ProxyServer] ${message}`)),
-  warning: (message) => console.warn(chalk.yellow(`[ProxyServer] ${message}`)),
-  success: (message) => console.log(chalk.green(`[ProxyServer] ${message}`)),
-};
-
-class ProxyServer {
-  constructor() {
-    this.proxyProcess = null;
-    this.platform = process.env.PROXY_SERVER_PLATFORM || 'auto';
-    this.port = process.env.PROXY_SERVER_PORT || 10655;
-    this.enabled = process.env.ENABLE_PROXY_SERVER === 'true';
-    this.proxyAuthToken = process.env.PROXY_AUTH_TOKEN || 'default_token';
-  }
-
-  // 获取当前系统平台
-  detectPlatform() {
-    if (this.platform !== 'auto') {
-      return this.platform;
-    }
-
-    const platform = os.platform();
-    const arch = os.arch();
-
-    if (platform === 'win32') {
-      return 'windows';
-    } else if (platform === 'linux') {
-      if (arch === 'arm64') {
-        return 'android';
-      } else {
-        return 'linux';
-      }
-    } else if (platform === 'android') {
-      return 'android';
-    } else {
-      logger.warning(`未知平台: ${platform}, ${arch}, 默认使用linux版本`);
-      return 'linux';
-    }
-  }
-
-  // 获取代理服务器可执行文件路径
-  getProxyServerPath() {
-    const platform = this.detectPlatform();
-    const proxyDir = join(__dirname, 'proxy');
-
-    switch (platform) {
-      case 'windows':
-        return join(proxyDir, 'chrome_proxy_server_windows_amd64.exe');
-      case 'linux':
-        return join(proxyDir, 'chrome_proxy_server_linux_amd64');
-      case 'android':
-        return join(proxyDir, 'chrome_proxy_server_android_arm64');
-      default:
-        logger.error(`不支持的平台: ${platform}`);
-        return null;
-    }
-  }
-
-  // 启动代理服务器
-  async start() {
-    if (!this.enabled) {
-      logger.info('代理服务器未启用，跳过启动');
-      return;
-    }
-
-    if (this.proxyProcess) {
-      logger.warning('代理服务器已经在运行中');
-      return;
-    }
-
-    const proxyServerPath = this.getProxyServerPath();
-    if (!proxyServerPath) {
-      logger.error('无法获取代理服务器路径');
-      return;
-    }
-
-    try {
-      // 启动代理服务器进程
-      this.proxyProcess = spawn(proxyServerPath, [
-        '--port', this.port.toString(),
-        '--token', this.proxyAuthToken
-      ], {
-        stdio: ['ignore', 'pipe', 'pipe'], // 使用pipe而不是直接传递流
-        detached: false
-      });
-
-      // 将进程的输出重定向到主进程
-      if (this.proxyProcess.stdout) {
-        this.proxyProcess.stdout.pipe(process.stdout);
-      }
-      
-      if (this.proxyProcess.stderr) {
-        this.proxyProcess.stderr.pipe(process.stderr);
-      }
-
-      // 设置进程事件处理
-      this.proxyProcess.on('error', (err) => {
-        logger.error(`代理服务器启动失败: ${err.message}`);
-        this.proxyProcess = null;
-      });
-
-      this.proxyProcess.on('exit', (code, signal) => {
-        logger.info(`代理服务器已退出，退出码: ${code}, 信号: ${signal}`);
-        this.proxyProcess = null;
-      });
-
-      // 等待一段时间，确保服务器启动
-      await new Promise(resolve => setTimeout(resolve, 1000));
-      
-      if (this.proxyProcess && this.proxyProcess.exitCode === null) {
-        logger.success(`代理服务器已启动，端口: ${this.port}`);
-        return true;
-      } else {
-        logger.error('代理服务器启动失败');
-        return false;
-      }
-    } catch (error) {
-      logger.error(`启动代理服务器时出错: ${error.message}`);
-      return false;
-    }
-  }
-
-  // 停止代理服务器
-  stop() {
-    if (!this.proxyProcess) {
-      //logger.info('代理服务器已关闭');
-      return;
-    }
-
-    try {
-      // 在Windows上使用taskkill确保子进程也被终止
-      if (this.detectPlatform() === 'windows' && this.proxyProcess.pid) {
-        spawn('taskkill', ['/pid', this.proxyProcess.pid, '/f', '/t']);
-      } else {
-        // 在Linux/Android上使用kill信号
-        this.proxyProcess.kill('SIGTERM');
-      }
-
-      logger.success('代理服务器已停止');
-    } catch (error) {
-      logger.error(`停止代理服务器时出错: ${error.message}`);
-    } finally {
-      this.proxyProcess = null;
-    }
-  }
-}
-
-// 创建单例
-const proxyServer = new ProxyServer();
-
-// 导出
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import fs from 'fs';
+import os from 'os';
+import dotenv from 'dotenv';
+import chalk from 'chalk';
+
+// 获取当前文件的目录路径
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// 加载环境变量
+dotenv.config({ path: join(dirname(__dirname), '.env') });
+
+// 日志配置
+const logger = {
+  info: (message) => console.log(chalk.blue(`[ProxyServer] ${message}`)),
+  error: (message) => console.error(chalk.red(`[ProxyServer] ${message}`)),
+  warning: (message) => console.warn(chalk.yellow(`[ProxyServer] ${message}`)),
+  success: (message) => console.log(chalk.green(`[ProxyServer] ${message}`)),
+};
+
+class ProxyServer {
+  constructor() {
+    this.proxyProcess = null;
+    this.platform = process.env.PROXY_SERVER_PLATFORM || 'auto';
+    this.port = process.env.PROXY_SERVER_PORT || 10655;
+    this.logPath = process.env.PROXY_SERVER_LOG_PATH || '/tmp/proxy_server.log';
+    this.enabled = process.env.ENABLE_PROXY_SERVER === 'true';
+    this.proxyAuthToken = process.env.PROXY_AUTH_TOKEN || 'default_token';
+    this.logStream = null;
+  }
+
+  // 获取当前系统平台
+  detectPlatform() {
+    if (this.platform !== 'auto') {
+      return this.platform;
+    }
+
+    const platform = os.platform();
+    const arch = os.arch();
+
+    if (platform === 'win32') {
+      return 'windows';
+    } else if (platform === 'linux') {
+      if (arch === 'arm64') {
+        return 'android';
+      } else {
+        return 'linux';
+      }
+    } else if (platform === 'android') {
+      return 'android';
+    } else {
+      logger.warning(`未知平台: ${platform}, ${arch}, 默认使用linux版本`);
+      return 'linux';
+    }
+  }
+
+  // 获取代理服务器可执行文件路径
+  getProxyServerPath() {
+    const platform = this.detectPlatform();
+    const proxyDir = join(__dirname, 'proxy');
+
+    switch (platform) {
+      case 'windows':
+        return join(proxyDir, 'chrome_proxy_server_windows_amd64.exe');
+      case 'linux':
+        return join(proxyDir, 'chrome_proxy_server_linux_amd64');
+      case 'android':
+        return join(proxyDir, 'chrome_proxy_server_android_arm64');
+      default:
+        logger.error(`不支持的平台: ${platform}`);
+        return null;
+    }
+  }
+
+  // 启动代理服务器
+  async start() {
+    if (!this.enabled) {
+      logger.info('代理服务器未启用，跳过启动');
+      return;
+    }
+
+    if (this.proxyProcess) {
+      logger.warning('代理服务器已经在运行中');
+      return;
+    }
+
+    const proxyServerPath = this.getProxyServerPath();
+    if (!proxyServerPath) {
+      logger.error('无法获取代理服务器路径');
+      return;
+    }
+
+    try {
+      // 确保可执行文件有执行权限（在Linux/Android上）
+      // 在Hugging Face环境中，文件权限应在Dockerfile中设置，运行时修改可能会失败
+      // if (this.detectPlatform() !== 'windows') {
+      //   try {
+      //     fs.chmodSync(proxyServerPath, 0o755);
+      //   } catch (err) {
+      //     logger.warning(`无法设置执行权限: ${err.message}`);
+      //   }
+      // }
+
+      // 创建日志文件
+      this.logStream = fs.createWriteStream(this.logPath, { flags: 'a' });
+      
+      // 修复 stdio 参数问题
+      // 启动代理服务器进程
+      this.proxyProcess = spawn(proxyServerPath, [
+        '--port', this.port.toString(),
+        '--token', this.proxyAuthToken
+      ], {
+        stdio: ['ignore', 'pipe', 'pipe'], // 使用pipe而不是直接传递流
+        detached: false
+      });
+
+      // 将进程的输出重定向到日志文件
+      if (this.proxyProcess.stdout) {
+        this.proxyProcess.stdout.pipe(this.logStream);
+      }
+      
+      if (this.proxyProcess.stderr) {
+        this.proxyProcess.stderr.pipe(this.logStream);
+      }
+
+      // 设置进程事件处理
+      this.proxyProcess.on('error', (err) => {
+        logger.error(`代理服务器启动失败: ${err.message}`);
+        this.proxyProcess = null;
+        if (this.logStream) {
+          this.logStream.end();
+          this.logStream = null;
+        }
+      });
+
+      this.proxyProcess.on('exit', (code, signal) => {
+        logger.info(`代理服务器已退出，退出码: ${code}, 信号: ${signal}`);
+        this.proxyProcess = null;
+        if (this.logStream) {
+          this.logStream.end();
+          this.logStream = null;
+        }
+      });
+
+      // 等待一段时间，确保服务器启动
+      await new Promise(resolve => setTimeout(resolve, 1000));
+      
+      if (this.proxyProcess && this.proxyProcess.exitCode === null) {
+        logger.success(`代理服务器已启动，端口: ${this.port}, 日志文件: ${this.logPath}`);
+        return true;
+      } else {
+        logger.error('代理服务器���动失败');
+        if (this.logStream) {
+          this.logStream.end();
+          this.logStream = null;
+        }
+        return false;
+      }
+    } catch (error) {
+      logger.error(`启动代理服务器时出错: ${error.message}`);
+      if (this.logStream) {
+        this.logStream.end();
+        this.logStream = null;
+      }
+      return false;
+    }
+  }
+
+  // 停止代理服务器
+  stop() {
+    if (!this.proxyProcess) {
+      //logger.info('代理服务器已关闭');
+      return;
+    }
+
+    try {
+      // 在Windows上使用taskkill确保子进程也被终止
+      if (this.detectPlatform() === 'windows' && this.proxyProcess.pid) {
+        spawn('taskkill', ['/pid', this.proxyProcess.pid, '/f', '/t']);
+      } else {
+        // 在Linux/Android上使用kill信号
+        this.proxyProcess.kill('SIGTERM');
+      }
+
+      logger.success('代理服务器已停止');
+    } catch (error) {
+      logger.error(`停止代理服务器时出错: ${error.message}`);
+    } finally {
+      this.proxyProcess = null;
+      if (this.logStream) {
+        this.logStream.end();
+        this.logStream = null;
+      }
+    }
+  }
+}
+
+// 创建单例
+const proxyServer = new ProxyServer();
+
+// 导出
 export { proxyServer }; 

src/lightweight-client-express.js

@@ -321,7 +321,7 @@ app.get('/cookies/status', authenticate, (req, res) => {
 const PORT = process.env.PORT || 7860;
 
 // 设置代理池日志级别为warn，减少详细日志输出
-proxyPool.logLevel = 'info';
+proxyPool.logLevel = 'error';
 
 // 初始化并启动服务器
 initialize().then(() => {

src/lightweight-client.js

@@ -14,8 +14,6 @@ import {
 import { proxyPool } from './ProxyPool.js';
 import { proxyServer } from './ProxyServer.js';
 import { cookieManager } from './CookieManager.js';
-import { HttpsProxyAgent } from 'https-proxy-agent';
-import dns from 'dns';
 
 // 获取当前文件的目录路径
 const __filename = fileURLToPath(import.meta.url);
@@ -382,50 +380,34 @@ async function fetchNotionResponse(chunkQueue, notionRequestBody, headers, notio
     // 创建fetch选项
     const fetchOptions = {
       method: 'POST',
-      headers: headers,
+      headers: {
+        ...headers,
+        'user-agent': window.navigator.userAgent,
+        'Cookie': notionCookie
+      },
       body: JSON.stringify(notionRequestBody),
-      timeout: 120000 // 120s
     };
     
-    // 根据条件添加代理
+    // 添加代理配置（如果有）
     if (USE_NATIVE_PROXY_POOL && ENABLE_PROXY_SERVER && !PROXY_URL) {
-      const proxy = await proxyPool.getProxy();
-      if (proxy) {
-        fetchOptions.agent = new HttpsProxyAgent(proxy.url);
-        logger.info(`使用原生代理池: ${proxy.url} (来自 ${proxy.source})`);
-      } else {
-        logger.warning("原生代理池已启用但没有可用的代理，将不使用代理");
+      proxy = proxyPool.getProxy();
+      if (proxy !== null)
+      {
+        logger.info(`使用代理: ${proxy.full}`);
       }
-    } else if(USE_NATIVE_PROXY_POOL&&!PROXY_URL&&!ENABLE_PROXY_SERVER) {
-      const proxy = await proxyPool.getProxy();
-      if (proxy) {
-        fetchOptions.agent = new HttpsProxyAgent(proxy.url);
-        logger.info(`使用原生代理池: ${proxy.url} (来自 ${proxy.source})`);
-      } else {
-        logger.warning("原生代理池已启用但没有可用的代理，将不使用代理");
+      else{
+        logger.warning(`没有可用代理`);
       }
+    } else if(USE_NATIVE_PROXY_POOL&&!PROXY_URL&&!ENABLE_PROXY_SERVER) {
+      const { HttpsProxyAgent } = await import('https-proxy-agent');
+      proxy = proxyPool.getProxy();
+      fetchOptions.agent = new HttpsProxyAgent(proxy.full);
+      logger.info(`使用代理: ${proxy.full}`);
     }else if(PROXY_URL){
-      // IPv6 优先
-      const customLookup = (hostname, options, callback) => {
-        dns.lookup(hostname, { family: 6 }, (err, address, family) => {
-          if (err) {
-            // 如果 IPv6 查询失败，则回退到 IPv4
-            dns.lookup(hostname, { family: 4 }, (err, address, family) => {
-              callback(err, address, family);
-            });
-          } else {
-            callback(err, address, family);
-          }
-        });
-      };
-      fetchOptions.agent = new HttpsProxyAgent(PROXY_URL, { lookup: customLookup });
+      const { HttpsProxyAgent } = await import('https-proxy-agent');
+      fetchOptions.agent = new HttpsProxyAgent(PROXY_URL);
       logger.info(`使用代理: ${PROXY_URL}`);
     }
-    else if (ENABLE_PROXY_SERVER && !USE_NATIVE_PROXY_POOL && !PROXY_URL){
-      const proxy = await proxyPool.getProxy();
-      fetchOptions.agent = new HttpsProxyAgent(proxy.url);
-      logger.info(`使用代理: ${proxy.url} (来自 ${proxy.source})`);
-    }
     let response = null;
     // 发送请求
     if (ENABLE_PROXY_SERVER && USE_NATIVE_PROXY_POOL){
@@ -873,7 +855,7 @@ async function initialize() {
   if (process.env.USE_NATIVE_PROXY_POOL === 'true') {
     logger.info(`正在初始化本地代理池...`);
     // 设置代理池的日志级别为warn，减少详细日志输出
-    proxyPool.logLevel = 'info';
+    proxyPool.logLevel = 'error';
     // 启用进度条显示
     proxyPool.showProgressBar = true;
     

src/proxy/chrome_proxy_server_android_arm64

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9112e4db1662224d93d2d24a30757333772f7338f059b926b1c3a9259679ab8f
-size 12876212
+oid sha256:e4fce54fee0fe3acc4d255517134dcabb9dc3086e9dbe571bc9f8f216ba64039
+size 12863727

src/proxy/chrome_proxy_server_linux_amd64

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:1821473bb2f1ef3b6e49b5ada7f53489055febf5510cef14593ae74a0e0ea32c
-size 12856741
+oid sha256:2e33e31ff51fb711daff95ca41f84e5f56dbfc9c57b90df3761bc1d69e57bfa9
+size 12845606

src/proxy/chrome_proxy_server_windows_amd64.exe

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:0f4e3b606b6b9bf118b8de79e80778eda24c2b9511e562cc9f5813d803bd69f7
-size 12977664
+oid sha256:bb09f4ed7261e2f0db9be7b1c37df628549df6243aee4c6e3b25d3e9452028f6
+size 12961280