Upload 16 files

proxy_server.log

@@ -86,3 +86,11 @@
 2025/06/11 17:54:09.357768 chrome_tls_proxy.go:710: 已禁用并发限制：允许同一IP发起多个并发请求
 2025/06/11 17:54:09.357768 chrome_tls_proxy.go:711: 已强制使用IPv4连接，并使用8.8.8.8作为DNS服务器
 2025/06/11 17:54:09.357768 chrome_tls_proxy.go:712: 使用Chrome浏览器的TLS指纹进行连接
+2025/06/11 18:05:05.408576 chrome_tls_proxy.go:706: Chrome TLS指纹代理服务器运行在 http://localhost:10655/proxy
+2025/06/11 18:05:05.413163 chrome_tls_proxy.go:707: 使用方法：向/proxy发送POST请求，请求体包含目标URL、方法、请求头和请求体
+2025/06/11 18:05:05.413163 chrome_tls_proxy.go:708: 支持流式响应，需要在请求体中添加 'stream': true
+2025/06/11 18:05:05.413163 chrome_tls_proxy.go:709: 已禁用速率限制：允许无限制请求
+2025/06/11 18:05:05.413163 chrome_tls_proxy.go:710: 已禁用并发限制：允许同一IP发起多个并发请求
+2025/06/11 18:05:05.413163 chrome_tls_proxy.go:711: 已强制使用IPv4连接，并使用8.8.8.8作为DNS服务器
+2025/06/11 18:05:05.413163 chrome_tls_proxy.go:712: 使用Chrome浏览器的TLS指纹进行连接
+2025/06/11 18:05:05.414212 chrome_tls_proxy.go:716: 服务器启动失败: listen tcp :10655: bind: Only one usage of each socket address (protocol/network address/port) is normally permitted.

src/ProxyPool.js

@@ -1,5 +1,14 @@
 import axios from 'axios';
