Upload 20 files

.github/workflows/publish-docker-image.yml

@@ -0,0 +1,60 @@
+name: Publish Docker Image
+
+on:
+  workflow_dispatch:
+
+env:
+  REGISTRY: ghcr.io
+  IMAGE_NAME: ${{ github.repository }}
+  MAJOR: 1
+  MINOR: 0
+  PATCH: ${{github.run_number}}
+
+jobs:
+  build-and-push-image:
+    runs-on: ubuntu-latest
+
+    # Sets the permissions granted to the `GITHUB_TOKEN` for the actions in this job.
+    permissions:
+      contents: read
+      packages: write
+      attestations: write
+      id-token: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      # Uses the `docker/login-action` action to log in to the Container registry registry using the account and password that will publish the packages. Once published, the packages are scoped to the account defined here.
+      - name: Log in to the Container registry
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      # This step uses [docker/metadata-action](https://github.com/docker/metadata-action#about) to extract tags and labels that will be applied to the specified image. The `id` "meta" allows the output of this step to be referenced in a subsequent step. The `images` value provides the base name for the tags and labels.
+      - name: Extract metadata (tags, labels) for Docker
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+          tags: |
+            type=ref,event=branch
+            type=raw,value=latest,enable=${{ github.ref == 'refs/heads/main' }}
+            type=raw,value=v${{ env.MAJOR }}.${{ env.MINOR }}.${{ env.PATCH }}
+
+      # This step uses the `docker/build-push-action` action to build the image, based on your repository's `Dockerfile`. If the build succeeds, it pushes the image to GitHub Packages.
+      # It uses the `context` parameter to define the build's context as the set of files located in the specified path. For more information, see "[Usage](https://github.com/docker/build-push-action#usage)" in the README of the `docker/build-push-action` repository.
+      # It uses the `tags` and `labels` parameters to tag and label the image with the output from the "meta" step.
+      - name: Build and push Docker image
+        id: push
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          subject-digest: ${{ steps.push.outputs.digest }}
+          push-to-registry: true
+      

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"
+] 

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(); 

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,50 @@
+// 读取并解析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',
+    
+    // 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.js

