Upload 15 files

src/CookieManager.js

@@ -253,13 +253,6 @@ class CookieManager {
         body: JSON.stringify({}),
       };
       
-      // 添加代理配置（如果有）
-      if (this.proxyUrl) {
-        const { HttpsProxyAgent } = await import('https-proxy-agent');
-        fetchOptions.agent = new HttpsProxyAgent(this.proxyUrl);
-        logger.info(`使用代理: ${this.proxyUrl}`);
-      }
-      
       // 发送请求
       const response = await fetch("https://www.notion.so/api/v3/getSpaces", fetchOptions);
       

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 - 测试代理超时时间(毫秒)，默认5000
-   * @param {number} options.requestTimeout - 请求目标网站超时时间(毫秒)，默认10000
+   * @param {number} options.testTimeout - 测试代理超时时间(毫秒)，默认3000
+   * @param {number} options.requestTimeout - 请求目标网站超时时间(毫秒)，默认5000
    * @param {string} options.targetUrl - 目标网站URL，默认'https://www.notion.so'
-   * @param {number} options.concurrentRequests - 并发请求数量，默认10
+   * @param {number} options.concurrentRequests - 并发请求数量，默认15
    * @param {number} options.minThreshold - 可用代理数量低于此阈值时自动补充，默认5
    * @param {number} options.checkInterval - 检查代理池状态的时间间隔(毫秒)，默认30000
    * @param {string} options.proxyProtocol - 代理协议，默认'http'
-   * @param {number} options.maxRefillAttempts - 最大补充尝试次数，默认20
-   * @param {number} options.retryDelay - 重试延迟(毫秒)，默认1000
+   * @param {number} options.maxRefillAttempts - 最大补充尝试次数，默认50
+   * @param {number} options.retryDelay - 重试延迟(毫秒)，默认500
    * @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 || 5000;
-    this.requestTimeout = options.requestTimeout || 10000;
+    this.testTimeout = options.testTimeout || 3000; // 减少测试超时时间
+    this.requestTimeout = options.requestTimeout || 5000; // 减少请求超时时间
     this.targetUrl = options.targetUrl || 'https://www.notion.so';
-    this.concurrentRequests = options.concurrentRequests || 10;
+    this.concurrentRequests = options.concurrentRequests || 15; // 增加默认并发请求数
     this.minThreshold = options.minThreshold || 5;
     this.checkInterval = options.checkInterval || 30000; // 默认30秒检查一次
     this.proxyProtocol = options.proxyProtocol || 'http';
-    this.maxRefillAttempts = options.maxRefillAttempts || 20; // 减少最大尝试次数
-    this.retryDelay = options.retryDelay || 1000; // 减少重试延迟
+    this.maxRefillAttempts = options.maxRefillAttempts || 50; // 增加最大尝试次数
+    this.retryDelay = options.retryDelay || 500; // 减少重试延迟
     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(this.batchSize, remainingNeeded * 2); // 获取更多代理以提高成功率
+        const batchSizeNeeded = Math.max(remainingNeeded * 2, 10); // 获取更多代理以提高成功率，至少10个
         
         // 获取代理
         const proxies = await this.getProxiesFromProvider(batchSizeNeeded);
