Update from GitHub Actions

.env

@@ -0,0 +1 @@
+API_KEYS={}

.env.example

@@ -0,0 +1,65 @@
+# 服务端口
+PORT=3010
+
+# 日志格式 (tiny, combined, common, dev, short)
+MORGAN_FORMAT=tiny
+
+# API Key与Cookie映射关系 (JSON格式)
+# 格式: {"自定义API Key": "Cookie值"} 或 {"自定义API Key": ["Cookie值1", "Cookie值2"]}
+API_KEYS={"sk-cursor-123":"user_xxxxxxx","sk-cursor-456":["user_yyyyyyy","user_zzzzzzz"]}
+
+# 轮询策略 (random 或 round-robin)
+ROTATION_STRATEGY=round-robin
+
+# Cursor校验和 (可选)
+# x-cursor-checksum=xxxxxxxx 
+
+# 自动刷新Cookie设置
+# 是否启用自动刷新Cookie (true 或 false)
+ENABLE_AUTO_REFRESH=true
+
+# 自动刷新Cookie的定时规则 (Cron表达式)
+# 默认每6小时执行一次
+REFRESH_CRON=0 */6 * * *
+
+# 每个API Key最小Cookie数量
+# 当Cookie数量低于此值时，会自动尝试刷新
+MIN_COOKIE_COUNT=1000
+
+# Cookie刷新模式
+# replace: 每次刷新都将现有cookie全部标记为无效并替换成新cookie（默认）
+# append: 保留现有cookie，仅追加新cookie
+COOKIE_REFRESH_MODE=replace
+
+# GitHub 仓库信息
+GITHUB_OWNER=your_name
+GITHUB_REPO=Cursor-Register-fix
+
+# GitHub Token (用于从GitHub Actions下载Artifact)
+# 需要有repo权限
+GITHUB_TOKEN=ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+
+# GitHub Actions 工作流ID
+# 用于触发工作流程
+GITHUB_WORKFLOW_ID=cursor_register.yml
+
+# 是否自动触发工作流
+# 设置为true时，会自动触发工作流而不是仅获取最新结果
+TRIGGER_WORKFLOW=true
+
+# 工作流参数设置 目前只支持gmail，outlook过于复杂，暂时不支持
+# 注册账号数量
+REGISTER_NUMBER=1
+# 最大并发工作线程数
+REGISTER_MAX_WORKERS=1
+# 邮箱服务器类型 (TempEmail 或 IMAP)
+REGISTER_EMAIL_SERVER=IMAP
+# 是否将账号令牌注入到OneAPI (true 或 false)
+REGISTER_INGEST_TO_ONEAPI=false
+# 是否上传账号信息到Artifact (true 或 false)
+REGISTER_UPLOAD_ARTIFACT=true
+# 是否从config.yaml读取邮箱配置 (true 或 false)
+REGISTER_USE_CONFIG_FILE=false
+# 邮箱配置JSON字符串（仅在REGISTER_USE_CONFIG_FILE=false时有效）
+# 格式例如[{"email":"example@gmail.com","imap_server":"imap.gmail.com","imap_port":993,"username":"example@gmail.com","password":"your_app_password"}]
+REGISTER_EMAIL_CONFIGS=[] 

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,26 @@
+FROM node:lts-alpine
+
+# 创建应用目录并设置工作目录
+WORKDIR /app
+
+# 复制依赖文件
+COPY package.json package-lock.json ./
+
+# 安装依赖
+RUN npm install
+
+# 复制应用代码
+COPY . /app
+
+# 创建数据目录并设置权限
+RUN mkdir -p /app/data && \
+    chown -R node:node /app
+
+# 使用非root用户运行应用
+USER node
+
+# 暴露端口
+EXPOSE 7860
+
+# 启动应用
+CMD ["npm", "run", "start"]

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2024 liuw1535
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

SETUP.md

@@ -0,0 +1,102 @@
+# Cursor-To-OpenAI 一键配置指南
+
+本文档将指导你使用一键配置工具来设置 Cursor-To-OpenAI 环境。
+
+## 准备工作
+
+在开始配置前，请确保你已经：
+
+1. Fork了 [Cursor-Register-fix](https://github.com/liuw1535/Cursor-Register-fix) 仓库到你的GitHub账号
+2. 创建了一个GitHub个人访问令牌（Personal Access Token），且具有 `repo` 权限
+3. 拥有至少一个Gmail账号，并启用了两步验证
+4. 为Gmail账号创建了应用密码（Application Password）
+
+## 配置步骤
+
+### 1. 安装依赖
+
+```bash
+npm install
+```
+
+### 2. 运行配置脚本
+
+```bash
+npm run setup
+```
+
+或者直接运行：
+
+```bash
+node setup.js
+```
+
+### 3. 按照提示输入信息
+
+脚本会引导你输入以下信息：
+
+- GitHub用户名：你的GitHub账号用户名
+- GitHub Token：你的个人访问令牌
+- API Key：自定义的API Key，用于访问服务
+- Gmail账号：用于自动注册Cursor账号的Gmail地址
+- Gmail应用密码：对应Gmail账号的应用密码（不是邮箱密码）
+
+### 4. 创建应用密码的步骤
+
+如果你还没有创建Gmail应用密码，请按照以下步骤操作：
+
+1. 访问 [Google账号安全设置](https://myaccount.google.com/security)
+2. 在"登录Google"部分，点击"两步验证"
+   (如果未启用两步验证，需要先启用)
+3. 在页面底部找到"应用密码"，点击进入
+4. 在"选择应用"下拉菜单中选择"其他(自定义名称)"
+5. 输入一个名称，例如"Cursor注册"
+6. 点击"生成"
+7. 复制生成的16位应用密码（格式如：xxxx xxxx xxxx xxxx）
+
+### 5. 管理邮箱配置
+
+系统提供了一个专门的邮箱配置管理工具，可以随时添加、修改或删除邮箱：
+
+```bash
+npm run manage-emails
+```
+
+使用此工具可以：
+- 查看所有已配置的邮箱
+- 添加新的Gmail账号
+- 修改现有Gmail账号的配置
+- 删除不再使用的Gmail账号
+
+## 配置完成后
+
+配置完成后，你可以：
+
+1. 启动服务：
+
+```bash
+npm start
+```
+
+2. 手动触发Cookie刷新：
+
+```bash
+npm run refresh-cookies:force
+```
+
+## 配置文件说明
+
+脚本会生成`.env`文件，其中包含以下主要配置：
+
+- `API_KEYS`：API Key到Cookie的映射关系
+- `GITHUB_OWNER`：你的GitHub用户名
+- `GITHUB_TOKEN`：你的GitHub个人访问令牌
+- `REGISTER_EMAIL_CONFIGS`：Gmail账号配置，用于自动注册
+
+## 注意事项
+
+1. GitHub Token需要具有repo权限，用于访问你fork的仓库
+2. Gmail应用密码不同于你的Gmail登录密码，是专门为第三方应用生成的
+3. MIN_COOKIE_COUNT设置为1000，确保系统会尝试刷新Cookie
+4. 配置完成后，你可以通过Web界面查看和管理Cookie状态
+5. 始终确保至少有一个有效的Gmail账号配置，否则自动刷新功能将无法正常工作 

add-api-key.js

@@ -0,0 +1,43 @@
+const fetch = require('node-fetch');
+
+async function addApiKey() {
+  try {
+    console.log('添加API Key...');
+    const response = await fetch('http://localhost:3010/v1/api-keys', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        apiKey: 'test-key',
+        cookieValues: ['test-cookie'],
+      }),
+    });
+    
+    console.log('响应状态:', response.status);
+    
+    if (!response.ok) {
+      throw new Error(`HTTP错误: ${response.status} ${response.statusText}`);
+    }
+    
+    const data = await response.json();
+    console.log('响应数据:', data);
+    
+    // 测试获取API Keys
+    console.log('\n测试获取API Keys...');
+    const getResponse = await fetch('http://localhost:3010/v1/api-keys');
+    
+    console.log('响应状态:', getResponse.status);
+    
+    if (!getResponse.ok) {
+      throw new Error(`HTTP错误: ${getResponse.status} ${getResponse.statusText}`);
+    }
+    
+    const getData = await getResponse.json();
+    console.log('获取到的数据:', getData);
+  } catch (error) {
+    console.error('操作失败:', error);
+  }
+}
+
+addApiKey(); 

auto-refresh-cookies.js

@@ -0,0 +1,143 @@
+// 加载环境变量
+require('dotenv').config();
+
+// 环境检查
+const envChecker = require('./src/utils/envChecker');
+console.log('启动前检查环境配置...');
+envChecker.enforceEnvCheck();
+
+// 已适配GitHub Actions工作流新参数 (use_config_file, email_configs)
+console.log('环境检查通过，已适配最新GitHub Actions工作流参数');
+
+const cookieRefresher = require('./src/utils/cookieRefresher');
+const keyManager = require('./src/utils/keyManager');
+const config = require('./src/config/config');
+
+// 解析命令行参数
+const args = process.argv.slice(2);
+const targetApiKey = args.length > 0 ? args[0] : null;
+const forceRefresh = args.includes('--force') || args.includes('-f');
+
+// 最小 Cookie 数量
+const MIN_COOKIE_COUNT = config.refresh.minCookieCount;
+
+// 获取Cookie刷新模式
+const COOKIE_REFRESH_MODE = process.env.COOKIE_REFRESH_MODE || 'append';
+
+// 主函数
+async function main() {
+  console.log('===== 自动刷新 Cookie 开始 =====');
+  console.log(`最小 Cookie 数量: ${MIN_COOKIE_COUNT}`);
+  console.log(`Cookie 刷新模式: ${COOKIE_REFRESH_MODE} (${COOKIE_REFRESH_MODE === 'replace' ? '替换现有cookie' : '追加新cookie'})`);
+  
+  if (targetApiKey) {
+    console.log(`指定刷新 API Key: ${targetApiKey}`);
+  }
+  
+  if (forceRefresh) {
+    console.log('强制刷新模式: 忽略 Cookie 数量检查');
+  }
+  
+  try {
+    // 获取所有 API Key
+    const apiKeys = keyManager.getAllApiKeys();
+    
+    if (apiKeys.length === 0) {
+      console.log('警告: 系统中没有找到任何 API Key');
+      
+      // 检查环境变量中是否有 API Keys
+      const envApiKeys = Object.keys(config.apiKeys);
+      if (envApiKeys.length > 0) {
+        console.log(`检测到环境变量中有 ${envApiKeys.length} 个 API Key，但尚未加载到系统中`);
+        console.log('正在重新初始化 API Keys...');
+        
+        // 重新初始化 API Keys
+        keyManager.initializeApiKeys();
+        
+        // 重新获取 API Keys
+        const refreshedApiKeys = keyManager.getAllApiKeys();
+        if (refreshedApiKeys.length > 0) {
+          console.log(`成功加载 ${refreshedApiKeys.length} 个 API Key，继续刷新流程`);
+          // 继续执行后续刷新逻辑
+        } else {
+          console.log('初始化后仍未找到 API Key，请检查配置');
+          console.log('===== 自动刷新 Cookie 结束 =====');
+          return;
+        }
+      } else {
+        console.log('环境变量中也没有配置 API Key，请先添加 API Key');
+        console.log('===== 自动刷新 Cookie 结束 =====');
+        return;
+      }
+    }
+    
+    // 重新获取最新的 API Keys（可能已经通过上面的初始化更新了）
+    const updatedApiKeys = keyManager.getAllApiKeys();
+    console.log(`系统中共有 ${updatedApiKeys.length} 个 API Key`);
+    
+    // 如果指定了特定的 API Key，检查它是否存在
+    if (targetApiKey && !updatedApiKeys.includes(targetApiKey)) {
+      console.error(`错误: 指定的 API Key "${targetApiKey}" 不存在`);
+      console.log('===== 自动刷新 Cookie 异常结束 =====');
+      return;
+    }
+    
+    // 过滤需要处理的 API Keys
+    const keysToProcess = targetApiKey ? [targetApiKey] : updatedApiKeys;
+    
+    // 按 Cookie 数量排序，优先处理 Cookie 数量少的 API Key
+    const sortedKeys = keysToProcess.sort((a, b) => {
+      const aCount = keyManager.getAllCookiesForApiKey(a).length;
+      const bCount = keyManager.getAllCookiesForApiKey(b).length;
+      return aCount - bCount; // 升序排列，Cookie 数量少的排在前面
+    });
+    
+    // 检查每个 API Key 是否需要刷新
+    let refreshedCount = 0;
+    let needRefreshCount = 0;
+    
+    for (const apiKey of sortedKeys) {
+      const cookies = keyManager.getAllCookiesForApiKey(apiKey);
+      console.log(`API Key: ${apiKey}, Cookie 数量: ${cookies.length}`);
+      
+      // 判断是否需要刷新：强制刷新模式或 Cookie 数量低于阈值
+      if (forceRefresh || cookies.length < MIN_COOKIE_COUNT) {
+        needRefreshCount++;
+        if (forceRefresh) {
+          console.log(`强制刷新 API Key: ${apiKey}`);
+        } else {
+          console.log(`API Key ${apiKey} 的 Cookie 数量不足，需要刷新`);
+        }
+        
+        // 执行刷新
+        console.log(`开始自动刷新 Cookie，目标 API Key: ${apiKey}，最小 Cookie 数量: ${MIN_COOKIE_COUNT}，刷新模式: ${COOKIE_REFRESH_MODE}`);
+        const result = await cookieRefresher.autoRefreshCookies(apiKey, MIN_COOKIE_COUNT);
+        
+        if (result.success) {
+          refreshedCount++;
+          console.log(`刷新结果: ${result.message}`);
+          
+          // 根据刷新模式输出额外的信息
+          if (COOKIE_REFRESH_MODE === 'replace') {
+            console.log(`使用替换模式: 现有cookie已全部标记为无效，系统现在只使用新cookie`);
+          } else {
+            console.log(`使用追加模式: 现有cookie已保留，新cookie已添加到系统`);
+          }
+        } else {
+          console.error(`刷新失败: ${result.message}`);
+        }
+      } else {
+        console.log(`API Key ${apiKey} 的 Cookie 数量足够，不需要刷新`);
+      }
+    }
+    
+    console.log('===== 自动刷新 Cookie 完成 =====');
+    console.log(`共有 ${needRefreshCount} 个 API Key 需要刷新，成功刷新 ${refreshedCount} 个`);
+  } catch (error) {
+    console.error('自动刷新 Cookie 失败:', error);
+    console.log('===== 自动刷新 Cookie 异常结束 =====');
+  }
+}
+
+// 执行主函数
+main().catch(console.error); 

cursor-to-openai-helper.sh

@@ -0,0 +1,557 @@
+#!/bin/bash
+
+# Colors for better UI
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[0;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Create backups directory if it doesn't exist
+mkdir -p backups
+
+# Function to display header
+show_header() {
+    clear
+    echo -e "${BLUE}=======================================${NC}"
+    echo -e "${GREEN}      Cursor-To-OpenAI 简易脚本      ${NC}"
+    echo -e "${BLUE}=======================================${NC}"
+    echo
+}
+
+# Function to check if Docker is installed
+check_docker() {
+    if ! command -v docker &> /dev/null; then
+        echo -e "${RED}未安装Docker。请先安装Docker。${NC}"
+        exit 1
+    fi
+}
+
+# Function to check if Node.js is installed
+check_nodejs() {
+    if ! command -v node &> /dev/null; then
+        echo -e "${RED}未安装Node.js。请先安装Node.js。${NC}"
+        exit 1
+    fi
+
+    if ! command -v npm &> /dev/null; then
+        echo -e "${RED}未安装npm。请先安装npm。${NC}"
+        exit 1
+    fi
+}
+
+# Function to backup configuration before update
+backup_configs() {
+    echo -e "${YELLOW}正在备份配置文件...${NC}"
+    backup_dir="backups/update_backup_$(date +"%Y%m%d_%H%M%S")"
+    mkdir -p "$backup_dir"
+
+    # Backup important configurations
+    if [ -d data ]; then
+        cp -r data "$backup_dir/"
+    fi
+
+    if [ -f .env ]; then
+        cp .env "$backup_dir/"
+    fi
+
+    echo -e "${GREEN}配置文件已备份到 ${backup_dir}${NC}"
+}
+
+# Function to restore configuration after update
+restore_configs() {
+    if [ -z "$1" ]; then
+        echo -e "${RED}未指定备份目录，无法恢复配置。${NC}"
+        return 1
+    fi
+
+    backup_dir="$1"
+    echo -e "${YELLOW}正在恢复配置文件...${NC}"
+
+    if [ -d "$backup_dir/data" ]; then
+        cp -r "$backup_dir/data/"* data/ 2>/dev/null
+    fi
+
+    if [ -f "$backup_dir/.env" ]; then
+        cp "$backup_dir/.env" ./ 2>/dev/null
+    fi
+
+    echo -e "${GREEN}配置文件已恢复${NC}"
+}
+
+# Function for installation tasks
+installation_menu() {
+    show_header
+    echo -e "${YELLOW}===== 安装菜单 =====${NC}"
+    echo -e "1) 克隆仓库"
+    echo -e "2) 安装依赖"
+    echo -e "3) 创建配置文件"
+    echo -e "4) 设置管理员账户"
+    echo -e "5) 运行安装向导"
+    echo -e "6) 构建并启动Docker容器"
+    echo -e "7) 使用npm启动"
+    echo -e "8) 返回主菜单"
+    echo
+    echo -n "请输入选择 [1-8]: "
+    read -r choice
+
+    case $choice in
+        1)
+            show_header
+            echo -e "${YELLOW}正在克隆仓库...${NC}"
+            read -p "请输入您的GitHub用户名: " username
+            git clone "https://github.com/${username}/cursor-to-openai.git"
+            if [ $? -eq 0 ]; then
+                echo -e "${GREEN}仓库克隆成功！${NC}"
+                cd cursor-to-openai
+            else
+                echo -e "${RED}克隆仓库失败！${NC}"
+            fi
+            read -p "按回车键继续..."
+            installation_menu
+            ;;
+        2)
+            show_header
+            echo -e "${YELLOW}正在安装依赖...${NC}"
+            npm install
+            if [ $? -eq 0 ]; then
+                echo -e "${GREEN}依赖安装成功！${NC}"
+            else
+                echo -e "${RED}依赖安装失败！${NC}"
+            fi
+            read -p "按回车键继续..."
+            installation_menu
+            ;;
+        3)
+            show_header
+            echo -e "${YELLOW}正在创建配置文件...${NC}"
+
+            if [ ! -f .env ]; then
+                cp .env.example .env
+                echo -e "${GREEN}.env文件已创建。${NC}"
+            else
+                echo -e "${YELLOW}.env文件已存在。${NC}"
+            fi
+
+            mkdir -p data
+
+            if [ ! -f data/admin.json ]; then
+                cp data/admin.example.json data/admin.json
+                echo -e "${GREEN}admin.json文件已创建。${NC}"
+            else
+                echo -e "${YELLOW}admin.json文件已存在。${NC}"
+            fi
+
+            echo -e "${YELLOW}您应该编辑.env文件来配置您的环境。${NC}"
+            read -p "是否现在编辑.env文件？(y/n): " edit_env
+            if [[ $edit_env == "y" || $edit_env == "Y" ]]; then
+                if command -v nano &> /dev/null; then
+                    nano .env
+                elif command -v vim &> /dev/null; then
+                    vim .env
+                else
+                    echo -e "${RED}未找到编辑器。请稍后手动编辑.env文件。${NC}"
+                fi
+            fi
+
+            read -p "按回车键继续..."
+            installation_menu
+            ;;
+        4)
+            show_header
+            echo -e "${YELLOW}正在设置管理员账户...${NC}"
+            node scripts/create-admin.js
+            read -p "按回车键继续..."
+            installation_menu
+            ;;
+        5)
+            show_header
+            echo -e "${YELLOW}正在运行安装向导...${NC}"
+            node setup.js
+            read -p "按回车键继续..."
+            installation_menu
+            ;;
+        6)
+            show_header
+            echo -e "${YELLOW}正在构建并启动Docker容器...${NC}"
+            check_docker
+            docker compose up -d --build
+            if [ $? -eq 0 ]; then
+                echo -e "${GREEN}Docker容器启动成功！${NC}"
+                echo -e "${GREEN}访问管理界面: http://localhost:3010${NC}"
+            else
+                echo -e "${RED}启动Docker容器失败！${NC}"
+            fi
+            read -p "按回车键继续..."
+            installation_menu
+            ;;
+        7)
+            show_header
+            echo -e "${YELLOW}正在使用npm启动...${NC}"
+            check_nodejs
+            npm start &
+            if [ $? -eq 0 ]; then
+                echo -e "${GREEN}服务启动成功！${NC}"
+                echo -e "${GREEN}访问管理界面: http://localhost:3010${NC}"
+            else
+                echo -e "${RED}启动服务失败！${NC}"
+            fi
+            read -p "按回车键继续..."
+            installation_menu
+            ;;
+        8)
+            main_menu
+            ;;
+        *)
+            echo -e "${RED}无效选项。请重试。${NC}"
+            read -p "按回车键继续..."
+            installation_menu
+            ;;
+    esac
+}
+
+# Function for maintenance tasks
+maintenance_menu() {
+    show_header
+    echo -e "${YELLOW}===== 维护菜单 =====${NC}"
+    echo -e "1) 查看服务状态"
+    echo -e "2) 刷新Cookie"
+    echo -e "3) 强制刷新Cookie"
+    echo -e "4) 管理邮箱"
+    echo -e "5) 管理无效Cookie"
+    echo -e "6) 查看日志"
+    echo -e "7) 重启服务"
+    echo -e "8) 停止服务"
+    echo -e "9) 更新项目代码"
+    echo -e "10) 备份项目数据"
+    echo -e "11) 持续刷新Cookie直到成功"
+    echo -e "12) 返回主菜单"
+    echo
+    echo -n "请输入选择 [1-12]: "
+    read -r choice
+
+    case $choice in
+        1)
+            show_header
+            echo -e "${YELLOW}服务状态:${NC}"
+            if docker ps | grep -q cursor-to-openai; then
+                echo -e "${GREEN}Docker容器正在运行。${NC}"
+                docker ps | grep cursor-to-openai
+            else
+                echo -e "${RED}Docker容器未运行。${NC}"
+            fi
+
+            pids=$(pgrep -f "node.*start")
+            if [ -n "$pids" ]; then
+                echo -e "${GREEN}Node.js服务正在运行，PID: $pids${NC}"
+            else
+                echo -e "${RED}Node.js服务未运行。${NC}"
+            fi
+
+            read -p "按回车键继续..."
+            maintenance_menu
+            ;;
+        2)
+            show_header
+            echo -e "${YELLOW}正在刷新Cookie...${NC}"
+            npm run refresh-cookies
+            read -p "按回车键继续..."
+            maintenance_menu
+            ;;
+        3)
+            show_header
+            echo -e "${YELLOW}正在强制刷新Cookie...${NC}"
+            npm run refresh-cookies -- --force
+            read -p "按回车键继续..."
+            maintenance_menu
+            ;;
+        4)
+            show_header
+            echo -e "${YELLOW}正在管理邮箱...${NC}"
+            npm run manage-emails
+            read -p "按回车键继续..."
+            maintenance_menu
+            ;;
+        5)
+            show_header
+            echo -e "${YELLOW}正在管理无效Cookie...${NC}"
+            node manage-invalid-cookies.js
+            read -p "按回车键继续..."
+            maintenance_menu
+            ;;
+        6)
+            show_header
+            echo -e "${YELLOW}正在查看日志...${NC}"
+            if docker ps | grep -q cursor-to-openai; then
+                docker compose logs -f
+            else
+                echo -e "${RED}Docker容器未运行。${NC}"
+                echo -e "${YELLOW}正在检查npm日志...${NC}"
+                # Try to find logs in npm-debug.log or similar
+                if [ -f npm-debug.log ]; then
+                    cat npm-debug.log
+                else
+                    echo -e "${RED}未找到日志文件。${NC}"
+                fi
+            fi
+            read -p "按回车键继续..."
+            maintenance_menu
+            ;;
+        7)
+            show_header
+            echo -e "${YELLOW}正在重启服务...${NC}"
+            if docker ps | grep -q cursor-to-openai; then
+                docker compose restart
+                echo -e "${GREEN}Docker容器已重启。${NC}"
+            else
+                pids=$(pgrep -f "node.*start")
+                if [ -n "$pids" ]; then
+                    kill $pids
+                    sleep 2
+                    npm start &
+                    echo -e "${GREEN}Node.js服务已重启。${NC}"
+                else
+                    echo -e "${RED}未检测到运行中的服务。${NC}"
+                    echo -e "${YELLOW}是否要启动服务？(y/n): ${NC}"
+                    read -r start_service
+                    if [[ $start_service == "y" || $start_service == "Y" ]]; then
+                        npm start &
+                        echo -e "${GREEN}服务已启动。${NC}"
+                    fi
+                fi
+            fi
+            read -p "按回车键继续..."
+            maintenance_menu
+            ;;
+        8)
+            show_header
+            echo -e "${YELLOW}正在停止服务...${NC}"
+            if docker ps | grep -q cursor-to-openai; then
+                docker compose down
+                echo -e "${GREEN}Docker容器已停止。${NC}"
+            else
+                pids=$(pgrep -f "node.*start")
+                if [ -n "$pids" ]; then
+                    kill $pids
+                    echo -e "${GREEN}Node.js服务已停止。${NC}"
+                else
+                    echo -e "${RED}未检测到运行中的服务。${NC}"
+                fi
+            fi
+            read -p "按回车键继续..."
+            maintenance_menu
+            ;;
+        9)
+            show_header
+            echo -e "${YELLOW}正在更新项目代码...${NC}"
+
+            # 备份配置文件
+            backup_configs
+            backup_dir=$(ls -td backups/update_backup_* | head -1)
+
+            # 检查是否存在未提交的更改
+            if [ -n "$(git status --porcelain)" ]; then
+                echo -e "${YELLOW}检测到未提交的更改。更新前请处理这些更改。${NC}"
+                echo -e "1) 查看更改"
+                echo -e "2) 备份并放弃更改"
+                echo -e "3) 取消更新"
+                echo -n "请选择操作 [1-3]: "
+                read -r update_choice
+
+                case $update_choice in
+                    1)
+                        git status
+                        echo -e "${YELLOW}是否继续更新？(y/n): ${NC}"
+                        read -r continue_update
+                        if [[ $continue_update != "y" && $continue_update != "Y" ]]; then
+                            echo -e "${YELLOW}更新已取消。${NC}"
+                            read -p "按回车键继续..."
+                            maintenance_menu
+                            return
+                        fi
+                        ;;
+                    2)
+                        echo -e "${YELLOW}备份更改...${NC}"
+                        git diff > "$backup_dir/local_changes.patch"
+                        git checkout -- .
+                        echo -e "${GREEN}更改已备份到 $backup_dir/local_changes.patch${NC}"
+                        ;;
+                    3)
+                        echo -e "${YELLOW}更新已取消。${NC}"
+                        read -p "按回车键继续..."
+                        maintenance_menu
+                        return
+                        ;;
+                    *)
+                        echo -e "${RED}无效选项。更新已取消。${NC}"
+                        read -p "按回车键继续..."
+                        maintenance_menu
+                        return
+                        ;;
+                esac
+            fi
+
+            # 更新代码
+            git pull
+            update_status=$?
+
+            # 恢复配置文件
+            restore_configs "$backup_dir"
+
+            if [ $update_status -eq 0 ]; then
+                echo -e "${GREEN}项目代码更新成功！${NC}"
+                echo -e "${YELLOW}是否需要重新安装依赖？(y/n): ${NC}"
+                read -r reinstall
+                if [[ $reinstall == "y" || $reinstall == "Y" ]]; then
+                    npm install
+                    if [ $? -eq 0 ]; then
+                        echo -e "${GREEN}依赖安装成功！${NC}"
+                    else
+                        echo -e "${RED}依赖安装失败！${NC}"
+                    fi
+                fi
+            else
+                echo -e "${RED}项目代码更新失败！${NC}"
+            fi
+
+            read -p "按回车键继续..."
+            maintenance_menu
+            ;;
+        10)
+            show_header
+            echo -e "${YELLOW}正在备份项目数据...${NC}"
+
+            # 创建备份目录
+            backup_dir="backups/backup_$(date +"%Y%m%d_%H%M%S")"
+            mkdir -p "$backup_dir"
+
+            # 备份关键文件
+            cp -r data "$backup_dir/" 2>/dev/null
+            if [ -f .env ]; then
+                cp .env "$backup_dir/"
+            fi
+
+            # 压缩备份
+            tar -czf "${backup_dir}.tar.gz" "$backup_dir"
+            rm -rf "$backup_dir"
+
+            echo -e "${GREEN}备份已创建: ${backup_dir}.tar.gz${NC}"
+            read -p "按回车键继续..."
+            maintenance_menu
+            ;;
+        11)
+            show_header
+            echo -e "${YELLOW}持续刷新Cookie直到成功...${NC}"
+            read -p "请输入最大尝试时间(分钟, 默认60): " max_time
+            max_time=${max_time:-60}
+            max_seconds=$((max_time * 60))
+
+            echo -e "${YELLOW}将持续尝试刷新Cookie，最长 ${max_time} 分钟...${NC}"
+
+            start_time=$(date +%s)
+            success=false
+            attempt=0
+
+            while ! $success && [ $(($(date +%s) - start_time)) -lt $max_seconds ]; do
+                attempt=$((attempt + 1))
+                elapsed=$(($(date +%s) - start_time))
+                remaining=$((max_seconds - elapsed))
+                remaining_min=$((remaining / 60))
+                remaining_sec=$((remaining % 60))
+
+                echo -e "${YELLOW}尝试 #${attempt}...（剩余时间: ${remaining_min}分${remaining_sec}秒）${NC}"
+
+                # 运行刷新命令并检查输出
+                output=$(npm run refresh-cookies -- --force 2>&1)
+                echo "$output"
+
+                if echo "$output" | grep -q "成功添加新的Cookie" || echo "$output" | grep -q "Successfully added new cookies"; then
+                    success=true
+                    echo -e "${GREEN}成功添加新Cookie！${NC}"
+                else
+                    wait_time=$((RANDOM % 61 + 30))  # 30-90秒随机间隔
+                    echo -e "${YELLOW}等待 ${wait_time} 秒后重试...${NC}"
+                    sleep $wait_time
+                fi
+            done
+
+            if $success; then
+                echo -e "${GREEN}成功刷新Cookie！${NC}"
+            else
+                echo -e "${RED}达到最大尝试时间，未能成功刷新Cookie。${NC}"
+            fi
+
+            read -p "按回车键继续..."
+            maintenance_menu
+            ;;
+        12)
+            main_menu
+            ;;
+        *)
+            echo -e "${RED}无效选项。请重试。${NC}"
+            read -p "按回车键继续..."
+            maintenance_menu
+            ;;
+    esac
+}
+
+# Main menu function
+main_menu() {
+    show_header
+    echo -e "${YELLOW}===== 主菜单 =====${NC}"
+    echo -e "1) 启动服务 (npm)"
+    echo -e "2) 安装配置"
+    echo -e "3) 系统维护"
+    echo -e "4) 退出"
+    echo
+    echo -n "请输入选择 [1-4]: "
+    read -r choice
+
+    case $choice in
+        1)
+            show_header
+            echo -e "${YELLOW}正在使用npm启动服务...${NC}"
+            check_nodejs
+
+            # 检查Node.js服务是否已在运行
+            pids=$(pgrep -f "node.*start")
+            if [ -n "$pids" ]; then
+                echo -e "${YELLOW}服务已在运行，PID: $pids${NC}"
+                echo -e "${YELLOW}是否要重启服务？(y/n): ${NC}"
+                read -r restart
+                if [[ $restart == "y" || $restart == "Y" ]]; then
+                    kill $pids
+                    sleep 2
+                    npm start &
+                    echo -e "${GREEN}服务已重启${NC}"
+                fi
+            else
+                npm start &
+                echo -e "${GREEN}服务已启动${NC}"
+            fi
+
+            echo -e "${GREEN}访问管理界面: http://localhost:3010${NC}"
+            read -p "按回车键继续..."
+            main_menu
+            ;;
+        2)
+            installation_menu
+            ;;
+        3)
+            maintenance_menu
+            ;;
+        4)
+            show_header
+            echo -e "${GREEN}感谢使用Cursor-To-OpenAI简易脚本！${NC}"
+            exit 0
+            ;;
+        *)
+            echo -e "${RED}无效选项。请重试。${NC}"
+            read -p "按回车键继续..."
+            main_menu
+            ;;
+    esac
+}
+
+# Start the script
+main_menu

data/admin.example.json

@@ -0,0 +1,7 @@
+{
+    "admin": {
+        "username": "your_admin_username",
+        "salt": "your_generated_salt",
+        "hash": "your_password_hash"
+    }
+} 

data/api_keys.example.json

@@ -0,0 +1,5 @@
+{
+  "sk-text@example": [
+    "user_XXXXXXXXXXXX%3A%3AeyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
+  ]
+} 

data/invalid_cookies.example.json

@@ -0,0 +1,3 @@
+[
+  "user_XXXXXXXXXXXX%3A%3AeyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
+] 

docker-compose.yaml

@@ -0,0 +1,14 @@
+version: '3.8'
+
+services:
+  app:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    image: cursor-to-openai
+    volumes:
+      - ./data:/app/data
+    ports:
+      - "3010:3010"
+    env_file:
+      - .env

