Upload 17 files

README.md

@@ -1,13 +1,3 @@
----
-title: Notion2API Node.js
-emoji: 🚀
-colorFrom: green
-colorTo: blue
-sdk: docker
-app_port: 7860
-pinned: false
----
-
 # Notion API 轻量级客户端
 
 这个项目提供了一个轻量级的 Notion API 客户端，可以在资源受限的环境（如 Termux）中运行，无需完整的浏览器环境。
@@ -135,4 +125,83 @@ if (FETCHED_IDS_SUCCESSFULLY) {
 - `jsdom`: 提供 DOM API 的轻量级模拟
 - `dotenv`: 加载环境变量
 - `express`: Web 服务器框架
-- `https-proxy-agent`: 支持 HTTPS 代理 
+- `https-proxy-agent`: 支持 HTTPS 代理
+
+## Cookie管理功能
+
+本项目新增了Cookie管理功能，可以更方便地管理多个Notion Cookie，避免在.env文件中手动编辑长字符串。
+
+### 使用方法
+
+#### 1. 通过文件管理Cookie
+
+在项目根目录创建一个`cookies.txt`文件，每行一个完整的Cookie字符串：
+
+```
+cookie1_string_here
+cookie2_string_here
+cookie3_string_here
+```
+
+然后在`.env`文件中设置：
+
+```
+COOKIE_FILE=cookies.txt
+```
+
+系统启动时会自动从该文件加载Cookie。
+
+#### 2. 使用Cookie管理工具
+
+项目提供了一个命令行工具来管理Cookie：
+
+```bash
+# 使用npm脚本运行
+npm run cookie
+
+# 或者全局安装后运行
+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"
+]
+``` 

cookies.txt

@@ -0,0 +1,4 @@
+notion_browser_id=a8182934-adff-461b-8c79-1506999adea4; device_id=200d872b-594c-812e-b369-003bcda8cdcd; _gcl_au=1.1.1170453355.1748542388; _ga=GA1.1.701605925.1748542389; _hjSessionUser_3664679=eyJpZCI6ImVlMmY4ZDIxLTMxY2QtNWMzNS1hZmQ1LThmYThjMjBiMTdhMCIsImNyZWF0ZWQiOjE3NDg1NDIzOTExMzcsImV4aXN0aW5nIjp0cnVlfQ==; notion_check_cookie_consent=false; _fbp=fb.1.1749309115969.575678538958199822; csrf=3c4feb4b-6326-40c0-9475-4e1884f6cbbd; notion_user_id=20cd872b-594c-8173-b5d1-0002cced3694; p_sync_session=%7B%22tokenId%22%3A%22v02%3Async_session%3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAswAbKutGqwNrCoDhEd_Shbu9h-MytbYGKknbSPCj2F07ufgzyXQZe80OIazyLYDe2Hlhhjj_zMaGxcg12txNRirfgJ67hr95aQVt%22%2C%22userIds%22%3A%5B%2220cd872b-594c-8173-b5d1-0002cced3694%22%5D%7D; _cioid=20cd872b594c8173b5d10002cced3694; _cfuvid=Ch1SRiUHxTgpm9P1m2Wpz62Nic_yTi97J7_R4lxKNKE-1749372872454-0.0.1.1-604800000; notion_cookie_sync_completed=%7B%22completed%22%3Atrue%2C%22version%22%3A4%2C%22attempts%22%3A2%7D; NEXT_LOCALE=en-US; notion_users=[%2220cd872b-594c-8173-b5d1-0002cced3694%22]; token_v2=v03%3AeyJhbGciOiJkaXIiLCJraWQiOiJwcm9kdWN0aW9uOnRva2VuLXYzOjIwMjQtMTEtMDciLCJlbmMiOiJBMjU2Q0JDLUhTNTEyIn0..ylhymya9pB__xkYLuLoKQA.c5dFHyRg1Eswr-qdbXqe7Jg9G7-VKguFtD0A1lm3SKw5fudZza9gHO69Od38u8arQjpNHv6CmxCDqNUAEtLtkks5mz8DjwfhxuPQhzkP8VjsHKD7JAPf3TU5LhounQGTO4OJ_MwQoEFqN-UUUPkoHBa1waJQ4CM5a8vAA8yeP4aqI7juS_UUp058MNiZZ2iYihBXYzX3Uepz2Hr0kQPzswUUlyuok5M_AWVfS-ws8hFSNgiHdSc5kZu5vk8liUBy6RCNELeHctUX1sXbiubIoy3yK9fHQDT2wyALecwmsy_FZZi_TOMIdqQkDRUZDzhwv08sVCe2u99Ldl9S_eIOxy6Om_PhCo3M0ddyjKS6ry_VmHPURdl221XOxkK2dD_T.gp5Uxr5t5Jj2bsyUQjqxmoxtQAErkLVuNhSoI-AwBr8; _ga_9ZJ8CB186L=GS2.1.s1749372875$o5$g0$t1749372875$j60$l0$h0; _rdt_uuid=1748542388717.64a3c6ac-6961-4401-9aec-9dfbb27dd932; _hjSession_3664679=eyJpZCI6IjkxYTE2Nzk0LTM0YzMtNDJlYi1hOTkyLWQ0Nzc1NDdjODkyYyIsImMiOjE3NDkzNzI4NzY2NjQsInMiOjAsInIiOjAsInNiIjowLCJzciI6MCwic2UiOjAsImZzIjowLCJzcCI6MH0=; __cf_bm=krgtdFh.9RpW333_.Y2qbyZSNT8wSbuJ4Pu_00k76D8-1749372879-1.0.1.1-Wi_RWsajHMTPPLBhAXWddtmDmoNCjzZe92yn1MqJjMJBAyXqx0p36dbnI9DSbtGQmFdc.JeskBIyvFMX4xmHcrFlGfr1S5cZctCE3d_BQ_547JaGhar9jdN3ul4US2MT; notion_locale=en-US%2Fautodetect
+notion_browser_id=fdf38010-21d4-433e-a2fd-65cab87f49f6; device_id=202d872b-594c-81d6-9a95-003bb32158fc; NEXT_LOCALE=zh-CN; _gcl_au=1.1.132916819.1748542408; _ga=GA1.1.1824875636.1748542409; _fbp=fb.1.1748542411909.266391455622580792; notion_user_id=200d872b-594c-81d3-bb1b-00024f30311d; p_sync_session=%7B%22tokenId%22%3A%22v02%3Async_session%3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlax4r-9CwW1tAnM4hm7SsLu9h-MytbYGKknbSPCj2F07ufgzyShCKc0MIvr1LYGI2ihhhjiqn8aHlsgy2otKQnuChsnq0LwuaQVt%22%2C%22userIds%22%3A%5B%22200d872b-594c-81d3-bb1b-00024f30311d%22%5D%7D; _cioid=200d872b594c81d3bb1b00024f30311d; notion_cookie_sync_completed=%7B%22completed%22%3Atrue%2C%22version%22%3A4%2C%22attempts%22%3A1%7D; notion_users=[%22200d872b-594c-81d3-bb1b-00024f30311d%22]; _hjSessionUser_3664679=eyJpZCI6IjgwYjAzZGViLWUxZmMtNTA3MC1iNDA2LWMyNzhlODdiZDdlNyIsImNyZWF0ZWQiOjE3NDg1NDI0MTE4ODEsImV4aXN0aW5nIjp0cnVlfQ==; notion_check_cookie_consent=false; _cfuvid=wTlmfFOGFuwtjS3B5cpDgBYYEQVRx657xz6GO.mLbGM-1749372976498-0.0.1.1-604800000; token_v2=v03%3AeyJhbGciOiJkaXIiLCJraWQiOiJwcm9kdWN0aW9uOnRva2VuLXYzOjIwMjQtMTEtMDciLCJlbmMiOiJBMjU2Q0JDLUhTNTEyIn0..Mp-BxJaoO0DWkZeGO_lskg.7AyTec3BJIN0GBIQbnLVNXDZMa9L96S0K8P-06lViUG7CjbZugK54J7TdHEvNo-OU9p07TmTtb-tLa2gHUGXJi6VWh9y1613W6vGGvsEz7CDi8tta7HRVuLCacry9nAH5txg3gk-1c_HE7Yt9up2ZGuZkR34UWPDScwoHizNfspAsdwFgFvbStFZ1uDDD0u8zODoYr5--VWcdR8nKu1Cv6dWPm7xXBzRBNwaYPmEYsDDHxpSGMQF1_goLi8AoRYxIM-s9wEGoU6WCy-n4fgPUt5HXvirQ_4RSqSzcugnOpCjAG9fNIQ5En6knr8B9JyR04XxVUI_7WCG1KOsKuReAfHg0lD_e7BI-sVkFW27N-k.3kFpD-Z46S89LoPkH_CBkZH_zTxSaVhQ-f8nU92wZcI; _ga_9ZJ8CB186L=GS2.1.s1749372981$o5$g0$t1749372981$j60$l0$h0; _rdt_uuid=1748542408747.963fa76b-30e7-4e18-ab01-aba3f7a1457e; _hjSession_3664679=eyJpZCI6IjliMTQ1NjE3LWVkODctNGM1OC1hNTNlLWIwMmYyZTQ2OWNhZiIsImMiOjE3NDkzNzI5ODEyNzAsInMiOjAsInIiOjAsInNiIjowLCJzciI6MCwic2UiOjAsImZzIjowLCJzcCI6MH0=; __cf_bm=VuvmjnWN46h3pr265Lq8SURwcFrcRgsGwSfYPoKX4hQ-1749372983-1.0.1.1-DAD44JAgwln368624Zuu98Lbc8_y9bYofxaClaQ2cUA.aRy6JHa8APWWqQdD8P.SvjHluoSk3v2xaN6wAd_jjIeofPU6lmgzLlgZeybnMcCbdJlH.EqZJtuFNjNaPtxV; notion_locale=zh-CN%2Fautodetect
+notion_browser_id=3df6d794-ba0a-4644-816c-29c8179d3f0e; device_id=20cd872b-594c-8118-9580-003ba37e2e8f; notion_check_cookie_consent=false; NEXT_LOCALE=zh-CN; _gcl_au=1.1.2123998494.1749355832; _ga=GA1.1.813384426.1749355835; _fbp=fb.1.1749355838864.415958857195472441; csrf=e233e94c-6881-417d-91f3-a0badd44dcad; notion_user_id=20bd872b-594c-81a1-b249-0002d1feacbe; p_sync_session=%7B%22tokenId%22%3A%22v02%3Async_session%3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAs76a4X79UYBYNhOmEp3ep7u9h-MytbYGKknbSPCj2F07ufgzySNOe81QcaDzLdSK3i5hhm2gzMbfl8gz2oBKF3uEjJm8178obwVt%22%2C%22userIds%22%3A%5B%2220bd872b-594c-81a1-b249-0002d1feacbe%22%5D%7D; _cioid=20bd872b594c81a1b2490002d1feacbe; notion_cookie_sync_completed=%7B%22completed%22%3Atrue%2C%22version%22%3A4%2C%22attempts%22%3A1%7D; notion_users=[%2220bd872b-594c-81a1-b249-0002d1feacbe%22]; _hjSessionUser_3664679=eyJpZCI6IjU1OThkY2MzLWJiNzItNTA5YS1hMDgyLTcwZTVmZTE0YWU1MiIsImNyZWF0ZWQiOjE3NDkzNTU4MzgyNDEsImV4aXN0aW5nIjp0cnVlfQ==; _cfuvid=jKt0witwH78x_tHSuwCsH7bTlG4MmLA2v3SaHDE.mpc-1749373022601-0.0.1.1-604800000; notion_locale=zh-CN/autodetect; token_v2=v03%3AeyJhbGciOiJkaXIiLCJraWQiOiJwcm9kdWN0aW9uOnRva2VuLXYzOjIwMjQtMTEtMDciLCJlbmMiOiJBMjU2Q0JDLUhTNTEyIn0..8cqt-fbGfogzRYZQ_svhuA.cdVPRcwnIvmJYlVtuuJx6Q8LO37JuPHfvnba08p6QLQERxmZ7TqTpGciFO_Krohj_iKFpGxvhAW9CoasH9--IDqpSvxhqxUi-CN1XoG7L6wjQI5KdNrzsMDb2C4_qkk8us4VdmAbfFHRfA0G317xJcyBWNj3T9N2aIkPru_Fd4raUoqjvWMFfSz_6qU-fN2SEM_IYDz1yFEBncErNPnRcCeBxvoGxoARCn-AP-7tBlLO6atw9NHA71a--Wu4xOjfkllB7UESw28T9kjwwU4Wz44RV4Jqec2udoD3f2AQOgG7yINoyDn8NnLIxoEsFVhcLDhBA0BxU-44NgqskmHdLdpcfM-aQARYWICDbgvcpXc.gLHW6mwrKXZRfvu0XGE43GwAmxEiNHjTi8WU_u8xkJI; _ga_9ZJ8CB186L=GS2.1.s1749373022$o2$g0$t1749373022$j60$l0$h0; _rdt_uuid=1749355834100.7a6ae1dc-56ed-4fae-a4da-03b2b79b51aa; __cf_bm=WdJeRHtNpyK6W1fzG.hy1eCituCRNXX66LiwYjQDMq4-1749373025-1.0.1.1-ozb75Fsi3DlqPljtK1hAM2jlC7KhTI6W8OxJ6TXFc2.rJAMOWSoyzZNwk4JHn6NeCY9VFvKfnPGXhsSGiz2KDrm1i7D6TcUIvNMu_Soy5dPcQIKCZXHdfY_qMihxUmEo; _hjSession_3664679=eyJpZCI6IjlhNGI5ODg2LTA3M2QtNGEwMC05ODdjLWU2ZWUwOWZkNDYzZiIsImMiOjE3NDkzNzMwMjMzMjksInMiOjAsInIiOjAsInNiIjowLCJzciI6MCwic2UiOjAsImZzIjowLCJzcCI6MX0=
+notion_browser_id=81aa048a-1a74-4fa6-bf68-9bd969fe0957; device_id=20cd872b-594c-818c-b13b-003bd4b64ce2; notion_check_cookie_consent=false; _gcl_au=1.1.1953388871.1749357888; _ga=GA1.1.60054060.1749357889; _fbp=fb.1.1749357890210.220600185514046487; csrf=1337709b-bdac-4940-9658-d701e789d5d5; notion_user_id=20cd872b-594c-8165-ac0f-000242d1ef5d; p_sync_session=%7B%22tokenId%22%3A%22v02%3Async_session%3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2LrwUqJv_xBJrZas5JL1uLu9h-MytbYGKknbSPCj2F07ufgzyXQaf88Md6GgLdbU23phhjGrzsbfn5gz2twcRiqEh8zg0ex9bAVt%22%2C%22userIds%22%3A%5B%2220cd872b-594c-8165-ac0f-000242d1ef5d%22%5D%7D; _cioid=20cd872b594c8165ac0f000242d1ef5d; notion_cookie_sync_completed=%7B%22completed%22%3Atrue%2C%22version%22%3A4%2C%22attempts%22%3A1%7D; NEXT_LOCALE=en-US; notion_users=[%2220cd872b-594c-8165-ac0f-000242d1ef5d%22]; _hjSessionUser_3664679=eyJpZCI6IjZhOWYyMTk2LTA4MTMtNTg0MS05MDJjLWFhYzc0YjljZjMyMyIsImNyZWF0ZWQiOjE3NDkzNTc4OTAyMDIsImV4aXN0aW5nIjp0cnVlfQ==; notion_locale=en-US/autodetect; token_v2=v03%3AeyJhbGciOiJkaXIiLCJraWQiOiJwcm9kdWN0aW9uOnRva2VuLXYzOjIwMjQtMTEtMDciLCJlbmMiOiJBMjU2Q0JDLUhTNTEyIn0..jacda0_C_ohrs8jZaEtaNQ.RhRp-HCDJiBVNeDX1_4rEV-GDnlWC6nPu-v5ft6xLqXd1VyWsQUGMyJfGNLE0WpYlMu1IPpdK6MFPWg5CWdyqssBXVOjq7RQ0HT1eD2vq3arymTP2Dr-yI4_MvVl68geC2Wf6WV2u6PGNTg0U9KfXDQku4zCE1Z-8NNmajOJLQVxrJRTd7jmTu9Y2tCsjQFmCwJIkM97nX49vVDF2D2jqCOXveKzBP-YUf5wHgAKirVCWVrRdzqpF7q99zMco6ud9kM0lwSYaR_LM0IxVBHXLqxWaSD6EevdtObI0mkzTKMdmO5KDkB79BbYAbGcCcruoqBnjUvP1_dgj40C1KRIj-AG8fmo0jlaY9ho9MPiCXI.55neTz3EAV_1mI_L48Ycm4g5ZEhqI3h-xx_VxH42eTY; _cfuvid=4RTSChhcZ3Ej_MnrypcZstukGvzsEw6.0aNyVeBZoGM-1749373079534-0.0.1.1-604800000; _ga_9ZJ8CB186L=GS2.1.s1749373078$o2$g0$t1749373078$j60$l0$h0; _rdt_uuid=1749357888777.49b9f069-6e3e-49a4-8616-02bf3cceab99; _hjSession_3664679=eyJpZCI6IjFhYzY0YTViLTlmODAtNDVkNC1hNjZlLTc1OGIzYTM4YjZkNCIsImMiOjE3NDkzNzMwNzgyODAsInMiOjAsInIiOjAsInNiIjowLCJzciI6MCwic2UiOjAsImZzIjowLCJzcCI6MH0=; __cf_bm=CwobhZNL_9339LZOPKM3_A0LzIn1ZI5LxHYvCsX_Az0-1749373080-1.0.1.1-diCnJXBwLMYQ8EPCllDnzKb56mGpO73GBCUqIQT3G_m7ouJ1np.4IaghLvovrt5ZeejVWgEzeqQ4OwU3vaMJbdvtYCTKs2p4tQh.kKjmSr26jQc0Gdui.ogY6stqUf11

package-lock.json

@@ -16,8 +16,10 @@
         "https-proxy-agent": "^7.0.2",
         "jsdom": "^22.1.0",
         "node-fetch": "^3.3.2",
-        "playwright": "^1.40.1",
-        "socks-proxy-agent": "^8.0.5"
+        "playwright": "^1.40.1"
+      },
+      "bin": {
+        "notion-cookie": "src/cookie-cli.js"
       },
       "devDependencies": {
         "nodemon": "^3.0.2"
@@ -996,18 +998,6 @@
       "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
       "license": "ISC"
     },