@@ -0,0 +1,1918 @@
+/*eslint-disable block-scoped-var, id-length, no-control-regex, no-magic-numbers, no-prototype-builtins, no-redeclare, no-shadow, no-var, sort-vars*/
+"use strict";
+
+var $protobuf = require("protobufjs/minimal");
+
+// Common aliases
+var $Reader = $protobuf.Reader, $Writer = $protobuf.Writer, $util = $protobuf.util;
+
+// Exported root namespace
+var $root = $protobuf.roots["default"] || ($protobuf.roots["default"] = {});
+
+$root.ChatMessage = (function() {
+
+    /**
+     * Properties of a ChatMessage.
+     * @exports IChatMessage
+     * @interface IChatMessage
+     * @property {Array.<ChatMessage.IUserMessage>|null} [userMessages] ChatMessage userMessages
+     * @property {ChatMessage.IInstructions|null} [instructions] ChatMessage instructions
+     * @property {ChatMessage.IModel|null} [model] ChatMessage model
+     * @property {number|null} [unknown13] ChatMessage unknown13
+     * @property {string|null} [conversationId] ChatMessage conversationId
+     * @property {number|null} [unknown16] ChatMessage unknown16
+     * @property {number|null} [unknown29] ChatMessage unknown29
+     * @property {number|null} [unknown31] ChatMessage unknown31
+     */
+
+    /**
+     * Constructs a new ChatMessage.
+     * @exports ChatMessage
+     * @classdesc Represents a ChatMessage.
+     * @implements IChatMessage
+     * @constructor
+     * @param {IChatMessage=} [properties] Properties to set
+     */
+    function ChatMessage(properties) {
+        this.userMessages = [];
+        if (properties)
+            for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                if (properties[keys[i]] != null)
+                    this[keys[i]] = properties[keys[i]];
+    }
+
+    /**
+     * ChatMessage userMessages.
+     * @member {Array.<ChatMessage.IUserMessage>} userMessages
+     * @memberof ChatMessage
+     * @instance
+     */
+    ChatMessage.prototype.userMessages = $util.emptyArray;
+
+    /**
+     * ChatMessage instructions.
+     * @member {ChatMessage.IInstructions|null|undefined} instructions
+     * @memberof ChatMessage
+     * @instance
+     */
+    ChatMessage.prototype.instructions = null;
+
+    /**
+     * ChatMessage model.
+     * @member {ChatMessage.IModel|null|undefined} model
+     * @memberof ChatMessage
+     * @instance
+     */
+    ChatMessage.prototype.model = null;
+
+    /**
+     * ChatMessage unknown13.
+     * @member {number} unknown13
+     * @memberof ChatMessage
+     * @instance
+     */
+    ChatMessage.prototype.unknown13 = 0;
+
+    /**
+     * ChatMessage conversationId.
+     * @member {string} conversationId
+     * @memberof ChatMessage
+     * @instance
+     */
+    ChatMessage.prototype.conversationId = "";
+
+    /**
+     * ChatMessage unknown16.
+     * @member {number} unknown16
+     * @memberof ChatMessage
+     * @instance
+     */
+    ChatMessage.prototype.unknown16 = 0;
+
+    /**
+     * ChatMessage unknown29.
+     * @member {number} unknown29
+     * @memberof ChatMessage
+     * @instance
+     */
+    ChatMessage.prototype.unknown29 = 0;
+
+    /**
+     * ChatMessage unknown31.
+     * @member {number} unknown31
+     * @memberof ChatMessage
+     * @instance
+     */
+    ChatMessage.prototype.unknown31 = 0;
+
+    /**
+     * Creates a new ChatMessage instance using the specified properties.
+     * @function create
+     * @memberof ChatMessage
+     * @static
+     * @param {IChatMessage=} [properties] Properties to set
+     * @returns {ChatMessage} ChatMessage instance
+     */
+    ChatMessage.create = function create(properties) {
+        return new ChatMessage(properties);
+    };
+
+    /**
+     * Encodes the specified ChatMessage message. Does not implicitly {@link ChatMessage.verify|verify} messages.
+     * @function encode
+     * @memberof ChatMessage
+     * @static
+     * @param {IChatMessage} message ChatMessage message or plain object to encode
+     * @param {$protobuf.Writer} [writer] Writer to encode to
+     * @returns {$protobuf.Writer} Writer
+     */
+    ChatMessage.encode = function encode(message, writer) {
+        if (!writer)
+            writer = $Writer.create();
+        if (message.userMessages != null && message.userMessages.length)
+            for (var i = 0; i < message.userMessages.length; ++i)
+                $root.ChatMessage.UserMessage.encode(message.userMessages[i], writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
+        if (message.instructions != null && Object.hasOwnProperty.call(message, "instructions"))
+            $root.ChatMessage.Instructions.encode(message.instructions, writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim();
+        if (message.model != null && Object.hasOwnProperty.call(message, "model"))
+            $root.ChatMessage.Model.encode(message.model, writer.uint32(/* id 7, wireType 2 =*/58).fork()).ldelim();
+        if (message.unknown13 != null && Object.hasOwnProperty.call(message, "unknown13"))
+            writer.uint32(/* id 13, wireType 0 =*/104).int32(message.unknown13);
+        if (message.conversationId != null && Object.hasOwnProperty.call(message, "conversationId"))
+            writer.uint32(/* id 15, wireType 2 =*/122).string(message.conversationId);
+        if (message.unknown16 != null && Object.hasOwnProperty.call(message, "unknown16"))
+            writer.uint32(/* id 16, wireType 0 =*/128).int32(message.unknown16);
+        if (message.unknown29 != null && Object.hasOwnProperty.call(message, "unknown29"))
+            writer.uint32(/* id 29, wireType 0 =*/232).int32(message.unknown29);
+        if (message.unknown31 != null && Object.hasOwnProperty.call(message, "unknown31"))
+            writer.uint32(/* id 31, wireType 0 =*/248).int32(message.unknown31);
+        return writer;
+    };
+
+    /**
+     * Encodes the specified ChatMessage message, length delimited. Does not implicitly {@link ChatMessage.verify|verify} messages.
+     * @function encodeDelimited
+     * @memberof ChatMessage
+     * @static
+     * @param {IChatMessage} message ChatMessage message or plain object to encode
+     * @param {$protobuf.Writer} [writer] Writer to encode to
+     * @returns {$protobuf.Writer} Writer
+     */
+    ChatMessage.encodeDelimited = function encodeDelimited(message, writer) {
+        return this.encode(message, writer).ldelim();
+    };
+
+    /**
+     * Decodes a ChatMessage message from the specified reader or buffer.
+     * @function decode
+     * @memberof ChatMessage
+     * @static
+     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+     * @param {number} [length] Message length if known beforehand
+     * @returns {ChatMessage} ChatMessage
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    ChatMessage.decode = function decode(reader, length) {
+        if (!(reader instanceof $Reader))
+            reader = $Reader.create(reader);
+        var end = length === undefined ? reader.len : reader.pos + length, message = new $root.ChatMessage();
+        while (reader.pos < end) {
+            var tag = reader.uint32();
+            switch (tag >>> 3) {
+            case 2: {
+                    if (!(message.userMessages && message.userMessages.length))
+                        message.userMessages = [];
+                    message.userMessages.push($root.ChatMessage.UserMessage.decode(reader, reader.uint32()));
+                    break;
+                }
+            case 4: {
+                    message.instructions = $root.ChatMessage.Instructions.decode(reader, reader.uint32());
+                    break;
+                }
+            case 7: {
+                    message.model = $root.ChatMessage.Model.decode(reader, reader.uint32());
+                    break;
+                }
+            case 13: {
+                    message.unknown13 = reader.int32();
+                    break;
+                }
+            case 15: {
+                    message.conversationId = reader.string();
+                    break;
+                }
+            case 16: {
+                    message.unknown16 = reader.int32();
+                    break;
+                }
+            case 29: {
+                    message.unknown29 = reader.int32();
+                    break;
+                }
+            case 31: {
+                    message.unknown31 = reader.int32();
+                    break;
+                }
+            default:
+                reader.skipType(tag & 7);
+                break;
+            }
+        }
+        return message;
+    };
+
+    /**
+     * Decodes a ChatMessage message from the specified reader or buffer, length delimited.
+     * @function decodeDelimited
+     * @memberof ChatMessage
+     * @static
+     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+     * @returns {ChatMessage} ChatMessage
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    ChatMessage.decodeDelimited = function decodeDelimited(reader) {
+        if (!(reader instanceof $Reader))
+            reader = new $Reader(reader);
+        return this.decode(reader, reader.uint32());
+    };
+
+    /**
+     * Verifies a ChatMessage message.
+     * @function verify
+     * @memberof ChatMessage
+     * @static
+     * @param {Object.<string,*>} message Plain object to verify
+     * @returns {string|null} `null` if valid, otherwise the reason why it is not
+     */
+    ChatMessage.verify = function verify(message) {
+        if (typeof message !== "object" || message === null)
+            return "object expected";
+        if (message.userMessages != null && message.hasOwnProperty("userMessages")) {
+            if (!Array.isArray(message.userMessages))
+                return "userMessages: array expected";
+            for (var i = 0; i < message.userMessages.length; ++i) {
+                var error = $root.ChatMessage.UserMessage.verify(message.userMessages[i]);
+                if (error)
+                    return "userMessages." + error;
+            }
+        }
+        if (message.instructions != null && message.hasOwnProperty("instructions")) {
+            var error = $root.ChatMessage.Instructions.verify(message.instructions);
+            if (error)
+                return "instructions." + error;
+        }
+        if (message.model != null && message.hasOwnProperty("model")) {
+            var error = $root.ChatMessage.Model.verify(message.model);
+            if (error)
+                return "model." + error;
+        }
+        if (message.unknown13 != null && message.hasOwnProperty("unknown13"))
+            if (!$util.isInteger(message.unknown13))
+                return "unknown13: integer expected";
+        if (message.conversationId != null && message.hasOwnProperty("conversationId"))
+            if (!$util.isString(message.conversationId))
+                return "conversationId: string expected";
+        if (message.unknown16 != null && message.hasOwnProperty("unknown16"))
+            if (!$util.isInteger(message.unknown16))
+                return "unknown16: integer expected";
+        if (message.unknown29 != null && message.hasOwnProperty("unknown29"))
+            if (!$util.isInteger(message.unknown29))
+                return "unknown29: integer expected";
+        if (message.unknown31 != null && message.hasOwnProperty("unknown31"))
+            if (!$util.isInteger(message.unknown31))
+                return "unknown31: integer expected";
+        return null;
+    };
+
+    /**
+     * Creates a ChatMessage message from a plain object. Also converts values to their respective internal types.
+     * @function fromObject
+     * @memberof ChatMessage
+     * @static
+     * @param {Object.<string,*>} object Plain object
+     * @returns {ChatMessage} ChatMessage
+     */
+    ChatMessage.fromObject = function fromObject(object) {
+        if (object instanceof $root.ChatMessage)
+            return object;
+        var message = new $root.ChatMessage();
+        if (object.userMessages) {
+            if (!Array.isArray(object.userMessages))
+                throw TypeError(".ChatMessage.userMessages: array expected");
+            message.userMessages = [];
+            for (var i = 0; i < object.userMessages.length; ++i) {
+                if (typeof object.userMessages[i] !== "object")
+                    throw TypeError(".ChatMessage.userMessages: object expected");
+                message.userMessages[i] = $root.ChatMessage.UserMessage.fromObject(object.userMessages[i]);
+            }
+        }
+        if (object.instructions != null) {
+            if (typeof object.instructions !== "object")
+                throw TypeError(".ChatMessage.instructions: object expected");
+            message.instructions = $root.ChatMessage.Instructions.fromObject(object.instructions);
+        }
+        if (object.model != null) {
+            if (typeof object.model !== "object")
+                throw TypeError(".ChatMessage.model: object expected");
+            message.model = $root.ChatMessage.Model.fromObject(object.model);
+        }
+        if (object.unknown13 != null)
+            message.unknown13 = object.unknown13 | 0;
+        if (object.conversationId != null)
+            message.conversationId = String(object.conversationId);
+        if (object.unknown16 != null)
+            message.unknown16 = object.unknown16 | 0;
+        if (object.unknown29 != null)
+            message.unknown29 = object.unknown29 | 0;
+        if (object.unknown31 != null)
+            message.unknown31 = object.unknown31 | 0;
+        return message;
+    };
+
+    /**
+     * Creates a plain object from a ChatMessage message. Also converts values to other types if specified.
+     * @function toObject
+     * @memberof ChatMessage
+     * @static
+     * @param {ChatMessage} message ChatMessage
+     * @param {$protobuf.IConversionOptions} [options] Conversion options
+     * @returns {Object.<string,*>} Plain object
+     */
+    ChatMessage.toObject = function toObject(message, options) {
+        if (!options)
+            options = {};
+        var object = {};
+        if (options.arrays || options.defaults)
+            object.userMessages = [];
+        if (options.defaults) {
+            object.instructions = null;
+            object.model = null;
+            object.unknown13 = 0;
+            object.conversationId = "";
+            object.unknown16 = 0;
+            object.unknown29 = 0;
+            object.unknown31 = 0;
+        }
+        if (message.userMessages && message.userMessages.length) {
+            object.userMessages = [];
+            for (var j = 0; j < message.userMessages.length; ++j)
+                object.userMessages[j] = $root.ChatMessage.UserMessage.toObject(message.userMessages[j], options);
+        }
+        if (message.instructions != null && message.hasOwnProperty("instructions"))
+            object.instructions = $root.ChatMessage.Instructions.toObject(message.instructions, options);
+        if (message.model != null && message.hasOwnProperty("model"))
+            object.model = $root.ChatMessage.Model.toObject(message.model, options);
+        if (message.unknown13 != null && message.hasOwnProperty("unknown13"))
+            object.unknown13 = message.unknown13;
+        if (message.conversationId != null && message.hasOwnProperty("conversationId"))
+            object.conversationId = message.conversationId;
+        if (message.unknown16 != null && message.hasOwnProperty("unknown16"))
+            object.unknown16 = message.unknown16;
+        if (message.unknown29 != null && message.hasOwnProperty("unknown29"))
+            object.unknown29 = message.unknown29;
+        if (message.unknown31 != null && message.hasOwnProperty("unknown31"))
+            object.unknown31 = message.unknown31;
+        return object;
+    };
+
+    /**
+     * Converts this ChatMessage to JSON.
+     * @function toJSON
+     * @memberof ChatMessage
+     * @instance
+     * @returns {Object.<string,*>} JSON object
+     */
+    ChatMessage.prototype.toJSON = function toJSON() {
+        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+    };
+
+    /**
+     * Gets the default type url for ChatMessage
+     * @function getTypeUrl
+     * @memberof ChatMessage
+     * @static
+     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+     * @returns {string} The default type url
+     */
+    ChatMessage.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+        if (typeUrlPrefix === undefined) {
+            typeUrlPrefix = "type.googleapis.com";
+        }
+        return typeUrlPrefix + "/ChatMessage";
+    };
+
+    ChatMessage.UserMessage = (function() {
+
+        /**
+         * Properties of a UserMessage.
+         * @memberof ChatMessage
+         * @interface IUserMessage
+         * @property {string|null} [content] UserMessage content
+         * @property {number|null} [role] UserMessage role
+         * @property {string|null} [messageId] UserMessage messageId
+         */
+
+        /**
+         * Constructs a new UserMessage.
+         * @memberof ChatMessage
+         * @classdesc Represents a UserMessage.
+         * @implements IUserMessage
+         * @constructor
+         * @param {ChatMessage.IUserMessage=} [properties] Properties to set
+         */
+        function UserMessage(properties) {
+            if (properties)
+                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                    if (properties[keys[i]] != null)
+                        this[keys[i]] = properties[keys[i]];
+        }
+
+        /**
+         * UserMessage content.
+         * @member {string} content
+         * @memberof ChatMessage.UserMessage
+         * @instance
+         */
+        UserMessage.prototype.content = "";
+
+        /**
+         * UserMessage role.
+         * @member {number} role
+         * @memberof ChatMessage.UserMessage
+         * @instance
+         */
+        UserMessage.prototype.role = 0;
+
+        /**
+         * UserMessage messageId.
+         * @member {string} messageId
+         * @memberof ChatMessage.UserMessage
+         * @instance
+         */
+        UserMessage.prototype.messageId = "";
+
+        /**
+         * Creates a new UserMessage instance using the specified properties.
+         * @function create
+         * @memberof ChatMessage.UserMessage
+         * @static
+         * @param {ChatMessage.IUserMessage=} [properties] Properties to set
+         * @returns {ChatMessage.UserMessage} UserMessage instance
+         */
+        UserMessage.create = function create(properties) {
+            return new UserMessage(properties);
+        };
+
+        /**
+         * Encodes the specified UserMessage message. Does not implicitly {@link ChatMessage.UserMessage.verify|verify} messages.
+         * @function encode
+         * @memberof ChatMessage.UserMessage
+         * @static
+         * @param {ChatMessage.IUserMessage} message UserMessage message or plain object to encode
+         * @param {$protobuf.Writer} [writer] Writer to encode to
+         * @returns {$protobuf.Writer} Writer
+         */
+        UserMessage.encode = function encode(message, writer) {
+            if (!writer)
+                writer = $Writer.create();
+            if (message.content != null && Object.hasOwnProperty.call(message, "content"))
+                writer.uint32(/* id 1, wireType 2 =*/10).string(message.content);
+            if (message.role != null && Object.hasOwnProperty.call(message, "role"))
+                writer.uint32(/* id 2, wireType 0 =*/16).int32(message.role);
+            if (message.messageId != null && Object.hasOwnProperty.call(message, "messageId"))
+                writer.uint32(/* id 13, wireType 2 =*/106).string(message.messageId);
+            return writer;
+        };
+
+        /**
+         * Encodes the specified UserMessage message, length delimited. Does not implicitly {@link ChatMessage.UserMessage.verify|verify} messages.
+         * @function encodeDelimited
+         * @memberof ChatMessage.UserMessage
+         * @static
+         * @param {ChatMessage.IUserMessage} message UserMessage message or plain object to encode
+         * @param {$protobuf.Writer} [writer] Writer to encode to
+         * @returns {$protobuf.Writer} Writer
+         */
+        UserMessage.encodeDelimited = function encodeDelimited(message, writer) {
+            return this.encode(message, writer).ldelim();
+        };
+
+        /**
+         * Decodes a UserMessage message from the specified reader or buffer.
+         * @function decode
+         * @memberof ChatMessage.UserMessage
+         * @static
+         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+         * @param {number} [length] Message length if known beforehand
+         * @returns {ChatMessage.UserMessage} UserMessage
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        UserMessage.decode = function decode(reader, length) {
+            if (!(reader instanceof $Reader))
+                reader = $Reader.create(reader);
+            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.ChatMessage.UserMessage();
+            while (reader.pos < end) {
+                var tag = reader.uint32();
+                switch (tag >>> 3) {
+                case 1: {
+                        message.content = reader.string();
+                        break;
+                    }
+                case 2: {
+                        message.role = reader.int32();
+                        break;
+                    }
+                case 13: {
+                        message.messageId = reader.string();
+                        break;
+                    }
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+                }
+            }
+            return message;
+        };
+
+        /**
+         * Decodes a UserMessage message from the specified reader or buffer, length delimited.
+         * @function decodeDelimited
+         * @memberof ChatMessage.UserMessage
+         * @static
+         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+         * @returns {ChatMessage.UserMessage} UserMessage
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        UserMessage.decodeDelimited = function decodeDelimited(reader) {
+            if (!(reader instanceof $Reader))
+                reader = new $Reader(reader);
+            return this.decode(reader, reader.uint32());
+        };
+
+        /**
+         * Verifies a UserMessage message.
+         * @function verify
+         * @memberof ChatMessage.UserMessage
+         * @static
+         * @param {Object.<string,*>} message Plain object to verify
+         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+         */
+        UserMessage.verify = function verify(message) {
+            if (typeof message !== "object" || message === null)
+                return "object expected";
+            if (message.content != null && message.hasOwnProperty("content"))
+                if (!$util.isString(message.content))
+                    return "content: string expected";
+            if (message.role != null && message.hasOwnProperty("role"))
+                if (!$util.isInteger(message.role))
+                    return "role: integer expected";
+            if (message.messageId != null && message.hasOwnProperty("messageId"))
+                if (!$util.isString(message.messageId))
+                    return "messageId: string expected";
+            return null;
+        };
+
+        /**
+         * Creates a UserMessage message from a plain object. Also converts values to their respective internal types.
+         * @function fromObject
+         * @memberof ChatMessage.UserMessage
+         * @static
+         * @param {Object.<string,*>} object Plain object
+         * @returns {ChatMessage.UserMessage} UserMessage
+         */
+        UserMessage.fromObject = function fromObject(object) {
+            if (object instanceof $root.ChatMessage.UserMessage)
+                return object;
+            var message = new $root.ChatMessage.UserMessage();
+            if (object.content != null)
+                message.content = String(object.content);
+            if (object.role != null)
+                message.role = object.role | 0;
+            if (object.messageId != null)
+                message.messageId = String(object.messageId);
+            return message;
+        };
+
+        /**
+         * Creates a plain object from a UserMessage message. Also converts values to other types if specified.
+         * @function toObject
+         * @memberof ChatMessage.UserMessage
+         * @static
+         * @param {ChatMessage.UserMessage} message UserMessage
+         * @param {$protobuf.IConversionOptions} [options] Conversion options
+         * @returns {Object.<string,*>} Plain object
+         */
+        UserMessage.toObject = function toObject(message, options) {
+            if (!options)
+                options = {};
+            var object = {};
+            if (options.defaults) {
+                object.content = "";
+                object.role = 0;
+                object.messageId = "";
+            }
+            if (message.content != null && message.hasOwnProperty("content"))
+                object.content = message.content;
+            if (message.role != null && message.hasOwnProperty("role"))
+                object.role = message.role;
+            if (message.messageId != null && message.hasOwnProperty("messageId"))
+                object.messageId = message.messageId;
+            return object;
+        };
+
+        /**
+         * Converts this UserMessage to JSON.
+         * @function toJSON
+         * @memberof ChatMessage.UserMessage
+         * @instance
+         * @returns {Object.<string,*>} JSON object
+         */
+        UserMessage.prototype.toJSON = function toJSON() {
+            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+        };
+
+        /**
+         * Gets the default type url for UserMessage
+         * @function getTypeUrl
+         * @memberof ChatMessage.UserMessage
+         * @static
+         * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+         * @returns {string} The default type url
+         */
+        UserMessage.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+            if (typeUrlPrefix === undefined) {
+                typeUrlPrefix = "type.googleapis.com";
+            }
+            return typeUrlPrefix + "/ChatMessage.UserMessage";
+        };
+
+        return UserMessage;
+    })();
+
+    ChatMessage.Instructions = (function() {
+
+        /**
+         * Properties of an Instructions.
+         * @memberof ChatMessage
+         * @interface IInstructions
+         * @property {string|null} [instruction] Instructions instruction
+         */
+
+        /**
+         * Constructs a new Instructions.
+         * @memberof ChatMessage
+         * @classdesc Represents an Instructions.
+         * @implements IInstructions
+         * @constructor
+         * @param {ChatMessage.IInstructions=} [properties] Properties to set
+         */
+        function Instructions(properties) {
+            if (properties)
+                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                    if (properties[keys[i]] != null)
+                        this[keys[i]] = properties[keys[i]];
+        }
+
+        /**
+         * Instructions instruction.
+         * @member {string} instruction
+         * @memberof ChatMessage.Instructions
+         * @instance
+         */
+        Instructions.prototype.instruction = "";
+
+        /**
+         * Creates a new Instructions instance using the specified properties.
+         * @function create
+         * @memberof ChatMessage.Instructions
+         * @static
+         * @param {ChatMessage.IInstructions=} [properties] Properties to set
+         * @returns {ChatMessage.Instructions} Instructions instance
+         */
+        Instructions.create = function create(properties) {
+            return new Instructions(properties);
+        };
+
+        /**
+         * Encodes the specified Instructions message. Does not implicitly {@link ChatMessage.Instructions.verify|verify} messages.
+         * @function encode
+         * @memberof ChatMessage.Instructions
+         * @static
+         * @param {ChatMessage.IInstructions} message Instructions message or plain object to encode
+         * @param {$protobuf.Writer} [writer] Writer to encode to
+         * @returns {$protobuf.Writer} Writer
+         */
+        Instructions.encode = function encode(message, writer) {
+            if (!writer)
+                writer = $Writer.create();
+            if (message.instruction != null && Object.hasOwnProperty.call(message, "instruction"))
+                writer.uint32(/* id 1, wireType 2 =*/10).string(message.instruction);
+            return writer;
+        };
+
+        /**
+         * Encodes the specified Instructions message, length delimited. Does not implicitly {@link ChatMessage.Instructions.verify|verify} messages.
+         * @function encodeDelimited
+         * @memberof ChatMessage.Instructions
+         * @static
+         * @param {ChatMessage.IInstructions} message Instructions message or plain object to encode
+         * @param {$protobuf.Writer} [writer] Writer to encode to
+         * @returns {$protobuf.Writer} Writer
+         */
+        Instructions.encodeDelimited = function encodeDelimited(message, writer) {
+            return this.encode(message, writer).ldelim();
+        };
+
+        /**
+         * Decodes an Instructions message from the specified reader or buffer.
+         * @function decode
+         * @memberof ChatMessage.Instructions
+         * @static
+         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+         * @param {number} [length] Message length if known beforehand
+         * @returns {ChatMessage.Instructions} Instructions
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        Instructions.decode = function decode(reader, length) {
+            if (!(reader instanceof $Reader))
+                reader = $Reader.create(reader);
+            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.ChatMessage.Instructions();
+            while (reader.pos < end) {
+                var tag = reader.uint32();
+                switch (tag >>> 3) {
+                case 1: {
+                        message.instruction = reader.string();
+                        break;
+                    }
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+                }
+            }
+            return message;
+        };
+
+        /**
+         * Decodes an Instructions message from the specified reader or buffer, length delimited.
+         * @function decodeDelimited
+         * @memberof ChatMessage.Instructions
+         * @static
+         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+         * @returns {ChatMessage.Instructions} Instructions
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        Instructions.decodeDelimited = function decodeDelimited(reader) {
+            if (!(reader instanceof $Reader))
+                reader = new $Reader(reader);
+            return this.decode(reader, reader.uint32());
+        };
+
+        /**
+         * Verifies an Instructions message.
+         * @function verify
+         * @memberof ChatMessage.Instructions
+         * @static
+         * @param {Object.<string,*>} message Plain object to verify
+         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+         */
+        Instructions.verify = function verify(message) {
+            if (typeof message !== "object" || message === null)
+                return "object expected";
+            if (message.instruction != null && message.hasOwnProperty("instruction"))
+                if (!$util.isString(message.instruction))
+                    return "instruction: string expected";
+            return null;
+        };
+
+        /**
+         * Creates an Instructions message from a plain object. Also converts values to their respective internal types.
+         * @function fromObject
+         * @memberof ChatMessage.Instructions
+         * @static
+         * @param {Object.<string,*>} object Plain object
+         * @returns {ChatMessage.Instructions} Instructions
+         */
+        Instructions.fromObject = function fromObject(object) {
+            if (object instanceof $root.ChatMessage.Instructions)
+                return object;
+            var message = new $root.ChatMessage.Instructions();
+            if (object.instruction != null)
+                message.instruction = String(object.instruction);
+            return message;
+        };
+
+        /**
+         * Creates a plain object from an Instructions message. Also converts values to other types if specified.
+         * @function toObject
+         * @memberof ChatMessage.Instructions
+         * @static
+         * @param {ChatMessage.Instructions} message Instructions
+         * @param {$protobuf.IConversionOptions} [options] Conversion options
+         * @returns {Object.<string,*>} Plain object
+         */
+        Instructions.toObject = function toObject(message, options) {
+            if (!options)
+                options = {};
+            var object = {};
+            if (options.defaults)
+                object.instruction = "";
+            if (message.instruction != null && message.hasOwnProperty("instruction"))
+                object.instruction = message.instruction;
+            return object;
+        };
+
+        /**
+         * Converts this Instructions to JSON.
+         * @function toJSON
+         * @memberof ChatMessage.Instructions
+         * @instance
+         * @returns {Object.<string,*>} JSON object
+         */
+        Instructions.prototype.toJSON = function toJSON() {
+            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+        };
+
+        /**
+         * Gets the default type url for Instructions
+         * @function getTypeUrl
+         * @memberof ChatMessage.Instructions
+         * @static
+         * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+         * @returns {string} The default type url
+         */
+        Instructions.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+            if (typeUrlPrefix === undefined) {
+                typeUrlPrefix = "type.googleapis.com";
+            }
+            return typeUrlPrefix + "/ChatMessage.Instructions";
+        };
+
+        return Instructions;
+    })();
+
+    ChatMessage.Model = (function() {
+
+        /**
+         * Properties of a Model.
+         * @memberof ChatMessage
+         * @interface IModel
+         * @property {string|null} [name] Model name
+         * @property {Uint8Array|null} [empty] Model empty
+         */
+
+        /**
+         * Constructs a new Model.
+         * @memberof ChatMessage
+         * @classdesc Represents a Model.
+         * @implements IModel
+         * @constructor
+         * @param {ChatMessage.IModel=} [properties] Properties to set
+         */
+        function Model(properties) {
+            if (properties)
+                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                    if (properties[keys[i]] != null)
+                        this[keys[i]] = properties[keys[i]];
+        }
+
+        /**
+         * Model name.
+         * @member {string} name
+         * @memberof ChatMessage.Model
+         * @instance
+         */
+        Model.prototype.name = "";
+
+        /**
+         * Model empty.
+         * @member {Uint8Array} empty
+         * @memberof ChatMessage.Model
+         * @instance
+         */
+        Model.prototype.empty = $util.newBuffer([]);
+
+        /**
+         * Creates a new Model instance using the specified properties.
+         * @function create
+         * @memberof ChatMessage.Model
+         * @static
+         * @param {ChatMessage.IModel=} [properties] Properties to set
+         * @returns {ChatMessage.Model} Model instance
+         */
+        Model.create = function create(properties) {
+            return new Model(properties);
+        };
+
+        /**
+         * Encodes the specified Model message. Does not implicitly {@link ChatMessage.Model.verify|verify} messages.
+         * @function encode
+         * @memberof ChatMessage.Model
+         * @static
+         * @param {ChatMessage.IModel} message Model message or plain object to encode
+         * @param {$protobuf.Writer} [writer] Writer to encode to
+         * @returns {$protobuf.Writer} Writer
+         */
+        Model.encode = function encode(message, writer) {
+            if (!writer)
+                writer = $Writer.create();
+            if (message.name != null && Object.hasOwnProperty.call(message, "name"))
+                writer.uint32(/* id 1, wireType 2 =*/10).string(message.name);
+            if (message.empty != null && Object.hasOwnProperty.call(message, "empty"))
+                writer.uint32(/* id 4, wireType 2 =*/34).bytes(message.empty);
+            return writer;
+        };
+
+        /**
+         * Encodes the specified Model message, length delimited. Does not implicitly {@link ChatMessage.Model.verify|verify} messages.
+         * @function encodeDelimited
+         * @memberof ChatMessage.Model
+         * @static
+         * @param {ChatMessage.IModel} message Model message or plain object to encode
+         * @param {$protobuf.Writer} [writer] Writer to encode to
+         * @returns {$protobuf.Writer} Writer
+         */
+        Model.encodeDelimited = function encodeDelimited(message, writer) {
+            return this.encode(message, writer).ldelim();
+        };
+
+        /**
+         * Decodes a Model message from the specified reader or buffer.
+         * @function decode
+         * @memberof ChatMessage.Model
+         * @static
+         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+         * @param {number} [length] Message length if known beforehand
+         * @returns {ChatMessage.Model} Model
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        Model.decode = function decode(reader, length) {
+            if (!(reader instanceof $Reader))
+                reader = $Reader.create(reader);
+            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.ChatMessage.Model();
+            while (reader.pos < end) {
+                var tag = reader.uint32();
+                switch (tag >>> 3) {
+                case 1: {
+                        message.name = reader.string();
+                        break;
+                    }
+                case 4: {
+                        message.empty = reader.bytes();
+                        break;
+                    }
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+                }
+            }
+            return message;
+        };
+
+        /**
+         * Decodes a Model message from the specified reader or buffer, length delimited.
+         * @function decodeDelimited
+         * @memberof ChatMessage.Model
+         * @static
+         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+         * @returns {ChatMessage.Model} Model
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        Model.decodeDelimited = function decodeDelimited(reader) {
+            if (!(reader instanceof $Reader))
+                reader = new $Reader(reader);
+            return this.decode(reader, reader.uint32());
+        };
+
+        /**
+         * Verifies a Model message.
+         * @function verify
+         * @memberof ChatMessage.Model
+         * @static
+         * @param {Object.<string,*>} message Plain object to verify
+         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+         */
+        Model.verify = function verify(message) {
+            if (typeof message !== "object" || message === null)
+                return "object expected";
+            if (message.name != null && message.hasOwnProperty("name"))
+                if (!$util.isString(message.name))
+                    return "name: string expected";
+            if (message.empty != null && message.hasOwnProperty("empty"))
+                if (!(message.empty && typeof message.empty.length === "number" || $util.isString(message.empty)))
+                    return "empty: buffer expected";
+            return null;
+        };
+
+        /**
+         * Creates a Model message from a plain object. Also converts values to their respective internal types.
+         * @function fromObject
+         * @memberof ChatMessage.Model
+         * @static
+         * @param {Object.<string,*>} object Plain object
+         * @returns {ChatMessage.Model} Model
+         */
+        Model.fromObject = function fromObject(object) {
+            if (object instanceof $root.ChatMessage.Model)
+                return object;
+            var message = new $root.ChatMessage.Model();
+            if (object.name != null)
+                message.name = String(object.name);
+            if (object.empty != null)
+                if (typeof object.empty === "string")
+                    $util.base64.decode(object.empty, message.empty = $util.newBuffer($util.base64.length(object.empty)), 0);
+                else if (object.empty.length >= 0)
+                    message.empty = object.empty;
+            return message;
+        };
+
+        /**
+         * Creates a plain object from a Model message. Also converts values to other types if specified.
+         * @function toObject
+         * @memberof ChatMessage.Model
+         * @static
+         * @param {ChatMessage.Model} message Model
+         * @param {$protobuf.IConversionOptions} [options] Conversion options
+         * @returns {Object.<string,*>} Plain object
+         */
+        Model.toObject = function toObject(message, options) {
+            if (!options)
+                options = {};
+            var object = {};
+            if (options.defaults) {
+                object.name = "";
+                if (options.bytes === String)
+                    object.empty = "";
+                else {
+                    object.empty = [];
+                    if (options.bytes !== Array)
+                        object.empty = $util.newBuffer(object.empty);
+                }
+            }
+            if (message.name != null && message.hasOwnProperty("name"))
+                object.name = message.name;
+            if (message.empty != null && message.hasOwnProperty("empty"))
+                object.empty = options.bytes === String ? $util.base64.encode(message.empty, 0, message.empty.length) : options.bytes === Array ? Array.prototype.slice.call(message.empty) : message.empty;
+            return object;
+        };
+
+        /**
+         * Converts this Model to JSON.
+         * @function toJSON
+         * @memberof ChatMessage.Model
+         * @instance
+         * @returns {Object.<string,*>} JSON object
+         */
+        Model.prototype.toJSON = function toJSON() {
+            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+        };
+
+        /**
+         * Gets the default type url for Model
+         * @function getTypeUrl
+         * @memberof ChatMessage.Model
+         * @static
+         * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+         * @returns {string} The default type url
+         */
+        Model.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+            if (typeUrlPrefix === undefined) {
+                typeUrlPrefix = "type.googleapis.com";
+            }
+            return typeUrlPrefix + "/ChatMessage.Model";
+        };
+
+        return Model;
+    })();
+
+    return ChatMessage;
+})();
+
+$root.ResMessage = (function() {
+
+    /**
+     * Properties of a ResMessage.
+     * @exports IResMessage
+     * @interface IResMessage
+     * @property {string|null} [content] ResMessage content
+     * @property {Uint8Array|null} [empty] ResMessage empty
+     * @property {string|null} [prompt] ResMessage prompt
+     */
+
+    /**
+     * Constructs a new ResMessage.
+     * @exports ResMessage
+     * @classdesc Represents a ResMessage.
+     * @implements IResMessage
+     * @constructor
+     * @param {IResMessage=} [properties] Properties to set
+     */
+    function ResMessage(properties) {
+        if (properties)
+            for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                if (properties[keys[i]] != null)
+                    this[keys[i]] = properties[keys[i]];
+    }
+
+    /**
+     * ResMessage content.
+     * @member {string} content
+     * @memberof ResMessage
+     * @instance
+     */
+    ResMessage.prototype.content = "";
+
+    /**
+     * ResMessage empty.
+     * @member {Uint8Array} empty
+     * @memberof ResMessage
+     * @instance
+     */
+    ResMessage.prototype.empty = $util.newBuffer([]);
+
+    /**
+     * ResMessage prompt.
+     * @member {string} prompt
+     * @memberof ResMessage
+     * @instance
+     */
+    ResMessage.prototype.prompt = "";
+
+    /**
+     * Creates a new ResMessage instance using the specified properties.
+     * @function create
+     * @memberof ResMessage
+     * @static
+     * @param {IResMessage=} [properties] Properties to set
+     * @returns {ResMessage} ResMessage instance
+     */
+    ResMessage.create = function create(properties) {
+        return new ResMessage(properties);
+    };
+
+    /**
+     * Encodes the specified ResMessage message. Does not implicitly {@link ResMessage.verify|verify} messages.
+     * @function encode
+     * @memberof ResMessage
+     * @static
+     * @param {IResMessage} message ResMessage message or plain object to encode
+     * @param {$protobuf.Writer} [writer] Writer to encode to
+     * @returns {$protobuf.Writer} Writer
+     */
+    ResMessage.encode = function encode(message, writer) {
+        if (!writer)
+            writer = $Writer.create();
+        if (message.content != null && Object.hasOwnProperty.call(message, "content"))
+            writer.uint32(/* id 1, wireType 2 =*/10).string(message.content);
+        if (message.empty != null && Object.hasOwnProperty.call(message, "empty"))
+            writer.uint32(/* id 4, wireType 2 =*/34).bytes(message.empty);
+        if (message.prompt != null && Object.hasOwnProperty.call(message, "prompt"))
+            writer.uint32(/* id 5, wireType 2 =*/42).string(message.prompt);
+        return writer;
+    };
+
+    /**
+     * Encodes the specified ResMessage message, length delimited. Does not implicitly {@link ResMessage.verify|verify} messages.
+     * @function encodeDelimited
+     * @memberof ResMessage
+     * @static
+     * @param {IResMessage} message ResMessage message or plain object to encode
+     * @param {$protobuf.Writer} [writer] Writer to encode to
+     * @returns {$protobuf.Writer} Writer
+     */
+    ResMessage.encodeDelimited = function encodeDelimited(message, writer) {
+        return this.encode(message, writer).ldelim();
+    };
+
+    /**
+     * Decodes a ResMessage message from the specified reader or buffer.
+     * @function decode
+     * @memberof ResMessage
+     * @static
+     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+     * @param {number} [length] Message length if known beforehand
+     * @returns {ResMessage} ResMessage
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    ResMessage.decode = function decode(reader, length) {
+        if (!(reader instanceof $Reader))
+            reader = $Reader.create(reader);
+        var end = length === undefined ? reader.len : reader.pos + length, message = new $root.ResMessage();
+        while (reader.pos < end) {
+            var tag = reader.uint32();
+            switch (tag >>> 3) {
+            case 1: {
+                    message.content = reader.string();
+                    break;
+                }
+            case 4: {
+                    message.empty = reader.bytes();
+                    break;
+                }
+            case 5: {
+                    message.prompt = reader.string();
+                    break;
+                }
+            default:
+                reader.skipType(tag & 7);
+                break;
+            }
+        }
+        return message;
+    };
+
+    /**
+     * Decodes a ResMessage message from the specified reader or buffer, length delimited.
+     * @function decodeDelimited
+     * @memberof ResMessage
+     * @static
+     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+     * @returns {ResMessage} ResMessage
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    ResMessage.decodeDelimited = function decodeDelimited(reader) {
+        if (!(reader instanceof $Reader))
+            reader = new $Reader(reader);
+        return this.decode(reader, reader.uint32());
+    };
+
+    /**
+     * Verifies a ResMessage message.
+     * @function verify
+     * @memberof ResMessage
+     * @static
+     * @param {Object.<string,*>} message Plain object to verify
+     * @returns {string|null} `null` if valid, otherwise the reason why it is not
+     */
+    ResMessage.verify = function verify(message) {
+        if (typeof message !== "object" || message === null)
+            return "object expected";
+        if (message.content != null && message.hasOwnProperty("content"))
+            if (!$util.isString(message.content))
+                return "content: string expected";
+        if (message.empty != null && message.hasOwnProperty("empty"))
+            if (!(message.empty && typeof message.empty.length === "number" || $util.isString(message.empty)))
+                return "empty: buffer expected";
+        if (message.prompt != null && message.hasOwnProperty("prompt"))
+            if (!$util.isString(message.prompt))
+                return "prompt: string expected";
+        return null;
+    };
+
+    /**
+     * Creates a ResMessage message from a plain object. Also converts values to their respective internal types.
+     * @function fromObject
+     * @memberof ResMessage
+     * @static
+     * @param {Object.<string,*>} object Plain object
+     * @returns {ResMessage} ResMessage
+     */
+    ResMessage.fromObject = function fromObject(object) {
+        if (object instanceof $root.ResMessage)
+            return object;
+        var message = new $root.ResMessage();
+        if (object.content != null)
+            message.content = String(object.content);
+        if (object.empty != null)
+            if (typeof object.empty === "string")
+                $util.base64.decode(object.empty, message.empty = $util.newBuffer($util.base64.length(object.empty)), 0);
+            else if (object.empty.length >= 0)
+                message.empty = object.empty;
+        if (object.prompt != null)
+            message.prompt = String(object.prompt);
+        return message;
+    };
+
+    /**
+     * Creates a plain object from a ResMessage message. Also converts values to other types if specified.
+     * @function toObject
+     * @memberof ResMessage
+     * @static
+     * @param {ResMessage} message ResMessage
+     * @param {$protobuf.IConversionOptions} [options] Conversion options
+     * @returns {Object.<string,*>} Plain object
+     */
+    ResMessage.toObject = function toObject(message, options) {
+        if (!options)
+            options = {};
+        var object = {};
+        if (options.defaults) {
+            object.content = "";
+            if (options.bytes === String)
+                object.empty = "";
+            else {
+                object.empty = [];
+                if (options.bytes !== Array)
+                    object.empty = $util.newBuffer(object.empty);
+            }
+            object.prompt = "";
+        }
+        if (message.content != null && message.hasOwnProperty("content"))
+            object.content = message.content;
+        if (message.empty != null && message.hasOwnProperty("empty"))
+            object.empty = options.bytes === String ? $util.base64.encode(message.empty, 0, message.empty.length) : options.bytes === Array ? Array.prototype.slice.call(message.empty) : message.empty;
+        if (message.prompt != null && message.hasOwnProperty("prompt"))
+            object.prompt = message.prompt;
+        return object;
+    };
+
+    /**
+     * Converts this ResMessage to JSON.
+     * @function toJSON
+     * @memberof ResMessage
+     * @instance
+     * @returns {Object.<string,*>} JSON object
+     */
+    ResMessage.prototype.toJSON = function toJSON() {
+        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+    };
+
+    /**
+     * Gets the default type url for ResMessage
+     * @function getTypeUrl
+     * @memberof ResMessage
+     * @static
+     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+     * @returns {string} The default type url
+     */
+    ResMessage.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+        if (typeUrlPrefix === undefined) {
+            typeUrlPrefix = "type.googleapis.com";
+        }
+        return typeUrlPrefix + "/ResMessage";
+    };
+
+    return ResMessage;
+})();
+
+$root.AvailableModelsResponse = (function() {
+
+    /**
+     * Properties of an AvailableModelsResponse.
+     * @exports IAvailableModelsResponse
+     * @interface IAvailableModelsResponse
+     * @property {Array.<AvailableModelsResponse.IAvailableModel>|null} [models] AvailableModelsResponse models
+     * @property {Array.<string>|null} [modelNames] AvailableModelsResponse modelNames
+     */
+
+    /**
+     * Constructs a new AvailableModelsResponse.
+     * @exports AvailableModelsResponse
+     * @classdesc Represents an AvailableModelsResponse.
+     * @implements IAvailableModelsResponse
+     * @constructor
+     * @param {IAvailableModelsResponse=} [properties] Properties to set
+     */
+    function AvailableModelsResponse(properties) {
+        this.models = [];
+        this.modelNames = [];
+        if (properties)
+            for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                if (properties[keys[i]] != null)
+                    this[keys[i]] = properties[keys[i]];
+    }
+
+    /**
+     * AvailableModelsResponse models.
+     * @member {Array.<AvailableModelsResponse.IAvailableModel>} models
+     * @memberof AvailableModelsResponse
+     * @instance
+     */
+    AvailableModelsResponse.prototype.models = $util.emptyArray;
+
+    /**
+     * AvailableModelsResponse modelNames.
+     * @member {Array.<string>} modelNames
+     * @memberof AvailableModelsResponse
+     * @instance
+     */
+    AvailableModelsResponse.prototype.modelNames = $util.emptyArray;
+
+    /**
+     * Creates a new AvailableModelsResponse instance using the specified properties.
+     * @function create
+     * @memberof AvailableModelsResponse
+     * @static
+     * @param {IAvailableModelsResponse=} [properties] Properties to set
+     * @returns {AvailableModelsResponse} AvailableModelsResponse instance
+     */
+    AvailableModelsResponse.create = function create(properties) {
+        return new AvailableModelsResponse(properties);
+    };
+
+    /**
+     * Encodes the specified AvailableModelsResponse message. Does not implicitly {@link AvailableModelsResponse.verify|verify} messages.
+     * @function encode
+     * @memberof AvailableModelsResponse
+     * @static
+     * @param {IAvailableModelsResponse} message AvailableModelsResponse message or plain object to encode
+     * @param {$protobuf.Writer} [writer] Writer to encode to
+     * @returns {$protobuf.Writer} Writer
+     */
+    AvailableModelsResponse.encode = function encode(message, writer) {
+        if (!writer)
+            writer = $Writer.create();
+        if (message.modelNames != null && message.modelNames.length)
+            for (var i = 0; i < message.modelNames.length; ++i)
+                writer.uint32(/* id 1, wireType 2 =*/10).string(message.modelNames[i]);
+        if (message.models != null && message.models.length)
+            for (var i = 0; i < message.models.length; ++i)
+                $root.AvailableModelsResponse.AvailableModel.encode(message.models[i], writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
+        return writer;
+    };
+
+    /**
+     * Encodes the specified AvailableModelsResponse message, length delimited. Does not implicitly {@link AvailableModelsResponse.verify|verify} messages.
+     * @function encodeDelimited
+     * @memberof AvailableModelsResponse
+     * @static
+     * @param {IAvailableModelsResponse} message AvailableModelsResponse message or plain object to encode
+     * @param {$protobuf.Writer} [writer] Writer to encode to
+     * @returns {$protobuf.Writer} Writer
+     */
+    AvailableModelsResponse.encodeDelimited = function encodeDelimited(message, writer) {
+        return this.encode(message, writer).ldelim();
+    };
+
+    /**
+     * Decodes an AvailableModelsResponse message from the specified reader or buffer.
+     * @function decode
+     * @memberof AvailableModelsResponse
+     * @static
+     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+     * @param {number} [length] Message length if known beforehand
+     * @returns {AvailableModelsResponse} AvailableModelsResponse
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    AvailableModelsResponse.decode = function decode(reader, length) {
+        if (!(reader instanceof $Reader))
+            reader = $Reader.create(reader);
+        var end = length === undefined ? reader.len : reader.pos + length, message = new $root.AvailableModelsResponse();
+        while (reader.pos < end) {
+            var tag = reader.uint32();
+            switch (tag >>> 3) {
+            case 2: {
+                    if (!(message.models && message.models.length))
+                        message.models = [];
+                    message.models.push($root.AvailableModelsResponse.AvailableModel.decode(reader, reader.uint32()));
+                    break;
+                }
+            case 1: {
+                    if (!(message.modelNames && message.modelNames.length))
+                        message.modelNames = [];
+                    message.modelNames.push(reader.string());
+                    break;
+                }
+            default:
+                reader.skipType(tag & 7);
+                break;
+            }
+        }
+        return message;
+    };
+
+    /**
+     * Decodes an AvailableModelsResponse message from the specified reader or buffer, length delimited.
+     * @function decodeDelimited
+     * @memberof AvailableModelsResponse
+     * @static
+     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+     * @returns {AvailableModelsResponse} AvailableModelsResponse
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    AvailableModelsResponse.decodeDelimited = function decodeDelimited(reader) {
+        if (!(reader instanceof $Reader))
+            reader = new $Reader(reader);
+        return this.decode(reader, reader.uint32());
+    };
+
+    /**
+     * Verifies an AvailableModelsResponse message.
+     * @function verify
+     * @memberof AvailableModelsResponse
+     * @static
+     * @param {Object.<string,*>} message Plain object to verify
+     * @returns {string|null} `null` if valid, otherwise the reason why it is not
+     */
+    AvailableModelsResponse.verify = function verify(message) {
+        if (typeof message !== "object" || message === null)
+            return "object expected";
+        if (message.models != null && message.hasOwnProperty("models")) {
+            if (!Array.isArray(message.models))
+                return "models: array expected";
+            for (var i = 0; i < message.models.length; ++i) {
+                var error = $root.AvailableModelsResponse.AvailableModel.verify(message.models[i]);
+                if (error)
+                    return "models." + error;
+            }
+        }
+        if (message.modelNames != null && message.hasOwnProperty("modelNames")) {
+            if (!Array.isArray(message.modelNames))
+                return "modelNames: array expected";
+            for (var i = 0; i < message.modelNames.length; ++i)
+                if (!$util.isString(message.modelNames[i]))
+                    return "modelNames: string[] expected";
+        }
+        return null;
+    };
+
+    /**
+     * Creates an AvailableModelsResponse message from a plain object. Also converts values to their respective internal types.
+     * @function fromObject
+     * @memberof AvailableModelsResponse
+     * @static
+     * @param {Object.<string,*>} object Plain object
+     * @returns {AvailableModelsResponse} AvailableModelsResponse
+     */
+    AvailableModelsResponse.fromObject = function fromObject(object) {
+        if (object instanceof $root.AvailableModelsResponse)
+            return object;
+        var message = new $root.AvailableModelsResponse();
+        if (object.models) {
+            if (!Array.isArray(object.models))
+                throw TypeError(".AvailableModelsResponse.models: array expected");
+            message.models = [];
+            for (var i = 0; i < object.models.length; ++i) {
+                if (typeof object.models[i] !== "object")
+                    throw TypeError(".AvailableModelsResponse.models: object expected");
+                message.models[i] = $root.AvailableModelsResponse.AvailableModel.fromObject(object.models[i]);
+            }
+        }
+        if (object.modelNames) {
+            if (!Array.isArray(object.modelNames))
+                throw TypeError(".AvailableModelsResponse.modelNames: array expected");
+            message.modelNames = [];
+            for (var i = 0; i < object.modelNames.length; ++i)
+                message.modelNames[i] = String(object.modelNames[i]);
+        }
+        return message;
+    };
+
+    /**
+     * Creates a plain object from an AvailableModelsResponse message. Also converts values to other types if specified.
+     * @function toObject
+     * @memberof AvailableModelsResponse
+     * @static
+     * @param {AvailableModelsResponse} message AvailableModelsResponse
+     * @param {$protobuf.IConversionOptions} [options] Conversion options
+     * @returns {Object.<string,*>} Plain object
+     */
+    AvailableModelsResponse.toObject = function toObject(message, options) {
+        if (!options)
+            options = {};
+        var object = {};
+        if (options.arrays || options.defaults) {
+            object.modelNames = [];
+            object.models = [];
+        }
+        if (message.modelNames && message.modelNames.length) {
+            object.modelNames = [];
+            for (var j = 0; j < message.modelNames.length; ++j)
+                object.modelNames[j] = message.modelNames[j];
+        }
+        if (message.models && message.models.length) {
+            object.models = [];
+            for (var j = 0; j < message.models.length; ++j)
+                object.models[j] = $root.AvailableModelsResponse.AvailableModel.toObject(message.models[j], options);
+        }
+        return object;
+    };
+
+    /**
+     * Converts this AvailableModelsResponse to JSON.
+     * @function toJSON
+     * @memberof AvailableModelsResponse
+     * @instance
+     * @returns {Object.<string,*>} JSON object
+     */
+    AvailableModelsResponse.prototype.toJSON = function toJSON() {
+        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+    };
+
+    /**
+     * Gets the default type url for AvailableModelsResponse
+     * @function getTypeUrl
+     * @memberof AvailableModelsResponse
+     * @static
+     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+     * @returns {string} The default type url
+     */
+    AvailableModelsResponse.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+        if (typeUrlPrefix === undefined) {
+            typeUrlPrefix = "type.googleapis.com";
+        }
+        return typeUrlPrefix + "/AvailableModelsResponse";
+    };
+
+    AvailableModelsResponse.AvailableModel = (function() {
+
+        /**
+         * Properties of an AvailableModel.
+         * @memberof AvailableModelsResponse
+         * @interface IAvailableModel
+         * @property {string|null} [name] AvailableModel name
+         * @property {boolean|null} [defaultOn] AvailableModel defaultOn
+         * @property {boolean|null} [isLongContextOnly] AvailableModel isLongContextOnly
+         * @property {boolean|null} [isChatOnly] AvailableModel isChatOnly
+         */
+
+        /**
+         * Constructs a new AvailableModel.
+         * @memberof AvailableModelsResponse
+         * @classdesc Represents an AvailableModel.
+         * @implements IAvailableModel
+         * @constructor
+         * @param {AvailableModelsResponse.IAvailableModel=} [properties] Properties to set
+         */
+        function AvailableModel(properties) {
+            if (properties)
+                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                    if (properties[keys[i]] != null)
+                        this[keys[i]] = properties[keys[i]];
+        }
+
+        /**
+         * AvailableModel name.
+         * @member {string} name
+         * @memberof AvailableModelsResponse.AvailableModel
+         * @instance
+         */
+        AvailableModel.prototype.name = "";
+
+        /**
+         * AvailableModel defaultOn.
+         * @member {boolean} defaultOn
+         * @memberof AvailableModelsResponse.AvailableModel
+         * @instance
+         */
+        AvailableModel.prototype.defaultOn = false;
+
+        /**
+         * AvailableModel isLongContextOnly.
+         * @member {boolean|null|undefined} isLongContextOnly
+         * @memberof AvailableModelsResponse.AvailableModel
+         * @instance
+         */
+        AvailableModel.prototype.isLongContextOnly = null;
+
+        /**
+         * AvailableModel isChatOnly.
+         * @member {boolean|null|undefined} isChatOnly
+         * @memberof AvailableModelsResponse.AvailableModel
+         * @instance
+         */
+        AvailableModel.prototype.isChatOnly = null;
+
+        // OneOf field names bound to virtual getters and setters
+        var $oneOfFields;
+
+        // Virtual OneOf for proto3 optional field
+        Object.defineProperty(AvailableModel.prototype, "_isLongContextOnly", {
+            get: $util.oneOfGetter($oneOfFields = ["isLongContextOnly"]),
+            set: $util.oneOfSetter($oneOfFields)
+        });
+
+        // Virtual OneOf for proto3 optional field
+        Object.defineProperty(AvailableModel.prototype, "_isChatOnly", {
+            get: $util.oneOfGetter($oneOfFields = ["isChatOnly"]),
+            set: $util.oneOfSetter($oneOfFields)
+        });
+
+        /**
+         * Creates a new AvailableModel instance using the specified properties.
+         * @function create
+         * @memberof AvailableModelsResponse.AvailableModel
+         * @static
+         * @param {AvailableModelsResponse.IAvailableModel=} [properties] Properties to set
+         * @returns {AvailableModelsResponse.AvailableModel} AvailableModel instance
+         */
+        AvailableModel.create = function create(properties) {
+            return new AvailableModel(properties);
+        };
+
+        /**
+         * Encodes the specified AvailableModel message. Does not implicitly {@link AvailableModelsResponse.AvailableModel.verify|verify} messages.
+         * @function encode
+         * @memberof AvailableModelsResponse.AvailableModel
+         * @static
+         * @param {AvailableModelsResponse.IAvailableModel} message AvailableModel message or plain object to encode
+         * @param {$protobuf.Writer} [writer] Writer to encode to
+         * @returns {$protobuf.Writer} Writer
+         */
+        AvailableModel.encode = function encode(message, writer) {
+            if (!writer)
+                writer = $Writer.create();
+            if (message.name != null && Object.hasOwnProperty.call(message, "name"))
+                writer.uint32(/* id 1, wireType 2 =*/10).string(message.name);
+            if (message.defaultOn != null && Object.hasOwnProperty.call(message, "defaultOn"))
+                writer.uint32(/* id 2, wireType 0 =*/16).bool(message.defaultOn);
+            if (message.isLongContextOnly != null && Object.hasOwnProperty.call(message, "isLongContextOnly"))
+                writer.uint32(/* id 3, wireType 0 =*/24).bool(message.isLongContextOnly);
+            if (message.isChatOnly != null && Object.hasOwnProperty.call(message, "isChatOnly"))
+                writer.uint32(/* id 4, wireType 0 =*/32).bool(message.isChatOnly);
+            return writer;
+        };
+
+        /**
+         * Encodes the specified AvailableModel message, length delimited. Does not implicitly {@link AvailableModelsResponse.AvailableModel.verify|verify} messages.
+         * @function encodeDelimited
+         * @memberof AvailableModelsResponse.AvailableModel
+         * @static
+         * @param {AvailableModelsResponse.IAvailableModel} message AvailableModel message or plain object to encode
+         * @param {$protobuf.Writer} [writer] Writer to encode to
+         * @returns {$protobuf.Writer} Writer
+         */
+        AvailableModel.encodeDelimited = function encodeDelimited(message, writer) {
+            return this.encode(message, writer).ldelim();
+        };
+
+        /**
+         * Decodes an AvailableModel message from the specified reader or buffer.
+         * @function decode
+         * @memberof AvailableModelsResponse.AvailableModel
+         * @static
+         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+         * @param {number} [length] Message length if known beforehand
+         * @returns {AvailableModelsResponse.AvailableModel} AvailableModel
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        AvailableModel.decode = function decode(reader, length) {
+            if (!(reader instanceof $Reader))
+                reader = $Reader.create(reader);
+            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.AvailableModelsResponse.AvailableModel();
+            while (reader.pos < end) {
+                var tag = reader.uint32();
+                switch (tag >>> 3) {
+                case 1: {
+                        message.name = reader.string();
+                        break;
+                    }
+                case 2: {
+                        message.defaultOn = reader.bool();
+                        break;
+                    }
+                case 3: {
+                        message.isLongContextOnly = reader.bool();
+                        break;
+                    }
+                case 4: {
+                        message.isChatOnly = reader.bool();
+                        break;
+                    }
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+                }
+            }
+            return message;
+        };
+
+        /**
+         * Decodes an AvailableModel message from the specified reader or buffer, length delimited.
+         * @function decodeDelimited
+         * @memberof AvailableModelsResponse.AvailableModel
+         * @static
+         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+         * @returns {AvailableModelsResponse.AvailableModel} AvailableModel
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        AvailableModel.decodeDelimited = function decodeDelimited(reader) {
+            if (!(reader instanceof $Reader))
+                reader = new $Reader(reader);
+            return this.decode(reader, reader.uint32());
+        };
+
+        /**
+         * Verifies an AvailableModel message.
+         * @function verify
+         * @memberof AvailableModelsResponse.AvailableModel
+         * @static
+         * @param {Object.<string,*>} message Plain object to verify
+         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+         */
+        AvailableModel.verify = function verify(message) {
+            if (typeof message !== "object" || message === null)
+                return "object expected";
+            var properties = {};
+            if (message.name != null && message.hasOwnProperty("name"))
+                if (!$util.isString(message.name))
+                    return "name: string expected";
+            if (message.defaultOn != null && message.hasOwnProperty("defaultOn"))
+                if (typeof message.defaultOn !== "boolean")
+                    return "defaultOn: boolean expected";
+            if (message.isLongContextOnly != null && message.hasOwnProperty("isLongContextOnly")) {
+                properties._isLongContextOnly = 1;
+                if (typeof message.isLongContextOnly !== "boolean")
+                    return "isLongContextOnly: boolean expected";
+            }
+            if (message.isChatOnly != null && message.hasOwnProperty("isChatOnly")) {
+                properties._isChatOnly = 1;
+                if (typeof message.isChatOnly !== "boolean")
+                    return "isChatOnly: boolean expected";
+            }
+            return null;
+        };
+
+        /**
+         * Creates an AvailableModel message from a plain object. Also converts values to their respective internal types.
+         * @function fromObject
+         * @memberof AvailableModelsResponse.AvailableModel
+         * @static
+         * @param {Object.<string,*>} object Plain object
+         * @returns {AvailableModelsResponse.AvailableModel} AvailableModel
+         */
+        AvailableModel.fromObject = function fromObject(object) {
+            if (object instanceof $root.AvailableModelsResponse.AvailableModel)
+                return object;
+            var message = new $root.AvailableModelsResponse.AvailableModel();
+            if (object.name != null)
+                message.name = String(object.name);
+            if (object.defaultOn != null)
+                message.defaultOn = Boolean(object.defaultOn);
+            if (object.isLongContextOnly != null)
+                message.isLongContextOnly = Boolean(object.isLongContextOnly);
+            if (object.isChatOnly != null)
+                message.isChatOnly = Boolean(object.isChatOnly);
+            return message;
+        };
+
+        /**
+         * Creates a plain object from an AvailableModel message. Also converts values to other types if specified.
+         * @function toObject
+         * @memberof AvailableModelsResponse.AvailableModel
+         * @static
+         * @param {AvailableModelsResponse.AvailableModel} message AvailableModel
+         * @param {$protobuf.IConversionOptions} [options] Conversion options
+         * @returns {Object.<string,*>} Plain object
+         */
+        AvailableModel.toObject = function toObject(message, options) {
+            if (!options)
+                options = {};
+            var object = {};
+            if (options.defaults) {
+                object.name = "";
+                object.defaultOn = false;
+            }
+            if (message.name != null && message.hasOwnProperty("name"))
+                object.name = message.name;
+            if (message.defaultOn != null && message.hasOwnProperty("defaultOn"))
+                object.defaultOn = message.defaultOn;
+            if (message.isLongContextOnly != null && message.hasOwnProperty("isLongContextOnly")) {
+                object.isLongContextOnly = message.isLongContextOnly;
+                if (options.oneofs)
+                    object._isLongContextOnly = "isLongContextOnly";
+            }
+            if (message.isChatOnly != null && message.hasOwnProperty("isChatOnly")) {
+                object.isChatOnly = message.isChatOnly;
+                if (options.oneofs)
+                    object._isChatOnly = "isChatOnly";
+            }
+            return object;
+        };
+
+        /**
+         * Converts this AvailableModel to JSON.
+         * @function toJSON
+         * @memberof AvailableModelsResponse.AvailableModel
+         * @instance
+         * @returns {Object.<string,*>} JSON object
+         */
+        AvailableModel.prototype.toJSON = function toJSON() {
+            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+        };
+
+        /**
+         * Gets the default type url for AvailableModel
+         * @function getTypeUrl
+         * @memberof AvailableModelsResponse.AvailableModel
+         * @static
+         * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+         * @returns {string} The default type url
+         */
+        AvailableModel.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+            if (typeUrlPrefix === undefined) {
+                typeUrlPrefix = "type.googleapis.com";
+            }
+            return typeUrlPrefix + "/AvailableModelsResponse.AvailableModel";
+        };
+
+        return AvailableModel;
+    })();
+
+    return AvailableModelsResponse;
+})();
+
+module.exports = $root;