@@ -253,6 +253,7 @@ class ProxyPool {
         
         if (newProxies.length === 0) {
           this.log('debug', '所有获取的代理都已存在，继续获取新代理...');
+          // 减少等待时间，立即继续尝试
           continue;
         }
         
@@ -274,9 +275,9 @@ class ProxyPool {
           break;
         }
         
-        // 如果还没补充到足够的代理，等待一段时间再继续
+        // 如果还没补充到足够的代理，减少等待时间再继续
         if (this.availableProxies.length < this.targetCount) {
-          await new Promise(resolve => setTimeout(resolve, this.retryDelay));
+          await new Promise(resolve => setTimeout(resolve, 500)); // 减少等待时间到500毫秒
         }
       }
     } catch (error) {
@@ -426,43 +427,85 @@ 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 response = await axios.get(url, { 
-        timeout: 10000,
-        validateStatus: status => true
-      });
+      // 计算需要发送的请求数量，以获取足够的代理
+      const requestsNeeded = Math.ceil(requestCount / 1); // 假设每次请求只返回1个代理
+      const maxParallelRequests = 5; // 最大并行请求数
+      const actualRequests = Math.min(requestsNeeded, maxParallelRequests);
+      
+      this.log('debug', `需要 ${requestCount} 个代理，将发送 ${actualRequests} 个并行请求`);
       
-      if (response.data) {
-        // 解析返回的数据格式
-        const proxyDataArray = response.data.trim().split('\n').filter(line => line.trim() !== '');
-        const proxies = [];
+      // 并行发送多个请求
+      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 = [];
+      
+      for (const response of responses) {
+        if (!response.data) continue;
         
-        for (const line of proxyDataArray) {
-          try {
-            const proxyData = JSON.parse(line);
-            if (proxyData.ip && proxyData.port) {
-              // 如果有用户名和密码，则使用认证格式
-              if (proxyData.username && proxyData.password) {
-                proxies.push(`${proxyData.ip}:${proxyData.port}:${proxyData.username}:${proxyData.password}`);
+        // 处理不同的返回格式
+        if (typeof response.data === 'string') {
+          // 如果返回的是字符串，尝试按行解析
+          const proxyDataArray = response.data.trim().split('\n').filter(line => line.trim() !== '');
+          
+          for (const line of proxyDataArray) {
+            try {
+              const proxyData = JSON.parse(line);
+              if (proxyData.ip && proxyData.port) {
+                // 如果有用户名和密码，则使用认证格式
+                if (proxyData.username && proxyData.password) {
+                  proxies.push(`${proxyData.ip}:${proxyData.port}:${proxyData.username}:${proxyData.password}`);
+                } else {
+                  proxies.push(`${proxyData.ip}:${proxyData.port}`);
+                }
+              }
+            } catch (err) {
+              this.log('error', '解析代理数据出错:', err.message);
+            }
+          }
+        } else if (typeof response.data === 'object') {
+          // 如果返回的是对象
+          if (Array.isArray(response.data)) {
+            // 如果是数组，遍历处理
+            for (const proxyData of response.data) {
+              if (proxyData.ip && proxyData.port) {
+                if (proxyData.username && proxyData.password) {
+                  proxies.push(`${proxyData.ip}:${proxyData.port}:${proxyData.username}:${proxyData.password}`);
+                } else {
+                  proxies.push(`${proxyData.ip}:${proxyData.port}`);
+                }
+              }
+            }
+          } else {
+            // 如果是单个对象
+            if (response.data.ip && response.data.port) {
+              if (response.data.username && response.data.password) {
+                proxies.push(`${response.data.ip}:${response.data.port}:${response.data.username}:${response.data.password}`);
               } else {
-                proxies.push(`${proxyData.ip}:${proxyData.port}`);
+                proxies.push(`${response.data.ip}:${response.data.port}`);
               }
             }
-          } catch (err) {
-            this.log('error', '解析代理数据出错:', err.message);
           }
         }
-        
-        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 [];
@@ -479,7 +522,7 @@ class ProxyPool {
     const remainingNeeded = this.targetCount - this.availableProxies.length;
     
     // 增加并发数以加快处理速度
-    const concurrentRequests = Math.min(this.concurrentRequests * 2, 20);
+    const concurrentRequests = Math.min(this.concurrentRequests * 3, 30); // 增加到最多30个并发请求
     
     // 分批处理代理
     for (let i = 0; i < proxies.length; i += concurrentRequests) {
@@ -559,9 +602,9 @@ class ProxyPool {
           'Connection': 'keep-alive',
           'Upgrade-Insecure-Requests': '1'
         },
-        timeout: this.requestTimeout,
+        timeout: Math.min(this.requestTimeout, 5000), // 减少超时时间，最多5秒
         validateStatus: status => true,
-        maxRedirects: 10,
+        maxRedirects: 5, // 减少最大重定向次数
         followRedirect: true
       });
       
@@ -695,10 +738,12 @@ async function example() {
     minThreshold: 3,           // 当可用代理少于3个时，自动补充
     checkInterval: 60000,      // 每60秒检查一次
     targetUrl: 'https://www.notion.so',
-    concurrentRequests: 15,    // 增加并发请求数
+    concurrentRequests: 20,    // 增加并发请求数
     useCache: true,            // 启用缓存
-    maxRefillAttempts: 15,     // 减少最大尝试次数
-    retryDelay: 1000,          // 减少重试延迟
+    maxRefillAttempts: 50,     // 增加最大尝试次数
+    retryDelay: 500,           // 减少重试延迟
+    testTimeout: 3000,         // 减少测试超时时间
+    requestTimeout: 5000,      // 减少请求超时时间
     logLevel: 'info',          // 设置日志级别
     showProgressBar: true      // 启用进度条
   });

src/ProxyServer.js

@@ -26,13 +26,7 @@ class ProxyServer {
     this.proxyProcess = null;
     this.platform = process.env.PROXY_SERVER_PLATFORM || 'auto';
     this.port = process.env.PROXY_SERVER_PORT || 10655;
-    
-    // 检查是否在Linux环境下，并且没有指定日志路径
-    const defaultLogPath = os.platform() === 'linux' && !process.env.PROXY_SERVER_LOG_PATH
-      ? '/tmp/proxy_server.log'
-      : './proxy_server.log';
-
-    this.logPath = process.env.PROXY_SERVER_LOG_PATH || defaultLogPath;
+    this.logPath = process.env.PROXY_SERVER_LOG_PATH || './proxy_server.log';
     this.enabled = process.env.ENABLE_PROXY_SERVER === 'true';
     this.proxyAuthToken = process.env.PROXY_AUTH_TOKEN || 'default_token';
     this.logStream = null;
@@ -103,11 +97,9 @@ class ProxyServer {
       // 确保可执行文件有执行权限（在Linux/Android上）
       if (this.detectPlatform() !== 'windows') {
         try {
-          // 在Docker等只读文件系统中，这可能会失败，但我们在Dockerfile中已经设置了权限
-          // fs.chmodSync(proxyServerPath, 0o755);
+          fs.chmodSync(proxyServerPath, 0o755);
         } catch (err) {
-          // 忽略这个错误，因为可能是在一个只读的环境中
-          // logger.warning(`无法设置执行权限: ${err.message}`);
+          logger.warning(`无法设置执行权限: ${err.message}`);
         }
       }
 

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 = 'error';
+proxyPool.logLevel = 'info';
 
 // 初始化并启动服务器
 initialize().then(() => {

src/lightweight-client.js

@@ -403,7 +403,7 @@ async function fetchNotionResponse(chunkQueue, notionRequestBody, headers, notio
       proxy = proxyPool.getProxy();
       fetchOptions.agent = new HttpsProxyAgent(proxy.full);
       logger.info(`使用代理: ${proxy.full}`);
-    }else if(!ENABLE_PROXY_SERVER && PROXY_URL){
+    }else if(PROXY_URL){
       const { HttpsProxyAgent } = await import('https-proxy-agent');
       fetchOptions.agent = new HttpsProxyAgent(PROXY_URL);
       logger.info(`使用代理: ${PROXY_URL}`);
@@ -855,7 +855,7 @@ async function initialize() {
   if (process.env.USE_NATIVE_PROXY_POOL === 'true') {
     logger.info(`正在初始化本地代理池...`);
     // 设置代理池的日志级别为warn，减少详细日志输出
-    proxyPool.logLevel = 'error';
+    proxyPool.logLevel = 'info';
     // 启用进度条显示
     proxyPool.showProgressBar = true;
     

src/proxy/chrome_proxy_server_android_arm64

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

src/proxy/chrome_proxy_server_linux_amd64

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

src/proxy/chrome_proxy_server_windows_amd64.exe

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