Upload 7 files

src/CookieManager.js

@@ -0,0 +1,423 @@
+import { JSDOM } from 'jsdom';
+import fetch from 'node-fetch';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+// 获取当前文件的目录路径
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// 日志配置
+const logger = {
+  info: (message) => console.log(`\x1b[34m[info] ${message}\x1b[0m`),
+  error: (message) => console.error(`\x1b[31m[error] ${message}\x1b[0m`),
+  warning: (message) => console.warn(`\x1b[33m[warn] ${message}\x1b[0m`),
+  success: (message) => console.log(`\x1b[32m[success] ${message}\x1b[0m`),
+};
+
+class CookieManager {
+  constructor() {
+    this.cookieEntries = []; // 存储cookie及其对应的ID
+    this.currentIndex = 0;
+    this.initialized = false;
+    this.maxRetries = 3; // 最大重试次数
+    this.proxyUrl = process.env.PROXY_URL || "";
+  }
+
+  /**
+   * 从文件加载cookie
+   * @param {string} filePath - cookie文件路径
+   * @returns {Promise<boolean>} - 是否加载成功
+   */
+  async loadFromFile(filePath) {
+    try {
+      // 确保文件路径是绝对路径
+      const absolutePath = path.isAbsolute(filePath) 
+        ? filePath 
+        : path.join(dirname(__dirname), filePath);
+      
+      logger.info(`从文件加载cookie: ${absolutePath}`);
+      
+      // 检查文件是否存在
+      if (!fs.existsSync(absolutePath)) {
+        logger.error(`Cookie文件不存在: ${absolutePath}`);
+        return false;
+      }
+      
+      // 读取文件内容
+      const fileContent = fs.readFileSync(absolutePath, 'utf8');
+      
+      // 根据文件扩展名处理不同格式
+      const ext = path.extname(absolutePath).toLowerCase();
+      let cookieArray = [];
+      
+      if (ext === '.json') {
+        // JSON格式
+        try {
+          const jsonData = JSON.parse(fileContent);
+          if (Array.isArray(jsonData)) {
+            cookieArray = jsonData;
+          } else if (jsonData.cookies && Array.isArray(jsonData.cookies)) {
+            cookieArray = jsonData.cookies;
+          } else {
+            logger.error('JSON文件格式错误，应为cookie数组或包含cookies数组的对象');
+            return false;
+          }
+        } catch (error) {
+          logger.error(`解析JSON文件失败: ${error.message}`);
+          return false;
+        }
+      } else {
+        // 文本格式，每行一个cookie
+        cookieArray = fileContent
+          .split('\n')
+          .map(line => line.trim())
+          .filter(line => line && !line.startsWith('#'));
+      }
+      
+      logger.info(`从文件中读取了 ${cookieArray.length} 个cookie`);
+      
+      // 初始化cookie
+      return await this.initialize(cookieArray.join('|'));
+      
+    } catch (error) {
+      logger.error(`从文件加载cookie失败: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * 初始化cookie管理器
+   * @param {string} cookiesString - 以"|"分隔的cookie字符串
+   * @returns {Promise<boolean>} - 是否初始化成功
+   */
+  async initialize(cookiesString) {
+    if (!cookiesString) {
+      logger.error('未提供cookie字符串');
+      return false;
+    }
+
+    // 分割cookie字符串
+    const cookieArray = cookiesString.split('|').map(c => c.trim()).filter(c => c);
+    
+    if (cookieArray.length === 0) {
+      logger.error('没有有效的cookie');
+      return false;
+    }
+
+    logger.info(`发现 ${cookieArray.length} 个cookie，开始获取对应的ID信息...`);
+
+    // 清空现有条目
+    this.cookieEntries = [];
+    
+    // 为每个cookie获取ID
+    for (let i = 0; i < cookieArray.length; i++) {
+      const cookie = cookieArray[i];
+      logger.info(`正在处理第 ${i+1}/${cookieArray.length} 个cookie...`);
+      
+      const result = await this.fetchNotionIds(cookie);
+      if (result.success) {
+        this.cookieEntries.push({
+          cookie,
+          spaceId: result.spaceId,
+          userId: result.userId,
+          valid: true,
+          lastUsed: 0 // 记录上次使用时间戳
+        });
+        logger.success(`第 ${i+1} 个cookie验证成功`);
+      } else {
+        if (result.status === 401) {
+          logger.error(`第 ${i+1} 个cookie无效（401未授权），已跳过`);
+        } else {
+          logger.warning(`第 ${i+1} 个cookie验证失败: ${result.error}，已跳过`);
+        }
+      }
+    }
+
+    // 检查是否有有效的cookie
+    if (this.cookieEntries.length === 0) {
+      logger.error('没有有效的cookie，初始化失败');
+      return false;
+    }
+
+    logger.success(`成功初始化 ${this.cookieEntries.length}/${cookieArray.length} 个cookie`);
+    this.initialized = true;
+    this.currentIndex = 0;
+    return true;
+  }
+
+  /**
+   * 保存cookie到文件
+   * @param {string} filePath - 保存路径
+   * @param {boolean} onlyValid - 是否只保存有效的cookie
+   * @returns {boolean} - 是否保存成功
+   */
+  saveToFile(filePath, onlyValid = true) {
+    try {
+      // 确保文件路径是绝对路径
+      const absolutePath = path.isAbsolute(filePath) 
+        ? filePath 
+        : path.join(dirname(__dirname), filePath);
+      
+      // 获取要保存的cookie
+      const cookiesToSave = onlyValid 
+        ? this.cookieEntries.filter(entry => entry.valid).map(entry => entry.cookie)
+        : this.cookieEntries.map(entry => entry.cookie);
+      
+      // 根据文件扩展名选择保存格式
+      const ext = path.extname(absolutePath).toLowerCase();
+      
+      if (ext === '.json') {
+        // 保存为JSON格式
+        const jsonData = {
+          cookies: cookiesToSave,
+          updatedAt: new Date().toISOString(),
+          count: cookiesToSave.length
+        };
+        fs.writeFileSync(absolutePath, JSON.stringify(jsonData, null, 2), 'utf8');
+      } else {
+        // 保存为文本格式，每行一个cookie
+        const content = cookiesToSave.join('\n');
+        fs.writeFileSync(absolutePath, content, 'utf8');
+      }
+      
+      logger.success(`已将 ${cookiesToSave.length} 个cookie保存到文件: ${absolutePath}`);
+      return true;
+    } catch (error) {
+      logger.error(`保存cookie到文件失败: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * 获取Notion的空间ID和用户ID
+   * @param {string} cookie - Notion cookie
+   * @returns {Promise<Object>} - 包含ID信息的对象
+   */
+  async fetchNotionIds(cookie, retryCount = 0) {
+    if (!cookie) {
+      return { success: false, error: '未提供cookie' };
+    }
+
+    try {
+      // 创建JSDOM实例模拟浏览器环境
+      const dom = new JSDOM("", {
+        url: "https://www.notion.so",
+        referrer: "https://www.notion.so/",
+        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;
+      
+      // 安全地设置全局对象
+      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}，继续执行`);
+        }
+      }
+      
+      // 设置cookie
+      document.cookie = cookie;
+      
+      // 创建fetch选项
+      const fetchOptions = {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'accept': '*/*',
+          'accept-language': 'en-US,en;q=0.9',
+          'notion-audit-log-platform': 'web',
+          'notion-client-version': '23.13.0.3686',
+          'origin': 'https://www.notion.so',
+          'referer': 'https://www.notion.so/',
+          'user-agent': window.navigator.userAgent,
+          'Cookie': cookie
+        },
+        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);
+      
+      // 检查响应状态
+      if (response.status === 401) {
+        return { success: false, status: 401, error: '未授权，cookie无效' };
+      }
+      
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
+      
+      const data = await response.json();
+      
+      // 提取用户ID
+      const userIdKey = Object.keys(data)[0];
+      if (!userIdKey) {
+        throw new Error('无法从响应中提取用户ID');
+      }
+      
+      const userId = userIdKey;
+      
+      // 提取空间ID
+      const userRoot = data[userIdKey]?.user_root?.[userIdKey];
+      const spaceViewPointers = userRoot?.value?.value?.space_view_pointers;
+      
+      if (!spaceViewPointers || !Array.isArray(spaceViewPointers) || spaceViewPointers.length === 0) {
+        throw new Error('在响应中找不到space_view_pointers或spaceId');
+      }
+      
+      const spaceId = spaceViewPointers[0].spaceId;
+      
+      if (!spaceId) {
+        throw new Error('无法从space_view_pointers中提取spaceId');
+      }
+      
+      // 清理全局对象
+      this.cleanupGlobalObjects();
+      
+      return {
+        success: true,
+        userId,
+        spaceId
+      };
+      
+    } catch (error) {
+      // 清理全局对象
+      this.cleanupGlobalObjects();
+      
+      // 重试逻���
+      if (retryCount < this.maxRetries && error.message !== '未授权，cookie无效') {
+        logger.warning(`获取Notion ID失败，正在重试 (${retryCount + 1}/${this.maxRetries}): ${error.message}`);
+        return await this.fetchNotionIds(cookie, retryCount + 1);
+      }
+      
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * 清理全局对象
+   */
+  cleanupGlobalObjects() {
+    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}`);
+    }
+  }
+
+  /**
+   * 获取下一个可用的cookie及其ID
+   * @returns {Object|null} - cookie及其对应的ID，如果没有可用cookie则返回null
+   */
+  getNext() {
+    if (!this.initialized || this.cookieEntries.length === 0) {
+      return null;
+    }
+
+    // 轮询选择下一个cookie
+    const entry = this.cookieEntries[this.currentIndex];
+    
+    // 更新索引，实现轮询
+    this.currentIndex = (this.currentIndex + 1) % this.cookieEntries.length;
+    
+    // 更新最后使用时间
+    entry.lastUsed = Date.now();
+    
+    return {
+      cookie: entry.cookie,
+      spaceId: entry.spaceId,
+      userId: entry.userId
+    };
+  }
+
+  /**
+   * 标记cookie为无效
+   * @param {string} userId - 用户ID
+   */
+  markAsInvalid(userId) {
+    const index = this.cookieEntries.findIndex(entry => entry.userId === userId);
+    if (index !== -1) {
+      this.cookieEntries[index].valid = false;
+      logger.warning(`已将用户ID为 ${userId} 的cookie标记为无效`);
+      
+      // 过滤掉所有无效的cookie
+      this.cookieEntries = this.cookieEntries.filter(entry => entry.valid);
+      
+      // 重置当前索引
+      if (this.cookieEntries.length > 0) {
+        this.currentIndex = 0;
+      }
+    }
+  }
+
+  /**
+   * 获取有效cookie的数量
+   * @returns {number} - 有效cookie的数量
+   */
+  getValidCount() {
+    return this.cookieEntries.filter(entry => entry.valid).length;
+  }
+
+  /**
+   * 获取所有cookie的状态信息
+   * @returns {Array} - cookie状态数组
+   */
+  getStatus() {
+    return this.cookieEntries.map((entry, index) => ({
+      index,
+      userId: entry.userId.substring(0, 8) + '...',
+      spaceId: entry.spaceId.substring(0, 8) + '...',
+      valid: entry.valid,
+      lastUsed: entry.lastUsed ? new Date(entry.lastUsed).toLocaleString() : 'never'
+    }));
+  }
+}
+
+export const cookieManager = new CookieManager(); 

src/ProxyPool.js

@@ -0,0 +1,214 @@
+/**
+ * 简化的代理池类，支持 HTTP 和 SOCKS5 代理
+ */
+class ProxyPool {
+  constructor() {
+    // 从环境变量读取完整的代理URL
+    this.proxyUrl = process.env.HTTP_PROXY || process.env.HTTPS_PROXY || '';
+    this.isInitialized = false;
+    
+    // 解析代理URL
+    this.parseProxyUrl();
+  }
+  
+  /**
+   * 解析代理URL
+   */
+  parseProxyUrl() {
+    if (!this.proxyUrl) {
+      console.log('未设置代理URL环境变量 (HTTP_PROXY)');
+      return;
+    }
+    
+    try {
+      const url = new URL(this.proxyUrl);
+      this.proxyInfo = {
+        protocol: url.protocol.replace(':', ''),
+        host: url.hostname,
+        port: parseInt(url.port),
+        username: url.username,
+        password: url.password,
+        full: this.proxyUrl
+      };
+      
+      console.log(`代理配置解析成功: ${this.proxyInfo.protocol}://${this.proxyInfo.host}:${this.proxyInfo.port}`);
+    } catch (error) {
+      console.error(`代理URL解析失败: ${error.message}`);
+      this.proxyInfo = null;
+    }
+  }
+  
+  /**
+   * 初始化代理池
+   */
+  async initialize() {
+    if (this.isInitialized) return true;
+    
+    if (!this.proxyUrl) {
+      console.log('未配置代理，将使用直连模式');
+      this.isInitialized = true;
+      return true;
+    }
+    
+    if (!this.proxyInfo) {
+      console.error('代理配置无效');
+      return false;
+    }
+    
+    // 测试代理连接
+    const isValid = await this.testProxyConnection();
+    if (isValid) {
+      this.isInitialized = true;
+      console.log('代理池初始化成功');
+      return true;
+    } else {
+      console.error('代理连接测试失败');
+      // 即使测试失败，也标记为已初始化，让实际使用时验证
+      this.isInitialized = true;
+      console.log('跳过测试失败，继续使用配置的代理');
+      return true;
+    }
+  }
+  
+  /**
+   * 测试代理连接
+   */
+  async testProxyConnection() {
+    if (!this.proxyInfo) return false;
+    
+    try {
+      let agent;
+      
+      // 根据协议选择不同的代理 Agent
+      if (this.proxyUrl.startsWith('socks5://')) {
+        const { SocksProxyAgent } = await import('socks-proxy-agent');
+        agent = new SocksProxyAgent(this.proxyUrl);
+        console.log('使用 SOCKS5 代理进行测试...');
+      } else if (this.proxyUrl.startsWith('socks4://')) {
+        const { SocksProxyAgent } = await import('socks-proxy-agent');
+        agent = new SocksProxyAgent(this.proxyUrl);
+        console.log('使用 SOCKS4 代理进行测试...');
+      } else {
+        const HttpProxyAgent = (await import('http-proxy-agent')).default;
+        agent = new HttpProxyAgent(this.proxyUrl);
+        console.log('使用 HTTP 代理进行测试...');
+      }
+      
+      const fetch = (await import('node-fetch')).default;
+      
+      // 尝试多个测试URL
+      const testUrls = [
+        'http://httpbin.org/ip',
+        'https://api.ipify.org?format=json',
+        'http://icanhazip.com'
+      ];
+      
+      for (const testUrl of testUrls) {
+        try {
+          console.log(`测试代理连接到: ${testUrl}`);
+          
+          const response = await fetch(testUrl, {
+            agent,
+            timeout: 15000,
+            headers: {
+              'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+              'Accept': '*/*',
+              'Connection': 'close'
+            }
+          });
+          
+          if (response.ok) {
+            const data = await response.text();
+            let ip = data.trim();
+            
+            // 尝试解析JSON格式的响应
+            try {
+              const jsonData = JSON.parse(data);
+              ip = jsonData.ip || jsonData.origin || ip;
+            } catch (e) {
+              // 如果不是JSON，使用原始文本
+            }
+            
+            console.log(`${this.proxyInfo.protocol.toUpperCase()} 代理连接测试成功！`);
+            console.log(`测试URL: ${testUrl}`);
+            console.log(`出口IP: ${ip}`);
+            return true;
+          } else {
+            console.log(`测试URL ${testUrl} 失败，状态码: ${response.status}`);
+          }
+        } catch (urlError) {
+          console.log(`测试URL ${testUrl} 出错: ${urlError.message}`);
+        }
+      }
+      
+      console.error('所有测试URL都失败了');
+      return false;
+    } catch (error) {
+      console.error(`代理连接测试失败: ${error.message}`);
+      return false;
+    }
+  }
+  
+  /**
+   * 获取代理（每次调用返回相同的代理）
+   */
+  getProxy() {
+    if (!this.proxyInfo) {
+      return null;
+    }
+    
+    return {
+      ip: this.proxyInfo.host,
+      port: this.proxyInfo.port,
+      protocol: this.proxyInfo.protocol,
+      full: this.proxyInfo.full
+    };
+  }
+  
+  /**
+   * 移除代理（记录错误）
+   */
+  removeProxy(ip, port) {
+    console.log(`记录代理问题: ${ip}:${port}`);
+    return true;
+  }
+  
+  /**
+   * 获取代理数量
+   */
+  getValidCount() {
+    return this.proxyInfo ? 1 : 0;
+  }
+  
+  /**
+   * 获取状态信息
+   */
+  getStatus() {
+    if (!this.proxyInfo) {
+      return [];
+    }
+    
+    return [{
+      index: 0,
+      host: this.proxyInfo.host,
+      port: this.proxyInfo.port,
+      protocol: this.proxyInfo.protocol,
+      active: true
+    }];
+  }
+  
+  /**
+   * 停止代理池
+   */
+  stop() {
+    console.log('代理池已停止');
+  }
+}
+
+// 导出
+export default ProxyPool;
+export const proxyPool = new ProxyPool();
+
+
+
+

src/ProxyServer.js

@@ -0,0 +1,113 @@
+import dotenv from 'dotenv';
+import chalk from 'chalk';
+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') });
+
+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.enabled = process.env.ENABLE_PROXY_SERVER === 'true';
+    this.proxyUrl = process.env.HTTP_PROXY || process.env.HTTPS_PROXY || '';
+    this.isConnected = false;
+  }
+
+  /**
+   * 启动代理服务器
+   */
+  async start() {
+    if (!this.enabled) {
+      logger.info('代理服务器未启用，跳过启动');
+      return false;
+    }
+
+    if (!this.proxyUrl) {
+      logger.warning('未设置代理URL (HTTP_PROXY)，跳过代理验证');
+      return false;
+    }
+
+    logger.info('正在验证代理连接...');
+    
+    try {
+      const isValid = await this.validateProxyConnection();
+      
+      if (isValid) {
+        this.isConnected = true;
+        logger.success('代理服务连接成功');
+        return true;
+      } else {
+        logger.error('代理服务连接失败');
+        return false;
+      }
+    } catch (error) {
+      logger.error(`连接代理服务时出错: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * 验证代理连接
+   */
+  async validateProxyConnection() {
+    try {
+      // 修复导入方式
+      const HttpProxyAgent = (await import('http-proxy-agent')).default;
+      const fetch = (await import('node-fetch')).default;
+      
+      const agent = new HttpProxyAgent(this.proxyUrl);
+      
+      const response = await fetch('https://httpbin.org/ip', {
+        agent,
+        timeout: 10000
+      });
+      
+      if (response.ok) {
+        const data = await response.json();
+        logger.info(`代理连接测试成功，出口IP: ${data.origin}`);
+        return true;
+      } else {
+        logger.error(`代理连接测试失败，状态码: ${response.status}`);
+        return false;
+      }
+    } catch (error) {
+      logger.error(`代理连接验证失败: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * 停止代理服务器
+   */
+  stop() {
+    this.isConnected = false;
+    logger.success('代理服务已断开');
+  }
+
+  /**
+   * 获取代理状态
+   */
+  getStatus() {
+    return {
+      enabled: this.enabled,
+      connected: this.isConnected,
+      proxyConfigured: !!this.proxyUrl
+    };
+  }
+}
+
+const proxyServer = new ProxyServer();
+
+export { proxyServer };

src/cookie-cli.js

@@ -0,0 +1,301 @@
+#!/usr/bin/env node
+
+import { cookieManager } from './CookieManager.js';
+import dotenv from 'dotenv';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import fs from 'fs';
+import readline from 'readline';
+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(`[信息] ${message}`)),
+  error: (message) => console.error(chalk.red(`[错误] ${message}`)),
+  warning: (message) => console.warn(chalk.yellow(`[警告] ${message}`)),
+  success: (message) => console.log(chalk.green(`[成功] ${message}`)),
+};
+
+// 创建readline接口
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout
+});
+
+// 默认cookie文件路径
+const DEFAULT_COOKIE_FILE = 'cookies.txt';
+
+let isSaveCookie = false;
+let isAddCookie = false;
+
+// 显示帮助信息
+function showHelp() {
+  console.log(chalk.cyan('Notion Cookie 管理工具'));
+  console.log(chalk.cyan('===================='));
+  console.log('');
+  console.log('可用命令:');
+  console.log('  help      - 显示此帮助信息');
+  console.log('  list      - 列出所有cookie');
+  console.log('  add       - 添加新的cookie');
+  console.log('  validate  - 验证所有cookie');
+  console.log('  remove    - 删除指定cookie');
+  console.log('  save      - 保存cookie到文件');
+  console.log('  load      - 从文件加载cookie');
+  console.log('  exit      - 退出程序');
+  console.log('');
+}
+
+// 列出所有cookie
+async function listCookies() {
+  if (!cookieManager.initialized || cookieManager.getValidCount() === 0) {
+    logger.warning('没有可用的cookie，请先加载或添加cookie');
+    return;
+  }
+
+  const status = cookieManager.getStatus();
+  console.log(chalk.cyan('\nCookie 列表:'));
+  console.log(chalk.cyan('==========='));
+  
+  status.forEach((entry, idx) => {
+    const validMark = entry.valid ? chalk.green('✓') : chalk.red('✗');
+    console.log(`${idx + 1}. ${validMark} 用户ID: ${entry.userId}, 空间ID: ${entry.spaceId}, 上次使用: ${entry.lastUsed}`);
+  });
+  
+  console.log(`\n共有 ${status.length} 个cookie，${cookieManager.getValidCount()} 个有效\n`);
+}
+
+// 添加新cookie
+async function addCookie() {
+  return new Promise((resolve) => {
+    rl.question(chalk.yellow('请输入Notion cookie: '), async (cookie) => {
+      if (!cookie || cookie.trim() === '') {
+        logger.error('Cookie不能为空');
+        resolve();
+        return;
+      }
+      
+      logger.info('正在验证cookie...');
+      const result = await cookieManager.fetchNotionIds(cookie.trim());
+      
+      if (result.success) {
+        // 如果cookie管理器尚未初始化，先初始化
+        if (!cookieManager.initialized) {
+          await cookieManager.initialize(cookie.trim());
+        } else {
+          // 已初始化，直接添加到现有条目
+          cookieManager.cookieEntries.push({
+            cookie: cookie.trim(),
+            spaceId: result.spaceId,
+            userId: result.userId,
+            valid: true,
+            lastUsed: 0
+          });
+        }
+        isAddCookie = true;
+        logger.success(`Cookie添加成功! 用户ID: ${result.userId}, 空间ID: ${result.spaceId}`);
+
+      } else {
+        logger.error(`Cookie验证失败: ${result.error}`);
+      }
+      
+      resolve();
+    });
+  });
+}
+
+// 验证所有cookie
+async function validateCookies() {
+  if (!cookieManager.initialized || cookieManager.cookieEntries.length === 0) {
+    logger.warning('没有可用的cookie，请先加载或添加cookie');
+    return;
+  }
+  
+  logger.info('开始验证所有cookie...');
+  
+  const originalEntries = [...cookieManager.cookieEntries];
+  cookieManager.cookieEntries = [];
+  
+  for (let i = 0; i < originalEntries.length; i++) {
+    const entry = originalEntries[i];
+    logger.info(`正在验证第 ${i+1}/${originalEntries.length} 个cookie...`);
+    
+    const result = await cookieManager.fetchNotionIds(entry.cookie);
+    if (result.success) {
+      cookieManager.cookieEntries.push({
+        cookie: entry.cookie,
+        spaceId: result.spaceId,
+        userId: result.userId,
+        valid: true,
+        lastUsed: entry.lastUsed || 0
+      });
+      logger.success(`第 ${i+1} 个cookie验证成功`);
+    } else {
+      logger.error(`第 ${i+1} 个cookie验证失败: ${result.error}`);
+    }
+  }
+  
+  logger.info(`验证完成，共 ${originalEntries.length} 个cookie，${cookieManager.cookieEntries.length} 个有效`);
+}
+
+// 删除指定cookie
+async function removeCookie() {
+  if (!cookieManager.initialized || cookieManager.cookieEntries.length === 0) {
+    logger.warning('没有可用的cookie，请先加载或添加cookie');
+    return;
+  }
+  
+  // 先列出所有cookie
+  await listCookies();
+  
+  return new Promise((resolve) => {
+    rl.question(chalk.yellow('请输入要删除的cookie编号: '), (input) => {
+      const index = parseInt(input) - 1;
+      
+      if (isNaN(index) || index < 0 || index >= cookieManager.cookieEntries.length) {
+        logger.error('无效的编号');
+        resolve();
+        return;
+      }
+      
+      const removed = cookieManager.cookieEntries.splice(index, 1)[0];
+      logger.success(`已删除编号 ${index + 1} 的cookie (用户ID: ${removed.userId.substring(0, 8)}...)`);
+      
+      // 重置当前索引
+      if (cookieManager.cookieEntries.length > 0) {
+        cookieManager.currentIndex = 0;
+      }
+      
+      resolve();
+    });
+  });
+}
+
+// 保存cookie到文件
+async function saveCookies() {
+  if (!cookieManager.initialized || cookieManager.cookieEntries.length === 0) {
+    logger.warning('没有可用的cookie，请先加载或添加cookie');
+    return;
+  }
+  
+  return new Promise((resolve) => {
+    rl.question(chalk.yellow(`请输入保存文件路径 (默认: ${DEFAULT_COOKIE_FILE}): `), (filePath) => {
+      const path = filePath.trim() || DEFAULT_COOKIE_FILE;
+      
+      rl.question(chalk.yellow('是否只保存有效的cookie? (y/n, 默认: y): '), (onlyValidInput) => {
+        const onlyValid = onlyValidInput.toLowerCase() !== 'n';
+        
+        const success = cookieManager.saveToFile(path, onlyValid);
+        if (success) {
+          logger.success(`Cookie已保存到文件: ${path}`);
+          isSaveCookie = true;
+        }
+        
+        resolve();
+      });
+    });
+  });
+}
+
+// 从文件加载cookie
+async function loadCookies() {
+  return new Promise((resolve) => {
+    rl.question(chalk.yellow(`请输入cookie文件路径 (默认: ${DEFAULT_COOKIE_FILE}): `), async (filePath) => {
+      const path = filePath.trim() || DEFAULT_COOKIE_FILE;
+      
+      logger.info(`正在从文件加载cookie: ${path}`);
+      const success = await cookieManager.loadFromFile(path);
+      
+      if (success) {
+        logger.success(`成功从文件加载cookie，共 ${cookieManager.getValidCount()} 个有效cookie`);
+      } else {
+        logger.error(`从文件加载cookie失败`);
+      }
+      
+      resolve();
+    });
+  });
+}
+
+// 主函数
+async function main() {
+  // 显示欢迎信息
+  console.log(chalk.cyan('\nNotion Cookie 管理工具'));
+  console.log(chalk.cyan('====================\n'));
+  
+  // 检查是否有环境变量中的cookie
+  const envCookie = process.env.NOTION_COOKIE;
+  if (envCookie) {
+    logger.info('检测到环境变量中的NOTION_COOKIE，正在初始化...');
+    await cookieManager.initialize(envCookie);
+  }
+  
+  // 检查是否有环境变量中的cookie文件
+  const envCookieFile = process.env.COOKIE_FILE;
+  if (envCookieFile && !cookieManager.initialized) {
+    logger.info(`检测到环境变量中的COOKIE_FILE: ${envCookieFile}，正在加载...`);
+    await cookieManager.loadFromFile(envCookieFile);
+  }
+  
+  // 如果没有cookie，检查默认文件
+  if (!cookieManager.initialized && fs.existsSync(DEFAULT_COOKIE_FILE)) {
+    logger.info(`检测到默认cookie文件: ${DEFAULT_COOKIE_FILE}，正在加载...`);
+    await cookieManager.loadFromFile(DEFAULT_COOKIE_FILE);
+  }
+  
+  showHelp();
+  
+  // 命令循环
+  while (true) {
+    const command = await new Promise((resolve) => {
+      rl.question(chalk.green('> '), (cmd) => {
+        resolve(cmd.trim().toLowerCase());
+      });
+    });
+    
+    switch (command) {
+      case 'help':
+        showHelp();
+        break;
+      case 'list':
+        await listCookies();
+        break;
+      case 'add':
+        await addCookie();
+        break;
+      case 'validate':
+        await validateCookies();
+        break;
+      case 'remove':
+        await removeCookie();
+        break;
+      case 'save':
+        await saveCookies();
+        break;
+      case 'load':
+        await loadCookies();
+        break;
+      case 'exit':
+      case 'quit':
+      case 'q':
+        logger.info('感谢使用，再见!');
+        rl.close();
+        process.exit(0);
+      default:
+        logger.error(`未知命令: ${command}`);
+        logger.info('输入 "help" 查看可用命令');
+    }
+  }
+}
+
+// 启动程序
+main().catch((error) => {
+  logger.error(`程序出错: ${error.message}`);
+  process.exit(1);
+}); 

src/lightweight-client-express.js

@@ -0,0 +1,269 @@
+import express from 'express';
+import dotenv from 'dotenv';
+import { randomUUID } from 'crypto';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import chalk from 'chalk';
+import {
+  ChatMessage, ChatCompletionRequest, Choice, ChoiceDelta, ChatCompletionChunk
+} from './models.js';
+import {
+  initialize,
+  streamNotionResponse,
+  buildNotionRequest,
+  INITIALIZED_SUCCESSFULLY
+} from './lightweight-client.js';
+import { proxyPool } from './ProxyPool.js';
+import { cookieManager } from './CookieManager.js';
+
+// 获取当前文件的目录路径
+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(`[info] ${message}`)),
+  error: (message) => console.error(chalk.red(`[error] ${message}`)),
+  warning: (message) => console.warn(chalk.yellow(`[warn] ${message}`)),
+  success: (message) => console.log(chalk.green(`[success] ${message}`)),
+  request: (method, path, status, time) => {
+    const statusColor = status >= 500 ? chalk.red : 
+                        status >= 400 ? chalk.yellow : 
+                        status >= 300 ? chalk.cyan : 
+                        status >= 200 ? chalk.green : chalk.white;
+    console.log(`${chalk.magenta(`[${method}]`)} - ${path} ${statusColor(status)} ${chalk.gray(`${time}ms`)}`);
+  }
+};
+
+// 认证配置
+const EXPECTED_TOKEN = process.env.PROXY_AUTH_TOKEN || "default_token";
+
+// 创建Express应用
+const app = express();
+app.use(express.json({ limit: '50mb' }));
+app.use(express.urlencoded({ extended: true, limit: '50mb' }));
+
+// 请求日志中间件
+app.use((req, res, next) => {
+  const start = Date.now();
+  
+  // 保存原始的 end 方法
+  const originalEnd = res.end;
+  
+  // 重写 end 方法以记录请求完成时间
+  res.end = function(...args) {
+    const duration = Date.now() - start;
+    logger.request(req.method, req.path, res.statusCode, duration);
+    return originalEnd.apply(this, args);
+  };
+  
+  next();
+});
+
+// 认证中间件
+function authenticate(req, res, next) {
+  const authHeader = req.headers.authorization;
+  
+  if (!authHeader || !authHeader.startsWith('Bearer ')) {
+    return res.status(401).json({
+      error: {
+        message: "Authentication required. Please provide a valid Bearer token.",
+        type: "authentication_error"
+      }
+    });
+  }
+  
+  const token = authHeader.split(' ')[1];
+  
+  if (token !== EXPECTED_TOKEN) {
+    return res.status(401).json({
+      error: {
+        message: "Invalid authentication credentials",
+        type: "authentication_error"
+      }
+    });
+  }
+  
+  next();
+}
+
+// API路由
+
+// 获取模型列表
+app.get('/v1/models', authenticate, (req, res) => {
+  // 返回可用模型列表
+  const modelList = {
+    data: [
+      { id: "openai-gpt-4.1" },
+      { id: "anthropic-opus-4" },
+      { id: "anthropic-sonnet-4" },
+      { id: "anthropic-sonnet-3.x-stable" }
+    ]
+  };
+  
+  res.json(modelList);
+});
+
+// 聊天完成端点
+app.post('/v1/chat/completions', authenticate, async (req, res) => {
+  try {
+    // 检查是否成功初始化
+    if (!INITIALIZED_SUCCESSFULLY) {
+      return res.status(500).json({
+        error: {
+          message: "系统未成功初始化。请检查您的NOTION_COOKIE是否有效。",
+          type: "server_error"
+        }
+      });
+    }
+    
+    // 检查是否有可用的cookie
+    if (cookieManager.getValidCount() === 0) {
+      return res.status(500).json({
+        error: {
+          message: "没有可用的有效cookie。请检查您的NOTION_COOKIE配置。",
+          type: "server_error"
+        }
+      });
+    }
+    
+    // 验证请求数据
+    const requestData = req.body;
+    
+    if (!requestData.messages || !Array.isArray(requestData.messages) || requestData.messages.length === 0) {
+      return res.status(400).json({
+        error: {
+          message: "Invalid request: 'messages' field must be a non-empty array.",
+          type: "invalid_request_error"
+        }
+      });
+    }
+    
+    // 构建Notion请求
+    const notionRequestBody = buildNotionRequest(requestData);
+    
+    // 处理流式响应
+    if (requestData.stream) {
+      res.setHeader('Content-Type', 'text/event-stream');
+      res.setHeader('Cache-Control', 'no-cache');
+      res.setHeader('Connection', 'keep-alive');
+      
+      logger.info(`开始流式响应`);
+      const stream = await streamNotionResponse(notionRequestBody);
+      stream.pipe(res);
+      
+      // 处理客户端断开连接
+      req.on('close', () => {
+        stream.end();
+      });
+    } else {
+      // 非流式响应
+      // 创建一个内部流来收集完整响应
+      logger.info(`开始非流式响应`);
+      const chunks = [];
+      const stream = await streamNotionResponse(notionRequestBody);
+      
+      return new Promise((resolve, reject) => {
+        stream.on('data', (chunk) => {
+          const chunkStr = chunk.toString();
+          if (chunkStr.startsWith('data: ') && !chunkStr.includes('[DONE]')) {
+            try {
+              const dataJson = chunkStr.substring(6).trim();
+              if (dataJson) {
+                const chunkData = JSON.parse(dataJson);
+                if (chunkData.choices && chunkData.choices[0].delta && chunkData.choices[0].delta.content) {
+                  chunks.push(chunkData.choices[0].delta.content);
+                }
+              }
+            } catch (error) {
+              logger.error(`解析非流式响应块时出错: ${error}`);
+            }
+          }
+        });
+        
+        stream.on('end', () => {
+          const fullResponse = {
+            id: `chatcmpl-${randomUUID()}`,
+            object: "chat.completion",
+            created: Math.floor(Date.now() / 1000),
+            model: requestData.model,
+            choices: [
+              {
+                index: 0,
+                message: {
+                  role: "assistant",
+                  content: chunks.join('')
+                },
+                finish_reason: "stop"
+              }
+            ],
+            usage: {
+              prompt_tokens: null,
+              completion_tokens: null,
+              total_tokens: null
+            }
+          };
+          
+          res.json(fullResponse);
+          resolve();
+        });
+        
+        stream.on('error', (error) => {
+          logger.error(`非流式响应出错: ${error}`);
+          reject(error);
+        });
+      });
+    }
+  } catch (error) {
+    logger.error(`聊天完成端点错误: ${error}`);
+    res.status(500).json({
+      error: {
+        message: `Internal server error: ${error.message}`,
+        type: "server_error"
+      }
+    });
+  }
+});
+
+// 健康检查端点
+app.get('/health', (req, res) => {
+  res.json({
+    status: 'ok',
+    timestamp: new Date().toISOString(),
+    initialized: INITIALIZED_SUCCESSFULLY,
+    valid_cookies: cookieManager.getValidCount()
+  });
+});
+
+// Cookie状态查询端点
+app.get('/cookies/status', authenticate, (req, res) => {
+  res.json({
+    total_cookies: cookieManager.getValidCount(),
+    cookies: cookieManager.getStatus()
+  });
+});
+
+// 启动服务器
+const PORT = process.env.PORT || 7860;
+
+// 初始化并启动服务器
+initialize().then(() => {
+  app.listen(PORT, () => {
+    logger.info(`服务已启动 - 端口: ${PORT}`);
+    logger.info(`访问地址: http://localhost:${PORT}`);
+    
+    if (INITIALIZED_SUCCESSFULLY) {
+      logger.success(`系统初始化状态: ✅`);
+      logger.success(`可用cookie数量: ${cookieManager.getValidCount()}`);
+    } else {
+      logger.warning(`系统初始化状态: ❌`);
+      logger.warning(`警告: 系统未成功初始化，API调用将无法正常工作`);
+      logger.warning(`请检查NOTION_COOKIE配置是否有效`);
+    }
+  });
+}).catch((error) => {
+  logger.error(`初始化失败: ${error}`);
+}); 

src/lightweight-client.js

@@ -0,0 +1,843 @@
+import fetch from 'node-fetch';
+import { JSDOM } from 'jsdom';
+import dotenv from 'dotenv';
+import { randomUUID } from 'crypto';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { PassThrough } from 'stream';
+import chalk from 'chalk';
+import fs from 'fs';
+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';
+
+// 获取当前文件的目录路径
+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(`[info] ${message}`)),
+  error: (message) => console.error(chalk.red(`[error] ${message}`)),
+  warning: (message) => console.warn(chalk.yellow(`[warn] ${message}`)),
+  success: (message) => console.log(chalk.green(`[success] ${message}`)),
+};
+
+// 配置
+const NOTION_API_URL = "https://www.notion.so/api/v3/runInferenceTranscript";
+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;
+
+// 安全的流写入函数
+function safeWriteToStream(stream, data) {
+  if (stream && !stream.destroyed && !stream.writableEnded && stream.writable) {
+    try {
+      return stream.write(data);
+    } catch (error) {
+      logger.error(`写入流时出错: ${error.message}`);
+      return false;
+    }
+  }
+  return false;
+}
+
+// 安全的流结束函数
+function safeEndStream(stream) {
+  if (stream && !stream.destroyed && !stream.writableEnded) {
+    try {
+      stream.end();
+    } catch (error) {
+      logger.error(`结束流时出错: ${error.message}`);
+    }
+  }
+}
+
+// 注册进程退出事件，确保代理服务器在程序退出时关闭
+process.on('exit', () => {
+  try {
+    if (proxyServer) {
+      proxyServer.stop();
+    }
+  } catch (error) {
+    logger.error(`程序退出时关闭代理服务器出错: ${error.message}`);
+  }
+});
+
+// 捕获意外退出信号
+['SIGINT', 'SIGTERM', 'SIGQUIT'].forEach(signal => {
+  process.on(signal, () => {
+    logger.info(`收到${signal}信号，正在关闭代理服务器...`);
+    try {
+      if (proxyServer) {
+        proxyServer.stop();
+      }
+    } catch (error) {
+      logger.error(`关闭代理服务器出错: ${error.message}`);
+    }
+    process.exit(0);
+  });
+});
+
+// 构建Notion请求
+function buildNotionRequest(requestData) {
+  // 确保我们有当前的cookie数据
+  if (!currentCookieData) {
+    currentCookieData = cookieManager.getNext();
+    if (!currentCookieData) {
+      throw new Error('没有可用的cookie');
+    }
+  }
+
+  // 当前时间
+  const now = new Date();
+  // 格式化为ISO字符串，确保包含毫秒和时区
+  const isoString = now.toISOString();
+  
+  // 生成随机名称，类似于Python版本
+  const randomWords = ["Project", "Workspace", "Team", "Studio", "Lab", "Hub", "Zone", "Space"];
+  const userName = `User${Math.floor(Math.random() * 900) + 100}`; // 生成100-999之间的随机数
+  const spaceName = `${randomWords[Math.floor(Math.random() * randomWords.length)]} ${Math.floor(Math.random() * 99) + 1}`;
+  
+  // 创建transcript数组
+  const transcript = [];
+  
+  // 添加配置项
+  if(requestData.model === 'anthropic-sonnet-3.x-stable'){
+    transcript.push(new NotionTranscriptItem({
+      type: "config",
+      value: new NotionTranscriptConfigValue({
+      })
+    }));
+  }else{
+      transcript.push(new NotionTranscriptItem({
+    type: "config",
+    value: new NotionTranscriptConfigValue({
+      model: requestData.model
+    })
+  }));
+  }
+
+  
+  // 添加上下文项
+  transcript.push(new NotionTranscriptItem({
+    type: "context",
+    value: new NotionTranscriptContextValue({
+      userId: currentCookieData.userId,
+      spaceId: currentCookieData.spaceId,
+      surface: "home_module",
+      timezone: "America/Los_Angeles",
+      userName: userName,
+      spaceName: spaceName,
+      spaceViewId: randomUUID(),
+      currentDatetime: isoString
+    })
+  }));
+  
+  // 添加agent-integration项
+  transcript.push(new NotionTranscriptItem({
+    type: "agent-integration"
+  }));
+  
+  // 添加消息
+  for (const message of requestData.messages) {
+    // 处理消息内容，确保格式一致
+    let content = message.content;
+    
+    // 处理内容为数组的情况
+    if (Array.isArray(content)) {
+      let textContent = "";
+      for (const part of content) {
+        if (part && typeof part === 'object' && part.type === 'text') {
+          if (typeof part.text === 'string') {
+            textContent += part.text;
+          }
+        }
+      }
+      content = textContent || ""; // 使用提取的文本或空字符串
+    } else if (typeof content !== 'string') {
+      content = ""; // 如果不是字符串或数组，则默认为空字符串
+    }
+    
+    if (message.role === "system") {
+      // 系统消息作为用户消息添加
+      transcript.push(new NotionTranscriptItemByuser({
+        type: "user",
+        value: [[content]],
+        userId: currentCookieData.userId,
+        createdAt: message.createdAt || isoString
+      }));
+    } else if (message.role === "user") {
+      // 用户消息
+      transcript.push(new NotionTranscriptItemByuser({
+        type: "user",
+        value: [[content]],
+        userId: currentCookieData.userId,
+        createdAt: message.createdAt || isoString
+      }));
+    } else if (message.role === "assistant") {
+      // 助手消息
+      transcript.push(new NotionTranscriptItem({
+        type: "markdown-chat",
+        value: content,
+        traceId: message.traceId || randomUUID(),
+        createdAt: message.createdAt || isoString
+      }));
+    }
+  }
+  
+  // 创建请求体
+  const requestBody = new NotionRequestBody({
+    spaceId: currentCookieData.spaceId,
+    transcript: transcript,
+    createThread: true,
+    traceId: randomUUID(),
+    debugOverrides: new NotionDebugOverrides({
+      cachedInferences: {},
+      annotationInferences: {},
+      emitInferences: false
+    }),
+    generateTitle: false,
+    saveAllThreadOperations: false
+  });
+
+  // 添加调试日志（仅在开发环境）
+  if (process.env.NODE_ENV !== 'production') {
+    logger.info(`构建的请求体transcript长度: ${transcript.length}`);
+  }
+  
+  return requestBody;
+}
+
+// 流式处理Notion响应
+async function streamNotionResponse(notionRequestBody) {
+  // 确保我们有当前的cookie数据
+  if (!currentCookieData) {
+    currentCookieData = cookieManager.getNext();
+    if (!currentCookieData) {
+      throw new Error('没有可用的cookie');
+    }
+  }
+
+  // 创建流
+  const stream = new PassThrough();
+  
+  // 添加初始数据，确保连接建立
+  safeWriteToStream(stream, ':\n\n');  // 发送一个空注释行，保持连接活跃
+  
+  // 设置HTTP头模板
+  const headers = {
+    'Content-Type': 'application/json',
+    'accept': 'application/x-ndjson',
+    'accept-language': 'en-US,en;q=0.9',
+    'notion-audit-log-platform': 'web',
+    'notion-client-version': '23.13.0.3686',
+    'origin': 'https://www.notion.so',
+    'referer': 'https://www.notion.so/chat',
+    'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36',
+    'x-notion-active-user-header': currentCookieData.userId,
+    'x-notion-space-id': currentCookieData.spaceId
+  };
+  
+  // 设置超时处理，确保流不会无限等待
+  const timeoutId = setTimeout(() => {
+    logger.warning(`请求超时，30秒内未收到响应`);
+    try {
+      // 发送结束消息
+      const endChunk = new ChatCompletionChunk({
+        choices: [
+          new Choice({
+            delta: new ChoiceDelta({ content: "请求超时，未收到Notion响应。" }),
+            finish_reason: "timeout"
+          })
+        ]
+      });
+      safeWriteToStream(stream, `data: ${JSON.stringify(endChunk)}\n\n`);
+      safeWriteToStream(stream, 'data: [DONE]\n\n');
+      safeEndStream(stream);
+    } catch (error) {
+      logger.error(`发送超时消息时出错: ${error}`);
+      safeEndStream(stream);
+    }
+  }, 30000); // 30秒超时
+  
+  // 启动fetch处理
+  fetchNotionResponseWithRetry(
+    stream,
+    notionRequestBody,
+    headers,
+    NOTION_API_URL,
+    currentCookieData.cookie,
+    timeoutId
+  ).catch((error) => {
+    logger.error(`流处理出错: ${error}`);
+    clearTimeout(timeoutId);  // 清除超时计时器
+    
+    try {
+      // 发送错误消息
+      const errorChunk = new ChatCompletionChunk({
+        choices: [
+          new Choice({
+            delta: new ChoiceDelta({ content: `处理请求时出错: ${error.message}` }),
+            finish_reason: "error"
+          })
+        ]
+      });
+      safeWriteToStream(stream, `data: ${JSON.stringify(errorChunk)}\n\n`);
+      safeWriteToStream(stream, 'data: [DONE]\n\n');
+    } catch (e) {
+      logger.error(`发送错误消息时出错: ${e}`);
+    } finally {
+      safeEndStream(stream);
+    }
+  });
+  
+  return stream;
+}
+
+// 带重试的fetch函数
+async function fetchNotionResponseWithRetry(chunkQueue, notionRequestBody, headers, notionApiUrl, notionCookie, timeoutId, retryCount = 0) {
+  const maxRetries = 2;
+  
+  try {
+    return await fetchNotionResponse(chunkQueue, notionRequestBody, headers, notionApiUrl, notionCookie, timeoutId, retryCount);
+  } catch (error) {
+    if (retryCount < maxRetries && (error.message.includes('400') || error.message.includes('timeout') || error.message.includes('EPROTO') || error.message.includes('SSL'))) {
+      logger.warning(`请求失败，正在重试 (${retryCount + 1}/${maxRetries}): ${error.message}`);
+      await new Promise(resolve => setTimeout(resolve, 1000 * (retryCount + 1))); // 递增等待时间
+      return fetchNotionResponseWithRetry(chunkQueue, notionRequestBody, headers, notionApiUrl, notionCookie, timeoutId, retryCount + 1);
+    }
+    throw error;
+  }
+}
+
+// 使用fetch调用Notion API并处理流式响应
+async function fetchNotionResponse(chunkQueue, notionRequestBody, headers, notionApiUrl, notionCookie, timeoutId, retryCount = 0) {
+  let responseReceived = false;
+  let dom = null;
+  
+  try {
+    // 创建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),
+    };
+    
+    // 支持多种代理协议的配置处理
+    if (USE_NATIVE_PROXY_POOL) {
+      proxy = proxyPool.getProxy();
+      if (proxy !== null) {
+        try {
+          let agent;
+          
+          // 根据代理协议选择合适的 Agent
+          if (proxy.full.startsWith('socks5://')) {
+            const { SocksProxyAgent } = await import('socks-proxy-agent');
+            agent = new SocksProxyAgent(proxy.full);
+            logger.info(`使用 SOCKS5 代理: ${proxy.ip}:${proxy.port}`);
+          } else if (proxy.full.startsWith('socks4://')) {
+            const { SocksProxyAgent } = await import('socks-proxy-agent');
+            agent = new SocksProxyAgent(proxy.full);
+            logger.info(`使用 SOCKS4 代理: ${proxy.ip}:${proxy.port}`);
+          } else {
+            const HttpProxyAgent = (await import('http-proxy-agent')).default;
+            agent = new HttpProxyAgent(proxy.full);
+            logger.info(`使用 HTTP 代理: ${proxy.ip}:${proxy.port}`);
+          }
+          
+          fetchOptions.agent = agent;
+        } catch (proxyError) {
+          logger.error(`代理配置失败: ${proxyError.message}`);
+          logger.warning(`跳过代理，使用直连`);
+          delete fetchOptions.agent;
+          
+          // 标记这个代理为无效
+          if (proxy && proxy.ip && proxy.port) {
+            proxyPool.removeProxy(proxy.ip, proxy.port);
+          }
+        }
+      } else {
+        logger.warning(`没有可用代理，使用直连`);
+      }
+    } else if (PROXY_URL) {
+      // 如果有环境变量配置的代理
+      try {
+        let agent;
+        
+        if (PROXY_URL.startsWith('socks5://')) {
+          const { SocksProxyAgent } = await import('socks-proxy-agent');
+          agent = new SocksProxyAgent(PROXY_URL);
+          logger.info(`使用环境变量 SOCKS5 代理: ${PROXY_URL}`);
+        } else if (PROXY_URL.startsWith('socks4://')) {
+          const { SocksProxyAgent } = await import('socks-proxy-agent');
+          agent = new SocksProxyAgent(PROXY_URL);
+          logger.info(`使用环境变量 SOCKS4 代理: ${PROXY_URL}`);
+        } else {
+          const HttpProxyAgent = (await import('http-proxy-agent')).default;
+          agent = new HttpProxyAgent(PROXY_URL);
+          logger.info(`使用环境变量 HTTP 代理: ${PROXY_URL}`);
+        }
+        
+        fetchOptions.agent = agent;
+      } catch (envProxyError) {
+        logger.error(`环境变量代理配置失败: ${envProxyError.message}`);
+      }
+    }
+    
+    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,
+        retryCount
+      );
+    }
+    
+    if (!response.ok) {
+      let errorDetails = '';
+      try {
+        const errorText = await response.text();
+        errorDetails = errorText;
+        logger.error(`Notion API 错误详情: ${response.status} - ${errorText}`);
+      } catch (e) {
+        logger.error(`无法读取错误响应: ${e.message}`);
+      }
+      
+      // 添加请求调试信息
+      logger.error(`请求URL: ${notionApiUrl}`);
+      logger.error(`请求头: ${JSON.stringify(fetchOptions.headers, null, 2)}`);
+      logger.error(`请求体长度: ${fetchOptions.body.length}`);
+      
+      throw new Error(`HTTP error! status: ${response.status}, details: ${errorDetails}`);
+    }
+    
+    // 处理流式响应
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    
+    // 创建流读取器
+    const reader = response.body;
+    let buffer = '';
+    
+    // 处理数据块
+    reader.on('data', (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 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 }),
+                    finish_reason: null
+                  })
+                ]
+              });
+              
+              // 添加到队列
+              const dataStr = `data: ${JSON.stringify(chunk)}\n\n`;
+              safeWriteToStream(chunkQueue, dataStr);
+            } else if (jsonData?.recordMap) {
+              // 忽略recordMap响应
+            } else {
+              // 忽略其他类型响应
+            }
+          } catch (jsonError) {
+            logger.error(`解析JSON出错: ${jsonError}`);
+          }
+        }
+      } catch (error) {
+        logger.error(`处理数据块出错: ${error}`);
+      }
+    });
+    
+    // 处理流结束
+    reader.on('end', () => {
+      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 && proxy) {
+            proxyPool.removeProxy(proxy.ip, proxy.port);
+          }
+          
+          const noContentChunk = new ChatCompletionChunk({
+            choices: [
+              new Choice({
+                delta: new ChoiceDelta({ content: "未从Notion收到内容响应,请更换ip重试。" }),
+                finish_reason: "no_content"
+              })
+            ]
+          });
+          safeWriteToStream(chunkQueue, `data: ${JSON.stringify(noContentChunk)}\n\n`);
+        }
+        
+        // 创建结束块
+        const endChunk = new ChatCompletionChunk({
+          choices: [
+            new Choice({
+              delta: new ChoiceDelta({ content: null }),
+              finish_reason: "stop"
+            })
+          ]
+        });
+        
+        // 添加到队列
+        safeWriteToStream(chunkQueue, `data: ${JSON.stringify(endChunk)}\n\n`);
+        safeWriteToStream(chunkQueue, 'data: [DONE]\n\n');
+        
+        // 清除超时计时器（如果尚未清除）
+        if (timeoutId) clearTimeout(timeoutId);
+        
+        // 清理全局对象
+        cleanupGlobalObjects();
+        
+        // 结束流
+        safeEndStream(chunkQueue);
+      } catch (error) {
+        logger.error(`Error in stream end handler: ${error}`);
+        if (timeoutId) clearTimeout(timeoutId);
+        
+        // 清理全局对象
+        cleanupGlobalObjects();
+        
+        safeEndStream(chunkQueue);
+      }
+    });
+    
+    // 处理错误
+    reader.on('error', (error) => {
+      logger.error(`Stream error: ${error}`);
+      if (timeoutId) clearTimeout(timeoutId);
+      
+      // 清理全局对象
+      cleanupGlobalObjects();
+      
+      try {
+        const errorChunk = new ChatCompletionChunk({
+          choices: [
+            new Choice({
+              delta: new ChoiceDelta({ content: `流读取错误: ${error.message}` }),
+              finish_reason: "error"
+            })
+          ]
+        });
+        safeWriteToStream(chunkQueue, `data: ${JSON.stringify(errorChunk)}\n\n`);
+        safeWriteToStream(chunkQueue, 'data: [DONE]\n\n');
+      } catch (e) {
+        logger.error(`Error sending error message: ${e}`);
+      } finally {
+        safeEndStream(chunkQueue);
+      }
+    });
+  } catch (error) {
+    logger.error(`Notion API请求失败: ${error}`);
+    
+    // 如果是代理相关的错误，尝试移除当前代理并重试
+    if (USE_NATIVE_PROXY_POOL && proxy && 
+        (error.message.includes('EPROTO') || 
+         error.message.includes('ECONNREFUSED') || 
+         error.message.includes('timeout') ||
+         error.message.includes('SSL') ||
+         error.message.includes('wrong version number'))) {
+      
+      logger.warning(`代理 ${proxy.ip}:${proxy.port} 出现错误，移除此代理`);
+      proxyPool.removeProxy(proxy.ip, proxy.port);
+      
+      // 如果还有其他代理可用，可以考虑重试
+      const nextProxy = proxyPool.getProxy();
+      if (nextProxy && retryCount < 1) { // 限制重试次数
+        logger.info(`尝试使用下一个代理: ${nextProxy.ip}:${nextProxy.port}`);
+        // 重新抛出错误让上层重试机制处理
+        throw new Error(`代理错误，需要重试: ${error.message}`);
+      }
+    }
+    
+    // 清理全局对象
+    cleanupGlobalObjects();
+    
+    if (timeoutId) clearTimeout(timeoutId);
+    
+    // 确保在错误情况下也触发流结束
+    try {
+      if (!responseReceived) {
+        const errorChunk = new ChatCompletionChunk({
+          choices: [
+            new Choice({
+              delta: new ChoiceDelta({ content: `Notion API请求失败: ${error.message}` }),
+              finish_reason: "error"
+            })
+          ]
+        });
+        safeWriteToStream(chunkQueue, `data: ${JSON.stringify(errorChunk)}\n\n`);
+        safeWriteToStream(chunkQueue, 'data: [DONE]\n\n');
+      }
+    } catch (e) {
+      logger.error(`发送错误消息时出错: ${e}`);
+    } finally {
+      safeEndStream(chunkQueue);
+    }
+    
+    throw error; // 重新抛出错误以便上层捕获
+  }
+}
+
+// 清理全局对象的函数
+function cleanupGlobalObjects() {
+  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}`);
+  }
+}
+
+// ====================================================================
+// 【核心修改】应用初始化函数，以适应Hugging Face Secrets
+// ====================================================================
+async function initialize() {
+  logger.info(`初始化Notion配置...`);
+
+  // 如果启用了完整的代理功能，则启动代理服务器
+  if (ENABLE_PROXY_SERVER) {
+    try {
+      await proxyServer.start();
+    } catch (error) {
+      logger.error(`启动代理服务器失败: ${error.message}`);
+    }
+  }
+
+  let initResult = false;
+  const cookieFileContent = process.env.COOKIE_FILE_CONTENT;
+  const cookieFilePath = process.env.COOKIE_FILE_PATH || 'cookies.txt';
+
+  // 1. 优先从环境变量 COOKIE_FILE_CONTENT 加载 (Hugging Face部署模式)
+  if (cookieFileContent) {
+    logger.info(`检测到 COOKIE_FILE_CONTENT，正在从环境变量内容加载...`);
+    try {
+      // 将Secret内容写入容器内的一个临时文件
+      fs.writeFileSync(cookieFilePath, cookieFileContent, 'utf8');
+      // 让CookieManager从这个刚创建的文件加载
+      initResult = await cookieManager.loadFromFile(cookieFilePath);
+    } catch (e) {
+      logger.error(`从Secret创建或加载cookie失败: ${e.message}`);
+      initResult = false;
+    }
+  } 
+  // 2. 如果没有，则回退到从环境变量 COOKIE_FILE 指定的路径加载 (本地开发模式1)
+  else if (process.env.COOKIE_FILE) {
+    logger.info(`检测到COOKIE_FILE配置: ${process.env.COOKIE_FILE}`);
+    initResult = await cookieManager.loadFromFile(process.env.COOKIE_FILE);
+  }
+
+  // 3. 如果以上都失败或未配置，则回退到从 NOTION_COOKIE 字符串加载 (本地开发模式2)
+  if (!initResult) {
+    const cookiesString = process.env.NOTION_COOKIE;
+    if (!cookiesString) {
+      logger.error(`错误: 未在Secrets或环境变量中设置 COOKIE_FILE_CONTENT, COOKIE_FILE 或 NOTION_COOKIE。应用无法启动。`);
+      INITIALIZED_SUCCESSFULLY = false;
+      return;
+    }
+    logger.info(`正在从环境变量 NOTION_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;
+  }
+  
+  logger.success(`成功初始化cookie管理器，共有 ${cookieManager.getValidCount()} 个有效cookie`);
+  logger.info(`当前使用的cookie对应的用户ID: ${currentCookieData.userId}`);
+  logger.info(`当前使用的cookie对应的空间ID: ${currentCookieData.spaceId}`);
+  
+  // 如果启用了代理池，则初始化代理池
+  if (USE_NATIVE_PROXY_POOL) {
+    logger.info(`正在初始化代理池...`);
+    try {
+      await proxyPool.initialize();
+      logger.success(`代理池初始化完成，可用代理数量: ${proxyPool.getValidCount ? proxyPool.getValidCount() : '未知'}`);
+    } catch (proxyError) {
+      logger.error(`代理池初始化失败: ${proxyError.message}`);
+      logger.warning(`将在没有代理池的情况下继续运行`);
+    }
+  }
+  
+  INITIALIZED_SUCCESSFULLY = true;
+}
+
+// 导出函数
+export {
+  initialize,
+  streamNotionResponse,
+  buildNotionRequest,
+  INITIALIZED_SUCCESSFULLY
+};
+
+

