Rename app.js to app.py

app.js

@@ -1,636 +0,0 @@
-const express = require('express');
-const axios = require('axios');
-const { v4: uuidv4 } = require('uuid');
-const dotenv = require('dotenv');
-
-dotenv.config();
-
-const app = express();
-app.use(express.json());
-
-// 常量定义
-const TARGET_URL = "https://grok.com/rest/app-chat/conversations/new";
-const MODELS = ["grok-2", "grok-3", "grok-3-thinking"];
-const PORT = process.env.PORT || 7860;
-
-// 用户代理列表
-const USER_AGENTS = [
-    // Windows - Chrome
-    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
-    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36",
-    // Windows - Firefox
-    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:132.0) Gecko/20100101 Firefox/132.0",
-    // Windows - Edge
-    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36 Edg/123.0.2420.81",
-    // Windows - Opera
-    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36 OPR/109.0.0.0",
-    // macOS - Chrome
-    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
-    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36",
-    // macOS - Safari
-    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0.1 Safari/605.1.15",
-    // macOS - Firefox
-    "Mozilla/5.0 (Macintosh; Intel Mac OS X 14.7; rv:132.0) Gecko/20100101 Firefox/132.0",
-    // macOS - Opera
-    "Mozilla/5.0 (Macintosh; Intel Mac OS X 14_4_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36 OPR/109.0.0.0",
-    // Linux - Chrome
-    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36",
-    // Linux - Firefox
-    "Mozilla/5.0 (X11; Linux i686; rv:124.0) Gecko/20100101 Firefox/124.0",
-];
-
-// 全局变量
-let COOKIE_NUM = 0;
-let COOKIE_LIST = [];
-let LAST_COOKIE_INDEX = {};
-let TEMPORARY_MODE = false;
-
-// 验证Cookie是否有效
-async function validateCookie(session) {
-    try {
-        const testUrl = "https://grok.com/rest/user/me";
-        const response = await axios.get(testUrl, {
-            headers: session.headers,
-            timeout: 5000
-        });
-        return response.status === 200;
-    } catch (error) {
-        console.log(`Cookie验证失败: ${error.message}`);
-        return false;
-    }
-}
-
-// 配置解析
-async function resolveConfig() {
-    COOKIE_LIST = [];
-    let cookieIndex = 1;
-    let validCookies = 0;
-    let invalidCookies = 0;
-    
-    while (true) {
-        const cookieEnvName = `GROK_COOKIE_${cookieIndex}`;
-        const cookieString = process.env[cookieEnvName];
-        
-        if (!cookieString) break;
-        
-        const session = {
-            headers: {
-                'user-agent': USER_AGENTS[Math.floor(Math.random() * USER_AGENTS.length)],
-                'cookie': cookieString
-            }
-        };
-        
-        // 验证cookie是否有效
-        if (await validateCookie(session)) {
-            COOKIE_LIST.push(session);
-            validCookies++;
-            console.log(`Cookie ${cookieIndex} 验证通过`);
-        } else {
-            invalidCookies++;
-            console.log(`警告: Cookie ${cookieIndex} 无效，已跳过`);
-        }
-        
-        cookieIndex++;
-    }
-
-    COOKIE_NUM = COOKIE_LIST.length;
-    if (COOKIE_NUM === 0) {
-        throw new Error("未提供有效的Grok cookies，请通过环境变量设置 (GROK_COOKIE_1, GROK_COOKIE_2, ...)");
-    }
-
-    const temporaryModeStr = (process.env.GROK_TEMPORARY_MODE || 'false').toLowerCase();
-    TEMPORARY_MODE = temporaryModeStr === 'true' || temporaryModeStr === '1';
-    
-    LAST_COOKIE_INDEX = {};
-    MODELS.forEach(model => {
-        LAST_COOKIE_INDEX[model] = 0;
-    });
-
-    console.log(`已从环境变量加载 ${COOKIE_NUM} 个有效Grok cookies，跳过 ${invalidCookies} 个无效cookies。`);
-    console.log(`临时模式: ${TEMPORARY_MODE}`);
-}
-
-// 定期验证所有Cookie
-async function periodicCookieValidation() {
-    const validCookies = [];
-    
-    console.log("开始定期Cookie验证...");
-    for (let i = 0; i < COOKIE_LIST.length; i++) {
-        const session = COOKIE_LIST[i];
-        if (await validateCookie(session)) {
-            validCookies.push(session);
-            console.log(`Cookie ${i+1} 仍然有效`);
-        } else {
-            console.log(`警告: Cookie ${i+1} 已失效，将被移除`);
-        }
-    }
-    
-    const originalCount = COOKIE_NUM;
-    COOKIE_LIST = validCookies;
-    COOKIE_NUM = validCookies.length;
-    
-    console.log(`Cookie验证完成: ${COOKIE_NUM}/${originalCount} 有效`);
-    if (COOKIE_NUM === 0) {
-        console.log("严重警告: 所有Cookie均已失效!");
-    }
-    
-    // 更新模型的最后使用索引，确保它们不会超出范围
-    MODELS.forEach(model => {
-        if (COOKIE_NUM > 0) {
-            LAST_COOKIE_INDEX[model] = LAST_COOKIE_INDEX[model] % COOKIE_NUM;
-        }
-    });
-    
-    // 10分钟后再次验证
-    setTimeout(periodicCookieValidation, 10 * 60 * 1000);
-}
-
-// 获取下一个账户
-function getNextAccount(model) {
-    if (COOKIE_NUM === 0) {
-        throw new Error("没有可用的有效Cookie");
-    }
-    
-    const current = (LAST_COOKIE_INDEX[model] + 1) % COOKIE_NUM;
-    LAST_COOKIE_INDEX[model] = current;
-    console.log(`Using account ${current+1}/${COOKIE_NUM} for ${model}`);
-    return COOKIE_LIST[current];
-}
-
-// 处理消息格式化
-function formatMessage(messages) {
-    let result = '';
-    const { roleMap, prefix, processedMessages } = extractRole(messages);
-    
-    for (const message of processedMessages) {
-        const role = message.role;
-        const displayRole = prefix ? '\b' + roleMap[role] : roleMap[role];
-        const content = message.content.replace(/\\n/g, '\n');
-        
-        if (/^<\|removeRole\|>\n/.test(content)) {
-            result += content.replace(/^<\|removeRole\|>\n/, '') + '\n';
-        } else {
-            result += `${displayRole}: ${content}\n`;
-        }
-    }
-    
-    return result;
-}
-
-// 提取角色信息
-function extractRole(messages) {
-    let roleMap = { "user": "Human", "assistant": "Assistant", "system": "System" };
-    let prefix = false;
-    const firstMessage = messages[0].content;
-    
-    const pattern = /<roleInfo>\s*user:\s*([^\n]*)\s*assistant:\s*([^\n]*)\s*system:\s*([^\n]*)\s*prefix:\s*([^\n]*)\s*<\/roleInfo>\n/;
-    const match = pattern.exec(firstMessage);
-    
-    if (match) {
-        roleMap = {
-            "user": match[1],
-            "assistant": match[2], 
-            "system": match[3]
-        };
-        prefix = match[4] === '1';
-        
-        messages[0].content = firstMessage.replace(pattern, '');
-        console.log(`Extracted role map:`);
-        console.log(`User: ${roleMap.user},  ${roleMap.assistant}, System: ${roleMap.system}`);
-        console.log(`Using prefix: ${prefix}`);
-    }
-    
-    return { roleMap, prefix, processedMessages: messages };
-}
-
-// 处理特殊指令
-function magic(messages) {
-    let firstMessage = messages[0].content;
-    let disableSearch = false;
-    let forceConcise = false;
-    
-    if (/<\|disableSearch\|>/.test(firstMessage)) {
-        disableSearch = true;
-        console.log("Disable search");
-        firstMessage = firstMessage.replace(/<\|disableSearch\|>/g, '');
-    }
-    
-    if (/<\|forceConcise\|>/.test(firstMessage)) {
-        forceConcise = true;
-        console.log("Force concise");
-        firstMessage = firstMessage.replace(/<\|forceConcise\|>/g, '');
-    }
-    
-    messages[0].content = firstMessage;
-    return { disableSearch, forceConcise, messages };
-}
-
-// 路由定义
-app.get('/', (req, res) => {
-    res.set('Content-Type', 'text/plain').status(200).send('Grok Proxy is running');
-});
-
-app.get('/health', (req, res) => {
-    res.set('Content-Type', 'text/plain').status(200).send('OK');
-});
-
-app.get('/cookie-status', (req, res) => {
-    // 授权检查
-    const authKey = req.query.auth_key;
-    if (!authKey || authKey !== process.env.STATUS_AUTH_KEY) {
-        return res.status(401).json({ error: "未授权" });
-    }
-    
-    // 准备验证所有Cookie
-    const cookieStatus = COOKIE_LIST.map((session, i) => ({
-        index: i + 1,
-        valid: true // 这是一个实时检查的简化版本
-    }));
-    
-    res.json({
-        total_cookies: COOKIE_NUM,
-        valid_cookies: COOKIE_NUM, // 假设所有列出的cookie都有效
-        cookies: cookieStatus,
-        temporary_mode: TEMPORARY_MODE
-    });
-});
-
-app.get('/v1/models', (req, res) => {
-    const modelList = MODELS.map(model => ({
-        id: model,
-        object: "model",
-        created: Math.floor(Date.now() / 1000),
-        owned_by: "Elbert",
-        name: model
-    }));
-    
-    res.json({
-        object: "list",
-        data: modelList
-    });
-});
-
-app.post('/v1/chat/completions', async (req, res) => {
-    // 检查是否有有效的Cookie
-    if (COOKIE_NUM === 0) {
-        return res.status(503).json({ error: "没有可用的有效Cookie" });
-    }
-    
-    console.log("Received request");
-    console.log(req.body);
-    
-    const stream = req.body.stream || false;
-    const messages = req.body.messages;
-    const model = req.body.model;
-    
-    if (!MODELS.includes(model)) {
-        return res.status(500).json({ error: "Model not available" });
-    }
-    
-    if (!messages) {
-        return res.status(400).json({ error: "Messages is required" });
-    }
-    
-    const { disableSearch, forceConcise, messages: processedMessages } = magic(messages);
-    const formattedMessage = formatMessage(processedMessages);
-    const isReasoning = model.length > 6;
-    const baseModel = model.substring(0, 6);
-    
-    if (stream) {
-        return await sendMessageStream(req, res, formattedMessage, baseModel, disableSearch, forceConcise, isReasoning);
-    } else {
-        return await sendMessageNonStream(req, res, formattedMessage, baseModel, disableSearch, forceConcise, isReasoning);
-    }
-});
-
-// 流式发送消息
-async function sendMessageStream(req, res, message, model, disableSearch, forceConcise, isReasoning) {
-    const headers = {
-        "authority": "grok.com",
-        "method": "POST",
-        "path": "/rest/app-chat/conversations/new",
-        "scheme": "https",
-        "accept": "*/*",
-        "accept-encoding": "gzip, deflate, br, zstd",
-        "accept-language": "zh-CN,zh;q=0.9,en;q=0.8",
-        "cache-control": "no-cache",
-        "content-type": "application/json",
-        "origin": "https://grok.com",
-        "pragma": "no-cache",
-        "priority": "u=1, i",
-        "referer": "https://grok.com/",
-        "sec-ch-ua": '"Not(A:Brand";v="99", "Google Chrome";v="133", "Chromium";v="133"',
-        "sec-ch-ua-mobile": "?0",
-        "sec-ch-ua-platform": '"Windows"',
-        "sec-fetch-dest": "empty",
-        "sec-fetch-mode": "cors",
-        "sec-fetch-site": "same-origin",
-    };
-    
-    const payload = {
-        "temporary": TEMPORARY_MODE,
-        "modelName": "grok-3",
-        "message": message,
-        "fileAttachments": [],
-        "imageAttachments": [],
-        "disableSearch": disableSearch,
-        "enableImageGeneration": false,
-        "returnImageBytes": false,
-        "returnRawGrokInXaiRequest": false,
-        "enableImageStreaming": true,
-        "imageGenerationCount": 2,
-        "forceConcise": forceConcise,
-        "toolOverrides": {},
-        "enableSideBySide": true,
-        "isPreset": false,
-        "sendFinalMetadata": true,
-        "customInstructions": "",
-        "deepsearchPreset": "",
-        "isReasoning": isReasoning,
-    };
-    
-    try {
-        const session = getNextAccount(model);
-        
-        res.setHeader('Content-Type', 'text/event-stream');
-        res.setHeader('Cache-Control', 'no-cache');
-        res.setHeader('Connection', 'keep-alive');
-        
-        const response = await axios.post(TARGET_URL, payload, {
-            headers: {...headers, ...session.headers},
-            responseType: 'stream'
-        });
-        
-        console.log("---------- Response ----------");
-        let cnt = 2;
-        let thinking = 2;
-        
-        response.data.on('data', chunk => {
-            const lines = chunk.toString().trim().split('\n');
-            for (const line of lines) {
-                if (!line) continue;
-                
-                if (cnt !== 0) {
-                    cnt--;
-                } else {
-                    try {
-                        const data = JSON.parse(line);
-                        const token = data.result.response.token;
-                        let content = "";
-                        
-                        if (isReasoning) {
-                            if (thinking === 2) {
-                                thinking = 1;
-                                content = `<Thinking>\n${token}`;
-                                process.stdout.write(content);
-                            } else if (thinking && !data.result.response.isThinking) {
-                                thinking = 0;
-                                content = `\n</Thinking>\n${token}`;
-                                process.stdout.write(content);
-                            } else {
-                                content = token;
-                                process.stdout.write(content);
-                            }
-                        } else {
-                            content = token;
-                            process.stdout.write(content);
-                        }
-                        
-                        const openaiChunk = {
-                            id: "chatcmpl-" + uuidv4(),
-                            object: "chat.completion.chunk",
-                            created: Math.floor(Date.now() / 1000),
-                            model: model,
-                            choices: [
-                                {
-                                    index: 0,
-                                    delta: { content },
-                                    finish_reason: null
-                                }
-                            ]
-                        };
-                        
-                        res.write(`data: ${JSON.stringify(openaiChunk)}\n\n`);
-                        
-                        if (data.result.response.isSoftStop) {
-                            const finalChunk = {
-                                id: "chatcmpl-" + uuidv4(),
-                                object: "chat.completion.chunk",
-                                created: Math.floor(Date.now() / 1000),
-                                model: model,
-                                choices: [
-                                    {
-                                        index: 0,
-                                        delta: { content },
-                                        finish_reason: "completed"
-                                    }
-                                ]
-                            };
-                            res.write(`data: ${JSON.stringify(finalChunk)}\n\n`);
-                            break;
-                        }
-                    } catch (error) {
-                        console.error("Error parsing chunk:", error);
-                    }
-                }
-            }
-        });
-        
-        response.data.on('end', () => {
-            console.log("\n---------- Response End ----------");
-            res.write(`data: [DONE]\n\n`);
-            res.end();
-        });
-        
-        response.data.on('error', error => {
-            console.error("Stream error:", error);
-            res.write(`data: {"error": "${error.message}"}\n\n`);
-            res.end();
-        });
-        
-    } catch (error) {
-        console.error(`Failed to send message: ${error.message}`);
-        
-        // 如果是Cookie失效造成的错误
-        if (error.response && (error.response.status === 401 || error.response.status === 403)) {
-            console.log("可能Cookie已失效，将触发立即验证");
-            setTimeout(periodicCookieValidation, 0);
-        }
-        
-        if (!res.headersSent) {
-            if (error.message === "没有可用的有效Cookie") {
-                return res.status(503).json({ error: error.message });
-            }
-            return res.status(500).json({ error: "Failed to send message" });
-        }
-    }
-}
-
-// 非流式发送消息
-async function sendMessageNonStream(req, res, message, model, disableSearch, forceConcise, isReasoning) {
-    const headers = {
-        "authority": "grok.com",
-        "method": "POST",
-        "path": "/rest/app-chat/conversations/new",
-        "scheme": "https",
-        "accept": "*/*",
-        "accept-encoding": "gzip, deflate, br, zstd",
-        "accept-language": "zh-CN,zh;q=0.9,en;q=0.8",
-        "cache-control": "no-cache",
-        "content-type": "application/json",
-        "origin": "https://grok.com",
-        "pragma": "no-cache",
-        "priority": "u=1, i",
-        "referer": "https://grok.com/",
-        "sec-ch-ua": '"Not(A:Brand";v="99", "Google Chrome";v="133", "Chromium";v="133"',
-        "sec-ch-ua-mobile": "?0",
-        "sec-ch-ua-platform": '"Windows"',
-        "sec-fetch-dest": "empty",
-        "sec-fetch-mode": "cors",
-        "sec-fetch-site": "same-origin",
-    };
-    
-    const payload = {
-        "temporary": TEMPORARY_MODE,
-        "modelName": "grok-3",
-        "message": message,
-        "fileAttachments": [],
-        "imageAttachments": [],
-        "disableSearch": disableSearch,
-        "enableImageGeneration": false,
-        "returnImageBytes": false,
-        "returnRawGrokInXaiRequest": false,
-        "enableImageStreaming": true,
-        "imageGenerationCount": 2,
-        "forceConcise": forceConcise,
-        "toolOverrides": {},
-        "enableSideBySide": true,
-        "isPreset": false,
-        "sendFinalMetadata": true,
-        "customInstructions": "",
-        "deepsearchPreset": "",
-        "isReasoning": isReasoning,
-    };
-    
-    try {
-        const session = getNextAccount(model);
-        const chunks = [];
-        let thinking = 2;
-        let buffer = '';
-        
-        const response = await axios.post(TARGET_URL, payload, {
-            headers: {...headers, ...session.headers},
-            responseType: 'stream'
-        });
-        
-        console.log("---------- Response ----------");
-        let cnt = 2;
-        
-        return new Promise((resolve, reject) => {
-            response.data.on('data', chunk => {
-                chunks.push(chunk);
-                const lines = chunk.toString().trim().split('\n');
-                
-                for (const line of lines) {
-                    if (!line) continue;
-                    
-                    if (cnt !== 0) {
-                        cnt--;
-                    } else {
-                        try {
-                            const data = JSON.parse(line);
-                            const token = data.result.response.token;
-                            let content = "";
-                            
-                            if (isReasoning) {
-                                if (thinking === 2) {
-                                    thinking = 1;
-                                    content = `<Thinking>\n${token}`;
-                                    process.stdout.write(content);
-                                    buffer += content;
-                                } else if (thinking && !data.result.response.isThinking) {
-                                    thinking = 0;
-                                    content = `\n</Thinking>\n${token}`;
-                                    process.stdout.write(content);
-                                    buffer += content;
-                                } else {
-                                    content = token;
-                                    process.stdout.write(content);
-                                    buffer += content;
-                                }
-                            } else {
-                                content = token;
-                                process.stdout.write(content);
-                                buffer += content;
-                            }
-                            
-                            if (data.result.response.isSoftStop) {
-                                break;
-                            }
-                        } catch (error) {
-                            console.error("Error parsing chunk:", error);
-                        }
-                    }
-                }
-            });
-            
-            response.data.on('end', () => {
-                console.log("\n---------- Response End ----------");
-                const openaiResponse = {
-                    id: "chatcmpl-" + uuidv4(),
-                    object: "chat.completion",
-                    created: Math.floor(Date.now() / 1000),
-                    model: model,
-                    choices: [
-                        {
-                            index: 0,
-                            message: { role: "assistant", content: buffer },
-                            finish_reason: "completed"
-                        }
-                    ]
-                };
-                res.json(openaiResponse);
-                resolve();
-            });
-            
-            response.data.on('error', error => {
-                console.error("Stream error:", error);
-                reject(error);
-            });
-        });
-        
-    } catch (error) {
-        console.error(`Failed to send message: ${error.message}`);
-        
-        // 如果是Cookie失效造成的错误
-        if (error.response && (error.response.status === 401 || error.response.status === 403)) {
-            console.log("可能Cookie已失效，将触发立即验证");
-            setTimeout(periodicCookieValidation, 0);
-        }
-        
-        if (error.message === "没有可用的有效Cookie") {
-            return res.status(503).json({ error: error.message });
-        }
-        return res.status(500).json({ error: "Failed to send message" });
-    }
-}
-
-// 初始化并启动服务器
-async function startServer() {
-    try {
-        await resolveConfig();
-        
-        // 启动定期Cookie验证（10分钟后首次验证）
-        setTimeout(periodicCookieValidation, 10 * 60 * 1000);
-        
-        app.listen(PORT, () => {
-            console.log(`===== Application Startup at ${new Date().toISOString()} =====`);
-            console.log(`Server is running on port ${PORT}`);
-        });
-    } catch (error) {
-        console.error(`启动失败: ${error.message}`);
-        process.exit(1);
-    }
-}
-
-startServer();

