Create app.js

app.js

@@ -0,0 +1,265 @@
+// app.js
+const express = require('express');
+const { v4: uuidv4 } = require('uuid');
+require('dotenv').config();
+
+const app = express();
+
+// 中间件配置
+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;
+
+  // Calculate lengths and fields similar to Python version
+  const FIXED_HEADER = 2;
+  const SEPARATOR = 1;
+  const FIXED_SUFFIX_LENGTH = 0xA3 + modelName.length;
+
+  // 计算文本长度字段 (类似 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;
+  }
+
+  // 计算基础长度 (类似 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;
+  }
+
+  // 计算总消息长度
+  const messageTotalLength = FIXED_HEADER + textLengthFieldSize + SEPARATOR +
+        textLengthFieldSize1 + byteLength + FIXED_SUFFIX_LENGTH;
+
+  const messageLengthHex = messageTotalLength.toString(16).padStart(10, '0');
+
+  // 构造完整的十六进制字符串
+  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');
+}
+
+// 封装函数，用于将 chunk 转换为 UTF-8 字符串
+function chunkToUtf8String(chunk) {
+  // 只处理以 0x00 0x00 0x00 0x00 开头的 chunk，其他不处理，不然会有乱码
+  if (!(chunk[0] === 0x00 && chunk[1] === 0x00)) {
+    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);
+
+  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;
+    }
+
+    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++;
+    }
+  }
+
+  // 第二步：去除所有的 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) => {
+  // o1开头的模型，不支持流式输出
+  if (req.body.model.startsWith('o1-') && req.body.stream) {
+    return res.status(400).json({
+      error: 'Model not supported stream'
+    });
+  }
+
+  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) {
+      return res.status(400).json({
+        error: 'Invalid request. Messages should be a non-empty array and authorization is required'
+      });
+    }
+
+    const formattedMessages = messages.map(msg => `${msg.role}:${msg.content}`).join('\n');
+    const hexData = stringToHex(formattedMessages, model);
+
+    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
+    });
+
+    if (stream) {
+      res.setHeader('Content-Type', 'text/event-stream');
+      res.setHeader('Cache-Control', 'no-cache');
+      res.setHeader('Connection', 'keep-alive');
+
+      const responseId = `chatcmpl-${uuidv4()}`;
+
+      // 使用封装的函数处理 chunk
+      for await (const chunk of response.body) {
+        const text = 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 += chunkToUtf8String(chunk);
+      }
+      // 对解析后的字符串进行进一步处理
+      text = text.replace(/^.*<\|END_USER\|>/s, '');
+      text = text.replace(/^\n[a-zA-Z]?/, '').trim();
+      console.log(text);
+
+      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' });
+      }
+    }
+  }
+});
+
+// 启动服务器
+const PORT = process.env.PORT || 3000;
+app.listen(PORT, () => {
+  console.log(`服务器运行在端口 ${PORT}`);
+});