Update app.js

app.js

@@ -1,274 +1,332 @@
-// app.js
 const express = require('express');
 const { v4: uuidv4 } = require('uuid');
-require('dotenv').config();
+const zlib = require('zlib');
+const $protobuf = require('protobufjs/minimal');
 
-const app = express();
+// 初始化 protobuf
+const $Reader = $protobuf.Reader;
+const $Writer = $protobuf.Writer;
+const $util = $protobuf.util;
+const $root = $protobuf.roots['default'] || ($protobuf.roots['default'] = {});
 
-// 中间件配置
-app.use(express.json());
-app.use(express.urlencoded({ extended: true }));
-
-// Helper function to convert string to hex bytes
-function stringToHex(str, modelName) {
-  const bytes = Buffer.from(str, 'utf-8');
-  const byteLength = bytes.length;
+// Proto 消息定义
+const ChatMessageDefinition = {
+    ChatMessage: {
+        nested: {
+            FileContent: {
+                fields: {
+                    filename: { type: "string", id: 1 },
+                    content: { type: "string", id: 2 },
+                    position: { type: "Position", id: 3 },
+                    language: { type: "string", id: 5 },
+                    range: { type: "Range", id: 6 },
+                    length: { type: "int32", id: 8 },
+                    type: { type: "int32", id: 9 },
+                    error_code: { type: "int32", id: 11 }
+                },
+                nested: {
+                    Position: {
+                        fields: {
+                            line: { type: "int32", id: 1 },
+                            column: { type: "int32", id: 2 }
+                        }
+                    },
+                    Range: {
+                        fields: {
+                            start: { type: "Position", id: 1 },
+                            end: { type: "Position", id: 2 }
+                        }
+                    }
+                }
+            },
+            UserMessage: {
+                fields: {
+                    content: { type: "string", id: 1 },
+                    role: { type: "int32", id: 2 },
+                    message_id: { type: "string", id: 13 }
+                }
+            },
+            Instructions: {
+                fields: {
+                    instruction: { type: "string", id: 1 }
+                }
+            },
+            Model: {
+                fields: {
+                    name: { type: "string", id: 1 },
+                    empty: { type: "string", id: 4 }
+                }
+            }
+        },
+        fields: {
+            messages: { rule: "repeated", type: "UserMessage", id: 2 },
+            instructions: { type: "Instructions", id: 4 },
+            projectPath: { type: "string", id: 5 },
+            model: { type: "Model", id: 7 },
+            requestId: { type: "string", id: 9 },
+            summary: { type: "string", id: 11 },
+            conversationId: { type: "string", id: 15 }
+        }
+    },
+    ResMessage: {
+        fields: {
+            msg: { type: "string", id: 1 }
+        }
+    }
+};
 
-  // Calculate lengths and fields similar to Python version
-  const FIXED_HEADER = 2;
-  const SEPARATOR = 1;
-  const FIXED_SUFFIX_LENGTH = 0xA3 + modelName.length;
+// 创建消息类型
+$root.ChatMessage = $protobuf.Root.fromJSON(ChatMessageDefinition).lookupType("ChatMessage");
+$root.ResMessage = $protobuf.Root.fromJSON(ChatMessageDefinition).lookupType("ResMessage");
 
-  // 计算文本长度字段 (类似 Python 中的 base_length1)
-  let textLengthField1, textLengthFieldSize1;
-  if (byteLength < 128) {
-    textLengthField1 = byteLength.toString(16).padStart(2, '0');
-    textLengthFieldSize1 = 1;
-  } else {
-    const lowByte1 = (byteLength & 0x7F) | 0x80;
-    const highByte1 = (byteLength >> 7) & 0xFF;
-    textLengthField1 = lowByte1.toString(16).padStart(2, '0') + highByte1.toString(16).padStart(2, '0');
-    textLengthFieldSize1 = 2;
-  }
+// 工具函数
+const regex = /<\|BEGIN_SYSTEM\|>.*?<\|END_SYSTEM\|>.*?<\|BEGIN_USER\|>.*?<\|END_USER\|>/s;
 
-  // 计算基础长度 (类似 Python 中的 base_length)
-  const baseLength = byteLength + 0x2A;
-  let textLengthField, textLengthFieldSize;
-  if (baseLength < 128) {
-    textLengthField = baseLength.toString(16).padStart(2, '0');
-    textLengthFieldSize = 1;
-  } else {
-    const lowByte = (baseLength & 0x7F) | 0x80;
-    const highByte = (baseLength >> 7) & 0xFF;
-    textLengthField = lowByte.toString(16).padStart(2, '0') + highByte.toString(16).padStart(2, '0');
-    textLengthFieldSize = 2;
-  }
+async function stringToHex(messages, modelName) {
+    const formattedMessages = messages.map((msg) => ({
+        ...msg,
+        role: msg.role === 'user' ? 1 : 2,
+        message_id: uuidv4(),
+    }));
 
-  // 计算总消息长度
-  const messageTotalLength = FIXED_HEADER + textLengthFieldSize + SEPARATOR +
-        textLengthFieldSize1 + byteLength + FIXED_SUFFIX_LENGTH;
+    const message = {
+        messages: formattedMessages,
+        instructions: {
+            instruction: 'Always respond in 中文',
+        },
+        projectPath: '/path/to/project',
+        model: {
+            name: modelName,
+            empty: '',
+        },
+        requestId: uuidv4(),
+        summary: '',
+        conversationId: uuidv4(),
+    };
 
-  const messageLengthHex = messageTotalLength.toString(16).padStart(10, '0');
+    const errMsg = $root.ChatMessage.verify(message);
+    if (errMsg) throw Error(errMsg);
 
-  // 构造完整的十六进制字符串
-  const hexString = (
-    messageLengthHex +
-        '12' +
-        textLengthField +
-        '0A' +
-        textLengthField1 +
-        bytes.toString('hex') +
-        '10016A2432343163636435662D393162612D343131382D393239612D3936626330313631626432612' +
-        '2002A132F643A2F6964656150726F2F656475626F73733A1E0A' +
-        // 将模型名称长度转换为两位十六进制，并确保是大写
-        Buffer.from(modelName, 'utf-8').length.toString(16).padStart(2, '0').toUpperCase() +
-        Buffer.from(modelName, 'utf-8').toString('hex').toUpperCase() +
-        '22004A' +
-        '24' + '61383761396133342D323164642D343863372D623434662D616636633365636536663765' +
-        '680070007A2436393337376535612D386332642D343835342D623564392D653062623232336163303061' +
-        '800101B00100C00100E00100E80100'
-  ).toUpperCase();
-  return Buffer.from(hexString, 'hex');
+    const messageInstance = $root.ChatMessage.create(message);
+    const buffer = $root.ChatMessage.encode(messageInstance).finish();
+    const hexString = (buffer.length.toString(16).padStart(10, '0') + 
+                      buffer.toString('hex')).toUpperCase();
+    return Buffer.from(hexString, 'hex');
 }
 
-// 封装函数，用于将 chunk 转换为 UTF-8 字符串
-function chunkToUtf8String(chunk) {
-  // 只处理以 0x00 0x00 0x00 0x00 开头的 chunk，其他不处理，不然会有乱码
-  if (!(chunk[0] === 0x00 && chunk[1] === 0x00)) {
-    console.log('Chunk does not start with 0x00 0x00, skipping.');
-    return '';
-  }
-
-  console.log('chunk:', Buffer.from(chunk).toString('hex'));
-  console.log('chunk string:', Buffer.from(chunk).toString('utf-8'));
-
-  // 去掉 chunk 中 0x0A 以及之前的字符
-  chunk = chunk.slice(chunk.indexOf(0x0A) + 1);
+async function chunkToUtf8String(chunk) {
+    try {
+        let hex = Buffer.from(chunk).toString('hex');
+        let offset = 0;
+        let results = [];
 
-  let filteredChunk = [];
-  let i = 0;
-  while (i < chunk.length) {
-    // 新的条件过滤：如果遇到连续4个0x00，则移除其之后所有的以 0 开头的字节（0x00 到 0x0F）
-    if (chunk.slice(i, i + 4).every(byte => byte === 0x00)) {
-      i += 4; // 跳过这4个0x00
-      while (i < chunk.length && chunk[i] >= 0x00 && chunk[i] <= 0x0F) {
-        i++; // 跳过所有以 0 开头的字节
-      }
-      continue;
-    }
+        while (offset < hex.length) {
+            if (offset + 10 > hex.length) break;
+            const dataLength = parseInt(hex.slice(offset, offset + 10), 16);
+            offset += 10;
+            
+            if (offset + dataLength * 2 > hex.length) break;
+            const messageHex = hex.slice(offset, offset + dataLength * 2);
+            offset += dataLength * 2;
+            
+            const messageBuffer = Buffer.from(messageHex, 'hex');
+            const message = $root.ResMessage.decode(messageBuffer);
+            results.push(message.msg);
+        }
 
-    if (chunk[i] === 0x0C) {
-      // 遇到 0x0C 时，跳过 0x0C 以及后续的所有连续的 0x0A
-      i++; // 跳过 0x0C
-      while (i < chunk.length && chunk[i] === 0x0A) {
-        i++; // 跳过所有连续的 0x0A
-      }
-    } else if (
-      i > 0 &&
-      chunk[i] === 0x0A &&
-      chunk[i - 1] >= 0x00 &&
-      chunk[i - 1] <= 0x09
-    ) {
-      // 如果当前字节是 0x0A，且前一个字节在 0x00 至 0x09 之间，跳过前一个字节和当前字节
-      filteredChunk.pop(); // 移除已添加的前一个字节
-      i++; // 跳过当前的 0x0A
-    } else {
-      filteredChunk.push(chunk[i]);
-      i++;
+        if (results.length == 0) {
+            return gunzip(chunk);
+        }
+        return results.join('');
+    } catch (err) {
+        return gunzip(chunk);
     }
-  }
-
-  // 第二步：去除所有的 0x00 和 0x0C
-  filteredChunk = filteredChunk.filter((byte) => byte !== 0x00 && byte !== 0x0C);
-
-  // 去除小于 0x0A 的字节
-  filteredChunk = filteredChunk.filter((byte) => byte >= 0x0A);
-
-  const hexString = Buffer.from(filteredChunk).toString('hex');
-  console.log('hexString:', hexString);
-  const utf8String = Buffer.from(filteredChunk).toString('utf-8');
-  console.log('utf8String:', utf8String);
-  return utf8String;
 }
 
-app.post('/ai/v1/chat/completions', async (req, res) => {
-  console.log('Received request:', req.body);
-
-  // o1开头的模型，不支持流式输出
-  if (req.body.model.startsWith('o1-') && req.body.stream) {
-    console.log('Model not supported stream:', req.body.model);
-    return res.status(400).json({
-      error: 'Model not supported stream'
+function gunzip(chunk) {
+    return new Promise((resolve, reject) => {
+        zlib.gunzip(chunk.slice(5), (err, decompressed) => {
+            if (err) {
+                resolve('');
+            } else {
+                const text = decompressed.toString('utf-8');
+                if (regex.test(text)) {
+                    resolve('');
+                } else {
+                    resolve(text);
+                }
+            }
+        });
     });
-  }
+}
 
-  let currentKeyIndex = 0;
-  try {
-    const { model, messages, stream = false } = req.body;
-    let authToken = req.headers.authorization?.replace('Bearer ', '');
-    // 处理逗号分隔的密钥
-    const keys = authToken.split(',').map(key => key.trim());
-    if (keys.length > 0) {
-      // 确保 currentKeyIndex 不会越界
-      if (currentKeyIndex >= keys.length) {
-        currentKeyIndex = 0;
-      }
-      // 使用当前索引获取密钥
-      authToken = keys[currentKeyIndex];
-      // 更新索引
-      currentKeyIndex = (currentKeyIndex + 1);
-    }
-    if (authToken && authToken.includes('%3A%3A')) {
-      authToken = authToken.split('%3A%3A')[1];
-    }
-    if (!messages || !Array.isArray(messages) || messages.length === 0 || !authToken) {
-      console.log('Invalid request:', { messages, authToken });
-      return res.status(400).json({
-        error: 'Invalid request. Messages should be a non-empty array and authorization is required'
-      });
+function getRandomIDPro({ size, dictType, customDict }) {
+    let random = '';
+    if (!customDict) {
+        switch (dictType) {
+            case 'alphabet':
+                customDict = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+                break;
+            case 'max':
+                customDict = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-';
+                break;
+            default:
+                customDict = '0123456789';
+        }
     }
+    for (; size--; ) random += customDict[(Math.random() * customDict.length) | 0];
+    return random;
+}
 
-    const formattedMessages = messages.map(msg => `${msg.role}:${msg.content}`).join('\n');
-    const hexData = stringToHex(formattedMessages, model);
+// Express 应用设置
+const app = express();
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
 
-    console.log('Sending request to external API with token:', authToken);
-    const response = await fetch('https://api2.cursor.sh/aiserver.v1.AiService/StreamChat', {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/connect+proto',
-        authorization: `Bearer ${authToken}`,
-        'connect-accept-encoding': 'gzip,br',
-        'connect-protocol-version': '1',
-        'user-agent': 'connect-es/1.4.0',
-        'x-amzn-trace-id': `Root=${uuidv4()}`,
-        'x-cursor-checksum': 'zo6Qjequ9b9734d1f13c3438ba25ea31ac93d9287248b9d30434934e9fcbfa6b3b22029e/7e4af391f67188693b722eff0090e8e6608bca8fa320ef20a0ccb5d7d62dfdef',
-        'x-cursor-client-version': '0.42.3',
-        'x-cursor-timezone': 'Asia/Shanghai',
-        'x-ghost-mode': 'false',
-        'x-request-id': uuidv4(),
-        Host: 'api2.cursor.sh'
-      },
-      body: hexData
-    });
+// 主要路由处理
+app.post('/ai/v1/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',
+        });
+    }
 
-    console.log('Received response from external API:', response.status, response.statusText);
+    let currentKeyIndex = 0;
 
-    if (stream) {
-      res.setHeader('Content-Type', 'text/event-stream');
-      res.setHeader('Cache-Control', 'no-cache');
-      res.setHeader('Connection', 'keep-alive');
+    try {
+        const { model, messages, stream = false } = req.body;
+        let authToken = req.headers.authorization?.replace('Bearer ', '');
 
-      const responseId = `chatcmpl-${uuidv4()}`;
+        // 处理认证token
+        const keys = authToken.split(',').map((key) => key.trim());
+        if (keys.length > 0) {
+            if (currentKeyIndex >= keys.length) {
+                currentKeyIndex = 0;
+            }
+            authToken = keys[currentKeyIndex];
+        }
 
-      // 使用封装的函数处理 chunk
-      for await (const chunk of response.body) {
-        const text = chunkToUtf8String(chunk);
+        if (authToken && authToken.includes('%3A%3A')) {
+            authToken = authToken.split('%3A%3A')[1];
+        }
 
-        if (text.length > 0) {
-          console.log('Sending chunk:', text);
-          res.write(`data: ${JSON.stringify({
-                        id: responseId,
-                        object: 'chat.completion.chunk',
-                        created: Math.floor(Date.now() / 1000),
-                        model,
-                        choices: [{
-                            index: 0,
-                            delta: {
-                                content: text
-                            }
-                        }]
-                    })}\n\n`);
+        // 验证请求
+        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',
+            });
         }
-      }
 
-      res.write('data: [DONE]\n\n');
-      return res.end();
-    } else {
-      let text = '';
-      // 在非流模式下也使用封装的函数
-      for await (const chunk of response.body) {
-        text += chunkToUtf8String(chunk);
-      }
-      // 对解析后的字符串进行进一步处理
-      text = text.replace(/^.*<\|END_USER\|>/s, '');
-      text = text.replace(/^\n[a-zA-Z]?/, '').trim();
-      console.log('Final text:', text);
+        const hexData = await stringToHex(messages, model);
+        
+        // 获取checksum
+        const checksum =
+            req.headers['x-cursor-checksum'] ??
+            process.env['x-cursor-checksum'] ??
+            `zo${getRandomIDPro({ dictType: 'max', size: 6 })}${getRandomIDPro({ dictType: 'max', size: 64 })}/${getRandomIDPro({ dictType: 'max', size: 64 })}`;
+
+        // API请求配置
+        const response = await fetch('https://api2.cursor.sh/aiserver.v1.AiService/StreamChat', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/connect+proto',
+                'authorization': `Bearer ${authToken}`,
+                'connect-accept-encoding': 'gzip,br',
+                'connect-protocol-version': '1',
+                'user-agent': 'connect-es/1.4.0',
+                'x-amzn-trace-id': `Root=${uuidv4()}`,
+                'x-cursor-checksum': checksum,
+                'x-cursor-client-version': '0.42.3',
+                'x-cursor-timezone': 'Asia/Shanghai',
+                'x-ghost-mode': 'false',
+                'x-request-id': uuidv4(),
+                'host': 'api2.cursor.sh',
+            },
+            body: hexData,
+        });
 
-      return 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
+        // 处理流式响应
+        if (stream) {
+            res.setHeader('Content-Type', 'text/event-stream');
+            res.setHeader('Cache-Control', 'no-cache');
+            res.setHeader('Connection', 'keep-alive');
+            
+            const responseId = `chatcmpl-${uuidv4()}`;
+            
+            for await (const chunk of response.body) {
+                const text = await chunkToUtf8String(chunk);
+                if (text.length > 0) {
+                    res.write(
+                        `data: ${JSON.stringify({
+                            id: responseId,
+                            object: 'chat.completion.chunk',
+                            created: Math.floor(Date.now() / 1000),
+                            model,
+                            choices: [
+                                {
+                                    index: 0,
+                                    delta: {
+                                        content: text,
+                                    },
+                                },
+                            ],
+                        })}\n\n`,
+                    );
+                }
+            }
+            
+            res.write('data: [DONE]\n\n');
+            return res.end();
+        } else {
+            // 处理非流式响应
+            let text = '';
+            for await (const chunk of response.body) {
+                text += await chunkToUtf8String(chunk);
+            }
+            
+            text = text.replace(/^.*<\|END_USER\|>/s, '');
+            text = text.replace(/^\n[a-zA-Z]?/, '').trim();
+            
+            return 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('Error:', error);
+        if (!res.headersSent) {
+            if (req.body.stream) {
+                res.write(`data: ${JSON.stringify({ error: 'Internal server error' })}\n\n`);
+                return res.end();
+            } else {
+                return res.status(500).json({ error: 'Internal server error' });
+            }
         }
-      });
-    }
-  } catch (error) {
-    console.error('Error:', error);
-    if (!res.headersSent) {
-      if (req.body.stream) {
-        res.write(`data: ${JSON.stringify({ error: 'Internal server error' })}\n\n`);
-        return res.end();
-      } else {
-        return res.status(500).json({ error: 'Internal server error' });
-      }
     }
-  }
 });
 
 // 启动服务器
 const PORT = process.env.PORT || 3000;
 app.listen(PORT, () => {
-  console.log(`服务器运行在端口 ${PORT}`);
-});
+    console.log(`服务器运行在端口 ${PORT}`);
+});
+
+module.exports = app;