-import { URL } from 'url';
+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代理
@@ -21,25 +30,33 @@ class ProxyPool {
    * @param {number} options.retryDelay - 重试延迟(毫秒)，默认1000
    * @param {boolean} options.useCache - 是否使用缓存，默认true
    * @param {number} options.cacheExpiry - 缓存过期时间(毫秒)，默认3600000 (1小时)
-   * @param {string} options.staticProxy - 静态代理地址，如果提供，将优先使用此代理
    */
   constructor(options = {}) {
-    // 新增静态代理配置 - 优先使用传入的选项，否则从环境变量读取
-    this.staticProxy = options.staticProxy || process.env.STATIC_PROXY || null;
+    this.staticProxy = process.env.STATIC_PROXY;
 
     // 配置参数
-    this.targetCount = options.targetCount || 20;
-    this.batchSize = options.batchSize || 20;
+    if (this.staticProxy) {
+      console.log(`检测到静态代理配置，将使用静态代理模式: ${this.staticProxy}`);
+      this.targetCount = 1;
+      this.batchSize = 1;
+      this.minThreshold = 0;
+      this.maxRefillAttempts = 5;
+      this.useCache = false;
+    } else {
+      this.targetCount = options.targetCount || 20;
+      this.batchSize = options.batchSize || 20;
+      this.minThreshold = options.minThreshold || 5;
+      this.maxRefillAttempts = options.maxRefillAttempts || 20; // 减少最大尝试次数
+      this.useCache = options.useCache !== undefined ? options.useCache : true;
+    }
+
     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小时
     
     // 内部状态
@@ -63,45 +80,6 @@ class ProxyPool {
   async initialize() {
     if (this.isInitialized) return;
     
-    // 如果配置了静态代理，则使用静态代理
-    if (this.staticProxy) {
-      console.log(`初始化代理池，使用静态代理: ${this.staticProxy}`);
-      try {
-        const url = new URL(this.staticProxy);
-        const protocol = url.protocol.replace(':', '');
-        const proxyUrlForTest = `${url.hostname}:${url.port}`;
-
-        // 确保代理协议与配置一致
-        if (protocol !== this.proxyProtocol) {
-            console.log(`静态代理协议与配置不符，将使用代理地址中的协议: ${protocol}`);
-            this.proxyProtocol = protocol;
-        }
-
-        const isValid = await this.testProxy(proxyUrlForTest);
-        
-        if (isValid) {
-          const proxyObj = {
-            ip: url.hostname,
-            port: url.port,
-            protocol: this.proxyProtocol,
-            full: `${this.proxyProtocol}://${url.hostname}:${url.port}`,
-            addedAt: new Date().toISOString()
-          };
-          this.availableProxies.push(proxyObj);
-          console.log(`静态代理 ${this.staticProxy} 测试通过并已添加。`);
-        } else {
-          console.error(`静态代理 ${this.staticProxy} 测试失败，不可用。`);
-        }
-      } catch (e) {
-        console.error(`提供的静态代理地址无效: ${this.staticProxy}`, e);
-      }
-      
-      this.isInitialized = true;
-      console.log(`代理池初始化完成，当前可用代理数量: ${this.availableProxies.length}`);
-      // 静态代理模式下，不需要定时检查和补充
-      return;
-    }
-    
     console.log(`初始化代理池，目标数量: ${this.targetCount}`);
     await this.refillProxies();
     
@@ -127,9 +105,6 @@ class ProxyPool {
    * 检查并补充代理
    */
   async checkAndRefill() {
-    // 如果使用静态代理，则不进行检查和补充
-    if (this.staticProxy) return;
-
     if (this.availableProxies.length <= this.minThreshold && !this.isRefilling) {
       console.log(`可用代理数量(${this.availableProxies.length})低于阈值(${this.minThreshold})，开始补充代理`);
       await this.refillProxies();
@@ -141,8 +116,41 @@ class ProxyPool {
    * @returns {Promise<void>}
    */
   async refillProxies() {
-    // 如果使用静态代理，则不进行补充
-    if (this.isRefilling || this.staticProxy) return;
+    if (this.isRefilling) return;
+
+    if (this.staticProxy) {
+      if (this.availableProxies.length > 0) {
+        return;
+      }
+      this.isRefilling = true;
+      console.log(`正在配置静态代理: ${this.staticProxy}`);
+      try {
+        const url = new URL(this.staticProxy);
+        const proxyProtocol = url.protocol.slice(0, -1);
+        const proxyUrlForTest = `${url.hostname}:${url.port}`;
+        
+        const isValid = await this.testProxy(proxyUrlForTest, proxyProtocol);
+
+        if (isValid) {
+          const proxyObj = {
+            ip: url.hostname,
+            port: url.port,
+            protocol: proxyProtocol,
+            full: this.staticProxy,
+            addedAt: new Date().toISOString()
+          };
+          this.availableProxies.push(proxyObj);
+          console.log(`静态代理 ${this.staticProxy} 已成功添加。`);
+        } else {
+          console.error(`静态代理 ${this.staticProxy} 测试失败，不可用。`);
+        }
+      } catch (error) {
+        console.error(`无效的静态代理URL '${this.staticProxy}': ${error.message}`);
+      } finally {
+        this.isRefilling = false;
+      }
+      return;
+    }
     
     this.isRefilling = true;
     console.log(`开始补充代理，当前数量: ${this.availableProxies.length}，目标数量: ${this.targetCount}`);
@@ -378,13 +386,13 @@ class ProxyPool {
    * @param {string} proxyUrl - 代理URL
    * @returns {Promise<boolean>} - 代理是否可用
    */
-  async testProxy(proxyUrl) {
+  async testProxy(proxyUrl, protocol = this.proxyProtocol) {
     try {
       // 创建代理配置
       const proxyConfig = {
         host: proxyUrl.split(':')[0],
         port: parseInt(proxyUrl.split(':')[1]),
-        protocol: this.proxyProtocol
+        protocol: protocol,
       };
       
       // 发送请求到目标网站
@@ -536,7 +544,7 @@ async function example() {
     concurrentRequests: 15,    // 增加并发请求数
     useCache: true,            // 启用缓存
     maxRefillAttempts: 15,     // 减少最大尝试次数
-    retryDelay: 1000,          // 减少重试延迟
+    retryDelay: 1000           // 减少重试延迟
   });
   
   // 初始化代理池

src/ProxyServer.js

@@ -119,10 +119,16 @@ class ProxyServer {
       // 将进程的输出重定向到日志文件
       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-express.js

@@ -145,9 +145,6 @@ app.post('/v1/chat/completions', authenticate, async (req, res) => {
     // 构建Notion请求
     const notionRequestBody = buildNotionRequest(requestData);
     
-    // 获取代理
-    const proxy = proxyPool.getProxy();
-
     // 处理流式响应
     if (requestData.stream) {
       res.setHeader('Content-Type', 'text/event-stream');
@@ -155,7 +152,7 @@ app.post('/v1/chat/completions', authenticate, async (req, res) => {
       res.setHeader('Connection', 'keep-alive');
       
       logger.info(`开始流式响应`);
-      const stream = await streamNotionResponse(notionRequestBody, proxy);
+      const stream = await streamNotionResponse(notionRequestBody);
       stream.pipe(res);
       
       // 处理客户端断开连接
@@ -167,7 +164,7 @@ app.post('/v1/chat/completions', authenticate, async (req, res) => {
       // 创建一个内部流来收集完整响应
       logger.info(`开始非流式响应`);
       const chunks = [];
-      const stream = await streamNotionResponse(notionRequestBody, proxy);
+      const stream = await streamNotionResponse(notionRequestBody);
       
       return new Promise((resolve, reject) => {
         stream.on('data', (chunk) => {
@@ -252,24 +249,21 @@ app.get('/cookies/status', authenticate, (req, res) => {
 // 启动服务器
 const PORT = process.env.PORT || 7860;
 
-(async () => {
-  try {
-    // 初始化代理池
-    await proxyPool.initialize();
-
-    // 初始化Notion客户端
-    await initialize();
-
-    // 启动服务器
-    app.listen(PORT, '0.0.0.0', () => {
-      logger.info(`服务已启动 - 端口: ${PORT}`);
-      logger.info(`访问地址: http://localhost:${PORT}`);
-      logger.success(`系统初始化状态: ${INITIALIZED_SUCCESSFULLY ? '✅' : '❌'}`);
+// 初始化并启动服务器
+initialize().then(() => {
+  app.listen(PORT, () => {
+    logger.info(`服务已启动 - 端口: ${PORT}`);
+    logger.info(`访问地址: http://localhost:${PORT}`);
+    
+    if (INITIALIZED_SUCCESSFULLY) {
+      logger.success(`系统初始化状态: ✅`);
       logger.success(`可用cookie数量: ${cookieManager.getValidCount()}`);
-    });
-
-  } catch (error) {
-    logger.error(`启动失败: ${error.message}`);
-    process.exit(1);
-  }
-})(); 
+    } else {
+      logger.warning(`系统初始化状态: ❌`);
+      logger.warning(`警告: 系统未成功初始化，API调用将无法正常工作`);
+      logger.warning(`请检查NOTION_COOKIE配置是否有效`);
+    }
+  });
+}).catch((error) => {
+  logger.error(`初始化失败: ${error}`);
+}); 

src/lightweight-client.js

@@ -6,12 +6,12 @@ import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 import { PassThrough } from 'stream';
 import chalk from 'chalk';
-import { HttpsProxyAgent } from 'https-proxy-agent';
 import {
   NotionTranscriptConfigValue,
   NotionTranscriptContextValue, NotionTranscriptItem, NotionDebugOverrides,
   NotionRequestBody, ChoiceDelta, Choice, ChatCompletionChunk, NotionTranscriptItemByuser
 } from './models.js';
+import { proxyPool } from './ProxyPool.js';
 import { proxyServer } from './ProxyServer.js';
 import { cookieManager } from './CookieManager.js';
 
@@ -34,7 +34,12 @@ 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';
+let proxy = null;
+
+// 代理配置
+const PROXY_URL = process.env.PROXY_URL || "";
 
 // 标记是否成功初始化
 let INITIALIZED_SUCCESSFULLY = false;
@@ -189,7 +194,7 @@ function buildNotionRequest(requestData) {
 }
 
 // 流式处理Notion响应
-async function streamNotionResponse(notionRequestBody, proxy = null) {
+async function streamNotionResponse(notionRequestBody) {
   // 确保我们有当前的cookie数据
   if (!currentCookieData) {
     currentCookieData = cookieManager.getNext();
@@ -247,8 +252,7 @@ async function streamNotionResponse(notionRequestBody, proxy = null) {
     headers,
     NOTION_API_URL,
     currentCookieData.cookie,
-    timeoutId,
-    proxy
+    timeoutId
   ).catch((error) => {
     logger.error(`流处理出错: ${error}`);
     clearTimeout(timeoutId);  // 清除超时计时器
@@ -275,133 +279,474 @@ async function streamNotionResponse(notionRequestBody, proxy = null) {
   return stream;
 }
 
-/**
- * 实际执行fetch请求的函数
- * @param {PassThrough} chunkQueue - 数据块队列
- * @param {NotionRequestBody} notionRequestBody - Notion请求体
- * @param {object} headers - 请求头
- * @param {string} notionApiUrl - Notion API URL
- * @param {string} notionCookie - Notion Cookie
- * @param {NodeJS.Timeout} timeoutId - 超时ID
- * @param {object|null} proxy - 代理对象 { ip, port, protocol }
- */
-async function fetchNotionResponse(chunkQueue, notionRequestBody, headers, notionApiUrl, notionCookie, timeoutId, proxy = null) {
-  let agent = null;
-  if (proxy && proxy.ip && proxy.port && proxy.protocol) {
-    agent = new HttpsProxyAgent(`${proxy.protocol}://${proxy.ip}:${proxy.port}`);
-    logger.info(`使用代理: ${proxy.protocol}://${proxy.ip}:${proxy.port}`);
-  }
-
+// 使用fetch调用Notion API并处理流式响应
+async function fetchNotionResponse(chunkQueue, notionRequestBody, headers, notionApiUrl, notionCookie, timeoutId) {
+  let responseReceived = false;
+  let dom = null;
+  
   try {
-    const response = await fetch(notionApiUrl, {
+    // 创建JSDOM实例模拟浏览器环境
+    dom = new JSDOM("", {
+      url: "https://www.notion.so",
+      referrer: "https://www.notion.so/chat",
+      contentType: "text/html",
+      includeNodeLocations: true,
+      storageQuota: 10000000,
+      pretendToBeVisual: true,
+      userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36"
+    });
+    
+    // 设置全局对象
+    const { window } = dom;
+    
+    // 使用更安全的方式设置全局对象
+    try {
+      if (!global.window) {
+        global.window = window;
+      }
+      
+      if (!global.document) {
+        global.document = window.document;
+      }
+      
+      // 安全地设置navigator
+      if (!global.navigator) {
+        try {
+          Object.defineProperty(global, 'navigator', {
+            value: window.navigator,
+            writable: true,
+            configurable: true
+          });
+        } catch (navError) {
+          logger.warning(`无法设置navigator: ${navError.message}，继续执行`);
+          // 继续执行，不会中断流程
+        }
+      }
+    } catch (globalError) {
+      logger.warning(`设置全局对象时出错: ${globalError.message}`);
+    }
+    
+    // 设置cookie
+    document.cookie = notionCookie;
+    
+    // 创建fetch选项
+    const fetchOptions = {
       method: 'POST',
       headers: {
         ...headers,
+        'user-agent': window.navigator.userAgent,
         'Cookie': notionCookie
       },
       body: JSON.stringify(notionRequestBody),
-      agent: agent // 应用代理
-    });
-
-    // 请求成功，清除超时
-    clearTimeout(timeoutId);
+    };
+    
+    // 添加代理配置（如果有）
+    if (USE_NATIVE_PROXY_POOL) {
+      proxy = proxyPool.getProxy();
+      if (proxy !== null)
+      {
+        const { HttpsProxyAgent } = await import('https-proxy-agent');
+        fetchOptions.agent = new HttpsProxyAgent(proxy.full);
+        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){
+      response = await fetch('http://127.0.0.1:10655/proxy', {
+        method: 'POST',
+        body: JSON.stringify({
+          method: 'POST',
+          url: notionApiUrl,
+          headers: fetchOptions.headers,
+          body: fetchOptions.body,
+          stream:true
+        }),
+      });
+    }else{
+      response = await fetch(notionApiUrl, fetchOptions);
+    }
 
+    // 检查是否收到401错误（未授权）
+    if (response.status === 401) {
+      logger.error(`收到401未授权错误，cookie可能已失效`);
+      // 标记当前cookie为无效
+      cookieManager.markAsInvalid(currentCookieData.userId);
+      // 尝试获取下一个cookie
+      currentCookieData = cookieManager.getNext();
+      
+      if (!currentCookieData) {
+        throw new Error('所有cookie均已失效，无法继续请求');
+      }
+      
+      // 使用新cookie重新构建请求体
+      const newRequestBody = buildNotionRequest({
+        model: notionRequestBody.transcript[0]?.value?.model || '',
+        messages: [] // 这里应该根据实际情况重构消息
+      });
+      
+      // 使用新cookie重试请求
+      return fetchNotionResponse(
+        chunkQueue,
+        newRequestBody,
+        {
+          ...headers,
+          'x-notion-active-user-header': currentCookieData.userId,
+          'x-notion-space-id': currentCookieData.spaceId
+        },
+        notionApiUrl,
+        currentCookieData.cookie,
+        timeoutId
+      );
+    }
+    
     if (!response.ok) {
-      // 简化错误处理
-      const errorBody = await response.text();
-      throw new Error(`HTTP error! status: ${response.status}, body: ${errorBody}`);
+      throw new Error(`HTTP error! status: ${response.status}`);
     }
-
+    
+    // 处理流式响应
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    
+    // 创建流读取器
     const reader = response.body;
     let buffer = '';
-
+    
+    // 处理数据块
     reader.on('data', (chunk) => {
-      buffer += chunk.toString('utf8');
-      // 处理ndjson
-      let boundary = buffer.indexOf('\n');
-      while (boundary !== -1) {
-        const line = buffer.substring(0, boundary).trim();
-        buffer = buffer.substring(boundary + 1);
-        if (line.startsWith('{"type":"chunk"')) {
+      try {
+        // 标记已收到响应
+        if (!responseReceived) {
+          responseReceived = true;
+          logger.info(`已连接Notion API`);
+          clearTimeout(timeoutId);  // 清除超时计时器
+        }
+        
+        // 解码数据
+        const text = chunk.toString('utf8');
+        buffer += text;
+        
+        // 按行分割并处理完整的JSON对象
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || ''; // 保留最后一行（可能不完整）
+        
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          
           try {
-            const parsed = JSON.parse(line);
-            if (parsed.chunk) {
-              const streamChunk = new ChatCompletionChunk({
+            const jsonData = JSON.parse(line);
+            
+            // 提取内容
+            if (jsonData?.type === "markdown-chat" && typeof jsonData?.value === "string") {
+              const content = jsonData.value;
+              if (!content) continue;
+              
+              // 创建OpenAI格式的块
+              const chunk = new ChatCompletionChunk({
                 choices: [
                   new Choice({
-                    delta: new ChoiceDelta({ content: parsed.chunk })
+                    delta: new ChoiceDelta({ content }),
+                    finish_reason: null
                   })
                 ]
               });
-              chunkQueue.write(`data: ${JSON.stringify(streamChunk)}\n\n`);
+              
+              // 添加到队列
+              const dataStr = `data: ${JSON.stringify(chunk)}\n\n`;
+              chunkQueue.write(dataStr);
+            } else if (jsonData?.recordMap) {
+              // 忽略recordMap响应
+            } else {
+              // 忽略其他类型响应
             }
-          } catch (e) {
-            logger.warning(`解析JSON块失败: ${e.message}`);
+          } catch (jsonError) {
+            logger.error(`解析JSON出错: ${jsonError}`);
           }
         }
-        boundary = buffer.indexOf('\n');
+      } catch (error) {
+        logger.error(`处理数据块出错: ${error}`);
       }
     });
-
+    
+    // 处理流结束
     reader.on('end', () => {
-      if (!chunkQueue.writableEnded) {
-         if (buffer.trim() === '') {
-           logger.warning(`未从Notion收到内容响应,请更换ip重试`);
-         }
+      try {
+        logger.info(`响应完成`);
+        if (cookieManager.getValidCount() > 1){
+          // 尝试切换到下一个cookie
+          currentCookieData = cookieManager.getNext();
+          logger.info(`切换到下一个cookie: ${currentCookieData.userId}`);
+        }
+        
+        // 如果没有收到任何响应，发送一个提示消息
+        if (!responseReceived) {
+          logger.warning(`未从Notion收到内容响应,请更换ip重试`);
+          if (USE_NATIVE_PROXY_POOL) {
+            proxyPool.removeProxy(proxy.ip, proxy.port);
+          }
+          
+          const noContentChunk = new ChatCompletionChunk({
+            choices: [
+              new Choice({
+                delta: new ChoiceDelta({ content: "未从Notion收到内容响应,请更换ip重试。" }),
+                finish_reason: "no_content"
+              })
+            ]
+          });
+          chunkQueue.write(`data: ${JSON.stringify(noContentChunk)}\n\n`);
+        }
+        
+        // 创建结束块
         const endChunk = new ChatCompletionChunk({
-          choices: [new Choice({ finish_reason: 'stop' })]
+          choices: [
+            new Choice({
+              delta: new ChoiceDelta({ content: null }),
+              finish_reason: "stop"
+            })
+          ]
         });
+        
+        // 添加到队列
         chunkQueue.write(`data: ${JSON.stringify(endChunk)}\n\n`);
         chunkQueue.write('data: [DONE]\n\n');
+        
+        // 清除超时计时器（如果尚未清除）
+        if (timeoutId) clearTimeout(timeoutId);
+        
+        // 清理全局对象
+        try {
+          if (global.window) delete global.window;
+          if (global.document) delete global.document;
+          
+          // 安全地删除navigator
+          if (global.navigator) {
+            try {
+              delete global.navigator;
+            } catch (navError) {
+              // 如果无法删除，尝试将其设置为undefined
+              try {
+                Object.defineProperty(global, 'navigator', {
+                  value: undefined,
+                  writable: true,
+                  configurable: true
+                });
+              } catch (defineError) {
+                logger.warning(`无法清理navigator: ${defineError.message}`);
+              }
+            }
+          }
+        } catch (cleanupError) {
+          logger.warning(`清理全局对象时出错: ${cleanupError.message}`);
+        }
+        
+        // 结束流
+        chunkQueue.end();
+      } catch (error) {
+        logger.error(`Error in stream end handler: ${error}`);
+        if (timeoutId) clearTimeout(timeoutId);
+        
+        // 清理全局对象
+        try {
+          if (global.window) delete global.window;
+          if (global.document) delete global.document;
+          
+          // 安全地删除navigator
+          if (global.navigator) {
+            try {
+              delete global.navigator;
+            } catch (navError) {
+              // 如果无法删除，尝试将其设置为undefined
+              try {
+                Object.defineProperty(global, 'navigator', {
+                  value: undefined,
+                  writable: true,
+                  configurable: true
+                });
+              } catch (defineError) {
+                logger.warning(`无法清理navigator: ${defineError.message}`);
+              }
+            }
+          }
+        } catch (cleanupError) {
+          logger.warning(`清理全局对象时出错: ${cleanupError.message}`);
+        }
+        
         chunkQueue.end();
       }
     });
-
-    reader.on('error', (err) => {
-       if (!chunkQueue.writableEnded) {
-         logger.error(`读取响应流时出错: ${err.message}`);
-         chunkQueue.end();
-       }
+    
+    // 处理错误
+    reader.on('error', (error) => {
+      logger.error(`Stream error: ${error}`);
+      if (timeoutId) clearTimeout(timeoutId);
+      
+      // 清理全局对象
+      try {
+        if (global.window) delete global.window;
+        if (global.document) delete global.document;
+        
+        // 安全地删除navigator
+        if (global.navigator) {
+          try {
+            delete global.navigator;
+          } catch (navError) {
+            // 如果无法删除，尝试将其设置为undefined
+            try {
+              Object.defineProperty(global, 'navigator', {
+                value: undefined,
+                writable: true,
+                configurable: true
+              });
+            } catch (defineError) {
+              logger.warning(`无法清理navigator: ${defineError.message}`);
+            }
+          }
+        }
+      } catch (cleanupError) {
+        logger.warning(`清理全局对象时出错: ${cleanupError.message}`);
+      }
+      
+      try {
+        const errorChunk = new ChatCompletionChunk({
+          choices: [
+            new Choice({
+              delta: new ChoiceDelta({ content: `流读取错误: ${error.message}` }),
+              finish_reason: "error"
+            })
+          ]
+        });
+        chunkQueue.write(`data: ${JSON.stringify(errorChunk)}\n\n`);
+        chunkQueue.write('data: [DONE]\n\n');
+      } catch (e) {
+        logger.error(`Error sending error message: ${e}`);
+      } finally {
+        chunkQueue.end();
+      }
     });
-
   } catch (error) {
-    clearTimeout(timeoutId);
-    logger.error(`fetchNotionResponse出错: ${error.message}`);
-    if (!chunkQueue.writableEnded) {
-      chunkQueue.end();
+    logger.error(`Notion API请求失败: ${error}`);
+    // 清理全局对象
+    try {
+      if (global.window) delete global.window;
+      if (global.document) delete global.document;
+      
+      // 安全地删除navigator
+      if (global.navigator) {
+        try {
+          delete global.navigator;
+        } catch (navError) {
+          // 如果无法删除，尝试将其设置为undefined
+          try {
+            Object.defineProperty(global, 'navigator', {
+              value: undefined,
+              writable: true,
+              configurable: true
+            });
+          } catch (defineError) {
+            logger.warning(`无法清理navigator: ${defineError.message}`);
+          }
+        }
+      }
+    } catch (cleanupError) {
+      logger.warning(`清理全局对象时出错: ${cleanupError.message}`);
+    }
+    
+    if (timeoutId) clearTimeout(timeoutId);
+    if (chunkQueue) chunkQueue.end();
+    
+    // 确保在错误情况下也触发流结束
+    try {
+      if (!responseReceived && chunkQueue) {
+        const errorChunk = new ChatCompletionChunk({
+          choices: [
+            new Choice({
+              delta: new ChoiceDelta({ content: `Notion API请求失败: ${error.message}` }),
+              finish_reason: "error"
+            })
+          ]
+        });
+        chunkQueue.write(`data: ${JSON.stringify(errorChunk)}\n\n`);
+        chunkQueue.write('data: [DONE]\n\n');
+      }
+    } catch (e) {
+      logger.error(`发送错误消息时出错: ${e}`);
     }
+    
+    throw error; // 重新抛出错误以便上层捕获
   }
 }
 
 // 应用初始化
 async function initialize() {
-  if (ENABLE_PROXY_SERVER) {
-    logger.info("正在启动内置代理服务器...");
-    try {
-      const started = await proxyServer.start();
-      if (!started) {
-        logger.warning('内置代理服务器启动失败，将尝试不使用代理。');
-      }
-    } catch (error) {
-      logger.error(`启动内置代理服务器失败: ${error.message}`);
+  logger.info(`初始化Notion配置...`);
+  
+  // 启动代理服务器
+  try {
+    await proxyServer.start();
+  } catch (error) {
+    logger.error(`启动代理服务器失败: ${error.message}`);
+  }
+  
+  // 初始化cookie管理器
+  let initResult = false;
+  
+  // 检查是否配置了cookie文件
+  const cookieFilePath = process.env.COOKIE_FILE;
+  if (cookieFilePath) {
+    logger.info(`检测到COOKIE_FILE配置: ${cookieFilePath}`);
+    initResult = await cookieManager.loadFromFile(cookieFilePath);
+    
+    if (!initResult) {
+      logger.error(`从文件加载cookie失败，尝试使用环境变量中的NOTION_COOKIE`);
     }
   }
-
-  logger.info("初始化Notion配置...");
-
-  // 初始化Cookie管理器
-  await cookieManager.initialize();
-  if (cookieManager.getValidCount() > 0) {
-    currentCookieData = cookieManager.getNext();
-    INITIALIZED_SUCCESSFULLY = true;
-    logger.success(`成功初始化cookie管理器，共有 ${cookieManager.getValidCount()} 个有效cookie`);
-    logger.info(`当前使用的cookie对应的用户ID: ${currentCookieData.userId}`);
-    logger.info(`当前使用的cookie对应的空间ID: ${currentCookieData.spaceId}`);
-  } else {
-    logger.error('初始化失败：没有有效的cookie。请检查您的.env或cookies.txt文件。');
+  
+  // 如果文件加载失败或未配置文件，尝试从环境变量加载
+  if (!initResult) {
+    const cookiesString = process.env.NOTION_COOKIE;
+    if (!cookiesString) {
+      logger.error(`错误: 未设置NOTION_COOKIE环境变量或COOKIE_FILE路径，应用无法正常工作`);
+      logger.error(`请在.env文件中设置有效的NOTION_COOKIE值或COOKIE_FILE路径`);
+      INITIALIZED_SUCCESSFULLY = false;
+      return;
+    }
+    
+    logger.info(`正在从环境变量初始化cookie管理器...`);
+    initResult = await cookieManager.initialize(cookiesString);
+    
+    if (!initResult) {
+      logger.error(`初始化cookie管理器失败，应用无法正常工作`);
+      INITIALIZED_SUCCESSFULLY = false;
+      return;
+    }
+  }
+  
+  // 获取第一个可用的cookie数据
+  currentCookieData = cookieManager.getNext();
+  if (!currentCookieData) {
+    logger.error(`没有可用的cookie，应用无法正常工作`);
     INITIALIZED_SUCCESSFULLY = false;
-    return; // 没有cookie，无法继续
+    return;
+  }
+  
+  logger.success(`成功初始化cookie管理器，共有 ${cookieManager.getValidCount()} 个有效cookie`);
+  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;
 }
 
 // 导出函数