Upload 14 files

.env.example

@@ -4,11 +4,14 @@ NOTION_COOKIE="cookie1|cookie2"
 #COOKIE_FILE="./cookies.txt"
 # （可选）反代密码，没有的话默认密码是 default_token
 PROXY_AUTH_TOKEN="sk-text"
-# （可选）代理地址，启用tls后失效
+# （可选）代理地址
 PROXY_URL=""
 # （可选）是否使用本地代理池，启用前确保没有设置其它代理，否则速度会减慢或者出现其它问题，推荐启用
 USE_NATIVE_PROXY_POOL=true
 
+# （可选）代理国家，支持us uk jp de fr ca
+PROXY_COUNTRY="us"
+
 # tls代理服务器配置（可选）建议启用
 # 平台选择：auto(自动检测), windows, linux, android
 PROXY_SERVER_PLATFORM="auto"

README.md

@@ -1,128 +1,207 @@
----
-title: Notion
-emoji: 📝
-colorFrom: indigo
-colorTo: blue
-sdk: docker
-app_port: 7860
----
+# Notion API 轻量级客户端
 
-# Notion API 轻量级客户端 (Hugging Face Space)
+这个项目提供了一个轻量级的 Notion API 客户端，可以在资源受限的环境（如 Termux）中运行，无需完整的浏览器环境。
 
-这个项目提供了一个轻量级的 Notion API 客户端，可以作为 Web 服务部署在 Hugging Face Spaces 上。它兼容 OpenAI API 格式，让你可以将 Notion AI 作为后端集成到各种应用中。
+## 特点
 
-## 🚀 在 Hugging Face Spaces 上部署
+- 使用 `node-fetch` 代替 Playwright 浏览器自动化
+- 轻量级设计，适合在移动设备和资源受限环境中运行
+- 支持 Notion AI 的流式响应
+- 兼容 OpenAI API 格式的请求和响应
 
-1.  **创建 Space**: 在 Hugging Face 上创建一个新的 Space。
-2.  **选择 Docker SDK**: 在 "Choose an SDK" 步骤中，选择 "Docker"。
-3.  **上传文件**: 将此项目的所有文件（包括 `Dockerfile`）上传到你的 Space Git 仓库中。
-4.  **设置 Secrets**: 这是最重要的一步。你的 Notion 凭证和其他配置需要作为 Secrets 添加到 Space 中。进入你的 Space "Settings" 页面，找到 "Repository secrets" 部分，然后点击 "New secret" 添加以下变量：
+## 安装
 
-    *   **必需**:
-        *   `NOTION_COOKIE`: 你的 Notion Cookie。你可以通过浏览器开发者工具获取。
-    *   **可选**:
-        *   `NOTION_SPACE_ID`: 你的 Notion Space ID。
-        *   `NOTION_ACTIVE_USER_HEADER`: 你的 Notion 用户 ID。
-        *   `PROXY_URL`: 如果你需要通过代理访问 Notion，请设置此项 (例如 `http://user:pass@host:port`)。
-        *   `PROXY_AUTH_TOKEN`: 如果你的代理需要单独的认证令牌，请设置此项。
-        *   `COOKIE_FILE`: 如果你使用文件管理多个 Cookie，请设置为文件名 (例如 `cookies.txt`)。请确保该文件也已上传到仓库中。
+### 依赖项
 
-    **注意**: `PORT` 环境变量由 Hugging Face 自动处理，你无需设置。
+确保安装以下依赖：
 
-5.  **等待部署**: 添加完 Secrets 后，Hugging Face 会自动构建 Docker 镜像并部署你的应用。你可以在 "Logs" 标签页查看部署进度和应用日志。部署成功后，你的 API 端点即可使用。
+```bash
+npm install
+```
 
-## 📖 API 使用说明
+### 环境变量
 
-服务启动后，你可以通过你的 Space URL 访问 API。
+创建 `.env` 文件，设置以下环境变量：
 