app.py

@@ -0,0 +1,477 @@
+from flask import Flask, request, jsonify, Response
+import cloudscraper  # 替换requests库，专门用于绕过Cloudflare保护
+import io
+import json
+import re
+import uuid
+import random
+import time
+import os
+
+app = Flask(__name__)
+
+TARGET_URL = "https://grok.com/rest/app-chat/conversations/new"
+MODELS = ["grok-2", "grok-3", "grok-3-thinking"]
+COOKIE_NUM = 0
+COOKIE_LIST = []
+LAST_COOKIE_INDEX = {}
+TEMPORARY_MODE = False
+
+USER_AGENTS = [
+    # Windows - Chrome
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36",
+    # Windows - Firefox
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:132.0) Gecko/20100101 Firefox/132.0",
+    # Windows - Edge
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36 Edg/123.0.2420.81",
+    # Windows - Opera
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36 OPR/109.0.0.0",
+    # macOS - Chrome
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36",
+    # macOS - Safari
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0.1 Safari/605.1.15",
+    # macOS - Firefox
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 14.7; rv:132.0) Gecko/20100101 Firefox/132.0",
+    # macOS - Opera
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 14_4_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36 OPR/109.0.0.0",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 14.4; rv:124.0) Gecko/20100101 Firefox/124.0",
+    # Linux - Chrome
+    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36",
+    # Linux - Firefox
+    "Mozilla/5.0 (X11; Linux i686; rv:124.0) Gecko/20100101 Firefox/124.0",
+]
+
+def create_cf_scraper(cookie_string):
+    """创建一个配置好的cloudscraper实例"""
+    browser = random.choice(['chrome', 'firefox', 'edge'])
+    platform = random.choice(['windows', 'darwin', 'linux'])
+    
+    # 创建cloudscraper会话
+    scraper = cloudscraper.create_scraper(
+        browser={
+            'browser': browser,
+            'platform': platform,
+            'desktop': True
+        },
+        delay=random.uniform(5, 10),  # 等待Cloudflare检查
+        interpreter='js2py',  # 使用js2py解释JavaScript挑战
+    )
+    
+    # 设置自定义用户代理
+    selected_ua = random.choice(USER_AGENTS)
+    
+    # 设置基本头信息
+    scraper.headers.update({
+        "user-agent": selected_ua,
+        "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
+        "accept-language": "en-US,en;q=0.5",
+        "accept-encoding": "gzip, deflate, br",
+        "dnt": "1",
+        "sec-fetch-dest": "document",
+        "sec-fetch-mode": "navigate",
+        "sec-fetch-site": "none",
+        "sec-fetch-user": "?1",
+        "upgrade-insecure-requests": "1",
+        "cookie": cookie_string
+    })
+    
+    return scraper
+
+def resolve_config():
+    global COOKIE_NUM, COOKIE_LIST, LAST_COOKIE_INDEX, TEMPORARY_MODE
+    COOKIE_LIST = []
+    cookie_index = 1
+    
+    while True:
+        cookie_env_name = f"GROK_COOKIE_{cookie_index}"
+        cookie_string = os.environ.get(cookie_env_name)
+        if cookie_string:
+            try:
+                print(f"创建Cookie {cookie_index} 的CloudScraper实例...")
+                scraper = create_cf_scraper(cookie_string)
+                COOKIE_LIST.append(scraper)
+                cookie_index += 1
+            except Exception as e:
+                print(f"为Cookie {cookie_index} 创建CloudScraper失败: {e}")
+                cookie_index += 1
+        else:
+            break
+
+    COOKIE_NUM = len(COOKIE_LIST)
+    if COOKIE_NUM == 0:
+        raise ValueError("未提供Grok cookies，请通过环境变量设置 (GROK_COOKIE_1, GROK_COOKIE_2, ...)")
+
+    temporary_mode_str = os.environ.get("GROK_TEMPORARY_MODE", "false").lower()
+    TEMPORARY_MODE = temporary_mode_str == "true" or temporary_mode_str == "1"
+
+    LAST_COOKIE_INDEX = {model: 0 for model in MODELS}
+
+    print(f"已从环境变量加载 {COOKIE_NUM} 个Grok cookies。")
+    print(f"临时模式: {TEMPORARY_MODE}")
+
+
+@app.route("/", methods=["GET"])
+def root():
+    return "Grok Proxy is running (Cloudflare Protected)", 200, {'Content-Type': 'text/plain'}
+
+
+@app.route("/health", methods=["GET"])
+def health_check():
+    return "OK", 200, {'Content-Type': 'text/plain'}
+
+
+@app.route("/v1/models", methods=["GET"])
+def get_models():
+    model_list = []
+    for model in MODELS:
+        model_list.append(
+            {
+                "id": model,
+                "object": "model",
+                "created": int(time.time()),
+                "owned_by": "Elbert",
+                "name": model,
+            }
+        )
+    return jsonify({"object": "list", "data": model_list})
+
+
+@app.route("/v1/chat/completions", methods=["POST"])
+def chat_completions():
+    print("Received request")
+    openai_request = request.get_json()
+    print(openai_request)
+    stream = openai_request.get("stream", False)
+    messages = openai_request.get("messages")
+    model = openai_request.get("model")
+    if model not in MODELS:
+        return jsonify({"error": "Model not available"}), 500
+    if messages is None:
+        return jsonify({"error": "Messages is required"}), 400
+    disable_search, force_concise, messages = magic(messages)
+    message = format_message(messages)
+    is_reasoning = len(model) > 6
+    model = model[0:6]
+    return (
+        send_message(message, model, disable_search, force_concise, is_reasoning)
+        if stream
+        else send_message_non_stream(
+            message, model, disable_search, force_concise, is_reasoning)
+    )
+
+
+def get_next_account(model):
+    current = (LAST_COOKIE_INDEX[model] + 1) % COOKIE_NUM
+    LAST_COOKIE_INDEX[model] = current
+    print(f"Using account {current+1}/{COOKIE_NUM} for {model}")
+    return COOKIE_LIST[current]
+
+
+def send_message(message, model, disable_search, force_concise, is_reasoning):
+    headers = {
+        "authority": "grok.com",
+        "accept": "*/*",
+        "accept-language": "zh-CN,zh;q=0.9,en;q=0.8",
+        "cache-control": "no-cache",
+        "content-type": "application/json",
+        "origin": "https://grok.com",
+        "pragma": "no-cache",
+        "referer": "https://grok.com/",
+        "sec-ch-ua": '"Not(A:Brand";v="99", "Google Chrome";v="133", "Chromium";v="133"',
+        "sec-ch-ua-mobile": "?0",
+        "sec-ch-ua-platform": '"Windows"',
+        "sec-fetch-dest": "empty",
+        "sec-fetch-mode": "cors",
+        "sec-fetch-site": "same-origin",
+    }
+    payload = {
+        "temporary": TEMPORARY_MODE,
+        "modelName": "grok-3",
+        "message": message,
+        "fileAttachments": [],
+        "imageAttachments": [],
+        "disableSearch": disable_search,
+        "enableImageGeneration": False,
+        "returnImageBytes": False,
+        "returnRawGrokInXaiRequest": False,
+        "enableImageStreaming": True,
+        "imageGenerationCount": 2,
+        "forceConcise": force_concise,
+        "toolOverrides": {},
+        "enableSideBySide": True,
+        "isPreset": False,
+        "sendFinalMetadata": True,
+        "customInstructions": "",
+        "deepsearchPreset": "",
+        "isReasoning": is_reasoning,
+    }
+    
+    try:
+        scraper = get_next_account(model)
+        
+        # 预热Cloudflare
+        print("预热Cloudflare权限...")
+        scraper.get("https://grok.com/", timeout=15)
+        time.sleep(random.uniform(1.0, 2.0))  # 随机等待以模拟人类
+        
+        print("发送消息请求...")
+        response = scraper.post(TARGET_URL, headers=headers, json=payload, stream=True)
+        response.raise_for_status()
+
+        def generate():
+            try:
+                print("---------- Response ----------")
+                cnt = 2
+                thinking = 2
+                for line in response.iter_lines():
+                    if line:
+                        if cnt != 0:
+                            cnt -= 1
+                        else:
+                            decoded_line = line.decode("utf-8")
+                            data = json.loads(decoded_line)
+                            token = data["result"]["response"]["token"]
+                            content = ""
+                            if is_reasoning:
+                                if thinking == 2:
+                                    thinking = 1
+                                    content = f"<Thinking>\n{token}"
+                                    print(f"{content}", end="")
+                                elif thinking & (
+                                    not data["result"]["response"]["isThinking"]
+                                ):
+                                    thinking = 0
+                                    content = f"\n</Thinking>\n{token}"
+                                    print(f"{content}", end="")
+                                else:
+                                    content = token
+                                    print(content, end="")
+                            else:
+                                content = token
+                                print(content, end="")
+                            openai_chunk = {
+                                "id": "chatcmpl-" + str(uuid.uuid4()),
+                                "object": "chat.completion.chunk",
+                                "created": int(time.time()),
+                                "model": model,
+                                "choices": [
+                                    {
+                                        "index": 0,
+                                        "delta": {"content": content},
+                                        "finish_reason": None,
+                                    }
+                                ],
+                            }
+                            yield f"data: {json.dumps(openai_chunk)}\n\n"
+                            if data["result"]["response"]["isSoftStop"]:
+                                openai_chunk = {
+                                    "id": "chatcmpl-" + str(uuid.uuid4()),
+                                    "object": "chat.completion.chunk",
+                                    "created": int(time.time()),
+                                    "model": model,
+                                    "choices": [
+                                        {
+                                            "index": 0,
+                                            "delta": {"content": content},
+                                            "finish_reason": "completed",
+                                        }
+                                    ],
+                                }
+                                yield f"data: {json.dumps(openai_chunk)}\n\n"
+                                break
+                print("\n---------- Response End ----------")
+                yield f"data: [DONE]\n\n"
+            except Exception as e:
+                print(f"Failed to send message: {e}")
+                yield f'data: {{"error": "{e}"}}\n\n'
+
+        return Response(generate(), content_type="text/event-stream")
+    except Exception as e:
+        print(f"Failed to send message: {e}")
+        return jsonify({"error": f"Failed to send message: {e}"}), 500
+
+
+def send_message_non_stream(
+    message, model, disable_search, force_concise, is_reasoning
+):
+    headers = {
+        "authority": "grok.com",
+        "accept": "*/*",
+        "accept-language": "zh-CN,zh;q=0.9,en;q=0.8",
+        "cache-control": "no-cache",
+        "content-type": "application/json",
+        "origin": "https://grok.com",
+        "pragma": "no-cache",
+        "referer": "https://grok.com/",
+        "sec-ch-ua": '"Not(A:Brand";v="99", "Google Chrome";v="133", "Chromium";v="133"',
+        "sec-ch-ua-mobile": "?0",
+        "sec-ch-ua-platform": '"Windows"',
+        "sec-fetch-dest": "empty",
+        "sec-fetch-mode": "cors",
+        "sec-fetch-site": "same-origin",
+    }
+    payload = {
+        "temporary": TEMPORARY_MODE,
+        "modelName": "grok-3",
+        "message": message,
+        "fileAttachments": [],
+        "imageAttachments": [],
+        "disableSearch": disable_search,
+        "enableImageGeneration": False,
+        "returnImageBytes": False,
+        "returnRawGrokInXaiRequest": False,
+        "enableImageStreaming": True,
+        "imageGenerationCount": 2,
+        "forceConcise": force_concise,
+        "toolOverrides": {},
+        "enableSideBySide": True,
+        "isPreset": False,
+        "sendFinalMetadata": True,
+        "customInstructions": "",
+        "deepsearchPreset": "",
+        "isReasoning": is_reasoning,
+    }
+    
+    thinking = 2
+    try:
+        scraper = get_next_account(model)
+        
+        # 预热Cloudflare
+        print("预热Cloudflare权限...")
+        scraper.get("https://grok.com/", timeout=15)
+        time.sleep(random.uniform(1.0, 2.0))  # 随机等待以模拟人类
+        
+        print("发送非流式消息请求...")
+        response = scraper.post(TARGET_URL, headers=headers, json=payload, stream=True)
+        response.raise_for_status()
+        cnt = 2
+        try:
+            print("---------- Response ----------")
+            buffer = io.StringIO()
+            for line in response.iter_lines():
+                if line:
+                    if cnt != 0:
+                        cnt -= 1
+                    else:
+                        decoded_line = line.decode("utf-8")
+                        data = json.loads(decoded_line)
+                        token = data["result"]["response"]["token"]
+                        content = ""
+                        if is_reasoning:
+                            if thinking == 2:
+                                thinking = 1
+                                content = f"<Thinking>\n{token}"
+                                print(f"{content}", end="")
+                                buffer.write(content)
+                            elif thinking & (
+                                not data["result"]["response"]["isThinking"]
+                            ):
+                                thinking = 0
+                                content = f"\n</Thinking>\n{token}"
+                                print(f"{content}", end="")
+                                buffer.write(content)
+                            else:
+                                content = token
+                                print(content, end="")
+                                buffer.write(content)
+                        else:
+                            content = token
+                            print(content, end="")
+                            buffer.write(content)
+                        if data["result"]["response"]["isSoftStop"]:
+                            break
+            print("\n---------- Response End ----------")
+            openai_response = {
+                "id": "chatcmpl-" + str(uuid.uuid4()),
+                "object": "chat.completion",
+                "created": int(time.time()),
+                "model": model,
+                "choices": [
+                    {
+                        "index": 0,
+                        "message": {"role": "assistant", "content": buffer.getvalue()},
+                        "finish_reason": "completed",
+                    }
+                ],
+            }
+            return jsonify(openai_response)
+        except Exception as e:
+            print(f"Failed to process response: {e}")
+            return jsonify({"error": f"Failed to process response: {e}"}), 500
+    except Exception as e:
+        print(f"Failed to send message: {e}")
+        return jsonify({"error": f"Failed to send message: {e}"}), 500
+
+
+def format_message(messages):
+    buffer = io.StringIO()
+    role_map, prefix, messages = extract_role(messages)
+    for message in messages:
+        role = message.get("role")
+        role = "\b" + role_map[role] if prefix else role_map[role]
+        content = message.get("content").replace("\\n", "\n")
+        pattern = re.compile(r"<\|removeRole\|>\n")
+        if pattern.match(content):
+            content = pattern.sub("", content)
+            buffer.write(f"{content}\n")
+        else:
+            buffer.write(f"{role}: {content}\n")
+    return buffer.getvalue()
+
+
+def extract_role(messages):
+    role_map = {"user": "Human", "assistant": "Assistant", "system": "System"}
+    prefix = False
+    first_message = messages[0]["content"]
+    pattern = re.compile(
+        r"""
+        <roleInfo>\s*
+        user:\s*(?P<user>[^\n]*)\s*
+        assistant:\s*(?P<assistant>[^\n]*)\s*
+        system:\s*(?P<system>[^\n]*)\s*
+        prefix:\s*(?P<prefix>[^\n]*)\s*
+        </roleInfo>\n
+        """,
+        re.VERBOSE,
+    )
+    match = pattern.search(first_message)
+    if match:
+        role_map = {
+            "user": match.group("user"),
+            "assistant": match.group("assistant"),
+            "system": match.group("system"),
+        }
+        prefix = match.group("prefix") == "1"
+        messages[0]["content"] = pattern.sub("", first_message)
+        print(f"Extracted role map:")
+        print(
+            f"User: {role_map['user']},  {role_map['assistant']}, System: {role_map['system']}"
+        )
+        print(f"Using prefix: {prefix}")
+    return (role_map, prefix, messages)
+
+
+def magic(messages):
+    first_message = messages[0]["content"]
+    disable_search = False
+    if re.search(r"<\|disableSearch\|>", first_message):
+        disable_search = True
+        print("Disable search")
+        first_message = re.sub(r"<\|disableSearch\|>", "", first_message)
+    force_concise = False
+    if re.search(r"<\|forceConcise\|>", first_message):
+        force_concise = True
+        print("Force concise")
+        first_message = re.sub(r"<\|forceConcise\|>", "", first_message)
+    messages[0]["content"] = first_message
+    return (disable_search, force_concise, messages)
+
+
+# 初始化配置
+resolve_config()
+
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", port=7860)
+