-    "node_modules/ip-address": {
-      "version": "9.0.5",
-      "resolved": "https://registry.npmjs.org/ip-address/-/ip-address-9.0.5.tgz",
-      "integrity": "sha512-zHtQzGojZXTwZTHQqra+ETKd4Sn3vgi7uBmlPoXVWZqYvuKmtI0l/VZTjqGmJY9x88GGOaZ9+G9ES8hC4T4X8g==",
-      "dependencies": {
-        "jsbn": "1.1.0",
-        "sprintf-js": "^1.1.3"
-      },
-      "engines": {
-        "node": ">= 12"
-      }
-    },
     "node_modules/ipaddr.js": {
       "version": "1.9.1",
       "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz",
@@ -1069,11 +1059,6 @@
       "integrity": "sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==",
       "license": "MIT"
     },
-    "node_modules/jsbn": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/jsbn/-/jsbn-1.1.0.tgz",
-      "integrity": "sha512-4bYVV3aAMtDTTu4+xsDYa6sy9GyJ69/amsu9sYF2zqjiEoZA5xJi3BrfX3uY+/IekIu7MwdObdbDWpoZdBv3/A=="
-    },
     "node_modules/jsdom": {
       "version": "22.1.0",
       "resolved": "https://registry.npmjs.org/jsdom/-/jsdom-22.1.0.tgz",
@@ -1790,67 +1775,6 @@
         "node": ">=10"
       }
     },
