Upload 4 files

Dockerfile

@@ -1,13 +1,32 @@
-FROM node:lts-alpine
-
-WORKDIR /app
-
-COPY package*.json ./
-
-RUN npm install
-
-COPY . .
-ENV PORT=7860
-EXPOSE 7860
-
-CMD ["npm", "start"]
+FROM node:18-slim
+
+# 安装 Chrome 依赖
+RUN apt-get update && apt-get install -y \
+    wget \
+    gnupg \
+    ca-certificates \
+    procps \
+    chromium \
+    chromium-sandbox
+
+# 设置工作目录
+WORKDIR /app
+
+# 复制 package.json 和 package-lock.json
+COPY package*.json ./
+
+# 安装依赖
+RUN npm install
+
+# 复制源代码
+COPY . .
+
+# 设置环境变量
+ENV CHROME_PATH=/usr/bin/chromium
+ENV PORT=7860
+
+# 暴露端口
+EXPOSE 7860
+
+# 启动应用
+CMD ["npm", "start"] 

index.js

@@ -1,527 +1,848 @@
 import express from 'express';
-import FormData from 'form-data';
-import { v4 as uuidv4 } from 'uuid';
 import fetch from 'node-fetch';
+import FormData from 'form-data';
+import dotenv from 'dotenv';
 import cors from 'cors';
+import puppeteer from 'puppeteer-extra'
+import StealthPlugin from 'puppeteer-extra-plugin-stealth'
+import { v4 as uuidv4 } from 'uuid';
 import Logger from './logger.js';
-import dotenv from 'dotenv';
 
-// 初始化环境变量
 dotenv.config();
 