src/proto/message.proto

@@ -0,0 +1,44 @@
+syntax = "proto3";
+
+message ChatMessage {
+  message UserMessage {
+    string content = 1;
+    int32 role = 2;
+    string messageId = 13;
+  }
+
+  message Instructions {
+    string instruction = 1;
+  }
+
+  message Model {
+    string name = 1;
+    bytes empty = 4;
+  }
+
+  repeated UserMessage userMessages = 2;
+  Instructions instructions = 4;
+  Model model = 7;
+  int32 unknown13 = 13;
+  string conversationId = 15;
+  int32 unknown16 = 16;
+  int32 unknown29 = 29;
+  int32 unknown31 = 31;
+}
+
+message ResMessage {
+  string content = 1;
+  bytes empty = 4;
+  string prompt = 5;
+}
+
+message AvailableModelsResponse { 
+		message AvailableModel {
+			string name = 1;
+			bool default_on = 2;
+			optional bool is_long_context_only = 3;
+			optional bool is_chat_only = 4;
+		}
+	repeated AvailableModel models = 2;
+	repeated string model_names = 1;
+}

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,931 @@
+const express = require('express');
+const router = express.Router();
+
+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');
+
+// 存储刷新状态的变量
+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 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-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"
+
+    // 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 response = await fetch('https://api2.cursor.sh/aiserver.v1.AiService/StreamChat', {
+      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-timezone': 'Asia/Shanghai',
+        'x-ghost-mode': 'true',
+        'x-request-id': uuidv4(),
+        'x-session-id': sessionid,
+        'Host': 'api2.cursor.sh',
+      },
+      body: cursorBody,
+      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,750 @@
+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 {
+      // 使用新的提取模块
+      const cookies = await extractCookiesFromCsv(csvFilePath);
+      
+      if (cookies && cookies.length > 0) {
+        console.log(`成功从CSV文件提取到 ${cookies.length} 个cookies`);
+        return cookies;
+      } else {
+        console.warn(`未能从CSV文件提取到cookies (尝试 ${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 => {
+      // 检查cookie是否包含JWT的三个部分
+      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 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`,
+      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,171 @@
+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([]);
+      }
+
+      // 检查文件内容是否包含关键字
+      const hasTokenKeyword = fileContent.includes('token');
+      const hasUserPrefix = fileContent.includes('user_');
+      console.log(`文件包含"token"关键字: ${hasTokenKeyword}`);
+      console.log(`文件包含"user_"前缀: ${hasUserPrefix}`);
+
+      // 如果文件包含user_前缀，尝试直接从内容中提取cookie
+      if (hasUserPrefix) {
+        const cookies = extractCookiesFromText(fileContent);
+        if (cookies.length > 0) {
+          console.log(`直接从文件内容中提取到 ${cookies.length} 个Cookie`);
+          return resolve(cookies);
+        }
+      }
+
+      // 使用csv-parser解析CSV文件
+      const cookies = [];
+      const possibleTokenFields = ['token', 'cookie', 'value', 'Token', 'Cookie', 'Value'];
+      
+      fs.createReadStream(csvFilePath)
+        .pipe(csv())
+        .on('data', (row) => {
+          // 检查所有可能的字段名
+          for (const field of possibleTokenFields) {
+            if (row[field] && row[field].includes('user_')) {
+              cookies.push(row[field]);
+              break;
+            }
+          }
+          
+          // 如果没有找到预定义的字段，遍历所有字段
+          if (cookies.length === 0) {
+            for (const field in row) {
+              if (row[field] && typeof row[field] === 'string' && row[field].includes('user_')) {
+                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) {
+              if (line.includes('user_')) {
+                const extractedCookies = extractCookiesFromText(line);
+                extractedCookies.forEach(cookie => {
+                  if (!cookies.includes(cookie)) {
+                    cookies.push(cookie);
+                  }
+                });
+              }
+            }
+            console.log(`按行读取后提取到 ${cookies.length} 个Cookie`);
+          }
+          
+          // 如果仍然没有找到cookie，尝试从整个文件内容中提取
+          if (cookies.length === 0) {
+            console.log('尝试从整个文件内容中提取Cookie...');
+            const extractedCookies = extractCookiesFromText(fileContent);
+            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);
+          // 如果解析出错，尝试从整个文件内容中提取
+          const extractedCookies = extractCookiesFromText(fileContent);
+          console.log(`解析出错后从文件内容中提取到 ${extractedCookies.length} 个Cookie`);
+          resolve(validateCookies(extractedCookies));
+        });
+    } catch (error) {
+      console.error('提取Cookie时出错:', error);
+      reject(error);
+    }
+  });
+}
+
+/**
+ * 从文本中提取cookie
+ * @param {string} text - 要提取cookie的文本
+ * @returns {string[]} - 提取到的cookie数组
+ */
+function extractCookiesFromText(text) {
+  const cookies = [];
+  
+  // 使用正则表达式匹配user_开头的cookie
+  const regex = /user_[a-zA-Z0-9%]+%3A%3A[a-zA-Z0-9%\.\_\-]+/g;
+  const matches = text.match(regex);
+  
+  if (matches) {
+    matches.forEach(match => {
+      if (!cookies.includes(match)) {
+        cookies.push(match);
+      }
+    });
+  }
+  
+  return cookies;
+}
+
+/**
+ * 验证cookie是否完整
+ * @param {string[]} cookies - 要验证的cookie数组
+ * @returns {string[]} - 验证后的cookie数组
+ */
+function validateCookies(cookies) {
+  return cookies.map(cookie => {
+    // 检查cookie是否包含JWT的三个部分（header.payload.signature）
+    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 cookie; // cookie完整
+        } else {
+          console.warn(`检测到不完整的JWT: ${cookie}`);
+          // 尝试修复不完整的JWT（如果可能）
+          return cookie;
+        }
+      }
+    }
+    return cookie;
+  });
+}
+
+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,200 @@
+const os = require('os');
+const zlib = require('zlib');
+const crypto = require('crypto');
+const { v4: uuidv4 } = require('uuid');
+const $root = require('../proto/message.js');
+
+const regex = /<\|BEGIN_SYSTEM\|>.*?<\|END_SYSTEM\|>.*?<\|BEGIN_USER\|>.*?<\|END_USER\|>/s;
+
+function generateCursorBody(messages, modelName) {
+
+  const systemMessages = messages
+    .filter((msg) => msg.role === 'system');
+  const instruction = systemMessages.map((msg) => msg.content).join('\n')
+
+  const nonSystemMessages = messages
+    .filter((msg) => msg.role !== 'system');
+  const formattedMessages = nonSystemMessages.map((msg) => ({
+    ...msg,
+    role: msg.role === 'user' ? 1 : 2,
+    messageId: uuidv4()
+  }));
+
+  const chatBody = {
+    userMessages: formattedMessages,
+    instructions: {
+      instruction: "Alway respond in 中文.\n" + instruction
+    },
+    model: {
+      name: modelName,
+      empty: '',
+    },
+    unknown13: 1,
+    conversationId: uuidv4(),
+    unknown16: 1,
+    unknown29: 1,
+    unknown31: 0,
+  };
+
+  const errMsg = $root.ChatMessage.verify(chatBody);
+  if (errMsg) throw Error(errMsg);
+  const chatMessageInstance = $root.ChatMessage.create(chatBody);
+  let buffer = $root.ChatMessage.encode(chatMessageInstance).finish();
+  let magicNumber = 0x00
+  if (formattedMessages.length >= 5){
+    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: '' }
+  
+  try {
+    if (!chunk || chunk.length === 0) {
+      console.error('收到空的chunk数据');
+      return '';
+    }
+    
+    const buffer = Buffer.from(chunk, 'hex');
+
+    for(let i = 0; i < buffer.length; i++){
+      try {
+        if (i + 5 >= buffer.length) {
+          console.error('数据不足以读取魔数和长度');
+          break;
+        }
+        
+        const magicNumber = parseInt(buffer.subarray(i, i + 1).toString('hex'), 16)
+        const dataLength = parseInt(buffer.subarray(i + 1, i + 5).toString('hex'), 16)
+        
+        if (dataLength <= 0 || dataLength > 1000000) {
+          console.error(`数据长度异常: ${dataLength}`);
+          break;
+        }
+        
+        if (i + 5 + dataLength > buffer.length) {
+          console.error('数据不足以读取内容');
+          break;
+        }
+        
+        const data = buffer.subarray(i + 5, i + 5 + dataLength)
+
+        // 处理不同类型的消息
+        const processMessage = async (data, isGzip = false) => {
+          try {
+            let processedData = data;
+            if (isGzip) {
+              processedData = zlib.gunzipSync(data);
+            }
+
+            if (magicNumber === 0 || magicNumber === 1) {
+              // 处理 Proto 消息
+              const resMessage = $root.ResMessage.decode(processedData);
+              if (resMessage.content !== undefined) {
+                results.push(resMessage.content);
+              }
+            } else if (magicNumber === 2 || magicNumber === 3) {
+              // 处理 JSON 消息
+              const utf8 = processedData.toString('utf-8');
+              const message = JSON.parse(utf8);
+              
+              if (message && message.error) {
+                console.error(`检测到JSON错误对象(${isGzip ? 'Gzip ' : ''}):`, utf8);
+                errorResults.hasError = true;
+                errorResults.errorMessage = utf8;
+              }
+            } else {
+              console.log('未知的魔数:', magicNumber);
+            }
+          } catch (error) {
+            console.error(`处理${isGzip ? 'Gzip ' : ''}消息错误:`, error);
+          }
+        };
+
+        // 根据魔数处理不同类型的消息
+        if (magicNumber === 0 || magicNumber === 2) {
+          processMessage(data, false);
+        } else if (magicNumber === 1 || magicNumber === 3) {
+          processMessage(data, true);
+        }
+
+        i += 5 + dataLength - 1;
+      } catch (chunkParseError) {
+        console.error('解析单个chunk部分错误:', chunkParseError);
+        i += 1;
+      }
+    }
+  } catch (err) {
+    console.error('解析chunk整体错误:', err);
+  }
+
+  if (errorResults.hasError) {
+    return { error: errorResults.errorMessage };
+  }
+
+  return results.join('');
+}
+
+function generateUUIDHash(input, salt = '') {
+  const hash = crypto.createHash('sha256').update(input + salt).digest('hex');
+  const hash128 = hash.substring(0, 32);
+  const uuid = `${hash128.substring(0, 8)}-${hash128.substring(8, 12)}-${hash128.substring(12, 16)}-${hash128.substring(16, 20)}-${hash128.substring(20, 32)}`;
+
+  return uuid;
+}
+
+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) {
+  // 生成machineId和macMachineId
+  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,
+  ]);
+
+  // 混淆字节数组并进行base64编码
+  const obfuscatedBytes = obfuscateBytes(byteArray);
+  const encodedChecksum = Buffer.from(obfuscatedBytes).toString('base64');
+
+  // 组合最终的checksum
+  return `${encodedChecksum}${machineId}/${macMachineId}`;
+}
+
+module.exports = {
+  generateCursorBody,
+  chunkToUtf8String,
+  generateHashed64Hex,
+  generateCursorChecksum
+};