manage-emails.js

@@ -0,0 +1,309 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const dotenv = require('dotenv');
+
+// 创建交互式命令行界面
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout
+});
+
+// 加载环境变量
+const ENV_FILE_PATH = path.join(process.cwd(), '.env');
+let envContent = '';
+let emailConfigs = [];
+
+// 应用密码说明
+function printAppPasswordInstructions() {
+  console.log('\n===== 如何创建谷歌应用密码 =====');
+  console.log('1. 访问 https://myaccount.google.com/security');
+  console.log('2. 在"登录Google"部分，点击"两步验证"');
+  console.log('   (如果未启用两步验证，需要先启用)');
+  console.log('3. 在页面底部找到"应用密码"，点击进入');
+  console.log('4. 在"选择应用"下拉菜单中选择"其他(自定义名称)"');
+  console.log('5. 输入一个名称，例如"Cursor注册"');
+  console.log('6. 点击"生成"');
+  console.log('7. 复制生成的16位应用密码（格式如：xxxx xxxx xxxx xxxx）');
+  console.log('注意: 应用密码只会显示一次，请务必保存好\n');
+}
+
+// 加载当前环境变量和邮箱配置
+function loadEnvironment() {
+  try {
+    if (!fs.existsSync(ENV_FILE_PATH)) {
+      console.error('❌ .env文件不存在，请先运行setup.js进行初始化配置');
+      process.exit(1);
+    }
+
+    // 读取原始.env文件内容
+    envContent = fs.readFileSync(ENV_FILE_PATH, 'utf8');
+    
+    // 解析环境变量
+    dotenv.config();
+
+    // 尝试解析当前的邮箱配置
+    try {
+      const configStr = process.env.REGISTER_EMAIL_CONFIGS;
+      if (configStr) {
+        emailConfigs = JSON.parse(configStr);
+        if (!Array.isArray(emailConfigs)) {
+          emailConfigs = [];
+        }
+      }
+    } catch (parseErr) {
+      console.warn('⚠️ 解析当前邮箱配置出错，将使用空配置');
+      emailConfigs = [];
+    }
+
+    return true;
+  } catch (error) {
+    console.error(`❌ 加载环境变量失败: ${error.message}`);
+    return false;
+  }
+}
+
+// 保存更新后的邮箱配置到.env文件
+function saveEmailConfigs() {
+  try {
+    // 将邮箱配置格式化为JSON字符串
+    const configStr = JSON.stringify(emailConfigs);
+    
+    // 替换.env文件中的配置
+    let newEnvContent = '';
+    
+    if (envContent.includes('REGISTER_EMAIL_CONFIGS=')) {
+      // 使用正则表达式替换REGISTER_EMAIL_CONFIGS行
+      newEnvContent = envContent.replace(
+        /REGISTER_EMAIL_CONFIGS=.*/,
+        `REGISTER_EMAIL_CONFIGS=${configStr}`
+      );
+    } else {
+      // 如果不存在该配置行，添加到文件末尾
+      newEnvContent = `${envContent}\nREGISTER_EMAIL_CONFIGS=${configStr}`;
+    }
+    
+    // 同时确保USE_CONFIG_FILE设置为false
+    if (newEnvContent.includes('REGISTER_USE_CONFIG_FILE=')) {
+      newEnvContent = newEnvContent.replace(
+        /REGISTER_USE_CONFIG_FILE=.*/,
+        'REGISTER_USE_CONFIG_FILE=false'
+      );
+    } else {
+      newEnvContent = `${newEnvContent}\nREGISTER_USE_CONFIG_FILE=false`;
+    }
+    
+    // 确保EMAIL_SERVER设置为IMAP
+    if (newEnvContent.includes('REGISTER_EMAIL_SERVER=')) {
+      newEnvContent = newEnvContent.replace(
+        /REGISTER_EMAIL_SERVER=.*/,
+        'REGISTER_EMAIL_SERVER=IMAP'
+      );
+    } else {
+      newEnvContent = `${newEnvContent}\nREGISTER_EMAIL_SERVER=IMAP`;
+    }
+    
+    // 写入更新后的内容
+    fs.writeFileSync(ENV_FILE_PATH, newEnvContent, 'utf8');
+    
+    console.log('✅ 邮箱配置已成功保存到.env文件');
+    return true;
+  } catch (error) {
+    console.error(`❌ 保存邮箱配置失败: ${error.message}`);
+    return false;
+  }
+}
+
+// 显示所有已配置的邮箱
+function displayEmails() {
+  console.log('\n===== 当前已配置的邮箱 =====');
+  
+  if (emailConfigs.length === 0) {
+    console.log('暂无已配置的邮箱');
+    return;
+  }
+  
+  emailConfigs.forEach((config, index) => {
+    console.log(`[${index + 1}] ${config.email}`);
+    console.log(`   IMAP服务器: ${config.imap_server}`);
+    console.log(`   IMAP端口: ${config.imap_port}`);
+    console.log(`   用户名: ${config.username}`);
+    console.log(`   应用密码: ${config.password}`);
+    console.log('');
+  });
+}
+
+// 添加新邮箱
+function addEmail() {
+  console.log('\n===== 添加新邮箱 =====');
+  printAppPasswordInstructions();
+  
+  rl.question('请输入Gmail地址: ', (email) => {
+    rl.question('请输入Gmail的应用密码 (不是邮箱密码): ', (password) => {
+      // 创建新配置
+      const newConfig = {
+        email: email,
+        imap_server: 'imap.gmail.com',
+        imap_port: 993,
+        username: email,
+        password: password
+      };
+      
+      // 添加到配置列表
+      emailConfigs.push(newConfig);
+      
+      console.log(`\n✅ 已添加邮箱: ${email}`);
+      
+      // 保存到.env文件
+      if (saveEmailConfigs()) {
+        showMainMenu();
+      }
+    });
+  });
+}
+
+// 修改邮箱
+function modifyEmail() {
+  if (emailConfigs.length === 0) {
+    console.log('\n❌ 当前没有可修改的邮箱。请先添加邮箱。');
+    showMainMenu();
+    return;
+  }
+  
+  console.log('\n===== 修改邮箱 =====');
+  displayEmails();
+  
+  rl.question('请输入要修改的邮箱序号 (1-' + emailConfigs.length + '): ', (indexStr) => {
+    const index = parseInt(indexStr) - 1;
+    
+    if (isNaN(index) || index < 0 || index >= emailConfigs.length) {
+      console.log('\n❌ 无效的序号。请重新选择。');
+      modifyEmail();
+      return;
+    }
+    
+    const currentConfig = emailConfigs[index];
+    
+    console.log(`\n正在修改邮箱: ${currentConfig.email}`);
+    
+    rl.question(`新的Gmail地址 (当前: ${currentConfig.email}，直接回车保持不变): `, (email) => {
+      const newEmail = email.trim() === '' ? currentConfig.email : email;
+      
+      rl.question('新的应用密码 (直接回车保持不变): ', (password) => {
+        const newPassword = password.trim() === '' ? currentConfig.password : password;
+        
+        // 更新配置
+        emailConfigs[index] = {
+          email: newEmail,
+          imap_server: 'imap.gmail.com',
+          imap_port: 993,
+          username: newEmail,
+          password: newPassword
+        };
+        
+        console.log(`\n✅ 已修改邮箱配置: ${newEmail}`);
+        
+        // 保存到.env文件
+        if (saveEmailConfigs()) {
+          showMainMenu();
+        }
+      });
+    });
+  });
+}
+
+// 删除邮箱
+function deleteEmail() {
+  if (emailConfigs.length === 0) {
+    console.log('\n❌ 当前没有可删除的邮箱。');
+    showMainMenu();
+    return;
+  }
+  
+  console.log('\n===== 删除邮箱 =====');
+  displayEmails();
+  
+  rl.question('请输入要删除的邮箱序号 (1-' + emailConfigs.length + '): ', (indexStr) => {
+    const index = parseInt(indexStr) - 1;
+    
+    if (isNaN(index) || index < 0 || index >= emailConfigs.length) {
+      console.log('\n❌ 无效的序号。请重新选择。');
+      deleteEmail();
+      return;
+    }
+    
+    const emailToDelete = emailConfigs[index].email;
+    
+    rl.question(`确认删除邮箱 "${emailToDelete}"? (y/n): `, (answer) => {
+      if (answer.toLowerCase() === 'y') {
+        // 删除邮箱
+        emailConfigs.splice(index, 1);
+        
+        console.log(`\n✅ 已删除邮箱: ${emailToDelete}`);
+        
+        // 保存到.env文件
+        if (saveEmailConfigs()) {
+          showMainMenu();
+        }
+      } else {
+        console.log('\n操作已取消');
+        showMainMenu();
+      }
+    });
+  });
+}
+
+// 显示主菜单
+function showMainMenu() {
+  console.log('\n===== 邮箱配置管理 =====');
+  console.log('1. 查看所有邮箱');
+  console.log('2. 添加新邮箱');
+  console.log('3. 修改邮箱');
+  console.log('4. 删除邮箱');
+  console.log('0. 退出');
+  
+  rl.question('请选择操作 (0-4): ', (choice) => {
+    switch (choice) {
+      case '1':
+        displayEmails();
+        showMainMenu();
+        break;
+      case '2':
+        addEmail();
+        break;
+      case '3':
+        modifyEmail();
+        break;
+      case '4':
+        deleteEmail();
+        break;
+      case '0':
+        console.log('\n✅ 配置完成，退出程序');
+        rl.close();
+        break;
+      default:
+        console.log('\n❌ 无效的选择，请重新输入');
+        showMainMenu();
+        break;
+    }
+  });
+}
+
+// 主函数
+async function main() {
+  console.log('===== Cursor-To-OpenAI 邮箱配置管理 =====');
+  
+  // 加载当前配置
+  if (loadEnvironment()) {
+    // 显示主菜单
+    showMainMenu();
+  } else {
+    console.error('程序退出');
+    rl.close();
+  }
+}
+
+// 运行主函数
+main(); 

manage-invalid-cookies.js

@@ -0,0 +1,169 @@
+// 加载环境变量
+require('dotenv').config();
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const keyManager = require('./src/utils/keyManager');
+
+// 创建命令行交互界面
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout
+});
+
+// 显示菜单
+function showMenu() {
+  console.log('\n===== 无效Cookie管理工具 =====');
+  console.log('1. 查看所有无效Cookie');
+  console.log('2. 添加无效Cookie');
+  console.log('3. 删除特定无效Cookie');
+  console.log('4. 清空所有无效Cookie');
+  console.log('5. 从API Keys中移除所有无效Cookie');
+  console.log('6. 退出');
+  console.log('============================');
+  
+  rl.question('请选择操作 (1-6): ', (answer) => {
+    switch(answer) {
+      case '1':
+        listInvalidCookies();
+        break;
+      case '2':
+        addInvalidCookie();
+        break;
+      case '3':
+        removeInvalidCookie();
+        break;
+      case '4':
+        clearAllInvalidCookies();
+        break;
+      case '5':
+        removeInvalidCookiesFromApiKeys();
+        break;
+      case '6':
+        console.log('退出程序');
+        rl.close();
+        break;
+      default:
+        console.log('无效的选择，请重新输入');
+        showMenu();
+        break;
+    }
+  });
+}
+
+// 查看所有无效Cookie
+function listInvalidCookies() {
+  const invalidCookies = Array.from(keyManager.getInvalidCookies());
+  
+  console.log('\n===== 所有无效Cookie =====');
+  if (invalidCookies.length === 0) {
+    console.log('没有无效Cookie');
+  } else {
+    invalidCookies.forEach((cookie, index) => {
+      console.log(`${index + 1}. ${cookie}`);
+    });
+  }
+  
+  showMenu();
+}
+
+// 添加无效Cookie
+function addInvalidCookie() {
+  rl.question('\n请输入要添加的无效Cookie: ', (cookie) => {
+    if (!cookie.trim()) {
+      console.log('Cookie不能为空');
+      showMenu();
+      return;
+    }
+    
+    // 将cookie添加到无效集合
+    const invalidCookies = new Set(keyManager.getInvalidCookies());
+    invalidCookies.add(cookie.trim());
+    
+    // 保存到文件
+    const INVALID_COOKIES_FILE = path.join(__dirname, 'data/invalid_cookies.json');
+    try {
+      // 确保目录存在
+      const dataDir = path.join(__dirname, 'data');
+      if (!fs.existsSync(dataDir)) {
+        fs.mkdirSync(dataDir, { recursive: true });
+      }
+      
+      fs.writeFileSync(INVALID_COOKIES_FILE, JSON.stringify(Array.from(invalidCookies), null, 2), 'utf8');
+      console.log('无效Cookie添加成功');
+      
+      // 重新加载无效cookie
+      keyManager.loadInvalidCookiesFromFile();
+    } catch (err) {
+      console.error('保存无效Cookie失败:', err);
+    }
+    
+    showMenu();
+  });
+}
+
+// 删除特定无效Cookie
+function removeInvalidCookie() {
+  const invalidCookies = Array.from(keyManager.getInvalidCookies());
+  
+  if (invalidCookies.length === 0) {
+    console.log('\n没有无效Cookie可删除');
+    showMenu();
+    return;
+  }
+  
+  console.log('\n===== 所有无效Cookie =====');
+  invalidCookies.forEach((cookie, index) => {
+    console.log(`${index + 1}. ${cookie}`);
+  });
+  
+  rl.question('\n请输入要删除的Cookie编号 (1-' + invalidCookies.length + '): ', (answer) => {
+    const index = parseInt(answer) - 1;
+    
+    if (isNaN(index) || index < 0 || index >= invalidCookies.length) {
+      console.log('无效的编号');
+      showMenu();
+      return;
+    }
+    
+    const cookieToRemove = invalidCookies[index];
+    const result = keyManager.clearInvalidCookie(cookieToRemove);
+    
+    if (result) {
+      console.log(`成功删除无效Cookie: ${cookieToRemove}`);
+    } else {
+      console.log('删除失败');
+    }
+    
+    showMenu();
+  });
+}
+
+// 清空所有无效Cookie
+function clearAllInvalidCookies() {
+  rl.question('\n确定要清空所有无效Cookie吗? (y/n): ', (answer) => {
+    if (answer.toLowerCase() === 'y') {
+      keyManager.clearAllInvalidCookies();
+      console.log('所有无效Cookie已清空');
+    } else {
+      console.log('操作已取消');
+    }
+    
+    showMenu();
+  });
+}
+
+// 从API Keys中移除所有无效Cookie
+function removeInvalidCookiesFromApiKeys() {
+  // 重新初始化API Keys，这会自动移除无效cookie
+  keyManager.initializeApiKeys();
+  console.log('已从API Keys中移除所有无效Cookie');
+  
+  showMenu();
+}
+
+// 启动程序
+console.log('正在加载无效Cookie...');
+keyManager.loadInvalidCookiesFromFile();
+showMenu(); 

package-lock.json