-    "node_modules/smart-buffer": {
-      "version": "4.2.0",
-      "resolved": "https://registry.npmjs.org/smart-buffer/-/smart-buffer-4.2.0.tgz",
-      "integrity": "sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==",
-      "engines": {
-        "node": ">= 6.0.0",
-        "npm": ">= 3.0.0"
-      }
-    },
-    "node_modules/socks": {
-      "version": "2.8.4",
-      "resolved": "https://registry.npmjs.org/socks/-/socks-2.8.4.tgz",
-      "integrity": "sha512-D3YaD0aRxR3mEcqnidIs7ReYJFVzWdd6fXJYUM8ixcQcJRGTka/b3saV0KflYhyVJXKhb947GndU35SxYNResQ==",
-      "dependencies": {
-        "ip-address": "^9.0.5",
-        "smart-buffer": "^4.2.0"
-      },
-      "engines": {
-        "node": ">= 10.0.0",
-        "npm": ">= 3.0.0"
-      }
-    },
-    "node_modules/socks-proxy-agent": {
-      "version": "8.0.5",
-      "resolved": "https://registry.npmjs.org/socks-proxy-agent/-/socks-proxy-agent-8.0.5.tgz",
-      "integrity": "sha512-HehCEsotFqbPW9sJ8WVYB6UbmIMv7kUUORIF2Nncq4VQvBfNBLibW9YZR5dlYCSUhwcD628pRllm7n+E+YTzJw==",
-      "dependencies": {
-        "agent-base": "^7.1.2",
-        "debug": "^4.3.4",
-        "socks": "^2.8.3"
-      },
-      "engines": {
-        "node": ">= 14"
-      }
-    },
-    "node_modules/socks-proxy-agent/node_modules/debug": {
-      "version": "4.4.1",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
-      "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
-      "dependencies": {
-        "ms": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=6.0"
-      },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/socks-proxy-agent/node_modules/ms": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
-      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="
-    },
-    "node_modules/sprintf-js": {
-      "version": "1.1.3",
-      "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.1.3.tgz",
-      "integrity": "sha512-Oo+0REFV59/rz3gfJNKQiBlwfHaSESl1pcGyABQsnnIfWOFt6JNj5gCog2U6MLZ//IGYD+nA8nI+mTShREReaA=="
-    },
     "node_modules/statuses": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz",

package.json

@@ -1,34 +1,37 @@
-{
-  "name": "notion2api-nodejs",
-  "version": "1.0.0",
-  "description": "Notion API client with lightweight browser-free option",
-  "main": "src/lightweight-client-express.js",
-  "type": "module",
-  "scripts": {
-    "start": "node src/lightweight-client-express.js",
-    "dev": "nodemon src/lightweight-client-express.js",
-    "original": "node src/index.js"
-  },
-  "keywords": [
-    "notion",
-    "openai",
-    "api",
-    "bridge"
-  ],
-  "author": "",
-  "license": "MIT",
-  "dependencies": {
-    "axios": "^1.9.0",
-    "chalk": "^4.1.2",
-    "dotenv": "^16.3.1",
-    "express": "^4.18.2",
-    "https-proxy-agent": "^7.0.2",
-    "jsdom": "^22.1.0",
-    "node-fetch": "^3.3.2",
-    "playwright": "^1.40.1",
-    "socks-proxy-agent": "^8.0.5"
-  },
-  "devDependencies": {
-    "nodemon": "^3.0.2"
-  }
-}
+{
+  "name": "notion2api-nodejs",
+  "version": "1.0.0",
+  "description": "Notion API client with lightweight browser-free option",
+  "main": "src/lightweight-client-express.js",
+  "type": "module",
+  "bin": {
+    "notion-cookie": "src/cookie-cli.js"
+  },
+  "scripts": {
+    "start": "node src/lightweight-client-express.js",
+    "dev": "nodemon src/lightweight-client-express.js",
+    "original": "node src/index.js",
+    "cookie": "node src/cookie-cli.js"
+  },
+  "keywords": [
+    "notion",
+    "openai",
+    "api",
+    "bridge"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^1.9.0",
+    "chalk": "^4.1.2",
+    "dotenv": "^16.3.1",
+    "express": "^4.18.2",
+    "https-proxy-agent": "^7.0.2",
+    "jsdom": "^22.1.0",
+    "node-fetch": "^3.3.2",
+    "playwright": "^1.40.1"
+  },
+  "devDependencies": {
+    "nodemon": "^3.0.2"
+  }
+}

proxy_server.log