-**基础 URL**: `https://<your-space-name>.hf.space`
+```
+NOTION_COOKIE=your_notion_cookie_here
+NOTION_SPACE_ID=optional_space_id
+NOTION_ACTIVE_USER_HEADER=optional_user_id
+PROXY_URL=optional_proxy_url
+PROXY_AUTH_TOKEN=your_auth_token
+PORT=7860
+```
 
-### API 端点
+## 使用方法
 
--   `GET /v1/models` - 获取可用模型列表 (主要是为了兼容 OpenAI 客户端)
--   `POST /v1/chat/completions` - 核心的聊天完成端点
--   `GET /health` - 健康检查端点
+### 启动服务
 
-### 示例: 使用 cURL 调用
+运行轻量级服务器：
 
 ```bash
-curl -X POST https://<your-space-name>.hf.space/v1/chat/completions \
--H "Content-Type: application/json" \
--d '{
-    "model": "openai-gpt-4.1",
-    "messages": [
-        {"role": "user", "content": "你好，请介绍一下你自己"}
-    ],
-    "stream": true
-}'
+npm start
 ```
-*请将 `<your-space-name>` 替换为你的 Space 名称。*
 
-## 🍪 Cookie 管理
+服务器将在指定端口（默认 7860）启动。
 
-为了提高服务的稳定性，你可以提供多个 Notion Cookie。
+如果需要使用原始的基于 Playwright 的版本（不推荐在 Termux 中使用）：
 
-### 通过文件管理 Cookie
+```bash
+npm run original
+```
 
-1.  在项目根目录创建一个 `cookies.txt` 或 `cookies.json` 文件。
-2.  将文件上传到你的 Space 仓库。
-3.  在 Space Secrets 中设置 `COOKIE_FILE` 为你的文件名 (例如 `cookies.txt`)。
+### API 端点
 
-系统启动时会自动从该文件加载Cookie。
+- `GET /v1/models` - 获取可用模型列表
+- `POST /v1/chat/completions` - 聊天完成端点
+- `GET /health` - 健康检查
 
-**`cookies.txt` 示例:** (每行一个Cookie)
+### 在 Termux 中运行
+
+1. 安装 Termux 和 Node.js：
+```bash
+pkg update
+pkg install nodejs
 ```
-cookie1_string_here
-cookie2_string_here
+
+2. 克隆项目并安装依赖：
+```bash
+git clone https://github.com/yourusername/notion2api-nodejs.git
+cd notion2api-nodejs
+npm install
 ```
 
-**`cookies.json` 示例:**
-```json
-{
-  "cookies": [
-    "cookie1_string_here",
-    "cookie2_string_here"
-  ]
+3. 设置环境变量并运行：
+```bash
+npm start
+```
+
+## 作为模块集成
+
+你也可以将轻量级客户端作为模块导入到你自己的项目中：
+
+```javascript
+import {
+  initialize,
+  streamNotionResponse,
+  buildNotionRequest,
+  FETCHED_IDS_SUCCESSFULLY
+} from './lightweight-client.js';
+
+// 初始化客户端
+await initialize();
+
+// 检查是否成功获取 Notion IDs
+if (FETCHED_IDS_SUCCESSFULLY) {
+  // 构建请求
+  const requestData = {
+    notion_model: "openai-gpt-4.1",
+    messages: [
+      { role: "user", content: "你好，请介绍一下自己" }
+    ]
+  };
+  
+  const notionRequestBody = buildNotionRequest(requestData);
+  
+  // 获取响应流
+  const stream = await streamNotionResponse(notionRequestBody);
+  
+  // 处理响应
+  stream.on('data', chunk => {
+    console.log(chunk.toString());
+  });
 }
 ```
 
-### Cookie 轮询机制
+## 故障排除
 
-系统会自动轮询使用所有有效的Cookie。当一个Cookie失效时（例如返回401错误），会自动切换到下一个有效的Cookie，确保服务不中断。
+- 如果无法获取 Notion IDs，请确保提供了有效的 NOTION_COOKIE
+- 对于网络问题，可以尝试设置 PROXY_URL
+- 查看日志输出以获取详细的错误信息
 
----
+## 依赖说明
 
-## 本地开发参考
+- `node-fetch`: 用于发送 HTTP 请求
+- `jsdom`: 提供 DOM API 的轻量级模拟
+- `dotenv`: 加载环境变量
+- `express`: Web 服务器框架
+- `https-proxy-agent`: 支持 HTTPS 代理
 
-以下信息用于在本地计算机上运行和开发。
+## Cookie管理功能
 
-### 依赖项
-```bash
-npm install
-```
+本项目新增了Cookie管理功能，可以更方便地管理多个Notion Cookie，避免在.env文件中手动编辑长字符串。
+
+### 使用方法
+
+#### 1. 通过文件管理Cookie
+
+在项目根目录创建一个`cookies.txt`文件，每行一个完整的Cookie字符串：
 
-### 环境变量
-创建 `.env` 文件，设置以下环境变量：
 ```