@@ -0,0 +1,2291 @@
+{
+  "name": "cursor-to-openai",
+  "version": "1.3.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "cursor-to-openai",
+      "version": "1.3.0",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/rest": "^20.0.2",
+        "adm-zip": "^0.5.16",
+        "axios": "^1.6.7",
+        "csv-parser": "^3.0.0",
+        "dotenv": "^16.4.7",
+        "express": "4.21.2",
+        "jsonwebtoken": "^9.0.2",
+        "morgan": "^1.10.0",
+        "node-cron": "^3.0.3",
+        "node-fetch": "^2.7.0",
+        "protobufjs": "^7.4.0",
+        "undici": "^6.21.2",
+        "uuid": "11.0.5"
+      },
+      "devDependencies": {
+        "protobufjs-cli": "^1.1.3"
+      }
+    },
+    "node_modules/@babel/helper-string-parser": {
+      "version": "7.25.9",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.25.9.tgz",
+      "integrity": "sha512-4A/SCr/2KLd5jrtOMFzaKjVtAei3+2r/NChoBNoZ3EyP/+GlhoaEGoWOZUmFmoITP7zOJyHIMm+DYRd8o3PvHA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-identifier": {
+      "version": "7.25.9",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.25.9.tgz",
+      "integrity": "sha512-Ed61U6XJc3CVRfkERJWDz4dJwKe7iLmmJsbOGu9wSloNSFttHV0I8g6UAgb7qnK5ly5bGLPd4oXZlxCdANBOWQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/parser": {
+      "version": "7.26.7",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.26.7.tgz",
+      "integrity": "sha512-kEvgGGgEjRUutvdVvZhbn/BxVt+5VSpwXz1j3WYXQbXDo8KzFOPNG2GQbdAiNq8g6wn1yKk7C/qrke03a84V+w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.26.7"
+      },
+      "bin": {
+        "parser": "bin/babel-parser.js"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@babel/types": {
+      "version": "7.26.7",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.26.7.tgz",
+      "integrity": "sha512-t8kDRGrKXyp6+tjUh7hw2RLyclsW4TRoRvRHtSyAX9Bb5ldlFh+90YAYY6awRXrlB4G5G2izNeGySpATlFzmOg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-string-parser": "^7.25.9",
+        "@babel/helper-validator-identifier": "^7.25.9"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@jsdoc/salty": {
+      "version": "0.2.9",
+      "resolved": "https://registry.npmjs.org/@jsdoc/salty/-/salty-0.2.9.tgz",
+      "integrity": "sha512-yYxMVH7Dqw6nO0d5NIV8OQWnitU8k6vXH8NtgqAfIa/IUqRMxRv/NUJJ08VEKbAakwxlgBl5PJdrU0dMPStsnw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "lodash": "^4.17.21"
+      },
+      "engines": {
+        "node": ">=v12.0.0"
+      }
+    },
+    "node_modules/@octokit/auth-token": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/@octokit/auth-token/-/auth-token-4.0.0.tgz",
+      "integrity": "sha512-tY/msAuJo6ARbK6SPIxZrPBms3xPbfwBrulZe0Wtr/DIY9lje2HeV1uoebShn6mx7SjCHif6EjMvoREj+gZ+SA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/@octokit/core": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/@octokit/core/-/core-5.2.0.tgz",
+      "integrity": "sha512-1LFfa/qnMQvEOAdzlQymH0ulepxbxnCYAKJZfMci/5XJyIHWgEYnDmgnKakbTh7CH2tFQ5O60oYDvns4i9RAIg==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/auth-token": "^4.0.0",
+        "@octokit/graphql": "^7.1.0",
+        "@octokit/request": "^8.3.1",
+        "@octokit/request-error": "^5.1.0",
+        "@octokit/types": "^13.0.0",
+        "before-after-hook": "^2.2.0",
+        "universal-user-agent": "^6.0.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/@octokit/endpoint": {
+      "version": "9.0.6",
+      "resolved": "https://registry.npmjs.org/@octokit/endpoint/-/endpoint-9.0.6.tgz",
+      "integrity": "sha512-H1fNTMA57HbkFESSt3Y9+FBICv+0jFceJFPWDePYlR/iMGrwM5ph+Dd4XRQs+8X+PUFURLQgX9ChPfhJ/1uNQw==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/types": "^13.1.0",
+        "universal-user-agent": "^6.0.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/@octokit/graphql": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/@octokit/graphql/-/graphql-7.1.1.tgz",
+      "integrity": "sha512-3mkDltSfcDUoa176nlGoA32RGjeWjl3K7F/BwHwRMJUW/IteSa4bnSV8p2ThNkcIcZU2umkZWxwETSSCJf2Q7g==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/request": "^8.4.1",
+        "@octokit/types": "^13.0.0",
+        "universal-user-agent": "^6.0.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/@octokit/openapi-types": {
+      "version": "23.0.1",
+      "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-23.0.1.tgz",
+      "integrity": "sha512-izFjMJ1sir0jn0ldEKhZ7xegCTj/ObmEDlEfpFrx4k/JyZSMRHbO3/rBwgE7f3m2DHt+RrNGIVw4wSmwnm3t/g==",
+      "license": "MIT"
+    },
+    "node_modules/@octokit/plugin-paginate-rest": {
+      "version": "11.4.4-cjs.2",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-paginate-rest/-/plugin-paginate-rest-11.4.4-cjs.2.tgz",
+      "integrity": "sha512-2dK6z8fhs8lla5PaOTgqfCGBxgAv/le+EhPs27KklPhm1bKObpu6lXzwfUEQ16ajXzqNrKMujsFyo9K2eaoISw==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/types": "^13.7.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      },
+      "peerDependencies": {
+        "@octokit/core": "5"
+      }
+    },
+    "node_modules/@octokit/plugin-request-log": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-request-log/-/plugin-request-log-4.0.1.tgz",
+      "integrity": "sha512-GihNqNpGHorUrO7Qa9JbAl0dbLnqJVrV8OXe2Zm5/Y4wFkZQDfTreBzVmiRfJVfE4mClXdihHnbpyyO9FSX4HA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 18"
+      },
+      "peerDependencies": {
+        "@octokit/core": "5"
+      }
+    },
+    "node_modules/@octokit/plugin-rest-endpoint-methods": {
+      "version": "13.3.2-cjs.1",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-rest-endpoint-methods/-/plugin-rest-endpoint-methods-13.3.2-cjs.1.tgz",
+      "integrity": "sha512-VUjIjOOvF2oELQmiFpWA1aOPdawpyaCUqcEBc/UOUnj3Xp6DJGrJ1+bjUIIDzdHjnFNO6q57ODMfdEZnoBkCwQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/types": "^13.8.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      },
+      "peerDependencies": {
+        "@octokit/core": "^5"
+      }
+    },
+    "node_modules/@octokit/request": {
+      "version": "8.4.1",
+      "resolved": "https://registry.npmjs.org/@octokit/request/-/request-8.4.1.tgz",
+      "integrity": "sha512-qnB2+SY3hkCmBxZsR/MPCybNmbJe4KAlfWErXq+rBKkQJlbjdJeS85VI9r8UqeLYLvnAenU8Q1okM/0MBsAGXw==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/endpoint": "^9.0.6",
+        "@octokit/request-error": "^5.1.1",
+        "@octokit/types": "^13.1.0",
+        "universal-user-agent": "^6.0.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/@octokit/request-error": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/@octokit/request-error/-/request-error-5.1.1.tgz",
+      "integrity": "sha512-v9iyEQJH6ZntoENr9/yXxjuezh4My67CBSu9r6Ve/05Iu5gNgnisNWOsoJHTP6k0Rr0+HQIpnH+kyammu90q/g==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/types": "^13.1.0",
+        "deprecation": "^2.0.0",
+        "once": "^1.4.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/@octokit/rest": {
+      "version": "20.1.2",
+      "resolved": "https://registry.npmjs.org/@octokit/rest/-/rest-20.1.2.tgz",
+      "integrity": "sha512-GmYiltypkHHtihFwPRxlaorG5R9VAHuk/vbszVoRTGXnAsY60wYLkh/E2XiFmdZmqrisw+9FaazS1i5SbdWYgA==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/core": "^5.0.2",
+        "@octokit/plugin-paginate-rest": "11.4.4-cjs.2",
+        "@octokit/plugin-request-log": "^4.0.0",
+        "@octokit/plugin-rest-endpoint-methods": "13.3.2-cjs.1"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/@octokit/types": {
+      "version": "13.8.0",
+      "resolved": "https://registry.npmjs.org/@octokit/types/-/types-13.8.0.tgz",
+      "integrity": "sha512-x7DjTIbEpEWXK99DMd01QfWy0hd5h4EN+Q7shkdKds3otGQP+oWE/y0A76i1OvH9fygo4ddvNf7ZvF0t78P98A==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/openapi-types": "^23.0.1"
+      }
+    },
+    "node_modules/@protobufjs/aspromise": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@protobufjs/aspromise/-/aspromise-1.1.2.tgz",
+      "integrity": "sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/base64": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@protobufjs/base64/-/base64-1.1.2.tgz",
+      "integrity": "sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/codegen": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/@protobufjs/codegen/-/codegen-2.0.4.tgz",
+      "integrity": "sha512-YyFaikqM5sH0ziFZCN3xDC7zeGaB/d0IUb9CATugHWbd1FRFwWwt4ld4OYMPWu5a3Xe01mGAULCdqhMlPl29Jg==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/eventemitter": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@protobufjs/eventemitter/-/eventemitter-1.1.0.tgz",
+      "integrity": "sha512-j9ednRT81vYJ9OfVuXG6ERSTdEL1xVsNgqpkxMsbIabzSo3goCjDIveeGv5d03om39ML71RdmrGNjG5SReBP/Q==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/fetch": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@protobufjs/fetch/-/fetch-1.1.0.tgz",
+      "integrity": "sha512-lljVXpqXebpsijW71PZaCYeIcE5on1w5DlQy5WH6GLbFryLUrBD4932W/E2BSpfRJWseIL4v/KPgBFxDOIdKpQ==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@protobufjs/aspromise": "^1.1.1",
+        "@protobufjs/inquire": "^1.1.0"
+      }
+    },
+    "node_modules/@protobufjs/float": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/@protobufjs/float/-/float-1.0.2.tgz",
+      "integrity": "sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/inquire": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@protobufjs/inquire/-/inquire-1.1.0.tgz",
+      "integrity": "sha512-kdSefcPdruJiFMVSbn801t4vFK7KB/5gd2fYvrxhuJYg8ILrmn9SKSX2tZdV6V+ksulWqS7aXjBcRXl3wHoD9Q==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/path": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@protobufjs/path/-/path-1.1.2.tgz",
+      "integrity": "sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/pool": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@protobufjs/pool/-/pool-1.1.0.tgz",
+      "integrity": "sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/utf8": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@protobufjs/utf8/-/utf8-1.1.0.tgz",
+      "integrity": "sha512-Vvn3zZrhQZkkBE8LSuW3em98c0FwgO4nxzv6OdSxPKJIEKY2bGbHn+mhGIPerzI4twdxaP8/0+06HBpwf345Lw==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@types/linkify-it": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/@types/linkify-it/-/linkify-it-5.0.0.tgz",
+      "integrity": "sha512-sVDA58zAw4eWAffKOaQH5/5j3XeayukzDk+ewSsnv3p4yJEZHCCzMDiZM8e0OUrRvmpGZ85jf4yDHkHsgBNr9Q==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/markdown-it": {
+      "version": "14.1.2",
+      "resolved": "https://registry.npmjs.org/@types/markdown-it/-/markdown-it-14.1.2.tgz",
+      "integrity": "sha512-promo4eFwuiW+TfGxhi+0x3czqTYJkG8qB17ZUJiVF10Xm7NLVRSLUsfRTU/6h1e24VvRnXCx+hG7li58lkzog==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/linkify-it": "^5",
+        "@types/mdurl": "^2"
+      }
+    },
+    "node_modules/@types/mdurl": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/@types/mdurl/-/mdurl-2.0.0.tgz",
+      "integrity": "sha512-RGdgjQUZba5p6QEFAVx2OGb8rQDL/cPRG7GiedRzMcJ1tYnUANBncjbSB1NRGwbvjcPeikRABz2nshyPk1bhWg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/node": {
+      "version": "22.10.5",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-22.10.5.tgz",
+      "integrity": "sha512-F8Q+SeGimwOo86fiovQh8qiXfFEh2/ocYv7tU5pJ3EXMSSxk1Joj5wefpFK2fHTf/N6HKGSxIDBT9f3gCxXPkQ==",
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~6.20.0"
+      }
+    },
+    "node_modules/accepts": {
+      "version": "1.3.8",
+      "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz",
+      "integrity": "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-types": "~2.1.34",
+        "negotiator": "0.6.3"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/acorn": {
+      "version": "8.14.0",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.14.0.tgz",
+      "integrity": "sha512-cl669nCJTZBsL97OF4kUQm5g5hC2uihk0NxY3WENAC0TYdILVkAyHymAntgxGkl7K+t0cXIrH5siy5S4XkFycA==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "acorn": "bin/acorn"
+      },
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/acorn-jsx": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz",
+      "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
+      }
+    },
+    "node_modules/adm-zip": {
+      "version": "0.5.16",
+      "resolved": "https://registry.npmjs.org/adm-zip/-/adm-zip-0.5.16.tgz",
+      "integrity": "sha512-TGw5yVi4saajsSEgz25grObGHEUaDrniwvA2qwSC060KfqGPdglhvPMA2lPIoxs3PQIItj2iag35fONcQqgUaQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.0"
+      }
+    },
+    "node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/argparse": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
+      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
+      "dev": true,
+      "license": "Python-2.0"
+    },
+    "node_modules/array-flatten": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz",
+      "integrity": "sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==",
+      "license": "MIT"
+    },
+    "node_modules/asynckit": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+      "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==",
+      "license": "MIT"
+    },
+    "node_modules/axios": {
+      "version": "1.8.3",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-1.8.3.tgz",
+      "integrity": "sha512-iP4DebzoNlP/YN2dpwCgb8zoCmhtkajzS48JvwmkSkXvPI3DHc7m+XYL5tGnSlJtR6nImXZmdCuN5aP8dh1d8A==",
+      "license": "MIT",
+      "dependencies": {
+        "follow-redirects": "^1.15.6",
+        "form-data": "^4.0.0",
+        "proxy-from-env": "^1.1.0"
+      }
+    },
+    "node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/basic-auth": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/basic-auth/-/basic-auth-2.0.1.tgz",
+      "integrity": "sha512-NF+epuEdnUYVlGuhaxbbq+dvJttwLnGY+YixlXlME5KpQ5W3CnXA5cVTneY3SPbPDRkcjMbifrwmFYcClgOZeg==",
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "5.1.2"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/basic-auth/node_modules/safe-buffer": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+      "license": "MIT"
+    },
+    "node_modules/before-after-hook": {
+      "version": "2.2.3",
+      "resolved": "https://registry.npmjs.org/before-after-hook/-/before-after-hook-2.2.3.tgz",
+      "integrity": "sha512-NzUnlZexiaH/46WDhANlyR2bXRopNg4F/zuSA3OpZnllCUgRaOF2znDioDWrmbNVsuZk6l9pMquQB38cfBZwkQ==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/bluebird": {
+      "version": "3.7.2",
+      "resolved": "https://registry.npmjs.org/bluebird/-/bluebird-3.7.2.tgz",
+      "integrity": "sha512-XpNj6GDQzdfW+r2Wnn7xiSAd7TM3jzkxGXBGTtWKuSXv1xUV+azxAm8jdWZN06QTQk+2N2XB9jRDkvbmQmcRtg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/body-parser": {
+      "version": "1.20.3",
+      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.3.tgz",
+      "integrity": "sha512-7rAxByjUMqQ3/bHJy7D6OGXvx/MMc4IqBn/X0fcM1QUcAItpZrBEYhWGem+tzXH90c+G01ypMcYJBO9Y30203g==",
+      "license": "MIT",
+      "dependencies": {
+        "bytes": "3.1.2",
+        "content-type": "~1.0.5",
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "destroy": "1.2.0",
+        "http-errors": "2.0.0",
+        "iconv-lite": "0.4.24",
+        "on-finished": "2.4.1",
+        "qs": "6.13.0",
+        "raw-body": "2.5.2",
+        "type-is": "~1.6.18",
+        "unpipe": "1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8",
+        "npm": "1.2.8000 || >= 1.4.16"
+      }
+    },
+    "node_modules/brace-expansion": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz",
+      "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0"
+      }
+    },
+    "node_modules/buffer-equal-constant-time": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/buffer-equal-constant-time/-/buffer-equal-constant-time-1.0.1.tgz",
+      "integrity": "sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/bytes": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
+      "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/call-bind-apply-helpers": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.1.tgz",
+      "integrity": "sha512-BhYE+WDaywFg2TBWYNXAE+8B1ATnThNBqXHP5nQu0jWJdVvY2hvkpyB3qOmtmDePiS5/BDQ8wASEWGMWRG148g==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/call-bound": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.3.tgz",
+      "integrity": "sha512-YTd+6wGlNlPxSuri7Y6X8tY2dmm12UMH66RpKMhiX6rsk5wXXnYgbUcOt8kiS31/AjfoTOvCsE+w8nZQLQnzHA==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "get-intrinsic": "^1.2.6"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/catharsis": {
+      "version": "0.9.0",
+      "resolved": "https://registry.npmjs.org/catharsis/-/catharsis-0.9.0.tgz",
+      "integrity": "sha512-prMTQVpcns/tzFgFVkVp6ak6RykZyWb3gu8ckUpd6YkTlacOd3DXGJjIpD4Q6zJirizvaiAjSSHlOsA+6sNh2A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "lodash": "^4.17.15"
+      },
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/chalk": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
+      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.1.0",
+        "supports-color": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk?sponsor=1"
+      }
+    },
+    "node_modules/color-convert": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "color-name": "~1.1.4"
+      },
+      "engines": {
+        "node": ">=7.0.0"
+      }
+    },
+    "node_modules/color-name": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/combined-stream": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+      "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+      "license": "MIT",
+      "dependencies": {
+        "delayed-stream": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/content-disposition": {
+      "version": "0.5.4",
+      "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.4.tgz",
+      "integrity": "sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==",
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "5.2.1"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/content-type": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz",
+      "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie": {
+      "version": "0.7.1",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.1.tgz",
+      "integrity": "sha512-6DnInpx7SJ2AK3+CTUE/ZM0vWTUboZCegxhC2xiIydHR9jNuTAASBrfEpHhiGOZw/nX51bHt6YQl8jsGo4y/0w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie-signature": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.6.tgz",
+      "integrity": "sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ==",
+      "license": "MIT"
+    },
+    "node_modules/csv-parser": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/csv-parser/-/csv-parser-3.2.0.tgz",
+      "integrity": "sha512-fgKbp+AJbn1h2dcAHKIdKNSSjfp43BZZykXsCjzALjKy80VXQNHPFJ6T9Afwdzoj24aMkq8GwDS7KGcDPpejrA==",
+      "license": "MIT",
+      "bin": {
+        "csv-parser": "bin/csv-parser"
+      },
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/debug": {
+      "version": "2.6.9",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "2.0.0"
+      }
+    },
+    "node_modules/deep-is": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
+      "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/delayed-stream": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+      "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/depd": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
+      "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/deprecation": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/deprecation/-/deprecation-2.3.1.tgz",
+      "integrity": "sha512-xmHIy4F3scKVwMsQ4WnVaS8bHOx0DmVwRywosKhaILI0ywMDWPtBSku2HNxRvF7jtwDRsoEwYQSfbxj8b7RlJQ==",
+      "license": "ISC"
+    },
+    "node_modules/destroy": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz",
+      "integrity": "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8",
+        "npm": "1.2.8000 || >= 1.4.16"
+      }
+    },
+    "node_modules/dotenv": {
+      "version": "16.4.7",
+      "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.4.7.tgz",
+      "integrity": "sha512-47qPchRCykZC03FhkYAhrvwU4xDBFIj1QPqaarj6mdM/hgUzfPHcpkHJOn3mJAufFeeAxAzeGsr5X0M4k6fLZQ==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://dotenvx.com"
+      }
+    },
+    "node_modules/dunder-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.2.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/ecdsa-sig-formatter": {
+      "version": "1.0.11",
+      "resolved": "https://registry.npmjs.org/ecdsa-sig-formatter/-/ecdsa-sig-formatter-1.0.11.tgz",
+      "integrity": "sha512-nagl3RYrbNv6kQkeJIpt6NJZy8twLB/2vtz6yN9Z4vRKHN4/QZJIEbqohALSgwKdnksuY3k5Addp5lg8sVoVcQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "safe-buffer": "^5.0.1"
+      }
+    },
+    "node_modules/ee-first": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz",
+      "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==",
+      "license": "MIT"
+    },
+    "node_modules/encodeurl": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz",
+      "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/entities": {
+      "version": "4.5.0",
+      "resolved": "https://registry.npmjs.org/entities/-/entities-4.5.0.tgz",
+      "integrity": "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=0.12"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/entities?sponsor=1"
+      }
+    },
+    "node_modules/es-define-property": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-errors": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-object-atoms": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.0.0.tgz",
+      "integrity": "sha512-MZ4iQ6JwHOBQjahnjwaC1ZtIBH+2ohjamzAO3oaHcXYup7qxjF2fixyH+Q71voWHeOkI2q/TnJao/KfXYIZWbw==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-set-tostringtag": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
+      "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.6",
+        "has-tostringtag": "^1.0.2",
+        "hasown": "^2.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/escape-html": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz",
+      "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==",
+      "license": "MIT"
+    },
+    "node_modules/escape-string-regexp": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-2.0.0.tgz",
+      "integrity": "sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/escodegen": {
+      "version": "1.14.3",
+      "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-1.14.3.tgz",
+      "integrity": "sha512-qFcX0XJkdg+PB3xjZZG/wKSuT1PnQWx57+TVSjIMmILd2yC/6ByYElPwJnslDsuWuSAp4AwJGumarAAmJch5Kw==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "esprima": "^4.0.1",
+        "estraverse": "^4.2.0",
+        "esutils": "^2.0.2",
+        "optionator": "^0.8.1"
+      },
+      "bin": {
+        "escodegen": "bin/escodegen.js",
+        "esgenerate": "bin/esgenerate.js"
+      },
+      "engines": {
+        "node": ">=4.0"
+      },
+      "optionalDependencies": {
+        "source-map": "~0.6.1"
+      }
+    },
+    "node_modules/escodegen/node_modules/estraverse": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.3.0.tgz",
+      "integrity": "sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=4.0"
+      }
+    },
+    "node_modules/eslint-visitor-keys": {
+      "version": "3.4.3",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz",
+      "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/espree": {
+      "version": "9.6.1",
+      "resolved": "https://registry.npmjs.org/espree/-/espree-9.6.1.tgz",
+      "integrity": "sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "acorn": "^8.9.0",
+        "acorn-jsx": "^5.3.2",
+        "eslint-visitor-keys": "^3.4.1"
+      },
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/esprima": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz",
+      "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "bin": {
+        "esparse": "bin/esparse.js",
+        "esvalidate": "bin/esvalidate.js"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/estraverse": {
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz",
+      "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=4.0"
+      }
+    },
+    "node_modules/esutils": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
+      "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/etag": {
+      "version": "1.8.1",
+      "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz",
+      "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/express": {
+      "version": "4.21.2",
+      "resolved": "https://registry.npmjs.org/express/-/express-4.21.2.tgz",
+      "integrity": "sha512-28HqgMZAmih1Czt9ny7qr6ek2qddF4FclbMzwhCREB6OFfH+rXAnuNCwo1/wFvrtbgsQDb4kSbX9de9lFbrXnA==",
+      "license": "MIT",
+      "dependencies": {
+        "accepts": "~1.3.8",
+        "array-flatten": "1.1.1",
+        "body-parser": "1.20.3",
+        "content-disposition": "0.5.4",
+        "content-type": "~1.0.4",
+        "cookie": "0.7.1",
+        "cookie-signature": "1.0.6",
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "etag": "~1.8.1",
+        "finalhandler": "1.3.1",
+        "fresh": "0.5.2",
+        "http-errors": "2.0.0",
+        "merge-descriptors": "1.0.3",
+        "methods": "~1.1.2",
+        "on-finished": "2.4.1",
+        "parseurl": "~1.3.3",
+        "path-to-regexp": "0.1.12",
+        "proxy-addr": "~2.0.7",
+        "qs": "6.13.0",
+        "range-parser": "~1.2.1",
+        "safe-buffer": "5.2.1",
+        "send": "0.19.0",
+        "serve-static": "1.16.2",
+        "setprototypeof": "1.2.0",
+        "statuses": "2.0.1",
+        "type-is": "~1.6.18",
+        "utils-merge": "1.0.1",
+        "vary": "~1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.10.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/fast-levenshtein": {
+      "version": "2.0.6",
+      "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz",
+      "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/finalhandler": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.1.tgz",
+      "integrity": "sha512-6BN9trH7bp3qvnrRyzsBz+g3lZxTNZTbVO2EV1CS0WIcDbawYVdYvGflME/9QP0h0pYlCDBCTjYa9nZzMDpyxQ==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "2.6.9",
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "on-finished": "2.4.1",
+        "parseurl": "~1.3.3",
+        "statuses": "2.0.1",
+        "unpipe": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/follow-redirects": {
+      "version": "1.15.9",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.9.tgz",
+      "integrity": "sha512-gew4GsXizNgdoRyqmyfMHyAmXsZDk6mHkSxZFCzW9gwlbtOW44CDtYavM+y+72qD/Vq2l550kMF52DT8fOLJqQ==",
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://github.com/sponsors/RubenVerborgh"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=4.0"
+      },
+      "peerDependenciesMeta": {
+        "debug": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/form-data": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.2.tgz",
+      "integrity": "sha512-hGfm/slu0ZabnNt4oaRZ6uREyfCj6P4fT/n6A1rGV+Z0VdGXjfOhVUpkn6qVQONHGIFwmveGXyDs75+nr6FM8w==",
+      "license": "MIT",
+      "dependencies": {
+        "asynckit": "^0.4.0",
+        "combined-stream": "^1.0.8",
+        "es-set-tostringtag": "^2.1.0",
+        "mime-types": "^2.1.12"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/forwarded": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
+      "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/fresh": {
+      "version": "0.5.2",
+      "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz",
+      "integrity": "sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/fs.realpath": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
+      "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/function-bind": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-intrinsic": {
+      "version": "1.2.7",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.7.tgz",
+      "integrity": "sha512-VW6Pxhsrk0KAOqs3WEd0klDiF/+V7gQOpAvY1jVU/LHmaD/kQO4523aiJuikX/QAKYiW6x8Jh+RJej1almdtCA==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "es-define-property": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.0.0",
+        "function-bind": "^1.1.2",
+        "get-proto": "^1.0.0",
+        "gopd": "^1.2.0",
+        "has-symbols": "^1.1.0",
+        "hasown": "^2.0.2",
+        "math-intrinsics": "^1.1.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
+      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+      "license": "MIT",
+      "dependencies": {
+        "dunder-proto": "^1.0.1",
+        "es-object-atoms": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/glob": {
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-8.1.0.tgz",
+      "integrity": "sha512-r8hpEjiQEYlF2QU0df3dS+nxxSIreXQS1qRhMJM0Q5NDdR386C7jb7Hwwod8Fgiuex+k0GFjgft18yvxm5XoCQ==",
+      "deprecated": "Glob versions prior to v9 are no longer supported",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "fs.realpath": "^1.0.0",
+        "inflight": "^1.0.4",
+        "inherits": "2",
+        "minimatch": "^5.0.1",
+        "once": "^1.3.0"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/gopd": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/graceful-fs": {
+      "version": "4.2.11",
+      "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
+      "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/has-flag": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
+      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/has-symbols": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-tostringtag": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
+      "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
+      "license": "MIT",
+      "dependencies": {
+        "has-symbols": "^1.0.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/hasown": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
+      "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
+      "license": "MIT",
+      "dependencies": {
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/http-errors": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz",
+      "integrity": "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==",
+      "license": "MIT",
+      "dependencies": {
+        "depd": "2.0.0",
+        "inherits": "2.0.4",
+        "setprototypeof": "1.2.0",
+        "statuses": "2.0.1",
+        "toidentifier": "1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/iconv-lite": {
+      "version": "0.4.24",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",
+      "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==",
+      "license": "MIT",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/inflight": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
+      "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",
+      "deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "once": "^1.3.0",
+        "wrappy": "1"
+      }
+    },
+    "node_modules/inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+      "license": "ISC"
+    },
+    "node_modules/ipaddr.js": {
+      "version": "1.9.1",
+      "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz",
+      "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/js2xmlparser": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/js2xmlparser/-/js2xmlparser-4.0.2.tgz",
+      "integrity": "sha512-6n4D8gLlLf1n5mNLQPRfViYzu9RATblzPEtm1SthMX1Pjao0r9YI9nw7ZIfRxQMERS87mcswrg+r/OYrPRX6jA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "xmlcreate": "^2.0.4"
+      }
+    },
+    "node_modules/jsdoc": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/jsdoc/-/jsdoc-4.0.4.tgz",
+      "integrity": "sha512-zeFezwyXeG4syyYHbvh1A967IAqq/67yXtXvuL5wnqCkFZe8I0vKfm+EO+YEvLguo6w9CDUbrAXVtJSHh2E8rw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@babel/parser": "^7.20.15",
+        "@jsdoc/salty": "^0.2.1",
+        "@types/markdown-it": "^14.1.1",
+        "bluebird": "^3.7.2",
+        "catharsis": "^0.9.0",
+        "escape-string-regexp": "^2.0.0",
+        "js2xmlparser": "^4.0.2",
+        "klaw": "^3.0.0",
+        "markdown-it": "^14.1.0",
+        "markdown-it-anchor": "^8.6.7",
+        "marked": "^4.0.10",
+        "mkdirp": "^1.0.4",
+        "requizzle": "^0.2.3",
+        "strip-json-comments": "^3.1.0",
+        "underscore": "~1.13.2"
+      },
+      "bin": {
+        "jsdoc": "jsdoc.js"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
+    "node_modules/jsonwebtoken": {
+      "version": "9.0.2",
+      "resolved": "https://registry.npmjs.org/jsonwebtoken/-/jsonwebtoken-9.0.2.tgz",
+      "integrity": "sha512-PRp66vJ865SSqOlgqS8hujT5U4AOgMfhrwYIuIhfKaoSCZcirrmASQr8CX7cUg+RMih+hgznrjp99o+W4pJLHQ==",
+      "license": "MIT",
+      "dependencies": {
+        "jws": "^3.2.2",
+        "lodash.includes": "^4.3.0",
+        "lodash.isboolean": "^3.0.3",
+        "lodash.isinteger": "^4.0.4",
+        "lodash.isnumber": "^3.0.3",
+        "lodash.isplainobject": "^4.0.6",
+        "lodash.isstring": "^4.0.1",
+        "lodash.once": "^4.0.0",
+        "ms": "^2.1.1",
+        "semver": "^7.5.4"
+      },
+      "engines": {
+        "node": ">=12",
+        "npm": ">=6"
+      }
+    },
+    "node_modules/jsonwebtoken/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==",
+      "license": "MIT"
+    },
+    "node_modules/jwa": {
+      "version": "1.4.1",
+      "resolved": "https://registry.npmjs.org/jwa/-/jwa-1.4.1.tgz",
+      "integrity": "sha512-qiLX/xhEEFKUAJ6FiBMbes3w9ATzyk5W7Hvzpa/SLYdxNtng+gcurvrI7TbACjIXlsJyr05/S1oUhZrc63evQA==",
+      "license": "MIT",
+      "dependencies": {
+        "buffer-equal-constant-time": "1.0.1",
+        "ecdsa-sig-formatter": "1.0.11",
+        "safe-buffer": "^5.0.1"
+      }
+    },
+    "node_modules/jws": {
+      "version": "3.2.2",
+      "resolved": "https://registry.npmjs.org/jws/-/jws-3.2.2.tgz",
+      "integrity": "sha512-YHlZCB6lMTllWDtSPHz/ZXTsi8S00usEV6v1tjq8tOUZzw7DpSDWVXjXDre6ed1w/pd495ODpHZYSdkRTsa0HA==",
+      "license": "MIT",
+      "dependencies": {
+        "jwa": "^1.4.1",
+        "safe-buffer": "^5.0.1"
+      }
+    },
+    "node_modules/klaw": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/klaw/-/klaw-3.0.0.tgz",
+      "integrity": "sha512-0Fo5oir+O9jnXu5EefYbVK+mHMBeEVEy2cmctR1O1NECcCkPRreJKrS6Qt/j3KC2C148Dfo9i3pCmCMsdqGr0g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "graceful-fs": "^4.1.9"
+      }
+    },
+    "node_modules/levn": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/levn/-/levn-0.3.0.tgz",
+      "integrity": "sha512-0OO4y2iOHix2W6ujICbKIaEQXvFQHue65vUG3pb5EUomzPI90z9hsA1VsO/dbIIpC53J8gxM9Q4Oho0jrCM/yA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "prelude-ls": "~1.1.2",
+        "type-check": "~0.3.2"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/linkify-it": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/linkify-it/-/linkify-it-5.0.0.tgz",
+      "integrity": "sha512-5aHCbzQRADcdP+ATqnDuhhJ/MRIqDkZX5pyjFHRRysS8vZ5AbqGEoFIb6pYHPZ+L/OC2Lc+xT8uHVVR5CAK/wQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "uc.micro": "^2.0.0"
+      }
+    },
+    "node_modules/lodash": {
+      "version": "4.17.21",
+      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
+      "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/lodash.includes": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/lodash.includes/-/lodash.includes-4.3.0.tgz",
+      "integrity": "sha512-W3Bx6mdkRTGtlJISOvVD/lbqjTlPPUDTMnlXZFnVwi9NKJ6tiAk6LVdlhZMm17VZisqhKcgzpO5Wz91PCt5b0w==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.isboolean": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/lodash.isboolean/-/lodash.isboolean-3.0.3.tgz",
+      "integrity": "sha512-Bz5mupy2SVbPHURB98VAcw+aHh4vRV5IPNhILUCsOzRmsTmSQ17jIuqopAentWoehktxGd9e/hbIXq980/1QJg==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.isinteger": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/lodash.isinteger/-/lodash.isinteger-4.0.4.tgz",
+      "integrity": "sha512-DBwtEWN2caHQ9/imiNeEA5ys1JoRtRfY3d7V9wkqtbycnAmTvRRmbHKDV4a0EYc678/dia0jrte4tjYwVBaZUA==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.isnumber": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/lodash.isnumber/-/lodash.isnumber-3.0.3.tgz",
+      "integrity": "sha512-QYqzpfwO3/CWf3XP+Z+tkQsfaLL/EnUlXWVkIk5FUPc4sBdTehEqZONuyRt2P67PXAk+NXmTBcc97zw9t1FQrw==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.isplainobject": {
+      "version": "4.0.6",
+      "resolved": "https://registry.npmjs.org/lodash.isplainobject/-/lodash.isplainobject-4.0.6.tgz",
+      "integrity": "sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.isstring": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/lodash.isstring/-/lodash.isstring-4.0.1.tgz",
+      "integrity": "sha512-0wJxfxH1wgO3GrbuP+dTTk7op+6L41QCXbGINEmD+ny/G/eCqGzxyCsh7159S+mgDDcoarnBw6PC1PS5+wUGgw==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.once": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/lodash.once/-/lodash.once-4.1.1.tgz",
+      "integrity": "sha512-Sb487aTOCr9drQVL8pIxOzVhafOjZN9UU54hiN8PU3uAiSV7lx1yYNpbNmex2PK6dSJoNTSJUUswT651yww3Mg==",
+      "license": "MIT"
+    },
+    "node_modules/long": {
+      "version": "5.2.4",
+      "resolved": "https://registry.npmjs.org/long/-/long-5.2.4.tgz",
+      "integrity": "sha512-qtzLbJE8hq7VabR3mISmVGtoXP8KGc2Z/AT8OuqlYD7JTR3oqrgwdjnk07wpj1twXxYmgDXgoKVWUG/fReSzHg==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/markdown-it": {
+      "version": "14.1.0",
+      "resolved": "https://registry.npmjs.org/markdown-it/-/markdown-it-14.1.0.tgz",
+      "integrity": "sha512-a54IwgWPaeBCAAsv13YgmALOF1elABB08FxO9i+r4VFk5Vl4pKokRPeX8u5TCgSsPi6ec1otfLjdOpVcgbpshg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "argparse": "^2.0.1",
+        "entities": "^4.4.0",
+        "linkify-it": "^5.0.0",
+        "mdurl": "^2.0.0",
+        "punycode.js": "^2.3.1",
+        "uc.micro": "^2.1.0"
+      },
+      "bin": {
+        "markdown-it": "bin/markdown-it.mjs"
+      }
+    },
+    "node_modules/markdown-it-anchor": {
+      "version": "8.6.7",
+      "resolved": "https://registry.npmjs.org/markdown-it-anchor/-/markdown-it-anchor-8.6.7.tgz",
+      "integrity": "sha512-FlCHFwNnutLgVTflOYHPW2pPcl2AACqVzExlkGQNsi4CJgqOHN7YTgDd4LuhgN1BFO3TS0vLAruV1Td6dwWPJA==",
+      "dev": true,
+      "license": "Unlicense",
+      "peerDependencies": {
+        "@types/markdown-it": "*",
+        "markdown-it": "*"
+      }
+    },
+    "node_modules/marked": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/marked/-/marked-4.3.0.tgz",
+      "integrity": "sha512-PRsaiG84bK+AMvxziE/lCFss8juXjNaWzVbN5tXAm4XjeaS9NAHhop+PjQxz2A9h8Q4M/xGmzP8vqNwy6JeK0A==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "marked": "bin/marked.js"
+      },
+      "engines": {
+        "node": ">= 12"
+      }
+    },
+    "node_modules/math-intrinsics": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/mdurl": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/mdurl/-/mdurl-2.0.0.tgz",
+      "integrity": "sha512-Lf+9+2r+Tdp5wXDXC4PcIBjTDtq4UKjCPMQhKIuzpJNW0b96kVqSwW0bT7FhRSfmAiFYgP+SCRvdrDozfh0U5w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/media-typer": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz",
+      "integrity": "sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/merge-descriptors": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.3.tgz",
+      "integrity": "sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/methods": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz",
+      "integrity": "sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz",
+      "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==",
+      "license": "MIT",
+      "bin": {
+        "mime": "cli.js"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/mime-db": {
+      "version": "1.52.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+      "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime-types": {
+      "version": "2.1.35",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-db": "1.52.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/minimatch": {
+      "version": "5.1.6",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.6.tgz",
+      "integrity": "sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/minimist": {
+      "version": "1.2.8",
+      "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",
+      "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/mkdirp": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz",
+      "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "mkdirp": "bin/cmd.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/morgan": {
+      "version": "1.10.0",
+      "resolved": "https://registry.npmjs.org/morgan/-/morgan-1.10.0.tgz",
+      "integrity": "sha512-AbegBVI4sh6El+1gNwvD5YIck7nSA36weD7xvIxG4in80j/UoK8AEGaWnnz8v1GxonMCltmlNs5ZKbGvl9b1XQ==",
+      "license": "MIT",
+      "dependencies": {
+        "basic-auth": "~2.0.1",
+        "debug": "2.6.9",
+        "depd": "~2.0.0",
+        "on-finished": "~2.3.0",
+        "on-headers": "~1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/morgan/node_modules/on-finished": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.3.0.tgz",
+      "integrity": "sha512-ikqdkGAAyf/X/gPhXGvfgAytDZtDbr+bkNUJ0N9h5MI/dmdgCs3l6hoHrcUv41sRKew3jIwrp4qQDXiK99Utww==",
+      "license": "MIT",
+      "dependencies": {
+        "ee-first": "1.1.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
+      "license": "MIT"
+    },
+    "node_modules/negotiator": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz",
+      "integrity": "sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/node-cron": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/node-cron/-/node-cron-3.0.3.tgz",
+      "integrity": "sha512-dOal67//nohNgYWb+nWmg5dkFdIwDm8EpeGYMekPMrngV3637lqnX0lbUcCtgibHTz6SEz7DAIjKvKDFYCnO1A==",
+      "license": "ISC",
+      "dependencies": {
+        "uuid": "8.3.2"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/node-cron/node_modules/uuid": {
+      "version": "8.3.2",
+      "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz",
+      "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==",
+      "license": "MIT",
+      "bin": {
+        "uuid": "dist/bin/uuid"
+      }
+    },
+    "node_modules/node-fetch": {
+      "version": "2.7.0",
+      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz",
+      "integrity": "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==",
+      "license": "MIT",
+      "dependencies": {
+        "whatwg-url": "^5.0.0"
+      },
+      "engines": {
+        "node": "4.x || >=6.0.0"
+      },
+      "peerDependencies": {
+        "encoding": "^0.1.0"
+      },
+      "peerDependenciesMeta": {
+        "encoding": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/object-inspect": {
+      "version": "1.13.3",
+      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.3.tgz",
+      "integrity": "sha512-kDCGIbxkDSXE3euJZZXzc6to7fCrKHNI/hSRQnRuQ+BWjFNzZwiFF8fj/6o2t2G9/jTj8PSIYTfCLelLZEeRpA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/on-finished": {
+      "version": "2.4.1",
+      "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz",
+      "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==",
+      "license": "MIT",
+      "dependencies": {
+        "ee-first": "1.1.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/on-headers": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/on-headers/-/on-headers-1.0.2.tgz",
+      "integrity": "sha512-pZAE+FJLoyITytdqK0U5s+FIpjN0JP3OzFi/u8Rx+EV5/W+JTWGXG8xFzevE7AjBfDqHv/8vL8qQsIhHnqRkrA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/once": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+      "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
+      "license": "ISC",
+      "dependencies": {
+        "wrappy": "1"
+      }
+    },
+    "node_modules/optionator": {
+      "version": "0.8.3",
+      "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.8.3.tgz",
+      "integrity": "sha512-+IW9pACdk3XWmmTXG8m3upGUJst5XRGzxMRjXzAuJ1XnIFNvfhjjIuYkDvysnPQ7qzqVzLt78BCruntqRhWQbA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "deep-is": "~0.1.3",
+        "fast-levenshtein": "~2.0.6",
+        "levn": "~0.3.0",
+        "prelude-ls": "~1.1.2",
+        "type-check": "~0.3.2",
+        "word-wrap": "~1.2.3"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/parseurl": {
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz",
+      "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/path-to-regexp": {
+      "version": "0.1.12",
+      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.12.tgz",
+      "integrity": "sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ==",
+      "license": "MIT"
+    },
+    "node_modules/prelude-ls": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.1.2.tgz",
+      "integrity": "sha512-ESF23V4SKG6lVSGZgYNpbsiaAkdab6ZgOxe52p7+Kid3W3u3bxR4Vfd/o21dmN7jSt0IwgZ4v5MUd26FEtXE9w==",
+      "dev": true,
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/protobufjs": {
+      "version": "7.4.0",
+      "resolved": "https://registry.npmjs.org/protobufjs/-/protobufjs-7.4.0.tgz",
+      "integrity": "sha512-mRUWCc3KUU4w1jU8sGxICXH/gNS94DvI1gxqDvBzhj1JpcsimQkYiOJfwsPUykUI5ZaspFbSgmBLER8IrQ3tqw==",
+      "hasInstallScript": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@protobufjs/aspromise": "^1.1.2",
+        "@protobufjs/base64": "^1.1.2",
+        "@protobufjs/codegen": "^2.0.4",
+        "@protobufjs/eventemitter": "^1.1.0",
+        "@protobufjs/fetch": "^1.1.0",
+        "@protobufjs/float": "^1.0.2",
+        "@protobufjs/inquire": "^1.1.0",
+        "@protobufjs/path": "^1.1.2",
+        "@protobufjs/pool": "^1.1.0",
+        "@protobufjs/utf8": "^1.1.0",
+        "@types/node": ">=13.7.0",
+        "long": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
+    "node_modules/protobufjs-cli": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/protobufjs-cli/-/protobufjs-cli-1.1.3.tgz",
+      "integrity": "sha512-MqD10lqF+FMsOayFiNOdOGNlXc4iKDCf0ZQPkPR+gizYh9gqUeGTWulABUCdI+N67w5RfJ6xhgX4J8pa8qmMXQ==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "chalk": "^4.0.0",
+        "escodegen": "^1.13.0",
+        "espree": "^9.0.0",
+        "estraverse": "^5.1.0",
+        "glob": "^8.0.0",
+        "jsdoc": "^4.0.0",
+        "minimist": "^1.2.0",
+        "semver": "^7.1.2",
+        "tmp": "^0.2.1",
+        "uglify-js": "^3.7.7"
+      },
+      "bin": {
+        "pbjs": "bin/pbjs",
+        "pbts": "bin/pbts"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "peerDependencies": {
+        "protobufjs": "^7.0.0"
+      }
+    },
+    "node_modules/proxy-addr": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz",
+      "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==",
+      "license": "MIT",
+      "dependencies": {
+        "forwarded": "0.2.0",
+        "ipaddr.js": "1.9.1"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/proxy-from-env": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
+      "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==",
+      "license": "MIT"
+    },
+    "node_modules/punycode.js": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/punycode.js/-/punycode.js-2.3.1.tgz",
+      "integrity": "sha512-uxFIHU0YlHYhDQtV4R9J6a52SLx28BCjT+4ieh7IGbgwVJWO+km431c4yRlREUAsAmt/uMjQUyQHNEPf0M39CA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/qs": {
+      "version": "6.13.0",
+      "resolved": "https://registry.npmjs.org/qs/-/qs-6.13.0.tgz",
+      "integrity": "sha512-+38qI9SOr8tfZ4QmJNplMUxqjbe7LKvvZgWdExBOmd+egZTtjLB67Gu0HRX3u/XOq7UU2Nx6nsjvS16Z9uwfpg==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "side-channel": "^1.0.6"
+      },
+      "engines": {
+        "node": ">=0.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/range-parser": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz",
+      "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/raw-body": {
+      "version": "2.5.2",
+      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.2.tgz",
+      "integrity": "sha512-8zGqypfENjCIqGhgXToC8aB2r7YrBX+AQAfIPs/Mlk+BtPTztOvTS01NRW/3Eh60J+a48lt8qsCzirQ6loCVfA==",
+      "license": "MIT",
+      "dependencies": {
+        "bytes": "3.1.2",
+        "http-errors": "2.0.0",
+        "iconv-lite": "0.4.24",
+        "unpipe": "1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/requizzle": {
+      "version": "0.2.4",
+      "resolved": "https://registry.npmjs.org/requizzle/-/requizzle-0.2.4.tgz",
+      "integrity": "sha512-JRrFk1D4OQ4SqovXOgdav+K8EAhSB/LJZqCz8tbX0KObcdeM15Ss59ozWMBWmmINMagCwmqn4ZNryUGpBsl6Jw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "lodash": "^4.17.21"
+      }
+    },
+    "node_modules/safe-buffer": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
+      "license": "MIT"
+    },
+    "node_modules/semver": {
+      "version": "7.7.0",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.0.tgz",
+      "integrity": "sha512-DrfFnPzblFmNrIZzg5RzHegbiRWg7KMR7btwi2yjHwx06zsUbO5g613sVwEV7FTwmzJu+Io0lJe2GJ3LxqpvBQ==",
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/send": {
+      "version": "0.19.0",
+      "resolved": "https://registry.npmjs.org/send/-/send-0.19.0.tgz",
+      "integrity": "sha512-dW41u5VfLXu8SJh5bwRmyYUbAoSB3c9uQh6L8h/KtsFREPWpbX1lrljJo186Jc4nmci/sGUZ9a0a0J2zgfq2hw==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "destroy": "1.2.0",
+        "encodeurl": "~1.0.2",
+        "escape-html": "~1.0.3",
+        "etag": "~1.8.1",
+        "fresh": "0.5.2",
+        "http-errors": "2.0.0",
+        "mime": "1.6.0",
+        "ms": "2.1.3",
+        "on-finished": "2.4.1",
+        "range-parser": "~1.2.1",
+        "statuses": "2.0.1"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/send/node_modules/encodeurl": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz",
+      "integrity": "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/send/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==",
+      "license": "MIT"
+    },
+    "node_modules/serve-static": {
+      "version": "1.16.2",
+      "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.16.2.tgz",
+      "integrity": "sha512-VqpjJZKadQB/PEbEwvFdO43Ax5dFBZ2UECszz8bQ7pi7wt//PWe1P6MN7eCnjsatYtBT6EuiClbjSWP2WrIoTw==",
+      "license": "MIT",
+      "dependencies": {
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "parseurl": "~1.3.3",
+        "send": "0.19.0"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/setprototypeof": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz",
+      "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==",
+      "license": "ISC"
+    },
+    "node_modules/side-channel": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz",
+      "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.3",
+        "side-channel-list": "^1.0.0",
+        "side-channel-map": "^1.0.1",
+        "side-channel-weakmap": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-list": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz",
+      "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-map": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz",
+      "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-weakmap": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz",
+      "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3",
+        "side-channel-map": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/source-map": {
+      "version": "0.6.1",
+      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+      "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "optional": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/statuses": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz",
+      "integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/strip-json-comments": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
+      "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/supports-color": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/tmp": {
+      "version": "0.2.3",
+      "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.2.3.tgz",
+      "integrity": "sha512-nZD7m9iCPC5g0pYmcaxogYKggSfLsdxl8of3Q/oIbqCqLLIO9IAF0GWjX1z9NZRHPiXv8Wex4yDCaZsgEw0Y8w==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.14"
+      }
+    },
+    "node_modules/toidentifier": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz",
+      "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.6"
+      }
+    },
+    "node_modules/tr46": {
+      "version": "0.0.3",
+      "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz",
+      "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==",
+      "license": "MIT"
+    },
+    "node_modules/type-check": {
+      "version": "0.3.2",
+      "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.3.2.tgz",
+      "integrity": "sha512-ZCmOJdvOWDBYJlzAoFkC+Q0+bUyEOS1ltgp1MGU03fqHG+dbi9tBFU2Rd9QKiDZFAYrhPh2JUf7rZRIuHRKtOg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "prelude-ls": "~1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/type-is": {
+      "version": "1.6.18",
+      "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.18.tgz",
+      "integrity": "sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==",
+      "license": "MIT",
+      "dependencies": {
+        "media-typer": "0.3.0",
+        "mime-types": "~2.1.24"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/uc.micro": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/uc.micro/-/uc.micro-2.1.0.tgz",
+      "integrity": "sha512-ARDJmphmdvUk6Glw7y9DQ2bFkKBHwQHLi2lsaH6PPmz/Ka9sFOBsBluozhDltWmnv9u/cF6Rt87znRTPV+yp/A==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/uglify-js": {
+      "version": "3.19.3",
+      "resolved": "https://registry.npmjs.org/uglify-js/-/uglify-js-3.19.3.tgz",
+      "integrity": "sha512-v3Xu+yuwBXisp6QYTcH4UbH+xYJXqnq2m/LtQVWKWzYc1iehYnLixoQDN9FH6/j9/oybfd6W9Ghwkl8+UMKTKQ==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "bin": {
+        "uglifyjs": "bin/uglifyjs"
+      },
+      "engines": {
+        "node": ">=0.8.0"
+      }
+    },
+    "node_modules/underscore": {
+      "version": "1.13.7",
+      "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.13.7.tgz",
+      "integrity": "sha512-GMXzWtsc57XAtguZgaQViUOzs0KTkk8ojr3/xAxXLITqf/3EMwxC0inyETfDFjH/Krbhuep0HNbbjI9i/q3F3g==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/undici": {
+      "version": "6.21.2",
+      "resolved": "https://registry.npmjs.org/undici/-/undici-6.21.2.tgz",
+      "integrity": "sha512-uROZWze0R0itiAKVPsYhFov9LxrPMHLMEQFszeI2gCN6bnIIZ8twzBCJcN2LJrBBLfrP0t1FW0g+JmKVl8Vk1g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18.17"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "6.20.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.20.0.tgz",
+      "integrity": "sha512-Ny6QZ2Nju20vw1SRHe3d9jVu6gJ+4e3+MMpqu7pqE5HT6WsTSlce++GQmK5UXS8mzV8DSYHrQH+Xrf2jVcuKNg==",
+      "license": "MIT"
+    },
+    "node_modules/universal-user-agent": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/universal-user-agent/-/universal-user-agent-6.0.1.tgz",
+      "integrity": "sha512-yCzhz6FN2wU1NiiQRogkTQszlQSlpWaw8SvVegAc+bDxbzHgh1vX8uIe8OYyMH6DwH+sdTJsgMl36+mSMdRJIQ==",
+      "license": "ISC"
+    },
+    "node_modules/unpipe": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
+      "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/utils-merge": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz",
+      "integrity": "sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4.0"
+      }
+    },
+    "node_modules/uuid": {
+      "version": "11.0.5",
+      "resolved": "https://registry.npmjs.org/uuid/-/uuid-11.0.5.tgz",
+      "integrity": "sha512-508e6IcKLrhxKdBbcA2b4KQZlLVp2+J5UwQ6F7Drckkc5N9ZJwFa4TgWtsww9UG8fGHbm6gbV19TdM5pQ4GaIA==",
+      "funding": [
+        "https://github.com/sponsors/broofa",
+        "https://github.com/sponsors/ctavan"
+      ],
+      "license": "MIT",
+      "bin": {
+        "uuid": "dist/esm/bin/uuid"
+      }
+    },
+    "node_modules/vary": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
+      "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/webidl-conversions": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz",
+      "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==",
+      "license": "BSD-2-Clause"
+    },
+    "node_modules/whatwg-url": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz",
+      "integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==",
+      "license": "MIT",
+      "dependencies": {
+        "tr46": "~0.0.3",
+        "webidl-conversions": "^3.0.0"
+      }
+    },
+    "node_modules/word-wrap": {
+      "version": "1.2.5",
+      "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz",
+      "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/wrappy": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
+      "license": "ISC"
+    },
+    "node_modules/xmlcreate": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/xmlcreate/-/xmlcreate-2.0.4.tgz",
+      "integrity": "sha512-nquOebG4sngPmGPICTS5EnxqhKbCmz5Ox5hsszI2T6U5qdrJizBc+0ilYSEjTSzU0yZcmvppztXe/5Al5fUwdg==",
+      "dev": true,
+      "license": "Apache-2.0"
+    }
+  }
+}