src/models.js

@@ -0,0 +1,213 @@
+import { randomUUID } from 'crypto';
+
+// 输入模型 (OpenAI-like)
+export class ChatMessage {
+  constructor({
+    id = generateCustomId(),
+    role,
+    content,
+    userId = null,
+    createdAt = null,
+    traceId = null
+  }) {
+    this.id = id;
+    this.role = role; // "system", "user", "assistant"
+    this.content = content;
+    this.userId = userId;
+    this.createdAt = createdAt;
+    this.traceId = traceId;
+  }
+}
+
+export class ChatCompletionRequest {
+  constructor({
+    messages,
+    model = "notion-proxy",
+    stream = false,
+    notion_model = "anthropic-opus-4"
+  }) {
+    this.messages = messages;
+    this.model = model;
+    this.stream = stream;
+    this.notion_model = notion_model;
+  }
+}
+
+// Notion 模型
+export class NotionTranscriptConfigValue {
+  constructor({
+    type = "markdown-chat",
+    model
+  }) {
+    this.type = type;
+    this.model = model;
+  }
+}
+
+
+export class NotionTranscriptContextValue {
+  constructor({
+    userId,
+    spaceId,
+    surface = "home_module",
+    timezone = "America/Los_Angeles",
+    userName,
+    spaceName,
+    spaceViewId,
+    currentDatetime
+  }) {
+    this.userId = userId;
+    this.spaceId = spaceId;
+    this.surface = surface;
+    this.timezone = timezone;
+    this.userName = userName;
+    this.spaceName = spaceName;
+    this.spaceViewId = spaceViewId;
+    this.currentDatetime = currentDatetime;
+  }
+}
+
+export class NotionTranscriptItem {
+  constructor({
+    id = generateCustomId(),
+    type,
+    value = null,
+
+  }) {
+    this.id = id;
+    this.type = type; // "markdown-chat", "agent-integration", "context"
+    this.value = value;
+  }
+}
+
+export class NotionTranscriptItemByuser {
+  constructor({
+    id = generateCustomId(),
+    type,
+    value = null,
+    userId,
+    createdAt
+
+  }) {
+    this.id = id;
+    this.type = type; // "config", "user"
+    this.value = value;
+    this.userId = userId;
+    this.createdAt = createdAt;
+  }
+}
+
+export class NotionDebugOverrides {
+  constructor({
+    cachedInferences = {},
+    annotationInferences = {},
+    emitInferences = false
+  }) {
+    this.cachedInferences = cachedInferences;
+    this.annotationInferences = annotationInferences;
+    this.emitInferences = emitInferences;
+  }
+}
+
+export function generateCustomId() {
+  // 创建固定部分
+  const prefix1 = '2036702a';
+  const prefix2 = '4d19';
+  const prefix5 = '00aa';
+  
+  // 生成随机十六进制字符
+  function randomHex(length) {
+    return Array(length).fill(0).map(() => 
+      Math.floor(Math.random() * 16).toString(16)
+    ).join('');
+  }
+  
+  // 组合所有部分
+  const part3 = '80' + randomHex(2);  // 8xxx
+  const part4 = randomHex(4);        // xxxx
+  const part5 = prefix5 + randomHex(8); // 00aaxxxxxxxx
+  
+  return `${prefix1}-${prefix2}-${part3}-${part4}-${part5}`;
+}
+
+export class NotionRequestBody {
+  constructor({
+    traceId = randomUUID(),
+    spaceId,
+    transcript,
+    createThread = false,
+    debugOverrides = new NotionDebugOverrides({}),
+    generateTitle = true,
+    saveAllThreadOperations = true,
+  }) {
+    this.traceId = traceId;
+    this.spaceId = spaceId;
+    this.transcript = transcript;
+    this.createThread = createThread;
+    this.debugOverrides = debugOverrides;
+    this.generateTitle = generateTitle;
+    this.saveAllThreadOperations = saveAllThreadOperations;
+  }
+}
+
+// 输出模型 (OpenAI SSE)
+export class ChoiceDelta {
+  constructor({
+    content = null
+  }) {
+    this.content = content;
+  }
+}
+
+export class Choice {
+  constructor({
+    index = 0,
+    delta,
+    finish_reason = null
+  }) {
+    this.index = index;
+    this.delta = delta;
+    this.finish_reason = finish_reason;
+  }
+}
+
+export class ChatCompletionChunk {
+  constructor({
+    id = `chatcmpl-${randomUUID()}`,
+    object = "chat.completion.chunk",
+    created = Math.floor(Date.now() / 1000),
+    model = "notion-proxy",
+    choices
+  }) {
+    this.id = id;
+    this.object = object;
+    this.created = created;
+    this.model = model;
+    this.choices = choices;
+  }
+}
+
+// 模型列表端点 /v1/models
+export class Model {
+  constructor({
+    id,
+    object = "model",
+    created = Math.floor(Date.now() / 1000),
+    owned_by = "notion"
+  }) {
+    this.id = id;
+    this.object = object;
+    this.created = created;
+    this.owned_by = owned_by;
+  }
+}
+
+export class ModelList {
+  constructor({
+    object = "list",
+    data
+  }) {
+    this.object = object;
+    this.data = data;
+  }
+}