-NOTION_COOKIE=your_notion_cookie_here
-NOTION_SPACE_ID=optional_space_id
-NOTION_ACTIVE_USER_HEADER=optional_user_id
-PROXY_URL=optional_proxy_url
-PROXY_AUTH_TOKEN=your_auth_token
-PORT=7860
+cookie1_string_here
+cookie2_string_here
+cookie3_string_here
 ```
 
-### 启动服务
-```bash
-npm start
+然后在`.env`文件中设置：
+
+```
+COOKIE_FILE=cookies.txt
 ```
 
-### Cookie 管理命令行工具
-项目提供了一个命令行工具来方便地管理 `cookies.json` 文件。
+系统启动时会自动从该文件加载Cookie。
+
+#### 2. 使用Cookie管理工具
+
+项目提供了一个命令行工具来管理Cookie：
+
 ```bash
-# 运行命令行工具
+# 使用npm脚本运行
 npm run cookie
 
-# 支持的命令
-help, list, add, validate, remove, save, load, exit
+# 或者全局安装后运行
+npm link
+notion-cookie
+```
+
+命令行工具支持以下功能：
+
+- `help`: 显示帮助信息
+- `list`: 列出所有已加载的Cookie
+- `add`: 添加新的Cookie
+- `validate`: 验证所有Cookie的有效性
+- `remove`: 删除指定的Cookie
+- `save`: 保存Cookie到文件
+- `load`: 从文件加载Cookie
+- `exit`: 退出程序
+
+### Cookie轮询机制
+
+系统会自动轮询使用所有有效的Cookie，当一个Cookie返回401错误（未授权）时，会自动将其标记为无效并切换到下一个Cookie。这样可以提高系统的可靠性和可用性。
+
+### 文件格式支持
+
+Cookie管理器支持两种文件格式：
+
+1. 文本格式（.txt）：每行一个Cookie
+2. JSON格式（.json）：包含Cookie数组的JSON文件
+
+```json
+{
+  "cookies": [
+    "cookie1_string_here",
+    "cookie2_string_here"
+  ],
+  "updatedAt": "2023-08-01T12:00:00.000Z",
+  "count": 2
+}
+```
+
+或者简单的数组：
+
+```json
+[
+  "cookie1_string_here",
+  "cookie2_string_here"
+]
 ``` 

src/ProxyPool.js