package.json

@@ -0,0 +1,38 @@
+{
+  "name": "cursor-to-openai",
+  "version": "1.3.0",
+  "description": "Cursor to OpenAPI",
+  "author": "JiuZ-Chn",
+  "private": false,
+  "main": "index.js",
+  "url": "https://github.com/JiuZ-Chn/Cursor-To-OpenAI",
+  "license": "MIT",
+  "dependencies": {
+    "@octokit/rest": "^20.0.2",
+    "adm-zip": "^0.5.16",
+    "axios": "^1.6.7",
+    "csv-parser": "^3.0.0",
+    "dotenv": "^16.4.7",
+    "express": "4.21.2",
+    "jsonwebtoken": "^9.0.2",
+    "morgan": "^1.10.0",
+    "node-cron": "^3.0.3",
+    "node-fetch": "^2.7.0",
+    "protobufjs": "^7.4.0",
+    "undici": "^6.21.2",
+    "uuid": "11.0.5"
+  },
+  "scripts": {
+    "proto": "npx pbjs -t static-module -w commonjs -o src/proto/message.js src/proto/message.proto",
+    "start": "node src/app.js",
+    "setup": "node setup.js",
+    "manage-emails": "node manage-emails.js",
+    "refresh-cookies": "node auto-refresh-cookies.js",
+    "refresh-cookies:force": "node auto-refresh-cookies.js --force",
+    "refresh-cookies:api": "node auto-refresh-cookies.js",
+    "manage-cookies": "node manage-invalid-cookies.js"
+  },
+  "devDependencies": {
+    "protobufjs-cli": "^1.1.3"
+  }
+}

project.sh

@@ -0,0 +1,51 @@
+#!/data/data/com.termux/files/usr/bin/bash
+
+# 项目管理脚本（数字选择版）
+
+echo "请选择操作："
+echo "1. 更新 cookie"
+echo "2. 启动项目"
+echo "3. 管理邮箱"
+echo "4. 初始化配置"
+echo "5. 更新项目代码"
+echo "6. 备份项目"
+echo "7. 退出"
+
+read -p "输入数字 (1-7): " choice
+
+case $choice in
+    1)
+        echo "正在更新 cookie..."
+        npm run refresh-cookies
+        ;;
+    2)
+        echo "正在启动项目..."
+        npm start
+        ;;
+    3)
+        echo "正在管理邮箱..."
+        npm run manage-emails
+        ;;
+    4)
+        echo "正在初始化配置文件..."
+        npm run setup
+        ;;
+    5)
+        echo "正在更新项目代码..."
+        git pull
+        ;;
+    6)
+        echo "正在备份项目..."
+        DATE=$(date +%Y%m%d_%H%M%S)
+        tar -czf "backup_$DATE.tar.gz" .
+        echo "备份完成: backup_$DATE.tar.gz"
+        ;;
+    7)
+        echo "退出"
+        exit 0
+        ;;
+    *)
+        echo "错误：请输入 1-7 之间的数字"
+        exit 1
+        ;;
+esac

scripts/create-admin.js

@@ -0,0 +1,71 @@
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const readline = require('readline');
+
+const ADMIN_FILE = path.join(__dirname, '../data/admin.json');
+
+// 创建readline接口
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+});
+
+// 生成盐值
+function generateSalt() {
+    return crypto.randomBytes(16).toString('hex');
+}
+
+// 使用盐值哈希密码
+function hashPassword(password, salt) {
+    return crypto.pbkdf2Sync(password, salt, 1000, 64, 'sha512').toString('hex');
+}
+
+// 提示用户输入
+function question(query) {
+    return new Promise((resolve) => {
+        rl.question(query, resolve);
+    });
+}
+
+async function main() {
+    try {
+        console.log('创建管理员账户\n');
+
+        // 获取用户输入
+        const username = await question('请输入管理员用户名: ');
+        const password = await question('请输入管理员密码: ');
+
+        // 生成盐值和密码哈希
+        const salt = generateSalt();
+        const hash = hashPassword(password, salt);
+
+        // 创建管理员数据
+        const adminData = {
+            admin: {
+                username,
+                salt,
+                hash
+            }
+        };
+
+        // 确保data目录存在
+        const dataDir = path.dirname(ADMIN_FILE);
+        if (!fs.existsSync(dataDir)) {
+            fs.mkdirSync(dataDir, { recursive: true });
+        }
+
+        // 写入文件
+        fs.writeFileSync(ADMIN_FILE, JSON.stringify(adminData, null, 2));
+
+        console.log('\n管理员账户创建成功！');
+        console.log('请妥善保管账户信息，不要将admin.json文件提交到版本控制系统。');
+
+    } catch (error) {
+        console.error('创建管理员账户失败:', error);
+    } finally {
+        rl.close();
+    }
+}
+
+main(); 

setup.js

@@ -0,0 +1,361 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const dotenv = require('dotenv');
+
+// 创建交互式命令行界面
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout
+});
+
+// 配置模板
+const ENV_TEMPLATE = `# 服务端口
+PORT=3010
+
+# 日志格式 (tiny, combined, common, dev, short)
+MORGAN_FORMAT=tiny
+
+# API Key与Cookie映射关系 (JSON格式)
+# 格式: {"自定义API Key": "Cookie值"} 或 {"自定义API Key": ["Cookie值1", "Cookie值2"]}
+API_KEYS={API_KEYS_PLACEHOLDER}
+
+# 轮询策略 (random 或 round-robin)
+ROTATION_STRATEGY=round-robin
+
+# Cursor校验和 (可选)
+# x-cursor-checksum=xxxxxxxx 
+
+# 自动刷新Cookie设置
+# 是否启用自动刷新Cookie (true 或 false)
+ENABLE_AUTO_REFRESH=true
+
+# 自动刷新Cookie的定时规则 (Cron表达式)
+# 默认每6小时执行一次
+REFRESH_CRON=0 */6 * * *
+
+# 每个API Key最小Cookie数量
+# 当Cookie数量低于此值时，会自动尝试刷新
+MIN_COOKIE_COUNT=1000
+
+# Cookie刷新模式
+# replace: 每次刷新都将现有cookie全部标记为无效并替换成新cookie（默认）
+# append: 保留现有cookie，仅追加新cookie
+COOKIE_REFRESH_MODE=replace
+
+# GitHub 仓库信息
+GITHUB_OWNER={GITHUB_OWNER_PLACEHOLDER}
+GITHUB_REPO=Cursor-Register-fix
+
+# GitHub Token (用于从GitHub Actions下载Artifact)
+# 需要有repo权限
+GITHUB_TOKEN={GITHUB_TOKEN_PLACEHOLDER}
+
+# GitHub Actions 工作流ID
+# 用于触发工作流程
+GITHUB_WORKFLOW_ID=cursor_register.yml
+
+# 是否自动触发工作流
+# 设置为true时，会自动触发工作流而不是仅获取最新结果
+TRIGGER_WORKFLOW=true
+
+# 工作流参数设置 目前只支持gmail，outlook过于复杂，暂时不支持
+# 注册账号数量
+REGISTER_NUMBER=1
+# 最大并发工作线程数
+REGISTER_MAX_WORKERS=1
+# 邮箱服务器类型 (TempEmail 或 IMAP)
+REGISTER_EMAIL_SERVER=IMAP
+# 是否将账号令牌注入到OneAPI (true 或 false)
+REGISTER_INGEST_TO_ONEAPI=false
+# 是否上传账号信息到Artifact (true 或 false)
+REGISTER_UPLOAD_ARTIFACT=true
+# 是否从config.yaml读取邮箱配置 (true 或 false)
+REGISTER_USE_CONFIG_FILE=false
+# 邮箱配置JSON字符串（仅在REGISTER_USE_CONFIG_FILE=false时有效）
+# 格式例如[{"email":"example@gmail.com","imap_server":"imap.gmail.com","imap_port":993,"username":"example@gmail.com","password":"your_app_password"}]
+REGISTER_EMAIL_CONFIGS={EMAIL_CONFIGS_PLACEHOLDER}
+`;
+
+// 提示信息
+console.log('===== Cursor-To-OpenAI 环境配置助手 =====');
+console.log('这个脚本将帮助你配置必要的环境变量\n');
+
+// 应用密码说明
+function printAppPasswordInstructions() {
+  console.log('\n===== 如何创建谷歌应用密码 =====');
+  console.log('1. 访问 https://myaccount.google.com/security');
+  console.log('2. 在"登录Google"部分，点击"两步验证"');
+  console.log('   (如果未启用两步验证，需要先启用)');
+  console.log('3. 在页面底部找到"应用密码"，点击进入');
+  console.log('4. 在"选择应用"下拉菜单中选择"其他(自定义名称)"');
+  console.log('5. 输入一个名称，例如"Cursor注册"');
+  console.log('6. 点击"生成"');
+  console.log('7. 复制生成的16位应用密码（格式如：xxxx xxxx xxxx xxxx）');
+  console.log('8. 在下面的提示中输入这个密码');
+  console.log('注意: 应用密码只会显示一次，请务必保存好\n');
+}
+
+// 从现有.env文件加载配置
+function loadExistingConfig() {
+  const envPath = path.join(process.cwd(), '.env');
+  let existingConfig = {
+    apiKeys: {},
+    githubOwner: '',
+    githubToken: '',
+    emailConfigs: [],
+    cookieRefreshMode: 'append'
+  };
+  
+  if (fs.existsSync(envPath)) {
+    console.log('发现现有的.env配置文件，将加载现有设置作为默认值');
+    console.log('提示: 直接按回车将保留现有设置不变\n');
+    
+    try {
+      // 加载.env文件
+      const envConfig = dotenv.parse(fs.readFileSync(envPath));
+      
+      // 提取API Keys
+      if (envConfig.API_KEYS) {
+        try {
+          existingConfig.apiKeys = JSON.parse(envConfig.API_KEYS);
+        } catch (e) {
+          console.log('无法解析现有的API Keys配置，将使用默认设置');
+        }
+      }
+      
+      // 提取GitHub Owner
+      if (envConfig.GITHUB_OWNER) {
+        existingConfig.githubOwner = envConfig.GITHUB_OWNER;
+      }
+      
+      // 提取GitHub Token
+      if (envConfig.GITHUB_TOKEN) {
+        existingConfig.githubToken = envConfig.GITHUB_TOKEN;
+      }
+      
+      // 提取Email配置
+      if (envConfig.REGISTER_EMAIL_CONFIGS) {
+        try {
+          existingConfig.emailConfigs = JSON.parse(envConfig.REGISTER_EMAIL_CONFIGS);
+        } catch (e) {
+          console.log('无法解析现有的Email配置，将使用默认设置');
+        }
+      }
+      
+      // 提取Cookie刷新模式
+      if (envConfig.COOKIE_REFRESH_MODE) {
+        existingConfig.cookieRefreshMode = envConfig.COOKIE_REFRESH_MODE;
+      }
+      
+      console.log('成功加载现有配置');
+    } catch (error) {
+      console.error('加载现有配置时出错:', error.message);
+      console.log('将使用默认设置');
+    }
+  } else {
+    console.log('未找到现有的.env配置文件，将创建新的配置文件');
+  }
+  
+  return existingConfig;
+}
+
+// 提示用户输入，带有默认值
+function promptWithDefault(question, defaultValue) {
+  return new Promise((resolve) => {
+    const defaultText = defaultValue ? ` [${defaultValue}]` : '';
+    rl.question(`${question}${defaultText}: `, (answer) => {
+      // 如果用户只按了回车，使用默认值
+      resolve(answer.trim() || defaultValue || '');
+    });
+  });
+}
+
+// 收集配置信息
+async function collectConfig() {
+  // 加载现有配置
+  const existingConfig = loadExistingConfig();
+  
+  const config = {
+    apiKeys: {},
+    githubOwner: '',
+    githubToken: '',
+    emailConfigs: [],
+    cookieRefreshMode: 'replace'
+  };
+
+  // 获取GitHub用户名
+  config.githubOwner = await promptWithDefault('请输入你的GitHub用户名', existingConfig.githubOwner);
+
+  // 获取GitHub Token
+  config.githubToken = await promptWithDefault('请输入你的GitHub Token (具有repo权限)', existingConfig.githubToken);
+
+  // 处理API Keys
+  const existingApiKeys = Object.keys(existingConfig.apiKeys);
+  if (existingApiKeys.length > 0) {
+    console.log('\n现有的API Keys:');
+    existingApiKeys.forEach(key => console.log(`- ${key}`));
+    
+    const keepExistingApiKeys = await promptWithDefault('是否保留现有的API Keys? (y/n)', 'y');
+    if (keepExistingApiKeys.toLowerCase() === 'y') {
+      config.apiKeys = { ...existingConfig.apiKeys };
+    }
+  }
+
+  // 询问是否添加新的API Key
+  const addNewApiKey = await promptWithDefault('是否添加新的API Key? (y/n)', existingApiKeys.length === 0 ? 'y' : 'n');
+  if (addNewApiKey.toLowerCase() === 'y') {
+    const apiKey = await promptWithDefault('请输入自定义的API Key (不含sk-前缀，将自动添加)', '');
+    if (apiKey) {
+      const fullApiKey = apiKey.startsWith('sk-') ? apiKey : `sk-${apiKey}`;
+      config.apiKeys[fullApiKey] = [];
+    }
+  }
+
+  // 询问Cookie刷新模式
+  const refreshModePrompt = `选择Cookie刷新模式 [append/replace]`;
+  const defaultRefreshMode = existingConfig.cookieRefreshMode || 'replace';
+  config.cookieRefreshMode = await promptWithDefault(refreshModePrompt, defaultRefreshMode);
+
+  // 解释所选的刷新模式
+  if (config.cookieRefreshMode.toLowerCase() === 'replace') {
+    config.cookieRefreshMode = 'replace';
+    console.log('已选择替换模式: 每次刷新都将现有cookie全部标记为无效并替换成新cookie');
+  } else {
+    config.cookieRefreshMode = 'append';
+    console.log('已选择追加模式: 保留现有cookie，仅追加新cookie');
+  }
+
+  // 处理Email配置
+  if (existingConfig.emailConfigs.length > 0) {
+    console.log('\n现有的Gmail账号:');
+    existingConfig.emailConfigs.forEach((emailConfig, index) => {
+      console.log(`- ${index + 1}: ${emailConfig.email}`);
+    });
+    
+    const keepExistingEmails = await promptWithDefault('是否保留现有的Gmail账号? (y/n)', 'y');
+    if (keepExistingEmails.toLowerCase() === 'y') {
+      config.emailConfigs = [...existingConfig.emailConfigs];
+    }
+  }
+
+  // 询问是否添加新的Gmail账号
+  const addNewGmail = await promptWithDefault('是否添加新的Gmail账号? (y/n)', existingConfig.emailConfigs.length === 0 ? 'y' : 'n');
+  if (addNewGmail.toLowerCase() === 'y') {
+    printAppPasswordInstructions();
+    await askForGmailAccount(config);
+  } else if (config.emailConfigs.length === 0 && existingConfig.emailConfigs.length === 0) {
+    console.log('\n⚠️ 警告: 未添加Gmail账号，自动刷新功能可能无法正常工作');
+    console.log('你可以稍后在.env文件中手动配置REGISTER_EMAIL_CONFIGS\n');
+  }
+
+  return config;
+}
+
+// 询问Gmail账号
+async function askForGmailAccount(config) {
+  const addGmail = await promptWithDefault('\n是否添加Gmail账号用于注册? (y/n)', 'y');
+  
+  if (addGmail.toLowerCase() === 'y') {
+    const email = await promptWithDefault('请输入Gmail地址', '');
+    const password = await promptWithDefault('请输入Gmail的应用密码 (不是邮箱密码)', '');
+    
+    if (email && password) {
+      // 添加Email配置
+      config.emailConfigs.push({
+        email: email,
+        imap_server: "imap.gmail.com",
+        imap_port: 993,
+        username: email,
+        password: password
+      });
+    }
+    
+    const continueAnswer = await promptWithDefault('是否继续添加另一个Gmail账号? (y/n)', 'n');
+    if (continueAnswer.toLowerCase() === 'y') {
+      await askForGmailAccount(config);
+    }
+  }
+  
+  return config;
+}
+
+// 生成配置文件
+function generateEnvFile(config) {
+  try {
+    // 准备API Keys
+    const apiKeysJson = JSON.stringify(config.apiKeys);
+    
+    // 准备邮箱配置
+    const emailConfigsJson = JSON.stringify(config.emailConfigs);
+    
+    // 替换模板中的占位符
+    let envContent = ENV_TEMPLATE
+      .replace('{API_KEYS_PLACEHOLDER}', apiKeysJson)
+      .replace('{GITHUB_OWNER_PLACEHOLDER}', config.githubOwner)
+      .replace('{GITHUB_TOKEN_PLACEHOLDER}', config.githubToken)
+      .replace('{EMAIL_CONFIGS_PLACEHOLDER}', emailConfigsJson);
+      
+    // 更新Cookie刷新模式
+    envContent = envContent.replace('COOKIE_REFRESH_MODE=append', `COOKIE_REFRESH_MODE=${config.cookieRefreshMode}`);
+    
+    // 写入.env文件
+    const envPath = path.join(process.cwd(), '.env');
+    
+    // 检查是否存在备份文件
+    const backupPath = path.join(process.cwd(), '.env.backup');
+    if (fs.existsSync(envPath)) {
+      // 创建备份
+      fs.copyFileSync(envPath, backupPath);
+      console.log(`\n✅ 已创建原配置文件备份: ${backupPath}`);
+    }
+    
+    fs.writeFileSync(envPath, envContent, 'utf8');
+    console.log(`\n✅ 配置文件已生成: ${envPath}`);
+    
+    // 检查data目录
+    const dataDir = path.join(process.cwd(), 'data');
+    if (!fs.existsSync(dataDir)) {
+      fs.mkdirSync(dataDir, { recursive: true });
+      console.log(`✅ 创建数据目录: ${dataDir}`);
+    }
+    
+    return true;
+  } catch (error) {
+    console.error('\n❌ 生成配置文件时出错:', error.message);
+    return false;
+  }
+}
+
+// 主函数
+async function main() {
+  try {
+    const config = await collectConfig();
+    
+    if (generateEnvFile(config)) {
+      console.log('\n===== 配置完成 =====');
+      console.log('你可以使用以下命令启动服务:');
+      console.log('  npm start');
+      console.log('\n如需手动获取cookie执行:');
+      console.log('  npm run refresh-cookies');
+      
+      // 根据配置的刷新模式提供提示
+      console.log(`\n当前Cookie刷新模式为: ${config.cookieRefreshMode}`);
+      if (config.cookieRefreshMode === 'replace') {
+        console.log('每次刷新都会将现有cookie全部标记为无效并替换成新cookie');
+      } else {
+        console.log('刷新时会保留现有cookie，仅追加新cookie');
+      }
+      console.log('你可以在.env文件中修改COOKIE_REFRESH_MODE设置');
+    }
+  } catch (error) {
+    console.error('\n❌ 配置过程中出错:', error.message);
+  } finally {
+    rl.close();
+  }
+}
+
+// 运行主函数
+main(); 

src/app.js

@@ -0,0 +1,154 @@
+// 加载环境变量
+require('dotenv').config();
+
+// 环境检查
+const envChecker = require('./utils/envChecker');
+console.log('启动前检查环境配置...');
+envChecker.enforceEnvCheck();
+
+const express = require('express');
+const morgan = require('morgan');
+const path = require('path');
+const cron = require('node-cron');
+const app = express();
+
+const config = require('./config/config');
+const routes = require('./routes');
+const keyManager = require('./utils/keyManager');
+const cookieRefresher = require('./utils/cookieRefresher');
+const authMiddleware = require('./middleware/auth');
+
+// 初始化API Keys
+console.log('初始化API Keys...');
+keyManager.initializeApiKeys();
+
+// 输出最终的API Keys配置
+console.log('最终API Keys配置:', JSON.stringify(keyManager.getAllApiKeys().reduce((obj, key) => {
+  obj[key] = keyManager.getAllCookiesForApiKey(key);
+  return obj;
+}, {}), null, 2));
+
+// 添加CORS支持
+app.use((req, res, next) => {
+    res.header('Access-Control-Allow-Origin', '*');
+    res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept, Authorization');
+    res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+    
+    if (req.method === 'OPTIONS') {
+        return res.status(200).end();
+    }
+    
+    next();
+});
+
+app.use(express.json({ limit: '50mb' }));
+app.use(express.urlencoded({ extended: true, limit: '50mb' }));
+
+app.use(morgan(process.env.MORGAN_FORMAT ?? 'tiny'));
+
+// 添加静态文件支持
+app.use(express.static(path.join(__dirname, 'public')));
+
+// 添加根路由，重定向到登录页面
+app.get('/', (req, res) => {
+    res.redirect('/login.html');
+});
+
+// 添加认证中间件
+app.use(authMiddleware);
+
+app.use("/", routes)
+
+// 设置定时任务，自动刷新 Cookie
+if (config.refresh.enabled) {
+    const cronSchedule = config.refresh.cron;
+    const minCookieCount = config.refresh.minCookieCount;
+    
+    console.log(`启用自动刷新 Cookie，定时规则: ${cronSchedule}，最小 Cookie 数量: ${minCookieCount}`);
+    
+    cron.schedule(cronSchedule, async () => {
+        console.log('===== 自动刷新 Cookie 开始 =====');
+        console.log(`最小 Cookie 数量: ${minCookieCount}`);
+        
+        try {
+            // 获取所有 API Key
+            const apiKeys = keyManager.getAllApiKeys();
+            
+            if (apiKeys.length === 0) {
+                console.log('警告: 系统中没有找到任何 API Key');
+                
+                // 检查环境变量中是否有 API Keys
+                const envApiKeys = Object.keys(config.apiKeys);
+                if (envApiKeys.length > 0) {
+                    console.log(`检测到环境变量中有 ${envApiKeys.length} 个 API Key，但尚未加载到系统中`);
+                    console.log('正在重新初始化 API Keys...');
+                    
+                    // 重新获取 API Keys
+                    const refreshedApiKeys = keyManager.getAllApiKeys();
+                    if (refreshedApiKeys.length > 0) {
+                        console.log(`成功加载 ${refreshedApiKeys.length} 个 API Key，继续刷新流程`);
+                        // 继续执行后续刷新逻辑
+                    } else {
+                        console.log('初始化后仍未找到 API Key，请检查配置');
+                        console.log('===== 自动刷新 Cookie 结束 =====');
+                        return;
+                    }
+                } else {
+                    console.log('环境变量中也没有配置 API Key，请先添加 API Key');
+                    console.log('===== 自动刷新 Cookie 结束 =====');
+                    return;
+                }
+            }
+            
+            // 重新获取最新的 API Keys（可能已经通过上面的初始化更新了）
+            const updatedApiKeys = keyManager.getAllApiKeys();
+            console.log(`系统中共有 ${updatedApiKeys.length} 个 API Key`);
+            
+            // 按 Cookie 数量排序，优先处理 Cookie 数量少的 API Key
+            const sortedKeys = updatedApiKeys.sort((a, b) => {
+                const aCount = keyManager.getAllCookiesForApiKey(a).length;
+                const bCount = keyManager.getAllCookiesForApiKey(b).length;
+                return aCount - bCount; // 升序排列，Cookie 数量少的排在前面
+            });
+            
+            // 检查每个 API Key 是否需要刷新
+            let refreshedCount = 0;
+            let needRefreshCount = 0;
+            
+            for (const apiKey of sortedKeys) {
+                const cookies = keyManager.getAllCookiesForApiKey(apiKey);
+                console.log(`API Key: ${apiKey}, Cookie 数量: ${cookies.length}`);
+                
+                if (cookies.length < minCookieCount) {
+                    needRefreshCount++;
+                    console.log(`API Key ${apiKey} 的 Cookie 数量不足，需要刷新`);
+                    
+                    // 执行刷新
+                    console.log(`开始自动刷新 Cookie，目标 API Key: ${apiKey}，最小 Cookie 数量: ${minCookieCount}`);
+                    const result = await cookieRefresher.autoRefreshCookies(apiKey, minCookieCount);
+                    
+                    if (result.success) {
+                        refreshedCount++;
+                        console.log(`刷新结果: ${result.message}`);
+                    } else {
+                        console.error(`刷新失败: ${result.message}`);
+                    }
+                } else {
+                    console.log(`API Key ${apiKey} 的 Cookie 数量足够，不需要刷新`);
+                }
+            }
+            
+            console.log('===== 自动刷新 Cookie 完成 =====');
+            console.log(`共有 ${needRefreshCount} 个 API Key 需要刷新，成功刷新 ${refreshedCount} 个`);
+        } catch (error) {
+            console.error('自动刷新 Cookie 任务执行失败:', error);
+            console.log('===== 自动刷新 Cookie 异常结束 =====');
+        }
+    });
+} else {
+    console.log('未启用自动刷新 Cookie，如需启用请设置环境变量 ENABLE_AUTO_REFRESH=true');
+}
+
+app.listen(config.port, () => {
+    console.log(`The server listens port: ${config.port}`);
+});

src/config/config.js

@@ -0,0 +1,56 @@
+// 读取并解析API_KEYS环境变量
+// 解析API Keys配置
+let apiKeysConfig = {};
+try {
+    if (process.env.API_KEYS) {
+        // 解析API Keys字符串为对象
+        apiKeysConfig = JSON.parse(process.env.API_KEYS);
+        console.log('正在从环境变量加载API Keys...');
+        console.log(`成功解析API Keys，包含 ${Object.keys(apiKeysConfig).length} 个键`);
+    } else {
+        console.log('警告: 环境变量API_KEYS未设置，系统将无法正常工作');
+    }
+} catch (error) {
+    console.error('解析API_KEYS环境变量失败:', error.message);
+    console.error('请确保API_KEYS是有效的JSON格式');
+}
+
+// 导出配置
+module.exports = {
+    port: process.env.PORT || 3010,
+    apiKeys: apiKeysConfig,
+    defaultRotationStrategy: process.env.ROTATION_STRATEGY || 'round-robin',
+    
+    // 添加代理配置
+    proxy: {
+        enabled: process.env.PROXY_ENABLED === 'true' || false,
+        url: process.env.PROXY_URL || 'http://127.0.0.1:7890',
+    },
+    
+    // GitHub相关配置
+    github: {
+        token: process.env.GITHUB_TOKEN,
+        owner: process.env.GITHUB_OWNER,
+        repo: process.env.GITHUB_REPO,
+        workflowId: process.env.GITHUB_WORKFLOW_ID,
+        triggerWorkflow: process.env.TRIGGER_WORKFLOW === 'true'
+    },
+    
+    // 工作流参数
+    workflowParams: {
+        number: parseInt(process.env.REGISTER_NUMBER || '2', 10),
+        maxWorkers: parseInt(process.env.REGISTER_MAX_WORKERS || '1', 10),
+        emailServer: process.env.REGISTER_EMAIL_SERVER || 'TempEmail',
+        ingestToOneapi: process.env.REGISTER_INGEST_TO_ONEAPI === 'true',
+        uploadArtifact: process.env.REGISTER_UPLOAD_ARTIFACT === 'true',
+        useConfigFile: process.env.REGISTER_USE_CONFIG_FILE !== 'false',
+        emailConfigs: process.env.REGISTER_EMAIL_CONFIGS || '[]'
+    },
+    
+    // 刷新配置
+    refresh: {
+        cron: process.env.REFRESH_CRON || '0 */6 * * *',
+        minCookieCount: parseInt(process.env.MIN_COOKIE_COUNT || '2', 10),
+        enabled: process.env.ENABLE_AUTO_REFRESH === 'true'
+    }
+};

src/middleware/auth.js

@@ -0,0 +1,44 @@
+const admin = require('../models/admin');
+
+// 验证管理员权限的中间件
+function authMiddleware(req, res, next) {
+    // 跳过登录相关的路由
+    if (req.path.startsWith('/v1/admin/')) {
+        return next();
+    }
+
+    // 修改为：只对管理相关的API进行认证
+    if (req.path.startsWith('/v1/api-keys') || 
+        req.path.startsWith('/v1/invalid-cookies') || 
+        req.path.startsWith('/v1/refresh-cookies')) {
+        // 获取Authorization头
+        const authHeader = req.headers.authorization;
+        if (!authHeader || !authHeader.startsWith('Bearer ')) {
+            return res.status(401).json({
+                success: false,
+                message: '未提供认证token'
+            });
+        }
+
+        // 提取token
+        const token = authHeader.split(' ')[1];
+        
+        // 验证token
+        const result = admin.verifyToken(token);
+        if (!result.success) {
+            return res.status(401).json({
+                success: false,
+                message: '无效的token'
+            });
+        }
+
+        // 将用户信息添加到请求对象
+        req.admin = {
+            username: result.username
+        };
+    }
+
+    next();
+}
+
+module.exports = authMiddleware; 

src/models/admin.js

@@ -0,0 +1,114 @@
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const jwt = require('jsonwebtoken');
+
+// 管理员数据文件路径
+const ADMIN_FILE = path.join(__dirname, '../../data/admin.json');
+const JWT_SECRET = process.env.JWT_SECRET || 'your-secret-key';
+
+// 确保data目录存在
+const dataDir = path.dirname(ADMIN_FILE);
+if (!fs.existsSync(dataDir)) {
+    fs.mkdirSync(dataDir, { recursive: true });
+}
+
+// 确保admin.json文件存在
+if (!fs.existsSync(ADMIN_FILE)) {
+    fs.writeFileSync(ADMIN_FILE, JSON.stringify({ admin: null }), 'utf8');
+}
+
+class Admin {
+    constructor() {
+        this.loadAdmin();
+    }
+
+    // 加载管理员数据
+    loadAdmin() {
+        try {
+            const data = fs.readFileSync(ADMIN_FILE, 'utf8');
+            this.admin = JSON.parse(data).admin;
+        } catch (error) {
+            console.error('加载管理员数据失败:', error);
+            this.admin = null;
+        }
+    }
+
+    // 保存管理员数据
+    saveAdmin() {
+        try {
+            fs.writeFileSync(ADMIN_FILE, JSON.stringify({ admin: this.admin }), 'utf8');
+        } catch (error) {
+            console.error('保存管理员数据失败:', error);
+            throw error;
+        }
+    }
+
+    // 检查是否已有管理员
+    hasAdmin() {
+        return !!this.admin;
+    }
+
+    // 注册管理员
+    register(username, password) {
+        if (this.hasAdmin()) {
+            throw new Error('已存在管理员账号');
+        }
+
+        // 生成盐值
+        const salt = crypto.randomBytes(16).toString('hex');
+        // 使用盐值加密密码
+        const hash = crypto.pbkdf2Sync(password, salt, 1000, 64, 'sha512').toString('hex');
+
+        this.admin = {
+            username,
+            salt,
+            hash
+        };
+
+        this.saveAdmin();
+        return this.generateToken(username);
+    }
+
+    // 验证密码
+    verifyPassword(password, salt, hash) {
+        const testHash = crypto.pbkdf2Sync(password, salt, 1000, 64, 'sha512').toString('hex');
+        return testHash === hash;
+    }
+
+    // 登录验证
+    login(username, password) {
+        if (!this.admin || username !== this.admin.username) {
+            throw new Error('用户名或密码错误');
+        }
+
+        if (!this.verifyPassword(password, this.admin.salt, this.admin.hash)) {
+            throw new Error('用户名或密码错误');
+        }
+
+        return this.generateToken(username);
+    }
+
+    // 生成JWT token
+    generateToken(username) {
+        return jwt.sign({ username }, JWT_SECRET, { expiresIn: '24h' });
+    }
+
+    // 验证JWT token
+    verifyToken(token) {
+        try {
+            const decoded = jwt.verify(token, JWT_SECRET);
+            return {
+                success: true,
+                username: decoded.username
+            };
+        } catch (error) {
+            return {
+                success: false,
+                error: 'Invalid token'
+            };
+        }
+    }
+}
+
+module.exports = new Admin(); 