@@ -1,141 +1,43 @@
-2025/06/07 22:39:46.565674 chrome_tls_proxy.go:706: Chrome TLS指纹代理服务器运行在 http://localhost:10655/proxy
-2025/06/07 22:39:46.581064 chrome_tls_proxy.go:707: 使用方法：向/proxy发送POST请求，请求体包含目标URL、方法、请求头和请求体
-2025/06/07 22:39:46.581064 chrome_tls_proxy.go:708: 支持流式响应，需要在请求体中添加 'stream': true
-2025/06/07 22:39:46.581064 chrome_tls_proxy.go:709: 已禁用速率限制：允许无限制请求
-2025/06/07 22:39:46.581064 chrome_tls_proxy.go:710: 已禁用并发限制：允许同一IP发起多个并发请求
-2025/06/07 22:39:46.581064 chrome_tls_proxy.go:711: 已强制使用IPv4连接，并使用8.8.8.8作为DNS服务器
-2025/06/07 22:39:46.581064 chrome_tls_proxy.go:712: 使用Chrome浏览器的TLS指纹进行连接
-2025/06/07 22:39:46.585274 chrome_tls_proxy.go:716: 服务器启动失败: listen tcp :10655: bind: Only one usage of each socket address (protocol/network address/port) is normally permitted.
-2025/06/07 22:40:34.956835 chrome_tls_proxy.go:706: Chrome TLS指纹代理服务器运行在 http://localhost:10655/proxy
-2025/06/07 22:40:34.982142 chrome_tls_proxy.go:707: 使用方法：向/proxy发送POST请求，请求体包含目标URL、方法、请求头和请求体
-2025/06/07 22:40:34.982142 chrome_tls_proxy.go:708: 支持流式响应，需要在请求体中添加 'stream': true
-2025/06/07 22:40:34.982142 chrome_tls_proxy.go:709: 已禁用速率限制：允许无限制请求
-2025/06/07 22:40:34.982142 chrome_tls_proxy.go:710: 已禁用并发限制：允许同一IP发起多个并发请求
-2025/06/07 22:40:34.982142 chrome_tls_proxy.go:711: 已强制使用IPv4连接，并使用8.8.8.8作为DNS服务器
-2025/06/07 22:40:34.982142 chrome_tls_proxy.go:712: 使用Chrome浏览器的TLS指纹进行连接
-2025/06/07 22:40:42.541508 chrome_tls_proxy.go:537: 处理流式请求: POST https://www.notion.so/api/v3/runInferenceTranscript
-2025/06/07 22:40:42.594747 chrome_tls_proxy.go:153: 成功解析域名: www.notion.so -> 198.18.0.48
-2025/06/07 22:40:42.594747 chrome_tls_proxy.go:187: 建立TCP连接到: www.notion.so:443 (IP: 198.18.0.48)
-2025/06/07 22:40:42.595977 chrome_tls_proxy.go:196: TCP连接成功建立到 198.18.0.48:443
-2025/06/07 22:40:43.212470 chrome_tls_proxy.go:214: TLS握手成功，使用Chrome指纹
-2025/06/07 22:40:43.212470 chrome_tls_proxy.go:218: 协商的协议: h2
-2025/06/07 22:40:43.213065 chrome_tls_proxy.go:222: 使用Chrome TLS指纹处理HTTP/2请求
-2025/06/07 22:40:50.606946 chrome_tls_proxy.go:606: 流式传输完成: POST https://www.notion.so/api/v3/runInferenceTranscript, 总计 5491 字节
-2025/06/07 22:41:28.720532 chrome_tls_proxy.go:706: Chrome TLS指纹代理服务器运行在 http://localhost:10655/proxy
-2025/06/07 22:41:28.733708 chrome_tls_proxy.go:707: 使用方法：向/proxy发送POST请求，请求体包含目标URL、方法、请求头和请求体
-2025/06/07 22:41:28.733708 chrome_tls_proxy.go:708: 支持流式响应，需要在请求体中添加 'stream': true
-2025/06/07 22:41:28.733708 chrome_tls_proxy.go:709: 已禁用速率限制：允许无限制请求
-2025/06/07 22:41:28.733708 chrome_tls_proxy.go:710: 已禁用并发限制：允许同一IP发起多个并发请求
-2025/06/07 22:41:28.733708 chrome_tls_proxy.go:711: 已强制使用IPv4连接，并使用8.8.8.8作为DNS服务器
-2025/06/07 22:41:28.733708 chrome_tls_proxy.go:712: 使用Chrome浏览器的TLS指纹进行连接
-2025/06/07 22:42:27.903516 chrome_tls_proxy.go:706: Chrome TLS指纹代理服务器运行在 http://localhost:10655/proxy
-2025/06/07 22:42:27.916172 chrome_tls_proxy.go:707: 使用方法：向/proxy发送POST请求，请求体包含目标URL、方法、请求头和请求体
-2025/06/07 22:42:27.916172 chrome_tls_proxy.go:708: 支持流式响应，需要在请求体中添加 'stream': true
-2025/06/07 22:42:27.916172 chrome_tls_proxy.go:709: 已禁用速率限制：允许无限制请求
-2025/06/07 22:42:27.916172 chrome_tls_proxy.go:710: 已禁用并发限制：允许同一IP发起多个并发请求
-2025/06/07 22:42:27.916172 chrome_tls_proxy.go:711: 已强制使用IPv4连接，并使用8.8.8.8作为DNS服务器
-2025/06/07 22:42:27.916172 chrome_tls_proxy.go:712: 使用Chrome浏览器的TLS指纹进行连接
-2025/06/07 22:43:04.738913 chrome_tls_proxy.go:706: Chrome TLS指纹代理服务器运行在 http://localhost:10655/proxy
-2025/06/07 22:43:04.755351 chrome_tls_proxy.go:707: 使用方法：向/proxy发送POST请求，请求体包含目标URL、方法、请求头和请求体
-2025/06/07 22:43:04.755866 chrome_tls_proxy.go:708: 支持流式响应，需要在请求体中添加 'stream': true
-2025/06/07 22:43:04.755866 chrome_tls_proxy.go:709: 已禁用速率限制：允许无限制请求
-2025/06/07 22:43:04.755866 chrome_tls_proxy.go:710: 已禁用并发限制：允许同一IP发起多个并发请求
-2025/06/07 22:43:04.755866 chrome_tls_proxy.go:711: 已强制使用IPv4连接，并使用8.8.8.8作为DNS服务器
-2025/06/07 22:43:04.755866 chrome_tls_proxy.go:712: 使用Chrome浏览器的TLS指纹进行连接
-2025/06/07 22:47:31.473790 chrome_tls_proxy.go:706: Chrome TLS指纹代理服务器运行在 http://localhost:10655/proxy
-2025/06/07 22:47:31.506810 chrome_tls_proxy.go:707: 使用方法：向/proxy发送POST请求，请求体包含目标URL、方法、请求头和请求体
-2025/06/07 22:47:31.506810 chrome_tls_proxy.go:708: 支持流式响应，需要在请求体中添加 'stream': true
-2025/06/07 22:47:31.506810 chrome_tls_proxy.go:709: 已禁用速率限制：允许无限制请求
-2025/06/07 22:47:31.506810 chrome_tls_proxy.go:710: 已禁用并发限制：允许同一IP发起多个并发请求
-2025/06/07 22:47:31.506810 chrome_tls_proxy.go:711: 已强制使用IPv4连接，并使用8.8.8.8作为DNS服务器
-2025/06/07 22:47:31.506810 chrome_tls_proxy.go:712: 使用Chrome浏览器的TLS指纹进行连接
-2025/06/07 22:47:34.873521 chrome_tls_proxy.go:537: 处理流式请求: POST https://www.notion.so/api/v3/runInferenceTranscript
-2025/06/07 22:47:34.893684 chrome_tls_proxy.go:153: 成功解析域名: www.notion.so -> 198.18.0.48
-2025/06/07 22:47:34.893684 chrome_tls_proxy.go:187: 建立TCP连接到: www.notion.so:443 (IP: 198.18.0.48)
-2025/06/07 22:47:34.894769 chrome_tls_proxy.go:196: TCP连接成功建立到 198.18.0.48:443
-2025/06/07 22:47:35.209971 chrome_tls_proxy.go:214: TLS握手成功，使用Chrome指纹
-2025/06/07 22:47:35.209971 chrome_tls_proxy.go:218: 协商的协议: h2
-2025/06/07 22:47:35.209971 chrome_tls_proxy.go:222: 使用Chrome TLS指纹处理HTTP/2请求
-2025/06/07 22:47:41.994124 chrome_tls_proxy.go:606: 流式传输完成: POST https://www.notion.so/api/v3/runInferenceTranscript, 总计 4791 字节
-2025/06/07 23:04:02.434223 chrome_tls_proxy.go:706: Chrome TLS指纹代理服务器运行在 http://localhost:10655/proxy
-2025/06/07 23:04:02.441993 chrome_tls_proxy.go:707: 使用方法：向/proxy发送POST请求，请求体包含目标URL、方法、请求头和请求体
-2025/06/07 23:04:02.441993 chrome_tls_proxy.go:708: 支持流式响应，需要在请求体中添加 'stream': true
-2025/06/07 23:04:02.441993 chrome_tls_proxy.go:709: 已禁用速率限制：允许无限制请求
-2025/06/07 23:04:02.441993 chrome_tls_proxy.go:710: 已禁用并发限制：允许同一IP发起多个并发请求
-2025/06/07 23:04:02.441993 chrome_tls_proxy.go:711: 已强制使用IPv4连接，并使用8.8.8.8作为DNS服务器
-2025/06/07 23:04:02.441993 chrome_tls_proxy.go:712: 使用Chrome浏览器的TLS指纹进行连接
-2025/06/07 23:08:08.021527 chrome_tls_proxy.go:706: Chrome TLS指纹代理服务器运行在 http://localhost:10655/proxy
-2025/06/07 23:08:08.026578 chrome_tls_proxy.go:707: 使用方法：向/proxy发送POST请求，请求体包含目标URL、方法、请求头和请求体
-2025/06/07 23:08:08.026578 chrome_tls_proxy.go:708: 支持流式响应，需要在请求体中添加 'stream': true
-2025/06/07 23:08:08.026578 chrome_tls_proxy.go:709: 已禁用速率限制：允许无限制请求
-2025/06/07 23:08:08.026578 chrome_tls_proxy.go:710: 已禁用并发限制：允许同一IP发起多个并发请求
-2025/06/07 23:08:08.026578 chrome_tls_proxy.go:711: 已强制使用IPv4连接，并使用8.8.8.8作为DNS服务器
-2025/06/07 23:08:08.026578 chrome_tls_proxy.go:712: 使用Chrome浏览器的TLS指纹进行连接
-2025/06/07 23:08:08.031126 chrome_tls_proxy.go:716: 服务器启动失败: listen tcp :10655: bind: Only one usage of each socket address (protocol/network address/port) is normally permitted.
-2025/06/07 23:08:33.883353 chrome_tls_proxy.go:706: Chrome TLS指纹代理服务器运行在 http://localhost:10655/proxy
-2025/06/07 23:08:33.887267 chrome_tls_proxy.go:707: 使用方法：向/proxy发送POST请求，请求体包含目标URL、方法、请求头和请求体
-2025/06/07 23:08:33.887267 chrome_tls_proxy.go:708: 支持流式响应，需要在请求体中添加 'stream': true
-2025/06/07 23:08:33.887267 chrome_tls_proxy.go:709: 已禁用速率限制：允许无限制请求
-2025/06/07 23:08:33.887267 chrome_tls_proxy.go:710: 已禁用并发限制：允许同一IP发起多个并发请求
-2025/06/07 23:08:33.887267 chrome_tls_proxy.go:711: 已强制使用IPv4连接，并使用8.8.8.8作为DNS服务器
-2025/06/07 23:08:33.887267 chrome_tls_proxy.go:712: 使用Chrome浏览器的TLS指纹进行连接
-2025/06/07 23:08:33.887941 chrome_tls_proxy.go:716: 服务器启动失败: listen tcp :10655: bind: Only one usage of each socket address (protocol/network address/port) is normally permitted.
-2025/06/07 23:09:49.976166 chrome_tls_proxy.go:706: Chrome TLS指纹代理服务器运行在 http://localhost:10655/proxy
-2025/06/07 23:09:49.981223 chrome_tls_proxy.go:707: 使用方法：向/proxy发送POST请求，请求体包含目标URL、方法、请求头和请求体
-2025/06/07 23:09:49.981223 chrome_tls_proxy.go:708: 支持流式响应，需要在请求体中添加 'stream': true
-2025/06/07 23:09:49.981223 chrome_tls_proxy.go:709: 已禁用速率限制：允许无限制请求
-2025/06/07 23:09:49.981223 chrome_tls_proxy.go:710: 已禁用并发限制：允许同一IP发起多个并发请求
-2025/06/07 23:09:49.981223 chrome_tls_proxy.go:711: 已强制使用IPv4连接，并使用8.8.8.8作为DNS服务器
-2025/06/07 23:09:49.981223 chrome_tls_proxy.go:712: 使用Chrome浏览器的TLS指纹进行连接
-2025/06/07 23:49:46.540100 chrome_tls_proxy.go:706: Chrome TLS指纹代理服务器运行在 http://localhost:10655/proxy
-2025/06/07 23:49:46.545351 chrome_tls_proxy.go:707: 使用方法：向/proxy发送POST请求，请求体包含目标URL、方法、请求头和请求体
-2025/06/07 23:49:46.545351 chrome_tls_proxy.go:708: 支持流式响应，需要在请求体中添加 'stream': true
-2025/06/07 23:49:46.545351 chrome_tls_proxy.go:709: 已禁用速率限制：允许无限制请求
-2025/06/07 23:49:46.545351 chrome_tls_proxy.go:710: 已禁用并发限制：允许同一IP发起多个并发请求
-2025/06/07 23:49:46.545351 chrome_tls_proxy.go:711: 已强制使用IPv4连接，并使用8.8.8.8作为DNS服务器
-2025/06/07 23:49:46.545351 chrome_tls_proxy.go:712: 使用Chrome浏览器的TLS指纹进行连接
-2025/06/07 23:49:46.545880 chrome_tls_proxy.go:716: 服务器启动失败: listen tcp :10655: bind: Only one usage of each socket address (protocol/network address/port) is normally permitted.
-2025/06/07 23:50:04.636504 chrome_tls_proxy.go:706: Chrome TLS指纹代理服务器运行在 http://localhost:10655/proxy
-2025/06/07 23:50:04.640668 chrome_tls_proxy.go:707: 使用方法：向/proxy发送POST请求，请求体包含目标URL、方法、请求头和请求体
-2025/06/07 23:50:04.640668 chrome_tls_proxy.go:708: 支持流式响应，需要在请求体中添加 'stream': true
-2025/06/07 23:50:04.640668 chrome_tls_proxy.go:709: 已禁用速率限制：允许无限制请求
-2025/06/07 23:50:04.640668 chrome_tls_proxy.go:710: 已禁用并发限制：允许同一IP发起多个并发请求
-2025/06/07 23:50:04.640668 chrome_tls_proxy.go:711: 已强制使用IPv4连接，并使用8.8.8.8作为DNS服务器
-2025/06/07 23:50:04.640668 chrome_tls_proxy.go:712: 使用Chrome浏览器的TLS指纹进行连接
-2025/06/08 00:44:51.400537 chrome_tls_proxy.go:706: Chrome TLS指纹代理服务器运行在 http://localhost:10655/proxy
-2025/06/08 00:44:51.408056 chrome_tls_proxy.go:707: 使用方法：向/proxy发送POST请求，请求体包含目标URL、方法、请求头和请求体
-2025/06/08 00:44:51.408056 chrome_tls_proxy.go:708: 支持流式响应，需要在请求体中添加 'stream': true
-2025/06/08 00:44:51.408056 chrome_tls_proxy.go:709: 已禁用速率限制：允许无限制请求
-2025/06/08 00:44:51.408056 chrome_tls_proxy.go:710: 已禁用并发限制：允许同一IP发起多个并发请求
-2025/06/08 00:44:51.408056 chrome_tls_proxy.go:711: 已强制使用IPv4连接，并使用8.8.8.8作为DNS服务器
-2025/06/08 00:44:51.408056 chrome_tls_proxy.go:712: 使用Chrome浏览器的TLS指纹进行连接
-2025/06/08 00:45:24.831086 chrome_tls_proxy.go:706: Chrome TLS指纹代理服务器运行在 http://localhost:10655/proxy
-2025/06/08 00:45:24.838018 chrome_tls_proxy.go:707: 使用方法：向/proxy发送POST请求，请求体包含目标URL、方法、请求头和请求体
-2025/06/08 00:45:24.838018 chrome_tls_proxy.go:708: 支持流式响应，需要在请求体中添加 'stream': true
-2025/06/08 00:45:24.838018 chrome_tls_proxy.go:709: 已禁用速率限制：允许无限制请求
-2025/06/08 00:45:24.838018 chrome_tls_proxy.go:710: 已禁用并发限制：允许同一IP发起多个并发请求
-2025/06/08 00:45:24.838018 chrome_tls_proxy.go:711: 已强制使用IPv4连接，并使用8.8.8.8作为DNS服务器
-2025/06/08 00:45:24.838018 chrome_tls_proxy.go:712: 使用Chrome浏览器的TLS指纹进行连接
-2025/06/08 00:47:10.787309 chrome_tls_proxy.go:706: Chrome TLS指纹代理服务器运行在 http://localhost:10655/proxy
-2025/06/08 00:47:10.791530 chrome_tls_proxy.go:707: 使用方法：向/proxy发送POST请求，请求体包含目标URL、方法、请求头和请求体
-2025/06/08 00:47:10.791530 chrome_tls_proxy.go:708: 支持流式响应，需要在请求体中添加 'stream': true
-2025/06/08 00:47:10.791530 chrome_tls_proxy.go:709: 已禁用速率限制：允许无限制请求
-2025/06/08 00:47:10.791530 chrome_tls_proxy.go:710: 已禁用并发限制：允许同一IP发起多个并发请求
-2025/06/08 00:47:10.791530 chrome_tls_proxy.go:711: 已强制使用IPv4连接，并使用8.8.8.8作为DNS服务器
-2025/06/08 00:47:10.791530 chrome_tls_proxy.go:712: 使用Chrome浏览器的TLS指纹进行连接
-2025/06/08 00:47:10.792061 chrome_tls_proxy.go:716: 服务器启动失败: listen tcp :10655: bind: Only one usage of each socket address (protocol/network address/port) is normally permitted.
-2025/06/08 00:54:49.318617 chrome_tls_proxy.go:706: Chrome TLS指纹代理服务器运行在 http://localhost:10655/proxy
-2025/06/08 00:54:49.325299 chrome_tls_proxy.go:707: 使用方法：向/proxy发送POST请求，请求体包含目标URL、方法、请求头和请求体
-2025/06/08 00:54:49.325299 chrome_tls_proxy.go:708: 支持流式响应，需要在请求体中添加 'stream': true
-2025/06/08 00:54:49.325299 chrome_tls_proxy.go:709: 已禁用速率限制：允许无限制请求
-2025/06/08 00:54:49.325299 chrome_tls_proxy.go:710: 已禁用并发限制：允许同一IP发起多个并发请求
-2025/06/08 00:54:49.325299 chrome_tls_proxy.go:711: 已强制使用IPv4连接，并使用8.8.8.8作为DNS服务器
-2025/06/08 00:54:49.325299 chrome_tls_proxy.go:712: 使用Chrome浏览器的TLS指纹进行连接
-2025/06/08 00:54:49.325813 chrome_tls_proxy.go:716: 服务器启动失败: listen tcp :10655: bind: Only one usage of each socket address (protocol/network address/port) is normally permitted.
-2025/06/08 19:06:11.117107 chrome_tls_proxy.go:706: Chrome TLS指纹代理服务器运行在 http://localhost:10655/proxy
-2025/06/08 19:06:11.123148 chrome_tls_proxy.go:707: 使用方法：向/proxy发送POST请求，请求体包含目标URL、方法、请求头和请求体
-2025/06/08 19:06:11.123148 chrome_tls_proxy.go:708: 支持流式响应，需要在请求体中添加 'stream': true
-2025/06/08 19:06:11.123148 chrome_tls_proxy.go:709: 已禁用速率限制：允许无限制请求
-2025/06/08 19:06:11.123148 chrome_tls_proxy.go:710: 已禁用并发限制：允许同一IP发起多个并发请求
-2025/06/08 19:06:11.123148 chrome_tls_proxy.go:711: 已强制使用IPv4连接，并使用8.8.8.8作为DNS服务器
-2025/06/08 19:06:11.123148 chrome_tls_proxy.go:712: 使用Chrome浏览器的TLS指纹进行连接
+2025/06/09 12:18:12.836692 chrome_tls_proxy.go:706: Chrome TLS指纹代理服务器运行在 http://localhost:10655/proxy
+2025/06/09 12:18:12.841349 chrome_tls_proxy.go:707: 使用方法：向/proxy发送POST请求，请求体包含目标URL、方法、请求头和请求体
+2025/06/09 12:18:12.841349 chrome_tls_proxy.go:708: 支持流式响应，需要在请求体中添加 'stream': true
+2025/06/09 12:18:12.841349 chrome_tls_proxy.go:709: 已禁用速率限制：允许无限制请求
+2025/06/09 12:18:12.841349 chrome_tls_proxy.go:710: 已禁用并发限制：允许同一IP发起多个并发请求
+2025/06/09 12:18:12.841349 chrome_tls_proxy.go:711: 已强制使用IPv4连接，并使用8.8.8.8作为DNS服务器
+2025/06/09 12:18:12.841349 chrome_tls_proxy.go:712: 使用Chrome浏览器的TLS指纹进行连接
+2025/06/09 12:20:28.077805 chrome_tls_proxy.go:706: Chrome TLS指纹代理服务器运行在 http://localhost:10655/proxy
+2025/06/09 12:20:28.082498 chrome_tls_proxy.go:707: 使用方法：向/proxy发送POST请求，请求体包含目标URL、方法、请求头和请求体
+2025/06/09 12:20:28.082498 chrome_tls_proxy.go:708: 支持流式响应，需要在请求体中添加 'stream': true
+2025/06/09 12:20:28.082498 chrome_tls_proxy.go:709: 已禁用速率限制：允许无限制请求
+2025/06/09 12:20:28.082498 chrome_tls_proxy.go:710: 已禁用并发限制：允许同一IP发起多个并发请求
+2025/06/09 12:20:28.082498 chrome_tls_proxy.go:711: 已强制使用IPv4连接，并使用8.8.8.8作为DNS服务器
+2025/06/09 12:20:28.082498 chrome_tls_proxy.go:712: 使用Chrome浏览器的TLS指纹进行连接
+2025/06/09 12:21:16.376141 chrome_tls_proxy.go:706: Chrome TLS指纹代理服务器运行在 http://localhost:10655/proxy
+2025/06/09 12:21:16.382812 chrome_tls_proxy.go:707: 使用方法：向/proxy发送POST请求，请求体包含目标URL、方法、请求头和请求体
+2025/06/09 12:21:16.382812 chrome_tls_proxy.go:708: 支持流式响应，需要在请求体中添加 'stream': true
+2025/06/09 12:21:16.382812 chrome_tls_proxy.go:709: 已禁用速率限制：允许无限制请求
+2025/06/09 12:21:16.382812 chrome_tls_proxy.go:710: 已禁用并发限制：允许同一IP发起多个并发请求
+2025/06/09 12:21:16.382812 chrome_tls_proxy.go:711: 已强制使用IPv4连接，并使用8.8.8.8作为DNS服务器
+2025/06/09 12:21:16.382812 chrome_tls_proxy.go:712: 使用Chrome浏览器的TLS指纹进行连接
+2025/06/09 12:22:43.593498 chrome_tls_proxy.go:706: Chrome TLS指纹代理服务器运行在 http://localhost:10655/proxy
+2025/06/09 12:22:43.597928 chrome_tls_proxy.go:707: 使用方法：向/proxy发送POST请求，请求体包含目标URL、方法、请求头和请求体
+2025/06/09 12:22:43.597928 chrome_tls_proxy.go:708: 支持流式响应，需要在请求体中添加 'stream': true
+2025/06/09 12:22:43.597928 chrome_tls_proxy.go:709: 已禁用速率限制：允许无限制请求
+2025/06/09 12:22:43.597928 chrome_tls_proxy.go:710: 已禁用并发限制：允许同一IP发起多个并发请求
+2025/06/09 12:22:43.597928 chrome_tls_proxy.go:711: 已强制使用IPv4连接，并使用8.8.8.8作为DNS服务器
+2025/06/09 12:22:43.597928 chrome_tls_proxy.go:712: 使用Chrome浏览器的TLS指纹进行连接
+2025/06/09 12:23:33.082331 chrome_tls_proxy.go:706: Chrome TLS指纹代理服务器运行在 http://localhost:10655/proxy
+2025/06/09 12:23:33.087347 chrome_tls_proxy.go:707: 使用方法：向/proxy发送POST请求，请求体包含目标URL、方法、请求头和请求体
+2025/06/09 12:23:33.087347 chrome_tls_proxy.go:708: 支持流式响应，需要在请求体中添加 'stream': true
+2025/06/09 12:23:33.087347 chrome_tls_proxy.go:709: 已禁用速率限制：允许无限制请求
+2025/06/09 12:23:33.087347 chrome_tls_proxy.go:710: 已禁用并发限制：允许同一IP发起多个并发请求
+2025/06/09 12:23:33.087347 chrome_tls_proxy.go:711: 已强制使用IPv4连接，并使用8.8.8.8作为DNS服务器
+2025/06/09 12:23:33.087347 chrome_tls_proxy.go:712: 使用Chrome浏览器的TLS指纹进行连接
+2025/06/09 12:24:37.277389 chrome_tls_proxy.go:537: 处理流式请求: POST https://www.notion.so/api/v3/runInferenceTranscript
+2025/06/09 12:24:37.317968 chrome_tls_proxy.go:153: 成功解析域名: www.notion.so -> 198.18.0.63
+2025/06/09 12:24:37.317968 chrome_tls_proxy.go:187: 建立TCP连接到: www.notion.so:443 (IP: 198.18.0.63)
+2025/06/09 12:24:37.319157 chrome_tls_proxy.go:196: TCP连接成功建立到 198.18.0.63:443
+2025/06/09 12:24:38.271929 chrome_tls_proxy.go:214: TLS握手成功，使用Chrome指纹
+2025/06/09 12:24:38.271929 chrome_tls_proxy.go:218: 协商的协议: h2
+2025/06/09 12:24:38.273041 chrome_tls_proxy.go:222: 使用Chrome TLS指纹处理HTTP/2请求
+2025/06/09 12:25:14.238223 chrome_tls_proxy.go:606: 流式传输完成: POST https://www.notion.so/api/v3/runInferenceTranscript, 总计 31669 字节

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/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

