Upload 17 files

Dockerfile

@@ -16,6 +16,19 @@ RUN npm install --production
 # Copy the rest of the application source code to the working directory
 COPY . .
 
+# Switch to root to install packages and set up the environment
+USER root
+
+# Install proxychains-ng for transparent proxying
+RUN apt-get update && apt-get install -y --no-install-recommends proxychains-ng && rm -rf /var/lib/apt/lists/*
+
+# Copy the entrypoint script and make it executable
+COPY entrypoint.sh /app/entrypoint.sh
+RUN chmod +x /app/entrypoint.sh
+
+# Create a directory for proxychains configuration for the 'node' user
+RUN mkdir -p /home/node/.proxychains && chown -R node:node /home/node/.proxychains
+
 # Grant execute permission to the proxy server binary for the root user
 RUN chmod +x /app/src/proxy/chrome_proxy_server_linux_amd64
 
@@ -28,5 +41,8 @@ USER node
 # Make port 7860 available to the world outside this container
 EXPOSE 7860
 
-# Define the command to run the app
+# Use the entrypoint script to start the application
+ENTRYPOINT ["/app/entrypoint.sh"]
+
+# Define the default command to run the app (will be passed to the entrypoint)
 CMD ["npm", "start"] 

entrypoint.sh

@@ -0,0 +1,55 @@
+#!/bin/sh
+set -e
+
+# This script configures and runs the application with proxychains if PROXY_URL is set.
+# It is designed to be the ENTRYPOINT of a Docker container.
+
+if [ -n "$PROXY_URL" ]; then
+    echo "PROXY_URL is set. Configuring proxychains..."
+
+    # Extract details from PROXY_URL
+    # Format: http://user:pass@host:port
+    PROTO=$(echo "$PROXY_URL" | grep :// | sed -e's,^\(.*://\).*,\1,g' | sed -e 's,://,,g')
+    URL_NO_PROTO=$(echo "$PROXY_URL" | sed -e 's,^.*://,,g')
+    USER_PASS=$(echo "$URL_NO_PROTO" | grep -o '.*@' | sed 's/@//')
+    HOST_PORT=$(echo "$URL_NO_PROTO" | sed -e "s,$USER_PASS@,,g")
+    HOST=$(echo "$HOST_PORT" | cut -d: -f1)
+    PORT=$(echo "$HOST_PORT" | cut -d: -f2)
+
+    # Default to http if protocol is not supported by proxychains
+    if [ "$PROTO" != "http" ] && [ "$PROTO" != "socks4" ] && [ "$PROTO" != "socks5" ]; then
+        echo "Warning: Unsupported proxy type '$PROTO'. Defaulting to 'http'."
+        PROTO="http"
+    fi
+
+    # Create proxychains config in the home directory of the 'node' user
+    CONFIG_DIR="/home/node/.proxychains"
+    mkdir -p "$CONFIG_DIR"
+    CONFIG_FILE="$CONFIG_DIR/proxychains.conf"
+
+    # Write base config
+    cat > "$CONFIG_FILE" <<EOF
+strict_chain
+proxy_dns
+[ProxyList]
+EOF
+
+    # Add proxy server entry
+    if [ -n "$USER_PASS" ]; then
+        USER=$(echo "$USER_PASS" | cut -d: -f1)
+        PASS=$(echo "$USER_PASS" | cut -d: -f2)
+        echo "$PROTO $HOST $PORT $USER $PASS" >> "$CONFIG_FILE"
+        echo "Configured proxy: $PROTO://$USER_PASS@$HOST:$PORT"
+    else
+        echo "$PROTO $HOST $PORT" >> "$CONFIG_FILE"
+        echo "Configured proxy: $PROTO://$HOST:$PORT"
+    fi
+
+    echo "Starting application with proxychains..."
+    # Execute the command passed to the script, wrapped in proxychains
+    exec proxychains4 "$@"
+else
+    echo "PROXY_URL is not set. Starting application without proxy."
+    # Execute the command as is
+    exec "$@"
+fi 

src/ProxyPool.js

@@ -1,166 +1,524 @@
 import axios from 'axios';
-import dotenv from 'dotenv';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-
-// 获取当前文件的目录路径
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-// 加载环境变量
-dotenv.config({ path: join(dirname(__dirname), '.env') });
 
 /**
- * 代理管理类，用于提供一个静态的HTTP代理
+ * 代理池类，用于管理和提供HTTP代理
  */
 class ProxyPool {
   /**
-   * 创建代理管理器实例
-   * @param {Object} options - 配置选项 (大部分将被忽略)
-   * @param {string} options.targetUrl - 测试代理用的目标网站URL
-   * @param {number} options.requestTimeout - 请求目标网站的超时时间(毫秒)
+   * 创建代理池实例
+   * @param {Object} options - 配置选项
+   * @param {number} options.targetCount - 目标代理数量，默认20
+   * @param {number} options.batchSize - 每次获取的代理数量，默认20
+   * @param {number} options.testTimeout - 测试代理超时时间(毫秒)，默认5000
+   * @param {number} options.requestTimeout - 请求目标网站超时时间(毫秒)，默认10000
+   * @param {string} options.targetUrl - 目标网站URL，默认'https://www.notion.so'
+   * @param {number} options.concurrentRequests - 并发请求数量，默认10
+   * @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 {boolean} options.useCache - 是否使用缓存，默认true
+   * @param {number} options.cacheExpiry - 缓存过期时间(毫秒)，默认3600000 (1小时)
    */
   constructor(options = {}) {
-    this.staticProxy = process.env.STATIC_PROXY;
-    this.targetUrl = options.targetUrl || 'https://www.notion.so';
+    // 配置参数
+    this.targetCount = options.targetCount || 20;
+    this.batchSize = options.batchSize || 20;
+    this.testTimeout = options.testTimeout || 5000;
     this.requestTimeout = options.requestTimeout || 10000;
+    this.targetUrl = options.targetUrl || 'https://www.notion.so';
+    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 || 20; // 减少最大尝试次数
+    this.retryDelay = options.retryDelay || 1000; // 减少重试延迟
+    this.useCache = options.useCache !== undefined ? options.useCache : true;
+    this.cacheExpiry = options.cacheExpiry || 3600000; // 默认1小时
     
-    this.proxy = null; // 将存储解析后的代理对象
+    // 内部状态
+    this.availableProxies = [];
+    this.currentIndex = 0;
     this.isInitialized = false;
-
+    this.isRefilling = false;
+    this.checkTimer = null;
+    this.proxyCache = new Map(); // 缓存验证过的代理
+    
     // 绑定方法
     this.getProxy = this.getProxy.bind(this);
     this.removeProxy = this.removeProxy.bind(this);
+    this.checkAndRefill = this.checkAndRefill.bind(this);
   }
   
   /**
-   * 初始化代理
+   * 初始化代理池
    * @returns {Promise<void>}
    */
   async initialize() {
     if (this.isInitialized) return;
-
-    if (!this.staticProxy) {
-      console.error('错误: 环境变量 STATIC_PROXY 未设置。无法初始化代理。');
-      this.isInitialized = true;
-      return;
+    
+    console.log(`初始化代理池，目标数量: ${this.targetCount}`);
+    await this.refillProxies();
+    
+    // 设置定时检查
+    this.checkTimer = setInterval(this.checkAndRefill, this.checkInterval);
+    
+    this.isInitialized = true;
+    console.log(`代理池初始化完成，当前可用代理数量: ${this.availableProxies.length}`);
+  }
+  
+  /**
+   * 停止代理池服务
+   */
+  stop() {
+    if (this.checkTimer) {
+      clearInterval(this.checkTimer);
+      this.checkTimer = null;
     }
+    console.log('代理池服务已停止');
+  }
+  
+  /**
+   * 检查并补充代理
+   */
+  async checkAndRefill() {
+    if (this.availableProxies.length <= this.minThreshold && !this.isRefilling) {
+      console.log(`可用代理数量(${this.availableProxies.length})低于阈值(${this.minThreshold})，开始补充代理`);
+      await this.refillProxies();
+    }
+  }
+  
+  /**
+   * 补充代理到目标数量
+   * @returns {Promise<void>}
+   */
+  async refillProxies() {
+    if (this.isRefilling) return;
     
-    console.log(`初始化静态代理: ${this.staticProxy}`);
+    this.isRefilling = true;
+    console.log(`开始补充代理，当前数量: ${this.availableProxies.length}，目标���量: ${this.targetCount}`);
+    
+    let attempts = 0;
     
     try {
-      const url = new URL(this.staticProxy);
-      const protocol = url.protocol.slice(0, -1);
-      const proxyUrlForTest = `${url.hostname}:${url.port}`;
+      // 计算需要补充的代理数量
+      const neededProxies = this.targetCount - this.availableProxies.length;
       
-      const isValid = await this.testProxy(proxyUrlForTest, protocol);
-
-      if (isValid) {
-        this.proxy = {
-          ip: url.hostname,
-          port: url.port,
-          protocol: protocol,
-          full: this.staticProxy,
-          addedAt: new Date().toISOString()
-        };
-        console.log(`静态代理 ${this.staticProxy} 已验证并准备就绪。`);
-      } else {
-        console.warn(`警告: 静态代理 ${this.staticProxy} 测试失败，当前不可用。后续将继续尝试使用。`);
-        // 即使测试失败，也设置代理对象，以便 getProxy 可以返回它
-        // 调用方需要处理请求失败的情况
-        this.proxy = {
-          ip: url.hostname,
-          port: url.port,
-          protocol: protocol,
-          full: this.staticProxy,
-        };
+      // 优先检查缓存中的代理
+      if (this.useCache && this.proxyCache.size > 0) {
+        await this.tryUsingCachedProxies(neededProxies);
+      }
+      
+      // 如果缓存中的代理不足，继续获取新代理
+      while (this.availableProxies.length < this.targetCount && attempts < this.maxRefillAttempts) {
+        attempts++;
+        
+        console.log(`补充尝试 #${attempts}，当前可用代理: ${this.availableProxies.length}/${this.targetCount}`);
+        
+        // 计算本次需要获取的批次大小
+        const remainingNeeded = this.targetCount - this.availableProxies.length;
+        const batchSizeNeeded = Math.max(this.batchSize, remainingNeeded * 2); // 获取更多代理以提高成功率
+        
+        // 获取代理
+        const proxies = await this.getProxiesFromProvider(batchSizeNeeded);
+        
+        if (proxies.length === 0) {
+          console.log(`没有获取到代理，等待${this.retryDelay/1000}秒后重试...`);
+          await new Promise(resolve => setTimeout(resolve, this.retryDelay));
+          continue;
+        }
+        
+        // 过滤掉已有的代理
+        const newProxies = this.filterExistingProxies(proxies);
+        
+        if (newProxies.length === 0) {
+          console.log('所有获取的代理都已存在，继续获取新代理...');
+          continue;
+        }
+        
+        // 测试代理
+        const results = await this.testProxiesConcurrently(newProxies);
+        
+        // 添加可用代理
+        this.addValidProxies(results);
+        
+        // 如果已经获取到足够的代理，提前结束
+        if (this.availableProxies.length >= this.targetCount) {
+          break;
+        }
+        
+        // 如果还没补充到足够的代理，等待一段时间再继续
+        if (this.availableProxies.length < this.targetCount) {
+          await new Promise(resolve => setTimeout(resolve, this.retryDelay));
+        }
       }
     } catch (error) {
-      console.error(`无效的静态代理URL '${this.staticProxy}': ${error.message}`);
-      // 阻止程序继续运行，因为代理配置是关键
+      console.error('补充代理过程中出错:', error);
     } finally {
-        this.isInitialized = true;
+      this.isRefilling = false;
+      
+      if (this.availableProxies.length >= this.targetCount) {
+        console.log(`代理补充完成，当前可用代理: ${this.availableProxies.length}/${this.targetCount}`);
+      } else {
+        console.log(`已达到最大尝试次数 ${this.maxRefillAttempts}，当前可用代理: ${this.availableProxies.length}/${this.targetCount}`);
+      }
     }
   }
   
   /**
-   * 停止代理服务 (空方法，为保持接口一致性)
+   * 尝试使用缓存中的代理
+   * @param {number} neededProxies - 需要的代理数量
    */
-  stop() {
-    console.log('代理服务已停止');
+  async tryUsingCachedProxies(neededProxies) {
+    const now = Date.now();
+    const cachedProxies = [];
+    
+    // 筛选未过期的缓存代理
+    for (const [proxyKey, data] of this.proxyCache.entries()) {
+      if (now - data.timestamp < this.cacheExpiry && data.valid) {
+        cachedProxies.push(proxyKey);
+        
+        if (cachedProxies.length >= neededProxies) {
+          break;
+        }
+      }
+    }
+    
+    if (cachedProxies.length > 0) {
+      console.log(`从缓存中找到 ${cachedProxies.length} 个可能可用的代理`);
+      
+      // 验证缓存的代理是否仍然可用
+      const results = await this.testProxiesConcurrently(cachedProxies);
+      this.addValidProxies(results);
+    }
+  }
+  
+  /**
+   * 过滤掉已存在的代理
+   * @param {Array<string>} proxies - 代理列表
+   * @returns {Array<string>} - 新代理列表
+   */
+  filterExistingProxies(proxies) {
+    return proxies.filter(proxy => {
+      const [ip, port] = proxy.split(':');
+      return !this.availableProxies.some(p => p.ip === ip && p.port === port);
+    });
+  }
+  
+  /**
+   * 添加有效的代理到代理池
+   * @param {Array<{proxy: string, result: boolean}>} results - 测试结果
+   */
+  addValidProxies(results) {
+    for (const { proxy, result } of results) {
+      if (result) {
+        const [ip, port] = proxy.split(':');
+        
+        // 检查是否已存在
+        if (!this.availableProxies.some(p => p.ip === ip && p.port === port)) {
+          const proxyObj = {
+            ip,
+            port,
+            protocol: this.proxyProtocol,
+            full: `${this.proxyProtocol}://${proxy}`,
+            addedAt: new Date().toISOString()
+          };
+          
+          this.availableProxies.push(proxyObj);
+          
+          // 添加到缓存
+          if (this.useCache) {
+            this.proxyCache.set(proxy, { 
+              valid: true, 
+              timestamp: Date.now() 
+            });
+          }
+          
+          console.log(`成功添加代理: ${proxyObj.full}，当前可用代理: ${this.availableProxies.length}/${this.targetCount}`);
+          
+          if (this.availableProxies.length >= this.targetCount) {
+            break;
+          }
+        }
+      } else if (this.useCache) {
+        // 记录无效代理到缓存
+        this.proxyCache.set(proxy, { 
+          valid: false, 
+          timestamp: Date.now() 
+        });
+      }
+    }
+  }
+  
+  /**
+   * 从代理服务获取代理URL
+   * @param {number} count - 请求的代理数量
+   * @returns {Promise<Array<string>>} - 代理URL列表
+   */
+  async getProxiesFromProvider(count = null) {
+    try {
+      const requestCount = count || this.batchSize;
+      const url = `https://proxy.scdn.io/api/get_proxy.php?protocol=${this.proxyProtocol}&count=${requestCount}`;
+      console.log(`正在获取代理，URL: ${url}`);
+      
+      const response = await axios.get(url, { 
+        timeout: 10000,
+        validateStatus: status => true
+      });
+      
+      if (response.data && response.data.code === 200) {
+        console.log(`成功获取 ${response.data.data.count} 个代理`);
+        return response.data.data.proxies;
+      } else {
+        console.error('获取代理失败:', response.data ? response.data.message : '未知错误');
+        return [];
+      }
+    } catch (error) {
+      console.error('获取代理出错:', error.message);
+      return [];
+    }
+  }
+  
+  /**
+   * 并发测试多个代理
+   * @param {Array<string>} proxies - 代理列表
+   * @returns {Promise<Array<{proxy: string, result: boolean}>>} - 测试结果
+   */
+  async testProxiesConcurrently(proxies) {
+    const results = [];
+    const remainingNeeded = this.targetCount - this.availableProxies.length;
+    
+    // 增加并发数以加快处理速度
+    const concurrentRequests = Math.min(this.concurrentRequests * 2, 20);
+    
+    // 分批处理代理
+    for (let i = 0; i < proxies.length; i += concurrentRequests) {
+      const batch = proxies.slice(i, i + concurrentRequests);
+      const promises = batch.map(proxy => {
+        // 检查缓存中是否有近期验证过的结果
+        if (this.useCache && this.proxyCache.has(proxy)) {
+          const cachedResult = this.proxyCache.get(proxy);
+          const isFresh = (Date.now() - cachedResult.timestamp) < this.cacheExpiry;
+          
+          if (isFresh) {
+            // 使用缓存结果，避免重复测试
+            return Promise.resolve({ proxy, result: cachedResult.valid });
+          }
+        }
+        
+        return this.testProxy(proxy)
+          .then(result => ({ proxy, result }))
+          .catch(() => ({ proxy, result: false }));
+      });
+      
+      const batchResults = await Promise.all(promises);
+      results.push(...batchResults);
+      
+      // 如果已经找到足够的代理，提前结束测试
+      const successCount = results.filter(item => item.result).length;
+      if (successCount >= remainingNeeded) {
+        break;
+      }
+    }
+    
+    return results;
   }
   
   /**
    * 测试代理是否可用
-   * @param {string} proxyUrl - 代理URL (ip:port)
-   * @param {string} protocol - 代理协议
+   * @param {string} proxyUrl - 代理URL
    * @returns {Promise<boolean>} - 代理是否可用
    */
-  async testProxy(proxyUrl, protocol) {
+  async testProxy(proxyUrl) {
     try {
-      const [host, port] = proxyUrl.split(':');
+      // 创建代理配置
       const proxyConfig = {
-        host,
-        port: parseInt(port),
-        protocol,
+        host: proxyUrl.split(':')[0],
+        port: parseInt(proxyUrl.split(':')[1]),
+        protocol: this.proxyProtocol
       };
       
+      // 发送请求到目标网站
       const response = await axios.get(this.targetUrl, {
         proxy: proxyConfig,
         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',
+          'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+          'Accept-Language': 'en-US,en;q=0.5',
+          'Connection': 'keep-alive',
+          'Upgrade-Insecure-Requests': '1'
         },
         timeout: this.requestTimeout,
-        validateStatus: (status) => status === 200,
+        validateStatus: status => true,
+        maxRedirects: 10,
+        followRedirect: true
       });
       
-      console.log(`代理 ${proxyUrl} 测试成功。`);
-      return true;
+      // 检查响应是否包含目标网站特有的内容
+      const isTargetContent = response.data && 
+                             (typeof response.data === 'string') && 
+                             (response.data.includes('notion') || 
+                              response.data.includes('Notion'));
+      
+      const isValid = response.status === 200 && isTargetContent;
+      
+      if (isValid) {
+        console.log(`代理 ${proxyUrl} 请求目标网站成功，状态码: ${response.status}`);
+      } else {
+        console.log(`代理 ${proxyUrl} 请求目标网站失败，状态码: ${response.status}`);
+      }
+      
+      return isValid;
     } catch (error) {
-      console.log(`代理 ${proxyUrl} 测试出错: ${error.message}`);
+      console.log(`代理 ${proxyUrl} 请求出错: ${error.message}`);
       return false;
     }
   }
   
   /**
-   * 获取静态代理
-   * @returns {Object|null} - 代理对象，如果没有配置则返回null
+   * 获取一个可用代理
+   * @returns {Object|null} - 代理对象，如果没有可用代理则返回null
    */
   getProxy() {
-    if (!this.proxy) {
-      if (this.staticProxy) {
-        console.warn('静态代理正在初始化或初始化失败，请稍后重试。');
-      } else {
-        console.error('未配置静态代理 (STATIC_PROXY)。');
-      }
+    if (this.availableProxies.length === 0) {
+      console.log('没有可用代理');
+      return null;
     }
-    return this.proxy;
+    
+    // 轮询方式获取代理
+    const proxy = this.availableProxies[this.currentIndex];
+    this.currentIndex = (this.currentIndex + 1) % this.availableProxies.length;
+    
+    return proxy;
   }
   
   /**
-   * 移除代理 (现在只记录日志，不实际移除)
+   * 移除指定代理
    * @param {string} ip - 代理IP
    * @param {string|number} port - 代理端口
+   * @returns {boolean} - 是否成功移除
    */
   removeProxy(ip, port) {
-    console.warn(`收到移除代理 ${ip}:${port} 的请求。由于使用的是静态代理，该请求被忽略。请检查调用方逻辑。`);
+    const portStr = port.toString();
+    const initialLength = this.availableProxies.length;
+    
+    // 找到要移除的代理
+    const proxyToRemove = this.availableProxies.find(
+      proxy => proxy.ip === ip && proxy.port === portStr
+    );
+    
+    if (proxyToRemove) {
+      // 更新缓存，标记为无效
+      if (this.useCache) {
+        const proxyKey = `${ip}:${portStr}`;
+        this.proxyCache.set(proxyKey, { valid: false, timestamp: Date.now() });
+      }
+    }
+    
+    this.availableProxies = this.availableProxies.filter(
+      proxy => !(proxy.ip === ip && proxy.port === portStr)
+    );
+    
+    // 重置当前索引，确保不会越界
+    if (this.currentIndex >= this.availableProxies.length && this.availableProxies.length > 0) {
+      this.currentIndex = 0;
+    }
+    
+    const removed = initialLength > this.availableProxies.length;
+    
+    if (removed) {
+      console.log(`已移除代理 ${ip}:${port}，当前可用代理: ${this.availableProxies.length}`);
+    } else {
+      console.log(`未找到要移除的代理 ${ip}:${port}`);
+    }
+    
+    // 如果移除后代理数量低于阈值，触发补充
+    this.checkAndRefill();
+    
+    return removed;
   }
   
   /**
-   * 获取所有可用代理 (只会有一个)
+   * 获取所有可用代理
    * @returns {Array<Object>} - 代理对象数组
    */
   getAllProxies() {
-    return this.proxy ? [this.proxy] : [];
+    return [...this.availableProxies];
   }
   
   /**
-   * 获取可用代理数量 (0或1)
+   * 获取可用代理数量
    * @returns {number} - 代理数量
    */
   getCount() {
-    return this.proxy ? 1 : 0;
+    return this.availableProxies.length;
   }
+  
+  /**
+   * 清理过期的缓存条目
+   */
+  cleanupCache() {
+    if (!this.useCache) return;
+    
+    const now = Date.now();
+    let cleanupCount = 0;
+    
+    for (const [key, data] of this.proxyCache.entries()) {
+      if (now - data.timestamp > this.cacheExpiry) {
+        this.proxyCache.delete(key);
+        cleanupCount++;
+      }
+    }
+    
+    if (cleanupCount > 0) {
+      console.log(`清理了 ${cleanupCount} 个过期的缓存代理`);
+    }
+  }
+}
+
+// 使用示例
+async function example() {
+  // 创建代理池实例
+  const proxyPool = new ProxyPool({
+    targetCount: 10,           // 目标保持10个代理
+    minThreshold: 3,           // 当可用代理少于3个时，自动补充
+    checkInterval: 60000,      // 每60秒检查一次
+    targetUrl: 'https://www.notion.so',
+    concurrentRequests: 15,    // 增加并发请求数
+    useCache: true,            // 启用缓存
+    maxRefillAttempts: 15,     // 减少最大尝试次数
+    retryDelay: 1000           // 减少重试延迟
+  });
+  
+  // 初始化代理池
+  await proxyPool.initialize();
+  
+  // 获取一个代理
+  const proxy = proxyPool.getProxy();
+  console.log('获取到代理:', proxy);
+  
+  // 模拟使用一段时间后，移除一个代理
+  setTimeout(() => {
+    if (proxy) {
+      proxyPool.removeProxy(proxy.ip, proxy.port);
+    }
+    
+    // 获取所有代理
+    const allProxies = proxyPool.getAllProxies();
+    console.log(`当前所有代理(${allProxies.length}):`, allProxies);
+    
+    // 使用完毕后停止服务
+    setTimeout(() => {
+      proxyPool.stop();
+      console.log('代理池示例运行完毕');
+    }, 5000);
+  }, 5000);
+}
+
+// 如果直接运行此文件，则执行示例
+if (typeof require !== 'undefined' && require.main === module) {
+  example().catch(err => console.error('示例运行出错:', err));
 }
 
 // 导出 ProxyPool 类和实例

src/ProxyServer.js

@@ -106,36 +106,23 @@ class ProxyServer {
       // 创建日志文件
       this.logStream = fs.createWriteStream(this.logPath, { flags: 'a' });
       
-      const spawnArgs = [
+      // 修复 stdio 参数问题
+      // 启动代理服务器进程
+      this.proxyProcess = spawn(proxyServerPath, [
         '--port', this.port.toString(),
         '--token', this.proxyAuthToken
-      ];
-
-      const staticProxy = process.env.STATIC_PROXY;
-      if (staticProxy) {
-        spawnArgs.push(`--proxy-server=${staticProxy}`);
-        logger.info(`为 chrome_proxy_server 配置上游代理: ${staticProxy}`);
-      }
-
-      // 启动代理服务器进程
-      this.proxyProcess = spawn(proxyServerPath, spawnArgs, {
-        stdio: ['ignore', 'pipe', 'pipe'],
+      ], {
+        stdio: ['ignore', 'pipe', 'pipe'], // 使用pipe而不是直接传递流
         detached: false
       });
 
       // 将进程的输出重定向到日志文件
       if (this.proxyProcess.stdout) {
         this.proxyProcess.stdout.pipe(this.logStream);
-        this.proxyProcess.stdout.on('data', (data) => {
-          logger.info(`[ProxyExecutable STDOUT] ${data.toString().trim()}`);
-        });
       }
       
       if (this.proxyProcess.stderr) {
         this.proxyProcess.stderr.pipe(this.logStream);
-        this.proxyProcess.stderr.on('data', (data) => {
-          logger.error(`[ProxyExecutable STDERR] ${data.toString().trim()}`);
-        });
       }
 
       // 设置进程事件处理

src/lightweight-client.js

@@ -34,10 +34,13 @@ const logger = {
 const NOTION_API_URL = "https://www.notion.so/api/v3/runInferenceTranscript";
 // 这些变量将由cookieManager动态提供
 let currentCookieData = null;
+const USE_NATIVE_PROXY_POOL = process.env.USE_NATIVE_PROXY_POOL === 'true';
 const ENABLE_PROXY_SERVER = process.env.ENABLE_PROXY_SERVER === 'true';
-const STATIC_PROXY = process.env.STATIC_PROXY;
 let proxy = null;
 
+// 代理配置
+const PROXY_URL = process.env.PROXY_URL || "";
+
 // 标记是否成功初始化
 let INITIALIZED_SUCCESSFULLY = false;
 
@@ -338,17 +341,22 @@ async function fetchNotionResponse(chunkQueue, notionRequestBody, headers, notio
     };
     
     // 添加代理配置（如果有）
-    if (!ENABLE_PROXY_SERVER && STATIC_PROXY) {
+    if (USE_NATIVE_PROXY_POOL) {
       proxy = proxyPool.getProxy();
-      if (proxy && proxy.full) {
+      if (proxy !== null)
+      {
         const { HttpsProxyAgent } = await import('https-proxy-agent');
         fetchOptions.agent = new HttpsProxyAgent(proxy.full);
-        logger.info(`使用静态代理: ${proxy.full}`);
-      } else {
-        logger.warning(`无法从 proxyPool 获取到静态代理，将不使用代理进行请求。`);
+        logger.info(`使用代理: ${proxy.full}`);
+      }
+      else{
+        logger.warning(`没有可用代理`);
       }
+    } else if(PROXY_URL) {
+      const { HttpsProxyAgent } = await import('https-proxy-agent');
+      fetchOptions.agent = new HttpsProxyAgent(PROXY_URL);
+      logger.info(`使用代理: ${PROXY_URL}`);
     }
-
     let response = null;
     // 发送请求
     if (ENABLE_PROXY_SERVER){
@@ -481,7 +489,7 @@ async function fetchNotionResponse(chunkQueue, notionRequestBody, headers, notio
         // 如果没有收到任何响应，发送一个提示消息
         if (!responseReceived) {
           logger.warning(`未从Notion收到内容响应,请更换ip重试`);
-          if (ENABLE_PROXY_SERVER) {
+          if (USE_NATIVE_PROXY_POOL) {
             proxyPool.removeProxy(proxy.ip, proxy.port);
           }
           
@@ -733,6 +741,11 @@ async function initialize() {
   logger.info(`当前使用的cookie对应的用户ID: ${currentCookieData.userId}`);
   logger.info(`当前使用的cookie对应的空间ID: ${currentCookieData.spaceId}`);
   
+  if (process.env.USE_NATIVE_PROXY_POOL === 'true') {
+    logger.info(`正在初始化本地代理池...`);
+    await proxyPool.initialize();
+  }
+  
   INITIALIZED_SUCCESSFULLY = true;
 }