src/proto/message.proto

@@ -0,0 +1,133 @@
+syntax = "proto3";
+
+message AvailableModelsResponse { 
+  message AvailableModel {
+    string name = 1;
+    bool defaultOn = 2;
+    optional bool isLongContextOnly = 3;
+    optional bool isChatOnly = 4;
+  }
+  repeated AvailableModel models = 2;
+  repeated string modelNames = 1;
+}
+
+message MessageSummary {
+  string content = 1;
+  string summaryId1 = 2; 
+  string summaryId2 = 3; // uuid, equal to summaryId1
+  string previousSummaryId = 4; 
+}
+
+message MessageThinking {
+  string content = 1;
+}
+message StreamUnifiedChatWithToolsRequest {
+  message Request {
+    message Message {
+      message Image {
+        message Metadata {
+          int32 width = 1;
+          int32 height = 2;
+        }
+        bytes data = 1;
+        Metadata metadata = 2;
+      }
+      string content = 1;
+      int32 role = 2;
+      Image image = 10;
+      string messageId = 13;
+      string unknown29 = 29; // 1, only for user message
+      string summaryId = 32;
+      MessageSummary summary = 39;
+      MessageThinking thinking = 45;
+      int32 chatModeEnum = 47; // 1 for ask, 2 for agent, 3 for edit
+    }
+    message Instruction {
+      string instruction = 1;
+    }
+    message Model {
+      string name = 1;
+      bytes empty = 4;
+    }
+    message CursorSetting {
+      message Unknown6 {
+        bytes unknown1 = 1;
+        bytes unknown2 = 2;
+      }
+      string name = 1;
+      bytes unknown3 = 3;
+      Unknown6 unknown6 = 6;
+      int32 unknown8 = 8;
+      int32 unknown9 = 9;
+    }
+    message Metadata {
+      string os = 1; // win32
+      string arch = 2; // x64
+      string version = 3; // 10.0.22631
+      string path = 4; // C:\Program Files\PowerShell\7\pwsh.exe
+      string timestamp = 5; // 2025-03-03T13:10:08.590Z
+    }
+    message MessageId {
+      string messageId = 1;
+      string summaryId = 2;
+      int32 role = 3;
+    }
+
+    repeated Message messages = 1;
+    int32 unknown2 = 2; // 1
+    Instruction instruction = 3;
+    int32 unknown4 = 4; // 1
+    Model model = 5;
+    repeated string wikiTool = 7; // one url one item
+    string webTool = 8; // "full search"
+    int32 unknown13 = 13;
+    CursorSetting cursorSetting = 15;
+    int32 unknown19 = 19; // 1
+    int32 unknown22 = 22; // 1
+    string conversationId = 23; // uuid
+    Metadata metadata = 26;
+    int32 unknown27 = 27; // 1
+    string unknown29 = 29;
+    repeated MessageId messageIds = 30;
+    int32 largeContext = 35; // 1
+    int32 unknown38 = 38; // 0
+    int32 chatModeEnum = 46; // 1 for ask, 2 for agent, 3 for edit
+    string unknown47 = 47; 
+    int32 unknown48 = 48; // 0
+    int32 unknown49 = 49; // 0
+    int32 unknown51 = 51; // 0
+    int32 unknown53 = 53; // 0
+    string chatMode = 54;
+  }
+  
+  Request request = 1;
+}
+
+message StreamUnifiedChatWithToolsResponse {
+  message Message {
+    message WebTool {
+      message WebPage {
+        string url = 1;
+        string title = 2;
+        string content = 3;
+      }
+      repeated WebPage webPage = 1;
+    }
+    message Unknown12 {
+      message Content {
+        string content = 1;
+      }
+      Content content = 1;
+    }
+    string content = 1;
+    WebTool webtool = 11;
+    Unknown12 unknown12 = 12;
+    string unknown22 = 22; // uuid
+    string unknown23 = 23;
+    string unknown27 = 27; // uuid
+    MessageThinking thinking = 25;
+  }
+
+  Message message = 2;
+  MessageSummary summary = 3;
+}

src/public/index.html

@@ -0,0 +1,921 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Cursor To OpenAI - API Key 管理</title>
+    <style>
+        body {
+            font-family: 'Arial', sans-serif;
+            line-height: 1.6;
+            margin: 0;
+            padding: 20px;
+            color: #333;
+            max-width: 1200px;
+            margin: 0 auto;
+        }
+        h1, h2 {
+            color: #2c3e50;
+        }
+        .container {
+            display: flex;
+            flex-direction: column;
+            gap: 20px;
+        }
+        .card {
+            background: #fff;
+            border-radius: 8px;
+            box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
+            padding: 20px;
+        }
+        .form-group {
+            margin-bottom: 15px;
+        }
+        label {
+            display: block;
+            margin-bottom: 5px;
+            font-weight: bold;
+        }
+        input, textarea {
+            width: 100%;
+            padding: 8px;
+            border: 1px solid #ddd;
+            border-radius: 4px;
+            font-size: 16px;
+        }
+        textarea {
+            min-height: 100px;
+            font-family: monospace;
+        }
+        button {
+            background: #3498db;
+            color: white;
+            border: none;
+            padding: 10px 15px;
+            border-radius: 4px;
+            cursor: pointer;
+            font-size: 16px;
+        }
+        button:hover {
+            background: #2980b9;
+        }
+        table {
+            width: 100%;
+            border-collapse: collapse;
+        }
+        th, td {
+            padding: 12px;
+            text-align: left;
+            border-bottom: 1px solid #ddd;
+        }
+        th {
+            background-color: #f2f2f2;
+        }
+        .action-btn {
+            background: #e74c3c;
+            margin-right: 5px;
+        }
+        .action-btn:hover {
+            background: #c0392b;
+        }
+        .edit-btn {
+            background: #f39c12;
+            margin-right: 5px;
+        }
+        .edit-btn:hover {
+            background: #d35400;
+        }
+        .info {
+            background-color: #d4edda;
+            color: #155724;
+            padding: 10px;
+            border-radius: 4px;
+            margin-bottom: 15px;
+        }
+        .error {
+            background-color: #f8d7da;
+            color: #721c24;
+            padding: 10px;
+            border-radius: 4px;
+            margin-bottom: 15px;
+        }
+        .modal {
+            display: none;
+            position: fixed;
+            z-index: 1;
+            left: 0;
+            top: 0;
+            width: 100%;
+            height: 100%;
+            overflow: auto;
+            background-color: rgba(0,0,0,0.4);
+        }
+        .modal-content {
+            background-color: #fefefe;
+            margin: 15% auto;
+            padding: 20px;
+            border: 1px solid #888;
+            width: 80%;
+            max-width: 600px;
+            border-radius: 8px;
+        }
+        .close {
+            color: #aaa;
+            float: right;
+            font-size: 28px;
+            font-weight: bold;
+            cursor: pointer;
+        }
+        .close:hover,
+        .close:focus {
+            color: black;
+            text-decoration: none;
+        }
+        /* 无效Cookie样式 */
+        .cookie-text {
+            max-width: 80%;
+            word-break: break-all;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="card">
+            <h1>Cursor To OpenAI - API Key 管理</h1>
+            <p>在此页面上，您可以管理自定义 API Key 与 Cursor Cookie 的映射关系。</p>
+            <div style="margin-top: 10px; display: flex; justify-content: space-between; align-items: center;">
+                <div>
+                <button id="testApiBtn" style="margin-right: 10px;">测试API连接</button>
+                <button id="clearCacheBtn">清除缓存并刷新</button>
+                </div>
+                <div>
+                    <span id="adminUsername" style="margin-right: 10px;"></span>
+                    <button id="logoutBtn" style="background: #e74c3c;">退出登录</button>
+                </div>
+            </div>
+            <div id="testApiResult" style="margin-top: 10px;"></div>
+        </div>
+
+        <div class="card">
+            <h2>添加/更新 API Key</h2>
+            <div id="addKeyMessage"></div>
+            <form id="addKeyForm">
+                <div class="form-group">
+                    <label for="apiKey">API Key（自定义）</label>
+                    <input type="text" id="apiKey" name="apiKey" placeholder="输入您想使用的自定义 API Key" required>
+                </div>
+                <div class="form-group">
+                    <label for="cookieValues">Cursor Cookie 值（多个值请用逗号分隔）</label>
+                    <textarea id="cookieValues" name="cookieValues" placeholder="输入 WorkosCursorSessionToken 值，多个值请用逗号分隔" required></textarea>
+                </div>
+                <button type="submit">保存</button>
+            </form>
+        </div>
+
+        <div class="card">
+            <h2>现有 API Key</h2>
+            <div id="keyListMessage"></div>
+            <table id="keyTable">
+                <thead>
+                    <tr>
+                        <th>API Key</th>
+                        <th>Cookie 数量</th>
+                        <th>操作</th>
+                    </tr>
+                </thead>
+                <tbody id="keyList">
+                    <!-- 数据将通过 JavaScript 动态加载 -->
+                </tbody>
+            </table>
+        </div>
+
+        <div class="card">
+            <h2>使用说明</h2>
+            <ol>
+                <li>添加自定义 API Key 和对应的 Cursor Cookie 值。</li>
+                <li>使用自定义 API Key 作为 OpenAI API 的认证凭证。</li>
+                <li>系统将自动在多个 Cookie 之间进行轮询。</li>
+                <li>API 端点：
+                    <ul>
+                        <li>模型列表：<code>/v1/models</code></li>
+                        <li>聊天补全：<code>/v1/chat/completions</code></li>
+                    </ul>
+                </li>
+            </ol>
+        </div>
+    </div>
+
+    <!-- 修改 Cookie 的模态框 -->
+    <div id="editModal" class="modal">
+        <div class="modal-content">
+            <span class="close">&times;</span>
+            <h2>修改 API Key 的 Cookie</h2>
+            <div id="editModalMessage"></div>
+            <form id="editCookieForm">
+                <input type="hidden" id="editApiKey" name="editApiKey">
+                <div class="form-group">
+                    <label for="editCookieValues">Cursor Cookie 值（多个值请用逗号分隔）</label>
+                    <textarea id="editCookieValues" name="editCookieValues" placeholder="输入 WorkosCursorSessionToken 值，多个值请用逗号分隔" required></textarea>
+                </div>
+                <button type="submit">保存修改</button>
+            </form>
+        </div>
+    </div>
+
+    <div class="card">
+        <h2>无效Cookie管理</h2>
+        <div class="form-group">
+            <div class="info">
+                以下是系统自动检测到的无效Cookie列表。这些Cookie在请求过程中被发现无效，已被自动从API Key中移除。
+            </div>
+            <div id="invalidCookiesContainer">
+                <div style="text-align: center; padding: 20px;">
+                    <div>加载中...</div>
+                </div>
+            </div>
+            <button id="clearAllInvalidCookies" style="background: #e74c3c;">清除所有无效Cookie</button>
+        </div>
+    </div>
+
+    <!-- 新增：Cookie刷新功能 -->
+    <div class="card">
+        <h2>Cookie自动刷新</h2>
+        <div class="form-group">
+            <div class="info">
+                系统支持自动刷新Cookie，确保API Key始终有足够的可用Cookie。您可以在此手动触发刷新操作。
+            </div>
+            <div id="refreshCookieMessage"></div>
+            <div style="margin-top: 15px;">
+                <div class="form-group">
+                    <label for="refreshApiKey">选择要刷新的API Key（不选则刷新所有）</label>
+                    <select id="refreshApiKey" style="width: 100%; padding: 8px; border: 1px solid #ddd; border-radius: 4px; font-size: 16px;">
+                        <option value="">所有API Key</option>
+                        <!-- 选项将通过JavaScript动态加载 -->
+                    </select>
+                </div>
+                <button id="refreshCookieBtn" style="background: #27ae60;">刷新Cookie</button>
+            </div>
+            <div id="refreshStatusContainer" style="margin-top: 15px; display: none;">
+                <div class="info">
+                    <div>刷新状态：<span id="refreshStatus">准备中...</span></div>
+                    <div style="margin-top: 10px;">
+                        <progress id="refreshProgress" value="0" max="100" style="width: 100%;"></progress>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        // 获取模态框元素
+        const modal = document.getElementById('editModal');
+        const closeBtn = document.getElementsByClassName('close')[0];
+        
+        // 关闭模态框
+        closeBtn.onclick = function() {
+            modal.style.display = 'none';
+        }
+        
+        // 点击模态框外部关闭
+        window.onclick = function(event) {
+            if (event.target == modal) {
+                modal.style.display = 'none';
+            }
+        }
+        
+        // 加载现有 API Key
+        async function loadApiKeys() {
+            try {
+                console.log('开始加载API Keys...');
+                const response = await fetch('/v1/api-keys', {
+                    method: 'GET',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Cache-Control': 'no-cache'
+                    }
+                });
+                
+                if (!response.ok) {
+                    throw new Error(`HTTP错误: ${response.status} ${response.statusText}`);
+                }
+                
+                console.log('API响应状态:', response.status);
+                const data = await response.json();
+                console.log('获取到的数据:', data);
+                
+                const keyList = document.getElementById('keyList');
+                keyList.innerHTML = '';
+                
+                if (data.success && data.apiKeys.length > 0) {
+                    data.apiKeys.forEach(key => {
+                        const row = document.createElement('tr');
+                        row.innerHTML = `
+                            <td>${key.key}</td>
+                            <td>${key.cookieCount}</td>
+                            <td>
+                                <button class="edit-btn" onclick="editApiKey('${key.key}')">修改</button>
+                                <button class="action-btn" onclick="deleteApiKey('${key.key}')">删除</button>
+                            </td>
+                        `;
+                        keyList.appendChild(row);
+                    });
+                } else {
+                    keyList.innerHTML = '<tr><td colspan="3">暂无 API Key</td></tr>';
+                }
+            } catch (error) {
+                console.error('加载 API Key 失败:', error);
+                document.getElementById('keyListMessage').innerHTML = `
+                    <div class="error">加载 API Key 失败: ${error.message}</div>
+                `;
+            }
+        }
+
+        // 添加/更新 API Key
+        document.getElementById('addKeyForm').addEventListener('submit', async function(e) {
+            e.preventDefault();
+            
+            const apiKey = document.getElementById('apiKey').value.trim();
+            const cookieValuesText = document.getElementById('cookieValues').value.trim();
+            
+            if (!apiKey || !cookieValuesText) {
+                document.getElementById('addKeyMessage').innerHTML = `
+                    <div class="error">API Key 和 Cookie 值不能为空</div>
+                `;
+                return;
+            }
+            
+            // 将逗号分隔的 Cookie 值转换为数组
+            const cookieValues = cookieValuesText.split(',').map(cookie => cookie.trim()).filter(cookie => cookie);
+            
+            try {
+                const response = await fetch('/v1/api-keys', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({
+                        apiKey,
+                        cookieValues,
+                    }),
+                });
+                
+                const data = await response.json();
+                
+                if (data.success) {
+                    document.getElementById('addKeyMessage').innerHTML = `
+                        <div class="info">API Key 添加/更新成功</div>
+                    `;
+                    document.getElementById('apiKey').value = '';
+                    document.getElementById('cookieValues').value = '';
+                    loadApiKeys();
+                } else {
+                    document.getElementById('addKeyMessage').innerHTML = `
+                        <div class="error">API Key 添加/更新失败: ${data.error}</div>
+                    `;
+                }
+            } catch (error) {
+                console.error('添加/更新 API Key 失败:', error);
+                document.getElementById('addKeyMessage').innerHTML = `
+                    <div class="error">添加/更新 API Key 失败: ${error.message}</div>
+                `;
+            }
+        });
+
+        // 删除 API Key
+        async function deleteApiKey(apiKey) {
+            if (!confirm(`确定要删除 API Key "${apiKey}" 吗？`)) {
+                return;
+            }
+            
+            try {
+                const response = await fetch(`/v1/api-keys/${encodeURIComponent(apiKey)}`, {
+                    method: 'DELETE',
+                });
+                
+                const data = await response.json();
+                
+                if (data.success) {
+                    document.getElementById('keyListMessage').innerHTML = `
+                        <div class="info">API Key 删除成功</div>
+                    `;
+                    loadApiKeys();
+                } else {
+                    document.getElementById('keyListMessage').innerHTML = `
+                        <div class="error">API Key ���除失败: ${data.error}</div>
+                    `;
+                }
+            } catch (error) {
+                console.error('删除 API Key 失败:', error);
+                document.getElementById('keyListMessage').innerHTML = `
+                    <div class="error">删除 API Key 失败: ${error.message}</div>
+                `;
+            }
+        }
+        
+        // 获取API Key的Cookie值
+        async function getCookiesForApiKey(apiKey) {
+            try {
+                const response = await fetch(`/v1/api-keys/${encodeURIComponent(apiKey)}/cookies`, {
+                    method: 'GET',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Cache-Control': 'no-cache'
+                    }
+                });
+                
+                if (!response.ok) {
+                    throw new Error(`HTTP错误: ${response.status} ${response.statusText}`);
+                }
+                
+                const data = await response.json();
+                return data.cookies;
+            } catch (error) {
+                console.error(`获取 ${apiKey} 的Cookie值失败:`, error);
+                throw error;
+            }
+        }
+        
+        // 修改 API Key
+        async function editApiKey(apiKey) {
+            try {
+                document.getElementById('editModalMessage').innerHTML = '';
+                document.getElementById('editApiKey').value = apiKey;
+                
+                // 获取当前Cookie值
+                const cookies = await getCookiesForApiKey(apiKey);
+                document.getElementById('editCookieValues').value = cookies.join(',');
+                
+                // 显示模态框
+                modal.style.display = 'block';
+            } catch (error) {
+                alert(`获取 ${apiKey} 的Cookie值失败: ${error.message}`);
+            }
+        }
+        
+        // 提交修改表单
+        document.getElementById('editCookieForm').addEventListener('submit', async function(e) {
+            e.preventDefault();
+            
+            const apiKey = document.getElementById('editApiKey').value.trim();
+            const cookieValuesText = document.getElementById('editCookieValues').value.trim();
+            
+            if (!apiKey || !cookieValuesText) {
+                document.getElementById('editModalMessage').innerHTML = `
+                    <div class="error">API Key 和 Cookie 值不能为空</div>
+                `;
+                return;
+            }
+            
+            // 将逗号分隔的 Cookie 值转换为数组
+            const cookieValues = cookieValuesText.split(',').map(cookie => cookie.trim()).filter(cookie => cookie);
+            
+            try {
+                const response = await fetch('/v1/api-keys', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({
+                        apiKey,
+                        cookieValues,
+                    }),
+                });
+                
+                const data = await response.json();
+                
+                if (data.success) {
+                    document.getElementById('editModalMessage').innerHTML = `
+                        <div class="info">Cookie 修改成功</div>
+                    `;
+                    setTimeout(() => {
+                        modal.style.display = 'none';
+                        loadApiKeys();
+                    }, 1500);
+                } else {
+                    document.getElementById('editModalMessage').innerHTML = `
+                        <div class="error">Cookie 修改失败: ${data.error}</div>
+                    `;
+                }
+            } catch (error) {
+                console.error('修改 Cookie 失败:', error);
+                document.getElementById('editModalMessage').innerHTML = `
+                    <div class="error">修改 Cookie 失败: ${error.message}</div>
+                `;
+            }
+        });
+
+        // 测试API连接
+        document.getElementById('testApiBtn').addEventListener('click', async function() {
+            const resultDiv = document.getElementById('testApiResult');
+            resultDiv.innerHTML = '<div class="info">正在测试API连接...</div>';
+            
+            try {
+                const response = await fetch('/v1/api-keys', {
+                    method: 'GET',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Cache-Control': 'no-cache'
+                    }
+                });
+                
+                resultDiv.innerHTML = `<div class="info">API响应状态: ${response.status}</div>`;
+                
+                if (!response.ok) {
+                    throw new Error(`HTTP错误: ${response.status} ${response.statusText}`);
+                }
+                
+                const data = await response.json();
+                resultDiv.innerHTML += `<div class="info">获取到的数据: ${JSON.stringify(data)}</div>`;
+            } catch (error) {
+                console.error('测试API失败:', error);
+                resultDiv.innerHTML = `<div class="error">测试API失败: ${error.message}</div>`;
+            }
+        });
+        
+        // 清除缓存并刷新
+        document.getElementById('clearCacheBtn').addEventListener('click', function() {
+            // 清除缓存
+            if ('caches' in window) {
+                caches.keys().then(function(names) {
+                    for (let name of names) {
+                        caches.delete(name);
+                    }
+                });
+            }
+            
+            // 强制刷新页面（绕过缓存）
+            window.location.reload(true);
+        });
+
+        // 获取无效Cookie列表
+        async function getInvalidCookies() {
+            try {
+                const response = await fetch('/v1/invalid-cookies', {
+                    method: 'GET',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Cache-Control': 'no-cache'
+                    }
+                });
+                
+                if (!response.ok) {
+                    throw new Error(`HTTP错误: ${response.status} ${response.statusText}`);
+                }
+                
+                const data = await response.json();
+                return data.invalidCookies;
+            } catch (error) {
+                console.error('获取无效Cookie失败:', error);
+                throw error;
+            }
+        }
+        
+        // 清除特定无效Cookie
+        async function clearInvalidCookie(cookie) {
+            try {
+                const response = await fetch(`/v1/invalid-cookies/${encodeURIComponent(cookie)}`, {
+                    method: 'DELETE',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Cache-Control': 'no-cache'
+                    }
+                });
+                
+                if (!response.ok) {
+                    throw new Error(`HTTP错误: ${response.status} ${response.statusText}`);
+                }
+                
+                const data = await response.json();
+                return data.success;
+            } catch (error) {
+                console.error(`清除无效Cookie失败:`, error);
+                throw error;
+            }
+        }
+        
+        // 清除所有无效Cookie
+        async function clearAllInvalidCookies() {
+            try {
+                const response = await fetch('/v1/invalid-cookies', {
+                    method: 'DELETE',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Cache-Control': 'no-cache'
+                    }
+                });
+                
+                if (!response.ok) {
+                    throw new Error(`HTTP错误: ${response.status} ${response.statusText}`);
+                }
+                
+                const data = await response.json();
+                return data.success;
+            } catch (error) {
+                console.error('清除所有无效Cookie失败:', error);
+                throw error;
+            }
+        }
+        
+        // 渲染无效Cookie列表
+        async function renderInvalidCookies() {
+            const container = document.getElementById('invalidCookiesContainer');
+            
+            try {
+                const invalidCookies = await getInvalidCookies();
+                
+                if (invalidCookies.length === 0) {
+                    container.innerHTML = '<div class="info">没有检测到无效Cookie</div>';
+                    return;
+                }
+                
+                let html = '<table><thead><tr><th>无效Cookie</th><th>操作</th></tr></thead><tbody>';
+                
+                invalidCookies.forEach(cookie => {
+                    // 截断显示cookie，避免页面过长
+                    const displayCookie = cookie.length > 50 ? cookie.substring(0, 50) + '...' : cookie;
+                    
+                    html += `
+                        <tr>
+                            <td class="cookie-text" title="${cookie}">${displayCookie}</td>
+                            <td>
+                                <button class="action-btn clear-invalid-cookie" data-cookie="${cookie}">
+                                    清除
+                                </button>
+                            </td>
+                        </tr>
+                    `;
+                });
+                
+                html += '</tbody></table>';
+                container.innerHTML = html;
+                
+                // 添加清除按钮事件监听
+                document.querySelectorAll('.clear-invalid-cookie').forEach(button => {
+                    button.addEventListener('click', async function() {
+                        const cookie = this.getAttribute('data-cookie');
+                        
+                        try {
+                            await clearInvalidCookie(cookie);
+                            showMessage('invalidCookiesContainer', '无效Cookie已清除', 'info');
+                            renderInvalidCookies(); // 重新渲染列表
+                        } catch (error) {
+                            showMessage('invalidCookiesContainer', `清除失败: ${error.message}`, 'error');
+                        }
+                    });
+                });
+                
+            } catch (error) {
+                container.innerHTML = `<div class="error">加载失败: ${error.message}</div>`;
+            }
+        }
+        
+        // 清除所有无效Cookie按钮事件
+        document.getElementById('clearAllInvalidCookies').addEventListener('click', async function() {
+            try {
+                await clearAllInvalidCookies();
+                showMessage('invalidCookiesContainer', '所有无效Cookie已清除', 'info');
+                renderInvalidCookies(); // 重新渲染列表
+            } catch (error) {
+                showMessage('invalidCookiesContainer', `清除失败: ${error.message}`, 'error');
+            }
+        });
+        
+        // 页面加载时获取 API Key 列表和无效Cookie列表
+        document.addEventListener('DOMContentLoaded', function() {
+            checkAuth();
+            loadApiKeys();
+            renderInvalidCookies();
+            populateRefreshApiKeySelect();
+        });
+
+        // 显示消息的通用函数
+        function showMessage(containerId, message, type) {
+            const container = document.getElementById(containerId);
+            container.innerHTML = `<div class="${type}">${message}</div>`;
+        }
+
+        // 填充刷新API Key的下拉选择框
+        async function populateRefreshApiKeySelect() {
+            try {
+                const apiKeys = await getApiKeys();
+                const select = document.getElementById('refreshApiKey');
+                
+                // 清空现有选项（保留"所有API Key"选项）
+                while (select.options.length > 1) {
+                    select.remove(1);
+                }
+                
+                // 添加API Key选项
+                apiKeys.forEach(key => {
+                    const option = document.createElement('option');
+                    option.value = key.key;
+                    option.textContent = `${key.key} (${key.cookieCount} 个Cookie)`;
+                    select.appendChild(option);
+                });
+            } catch (error) {
+                console.error('加载API Key选项失败:', error);
+            }
+        }
+
+        // 获取API Keys的辅助函数
+        async function getApiKeys() {
+            const response = await fetch('/v1/api-keys', {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Cache-Control': 'no-cache'
+                }
+            });
+            
+            if (!response.ok) {
+                throw new Error(`HTTP错误: ${response.status} ${response.statusText}`);
+            }
+            
+            const data = await response.json();
+            return data.success ? data.apiKeys : [];
+        }
+
+        // 刷新Cookie按钮事件
+        document.getElementById('refreshCookieBtn').addEventListener('click', async function() {
+            const refreshBtn = this;
+            const apiKey = document.getElementById('refreshApiKey').value;
+            const statusContainer = document.getElementById('refreshStatusContainer');
+            const statusText = document.getElementById('refreshStatus');
+            const progressBar = document.getElementById('refreshProgress');
+            
+            // 禁用按钮，显示状态容器
+            refreshBtn.disabled = true;
+            statusContainer.style.display = 'block';
+            statusText.textContent = '正在发送刷新请求...';
+            progressBar.value = 10;
+            
+            try {
+                // 构建请求URL
+                let url = '/v1/refresh-cookies';
+                if (apiKey) {
+                    url += `?apiKey=${encodeURIComponent(apiKey)}`;
+                }
+                
+                // 发送刷新请求
+                statusText.textContent = '正在发送刷新请求...';
+                progressBar.value = 20;
+                
+                const response = await fetch(url, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Cache-Control': 'no-cache'
+                    }
+                });
+                
+                if (!response.ok) {
+                    throw new Error(`HTTP错误: ${response.status} ${response.statusText}`);
+                }
+                
+                // 显示长时间等待提示
+                statusText.textContent = '刷新请求已发送，请耐心等待2-12分钟...';
+                progressBar.value = 50;
+                showMessage('refreshCookieMessage', '刷新请求已发送，由于需要访问Cursor官网获取新Cookie，整个过程可能需要2-12分钟，请耐心等待。您可以关闭此页面，稍后再来查看结果。', 'info');
+                
+                // 启动定时检查刷新状态
+                let checkInterval = setInterval(async () => {
+                    try {
+                        const statusResponse = await fetch('/v1/refresh-status', {
+                            method: 'GET',
+                            headers: {
+                                'Cache-Control': 'no-cache'
+                            }
+                        });
+                        
+                        if (!statusResponse.ok) {
+                            throw new Error(`HTTP错误: ${statusResponse.status} ${statusResponse.statusText}`);
+                        }
+                        
+                        const statusData = await statusResponse.json();
+                        const refreshData = statusData.data;
+                        
+                        // 更新状态信息
+                        statusText.textContent = refreshData.message || '正在刷新...';
+                        
+                        // 根据状态更新进度条和UI
+                        if (refreshData.status === 'completed') {
+                            // 刷新完成
+                            progressBar.value = 100;
+                            statusText.textContent = `刷新完成: ${refreshData.message}`;
+                            clearInterval(checkInterval);
+                            
+                            // 重新加载API Key列表
+                            await loadApiKeys();
+                            await populateRefreshApiKeySelect();
+                            
+                            // 显示成功消息
+                            showMessage('refreshCookieMessage', `刷新完成: ${refreshData.message}`, 'success');
+                            
+                            // 启用按钮
+                            refreshBtn.disabled = false;
+                            
+                            // 3秒后隐藏状态容器
+                            setTimeout(() => {
+                                statusContainer.style.display = 'none';
+                            }, 3000);
+                        } else if (refreshData.status === 'failed') {
+                            // 刷新失败
+                            progressBar.value = 0;
+                            statusText.textContent = `刷新失败: ${refreshData.message}`;
+                            clearInterval(checkInterval);
+                            
+                            // 显示错误消息
+                            showMessage('refreshCookieMessage', `刷新失败: ${refreshData.message}`, 'error');
+                            
+                            // 启用按钮
+                            refreshBtn.disabled = false;
+                        } else if (refreshData.status === 'running') {
+                            // 正在刷新
+                            progressBar.value = 75;
+                        } else if (!refreshData.isRunning) {
+                            // 未知状态但不在运行
+                            clearInterval(checkInterval);
+                            refreshBtn.disabled = false;
+                        }
+                    } catch (error) {
+                        console.error('检查刷新状态失败:', error);
+                    }
+                }, 5000); // 每5秒检查一次
+                
+                // 设置超时检查，12分钟后如果还没完成就停止检查
+                setTimeout(() => {
+                    if (checkInterval) {
+                        clearInterval(checkInterval);
+                        refreshBtn.disabled = false;
+                        statusContainer.style.display = 'none';
+                    }
+                }, 720000);
+            } catch (error) {
+                console.error('刷新Cookie失败:', error);
+                statusText.textContent = '刷新请求发送失败';
+                progressBar.value = 0;
+                showMessage('refreshCookieMessage', `刷新请求发送失败: ${error.message}`, 'error');
+                refreshBtn.disabled = false;
+            }
+        });
+
+        // 检查登录状态
+        function checkAuth() {
+            const token = localStorage.getItem('adminToken');
+            if (!token) {
+                window.location.href = '/login.html';
+                return;
+            }
+            
+            // 验证token
+            fetch('/v1/admin/verify', {
+                headers: {
+                    'Authorization': `Bearer ${token}`
+                }
+            })
+            .then(response => response.json())
+            .then(data => {
+                if (!data.success) {
+                    localStorage.removeItem('adminToken');
+                    window.location.href = '/login.html';
+                } else {
+                    // 显示管理员用户名
+                    document.getElementById('adminUsername').textContent = `管理员：${data.username}`;
+                }
+            })
+            .catch(error => {
+                console.error('验证失败:', error);
+                localStorage.removeItem('adminToken');
+                window.location.href = '/login.html';
+            });
+        }
+
+        // 退出登录
+        document.getElementById('logoutBtn').addEventListener('click', () => {
+            localStorage.removeItem('adminToken');
+            window.location.href = '/login.html';
+        });
+
+        // 添加token到所有API请求
+        function addAuthHeader(headers = {}) {
+            const token = localStorage.getItem('adminToken');
+            return {
+                ...headers,
+                'Authorization': `Bearer ${token}`
+            };
+        }
+
+        // 修改所有fetch请求，添加token
+        const originalFetch = window.fetch;
+        window.fetch = function(url, options = {}) {
+            // 只对管理页面的API请求添加token
+            if (url.includes('/v1/api-keys') || 
+                url.includes('/v1/invalid-cookies') || 
+                url.includes('/v1/refresh-cookies')) {
+                options.headers = addAuthHeader(options.headers);
+            }
+            return originalFetch(url, options);
+        };
+    </script>
+</body>
+</html> 

src/public/login.html