@@ -4,7 +4,6 @@ import { randomUUID } from 'crypto';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 import chalk from 'chalk';
-import fetch from 'node-fetch';
 import {
   ChatMessage, ChatCompletionRequest, Choice, ChoiceDelta, ChatCompletionChunk
 } from './models.js';
@@ -12,9 +11,10 @@ import {
   initialize,
   streamNotionResponse,
   buildNotionRequest,
-  FETCHED_IDS_SUCCESSFULLY
+  INITIALIZED_SUCCESSFULLY
 } from './lightweight-client.js';
 import { proxyPool } from './ProxyPool.js';
+import { cookieManager } from './CookieManager.js';
 
 // 获取当前文件的目录路径
 const __filename = fileURLToPath(import.meta.url);
@@ -23,10 +23,6 @@ const __dirname = dirname(__filename);
 // 加载环境变量
 dotenv.config({ path: join(dirname(__dirname), '.env') });
 
-// 用户邮箱信息
-let userEmails = [];
-let currentEmailIndex = 0;
-
 // 日志配置
 const logger = {
   info: (message) => console.log(chalk.blue(`[info] ${message}`)),
@@ -67,71 +63,6 @@ app.use((req, res, next) => {
   next();
 });
 
-// 获取用户邮箱信息
-async function fetchUserEmails() {
-  logger.info('开始获取用户邮箱信息...');
-  
-  const cookies = process.env.NOTION_COOKIE;
-  if (!cookies) {
-    logger.error('未设置 NOTION_COOKIE 环境变量，无法获取用户邮箱信息');
-    return [];
-  }
-  
-  const cookiePairs = cookies.split('|');
-  const emails = [];
-  
-  for (let i = 0; i < cookiePairs.length; i++) {
-    try {
-      const cookie = cookiePairs[i].trim();
-      const response = await fetch("https://www.notion.so/api/v3/getUserAnalyticsSettings", {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'accept': '*/*',
-          'accept-language': 'en-US,en;q=0.9,zh-CN;q=0.8,zh;q=0.7',
-          'notion-audit-log-platform': 'web',
-          'notion-client-version': '23.13.0.3799',
-          'cookie': cookie
-        },
-        body: '{}'
-      });
-      
-      if (response.ok) {
-        const data = await response.json();
-        if (data && data.user_email) {
-          emails.push({
-            email: data.user_email,
-            name: data.user_name || '未知用户',
-            cookie: cookie
-          });
-          logger.success(`获取到账号信息: ${data.user_email} (${data.user_name || '未知用户'})`);
-        } else {
-          logger.warning(`无法从 Notion API 响应中获取用户邮箱信息 (cookie ${i+1})`);
-        }
-      } else {
-        logger.warning(`Notion API 请求失败，状态码: ${response.status} (cookie ${i+1})`);
-      }
-    } catch (error) {
-      logger.error(`获取用户邮箱时出错 (cookie ${i+1}): ${error.message}`);
-    }
-  }
-  
-  logger.info(`共获取到 ${emails.length} 个用户账号信息`);
-  return emails;
-}
-
-// 获取当前使用的邮箱信息
-function getCurrentEmail() {
-  if (userEmails.length === 0) {
-    return null;
-  }
-  
-  const email = userEmails[currentEmailIndex];
-  // 轮询到下一个邮箱
-  currentEmailIndex = (currentEmailIndex + 1) % userEmails.length;
-  return email;
-}
-
 // 认证中间件
 function authenticate(req, res, next) {
   const authHeader = req.headers.authorization;
@@ -179,22 +110,24 @@ app.get('/v1/models', authenticate, (req, res) => {
 // 聊天完成端点
 app.post('/v1/chat/completions', authenticate, async (req, res) => {
   try {
-    // 检查是否成功获取Notion ID
-    if (!FETCHED_IDS_SUCCESSFULLY) {
+    // 检查是否成功初始化
+    if (!INITIALIZED_SUCCESSFULLY) {
       return res.status(500).json({
         error: {
-          message: "Notion ID获取失败。请检查您的NOTION_COOKIE是否有效，或者手动设置NOTION_SPACE_ID和NOTION_ACTIVE_USER_HEADER。",
+          message: "系统未成功初始化。请检查您的NOTION_COOKIE是否有效。",
           type: "server_error"
         }
       });
     }
     
-    // 获取当前使用的邮箱信息并打印
-    const emailInfo = getCurrentEmail();
-    if (emailInfo) {
-      logger.info(`本次调用使用账号: ${emailInfo.email} (${emailInfo.name})`);
-    } else {
-      logger.warning('未能获取到用户邮箱信息，无法显示当前使用的账号');
+    // 检查是否有可用的cookie
+    if (cookieManager.getValidCount() === 0) {
+      return res.status(500).json({
+        error: {
+          message: "没有可用的有效cookie。请检查您的NOTION_COOKIE配置。",
+          type: "server_error"
+        }
+      });
     }
     
     // 验证请求数据
@@ -209,6 +142,9 @@ app.post('/v1/chat/completions', authenticate, async (req, res) => {
       });
     }
     
+    // 构建Notion请求
+    const notionRequestBody = buildNotionRequest(requestData);
+    
     // 处理流式响应
     if (requestData.stream) {
       res.setHeader('Content-Type', 'text/event-stream');
@@ -216,7 +152,7 @@ app.post('/v1/chat/completions', authenticate, async (req, res) => {
       res.setHeader('Connection', 'keep-alive');
       
       logger.info(`开始流式响应`);
-      const stream = await streamNotionResponse(requestData);
+      const stream = await streamNotionResponse(notionRequestBody);
       stream.pipe(res);
       
       // 处理客户端断开连接
@@ -228,7 +164,7 @@ app.post('/v1/chat/completions', authenticate, async (req, res) => {
       // 创建一个内部流来收集完整响应
       logger.info(`开始非流式响应`);
       const chunks = [];
-      const stream = await streamNotionResponse(requestData);
+      const stream = await streamNotionResponse(notionRequestBody);
       
       return new Promise((resolve, reject) => {
         stream.on('data', (chunk) => {
@@ -297,7 +233,16 @@ app.get('/health', (req, res) => {
   res.json({
     status: 'ok',
     timestamp: new Date().toISOString(),
-    notion_ids_fetched: FETCHED_IDS_SUCCESSFULLY
+    initialized: INITIALIZED_SUCCESSFULLY,
+    valid_cookies: cookieManager.getValidCount()
+  });
+});
+
+// Cookie状态查询端点
+app.get('/cookies/status', authenticate, (req, res) => {
+  res.json({
+    total_cookies: cookieManager.getValidCount(),
+    cookies: cookieManager.getStatus()
   });
 });
 
@@ -305,34 +250,20 @@ app.get('/health', (req, res) => {
 const PORT = process.env.PORT || 7860;
 
 // 初始化并启动服务器
-initialize()
-  .then(() => fetchUserEmails())
-  .then((emails) => {
-    userEmails = emails;
-    return app.listen(PORT);
-  })
-  .then(() => {
+initialize().then(() => {
+  app.listen(PORT, () => {
     logger.info(`服务已启动 - 端口: ${PORT}`);
     logger.info(`访问地址: http://localhost:${PORT}`);
     
-    if (FETCHED_IDS_SUCCESSFULLY) {
-      logger.success(`Notion可用状态: ✅`);
-    } else {
-      logger.warning(`Notion可用状态: ❌`);
-      logger.warning(`警告: Notion ID未成功获取，API调用将无法正常工作`);
-      logger.warning(`请检查NOTION_COOKIE配置或手动设置NOTION_SPACE_ID和NOTION_ACTIVE_USER_HEADER`);
-    }
-    
-    if (userEmails.length > 0) {
-      logger.success(`邮箱账号状态: ✅ (共 ${userEmails.length} 个账号)`);
-      userEmails.forEach((email, index) => {
-        logger.info(`账号 ${index + 1}: ${email.email} (${email.name})`);
-      });
+    if (INITIALIZED_SUCCESSFULLY) {
+      logger.success(`系统初始化状态: ✅`);
+      logger.success(`可用cookie数量: ${cookieManager.getValidCount()}`);
     } else {
-      logger.warning(`邮箱账号状态: ❌`);
-      logger.warning(`警告: 未能获取到任何用户邮箱信息`);
+      logger.warning(`系统初始化状态: ❌`);
+      logger.warning(`警告: 系统未成功初始化，API调用将无法正常工作`);
+      logger.warning(`请检查NOTION_COOKIE配置是否有效`);
     }
-  })
-  .catch((error) => {
-    logger.error(`初始化失败: ${error}`);
-  }); 
+  });
+}).catch((error) => {
+  logger.error(`初始化失败: ${error}`);
+}); 

src/lightweight-client.js

@@ -7,12 +7,14 @@ import { dirname, join } from 'path';
 import { PassThrough } from 'stream';
 import chalk from 'chalk';
 import {
-  ChatMessage, ChatCompletionRequest, NotionTranscriptConfigValue,
+  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);
@@ -30,26 +32,17 @@ const logger = {
 
 // 配置
 const NOTION_API_URL = "https://www.notion.so/api/v3/runInferenceTranscript";
-let NOTION_COOKIES = [];
-let NOTION_SPACE_IDS = {};
-let NOTION_USER_IDS = {};
-let currentCookieIndex = 0;
-
-let NOTION_COOKIE = '';
-let NOTION_SPACE_ID = process.env.NOTION_SPACE_ID;
-let FETCHED_NOTION_USER_ID = process.env.NOTION_ACTIVE_USER_HEADER;
+// 这些变量将由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;
-let isMoreThanOne = false;
-let index = 0;
-
 
 // 代理配置
 const PROXY_URL = process.env.PROXY_URL || "";
 
-// 标记是否成功获取ID
-let FETCHED_IDS_SUCCESSFULLY = false;
+// 标记是否成功初始化
+let INITIALIZED_SUCCESSFULLY = false;
 
 // 注册进程退出事件，确保代理服务器在程序退出时关闭
 process.on('exit', () => {
@@ -77,241 +70,16 @@ process.on('exit', () => {
   });
 });
 
-function getCookie() {
-  if (NOTION_COOKIES.length === 0) {
-    return '';
-  }
-  const cookie = NOTION_COOKIES[currentCookieIndex];
-  currentCookieIndex = (currentCookieIndex + 1) % NOTION_COOKIES.length;
-  return cookie;
-}
-
-// 添加一个通用的cookie解析函数
-function parseCookiesFromString(cookieString, logPrefix = "") {
-  const cookiesToAdd = {};
-  
-  if (!cookieString || typeof cookieString !== 'string') {
-    logger.error(`${logPrefix}Invalid cookie string provided`);
-    return cookiesToAdd;
-  }
-  
-  // 按分号分割cookie字符串
-  const cookiePairs = cookieString.split(';');
-  logger.info(`${logPrefix}Parsing ${cookiePairs.length} cookie pairs`);
-  
-  for (let i = 0; i < cookiePairs.length; i++) {
-    try {
-      const pair = cookiePairs[i].trim();
-      if (!pair) continue;
-      
-      // 查找第一个等号的位置
-      const firstEqualPos = pair.indexOf('=');
-      if (firstEqualPos <= 0) {
-        logger.warning(`${logPrefix}Skipping invalid cookie pair: ${pair}`);
-        continue;
-      }
-      
-      // 分割名称和值
-      const name = pair.substring(0, firstEqualPos).trim();
-      const value = pair.substring(firstEqualPos + 1).trim();
-      
-      if (!name || !value) {
-        logger.warning(`${logPrefix}Skipping cookie with empty name or value: ${pair}`);
-        continue;
-      }
-      
-      logger.info(`${logPrefix}Parsed cookie: ${name} (length: ${value.length})`);
-      
-      cookiesToAdd[name] = value;
-    } catch (cookieError) {
-      logger.warning(`${logPrefix}Error parsing cookie pair at index ${i}: ${cookieError}`);
-    }
-  }
-  
-  logger.info(`${logPrefix}Successfully parsed ${Object.keys(cookiesToAdd).length} cookies`);
-  return cookiesToAdd;
-}
-
-// 获取Notion空间ID和用户ID
-async function fetchAndSetNotionIds(cookie) {
-  if (!cookie) {
-    logger.error(`无法获取Notion ID: 未设置NOTION_COOKIE`);
-    FETCHED_IDS_SUCCESSFULLY = false;
-    return;
-  }
-
-  try {
-    logger.info(`正在设置JSDOM环境...`);
-    
-    // 创建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;
-    
-    // 使用更安全的方式设置全局对象
-    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 = 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 (PROXY_URL) {
-      const { HttpsProxyAgent } = await import('https-proxy-agent');
-      fetchOptions.agent = new HttpsProxyAgent(PROXY_URL);
-      logger.info(`使用代理: ${PROXY_URL}`);
-    }
-    logger.info(`正在获取Notion用户/空间ID...`);
-    
-    // 发送请求
-    const response = await fetch("https://www.notion.so/api/v3/getSpaces", fetchOptions);
-    
-    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) {
-      logger.error(`无法从响应中提取用户ID`);
-      FETCHED_IDS_SUCCESSFULLY = false;
-      return;
-    }
-    
-    FETCHED_NOTION_USER_ID = userIdKey;
-    logger.success(`已获取Notion用户ID`);
-    
-    // 提取空间ID
-    const userRoot = data[userIdKey]?.user_root?.[userIdKey];
-    const spaceViewPointers = userRoot?.value?.value?.space_view_pointers;
-    
-    if (spaceViewPointers && Array.isArray(spaceViewPointers) && spaceViewPointers.length > 0) {
-      NOTION_SPACE_ID = spaceViewPointers[0].spaceId;
-      
-      if (NOTION_SPACE_ID) {
-        logger.success(`已获取Notion空间ID`);
-        FETCHED_IDS_SUCCESSFULLY = true;
-      } else {
-        logger.error(`无法从space_view_pointers中提取spaceId`);
-        FETCHED_IDS_SUCCESSFULLY = false;
-      }
-    } else {
-      logger.error(`在响应中找不到space_view_pointers或spaceId`);
-      FETCHED_IDS_SUCCESSFULLY = false;
-    }
-    
-    // 清理全局对象
-    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}`);
-    }
-    
-    return { spaceId: NOTION_SPACE_ID, userId: userIdKey };
-  } catch (error) {
-    logger.error(`获取Notion ID时出错: ${error}`);
-    FETCHED_IDS_SUCCESSFULLY = false;
-    
-    // 确保清理全局对象
-    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}`);
+// 构建Notion请求
+function buildNotionRequest(requestData) {
+  // 确保我们有当前的cookie数据
+  if (!currentCookieData) {
+    currentCookieData = cookieManager.getNext();
+    if (!currentCookieData) {
+      throw new Error('没有可用的cookie');
     }
   }
-}
 
-// 构建Notion请求
-function buildNotionRequest(requestData, userId, spaceId) {
   // 当前时间
   const now = new Date();
   // 格式化为ISO字符串，确保包含毫秒和时区
@@ -346,8 +114,8 @@ function buildNotionRequest(requestData, userId, spaceId) {
   transcript.push(new NotionTranscriptItem({
     type: "context",
     value: new NotionTranscriptContextValue({
-      userId: userId,
-      spaceId: spaceId,
+      userId: currentCookieData.userId,
+      spaceId: currentCookieData.spaceId,
       surface: "home_module",
       timezone: "America/Los_Angeles",
       userName: userName,
@@ -387,7 +155,7 @@ function buildNotionRequest(requestData, userId, spaceId) {
       transcript.push(new NotionTranscriptItemByuser({
         type: "user",
         value: [[content]],
-        userId: userId,
+        userId: currentCookieData.userId,
         createdAt: message.createdAt || isoString
       }));
     } else if (message.role === "user") {
@@ -395,7 +163,7 @@ function buildNotionRequest(requestData, userId, spaceId) {
       transcript.push(new NotionTranscriptItemByuser({
         type: "user",
         value: [[content]],
-        userId: userId,
+        userId: currentCookieData.userId,
         createdAt: message.createdAt || isoString
       }));
     } else if (message.role === "assistant") {
@@ -411,7 +179,7 @@ function buildNotionRequest(requestData, userId, spaceId) {
   
   // 创建请求体
   return new NotionRequestBody({
-    spaceId: spaceId,
+    spaceId: currentCookieData.spaceId,
     transcript: transcript,
     createThread: true,
     traceId: randomUUID(),
@@ -426,52 +194,89 @@ function buildNotionRequest(requestData, userId, spaceId) {
 }
 
 // 流式处理Notion响应
-async function streamNotionResponse(requestData) {
-  const chunkQueue = new PassThrough();
-  let timeoutId = null;
-
-  try {
-    // 动态获取cookie并查找其对应的ID
-    const currentCookie = getCookie();
-    if (!currentCookie) {
-      throw new Error("无法获取 Notion cookie，请检查配置");
+async function streamNotionResponse(notionRequestBody) {
+  // 确保我们有当前的cookie数据
+  if (!currentCookieData) {
+    currentCookieData = cookieManager.getNext();
+    if (!currentCookieData) {
+      throw new Error('没有可用的cookie');
     }
-    const userId = NOTION_USER_IDS[currentCookie];
-    const spaceId = NOTION_SPACE_IDS[currentCookie];
+  }
 
-    if (!userId || !spaceId) {
-      throw new Error(`无法找到 cookie ...${currentCookie.slice(-10)} 对应的ID`);
+  // 创建流
+  const stream = new PassThrough();
+  
+  // 添加初始数据，确保连接建立
+  stream.write(':\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"
+          })
+        ]
+      });
+      stream.write(`data: ${JSON.stringify(endChunk)}\n\n`);
+      stream.write('data: [DONE]\n\n');
+      stream.end();
+    } catch (error) {
+      logger.error(`发送超时消息时出错: ${error}`);
+      stream.end();
     }
-
-    // 使用正确的ID构建请求体
-    const notionRequestBody = buildNotionRequest(requestData, userId, spaceId);
-    
-    // 设置请求头
-    const headers = {
-      'Content-Type': 'application/json',
-      'Cookie': currentCookie,
-      'x-notion-active-user-header': userId,
-      "accept": "application/json",
-      "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"
-    };
+  }, 30000); // 30秒超时
+  
+  // 启动fetch处理
+  fetchNotionResponse(
+    stream,
+    notionRequestBody,
+    headers,
+    NOTION_API_URL,
+    currentCookieData.cookie,
+    timeoutId
+  ).catch((error) => {
+    logger.error(`流处理出错: ${error}`);
+    clearTimeout(timeoutId);  // 清除超时计时器
     
-    fetchNotionResponse(chunkQueue, notionRequestBody, headers, NOTION_API_URL, currentCookie, timeoutId);
-  } catch (error) {
-    logger.error(`streamNotionResponse 错误: ${error}`);
-    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');
-    chunkQueue.end();
-  }
-
-  return chunkQueue;
+    try {
+      // 发送错误消息
+      const errorChunk = new ChatCompletionChunk({
+        choices: [
+          new Choice({
+            delta: new ChoiceDelta({ content: `处理请求时出错: ${error.message}` }),
+            finish_reason: "error"
+          })
+        ]
+      });
+      stream.write(`data: ${JSON.stringify(errorChunk)}\n\n`);
+      stream.write('data: [DONE]\n\n');
+    } catch (e) {
+      logger.error(`发送错误���息时出错: ${e}`);
+    } finally {
+      stream.end();
+    }
+  });
+  
+  return stream;
 }
 
 // 使用fetch调用Notion API并处理流式响应
@@ -524,8 +329,6 @@ async function fetchNotionResponse(chunkQueue, notionRequestBody, headers, notio
     // 设置cookie
     document.cookie = notionCookie;
     
-    //logger.info(`JSDOM环境已设置`);
-    
     // 创建fetch选项
     const fetchOptions = {
       method: 'POST',
@@ -556,7 +359,6 @@ async function fetchNotionResponse(chunkQueue, notionRequestBody, headers, notio
     }
     let response = null;
     // 发送请求
-    //const response = await fetch(notionApiUrl, fetchOptions);
     if (ENABLE_PROXY_SERVER){
       response = await fetch('http://127.0.0.1:10655/proxy', {
         method: 'POST',
@@ -572,6 +374,38 @@ async function fetchNotionResponse(chunkQueue, notionRequestBody, headers, notio
       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) {
       throw new Error(`HTTP error! status: ${response.status}`);
@@ -646,10 +480,10 @@ async function fetchNotionResponse(chunkQueue, notionRequestBody, headers, notio
     reader.on('end', () => {
       try {
         logger.info(`响应完成`);
-        if (isMoreThanOne){
-          NOTION_COOKIE = getCookie(); // 获取下一个cookie
-          logger.info('开始切换cookie和ID');
-          fetchAndSetNotionIds(); // 切换到下一个ID
+        if (cookieManager.getValidCount() > 1){
+          // 尝试切换到下一个cookie
+          currentCookieData = cookieManager.getNext();
+          logger.info(`切换到下一个cookie: ${currentCookieData.userId}`);
         }
         
         // 如果没有收到任何响应，发送一个提示消息
@@ -658,6 +492,7 @@ async function fetchNotionResponse(chunkQueue, notionRequestBody, headers, notio
           if (USE_NATIVE_PROXY_POOL) {
             proxyPool.removeProxy(proxy.ip, proxy.port);
           }
+          
           const noContentChunk = new ChatCompletionChunk({
             choices: [
               new Choice({
@@ -860,47 +695,58 @@ async function initialize() {
     logger.error(`启动代理服务器失败: ${error.message}`);
   }
   
-  // 从环境变量加载所有 cookies
-  const cookiesEnv = process.env.NOTION_COOKIE;
-  if (!cookiesEnv) {
-    logger.error(`错误: 未设置NOTION_COOKIE环境变量，应用无法正常工作`);
-    return;
-  }
-  NOTION_COOKIES = cookiesEnv.split('|').map(c => c.trim()).filter(c => c);
+  // 初始化cookie管理器
+  let initResult = false;
   
-  if (NOTION_COOKIES.length === 0) {
-    logger.error(`错误: NOTION_COOKIE环境变量中未找到有效cookie`);
-    return;
+  // 检查是否配置了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_COOKIES.length} 个 Notion cookie，正在逐个获取 ID...`);
-
-  let successfulCookies = 0;
-  for (const cookie of NOTION_COOKIES) {
-    try {
-      const ids = await fetchAndSetNotionIds(cookie);
-      if (ids && ids.spaceId && ids.userId) {
-        NOTION_SPACE_IDS[cookie] = ids.spaceId;
-        NOTION_USER_IDS[cookie] = ids.userId;
-        logger.success(`成功获取 cookie 的 ID: ...${cookie.slice(-10)}`);
-        successfulCookies++;
-      }
-    } catch (error) {
-      logger.error(`获取 cookie 的 ID 失败: ...${cookie.slice(-10)} - ${error.message}`);
+  
+  // 如果文件加载失败或未配置文件，尝试从环境变量加载
+  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;
     }
   }
-
-  if (successfulCookies > 0) {
-    FETCHED_IDS_SUCCESSFULLY = true;
-    logger.success(`成功初始化 ${successfulCookies} 个 Notion 账号`);
-  } else {
-    logger.error(`所有 Notion cookie 均无法成功初始化，应用可能无法正常工作`);
+  
+  // 获取第一个可用的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 (process.env.USE_NATIVE_PROXY_POOL === 'true') {
     logger.info(`正在初始化本地代理池...`);
     await proxyPool.initialize();
   }
+  
+  INITIALIZED_SUCCESSFULLY = true;
 }
 
 // 导出函数
@@ -908,5 +754,5 @@ export {
   initialize,
   streamNotionResponse,
   buildNotionRequest,
-  FETCHED_IDS_SUCCESSFULLY
+  INITIALIZED_SUCCESSFULLY
 };