-// 配置管理
+// 配置常量
 const CONFIG = {
-    SERVER: {
-        PORT: process.env.PORT || 25526,
-        BODY_LIMIT: '5mb',
-        CORS_OPTIONS: {
-            origin: '*',
-            methods: ['GET', 'POST', 'OPTIONS'],
-            allowedHeaders: ['Content-Type', 'Authorization'],
-            credentials: true
-        }
+    MODELS: {
+        'grok-2': 'grok-latest',
+        'grok-2-imageGen': 'grok-latest',
+        'grok-2-search': 'grok-latest',
+        "grok-3": "grok-3",
+        "grok-3-imageGen": "grok-3",
+        "grok-3-deepsearch": "grok-3",
+        "grok-3-reasoning": "grok-3"
     },
     API: {
+        BASE_URL: "https://grok.com",
         API_KEY: process.env.API_KEY || "sk-123456",
-        AUTH_TOKEN: process.env.AUTH_TOKEN,
-        CT0: process.env.CT0,
-        ENDPOINTS: {
-            CHAT: 'https://grok.x.com/2/grok/add_response.json',
-            CREATE_CONVERSATION: 'https://x.com/i/api/graphql/vvC5uy7pWWHXS2aDi1FZeA/CreateGrokConversation',
-            DELETE_CONVERSATION: 'https://x.com/i/api/graphql/TlKHSWVMVeaa-i7dqQqFQA/ConversationItem_DeleteConversationMutation',
-            UPLOAD_IMAGE: 'https://x.com/i/api/2/grok/attachment.json'
-        }
+        SIGNATURE_COOKIE: null,
+        TEMP_COOKIE: null,
+        PICGO_KEY: process.env.PICGO_KEY || null //想要流式生图的话需要填入这个PICGO图床的key
     },
-    MODELS: {
-        "grok-3": "grok-3",
-        "grok-3-deepsearch": "grok-3",
-        "grok-3-reasoning": "grok-3",
-        "grok-3-imageGen": "grok-3",
+    SERVER: {
+        PORT: process.env.PORT || 3000,
+        BODY_LIMIT: '5mb'
+    },
+    RETRY: {
+        MAX_ATTEMPTS: 2//重试次数
     },
+    SHOW_THINKING:process.env.SHOW_THINKING === 'true',//显示思考过程
+    IS_THINKING: false,
     IS_IMG_GEN: false,
-    IS_THINKING: false
+    IS_IMG_GEN2: false,
+    SSO_INDEX: 0,//sso的索引
+    ISSHOW_SEARCH_RESULTS: process.env.ISSHOW_SEARCH_RESULTS === 'true',//是否显示搜索结果,默认关闭
+    CHROME_PATH: process.env.CHROME_PATH || "/usr/bin/chromium"//chrome路径
 };
-
-// HTTP 请求头配置
+puppeteer.use(StealthPlugin())
+// 请求头配置
 const DEFAULT_HEADERS = {
-    'authorization': 'Bearer AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA',
-    'sec-ch-ua': '"Google Chrome";v="131", "Chromium";v="131", "Not_A Brand";v="24"',
-    'sec-ch-ua-mobile': '?0',
-    'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36',
     'accept': '*/*',
+    'accept-language': 'zh-CN,zh;q=0.9',
+    'accept-encoding': 'gzip, deflate, br, zstd',
     'content-type': 'text/plain;charset=UTF-8',
-    'origin': 'https://x.com',
-    'sec-fetch-site': 'same-site',
+    'Connection': 'keep-alive',
+    'origin': 'https://grok.com',
+    'priority': 'u=1, i',
+    'sec-ch-ua': '"Chromium";v="130", "Google Chrome";v="130", "Not?A_Brand";v="99"',
+    'sec-ch-ua-mobile': '?0',
+    'sec-ch-ua-platform': '"Windows"',
+    'sec-fetch-dest': 'empty',
     'sec-fetch-mode': 'cors',
-    'accept-encoding': 'gzip, deflate, br, zstd',
-    'accept-language': 'zh-CN,zh;q=0.9',
-    'priority': 'u=1, i'
+    'sec-fetch-site': 'same-origin',
+    'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36',
+    'baggage': 'sentry-public_key=b311e0f2690c81f25e2c4cf6d4f7ce1c'
 };
 
-// 工具类
-class Utils {
-    static generateRandomString(length, charset = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ') {
-        return Array(length).fill(null)
-            .map(() => charset[Math.floor(Math.random() * charset.length)])
-            .join('');
-    }
 
-    static createAuthHeaders() {
-        return {
-            ...DEFAULT_HEADERS,
-            'x-csrf-token': CONFIG.API.CT0,
-            'cookie': `auth_token=${CONFIG.API.AUTH_TOKEN};ct0=${CONFIG.API.CT0}`
+async function initialization() {
+    const ssoArray = process.env.SSO.split(',');
+    const ssorwArray = process.env.SSO_RW.split(',');
+    ssoArray.forEach((sso, index) => {
+        tokenManager.addToken(`sso-rw=${ssorwArray[index]};sso=${sso}`);
+    });
+    console.log(JSON.stringify(tokenManager.getActiveTokens(), null, 2));
+    await Utils.get_signature()
+    Logger.info("初始化完成", 'Server');
+}
+
+
+class AuthTokenManager {
+    constructor() {
+        this.activeTokens = [];
+        this.expiredTokens = new Map();
+        this.tokenModelFrequency = new Map();
+        this.modelRateLimit = {
+            "grok-3": { RequestFrequency: 20 },
+            "grok-3-deepsearch": { RequestFrequency: 5 },
+            "grok-3-reasoning": { RequestFrequency: 5 }
         };
     }
 
-    static getImageMimeType(base64String) {
-        const matches = base64String.match(/data:([a-zA-Z0-9]+\/[a-zA-Z0-9-.+]+);base64,/);
-        return matches ? matches[1] : 'image/jpeg';
+    addToken(token) {
+        if (!this.activeTokens.includes(token)) {
+            this.activeTokens.push(token);
+            this.tokenModelFrequency.set(token, {
+                "grok-3": 0,
+                "grok-3-deepsearch": 0,
+                "grok-3-reasoning": 0
+            });
+        }
     }
 
-    static async handleApiResponse(response, errorMessage) {
-        if (!response.ok) {
-            throw new Error(`${errorMessage} Status: ${response.status}`);
+    getTokenByIndex(index, model) {
+        if (!this.modelRateLimit[model]) return;
+        if(this.activeTokens.length === 0){
+            return null;
         }
-        return await response.json();
+        const token = this.activeTokens[index];
+        this.recordModelRequest(token, model);
+        return token;
     }
-}
 
-// 会话管理类
-class ConversationManager {
-    static async generateNewId() {
-        const response = await fetch(CONFIG.API.ENDPOINTS.CREATE_CONVERSATION, {
-            method: 'POST',
-            headers: Utils.createAuthHeaders(),
-            body: JSON.stringify({
-                variables: {},
-                queryId: "vvC5uy7pWWHXS2aDi1FZeA"
-            })
-        });
-
-        const data = await Utils.handleApiResponse(response, '创建会话失败!');
-        return data.data.create_grok_conversation.conversation_id;
+    recordModelRequest(token, model) {
+        if (!this.modelRateLimit[model]) return;
+        const tokenFrequency = this.tokenModelFrequency.get(token);
+        if (tokenFrequency && tokenFrequency[model] !== undefined) {
+            tokenFrequency[model]++;
+        }
+        this.checkAndRemoveTokenIfLimitReached(token);
     }
+    setModelLimit(index, model) {
+        if (!this.modelRateLimit[model]) return;
+        const tokenFrequency = this.tokenModelFrequency.get(this.activeTokens[index]);
+        tokenFrequency[model] = 9999;
+    }
+    isTokenModelLimitReached(index, model) {
+        if (!this.modelRateLimit[model]) return;
+        const token = this.activeTokens[index];
+        const tokenFrequency = this.tokenModelFrequency.get(token);
 
-    static async deleteConversation(conversationId) {
-        if (!conversationId) return;
-
-        await fetch(CONFIG.API.ENDPOINTS.DELETE_CONVERSATION, {
-            method: 'POST',
-            headers: Utils.createAuthHeaders(),
-            body: JSON.stringify({
-                variables: { conversationId },
-                queryId: "TlKHSWVMVeaa-i7dqQqFQA"
-            })
-        });
+        if (!tokenFrequency) {
+            return false;
+        }
+        return tokenFrequency[model] >= this.modelRateLimit[model].RequestFrequency;
     }
-}
+    checkAndRemoveTokenIfLimitReached(token) {
+        const tokenFrequency = this.tokenModelFrequency.get(token);
+        if (!tokenFrequency) return;
 
-// 消息处理类
-class MessageProcessor {
-    static createChatResponse(message, model, isStream = false) {
-        const baseResponse = {
-            id: `chatcmpl-${uuidv4()}`,
-            created: Math.floor(Date.now() / 1000),
-            model: model
-        };
+        const isLimitReached = Object.keys(tokenFrequency).every(model =>
+            tokenFrequency[model] >= this.modelRateLimit[model].RequestFrequency
+        );
 
-        if (isStream) {
-            return {
-                ...baseResponse,
-                object: 'chat.completion.chunk',
-                choices: [{
-                    index: 0,
-                    delta: { content: message }
-                }]
-            };
+        if (isLimitReached) {
+            const tokenIndex = this.activeTokens.indexOf(token);
+            if (tokenIndex !== -1) {
+                this.removeTokenByIndex(tokenIndex);
+            }
         }
-
-        return {
-            ...baseResponse,
-            object: 'chat.completion',
-            choices: [{
-                index: 0,
-                message: {
-                    role: 'assistant',
-                    content: message
-                },
-                finish_reason: 'stop'
-            }],
-            usage: null
-        };
     }
 
-    static processMessageContent(content) {
-        if (typeof content === 'string') return content;
-        if (Array.isArray(content)) {
-            if (content.some(item => item.type === 'image_url')) return null;
-            return content
-                .filter(item => item.type === 'text')
-                .map(item => item.text)
-                .join('\n');
+    removeTokenByIndex(index) {
+        if (!this.isRecoveryProcess) {
+            this.startTokenRecoveryProcess();
         }
-        if (typeof content === 'object') return content.text || null;
-        return null;
+        const token = this.activeTokens[index];
+        this.expiredTokens.set(token, Date.now());
+        this.activeTokens.splice(index, 1);
+        this.tokenModelFrequency.delete(token);
+        Logger.info(`令牌${token}已达到上限，已移除`, 'TokenManager');
     }
-}
 
-// Grok API 客户端类
-class TwitterGrokApiClient {
-    constructor(modelId) {
-        if (!CONFIG.MODELS[modelId]) {
-            throw new Error(`不支持的模型: ${modelId}`);
-        }
-        this.modelId = CONFIG.MODELS[modelId];
-        this.modelType = {
-            isDeepSearch: modelId === 'grok-3-deepsearch',
-            isReasoning: modelId === 'grok-3-reasoning'
-        };
+    startTokenRecoveryProcess() {
+        setInterval(() => {
+            const now = Date.now();
+            for (const [token, expiredTime] of this.expiredTokens.entries()) {
+                if (now - expiredTime >= 2 * 60 * 60 * 1000) {
+                    this.tokenModelUsage.set(token, {
+                        "grok-3": 0,
+                        "grok-3-imageGen": 0,
+                        "grok-3-deepsearch": 0,
+                        "grok-3-reasoning": 0
+                    });
+                    this.activeTokens.push(token);
+                    this.expiredTokens.delete(token);
+                    Logger.info(`令牌${token}已恢复，已添加到可用令牌列表`, 'TokenManager');
+                }
+            }
+        }, 2 * 60 * 60 * 1000);
     }
 
-    async uploadImage(imageData) {
-        const formData = new FormData();
-        const imageBuffer = Buffer.from(imageData.split(',')[1], 'base64');
-        const mimeType = Utils.getImageMimeType(imageData);
+    getTokenCount() {
+        return this.activeTokens.length || 0;
+    }
 
-        formData.append('photo', imageBuffer, {
-            filename: 'image.png',
-            contentType: mimeType
-        });
+    getActiveTokens() {
+        return [...this.activeTokens];
+    }
+}
 
-        const response = await fetch(CONFIG.API.ENDPOINTS.UPLOAD_IMAGE, {
-            method: 'POST',
-            headers: {
-                ...Utils.createAuthHeaders(),
-                ...formData.getHeaders()
-            },
-            body: formData
-        });
+class Utils {
+    static async extractGrokHeaders() {
+        Logger.info("开始提取头信息", 'Server');
+        try {
+            // 启动浏览器
+            const browser = await puppeteer.launch({
+                headless: true,
+                args: [
+                    '--no-sandbox',
+                    '--disable-setuid-sandbox',
+                    '--disable-dev-shm-usage',
+                    '--disable-gpu'
+                ],
+                executablePath: CONFIG.CHROME_PATH
+            });
+
+            const page = await browser.newPage();
+            await page.goto('https://grok.com/', { waitUntil: 'domcontentloaded' });
+            await page.evaluate(() => {
+                return new Promise(resolve => setTimeout(resolve, 5000))
+            })
+            // 获取所有 Cookies
+            const cookies = await page.cookies();
+            const targetHeaders = ['x-anonuserid', 'x-challenge', 'x-signature'];
+            const extractedHeaders = {};
+            // 遍历 Cookies
+            for (const cookie of cookies) {
+                // 检查是否为目标头信息
+                if (targetHeaders.includes(cookie.name.toLowerCase())) {
+                    extractedHeaders[cookie.name.toLowerCase()] = cookie.value;
+                }
+            }
+            // 关闭浏览器
+            await browser.close();
+            // 打印并返回提取的头信息
+            Logger.info('提取的头信息:', JSON.stringify(extractedHeaders, null, 2), 'Server');
+            return extractedHeaders;
 
-        return await Utils.handleApiResponse(response, '图片上传失败');
+        } catch (error) {
+            Logger.error('获取头信息出错:', error, 'Server');
+            return null;
+        }
     }
-
-    async transformMessages(messages) {
-        const processedMessages = [];
-        for (let i = 0; i < messages.length; i++) {
-            const isLastTwoMessages = i >= messages.length - 2;
-            const content = await this.processMessageContent(messages[i], isLastTwoMessages);
-            if (content) {
-                processedMessages.push(content);
+    static async get_signature() {
+        if (CONFIG.API.TEMP_COOKIE) {
+            return CONFIG.API.TEMP_COOKIE;
+        }
+        Logger.info("刷新认证信息", 'Server');
+        let retryCount = 0;
+        while (!CONFIG.API.TEMP_COOKIE || retryCount < CONFIG.RETRY.MAX_ATTEMPTS) {
+            let headers = await Utils.extractGrokHeaders();
+            if (headers) {
+                Logger.info("获取认证信息成功", 'Server');
+                CONFIG.API.TEMP_COOKIE = { cookie: `x-anonuserid=${headers["x-anonuserid"]}; x-challenge=${headers["x-challenge"]}; x-signature=${headers["x-signature"]}` };
+                return;
+            }
+            retryCount++;
+            if (retryCount >= CONFIG.RETRY.MAX_ATTEMPTS) {
+                throw new Error(`获取认证信息失败!`);
             }
         }
-        return processedMessages;
     }
-
-    async processMessageContent(msg, isLastTwoMessages) {
-        const { role, content } = msg;
-        let message = '';
-        let fileAttachments = [];
-
-        if (typeof content === 'string') {
-            message = content;
-        } else if (Array.isArray(content) || typeof content === 'object') {
-            const { text, imageAttachments } = await this.processComplexContent(content, isLastTwoMessages);
-            message = text;
-            fileAttachments = imageAttachments;
+    static async organizeSearchResults(searchResults) {
+        // 确保传入的是有效的搜索结果对象
+        if (!searchResults || !searchResults.results) {
+            return '';
         }
 
+        const results = searchResults.results;
+        const formattedResults = results.map((result, index) => {
+            // 处理可能为空的字段
+            const title = result.title || '未知标题';
+            const url = result.url || '#';
+            const preview = result.preview || '无预览内容';
+
+            return `\r\n<details><summary>资料[${index}]: ${title}</summary>\r\n${preview}\r\n\n[Link](${url})\r\n</details>`;
+        });
+        return formattedResults.join('\n\n');
+    }
+    static createAuthHeaders(model) {
         return {
-            message,
-            sender: role === 'user' ? 1 : 2,
-            ...(role === 'user' && { fileAttachments })
+            'cookie': `${tokenManager.getTokenByIndex(CONFIG.SSO_INDEX, model)}`
         };
     }
+}
 
-    async processComplexContent(content, isLastTwoMessages) {
-        let text = '';
-        let imageAttachments = [];
-
-        const processItem = async (item) => {
-            if (item.type === 'text') {
-                text += item.text;
-            } else if (item.type === 'image_url' && item.image_url.url.includes('data:image')) {
-                if (isLastTwoMessages) {
-                    const uploadResult = await this.uploadImage(item.image_url.url);
-                    if (Array.isArray(uploadResult)) {
-                        imageAttachments.push(...uploadResult);
-                    }
-                } else {
-                    text += '[图片]';
-                }
-            }
-        };
 
-        if (Array.isArray(content)) {
-            await Promise.all(content.map(processItem));
-        } else {
-            await processItem(content);
+class GrokApiClient {
+    constructor(modelId) {
+        if (!CONFIG.MODELS[modelId]) {
+            throw new Error(`不支持的模型: ${modelId}`);
         }
-
-        return { text, imageAttachments };
+        this.modelId = CONFIG.MODELS[modelId];
     }
 
-    async prepareChatRequest(request) {
-        const responses = await this.transformMessages(request.messages);
-        const conversationId = await ConversationManager.generateNewId();
+    processMessageContent(content) {
+        if (typeof content === 'string') return content;
+        return null;
+    }
+    // 获取图片类型
+    getImageType(base64String) {
+        let mimeType = 'image/jpeg';
+        if (base64String.includes('data:image')) {
+            const matches = base64String.match(/data:([a-zA-Z0-9]+\/[a-zA-Z0-9-.+]+);base64,/);
+            if (matches) {
+                mimeType = matches[1];
+            }
+        }
+        const extension = mimeType.split('/')[1];
+        const fileName = `image.${extension}`;
 
         return {
-            responses,
-            systemPromptName: "",
-            grokModelOptionId: this.modelId,
-            conversationId,
-            returnSearchResults: this.modelType.isReasoning,
-            returnCitations: this.modelType.isReasoning,
-            promptMetadata: {
-                promptSource: "NATURAL",
-                action: "INPUT"
-            },
-            imageGenerationCount: 1,
-            requestFeatures: {
-                eagerTweets: false,
-                serverHistory: false
-            },
-            enableCustomization: true,
-            enableSideBySide: false,
-            toolOverrides: {
-                imageGen: request.model === 'grok-3-imageGen',
-            },
-            isDeepsearch: this.modelType.isDeepSearch,
-            isReasoning: this.modelType.isReasoning
+            mimeType: mimeType,
+            fileName: fileName
         };
     }
-}
-
-// 响应处理类
-class ResponseHandler {
-    static async handleStreamResponse(response, model, res) {
-        res.setHeader('Content-Type', 'text/event-stream');
-        res.setHeader('Cache-Control', 'no-cache');
-        res.setHeader('Connection', 'keep-alive');
-
-        const reader = response.body;
-        let buffer = '';
-        CONFIG.IS_IMG_GEN = false;
-        CONFIG.IS_THINKING = false;
 
+    async uploadBase64Image(base64Data, url) {
         try {
-            for await (const chunk of reader) {
-                const lines = (buffer + chunk.toString()).split('\n');
-                buffer = lines.pop() || '';
-
-                for (const line of lines) {
-                    if (!line.trim()) continue;
-                    await this.processStreamLine(JSON.parse(line), model, res);
+            // 处理 base64 数据
+            let imageBuffer;
+            if (base64Data.includes('data:image')) {
+                imageBuffer = base64Data.split(',')[1];
+            } else {
+                imageBuffer = base64Data
+            }
+            const { mimeType, fileName } = this.getImageType(base64Data);
+            let uploadData = {
+                rpc: "uploadFile",
+                req: {
+                    fileName: fileName,
+                    fileMimeType: mimeType,
+                    content: imageBuffer
                 }
+            };
+            Logger.info("发送图片请求", 'Server');
+            // 发送请求
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    ...CONFIG.DEFAULT_HEADERS,
+                    ...CONFIG.API.SIGNATURE_COOKIE
+                },
+                body: JSON.stringify(uploadData)
+            });
+
+            if (!response.ok) {
+                Logger.error(`上传图片失败,状态码:${response.status},原因:${response.error}`, 'Server');
+                return '';
             }
 
-            res.write('data: [DONE]\n\n');
-            res.end();
+            const result = await response.json();
+            Logger.info('上传图片成功:', result, 'Server');
+            return result.fileMetadataId;
+
         } catch (error) {
-            Logger.error('Stream response error:', error, 'ChatAPI');
-            throw error;
+            Logger.error(error, 'Server');
+            return '';
         }
     }
 
-    static async processStreamLine(jsonData, model, res) {
-        if (jsonData.result?.doImgGen) {
-            CONFIG.IS_IMG_GEN = true;
-            return;
+    async prepareChatRequest(request) {
+        if ((request.model === 'grok-2-imageGen' || request.model === 'grok-3-imageGen') && !CONFIG.API.PICGO_KEY && request.stream) {
+            throw new Error(`该模型流式输出需要配置PICGO图床密钥!`);
         }
-
-        if (CONFIG.IS_IMG_GEN && jsonData.result?.event?.imageAttachmentUpdate?.progress === 100) {
-            await this.handleImageGeneration(jsonData, model, res);
-            return;
+        
+        // 处理画图模型的消息限制
+        let todoMessages = request.messages;
+        if (request.model === 'grok-2-imageGen' || request.model === 'grok-3-imageGen') {
+            const lastMessage = todoMessages[todoMessages.length - 1];
+            if (lastMessage.role !== 'user') {
+                throw new Error('画图模型的最后一条消息必须是用户消息!');
+            }
+            todoMessages = [lastMessage]; 
         }
-
-        if (!CONFIG.IS_IMG_GEN && jsonData.result?.message) {
-            await this.handleTextMessage(jsonData, model, res);
+        
+        const fileAttachments = [];
+        let messages = '';
+        let lastRole = null;
+        let lastContent = '';
+        const search = request.model === 'grok-2-search';
+    
+        // 移除<think>标签及其内容和base64图片
+        const removeThinkTags = (text) => {
+            text = text.replace(/<think>[\s\S]*?<\/think>/g, '').trim();
+            text = text.replace(/!\[image\]\(data:.*?base64,.*?\)/g, '[图片]');
+            return text;
+        };
+    
+        const processImageUrl = async (content) => {
+            if (content.type === 'image_url' && content.image_url.url.includes('data:image')) {
+                const imageResponse = await this.uploadBase64Image(
+                    content.image_url.url,
+                    `${CONFIG.API.BASE_URL}/api/rpc`
+                );
+                return imageResponse;
+            }
+            return null;
+        };
+    
+        const processContent = async (content) => {
+            if (Array.isArray(content)) {
+                let textContent = '';
+                for (const item of content) {
+                    if (item.type === 'image_url') {
+                        textContent += (textContent ? '\n' : '') + "[图片]";
+                    } else if (item.type === 'text') {
+                        textContent += (textContent ? '\n' : '') + removeThinkTags(item.text);
+                    }
+                }
+                return textContent;
+            } else if (typeof content === 'object' && content !== null) {
+                if (content.type === 'image_url') {
+                    return "[图片]";
+                } else if (content.type === 'text') {
+                    return removeThinkTags(content.text);
+                }
+            }
+            return removeThinkTags(this.processMessageContent(content));
+        };
+    
+        for (const current of todoMessages) {
+            const role = current.role === 'assistant' ? 'assistant' : 'user';
+            const isLastMessage = current === todoMessages[todoMessages.length - 1];
+            
+            // 处理图片附件
+            if (isLastMessage && current.content) {
+                if (Array.isArray(current.content)) {
+                    for (const item of current.content) {
+                        if (item.type === 'image_url') {
+                            const processedImage = await processImageUrl(item);
+                            if (processedImage) fileAttachments.push(processedImage);
+                        }
+                    }
+                } else if (current.content.type === 'image_url') {
+                    const processedImage = await processImageUrl(current.content);
+                    if (processedImage) fileAttachments.push(processedImage);
+                }
+            }
+    
+            // 处理文本内容
+            const textContent = await processContent(current.content);
+            
+            if (textContent || (isLastMessage && fileAttachments.length > 0)) {
+                if (role === lastRole && textContent) {
+                    lastContent += '\n' + textContent;
+                    messages = messages.substring(0, messages.lastIndexOf(`${role.toUpperCase()}: `)) +
+                        `${role.toUpperCase()}: ${lastContent}\n`;
+                } else {
+                    messages += `${role.toUpperCase()}: ${textContent || '[图片]'}\n`;
+                    lastContent = textContent;
+                    lastRole = role;
+                }
+            }
         }
+    
+        return {
+            modelName: this.modelId,
+            message: messages.trim(),
+            fileAttachments: fileAttachments.slice(0, 4),
+            imageAttachments: [],
+            disableSearch: false,
+            enableImageGeneration: true,
+            returnImageBytes: false,
+            returnRawGrokInXaiRequest: false,
+            enableImageStreaming: false,
+            imageGenerationCount: 1,
+            forceConcise: false,
+            toolOverrides: {
+                imageGen: request.model === 'grok-2-imageGen' || request.model === 'grok-3-imageGen',
+                webSearch: search,
+                xSearch: search,
+                xMediaSearch: search,
+                trendsSearch: search,
+                xPostAnalyze: search
+            },
+            enableSideBySide: true,
+            isPreset: false,
+            sendFinalMetadata: true,
+            customInstructions: "",
+            deepsearchPreset: request.model === 'grok-3-deepsearch' ? "default" : "",
+            isReasoning: request.model === 'grok-3-reasoning'
+        };
     }
+}
 
-    static async handleImageGeneration(jsonData, model, res) {
-        const imageUrl = jsonData.result.event.imageAttachmentUpdate.imageUrl;
-        const imageResponse = await fetch(imageUrl, {
-            method: 'GET',
-            headers: Utils.createAuthHeaders()
-        });
+class MessageProcessor {
+    static createChatResponse(message, model, isStream = false) {
+        const baseResponse = {
+            id: `chatcmpl-${uuidv4()}`,
+            created: Math.floor(Date.now() / 1000),
+            model: model
+        };
 
-        if (!imageResponse.ok) {
-            throw new Error(`Image request failed: ${imageResponse.status}`);
+        if (isStream) {
+            return {
+                ...baseResponse,
+                object: 'chat.completion.chunk',
+                choices: [{
+                    index: 0,
+                    delta: {
+                        content: message
+                    }
+                }]
+            };
         }
 
-        const imageBuffer = await imageResponse.arrayBuffer();
-        const base64Image = Buffer.from(imageBuffer).toString('base64');
-        const imageContentType = imageResponse.headers.get('content-type');
-        const message = `![image](data:${imageContentType};base64,${base64Image})`;
-
-        const responseData = MessageProcessor.createChatResponse(message, model, true);
-        res.write(`data: ${JSON.stringify(responseData)}\n\n`);
+        return {
+            ...baseResponse,
+            object: 'chat.completion',
+            choices: [{
+                index: 0,
+                message: {
+                    role: 'assistant',
+                    content: message
+                },
+                finish_reason: 'stop'
+            }],
+            usage: null
+        };
     }
-
-    static async handleTextMessage(jsonData, model, res) {
-        let message = jsonData.result.message;
-
-        switch (model) {
-            case "grok-3-reasoning":
-                if (!CONFIG.IS_THINKING && jsonData.result?.isThinking) {
-                    message = "<think>" + message;
-                    CONFIG.IS_THINKING = true;
-                } else if (CONFIG.IS_THINKING && !jsonData.result?.isThinking) {
-                    message = "</think>" + message;
-                    CONFIG.IS_THINKING = false;
-                }
-                break;
-            case "grok-3-deepsearch":
-                if (jsonData.result?.messageTag !== "final") return;
-                break;
+}
+async function processModelResponse(linejosn, model) {
+    let result = { token: '', imageUrl: null }
+    if (CONFIG.IS_IMG_GEN) {
+        if (linejosn?.cachedImageGenerationResponse && !CONFIG.IS_IMG_GEN2) {
+            result.imageUrl = linejosn.cachedImageGenerationResponse.imageUrl;
         }
-
-        const responseData = MessageProcessor.createChatResponse(message, model, true);
-        res.write(`data: ${JSON.stringify(responseData)}\n\n`);
+        return result;
     }
+    var token = linejosn?.token
+    if (!token) return result;
+    //非生图模型的处理
+    switch (model) {
+        case 'grok-2':
+            result.token = token;
+            return result;
+        case 'grok-2-search':
+            if (linejosn?.webSearchResults && CONFIG.ISSHOW_SEARCH_RESULTS) {
+                result.token = `\r\n<think>${await Utils.organizeSearchResults(linejosn.webSearchResults)}</think>\r\n`;
+            } else {
+                result.token = token;
+            }
+            return result;
+        case 'grok-3':
+            result.token = token;
+            return result;
+        case 'grok-3-deepsearch':
+            if (linejosn.messageTag === "final") {
+                result.token = token;
+            }
+            return result;
+        case 'grok-3-reasoning':
+            if(linejosn?.isThinking && !CONFIG.SHOW_THINKING)return result;
+
+            if (linejosn?.isThinking && !CONFIG.IS_THINKING) {
+                result.token = "<think>" + token;
+                CONFIG.IS_THINKING = true;
+            } else if (CONFIG.IS_THINKING && !linejosn.isThinking) {
+                result.token = "</think>" + token;
+                CONFIG.IS_THINKING = false;
+            } else {
+                result.token = token;
+            }
+            return result;
+    }
+}
 
-    static async handleNormalResponse(response, model, res) {
-        const reader = response.body;
+async function handleResponse(response, model, res, isStream) {
+    try {
+        const stream = response.body;
         let buffer = '';
         let fullResponse = '';
-        let imageUrl = null;
-
-        try {
-            for await (const chunk of reader) {
-                const lines = (buffer + chunk.toString()).split('\n');
+        const dataPromises = [];
+        
+        return new Promise((resolve, reject) => { 
+            stream.on('data', async (chunk) => {
+                buffer += chunk.toString();
+                const lines = buffer.split('\n');
                 buffer = lines.pop() || '';
 
                 for (const line of lines) {
                     if (!line.trim()) continue;
-                    const result = await this.processNormalLine(JSON.parse(line), model, CONFIG.IS_THINKING);
-                    fullResponse += result.text || '';
-                    imageUrl = result.imageUrl || imageUrl;
-                    CONFIG.IS_THINKING = result.isThinking;
+                    const trimmedLine = line.trim();
+                    if (trimmedLine.startsWith('data: ')) {
+                        const data = trimmedLine.substring(6);
+                        try {
+                            if (!data.trim()) continue;
+                            if(data === "[DONE]") continue;
+                            const linejosn = JSON.parse(data);
+                            if (linejosn?.error) {
+                                stream.destroy();
+                                reject(new Error("RateLimitError")); 
+                                return;
+                            }
+                            if (linejosn?.doImgGen || linejosn?.imageAttachmentInfo) {
+                                CONFIG.IS_IMG_GEN = true;
+                            }
+                            const processPromise = (async () => {
+                                const result = await processModelResponse(linejosn, model);
+                                if (result.token) {
+                                    if (isStream) {
+                                        res.write(`data: ${JSON.stringify(MessageProcessor.createChatResponse(result.token, model, true))}\n\n`);
+                                    } else {
+                                        fullResponse += result.token;
+                                    }
+                                }
+                                if (result.imageUrl) {
+                                    CONFIG.IS_IMG_GEN2 = true;
+                                    const dataImage = await handleImageResponse(result.imageUrl);
+                                    if (isStream) {
+                                        res.write(`data: ${JSON.stringify(MessageProcessor.createChatResponse(dataImage, model, true))}\n\n`);
+                                    } else {
+                                        res.json(MessageProcessor.createChatResponse(dataImage, model));
+                                    }
+                                }
+                            })();
+                            dataPromises.push(processPromise);
+                        } catch (error) {
+                            continue;
+                        }
+                    }
                 }
-            }
+            });
+
+            stream.on('end', async () => {
+                try {
+                    await Promise.all(dataPromises);
+                    if (isStream) {
+                        res.write('data: [DONE]\n\n');
+                        res.end();
+                    } else {
+                        if (!CONFIG.IS_IMG_GEN2) {
+                            res.json(MessageProcessor.createChatResponse(fullResponse, model));
+                        }                        
+                    }
+                    CONFIG.IS_IMG_GEN = false;
+                    CONFIG.IS_IMG_GEN2 = false;
+                    resolve(); 
+                } catch (error) {
+                    reject(error); 
+                }
+            });
 
-            if (imageUrl) {
-                await this.sendImageResponse(imageUrl, model, res);
-            } else {
-                const responseData = MessageProcessor.createChatResponse(fullResponse, model);
-                res.json(responseData);
-            }
-        } catch (error) {
-            Logger.error('Normal response error:', error, 'ChatAPI');
-            throw error;
-        }
+            stream.on('error', (error) => {
+                reject(error); 
+            });
+        });
+    } catch (error) {
+        Logger.error(error, 'Server');
+        CONFIG.IS_IMG_GEN = false;
+        CONFIG.IS_IMG_GEN2 = false;
+        throw error;
     }
+}
 
-    static async processNormalLine(jsonData, model, isThinking) {
-        let result = { text: '', imageUrl: null, isThinking };
-
-        if (jsonData.result?.message) {
-            switch (model) {
-                case "grok-3-reasoning":
-                    result = this.processReasoningMessage(jsonData, isThinking);
-                    break;
-                case "grok-3-deepsearch":
-                    if (jsonData.result?.messageTag === "final") {
-                        result.text = jsonData.result.message;
-                    }
-                    break;
-                default:
-                    result.text = jsonData.result.message;
-            }
-        }
+async function handleImageResponse(imageUrl) {
+    const MAX_RETRIES = 2;
+    let retryCount = 0;
+    let imageBase64Response;
 
-        if (jsonData.result?.event?.imageAttachmentUpdate?.progress === 100) {
-            result.imageUrl = jsonData.result.event.imageAttachmentUpdate.imageUrl;
-        }
+    while (retryCount < MAX_RETRIES) {
+        try {
+            imageBase64Response = await fetch(`https://assets.grok.com/${imageUrl}`, {
+                method: 'GET',
+                headers: {
+                    ...DEFAULT_HEADERS,
+                    ...CONFIG.API.SIGNATURE_COOKIE
+                }
+            });
 
-        return result;
-    }
+            if (imageBase64Response.ok) break; 
+            retryCount++;
+            if (retryCount === MAX_RETRIES) {
+                throw new Error(`上游服务请求失败! status: ${imageBase64Response.status}`);
+            }
+            await new Promise(resolve => setTimeout(resolve, CONFIG.API.RETRY_TIME * retryCount));
 
-    static processReasoningMessage(jsonData, isThinking) {
-        let result = { text: '', isThinking };
-
-        if (jsonData.result?.isThinking && !isThinking) {
-            result.text = "<think>" + jsonData.result.message;
-            result.isThinking = true;
-        } else if (isThinking && !jsonData.result?.isThinking) {
-            result.text = "</think>" + jsonData.result.message;
-            result.isThinking = false;
-        } else {
-            result.text = jsonData.result.message;
+        } catch (error) {
+            retryCount++;
+            if (retryCount === MAX_RETRIES) {
+                throw error;
+            }
+            await new Promise(resolve => setTimeout(resolve, CONFIG.API.RETRY_TIME * retryCount));
         }
-
-        return result;
     }
 
-    static async sendImageResponse(imageUrl, model, res) {
-        const response = await fetch(imageUrl, {
-            method: 'GET',
-            headers: Utils.createAuthHeaders()
-        });
 
-        if (!response.ok) {
-            throw new Error(`Image request failed: ${response.status}`);
-        }
+    const arrayBuffer = await imageBase64Response.arrayBuffer();
+    const imageBuffer = Buffer.from(arrayBuffer);
 
-        const imageBuffer = await response.arrayBuffer();
-        const base64Image = Buffer.from(imageBuffer).toString('base64');
-        const imageContentType = response.headers.get('content-type');
+    if(!CONFIG.API.PICGO_KEY){
+        const base64Image = imageBuffer.toString('base64');
+        const imageContentType = imageBase64Response.headers.get('content-type');
+        return `![image](data:${imageContentType};base64,${base64Image})`
+    }
 
-        const responseData = MessageProcessor.createChatResponse(
-            `![image](data:${imageContentType};base64,${base64Image})`,
-            model
-        );
-        res.json(responseData);
+    const formData = new FormData();
+
+    formData.append('source', imageBuffer, {
+        filename: 'new.jpg',
+        contentType: 'image/jpeg'
+    });
+    const formDataHeaders = formData.getHeaders();
+    const responseURL = await fetch("https://www.picgo.net/api/1/upload", {
+        method: "POST",
+        headers: {
+            ...formDataHeaders,
+            "Content-Type": "multipart/form-data",
+            "X-API-Key": CONFIG.API.PICGO_KEY
+        },
+        body: formData
+    });
+    if (!responseURL.ok) {
+        return "生图失败，请查看图床密钥是否设置正确"
+    } else {
+        console.log("生图成功");
+        const result = await responseURL.json();
+        return `![image](${result.image.url})`
     }
 }
 
-// Express 应用配置
+const tokenManager = new AuthTokenManager();
+await initialization();
+
+// 中间件配置
 const app = express();
 app.use(Logger.requestLogger);
-app.use(cors(CONFIG.SERVER.CORS_OPTIONS));
 app.use(express.json({ limit: CONFIG.SERVER.BODY_LIMIT }));
 app.use(express.urlencoded({ extended: true, limit: CONFIG.SERVER.BODY_LIMIT }));
+app.use(cors({
+    origin: '*',
+    methods: ['GET', 'POST', 'OPTIONS'],
+    allowedHeaders: ['Content-Type', 'Authorization']
+}));
 
-// API 路由
-app.get('/v1/models', (req, res) => {
+app.get('/hf/v1/models', (req, res) => {
     res.json({
         object: "list",
-        data: Object.keys(CONFIG.MODELS).map(model => ({
+        data: Object.keys(CONFIG.MODELS).map((model, index) => ({
             id: model,
             object: "model",
             created: Math.floor(Date.now() / 1000),
-            owned_by: "xgrok",
+            owned_by: "grok",
         }))
     });
 });
 
-app.post('/v1/chat/completions', async (req, res) => {
+
+app.post('/hf/v1/chat/completions', async (req, res) => {
     try {
         const authToken = req.headers.authorization?.replace('Bearer ', '');
         if (authToken !== CONFIG.API.API_KEY) {
             return res.status(401).json({ error: 'Unauthorized' });
         }
+        let isTempCookie = req.body.model.includes("grok-2");
+        let retryCount = 0;
+        
+        while (retryCount < CONFIG.RETRY.MAX_ATTEMPTS) {
+            retryCount++;
+            const grokClient = new GrokApiClient(req.body.model);
+            const requestPayload = await grokClient.prepareChatRequest(req.body);       
+
+            if (!CONFIG.API.TEMP_COOKIE) {
+                await Utils.get_signature();
+            }
 
-        const grokClient = new TwitterGrokApiClient(req.body.model);
-        const requestPayload = await grokClient.prepareChatRequest(req.body);
-
-        const response = await fetch(CONFIG.API.ENDPOINTS.CHAT, {
-            method: 'POST',
-            headers: Utils.createAuthHeaders(),
-            body: JSON.stringify(requestPayload)
-        });
-
-        if (!response.ok) {
-            throw new Error(`上游服务请求失败! status: ${response.status}`);
+            if (isTempCookie) {
+                CONFIG.API.SIGNATURE_COOKIE = CONFIG.API.TEMP_COOKIE;
+                Logger.info(`已切换为临时令牌`, 'Server');
+            } else {
+                CONFIG.API.SIGNATURE_COOKIE = Utils.createAuthHeaders(req.body.model);
+            }
+            Logger.info(`当前令牌索引: ${CONFIG.SSO_INDEX}`, 'Server');
+            const newMessageReq = await fetch(`${CONFIG.API.BASE_URL}/api/rpc`, {
+                method: 'POST',
+                headers: {
+                    ...DEFAULT_HEADERS,
+                    ...CONFIG.API.SIGNATURE_COOKIE
+                },
+                body: JSON.stringify({
+                    rpc: "createConversation",
+                    req: {
+                        temporary: false
+                    }
+                })
+            });
+
+            const responseText = await newMessageReq.json();
+            const conversationId = responseText.conversationId;
+
+            const response = await fetch(`${CONFIG.API.BASE_URL}/api/conversations/${conversationId}/responses`, {
+                method: 'POST',
+                headers: {
+                    "accept": "text/event-stream",
+                    "baggage": "sentry-public_key=b311e0f2690c81f25e2c4cf6d4f7ce1c",
+                    "content-type": "text/plain;charset=UTF-8",
+                    "Connection": "keep-alive",
+                    ...CONFIG.API.SIGNATURE_COOKIE
+                },
+                body: JSON.stringify(requestPayload)
+            });
+
+            if (response.ok) {
+                Logger.info(`请求成功`, 'Server');
+                CONFIG.SSO_INDEX = (CONFIG.SSO_INDEX + 1) % tokenManager.getTokenCount();
+                Logger.info(`当前剩余可用令牌数: ${tokenManager.getTokenCount()}`, 'Server');
+                try {
+                    await handleResponse(response, req.body.model, res, req.body.stream);
+                    return; 
+                } catch (error) {
+                    if(isTempCookie){
+                        await Utils.get_signature();
+                    }else{
+                        tokenManager.setModelLimit(CONFIG.SSO_INDEX, req.body.model);
+                        for (let i = 1; i <= tokenManager.getTokenCount(); i++) {
+                            CONFIG.SSO_INDEX = (CONFIG.SSO_INDEX + 1) % tokenManager.getTokenCount();
+                            if (!tokenManager.isTokenModelLimitReached(CONFIG.SSO_INDEX, req.body.model)) {
+                                break;
+                            } else if (i >= tokenManager.getTokenCount()) {
+                                throw new Error(`${req.body.model} 次数已达上限，请切换其他模型或者重新对话`);
+                            }
+                        }
+                    }
+                }
+            } else {
+                if (response.status === 429) {
+                    if (isTempCookie) {
+                        await Utils.get_signature();
+                    } else {
+                        tokenManager.setModelLimit(CONFIG.SSO_INDEX, req.body.model);
+                        for (let i = 1; i <= tokenManager.getTokenCount(); i++) {
+                            CONFIG.SSO_INDEX = (CONFIG.SSO_INDEX + 1) % tokenManager.getTokenCount();
+                            if (!tokenManager.isTokenModelLimitReached(CONFIG.SSO_INDEX, req.body.model)) {
+                                break;
+                            } else if (i >= tokenManager.getTokenCount()) {
+                                throw new Error(`${req.body.model} 次数已达上限，请切换其他模型或者重新对话`);
+                            }
+                        }
+                    }
+                } else {
+                    // 非429错误直接抛出
+                    if (isTempCookie) {
+                        await Utils.get_signature();
+                    } else {
+                        Logger.error(`令牌异常错误状态!status: ${response.status}， 已移除当前令牌${CONFIG.SSO_INDEX.cookie}`, 'Server');
+                        tokenManager.removeTokenByIndex(CONFIG.SSO_INDEX);
+                        Logger.info(`当前剩余可用令牌数: ${tokenManager.getTokenCount()}`, 'Server');
+                        CONFIG.SSO_INDEX = (CONFIG.SSO_INDEX + 1) % tokenManager.getTokenCount();
+                    }
+                }
+            }
         }
-
-        await (req.body.stream
-            ? ResponseHandler.handleStreamResponse(response, req.body.model, res)
-            : ResponseHandler.handleNormalResponse(response, req.body.model, res));
-
+        throw new Error('当前模型所有令牌都已耗尽');
     } catch (error) {
-        Logger.error('Chat Completions Request Error', error, 'ChatAPI');
+        Logger.error(error, 'ChatAPI');
         res.status(500).json({
             error: {
                 message: error.message,
@@ -530,19 +851,15 @@ app.post('/v1/chat/completions', async (req, res) => {
                 code: error.code || null
             }
         });
-    } finally {
-        if (req.body.conversationId) {
-            await ConversationManager.deleteConversation(req.body.conversationId);
-        }
     }
 });
 
-// 404 处理
+
 app.use((req, res) => {
-    res.status(404).json({ error: '请求路径不存在' });
+    res.status(200).send('api运行正常');
 });
 
-// 启动服务器
+
 app.listen(CONFIG.SERVER.PORT, () => {
-    Logger.info(`服务器运行在端口 ${CONFIG.SERVER.PORT}`, 'Server');
+    Logger.info(`服务器已启动，监听端口: ${CONFIG.SERVER.PORT}`, 'Server');
 });

logger.js

@@ -34,7 +34,7 @@ static warn(message, context) {
   console.warn(this.formatMessage(LogLevel.WARN, context ? `[${context}] ${message}` : message));
 }
 
-static error(message, error, context) {
+static error(message, context, error = null) {
   const errorMessage = error ? ` - ${error.message}` : '';
   console.error(this.formatMessage(LogLevel.ERROR, `${context ? `[${context}] ` : ''}${message}${errorMessage}`));
 }

package.json

@@ -1,20 +1,23 @@
 {
-	"name": "xgrokServicee",
-	"version": "1.0.0",
-	"main": "index.js",
-	"type": "module",
-	"scripts": {
-		"start": "node index.js"
-	},
-	"author": "yxmiler",
-	"dependencies": {
-		"express": "^4.18.2",
-		"cors": "^2.8.5",
-		"dotenv": "^16.3.1",
-		"uuid": "^9.0.0",
-		"chalk": "^5.4.1",
-		"moment": "^2.30.1",
-		"node-fetch": "^3.3.2",
-		"form-data": "^4.0.0"
-	}
-}
+  "name": "grok2api",
+  "version": "1.0.0",
+  "main": "index.js",
+  "type": "module",
+  "scripts": {
+    "start": "node index.js"
+  },
+  "author": "yxmiler",
+  "dependencies": {
+    "express": "^4.18.2",
+    "node-fetch": "^3.3.2",
+    "dotenv": "^16.3.1",
+    "cors": "^2.8.5",
+    "form-data": "^4.0.0",
+    "puppeteer": "^22.8.2",
+    "puppeteer-extra": "^3.3.6",
+    "puppeteer-extra-plugin-stealth": "^2.11.2",
+    "moment": "^2.30.1",
+    "chalk": "^5.4.1",
+    "uuid": "^9.0.0"
+  }
+}