@@ -0,0 +1,243 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Cursor To OpenAI - 管理员登录</title>
+    <style>
+        body {
+            font-family: 'Arial', sans-serif;
+            line-height: 1.6;
+            margin: 0;
+            padding: 20px;
+            color: #333;
+            background-color: #f5f5f5;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            min-height: 100vh;
+        }
+        .container {
+            background: #fff;
+            padding: 30px;
+            border-radius: 8px;
+            box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
+            width: 100%;
+            max-width: 400px;
+        }
+        h1 {
+            color: #2c3e50;
+            text-align: center;
+            margin-bottom: 30px;
+        }
+        .form-group {
+            margin-bottom: 20px;
+        }
+        label {
+            display: block;
+            margin-bottom: 5px;
+            font-weight: bold;
+        }
+        input {
+            width: 100%;
+            padding: 10px;
+            border: 1px solid #ddd;
+            border-radius: 4px;
+            font-size: 16px;
+            box-sizing: border-box;
+        }
+        button {
+            background: #3498db;
+            color: white;
+            border: none;
+            padding: 12px 20px;
+            border-radius: 4px;
+            cursor: pointer;
+            font-size: 16px;
+            width: 100%;
+            margin-top: 10px;
+        }
+        button:hover {
+            background: #2980b9;
+        }
+        .message {
+            margin-top: 20px;
+            padding: 10px;
+            border-radius: 4px;
+            text-align: center;
+        }
+        .error {
+            background-color: #f8d7da;
+            color: #721c24;
+        }
+        .info {
+            background-color: #d4edda;
+            color: #155724;
+        }
+        .toggle-form {
+            text-align: center;
+            margin-top: 20px;
+            color: #3498db;
+            cursor: pointer;
+        }
+        #registerForm {
+            display: none;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>管理员登录</h1>
+        
+        <!-- 登录表单 -->
+        <form id="loginForm">
+            <div class="form-group">
+                <label for="loginUsername">用户名</label>
+                <input type="text" id="loginUsername" required>
+            </div>
+            <div class="form-group">
+                <label for="loginPassword">密码</label>
+                <input type="password" id="loginPassword" required>
+            </div>
+            <button type="submit">登录</button>
+            <div id="loginMessage" class="message"></div>
+        </form>
+        
+        <!-- 注册表单 -->
+        <form id="registerForm">
+            <div class="form-group">
+                <label for="registerUsername">用户名</label>
+                <input type="text" id="registerUsername" required>
+            </div>
+            <div class="form-group">
+                <label for="registerPassword">密码</label>
+                <input type="password" id="registerPassword" required>
+            </div>
+            <div class="form-group">
+                <label for="confirmPassword">确认密码</label>
+                <input type="password" id="confirmPassword" required>
+            </div>
+            <button type="submit">注册</button>
+            <div id="registerMessage" class="message"></div>
+        </form>
+        
+        <div class="toggle-form" id="toggleForm">
+            还没有账号？点击注册
+        </div>
+    </div>
+
+    <script>
+        // 获取元素
+        const loginForm = document.getElementById('loginForm');
+        const registerForm = document.getElementById('registerForm');
+        const toggleForm = document.getElementById('toggleForm');
+        const loginMessage = document.getElementById('loginMessage');
+        const registerMessage = document.getElementById('registerMessage');
+
+        // 切换表单显示
+        let isLoginForm = true;
+        toggleForm.addEventListener('click', () => {
+            isLoginForm = !isLoginForm;
+            loginForm.style.display = isLoginForm ? 'block' : 'none';
+            registerForm.style.display = isLoginForm ? 'none' : 'block';
+            toggleForm.textContent = isLoginForm ? '还没有账号？点击注册' : '已有账号？点击登录';
+            loginMessage.textContent = '';
+            registerMessage.textContent = '';
+        });
+
+        // 检查是否已有管理员账号
+        async function checkAdminExists() {
+            try {
+                const response = await fetch('/v1/admin/check');
+                const data = await response.json();
+                
+                if (data.exists) {
+                    // 如果已有管理员，显示登录表单
+                    loginForm.style.display = 'block';
+                    registerForm.style.display = 'none';
+                    toggleForm.style.display = 'none';
+                } else {
+                    // 如果没有管理员，显示注册表单
+                    loginForm.style.display = 'none';
+                    registerForm.style.display = 'block';
+                    toggleForm.style.display = 'none';
+                    registerMessage.innerHTML = '<div class="info">首次使用，请注册管理员账号</div>';
+                }
+            } catch (error) {
+                console.error('检查管理员账号失败:', error);
+            }
+        }
+
+        // 登录处理
+        loginForm.addEventListener('submit', async (e) => {
+            e.preventDefault();
+            
+            const username = document.getElementById('loginUsername').value;
+            const password = document.getElementById('loginPassword').value;
+            
+            try {
+                const response = await fetch('/v1/admin/login', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({ username, password }),
+                });
+                
+                const data = await response.json();
+                
+                if (data.success) {
+                    // 登录成功，保存token并跳转
+                    localStorage.setItem('adminToken', data.token);
+                    window.location.href = '/index.html';
+                } else {
+                    loginMessage.innerHTML = `<div class="error">${data.message}</div>`;
+                }
+            } catch (error) {
+                console.error('登录失败:', error);
+                loginMessage.innerHTML = '<div class="error">登录失败，请稍后重试</div>';
+            }
+        });
+
+        // 注册处理
+        registerForm.addEventListener('submit', async (e) => {
+            e.preventDefault();
+            
+            const username = document.getElementById('registerUsername').value;
+            const password = document.getElementById('registerPassword').value;
+            const confirmPassword = document.getElementById('confirmPassword').value;
+            
+            if (password !== confirmPassword) {
+                registerMessage.innerHTML = '<div class="error">两次输入的密码不一致</div>';
+                return;
+            }
+            
+            try {
+                const response = await fetch('/v1/admin/register', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({ username, password }),
+                });
+                
+                const data = await response.json();
+                
+                if (data.success) {
+                    // 注册成功，保存token并跳转
+                    localStorage.setItem('adminToken', data.token);
+                    window.location.href = '/index.html';
+                } else {
+                    registerMessage.innerHTML = `<div class="error">${data.message}</div>`;
+                }
+            } catch (error) {
+                console.error('注册失败:', error);
+                registerMessage.innerHTML = '<div class="error">注册失败，请稍后重试</div>';
+            }
+        });
+
+        // 页面加载时检查管理员账号
+        document.addEventListener('DOMContentLoaded', checkAdminExists);
+    </script>
+</body>
+</html> 

src/routes/index.js

@@ -0,0 +1,8 @@
+const express = require('express');
+const router = express.Router();
+const v1Routes = require('./v1');
+
+// OpenAI v1 API routes
+router.use('/v1', v1Routes);
+
+module.exports = router;

src/routes/v1.js

@@ -0,0 +1,944 @@
+const express = require('express');
+const router = express.Router();
+const { fetch, ProxyAgent, Agent } = require('undici');
+
+const $root = require('../proto/message.js');
+const { v4: uuidv4, v5: uuidv5 } = require('uuid');
+const { generateCursorBody, chunkToUtf8String, generateHashed64Hex, generateCursorChecksum } = require('../utils/utils.js');
+const keyManager = require('../utils/keyManager.js');
+const { spawn } = require('child_process');
+const path = require('path');
+const admin = require('../models/admin');
+const config = require('../config/config');
+
+// 存储刷新状态的变量
+let refreshStatus = {
+  isRunning: false,
+  status: 'idle', // idle, running, completed, failed
+  message: '',
+  startTime: null,
+  endTime: null,
+  error: null
+};
+
+// 检查是否已有管理员账号
+router.get('/admin/check', (req, res) => {
+  try {
+    return res.json({
+      success: true,
+      exists: admin.hasAdmin()
+    });
+  } catch (error) {
+    console.error('检查管理员账号失败:', error);
+    return res.status(500).json({
+      success: false,
+      message: error.message
+    });
+  }
+});
+
+// 注册管理员
+router.post('/admin/register', (req, res) => {
+  try {
+    const { username, password } = req.body;
+    
+    if (!username || !password) {
+      return res.status(400).json({
+        success: false,
+        message: '用户名和密码不能为空'
+      });
+    }
+    
+    const token = admin.register(username, password);
+    
+    return res.json({
+      success: true,
+      message: '注册成功',
+      token
+    });
+  } catch (error) {
+    console.error('注册管理员失败:', error);
+    return res.status(400).json({
+      success: false,
+      message: error.message
+    });
+  }
+});
+
+// 管理员登录
+router.post('/admin/login', (req, res) => {
+  try {
+    const { username, password } = req.body;
+    
+    if (!username || !password) {
+      return res.status(400).json({
+        success: false,
+        message: '用户名和密码不能为空'
+      });
+    }
+    
+    const token = admin.login(username, password);
+    
+    return res.json({
+      success: true,
+      message: '登录成功',
+      token
+    });
+  } catch (error) {
+    console.error('登录失败:', error);
+    return res.status(400).json({
+      success: false,
+      message: error.message
+    });
+  }
+});
+
+// 验证token
+router.get('/admin/verify', (req, res) => {
+  try {
+    const authHeader = req.headers.authorization;
+    if (!authHeader || !authHeader.startsWith('Bearer ')) {
+      return res.status(401).json({
+        success: false,
+        message: '未提供认证token'
+      });
+    }
+    
+    const token = authHeader.split(' ')[1];
+    const result = admin.verifyToken(token);
+    
+    return res.json(result);
+  } catch (error) {
+    console.error('验证token失败:', error);
+    return res.status(401).json({
+      success: false,
+      message: error.message
+    });
+  }
+});
+
+// 添加API key管理路由
+router.post("/api-keys", async (req, res) => {
+  try {
+    const { apiKey, cookieValues } = req.body;
+    
+    if (!apiKey || !cookieValues) {
+      return res.status(400).json({
+        error: 'API key and cookie values are required',
+      });
+    }
+    
+    keyManager.addOrUpdateApiKey(apiKey, cookieValues);
+    
+    return res.json({
+      success: true,
+      message: 'API key added or updated successfully',
+    });
+  } catch (error) {
+    console.error(error);
+    return res.status(500).json({
+      error: 'Internal server error',
+    });
+  }
+});
+
+// 获取所有API Keys
+router.get("/api-keys", async (req, res) => {
+  try {
+    console.log('收到获取API Keys请求');
+    const apiKeys = keyManager.getAllApiKeys();
+    console.log('获取到的API Keys:', apiKeys);
+    
+    const result = {
+      success: true,
+      apiKeys: apiKeys.map(apiKey => ({
+        key: apiKey,
+        cookieCount: keyManager.getAllCookiesForApiKey(apiKey).length,
+      })),
+    };
+    console.log('返回结果:', result);
+    
+    return res.json(result);
+  } catch (error) {
+    console.error('获取API Keys失败:', error);
+    return res.status(500).json({
+      error: 'Internal server error',
+      message: error.message
+    });
+  }
+});
+
+// 删除API key
+router.delete("/api-keys/:apiKey", async (req, res) => {
+  try {
+    const { apiKey } = req.params;
+    
+    keyManager.removeApiKey(apiKey);
+    
+    return res.json({
+      success: true,
+      message: 'API key removed successfully',
+    });
+  } catch (error) {
+    console.error(error);
+    return res.status(500).json({
+      error: 'Internal server error',
+    });
+  }
+});
+
+// 获取特定API Key的Cookie值
+router.get("/api-keys/:apiKey/cookies", async (req, res) => {
+  try {
+    const { apiKey } = req.params;
+    console.log(`收到获取API Key ${apiKey}的Cookie值请求`);
+    
+    const cookies = keyManager.getAllCookiesForApiKey(apiKey);
+    console.log(`API Key ${apiKey}的Cookie值:`, cookies);
+    
+    return res.json({
+      success: true,
+      cookies: cookies
+    });
+  } catch (error) {
+    console.error(`获取API Key ${req.params.apiKey}的Cookie值失败:`, error);
+    return res.status(500).json({
+      error: 'Internal server error',
+      message: error.message
+    });
+  }
+});
+
+// 获取所有无效的cookie
+router.get("/invalid-cookies", async (req, res) => {
+  try {
+    const invalidCookies = keyManager.getInvalidCookies();
+    
+    return res.json({
+      success: true,
+      invalidCookies: Array.from(invalidCookies)
+    });
+  } catch (error) {
+    console.error('获取无效cookie失败:', error);
+    return res.status(500).json({
+      error: 'Internal server error',
+      message: error.message
+    });
+  }
+});
+
+// 清除特定的无效cookie
+router.delete("/invalid-cookies/:cookie", async (req, res) => {
+  try {
+    const { cookie } = req.params;
+    const success = keyManager.clearInvalidCookie(cookie);
+    
+    return res.json({
+      success: success,
+      message: success ? '无效cookie已清除' : '未找到指定的无效cookie'
+    });
+  } catch (error) {
+    console.error('清除无效cookie失败:', error);
+    return res.status(500).json({
+      error: 'Internal server error',
+      message: error.message
+    });
+  }
+});
+
+// 清除所有无效cookie
+router.delete("/invalid-cookies", async (req, res) => {
+  try {
+    keyManager.clearAllInvalidCookies();
+    
+    return res.json({
+      success: true,
+      message: '所有无效cookie已清除'
+    });
+  } catch (error) {
+    console.error('清除所有无效cookie失败:', error);
+    return res.status(500).json({
+      error: 'Internal server error',
+      message: error.message
+    });
+  }
+});
+
+router.get("/models", async (req, res) => {
+  try{
+    let bearerToken = req.headers.authorization?.replace('Bearer ', '');
+    
+    // 使用keyManager获取实际的cookie
+    let authToken = keyManager.getCookieForApiKey(bearerToken);
+    
+    if (authToken && authToken.includes('%3A%3A')) {
+      authToken = authToken.split('%3A%3A')[1];
+    }
+    else if (authToken && authToken.includes('::')) {
+      authToken = authToken.split('::')[1];
+    }
+
+    const checksum = req.headers['x-cursor-checksum'] 
+      ?? process.env['x-cursor-checksum'] 
+      ?? generateCursorChecksum(authToken.trim());
+    //const cursorClientVersion = "0.45.11"
+    const cursorClientVersion = "0.48.7";
+
+    const availableModelsResponse = await fetch("https://api2.cursor.sh/aiserver.v1.AiService/AvailableModels", {
+      method: 'POST',
+      headers: {
+        'accept-encoding': 'gzip',
+        'authorization': `Bearer ${authToken}`,
+        'connect-protocol-version': '1',
+        'content-type': 'application/proto',
+        'user-agent': 'connect-es/1.6.1',
+        'x-cursor-checksum': checksum,
+        'x-cursor-client-version': cursorClientVersion,
+        'x-cursor-config-version': uuidv4(),
+        'x-cursor-timezone': 'Asia/Shanghai',
+        'x-ghost-mode': 'true',
+        'Host': 'api2.cursor.sh',
+      },
+    })
+    const data = await availableModelsResponse.arrayBuffer();
+    const buffer = Buffer.from(data);
+    try{
+      const models = $root.AvailableModelsResponse.decode(buffer).models;
+
+      return res.json({
+        object: "list",
+        data: models.map(model => ({
+          id: model.name,
+          created: Date.now(),
+          object: 'model',
+          owned_by: 'cursor'
+        }))
+      })
+    } catch (error) {
+      const text = buffer.toString('utf-8');
+      throw new Error(text);      
+    }
+  }
+  catch (error) {
+    console.error(error);
+    return res.status(500).json({
+      error: 'Internal server error',
+    });
+  }
+})
+
+router.post('/chat/completions', async (req, res) => {
+  // o1开头的模型，不支持流式输出
+  if (req.body.model.startsWith('o1-') && req.body.stream) {
+    return res.status(400).json({
+      error: 'Model not supported stream',
+    });
+  }
+
+  try {
+    const { model, messages, stream = false } = req.body;
+    let bearerToken = req.headers.authorization?.replace('Bearer ', '');
+    
+    // 使用keyManager获取实际的cookie
+    let authToken = keyManager.getCookieForApiKey(bearerToken);
+    // 保存原始cookie，用于后续可能的错误处理
+    const originalAuthToken = authToken;
+    //console.log('原始cookie:', originalAuthToken);
+
+    if (authToken && authToken.includes('%3A%3A')) {
+      authToken = authToken.split('%3A%3A')[1];
+    }
+    else if (authToken && authToken.includes('::')) {
+      authToken = authToken.split('::')[1];
+    }
+
+    if (!messages || !Array.isArray(messages) || messages.length === 0 || !authToken) {
+      return res.status(400).json({
+        error: 'Invalid request. Messages should be a non-empty array and authorization is required',
+      });
+    }
+
+    const checksum = req.headers['x-cursor-checksum'] 
+      ?? process.env['x-cursor-checksum'] 
+      ?? generateCursorChecksum(authToken.trim());
+
+    const sessionid = uuidv5(authToken,  uuidv5.DNS);
+    const clientKey = generateHashed64Hex(authToken)
+    //const cursorClientVersion = "0.45.11"
+    const cursorClientVersion = "0.48.7";
+    // Request the AvailableModels before StreamChat.
+    const availableModelsResponse = await fetch("https://api2.cursor.sh/aiserver.v1.AiService/AvailableModels", {
+      method: 'POST',
+      headers: {
+        'accept-encoding': 'gzip',
+        'authorization': `Bearer ${authToken}`,
+        'connect-protocol-version': '1',
+        'content-type': 'application/proto',
+        'user-agent': 'connect-es/1.6.1',
+        'x-amzn-trace-id': `Root=${uuidv4()}`,
+        'x-client-key': clientKey,
+        'x-cursor-checksum': checksum,
+        'x-cursor-client-version': cursorClientVersion,
+        'x-cursor-timezone': 'Asia/Shanghai',
+        'x-ghost-mode': 'true',
+        "x-request-id": uuidv4(),
+        "x-session-id": sessionid,
+        'Host': 'api2.cursor.sh',
+      },
+    })
+
+    const cursorBody = generateCursorBody(messages, model);
+    
+    // 添加代理支持
+    const dispatcher = config.proxy && config.proxy.enabled
+      ? new ProxyAgent(config.proxy.url, { allowH2: true })
+      : new Agent({ allowH2: true });
+    
+    // 更新接口地址为 StreamUnifiedChatWithTools
+    const response = await fetch('https://api2.cursor.sh/aiserver.v1.ChatService/StreamUnifiedChatWithTools', {
+      method: 'POST',
+      headers: {
+        'authorization': `Bearer ${authToken}`,
+        'connect-accept-encoding': 'gzip',
+        'connect-content-encoding': 'gzip',
+        'connect-protocol-version': '1',
+        'content-type': 'application/connect+proto',
+        'user-agent': 'connect-es/1.6.1',
+        'x-amzn-trace-id': `Root=${uuidv4()}`,
+        'x-client-key': clientKey,
+        'x-cursor-checksum': checksum,
+        'x-cursor-client-version': cursorClientVersion,
+        'x-cursor-config-version': uuidv4(),
+        'x-cursor-timezone': 'Asia/Shanghai',
+        'x-ghost-mode': 'true',
+        'x-request-id': uuidv4(),
+        'x-session-id': sessionid,
+        'Host': 'api2.cursor.sh',
+      },
+      body: cursorBody,
+      dispatcher: dispatcher,
+      timeout: {
+        connect: 5000,
+        read: 30000
+      }
+    });
+
+    // 处理响应
+    if (stream) {
+      res.setHeader('Content-Type', 'text/event-stream');
+      res.setHeader('Cache-Control', 'no-cache');
+      res.setHeader('Connection', 'keep-alive');
+
+      const responseId = `chatcmpl-${uuidv4()}`;
+      
+
+      try {
+        let responseEnded = false; // 添加标志，标记响应是否已结束
+        
+        for await (const chunk of response.body) {
+          // 如果响应已结束，不再处理后续数据
+          if (responseEnded) {
+            continue;
+          }
+          
+          let text = chunkToUtf8String(chunk);
+          // 输出完整的text内容和类型，便于调试
+          //console.log("收到的响应:", typeof text, text && typeof text === 'object' ? JSON.stringify(text) : text);
+
+          
+          // 检查是否返回了错误对象
+          if (text && typeof text === 'object' && text.error) {
+            // 检查是否包含特定的无效cookie错误信息
+            const errorStr = typeof text.error === 'string' ? text.error : JSON.stringify(text.error);
+            
+            // 处理错误并获取结果
+            const errorResult = handleCursorError(errorStr, bearerToken, originalAuthToken);
+            
+            // 如果是需要移除的cookie，从API Key中移除
+            if (errorResult.shouldRemoveCookie) {
+              const removed = keyManager.removeCookieFromApiKey(bearerToken, originalAuthToken);
+              console.log(`Cookie移除${removed ? '成功' : '失败'}`);
+              
+              // 如果成功移除，在错误消息中添加明确提示
+              if (removed) {
+                errorResult.message = `⚠️ 目前Cookie已从API Key中移除 ⚠️\n\n${errorResult.message}`;
+              }
+            }
+            
+            // 返回错误信息给客户端，作为assistant消息
+            res.write(
+              `data: ${JSON.stringify({
+                id: responseId,
+                object: 'chat.completion.chunk',
+                created: Math.floor(Date.now() / 1000),
+                model: req.body.model,
+                choices: [
+                  {
+                    index: 0,
+                    delta: {
+                      content: errorResult.message,
+                    },
+                  },
+                ],
+              })}\n\n`
+            );
+            
+            res.write('data: [DONE]\n\n');
+            responseEnded = true; // 标记响应已结束
+            break; // 跳出循环，不再处理后续数据
+          }
+
+          if (text && text.length > 0) {
+            res.write(
+              `data: ${JSON.stringify({
+                id: responseId,
+                object: 'chat.completion.chunk',
+                created: Math.floor(Date.now() / 1000),
+                model: req.body.model,
+                choices: [
+                  {
+                    index: 0,
+                    delta: {
+                      content: text,
+                    },
+                  },
+                ],
+              })}\n\n`
+            );
+          }
+        }
+        
+        // 只有在响应尚未结束的情况下，才发送结束标记
+        if (!responseEnded) {
+          res.write('data: [DONE]\n\n');
+          res.end();
+        }
+      } catch (streamError) {
+        console.error('Stream error:', streamError);
+        // 确保在发送错误信息前检查响应是否已结束
+        if (!res.writableEnded) {
+          if (streamError.name === 'TimeoutError') {
+            // 将超时错误作为assistant消息发送
+            const errorMessage = `⚠️ 请求超时 ⚠️\n\n错误：服务器响应超时，请稍后重试。`;
+            res.write(
+              `data: ${JSON.stringify({
+                id: responseId,
+                object: 'chat.completion.chunk',
+                created: Math.floor(Date.now() / 1000),
+                model: req.body.model,
+                choices: [
+                  {
+                    index: 0,
+                    delta: {
+                      content: errorMessage,
+                    },
+                  },
+                ],
+              })}\n\n`
+            );
+          } else {
+            // 将处理错误作为assistant消息发送
+            const errorMessage = `⚠️ 处理错误 ⚠️\n\n错误：流处理出错，请稍后重试。\n\n${streamError.message || ''}`;
+            res.write(
+              `data: ${JSON.stringify({
+                id: responseId,
+                object: 'chat.completion.chunk',
+                created: Math.floor(Date.now() / 1000),
+                model: req.body.model,
+                choices: [
+                  {
+                    index: 0,
+                    delta: {
+                      content: errorMessage,
+                    },
+                  },
+                ],
+              })}\n\n`
+            );
+          }
+          res.write('data: [DONE]\n\n');
+          res.end();
+        }
+      }
+    } else {
+      try {
+        let text = '';
+        let responseEnded = false; // 添加标志，标记响应是否已结束
+        
+        for await (const chunk of response.body) {
+          // 如果响应已结束，不再处理后续数据
+          if (responseEnded) {
+            continue;
+          }
+          
+          const chunkText = chunkToUtf8String(chunk);
+          // 输出完整的chunkText内容和类型，便于调试
+          //console.log("收到的非流式响应:", typeof chunkText, chunkText && typeof chunkText === 'object' ? JSON.stringify(chunkText) : chunkText);
+          
+          // 检查是否返回了错误对象
+          if (chunkText && typeof chunkText === 'object' && chunkText.error) {
+            //console.error('检测到错误响应:', chunkText.error);
+            
+            // 检查是否包含特定的无效cookie错误信息
+            const errorStr = typeof chunkText.error === 'string' ? chunkText.error : JSON.stringify(chunkText.error);
+            
+            // 处理错误并获取结果
+            const errorResult = handleCursorError(errorStr, bearerToken, originalAuthToken);
+            
+            // 如果是需要移除的cookie，从API Key中移除
+            if (errorResult.shouldRemoveCookie) {
+              const removed = keyManager.removeCookieFromApiKey(bearerToken, originalAuthToken);
+              console.log(`Cookie移除${removed ? '成功' : '失败'}`);
+              
+              // 如果成功移除，在错误消息中添加明确提示
+              if (removed) {
+                errorResult.message = `⚠️ 目前Cookie已从API Key中移除 ⚠️\n\n${errorResult.message}`;
+              }
+            }
+            
+            // 无效cookie错误，格式化为assistant消息
+            res.json({
+              id: `chatcmpl-${uuidv4()}`,
+              object: 'chat.completion',
+              created: Math.floor(Date.now() / 1000),
+              model,
+              choices: [
+                {
+                  index: 0,
+                  message: {
+                    role: 'assistant',
+                    content: errorResult.message,
+                  },
+                  finish_reason: 'stop',
+                },
+              ],
+              usage: {
+                prompt_tokens: 0,
+                completion_tokens: 0,
+                total_tokens: 0,
+              },
+            });
+            
+            responseEnded = true; // 标记响应已结束
+            break; // 跳出循环，不再处理后续数据
+          }
+          
+          // 正常文本，添加到结果中
+          if (chunkText && typeof chunkText === 'string') {
+            text += chunkText;
+          }
+        }
+        
+        // 只有在响应尚未结束的情况下，才处理和返回结果
+        if (!responseEnded) {
+          // 对解析后的字符串进行进一步处理
+          text = text.replace(/^.*<\|END_USER\|>/s, '');
+          text = text.replace(/^\n[a-zA-Z]?/, '').trim();
+          // console.log(text)
+
+          res.json({
+            id: `chatcmpl-${uuidv4()}`,
+            object: 'chat.completion',
+            created: Math.floor(Date.now() / 1000),
+            model,
+            choices: [
+              {
+                index: 0,
+                message: {
+                  role: 'assistant',
+                  content: text,
+                },
+                finish_reason: 'stop',
+              },
+            ],
+            usage: {
+              prompt_tokens: 0,
+              completion_tokens: 0,
+              total_tokens: 0,
+            },
+          });
+        }
+      } catch (error) {
+        console.error('Non-stream error:', error);
+        // 确保在发送错误信息前检查响应是否已结束
+        if (!res.headersSent) {
+          if (error.name === 'TimeoutError') {
+            // 使用统一的错误格式
+            const errorMessage = `⚠️ 请求超时 ⚠️\n\n错误：服务器响应超时，请稍后重试。`;
+            return res.json({
+              id: `chatcmpl-${uuidv4()}`,
+              object: 'chat.completion',
+              created: Math.floor(Date.now() / 1000),
+              model: req.body.model || 'unknown',
+              choices: [
+                {
+                  index: 0,
+                  message: {
+                    role: 'assistant',
+                    content: errorMessage,
+                  },
+                  finish_reason: 'stop',
+                },
+              ],
+              usage: {
+                prompt_tokens: 0,
+                completion_tokens: 0,
+                total_tokens: 0,
+              },
+            });
+          }
+          throw error;
+        }
+      }
+    }
+  } catch (error) {
+    console.error('Error:', error);
+    if (!res.headersSent) {
+      const errorText = error.name === 'TimeoutError' ? '请求超时' : '服务器内部错误';
+      
+      if (req.body.stream) {
+        // 流式响应格式的错误
+        const responseId = `chatcmpl-${uuidv4()}`;
+        // 添加清晰的错误提示
+        const errorMessage = `⚠️ 请求失败 ⚠️\n\n错误：${errorText}，请稍后重试。\n\n${error.message || ''}`;
+        res.write(
+          `data: ${JSON.stringify({
+            id: responseId,
+            object: 'chat.completion.chunk',
+            created: Math.floor(Date.now() / 1000),
+            model: req.body.model || 'unknown',
+            choices: [
+              {
+                index: 0,
+                delta: {
+                  content: errorMessage,
+                },
+              },
+            ],
+          })}\n\n`
+        );
+        res.write('data: [DONE]\n\n');
+        res.end();
+      } else {
+        // 非流式响应格式的错误
+        // 添加清晰的错误提示
+        const errorMessage = `⚠️ 请求失败 ⚠️\n\n错误：${errorText}，请稍后重试。\n\n${error.message || ''}`;
+        res.json({
+          id: `chatcmpl-${uuidv4()}`,
+          object: 'chat.completion',
+          created: Math.floor(Date.now() / 1000),
+          model: req.body.model || 'unknown',
+          choices: [
+            {
+              index: 0,
+              message: {
+                role: 'assistant',
+                content: errorMessage,
+              },
+              finish_reason: 'stop',
+            },
+          ],
+          usage: {
+            prompt_tokens: 0,
+            completion_tokens: 0,
+            total_tokens: 0,
+          },
+        });
+      }
+    }
+  }
+});
+
+// 触发Cookie刷新
+router.post("/refresh-cookies", async (req, res) => {
+  try {
+    // 如果已经有刷新进程在运行，则返回错误
+    if (refreshStatus.isRunning) {
+      return res.status(409).json({
+        success: false,
+        message: '已有刷新进程在运行，请等待完成后再试'
+      });
+    }
+    
+    // 获取请求参数
+    const apiKey = req.query.apiKey || '';
+    
+    // 重置刷新状态
+    refreshStatus = {
+      isRunning: true,
+      status: 'running',
+      message: '正在启动刷新进程...',
+      startTime: new Date(),
+      endTime: null,
+      error: null
+    };
+    
+    console.log(`收到刷新Cookie请求，API Key: ${apiKey || '所有'}`);
+    
+    // 构建命令行参数
+    const args = [];
+    if (apiKey) {
+      args.push(apiKey);
+    }
+    
+    // 获取auto-refresh-cookies.js的绝对路径
+    const scriptPath = path.resolve(__dirname, '../../auto-refresh-cookies.js');
+    
+    // 启动子进程执行刷新脚本
+    const refreshProcess = spawn('node', [scriptPath, ...args], {
+      stdio: ['ignore', 'pipe', 'pipe']
+    });
+    
+    // 收集输出
+    let output = '';
+    
+    refreshProcess.stdout.on('data', (data) => {
+      const text = data.toString();
+      output += text;
+      console.log(`刷新进程输出: ${text}`);
+      
+      // 更新状态消息
+      if (text.includes('开始自动刷新')) {
+        refreshStatus.message = '正在刷新Cookie...';
+      } else if (text.includes('刷新结果:')) {
+        refreshStatus.message = text.trim();
+      }
+    });
+    
+    refreshProcess.stderr.on('data', (data) => {
+      const text = data.toString();
+      output += text;
+      console.error(`刷新进程错误: ${text}`);
+      
+      // 更新错误信息
+      refreshStatus.error = text.trim();
+      refreshStatus.message = `发生错误: ${text.trim()}`;
+    });
+    
+    refreshProcess.on('close', (code) => {
+      console.log(`刷新进程退出，代码: ${code}`);
+      
+      refreshStatus.isRunning = false;
+      refreshStatus.endTime = new Date();
+      
+      if (code === 0) {
+        refreshStatus.status = 'completed';
+        
+        // 提取成功信息
+        const successMatch = output.match(/成功刷新 (\d+) 个/);
+        if (successMatch) {
+          refreshStatus.message = `成功刷新 ${successMatch[1]} 个API Key的Cookie`;
+        } else {
+          refreshStatus.message = '刷新完成';
+        }
+        
+        // 子进程执行完成后，重新初始化API Keys来加载新的Cookie
+        try {
+          const keyManager = require('../utils/keyManager');
+          console.log('子进程刷新Cookie完成，重新初始化主进程中的API Keys...');
+          keyManager.initializeApiKeys();
+          console.log('主进程API Keys重新加载完成');
+        } catch (initError) {
+          console.error('重新初始化API Keys失败:', initError);
+        }
+      } else {
+        refreshStatus.status = 'failed';
+        refreshStatus.message = refreshStatus.error || '刷新失败，请查看服务器日志';
+      }
+    });
+    
+    // 立即返回响应，不等待刷新完成
+    return res.json({
+      success: true,
+      message: '刷新请求已接受，正在后台处理'
+    });
+  } catch (error) {
+    console.error('触发刷新Cookie失败:', error);
+    
+    // 更新刷新状态
+    refreshStatus.isRunning = false;
+    refreshStatus.status = 'failed';
+    refreshStatus.endTime = new Date();
+    refreshStatus.error = error.message;
+    refreshStatus.message = `触发刷新失败: ${error.message}`;
+    
+    return res.status(500).json({
+      success: false,
+      message: `触发刷新失败: ${error.message}`
+    });
+  }
+});
+
+// 查询Cookie刷新状态
+router.get("/refresh-status", (req, res) => {
+  try {
+    // 返回当前刷新状态
+    return res.json({
+      success: true,
+      data: {
+        ...refreshStatus,
+        isRunning: refreshStatus.isRunning || false,
+        status: refreshStatus.status || 'unknown',
+        message: refreshStatus.message || '未触发刷新',
+        startTime: refreshStatus.startTime || null,
+        endTime: refreshStatus.endTime || null
+      }
+    });
+  } catch (error) {
+    console.error('获取刷新状态失败:', error);
+    return res.status(500).json({
+      success: false,
+      message: `获取刷新状态失败: ${error.message}`
+    });
+  }
+});
+
+// 在文件末尾添加错误处理函数
+function handleCursorError(errorStr, bearerToken, originalAuthToken) {
+  let message = '';
+  let shouldRemoveCookie = false;
+  
+  if (errorStr.includes('Not logged in')) {
+    // 更明确的错误日志
+    if (originalAuthToken === bearerToken) {
+      console.error(`检测到API Key "${bearerToken}" 中没有可用Cookie，正在尝试以向后兼容模式使用API Key本身`);
+      message = `错误：API Key "${bearerToken}" 中没有可用的Cookie。请添加有效的Cookie到此API Key，或使用其他有效的API Key。\n\n详细信息：${errorStr}`;
+    } else {
+      console.error('检测到无效cookie:', originalAuthToken);
+      message = `错误：Cookie无效或已过期，请更新Cookie。\n\n详细信息：${errorStr}`;
+    }
+    shouldRemoveCookie = true;
+  } else if (errorStr.includes('You\'ve reached your trial request limit')) {
+    console.error('检测到额度用尽cookie:', originalAuthToken);
+    message = `错误：Cookie使用额度已用完，请更换Cookie或等待刷新。\n\n详细信息：${errorStr}`;
+    shouldRemoveCookie = true;
+  } else if (errorStr.includes('User is unauthorized')) {
+    console.error('检测到未授权cookie:', originalAuthToken);
+    message = `错误：Cookie已被封禁或失效，请更换Cookie。\n\n详细信息：${errorStr}`;
+    shouldRemoveCookie = true;
+  } else if (errorStr.includes('suspicious activity checks')) {
+    console.error('检测到IP黑名单:', originalAuthToken);
+    message = `错误：IP可能被列入黑名单，请尝试更换网络环境或使用代理。\n\n详细信息：${errorStr}`;
+    shouldRemoveCookie = false;
+  } else if (errorStr.includes('Too many computers')) {
+    console.error('检测到账户暂时被封禁:', originalAuthToken);
+    message = `错误：账户因在多台设备登录而暂时被封禁，请稍后再试或更换账户。\n\n详细信息：${errorStr}`;
+    shouldRemoveCookie = true;
+  } else if (errorStr.includes('Login expired') || errorStr.includes('login expired')) {
+    console.error('检测到登录过期cookie:', originalAuthToken);
+    message = `错误：Cookie登录已过期，请更新Cookie。\n\n详细信息：${errorStr}`;
+    shouldRemoveCookie = true;
+  } else {
+    // 非Cookie相关错误
+    console.error('检测到其他错误:', errorStr);
+    message = `错误：请求失败。\n\n详细信息：${errorStr}`;
+    shouldRemoveCookie = false;
+  }
+  
+  return {
+    message,
+    shouldRemoveCookie
+  };
+}
+
+module.exports = router;