@@ -21,6 +21,7 @@ class ProxyPool {
    * @param {boolean} options.useCache - 是否使用缓存，默认true
    * @param {number} options.cacheExpiry - 缓存过期时间(毫秒)，默认3600000 (1小时)
    * @param {string} options.logLevel - 日志级别，可选值：'debug', 'info', 'warn', 'error', 'none'，默认'info'
+   * @param {boolean} options.showProgressBar - 是否显示进度条，默认false
    */
   constructor(options = {}) {
     // 配置参数
@@ -38,6 +39,7 @@ class ProxyPool {
     this.useCache = options.useCache !== undefined ? options.useCache : true;
     this.cacheExpiry = options.cacheExpiry || 3600000; // 默认1小时
     this.logLevel = options.logLevel || 'info'; // 默认日志级别为info
+    this.showProgressBar = options.showProgressBar !== undefined ? options.showProgressBar : false; // 是否显示进度条
     
     // 内部状态
     this.availableProxies = [];
@@ -46,6 +48,13 @@ class ProxyPool {
     this.isRefilling = false;
     this.checkTimer = null;
     this.proxyCache = new Map(); // 缓存验证过的代理
+    this.proxyCountry = 'us';
+    
+    // 进度条状态
+    this.progressTotal = 0;
+    this.progressCurrent = 0;
+    this.progressBarLength = 30; // 进度条长度
+    this.lastProgressString = ''; // 上次显示的进度字符串
     
     // 日志级别权重
     this.logLevels = {
@@ -61,6 +70,14 @@ class ProxyPool {
     this.removeProxy = this.removeProxy.bind(this);
     this.checkAndRefill = this.checkAndRefill.bind(this);
   }
+
+  /**
+   * 设置代理国家
+   * @param {string} country - 代理国家 支持us uk jp de fr ca
+   */
+  setCountry(country) {
+    this.proxyCountry = country;
+  }
   
   /**
    * 根据设置的日志级别输出日志
@@ -79,6 +96,62 @@ class ProxyPool {
     }
   }
   
+  /**
+   * 显示进度条
+   * @param {string} message - 进度条前的消息
+   * @param {number} current - 当前进度
+   * @param {number} total - 总进度
+   * @param {boolean} [complete=false] - 是否完成
+   */
+  showProgress(message, current, total) {
+    if (!this.showProgressBar) return;
+    
+    // 确保进度不超过总数
+    current = Math.min(current, total);
+    
+    // 计算进度百分比
+    const percent = total > 0 ? Math.floor((current / total) * 100) : 0;
+    
+    // 创建终端风格的箭头进度条
+    let bar = '';
+    let ProcessBarLength = 15;
+    let CurrentProcessBarLength = Math.floor(ProcessBarLength*(percent/100));
+    let ProcessBarRemainLength = ProcessBarLength-CurrentProcessBarLength;
+    let ProcessBar = '-'.repeat(CurrentProcessBarLength)+'>';
+    let ProcessBarRemain = '·'.repeat(ProcessBarRemainLength);
+    if (percent === 100) {
+      // 完成状态显示完整箭头
+      bar = '['+'-'.repeat(ProcessBarLength)+'>'+']';
+    } else {
+      bar = '['+ProcessBar+ProcessBarRemain+']';
+    }
+    
+    // 构建进度字符串，添加百分比
+    const progressString = `${message} ${bar} ${current}/${total} (${percent}%)`;
+    
+    // 如果进度字符串与上次相同，则不重复显示
+    if (progressString === this.lastProgressString) {
+      return;
+    }
+    
+    // 清除上一行
+    if (this.lastProgressString) {
+      process.stdout.clearLine(0);
+      process.stdout.cursorTo(0);
+    }
+    
+    // 显示进度条
+    process.stdout.write(progressString);
+    
+    // 如果完成，换行
+    if (percent === 100) {
+      process.stdout.write('\n');
+    }
+    
+    // 保存当前进度字符串
+    this.lastProgressString = progressString;
+  }
+  
   /**
    * 初始化代理池
    * @returns {Promise<void>}
@@ -87,12 +160,21 @@ class ProxyPool {
     if (this.isInitialized) return;
     
     this.log('info', `初始化代理池，目标数量: ${this.targetCount}`);
+    
+    // 重置进度条状态
+    this.progressTotal = this.targetCount;
+    this.progressCurrent = 0;
+    //this.showProgress('初始化代理池进度', this.progressCurrent, this.progressTotal);
+    
     await this.refillProxies();
     
     // 设置定时检查
     this.checkTimer = setInterval(this.checkAndRefill, this.checkInterval);
     
     this.isInitialized = true;
+    
+    // 完成进度条
+    this.showProgress('补充代理进度', this.availableProxies.length, this.progressTotal);
     this.log('info', `代理池初始化完成，当前可用代理数量: ${this.availableProxies.length}`);
   }
   
@@ -127,6 +209,11 @@ class ProxyPool {
     this.isRefilling = true;
     this.log('info', `开始补充代理，当前数量: ${this.availableProxies.length}，目标数量: ${this.targetCount}`);
     
+    // 设置进度条状态
+    this.progressTotal = this.targetCount;
+    this.progressCurrent = this.availableProxies.length;
+    this.showProgress('补充代理进度', this.progressCurrent, this.progressTotal);
+    
     let attempts = 0;
     
     try {
@@ -136,6 +223,10 @@ class ProxyPool {
       // 优先检查缓存中的代理
       if (this.useCache && this.proxyCache.size > 0) {
         await this.tryUsingCachedProxies(neededProxies);
+        
+        // 更新进度条
+        this.progressCurrent = this.availableProxies.length;
+        this.showProgress('补充代理进度', this.progressCurrent, this.progressTotal);
       }
       
       // 如果缓存中的代理不足，继续获取新代理
@@ -165,12 +256,19 @@ class ProxyPool {
           continue;
         }
         
+        // 保存当前进度，测试代理过程中会临时更新进度条
+        const previousProgress = this.progressCurrent;
+        
         // 测试代理
         const results = await this.testProxiesConcurrently(newProxies);
         
         // 添加可用代理
         this.addValidProxies(results);
         
+        // 更新实际进度
+        this.progressCurrent = this.availableProxies.length;
+        this.showProgress('补充代理进度', this.progressCurrent, this.progressTotal);
+        
         // 如果已经获取到足够的代理，提前结束
         if (this.availableProxies.length >= this.targetCount) {
           break;
@@ -184,8 +282,7 @@ class ProxyPool {
     } catch (error) {
       this.log('error', '补充代理过程中出错:', error);
     } finally {
-      this.isRefilling = false;
-      
+      this.isRefilling = false;      
       if (this.availableProxies.length >= this.targetCount) {
         this.log('info', `代理补充完成，当前可用代理: ${this.availableProxies.length}/${this.targetCount}`);
       } else {
@@ -331,7 +428,7 @@ class ProxyPool {
       const requestCount = count || this.batchSize;
       // 限制请求数量最大为10
       const actualCount = Math.min(requestCount, 10);
-      const url = `https://proxy.doudouzi.me/random/us?number=${actualCount}&protocol=${this.proxyProtocol}&type=json`;
+      const url = `https://proxy.doudouzi.me/random/${this.proxyCountry}?number=${actualCount}&protocol=${this.proxyProtocol}&type=json`;
       this.log('debug', `正在获取代理，URL: ${url}`);
       
       const response = await axios.get(url, { 
@@ -387,6 +484,16 @@ class ProxyPool {
     // 分批处理代理
     for (let i = 0; i < proxies.length; i += concurrentRequests) {
       const batch = proxies.slice(i, i + concurrentRequests);
+      
+      // 不再显示测试代理的单独进度条，而是更新补充代理的总体进度
+      if (this.showProgressBar) {
+        // 计算当前测试进度对应的总体进度
+        const testedPercent = i / proxies.length;
+        const progressStep = Math.min(1, testedPercent) * 0.2; // 测试部分占总体进度的20%
+        const currentProgress = this.progressCurrent + progressStep * (this.targetCount - this.progressCurrent);
+        this.showProgress('补充代理进度', Math.floor(currentProgress), this.progressTotal);
+      }
+      
       const promises = batch.map(proxy => {
         // 检查缓存中是否有近期验证过的结果
         if (this.useCache && this.proxyCache.has(proxy)) {
@@ -414,6 +521,8 @@ class ProxyPool {
       }
     }
     
+    // 不再显示测试完成的进度条
+    
     return results;
   }
   
@@ -590,7 +699,8 @@ async function example() {
     useCache: true,            // 启用缓存
     maxRefillAttempts: 15,     // 减少最大尝试次数
     retryDelay: 1000,          // 减少重试延迟
-    logLevel: 'info'           // 设置日志级别
+    logLevel: 'info',          // 设置日志级别
+    showProgressBar: true      // 启用进度条
   });
   
   // 初始化代理池
@@ -626,5 +736,7 @@ if (typeof require !== 'undefined' && require.main === module) {
 // 导出 ProxyPool 类和实例
 export default ProxyPool;
 export const proxyPool = new ProxyPool({
-  logLevel: 'info' // 默认导出的实例使用info级别的日志
+  logLevel: 'info', // 默认导出的实例使用info级别的日志
+  showProgressBar: true // 启用进度条
 });
+

src/ProxyServer.js

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

src/lightweight-client-express.js

@@ -137,7 +137,9 @@ app.get('/v1/models', authenticate, (req, res) => {
       { id: "openai-gpt-4.1" },
       { id: "anthropic-opus-4" },
       { id: "anthropic-sonnet-4" },
-      { id: "anthropic-sonnet-3.x-stable" }
+      { id: "anthropic-sonnet-3.x-stable" },
+      { id: "google-gemini-2.5-pro"}, //vertex-gemini-2.5-pro
+      { id: "google-gemini-2.5-flash"}, //vertex-gemini-2.5-flash
     ]
   };
   
@@ -319,7 +321,7 @@ app.get('/cookies/status', authenticate, (req, res) => {
 const PORT = process.env.PORT || 7860;
 
 // 设置代理池日志级别为warn，减少详细日志输出
-proxyPool.logLevel = 'warn';
+proxyPool.logLevel = 'error';
 
 // 初始化并启动服务器
 initialize().then(() => {

src/lightweight-client.js

@@ -100,7 +100,22 @@ function buildNotionRequest(requestData) {
       value: new NotionTranscriptConfigValue({
       })
     }));
-  }else{
+  } else if(requestData.model === 'google-gemini-2.5-pro'){
+    transcript.push(new NotionTranscriptItem({
+      type: "config",
+      value: new NotionTranscriptConfigValue({
+        model: 'vertex-gemini-2.5-pro'
+      })
+    }));
+  } else if (requestData.model === 'google-gemini-2.5-flash'){
+    transcript.push(new NotionTranscriptItem({
+      type: "config",
+      value: new NotionTranscriptConfigValue({
+        model: 'vertex-gemini-2.5-flash'
+      })
+    }));
+  }
+  else{
       transcript.push(new NotionTranscriptItem({
     type: "config",
     value: new NotionTranscriptConfigValue({
@@ -840,8 +855,19 @@ async function initialize() {
   if (process.env.USE_NATIVE_PROXY_POOL === 'true') {
     logger.info(`正在初始化本地代理池...`);
     // 设置代理池的日志级别为warn，减少详细日志输出
-    proxyPool.logLevel = 'warn';
+    proxyPool.logLevel = 'error';
+    // 启用进度条显示
+    proxyPool.showProgressBar = true;
+    
+    if (['us', 'uk', 'jp', 'de', 'fr', 'ca'].includes(process.env.PROXY_COUNTRY)) {
+      proxyPool.setCountry(process.env.PROXY_COUNTRY);
+    } else {
+      logger.warning(`未设置正确PROXY_COUNTRY，使用默认代理国家: us`);
+      proxyPool.setCountry('us');
+    }
     await proxyPool.initialize();
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    logger.success(`代理池初始化完成，当前代理国家: ${proxyPool.proxyCountry}`);
   }
   
   INITIALIZED_SUCCESSFULLY = true;