src/utils/cookieRefresher.js

@@ -0,0 +1,817 @@
+const fs = require('fs');
+const path = require('path');
+const csv = require('csv-parser');
+const axios = require('axios');
+const AdmZip = require('adm-zip');
+const { Octokit } = require('@octokit/rest');
+const keyManager = require('./keyManager');
+const config = require('../config/config');
+const { extractCookiesFromCsv } = require('./extractCookieFromCsv');
+
+// GitHub 仓库信息从环境变量中获取
+const GITHUB_OWNER = process.env.GITHUB_OWNER || 'liuw1535';
+const GITHUB_REPO = process.env.GITHUB_REPO || 'Cursor-Register';
+const GITHUB_TOKEN = process.env.GITHUB_TOKEN; // 需要在环境变量中设置
+const GITHUB_WORKFLOW_ID = process.env.GITHUB_WORKFLOW_ID || 'register.yml';
+const TRIGGER_WORKFLOW = process.env.TRIGGER_WORKFLOW === 'true';
+
+// 下载目录
+const DOWNLOAD_DIR = path.join(__dirname, '../../downloads');
+const EXTRACT_DIR = path.join(__dirname, '../../extracted');
+
+// 确保目录存在
+function ensureDirectoryExists(dir) {
+  if (!fs.existsSync(dir)) {
+    try {
+      fs.mkdirSync(dir, { recursive: true });
+      console.log(`创建目录成功: ${dir}`);
+    } catch (err) {
+      console.error(`创建目录失败: ${dir}`, err);
+      throw err;
+    }
+  }
+}
+
+// 触发 GitHub Actions 工作流
+async function triggerWorkflow() {
+  try {
+    if (!GITHUB_TOKEN) {
+      console.error('未设置 GITHUB_TOKEN，无法触发工作流');
+      return null;
+    }
+
+    console.log(`正在触发 GitHub Actions 工作流: ${GITHUB_WORKFLOW_ID}...`);
+    const octokit = new Octokit({
+      auth: GITHUB_TOKEN
+    });
+
+    // 从环境变量获取工作流参数
+    const number = process.env.REGISTER_NUMBER || '2';
+    const maxWorkers = process.env.REGISTER_MAX_WORKERS || '1';
+    const emailServer = process.env.REGISTER_EMAIL_SERVER || 'TempEmail';
+    const ingestToOneapi = process.env.REGISTER_INGEST_TO_ONEAPI === 'true';
+    const uploadArtifact = process.env.REGISTER_UPLOAD_ARTIFACT !== 'false'; // 默认为true
+    const useConfigFile = process.env.REGISTER_USE_CONFIG_FILE !== 'false'; // 默认为true
+    const emailConfigs = process.env.REGISTER_EMAIL_CONFIGS || '[]';
+
+    console.log(`工作流参数: number=${number}, maxWorkers=${maxWorkers}, emailServer=${emailServer}, ingestToOneapi=${ingestToOneapi}, uploadArtifact=${uploadArtifact}, useConfigFile=${useConfigFile}`);
+
+    // 获取触发前的最新工作流ID，用于后续识别新触发的工作流
+    const { data: beforeWorkflowRuns } = await octokit.actions.listWorkflowRuns({
+      owner: GITHUB_OWNER,
+      repo: GITHUB_REPO,
+      workflow_id: GITHUB_WORKFLOW_ID,
+      per_page: 1
+    });
+    
+    const latestWorkflowIdBefore = beforeWorkflowRuns.workflow_runs && beforeWorkflowRuns.workflow_runs.length > 0 
+      ? beforeWorkflowRuns.workflow_runs[0].id 
+      : 0;
+    
+    console.log(`触发前最新工作流ID: ${latestWorkflowIdBefore}`);
+
+    // 触发工作流
+    const response = await octokit.actions.createWorkflowDispatch({
+      owner: GITHUB_OWNER,
+      repo: GITHUB_REPO,
+      workflow_id: GITHUB_WORKFLOW_ID,
+      ref: 'main', // 默认使用 main 分支，可以根据需要修改
+      inputs: {
+        number: number,
+        max_workers: maxWorkers,
+        email_server: emailServer,
+        ingest_to_oneapi: ingestToOneapi.toString(),
+        upload_artifact: uploadArtifact.toString(),
+        use_config_file: useConfigFile.toString(),
+        email_configs: emailConfigs
+      }
+    });
+
+    console.log('工作流触发成功，等待工作流开始运行...');
+    
+    // 等待新工作流出现并获取其ID
+    let newWorkflowRunId = null;
+    let findAttempts = 0;
+    const maxFindAttempts = 30; // 最多等待30次，每次5秒
+    
+    while (findAttempts < maxFindAttempts && !newWorkflowRunId) {
+      findAttempts++;
+      console.log(`查找新触发的工作流，尝试 ${findAttempts}/${maxFindAttempts}...`);
+      
+      try {
+        const { data: afterWorkflowRuns } = await octokit.actions.listWorkflowRuns({
+          owner: GITHUB_OWNER,
+          repo: GITHUB_REPO,
+          workflow_id: GITHUB_WORKFLOW_ID,
+          per_page: 5
+        });
+        
+        if (afterWorkflowRuns.workflow_runs && afterWorkflowRuns.workflow_runs.length > 0) {
+          // 查找ID大于之前最新工作流ID的工作流（即新触发的工作流）
+          const newWorkflow = afterWorkflowRuns.workflow_runs.find(run => run.id > latestWorkflowIdBefore);
+          if (newWorkflow) {
+            newWorkflowRunId = newWorkflow.id;
+            console.log(`找到新触发的工作流，ID: ${newWorkflowRunId}, 状态: ${newWorkflow.status}`);
+          }
+        }
+      } catch (error) {
+        console.error(`查找工作流时出错 (尝试 ${findAttempts}/${maxFindAttempts}): ${error.message}`);
+        // 出错时继续尝试，不中断循环
+      }
+      
+      if (!newWorkflowRunId) {
+        // 等待5秒后再次检查
+        await new Promise(resolve => setTimeout(resolve, 5000));
+      }
+    }
+    
+    if (!newWorkflowRunId) {
+      console.log('未能找到新触发的工作流，可能触发失败');
+      return null;
+    }
+    
+    // 等待工作流完成
+    let attempts = 0;
+    const maxAttempts = 120; // 最多等待120次，每次30秒，总共60分钟
+    let consecutiveErrors = 0;
+    const maxConsecutiveErrors = 5; // 最多允许连续5次错误
+    
+    while (attempts < maxAttempts) {
+      attempts++;
+      console.log(`等待工作流完成，尝试 ${attempts}/${maxAttempts}...`);
+      
+      try {
+        // 获取工作流状态
+        const { data: workflowRun } = await octokit.actions.getWorkflowRun({
+          owner: GITHUB_OWNER,
+          repo: GITHUB_REPO,
+          run_id: newWorkflowRunId
+        });
+        
+        // 重置连续错误计数
+        consecutiveErrors = 0;
+        
+        console.log(`工作流状态: ${workflowRun.status}, 结果: ${workflowRun.conclusion || '进行中'}`);
+        
+        // 检查工作流是否完成
+        if (workflowRun.status === 'completed') {
+          if (workflowRun.conclusion === 'success') {
+            console.log(`工作流运行成功，ID: ${newWorkflowRunId}`);
+            return workflowRun;
+          } else {
+            console.log(`工作流运行失败，结果: ${workflowRun.conclusion}`);
+            return null;
+          }
+        }
+      } catch (error) {
+        consecutiveErrors++;
+        console.error(`获取工作流状态时出错 (尝试 ${attempts}/${maxAttempts}, 连续错误 ${consecutiveErrors}/${maxConsecutiveErrors}): ${error.message}`);
+        
+        // 如果连续错误次数超过阈值，则放弃
+        if (consecutiveErrors >= maxConsecutiveErrors) {
+          console.error(`连续错误次数超过阈值 (${maxConsecutiveErrors})，放弃等待`);
+          throw new Error(`连续 ${maxConsecutiveErrors} 次获取工作流状态失败: ${error.message}`);
+        }
+        
+        // 错误后等待时间稍微延长
+        await new Promise(resolve => setTimeout(resolve, 10000));
+        // 继续循环，不中断
+        continue;
+      }
+      
+      // 等待30秒后再次检查
+      await new Promise(resolve => setTimeout(resolve, 30000));
+    }
+    
+    console.log('等待工作流完成超时');
+    return null;
+  } catch (error) {
+    console.error('触发工作流失败:', error);
+    throw error; // 重新抛出错误，让调用者处理
+  }
+}
+
+// 从 GitHub Actions 获取最新的 Artifact
+async function getLatestArtifact() {
+  try {
+    console.log('正在连接 GitHub API...');
+    const octokit = new Octokit({
+      auth: GITHUB_TOKEN
+    });
+
+    // 如果配置了自动触发工作流，则先触发工作流
+    let workflowRun = null;
+    if (TRIGGER_WORKFLOW) {
+      console.log('配置了自动触发工作流，正在触发...');
+      try {
+        workflowRun = await triggerWorkflow();
+      } catch (error) {
+        console.error('触发工作流过程中出现错误:', error.message);
+        console.log('尝试继续使用已找到的工作流ID...');
+        
+        // 尝试获取最新的工作流，看是否有正在运行的工作流
+        const { data: runningWorkflows } = await octokit.actions.listWorkflowRuns({
+          owner: GITHUB_OWNER,
+          repo: GITHUB_REPO,
+          workflow_id: GITHUB_WORKFLOW_ID,
+          status: 'in_progress',
+          per_page: 5
+        });
+        
+        if (runningWorkflows.workflow_runs && runningWorkflows.workflow_runs.length > 0) {
+          // 找到正在运行的工作流
+          const runningWorkflow = runningWorkflows.workflow_runs[0];
+          console.log(`找到正在运行的工作流，ID: ${runningWorkflow.id}, 状态: ${runningWorkflow.status}`);
+          
+          // 等待工作流完成
+          let attempts = 0;
+          const maxAttempts = 120; // 最多等待120次，每次30秒，总共60分钟
+          let consecutiveErrors = 0;
+          const maxConsecutiveErrors = 5; // 最多允许连续5次错误
+          
+          while (attempts < maxAttempts) {
+            attempts++;
+            console.log(`等待工作流完成，尝试 ${attempts}/${maxAttempts}...`);
+            
+            try {
+              // 获取工作流状态
+              const { data: currentWorkflow } = await octokit.actions.getWorkflowRun({
+                owner: GITHUB_OWNER,
+                repo: GITHUB_REPO,
+                run_id: runningWorkflow.id
+              });
+              
+              // 重置连续错误计数
+              consecutiveErrors = 0;
+              
+              console.log(`工作流状态: ${currentWorkflow.status}, 结果: ${currentWorkflow.conclusion || '进行中'}`);
+              
+              // 检查工作流是否完成
+              if (currentWorkflow.status === 'completed') {
+                if (currentWorkflow.conclusion === 'success') {
+                  console.log(`工作流运行成功，ID: ${currentWorkflow.id}`);
+                  workflowRun = currentWorkflow;
+                  break;
+                } else {
+                  console.log(`工作流运行失败，结果: ${currentWorkflow.conclusion}`);
+                  break;
+                }
+              }
+            } catch (err) {
+              consecutiveErrors++;
+              console.error(`获取工作流状态时出错 (尝试 ${attempts}/${maxAttempts}, 连续错误 ${consecutiveErrors}/${maxConsecutiveErrors}): ${err.message}`);
+              
+              // 如果连续错误次数超过阈值，则放弃
+              if (consecutiveErrors >= maxConsecutiveErrors) {
+                console.error(`连续错误次数超过阈值 (${maxConsecutiveErrors})，放弃等待`);
+                break;
+              }
+              
+              // 错误后等待时间稍微延长
+              await new Promise(resolve => setTimeout(resolve, 10000));
+              // 继续循环，不中断
+              continue;
+            }
+            
+            // 等待30秒后再次检查
+            await new Promise(resolve => setTimeout(resolve, 30000));
+          }
+        }
+      }
+      
+      if (!workflowRun) {
+        console.log('触发工作流失败或等待超时，尝试获取最新的工作流运行');
+      }
+    }
+
+    // 如果没有触发工作流或触发失败，则获取最新的工作流运行
+    if (!workflowRun) {
+      console.log('获取最新的工作流运行...');
+      const { data: workflowRuns } = await octokit.actions.listWorkflowRunsForRepo({
+        owner: GITHUB_OWNER,
+        repo: GITHUB_REPO,
+        status: 'success',
+        per_page: 5
+      });
+
+      if (!workflowRuns.workflow_runs || workflowRuns.workflow_runs.length === 0) {
+        console.log('没有找到成功的工作流运行');
+        return null;
+      }
+
+      // 获取最新成功运行的 Artifacts
+      workflowRun = workflowRuns.workflow_runs[0];
+    }
+    
+    console.log(`找到最新的工作流运行: ${workflowRun.id}`);
+
+    // 等待一段时间，确保Artifact已经上传完成
+    console.log('等待Artifact上传完成...');
+    await new Promise(resolve => setTimeout(resolve, 10000));
+
+    // 获取工作流的Artifacts
+    let artifacts = null;
+    let artifactAttempts = 0;
+    const maxArtifactAttempts = 10; // 最多尝试10次，每次10秒
+    
+    while (artifactAttempts < maxArtifactAttempts && (!artifacts || !artifacts.artifacts || artifacts.artifacts.length === 0)) {
+      artifactAttempts++;
+      console.log(`尝试获取Artifacts，尝试 ${artifactAttempts}/${maxArtifactAttempts}...`);
+      
+      try {
+        const response = await octokit.actions.listWorkflowRunArtifacts({
+          owner: GITHUB_OWNER,
+          repo: GITHUB_REPO,
+          run_id: workflowRun.id
+        });
+        
+        artifacts = response.data;
+      } catch (error) {
+        console.error(`获取Artifacts时出错 (尝试 ${artifactAttempts}/${maxArtifactAttempts}): ${error.message}`);
+        // 出错时继续尝试，不中断循环
+      }
+      
+      if (!artifacts || !artifacts.artifacts || artifacts.artifacts.length === 0) {
+        console.log('暂时没有找到Artifacts，等待10秒后重试...');
+        await new Promise(resolve => setTimeout(resolve, 10000));
+      }
+    }
+
+    if (!artifacts || !artifacts.artifacts || artifacts.artifacts.length === 0) {
+      console.log('没有找到Artifacts，可能工作流没有生成Artifact');
+      return null;
+    }
+
+    console.log(`找到 ${artifacts.artifacts.length} 个Artifacts`);
+
+    // 查找 Account info Artifact
+    const accountInfoArtifact = artifacts.artifacts.find(artifact => 
+      artifact.name.toLowerCase().includes('account info'));
+
+    if (!accountInfoArtifact) {
+      console.log('没有找到 Account info Artifact');
+      return null;
+    }
+
+    console.log(`找到 Account info Artifact: ${accountInfoArtifact.id}`);
+    return accountInfoArtifact;
+  } catch (error) {
+    console.error('获取 Artifact 失败:', error);
+    return null;
+  }
+}
+
+// 下载 Artifact
+async function downloadArtifact(artifact) {
+  let downloadAttempts = 0;
+  const maxDownloadAttempts = 5; // 最多尝试5次下载
+  
+  while (downloadAttempts < maxDownloadAttempts) {
+    downloadAttempts++;
+    try {
+      console.log(`开始下载 Artifact: ${artifact.id}... (尝试 ${downloadAttempts}/${maxDownloadAttempts})`);
+      ensureDirectoryExists(DOWNLOAD_DIR);
+
+      const octokit = new Octokit({
+        auth: GITHUB_TOKEN
+      });
+
+      // 获取下载 URL
+      const { url } = await octokit.actions.downloadArtifact({
+        owner: GITHUB_OWNER,
+        repo: GITHUB_REPO,
+        artifact_id: artifact.id,
+        archive_format: 'zip'
+      });
+
+      // 下载 zip 文件
+      const zipFilePath = path.join(DOWNLOAD_DIR, `${artifact.id}.zip`);
+      const response = await axios({
+        method: 'get',
+        url: url,
+        responseType: 'arraybuffer',
+        timeout: 60000 // 设置60秒超时
+      });
+
+      fs.writeFileSync(zipFilePath, response.data);
+      console.log(`Artifact 下载完成: ${zipFilePath}`);
+      return zipFilePath;
+    } catch (error) {
+      console.error(`下载 Artifact 失败 (尝试 ${downloadAttempts}/${maxDownloadAttempts}): ${error.message}`);
+      
+      if (downloadAttempts >= maxDownloadAttempts) {
+        console.error('达到最大尝试次数，放弃下载');
+        return null;
+      }
+      
+      // 等待一段时间后重试
+      const retryDelay = 10000; // 10秒
+      console.log(`等待 ${retryDelay/1000} 秒后重试...`);
+      await new Promise(resolve => setTimeout(resolve, retryDelay));
+    }
+  }
+  
+  return null;
+}
+
+// 解压 Artifact
+async function extractArtifact(zipFilePath) {
+  let extractAttempts = 0;
+  const maxExtractAttempts = 3; // 最多尝试3次解压
+  
+  while (extractAttempts < maxExtractAttempts) {
+    extractAttempts++;
+    try {
+      console.log(`开始解压 Artifact: ${zipFilePath}... (尝试 ${extractAttempts}/${maxExtractAttempts})`);
+      ensureDirectoryExists(EXTRACT_DIR);
+
+      const zip = new AdmZip(zipFilePath);
+      zip.extractAllTo(EXTRACT_DIR, true);
+      console.log(`Artifact 解压完成: ${EXTRACT_DIR}`);
+
+      // 查找 token CSV 文件
+      const files = fs.readdirSync(EXTRACT_DIR);
+      const tokenFile = files.find(file => file.startsWith('token_') && file.endsWith('.csv'));
+
+      if (!tokenFile) {
+        console.log('没有找到 token CSV 文件');
+        
+        if (extractAttempts >= maxExtractAttempts) {
+          return null;
+        }
+        
+        // 等待一段时间后重试
+        const retryDelay = 5000; // 5秒
+        console.log(`等待 ${retryDelay/1000} 秒后重试...`);
+        await new Promise(resolve => setTimeout(resolve, retryDelay));
+        continue;
+      }
+
+      console.log(`找到 token CSV 文件: ${tokenFile}`);
+      return path.join(EXTRACT_DIR, tokenFile);
+    } catch (error) {
+      console.error(`解压 Artifact 失败 (尝试 ${extractAttempts}/${maxExtractAttempts}): ${error.message}`);
+      
+      if (extractAttempts >= maxExtractAttempts) {
+        console.error('达到最大尝试次数，放弃解压');
+        return null;
+      }
+      
+      // 等待一段时间后重试
+      const retryDelay = 5000; // 5秒
+      console.log(`等待 ${retryDelay/1000} 秒后重试...`);
+      await new Promise(resolve => setTimeout(resolve, retryDelay));
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * 从CSV文件中提取cookies
+ * @param {string} csvFilePath - CSV文件路径
+ * @returns {Promise<string[]>} - 提取到的cookie数组
+ */
+async function extractCookiesFromCsvFile(csvFilePath) {
+  const maxExtractAttempts = 3;
+  let attempt = 1;
+  
+  while (attempt <= maxExtractAttempts) {
+    console.log(`尝试从CSV文件提取cookies (尝试 ${attempt}/${maxExtractAttempts})...`);
+    
+    try {
+      // 读取文件内容
+      if (!fs.existsSync(csvFilePath)) {
+        console.error(`CSV文件不存在: ${csvFilePath}`);
+        return [];
+      }
+      
+      // 读取文件内容并处理可能的换行符
+      let fileContent = fs.readFileSync(csvFilePath, 'utf8');
+      fileContent = fileContent.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+      
+      // 首先尝试直接从文件内容中提取所有可能的cookie
+      const cookies = [];
+      
+      // 1. 检查是否有JWT格式的token (新格式)
+      const jwtRegex = /ey[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g;
+      const jwtMatches = fileContent.match(jwtRegex);
+      
+      if (jwtMatches && jwtMatches.length > 0) {
+        console.log(`直接从文件内容中提取到 ${jwtMatches.length} 个JWT token格式的Cookie`);
+        jwtMatches.forEach(match => {
+          if (!cookies.includes(match)) {
+            cookies.push(match);
+          }
+        });
+      }
+      
+      // 2. 检查是否有旧格式的cookie
+      if (fileContent.includes('user_')) {
+        console.log('文件包含旧格式cookie标识"user_"');
+        
+        // 使用旧的提取函数尝试提取
+        try {
+          const oldFormatCookies = await extractCookiesFromCsv(csvFilePath);
+          if (oldFormatCookies && oldFormatCookies.length > 0) {
+            console.log(`通过提取模块获取到 ${oldFormatCookies.length} 个cookie`);
+            oldFormatCookies.forEach(cookie => {
+              if (!cookies.includes(cookie)) {
+                cookies.push(cookie);
+              }
+            });
+          }
+        } catch (e) {
+          console.warn('通过提取模块获取cookie失败:', e.message);
+        }
+      }
+      
+      // 3. 如果找到了cookie，返回结果
+      if (cookies.length > 0) {
+        const newFormatCount = cookies.filter(c => c.startsWith('ey')).length;
+        const oldFormatCount = cookies.filter(c => c.includes('%3A%3A')).length;
+        
+        console.log(`总共找到 ${cookies.length} 个cookie`);
+        console.log(`新格式cookie(ey开头): ${newFormatCount}个`);
+        console.log(`旧格式cookie(包含%3A%3A): ${oldFormatCount}个`);
+        console.log(`其他格式cookie: ${cookies.length - newFormatCount - oldFormatCount}个`);
+        
+        return cookies;
+      }
+      
+      console.warn(`未能从文件中提取到任何cookie (尝试 ${attempt}/${maxExtractAttempts})`);
+    } catch (error) {
+      console.error(`从CSV文件提取cookies时出错 (尝试 ${attempt}/${maxExtractAttempts}):`, error);
+    }
+    
+    attempt++;
+    if (attempt <= maxExtractAttempts) {
+      console.log(`等待5秒后重试...`);
+      await new Promise(resolve => setTimeout(resolve, 5000));
+    }
+  }
+  
+  console.error(`在 ${maxExtractAttempts} 次尝试后未能从CSV文件提取到cookies`);
+  return [];
+}
+
+// 将新的有效cookie添加到系统中
+function addNewCookiesToSystem(apiKey, newCookies) {
+  try {
+    console.log(`准备添加 ${newCookies.length} 个新cookie到系统中`);
+    
+    // 获取当前的cookies
+    const currentCookies = keyManager.getAllCookiesForApiKey(apiKey) || [];
+    console.log(`当前API密钥 ${apiKey} 有 ${currentCookies.length} 个cookies`);
+    
+    // 获取无效的cookies
+    const invalidCookies = keyManager.getInvalidCookies() || [];
+    console.log(`系统中有 ${invalidCookies.length || 0} 个无效cookies`);
+    
+    // 过滤出新的有效cookie
+    let newValidCookies = [];
+    
+    // 检查invalidCookies的类型并相应处理
+    if (invalidCookies instanceof Set) {
+      newValidCookies = newCookies.filter(cookie => 
+        !currentCookies.includes(cookie) && !invalidCookies.has(cookie)
+      );
+    } else if (Array.isArray(invalidCookies)) {
+      newValidCookies = newCookies.filter(cookie => 
+        !currentCookies.includes(cookie) && !invalidCookies.includes(cookie)
+      );
+    } else if (invalidCookies && typeof invalidCookies === 'object') {
+      // 如果是普通对象，检查cookie是否作为键存在
+      newValidCookies = newCookies.filter(cookie => 
+        !currentCookies.includes(cookie) && !(cookie in invalidCookies)
+      );
+    } else {
+      // 如果invalidCookies不是预期的类型，只过滤当前cookies
+      newValidCookies = newCookies.filter(cookie => !currentCookies.includes(cookie));
+    }
+    
+    console.log(`过滤后有 ${newValidCookies.length} 个新的有效cookies`);
+    
+    // 验证cookie是否完整
+    const validatedCookies = newValidCookies.filter(cookie => {
+      // 检查是否是新格式的JWT token (ey开头)
+      if (cookie.startsWith('ey') && cookie.includes('.')) {
+        const parts = cookie.split('.');
+        // 检查JWT是否包含三个部分
+        if (parts.length !== 3) {
+          console.warn(`跳过不完整的JWT cookie (新格式): ${cookie}`);
+          return false;
+        }
+        return true;
+      }
+      // 检查旧格式cookie是否包含JWT的三个部分
+      else if (cookie.includes('%3A%3A')) {
+        const parts = cookie.split('%3A%3A');
+        if (parts.length === 2) {
+          const jwt = parts[1];
+          // 检查JWT是否包含点（表示JWT的三个部分）
+          if (!jwt.includes('.') || jwt.split('.').length !== 3) {
+            console.warn(`跳过不完整的cookie (旧格式): ${cookie}`);
+            return false;
+          }
+        }
+      }
+      return true;
+    });
+    
+    console.log(`验证完整性后有 ${validatedCookies.length} 个有效cookies`);
+    
+    if (validatedCookies.length > 0) {
+      // 添加新的有效cookie到系统
+      keyManager.addOrUpdateApiKey(apiKey, [...currentCookies, ...validatedCookies]);
+      console.log(`成功添加 ${validatedCookies.length} 个新cookie到API密钥 ${apiKey}`);
+      return validatedCookies.length; // 返回添加的cookie数量
+    } else {
+      console.log(`没有新的有效cookie需要添加到API密钥 ${apiKey}`);
+      return 0; // 没有添加cookie，返回0
+    }
+  } catch (error) {
+    console.error('添加新cookie到系统时出错:', error);
+    return 0; // 出错时返回0
+  }
+}
+
+// 清理临时文件
+function cleanupTempFiles() {
+  try {
+    console.log('开始清理临时文件...');
+    
+    // 清理下载目录
+    if (fs.existsSync(DOWNLOAD_DIR)) {
+      fs.readdirSync(DOWNLOAD_DIR).forEach(file => {
+        fs.unlinkSync(path.join(DOWNLOAD_DIR, file));
+      });
+    }
+    
+    // 清理解压目录
+    if (fs.existsSync(EXTRACT_DIR)) {
+      fs.readdirSync(EXTRACT_DIR).forEach(file => {
+        fs.unlinkSync(path.join(EXTRACT_DIR, file));
+      });
+    }
+    
+    console.log('临时文件清理完成');
+  } catch (error) {
+    console.error('清理临时文件失败:', error);
+  }
+}
+
+// 检查 API Key 是否需要补充 Cookie
+function checkApiKeyNeedRefresh(apiKey, minCookieCount = config.refresh.minCookieCount) {
+  const cookies = keyManager.getAllCookiesForApiKey(apiKey);
+  return cookies.length < minCookieCount;
+}
+
+// 将��有cookie全部设为无效并从API Key中移除
+function markExistingCookiesAsInvalid(apiKey) {
+  try {
+    // 获取当前API Key的所有cookie
+    const currentCookies = keyManager.getAllCookiesForApiKey(apiKey) || [];
+    console.log(`正在将API Key ${apiKey} 的 ${currentCookies.length} 个现有cookie标记为无效...`);
+    
+    // 如果没有cookie，直接返回
+    if (currentCookies.length === 0) {
+      console.log(`API Key ${apiKey} 没有现有cookie，无需标记为无效`);
+      return 0;
+    }
+    
+    // 获取无效cookie列表
+    const invalidCookies = keyManager.getInvalidCookies();
+    let markedCount = 0;
+    
+    // 遍历cookie并添加到无效列表
+    for (const cookie of currentCookies) {
+      // 将cookie添加到无效集合中
+      if (invalidCookies instanceof Set) {
+        invalidCookies.add(cookie);
+      }
+      markedCount++;
+    }
+    
+    // 保存无效cookie到文件
+    keyManager.saveInvalidCookiesToFile();
+    
+    // 清空当前API Key的cookie列表
+    keyManager.addOrUpdateApiKey(apiKey, []);
+    
+    // 保存更新后的API Keys
+    keyManager.saveApiKeysToFile();
+    
+    console.log(`已将API Key ${apiKey} 的 ${markedCount} 个cookie标记为无效并从API Key中移除`);
+    return markedCount;
+  } catch (error) {
+    console.error(`标记现有cookie为无效时出错:`, error);
+    return 0;
+  }
+}
+
+// 主函数：自动刷新 Cookie
+async function autoRefreshCookies(apiKey, minCookieCount = config.refresh.minCookieCount) {
+  console.log(`开始自动刷新 Cookie，目标 API Key: ${apiKey}，最小 Cookie 数量: ${minCookieCount}`);
+  
+  try {
+    // 检查是否需要刷新
+    if (!checkApiKeyNeedRefresh(apiKey, minCookieCount)) {
+      console.log(`API Key ${apiKey} 的 Cookie 数量足够，不需要刷新`);
+      return {
+        success: true,
+        message: '当前 Cookie 数量足够，不需要刷新',
+        refreshed: 0
+      };
+    }
+    
+    // 获取最新的 Artifact
+    const artifact = await getLatestArtifact();
+    if (!artifact) {
+      return {
+        success: false,
+        message: '获取 Artifact 失败',
+        refreshed: 0
+      };
+    }
+    
+    // 下载 Artifact
+    const zipFilePath = await downloadArtifact(artifact);
+    if (!zipFilePath) {
+      return {
+        success: false,
+        message: '下载 Artifact 失败',
+        refreshed: 0
+      };
+    }
+    
+    // 解压 Artifact
+    const csvFilePath = await extractArtifact(zipFilePath);
+    if (!csvFilePath) {
+      return {
+        success: false,
+        message: '解压 Artifact 失败',
+        refreshed: 0
+      };
+    }
+    
+    // 提取 Cookie
+    const cookies = await extractCookiesFromCsvFile(csvFilePath);
+    if (cookies.length === 0) {
+      return {
+        success: false,
+        message: '没有找到有效的 Cookie',
+        refreshed: 0
+      };
+    }
+    
+    // 分析提取到的cookie格式
+    const newFormatCookies = cookies.filter(cookie => cookie.startsWith('ey'));
+    const oldFormatCookies = cookies.filter(cookie => cookie.includes('%3A%3A'));
+    console.log(`提取到 ${newFormatCookies.length} 个新格式cookie(ey开头)`);
+    console.log(`提取到 ${oldFormatCookies.length} 个旧格式cookie(包含%3A%3A)`);
+    
+    // 根据配置决定是否将现有cookie标记为无效
+    const refreshMode = process.env.COOKIE_REFRESH_MODE || 'append';
+    
+    if (refreshMode === 'replace') {
+      // 将现有cookie标记为无效并从API Key中移除
+      console.log('使用替换模式: 将现有cookie标记为无效');
+      markExistingCookiesAsInvalid(apiKey);
+    } else {
+      console.log('使用追加模式: 保留现有cookie，只添加新cookie');
+    }
+    
+    // 添加新的 Cookie 到系统
+    const addedCount = addNewCookiesToSystem(apiKey, cookies);
+    
+    // 清理临时文件
+    cleanupTempFiles();
+    
+    return {
+      success: true,
+      message: `成功添加 ${addedCount} 个新 Cookie (新格式: ${newFormatCookies.length}, 旧格式: ${oldFormatCookies.length})`,
+      refreshed: addedCount
+    };
+  } catch (error) {
+    console.error('自动刷新 Cookie 失败:', error);
+    return {
+      success: false,
+      message: `刷新失败: ${error.message}`,
+      refreshed: 0
+    };
+  }
+}
+
+module.exports = {
+  autoRefreshCookies,
+  checkApiKeyNeedRefresh,
+  getLatestArtifact,
+  downloadArtifact,
+  extractArtifact,
+  extractCookiesFromCsvFile,
+  addNewCookiesToSystem,
+  cleanupTempFiles,
+  triggerWorkflow,
+  markExistingCookiesAsInvalid
+}; 

src/utils/envChecker.js

@@ -0,0 +1,76 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * 检查 .env 文件是否存在
+ * @returns {boolean} 文件是否存在
+ */
+function checkEnvFileExists() {
+  const envPath = path.resolve(process.cwd(), '.env');
+  return fs.existsSync(envPath);
+}
+
+/**
+ * 检查必要的环境变量是否已设置
+ * @returns {Object} 检查结果，包含是否通过和缺失的变量列表
+ */
+function checkRequiredEnvVars() {
+  // 定义必要的环境变量列表
+  const requiredVars = [
+    'API_KEYS', // API Keys 配置
+  ];
+
+  // 如果启用了自动刷新，则需要检查相关配置
+  if (process.env.ENABLE_AUTO_REFRESH === 'true') {
+    requiredVars.push(
+      'GITHUB_TOKEN',
+      'GITHUB_OWNER',
+      'GITHUB_REPO',
+      'GITHUB_WORKFLOW_ID',
+      'TRIGGER_WORKFLOW'
+    );
+  }
+
+  // 检查每个必要的环境变量
+  const missingVars = requiredVars.filter(varName => !process.env[varName]);
+
+  return {
+    passed: missingVars.length === 0,
+    missingVars
+  };
+}
+
+/**
+ * 执行环境检查，如果不符合要求则退出程序
+ */
+function enforceEnvCheck() {
+  console.log('正在检查环境配置...');
+  
+  // 检查 .env 文件是否存在
+  const envFileExists = checkEnvFileExists();
+  if (!envFileExists) {
+    console.error('\n错误: 未找到 .env 文件!');
+    console.error('请根据 .env.example 创建 .env 文件并配置必要的环境变量。');
+    console.error('执行以下命令复制示例文件: cp .env.example .env,或执行npm run setup\n');
+    process.exit(1); // 退出程序，状态码 1 表示错误
+  }
+  
+  // 检查必要的环境变量
+  const { passed, missingVars } = checkRequiredEnvVars();
+  if (!passed) {
+    console.error('\n错误: 以下必要的环境变量未在 .env 文件中设置:');
+    missingVars.forEach(varName => {
+      console.error(`  - ${varName}`);
+    });
+    console.error('\n请在 .env 文件中配置这些变量后重新启动程序。\n');
+    process.exit(1); // 退出程序，状态码 1 表示错误
+  }
+  
+  console.log('环境检查通过，继续启动程序...');
+}
+
+module.exports = {
+  checkEnvFileExists,
+  checkRequiredEnvVars,
+  enforceEnvCheck
+}; 

src/utils/extractCookieFromCsv.js

@@ -0,0 +1,269 @@
+const fs = require('fs');
+const path = require('path');
+const csv = require('csv-parser');
+
+/**
+ * 从CSV文件中提取完整的cookie
+ * @param {string} csvFilePath - CSV文件路径
+ * @returns {Promise<string[]>} - 提取到的cookie数组
+ */
+async function extractCookiesFromCsv(csvFilePath) {
+  return new Promise((resolve, reject) => {
+    try {
+      // 检查文件是否存在
+      if (!fs.existsSync(csvFilePath)) {
+        console.error(`CSV文件不存在: ${csvFilePath}`);
+        return resolve([]);
+      }
+
+      // 读取文件内容
+      const fileContent = fs.readFileSync(csvFilePath, 'utf8');
+      console.log(`文件内容前200个字符: ${fileContent.substring(0, 200)}`);
+
+      // 检查文件是否为空
+      if (!fileContent || fileContent.trim() === '') {
+        console.error('CSV文件为空');
+        return resolve([]);
+      }
+
+      // 首先尝试直接从文件内容中提取所有可能的cookie
+      const cookies = [];
+      
+      // 检查是否有JWT格式的token (新格式)
+      const jwtRegex = /ey[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g;
+      const jwtMatches = fileContent.match(jwtRegex);
+      
+      if (jwtMatches && jwtMatches.length > 0) {
+        console.log(`直接从文件内容中提取到 ${jwtMatches.length} 个JWT token格式的Cookie`);
+        jwtMatches.forEach(match => {
+          if (!cookies.includes(match)) {
+            cookies.push(match);
+          }
+        });
+      }
+
+      // 检查文件内容是否包含关键字
+      const hasTokenKeyword = fileContent.includes('token');
+      const hasUserPrefix = fileContent.includes('user_');
+      console.log(`文件包含"token"关键字: ${hasTokenKeyword}`);
+      console.log(`文件包含"user_"前缀: ${hasUserPrefix}`);
+
+      // 如果文件包含user_前缀，尝试提取旧格式cookie
+      if (hasUserPrefix) {
+        const oldFormatCookies = extractCookiesFromText(fileContent);
+        if (oldFormatCookies.length > 0) {
+          console.log(`从文件内容中提取到 ${oldFormatCookies.length} 个旧格式Cookie`);
+          oldFormatCookies.forEach(cookie => {
+            if (!cookies.includes(cookie)) {
+              cookies.push(cookie);
+            }
+          });
+        }
+      }
+
+      // 如果已经找到cookie，返回结果
+      if (cookies.length > 0) {
+        console.log(`总共提取到 ${cookies.length} 个Cookie`);
+        return resolve(validateCookies(cookies));
+      }
+
+      // 使用csv-parser解析CSV文件
+      const possibleTokenFields = ['token', 'cookie', 'value', 'Token', 'Cookie', 'Value', 'jwt', 'JWT'];
+      
+      fs.createReadStream(csvFilePath)
+        .pipe(csv())
+        .on('data', (row) => {
+          // 检查所有可能的字段名
+          for (const field of possibleTokenFields) {
+            if (row[field]) {
+              // 检查是否是JWT格式
+              if (row[field].startsWith('ey') && row[field].includes('.')) {
+                if (!cookies.includes(row[field])) {
+                  cookies.push(row[field]);
+                }
+                break;
+              }
+              // 检查是否是旧格式
+              else if (row[field].includes('user_')) {
+                if (!cookies.includes(row[field])) {
+                  cookies.push(row[field]);
+                }
+                break;
+              }
+            }
+          }
+          
+          // 如果没有找到预定义的字段，遍历所有字段
+          if (cookies.length === 0) {
+            for (const field in row) {
+              if (row[field] && typeof row[field] === 'string') {
+                // 检查是否是JWT格式
+                if (row[field].startsWith('ey') && row[field].includes('.')) {
+                  if (!cookies.includes(row[field])) {
+                    cookies.push(row[field]);
+                  }
+                  break;
+                }
+                // 检查是否是旧格式
+                else if (row[field].includes('user_')) {
+                  if (!cookies.includes(row[field])) {
+                    cookies.push(row[field]);
+                  }
+                  break;
+                }
+              }
+            }
+          }
+        })
+        .on('end', () => {
+          console.log(`从CSV解析中提取到 ${cookies.length} 个Cookie`);
+          
+          // 如果通过CSV解析没有找到cookie，尝试按行读取
+          if (cookies.length === 0) {
+            console.log('尝试按行读取文件...');
+            const lines = fileContent.split('\n');
+            for (const line of lines) {
+              // 检查是否有JWT格式token
+              if (line.includes('ey')) {
+                const jwtMatches = line.match(jwtRegex);
+                if (jwtMatches) {
+                  jwtMatches.forEach(match => {
+                    if (!cookies.includes(match)) {
+                      cookies.push(match);
+                    }
+                  });
+                }
+              }
+              
+              // 检查是否有旧格式cookie
+              if (line.includes('user_')) {
+                const extractedCookies = extractCookiesFromText(line);
+                extractedCookies.forEach(cookie => {
+                  if (!cookies.includes(cookie)) {
+                    cookies.push(cookie);
+                  }
+                });
+              }
+            }
+            console.log(`按行读取后提取到 ${cookies.length} 个Cookie`);
+          }
+          
+          // 验证提取的cookie是否完整
+          const validatedCookies = validateCookies(cookies);
+          
+          resolve(validatedCookies);
+        })
+        .on('error', (error) => {
+          console.error('解析CSV文件时出错:', error);
+          
+          // 如果已经提取到cookie，直接返回
+          if (cookies.length > 0) {
+            console.log(`解析出错但已提取到 ${cookies.length} 个Cookie，进行验证后返回`);
+            resolve(validateCookies(cookies));
+          } else {
+            // 否则尝试其他方法提取
+            console.log('尝试其他方法提取Cookie...');
+            
+            // 尝试提取JWT格式token
+            const jwtMatches = fileContent.match(jwtRegex);
+            if (jwtMatches) {
+              jwtMatches.forEach(match => {
+                if (!cookies.includes(match)) {
+                  cookies.push(match);
+                }
+              });
+            }
+            
+            // 尝试提取旧格式cookie
+            const oldFormatCookies = extractCookiesFromText(fileContent);
+            oldFormatCookies.forEach(cookie => {
+              if (!cookies.includes(cookie)) {
+                cookies.push(cookie);
+              }
+            });
+            
+            console.log(`通过其他方法提取到 ${cookies.length} 个Cookie`);
+            resolve(validateCookies(cookies));
+          }
+        });
+    } catch (error) {
+      console.error('提取Cookie时出错:', error);
+      reject(error);
+    }
+  });
+}
+
+/**
+ * 从文本中提取cookie
+ * @param {string} text - 要提取cookie的文本
+ * @returns {string[]} - 提取到的cookie数组
+ */
+function extractCookiesFromText(text) {
+  const cookies = [];
+  
+  // 使用正则表达式匹配user_开头的cookie（旧格式）
+  const oldFormatRegex = /user_[a-zA-Z0-9%]+%3A%3A[a-zA-Z0-9%\.\_\-]+/g;
+  const oldFormatMatches = text.match(oldFormatRegex);
+  
+  if (oldFormatMatches) {
+    oldFormatMatches.forEach(match => {
+      if (!cookies.includes(match)) {
+        cookies.push(match);
+      }
+    });
+  }
+  
+  // 使用正则表达式匹配以ey开头的JWT格式cookie（新格式）
+  const jwtRegex = /ey[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g;
+  const jwtMatches = text.match(jwtRegex);
+  
+  if (jwtMatches) {
+    jwtMatches.forEach(match => {
+      if (!cookies.includes(match)) {
+        cookies.push(match);
+      }
+    });
+  }
+  
+  return cookies;
+}
+
+/**
+ * 验证cookie是否完整
+ * @param {string[]} cookies - 要验证的cookie数组
+ * @returns {string[]} - 验证后的cookie数组
+ */
+function validateCookies(cookies) {
+  return cookies.filter(cookie => {
+    // 检查是否是新格式的JWT token (ey开头)
+    if (cookie.startsWith('ey') && cookie.includes('.')) {
+      const parts = cookie.split('.');
+      // 检查JWT是否包含三个部分
+      if (parts.length === 3) {
+        return true; // cookie有效
+      } else {
+        console.warn(`检测到不完整的JWT(新格式): ${cookie}`);
+        return false;
+      }
+    } 
+    // 检查旧格式cookie是否完整
+    else if (cookie.includes('%3A%3A')) {
+      const parts = cookie.split('%3A%3A');
+      if (parts.length === 2) {
+        const jwt = parts[1];
+        // 检查JWT是否包含两个点（表示三个部分）
+        if (jwt.includes('.') && jwt.split('.').length === 3) {
+          return true; // cookie完整
+        } else {
+          console.warn(`检测到不完整的JWT(旧格式): ${cookie}`);
+          return false;
+        }
+      }
+    }
+    return true; // 对于无法识别的格式，默认保留
+  });
+}
+
+module.exports = {
+  extractCookiesFromCsv
+}; 

src/utils/keyManager.js

@@ -0,0 +1,406 @@
+const config = require('../config/config');
+const fs = require('fs');
+const path = require('path');
+
+// 定义无效cookie的存储文件路径
+const INVALID_COOKIES_FILE = path.join(__dirname, '../../data/invalid_cookies.json');
+// 定义API Keys的存储文件路径
+const API_KEYS_FILE = path.join(__dirname, '../../data/api_keys.json');
+
+// 确保data目录存在
+function ensureDataDirExists() {
+  const dataDir = path.join(__dirname, '../../data');
+  if (!fs.existsSync(dataDir)) {
+    try {
+      fs.mkdirSync(dataDir, { recursive: true });
+      console.log('创建data目录成功');
+    } catch (err) {
+      console.error('创建data目录失败:', err);
+    }
+  }
+}
+
+// 存储API key与Cursor cookie的映射关系
+let apiKeyMap = new Map();
+
+// 存储每个API key对应的cookie轮询索引
+let rotationIndexes = new Map();
+
+// 存储被标记为无效的cookie
+let invalidCookies = new Set();
+
+// 从文件加载无效cookie
+function loadInvalidCookiesFromFile() {
+  ensureDataDirExists();
+  
+  try {
+    if (fs.existsSync(INVALID_COOKIES_FILE)) {
+      const data = fs.readFileSync(INVALID_COOKIES_FILE, 'utf8');
+      const cookiesArray = JSON.parse(data);
+      
+      // 清空当前集合并添加从文件加载的cookie
+      invalidCookies.clear();
+      cookiesArray.forEach(cookie => invalidCookies.add(cookie));
+      
+      console.log(`从文件加载了 ${cookiesArray.length} 个无效cookie`);
+    } else {
+      saveInvalidCookiesToFile(); // 如果文件不存在，创建新文件
+    }
+  } catch (err) {
+    console.error('加载无效cookie文件失败:', err);
+    saveInvalidCookiesToFile(); // 如果加载失败，尝试创建新文件
+  }
+}
+
+// 将无效cookie保存到文件
+function saveInvalidCookiesToFile() {
+  ensureDataDirExists();
+  
+  try {
+    const cookiesArray = Array.from(invalidCookies);
+    fs.writeFileSync(INVALID_COOKIES_FILE, JSON.stringify(cookiesArray, null, 2), 'utf8');
+    console.log(`已将 ${cookiesArray.length} 个无效cookie保存到文件`);
+  } catch (err) {
+    console.error('保存无效cookie文件失败:', err);
+  }
+}
+
+// 从文件加载API Keys
+function loadApiKeysFromFile() {
+  ensureDataDirExists();
+  
+  try {
+    if (fs.existsSync(API_KEYS_FILE)) {
+      const data = fs.readFileSync(API_KEYS_FILE, 'utf8');
+      const apiKeysObj = JSON.parse(data);
+      
+      // 清空现有映射
+      apiKeyMap.clear();
+      rotationIndexes.clear();
+      
+      // 统计总cookie数量
+      let totalCookies = 0;
+      
+      // 添加从文件加载的API Keys
+      for (const [apiKey, cookies] of Object.entries(apiKeysObj)) {
+        if (Array.isArray(cookies)) {
+          apiKeyMap.set(apiKey, cookies);
+          rotationIndexes.set(apiKey, 0);
+          totalCookies += cookies.length;
+        } else {
+          console.error(`API Key ${apiKey} 的cookies不是数组，跳过`);
+        }
+      }
+      
+      const apiKeyCount = Object.keys(apiKeysObj).length;
+      console.log(`从文件加载了 ${apiKeyCount} 个API Key，共 ${totalCookies} 个Cookie`);
+      return apiKeyCount > 0;
+    } else {
+      console.log('API Keys文件不存在，将使用配置中的API Keys');
+      return false;
+    }
+  } catch (err) {
+    console.error('加载API Keys文件失败:', err);
+    return false;
+  }
+}
+
+// 将API Keys保存到文件
+function saveApiKeysToFile() {
+  ensureDataDirExists();
+  
+  try {
+    // 将Map转换为普通对象
+    const apiKeysObj = {};
+    for (const [apiKey, cookies] of apiKeyMap.entries()) {
+      apiKeysObj[apiKey] = cookies;
+    }
+    
+    // 使用JSON.stringify时避免特殊字符处理问题
+    const jsonString = JSON.stringify(apiKeysObj, null, 2);
+    fs.writeFileSync(API_KEYS_FILE, jsonString, 'utf8');
+    console.log(`已将 ${Object.keys(apiKeysObj).length} 个API Key保存到文件`);
+    
+    // 简化验证过程
+    try {
+      const savedContent = fs.readFileSync(API_KEYS_FILE, 'utf8');
+      JSON.parse(savedContent); // 只验证JSON格式是否正确
+      console.log('验证通过: 所有cookie都被完整保存');
+    } catch (verifyErr) {
+      console.error('验证保存内容时出错:', verifyErr);
+    }
+  } catch (err) {
+    console.error('保存API Keys文件失败:', err);
+  }
+}
+
+// API Keys初始化函数
+function initializeApiKeys() {
+    // 首先从文件加载现有的API Keys
+    const loadedFromFile = loadApiKeysFromFile();
+    
+    // 检查环境变量中是否有API Keys配置
+    const configApiKeys = config.apiKeys;
+    const hasEnvApiKeys = Object.keys(configApiKeys).length > 0;
+    
+    if (hasEnvApiKeys) {
+        console.log('从环境变量检测到API Keys配置，将合并到现有配置...');
+        
+        // 记录合并前的Cookie数量
+        let beforeMergeCookies = 0;
+        for (const cookies of apiKeyMap.values()) {
+            beforeMergeCookies += cookies.length;
+        }
+        
+        // 合并环境变量中的API Keys到现有映射
+        for (const [apiKey, cookieValue] of Object.entries(configApiKeys)) {
+            // 获取现有的cookies（如果有）
+            const existingCookies = apiKeyMap.get(apiKey) || [];
+            
+            // 准备要添加的新cookies
+            let newCookies = [];
+            if (typeof cookieValue === 'string') {
+                newCookies = [cookieValue];
+            } else if (Array.isArray(cookieValue)) {
+                newCookies = cookieValue;
+            }
+            
+            // 合并cookies，确保不重复
+            const mergedCookies = [...existingCookies];
+            for (const cookie of newCookies) {
+                if (!mergedCookies.includes(cookie)) {
+                    mergedCookies.push(cookie);
+                }
+            }
+            
+            // 更新映射
+            apiKeyMap.set(apiKey, mergedCookies);
+            
+            // 确保轮询索引存在
+            if (!rotationIndexes.has(apiKey)) {
+                rotationIndexes.set(apiKey, 0);
+            }
+        }
+        
+        // 记录合并后的Cookie数量
+        let afterMergeCookies = 0;
+        for (const cookies of apiKeyMap.values()) {
+            afterMergeCookies += cookies.length;
+        }
+        
+        console.log(`合并前共有 ${beforeMergeCookies} 个Cookie，合并后共有 ${afterMergeCookies} 个Cookie`);
+        
+        // 保存合并后的结果到文件
+        saveApiKeysToFile();
+    } else if (!loadedFromFile) {
+        console.log('警告: 未能从文件加载API Keys，且环境变量中也没有配置API Keys');
+    }
+    
+    // 统计API Keys和Cookies数量
+    let totalCookies = 0;
+    for (const cookies of apiKeyMap.values()) {
+        totalCookies += cookies.length;
+    }
+    
+    console.log(`API Keys初始化完成，共有 ${apiKeyMap.size} 个API Key，${totalCookies} 个Cookie`);
+    
+    // 加载无效cookie
+    loadInvalidCookiesFromFile();
+    
+    // 从API Key中移除已知的无效cookie
+    console.log('开始从API Keys中移除无效cookie...');
+    removeInvalidCookiesFromApiKeys();
+}
+
+// 从所有API Key中移除已知的无效cookie
+function removeInvalidCookiesFromApiKeys() {
+    let totalRemoved = 0;
+    
+    for (const [apiKey, cookies] of apiKeyMap.entries()) {
+        const initialLength = cookies.length;
+        
+        // 过滤掉无效的cookie
+        const filteredCookies = cookies.filter(cookie => !invalidCookies.has(cookie));
+        
+        // 如果有cookie被移除，更新API Key的cookie列表
+        if (filteredCookies.length < initialLength) {
+            const removedCount = initialLength - filteredCookies.length;
+            totalRemoved += removedCount;
+            
+            apiKeyMap.set(apiKey, filteredCookies);
+            rotationIndexes.set(apiKey, 0);
+            
+            console.log(`从API Key ${apiKey} 中移除了 ${removedCount} 个无效cookie，剩余 ${filteredCookies.length} 个`);
+        }
+    }
+    
+    console.log(`总共从API Keys中移除了 ${totalRemoved} 个无效cookie`);
+    
+    // 如果有cookie被移除，保存更新后的API Keys
+    if (totalRemoved > 0) {
+        saveApiKeysToFile();
+    }
+}
+
+// 添加或更新API key映射
+function addOrUpdateApiKey(apiKey, cookieValues) {
+    if (!Array.isArray(cookieValues)) {
+        cookieValues = [cookieValues];
+    }
+    
+    // 过滤掉已知的无效cookie
+    const validCookies = cookieValues.filter(cookie => !invalidCookies.has(cookie));
+    
+    if (validCookies.length < cookieValues.length) {
+        console.log(`API Key ${apiKey} 中有 ${cookieValues.length - validCookies.length} 个无效cookie被过滤`);
+    }
+    
+    apiKeyMap.set(apiKey, validCookies);
+    rotationIndexes.set(apiKey, 0);
+    
+    // 保存更新后的API Keys
+    saveApiKeysToFile();
+}
+
+// 删除API key映射
+function removeApiKey(apiKey) {
+    apiKeyMap.delete(apiKey);
+    rotationIndexes.delete(apiKey);
+    
+    // 保存更新后的API Keys
+    saveApiKeysToFile();
+}
+
+// 获取API key对应的cookie值（根据轮询策略）
+function getCookieForApiKey(apiKey, strategy = config.defaultRotationStrategy) {
+    // 如果API key不存在，也许是cookie本身，直接返回API key本身（向后兼容）
+    if (!apiKeyMap.has(apiKey)) {
+      return apiKey;
+    }
+    const cookies = apiKeyMap.get(apiKey);
+    
+    if (!cookies || cookies.length === 0) {
+        return apiKey;
+    }
+    
+    if (cookies.length === 1) {
+        return cookies[0];
+    }
+    
+    // 根据策略选择cookie
+    if (strategy === 'random') {
+        // 随机策略
+        const randomIndex = Math.floor(Math.random() * cookies.length);
+        return cookies[randomIndex];
+    } else {
+        // 轮询策略（round-robin）
+        let currentIndex = rotationIndexes.get(apiKey) || 0;
+        const cookie = cookies[currentIndex];
+        
+        // 更新索引
+        currentIndex = (currentIndex + 1) % cookies.length;
+        rotationIndexes.set(apiKey, currentIndex);
+        
+        return cookie;
+    }
+}
+
+// 获取所有API key
+function getAllApiKeys() {
+    return Array.from(apiKeyMap.keys());
+}
+
+// 获取API key对应的所有cookie
+function getAllCookiesForApiKey(apiKey) {
+    return apiKeyMap.get(apiKey) || [];
+}
+
+// 从API key的cookie列表中移除特定cookie
+function removeCookieFromApiKey(apiKey, cookieToRemove) {
+    if (!apiKeyMap.has(apiKey)) {
+        console.log(`API Key ${apiKey} 不存在，无法移除cookie`);
+        return false;
+    }
+    
+    const cookies = apiKeyMap.get(apiKey);
+    const initialLength = cookies.length;
+    
+    // 检查是否尝试移除与API Key相同的值（可能是向后兼容模式）
+    if (cookieToRemove === apiKey && initialLength === 0) {
+        console.log(`API Key ${apiKey} 中没有任何cookie，系统正在尝试以向后兼容模式使用API Key本身`);
+        return false;
+    }
+    
+    // 过滤掉要移除的cookie
+    const filteredCookies = cookies.filter(cookie => cookie !== cookieToRemove);
+    
+    // 如果长度没变，说明没有找到要移除的cookie
+    if (filteredCookies.length === initialLength) {
+        console.log(`未找到要移除的cookie: ${cookieToRemove}`);
+        return false;
+    }
+    
+    // 更新cookie列表
+    apiKeyMap.set(apiKey, filteredCookies);
+    
+    // 重置轮询索引
+    rotationIndexes.set(apiKey, 0);
+    
+    // 将移除的cookie添加到无效cookie集合中
+    invalidCookies.add(cookieToRemove);
+    
+    // 保存无效cookie到文件
+    saveInvalidCookiesToFile();
+    
+    // 保存更新后的API Keys
+    saveApiKeysToFile();
+    
+    console.log(`已从API Key ${apiKey} 中移除cookie: ${cookieToRemove}`);
+    console.log(`剩余cookie数量: ${filteredCookies.length}`);
+    
+    return true;
+}
+
+// 获取所有被标记为无效的cookie
+function getInvalidCookies() {
+    return invalidCookies;
+}
+
+// 清除特定的无效cookie记录
+function clearInvalidCookie(cookie) {
+    const result = invalidCookies.delete(cookie);
+    
+    if (result) {
+        // 保存更新后的无效cookie到文件
+        saveInvalidCookiesToFile();
+    }
+    
+    return result;
+}
+
+// 清除所有无效cookie记录
+function clearAllInvalidCookies() {
+    invalidCookies.clear();
+    
+    // 保存更新后的无效cookie到文件
+    saveInvalidCookiesToFile();
+    
+    return true;
+}
+
+module.exports = {
+    addOrUpdateApiKey,
+    removeApiKey,
+    getCookieForApiKey,
+    getAllApiKeys,
+    getAllCookiesForApiKey,
+    initializeApiKeys,
+    removeCookieFromApiKey,
+    getInvalidCookies,
+    clearInvalidCookie,
+    clearAllInvalidCookies,
+    loadInvalidCookiesFromFile,
+    saveInvalidCookiesToFile,
+    loadApiKeysFromFile,
+    saveApiKeysToFile
+}; 

src/utils/utils.js

@@ -0,0 +1,202 @@
+const os = require('os');
+const zlib = require('zlib');
+const crypto = require('crypto');
+const { v4: uuidv4 } = require('uuid');
+const $root = require('../proto/message.js');
+
+function generateCursorBody(messages, modelName) {
+
+  const instruction = messages
+    .filter(msg => msg.role === 'system')
+    .map(msg => msg.content)
+    .join('\n')
+
+  const formattedMessages = messages
+    .filter(msg => msg.role !== 'system')
+    .map(msg => ({
+      content: msg.content,
+      role: msg.role === 'user' ? 1 : 2,
+      messageId: uuidv4(),
+      ...(msg.role === 'user' ? { chatModeEnum: 1 } : {})
+      //...(msg.role !== 'user' ? { summaryId: uuidv4() } : {})
+    }));
+
+  const messageIds = formattedMessages.map(msg => {
+    const { role, messageId, summaryId } = msg;
+    return summaryId ? { role, messageId, summaryId } : { role, messageId };
+  });
+
+  const body = {
+    request:{
+      messages: formattedMessages,
+      unknown2: 1,
+      instruction: {
+        instruction: instruction
+      },
+      unknown4: 1,
+      model: {
+        name: modelName,
+        empty: '',
+      },
+      webTool: "",
+      unknown13: 1,
+      cursorSetting: {
+        name: "cursor\\aisettings",
+        unknown3: "",
+        unknown6: {
+          unknwon1: "",
+          unknown2: ""
+        },
+        unknown8: 1,
+        unknown9: 1
+      },
+      unknown19: 1,
+      //unknown22: 1,
+      conversationId: uuidv4(),
+      metadata: {
+        os: "win32",
+        arch: "x64",
+        version: "10.0.22631",
+        path: "C:\\Program Files\\PowerShell\\7\\pwsh.exe",
+        timestamp: new Date().toISOString(),
+      },
+      unknown27: 0,
+      //unknown29: "",
+      messageIds: messageIds,
+      largeContext: 0,
+      unknown38: 0,
+      chatModeEnum: 1,
+      unknown47: "",
+      unknown48: 0,
+      unknown49: 0,
+      unknown51: 0,
+      unknown53: 1,
+      chatMode: "Ask"
+    }
+  };
+
+  const errMsg = $root.StreamUnifiedChatWithToolsRequest.verify(body);
+  if (errMsg) throw Error(errMsg);
+  const instance = $root.StreamUnifiedChatWithToolsRequest.create(body);
+  let buffer = $root.StreamUnifiedChatWithToolsRequest.encode(instance).finish();
+  let magicNumber = 0x00
+  if (formattedMessages.length >= 3){
+    buffer = zlib.gzipSync(buffer)
+    magicNumber = 0x01
+  }
+
+  const finalBody = Buffer.concat([
+    Buffer.from([magicNumber]),
+    Buffer.from(buffer.length.toString(16).padStart(8, '0'), 'hex'),
+    buffer
+  ])
+
+  return finalBody
+}
+
+function chunkToUtf8String(chunk) {
+  const results = []
+  const errorResults = { hasError: false, errorMessage: '' }
+  const buffer = Buffer.from(chunk, 'hex');
+  //console.log("Chunk buffer:", buffer.toString('hex'))
+
+  try {
+    for(let i = 0; i < buffer.length; i++){
+      const magicNumber = parseInt(buffer.subarray(i, i + 1).toString('hex'), 16)
+      const dataLength = parseInt(buffer.subarray(i + 1, i + 5).toString('hex'), 16)
+      const data = buffer.subarray(i + 5, i + 5 + dataLength)
+      //console.log("Parsed buffer:", magicNumber, dataLength, data.toString('hex'))
+
+      if (magicNumber == 0 || magicNumber == 1) {
+        const gunzipData = magicNumber == 0 ? data : zlib.gunzipSync(data)
+        const response = $root.StreamUnifiedChatWithToolsResponse.decode(gunzipData);
+        const thinking = response?.message?.thinking?.content
+        if (thinking !== undefined){
+            results.push(thinking);
+            //console.log(thinking);
+        }
+
+        const content = response?.message?.content
+        if (content !== undefined){
+          results.push(content)
+          //console.log(content)
+        }
+        
+      }
+      else if (magicNumber == 2 || magicNumber == 3) { 
+        // Json message
+        const gunzipData = magicNumber == 2 ? data : zlib.gunzipSync(data)
+        const utf8 = gunzipData.toString('utf-8')
+        const message = JSON.parse(utf8)
+
+        if (message != null && (typeof message !== 'object' || 
+          (Array.isArray(message) ? message.length > 0 : Object.keys(message).length > 0))){
+            //results.push(utf8)
+            console.error(utf8)
+            
+            // 检查是否为错误消息
+            if (message && message.error) {
+              errorResults.hasError = true;
+              errorResults.errorMessage = utf8;
+            }
+        }
+      }
+      else {
+        //console.log('Unknown magic number when parsing chunk response: ' + magicNumber)
+      }
+
+      i += 5 + dataLength - 1
+    }
+  } catch (err) {
+    console.log('Error parsing chunk response:', err)
+  }
+
+  // 如果存在错误，返回错误对象
+  if (errorResults.hasError) {
+    return { error: errorResults.errorMessage };
+  }
+
+  return results.join('')
+}
+
+function generateHashed64Hex(input, salt = '') {
+  const hash = crypto.createHash('sha256');
+  hash.update(input + salt);
+  return hash.digest('hex');
+}
+
+function obfuscateBytes(byteArray) {
+  let t = 165;
+  for (let r = 0; r < byteArray.length; r++) {
+    byteArray[r] = (byteArray[r] ^ t) + (r % 256);
+    t = byteArray[r];
+  }
+  return byteArray;
+}
+
+function generateCursorChecksum(token) {
+  const machineId = generateHashed64Hex(token, 'machineId');
+  const macMachineId = generateHashed64Hex(token, 'macMachineId');
+
+  const timestamp = Math.floor(Date.now() / 1e6);
+  const byteArray = new Uint8Array([
+    (timestamp >> 40) & 255,
+    (timestamp >> 32) & 255,
+    (timestamp >> 24) & 255,
+    (timestamp >> 16) & 255,
+    (timestamp >> 8) & 255,
+    255 & timestamp,
+  ]);
+
+  const obfuscatedBytes = obfuscateBytes(byteArray);
+  const encodedChecksum = Buffer.from(obfuscatedBytes).toString('base64');
+
+  return `${encodedChecksum}${machineId}/${macMachineId}`;
+}
+
+module.exports = {
+  generateCursorBody,
+  chunkToUtf8String,
+  generateHashed64Hex,
+  generateCursorChecksum
+};