Initial project commit with gitignore

.gitignore

@@ -0,0 +1,19 @@
+# Python
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+venv/
+.venv/
+
+# Editors/IDEs
+.vscode/
+.idea/
+
+# Temporary files
+*.log
+*.tmp
+*.swp
+
+# Hugging Face Space nested directory (if it exists locally)
+g2api-test/

Dockerfile

@@ -0,0 +1,19 @@
+# 使用官方 Python 镜像作为基础镜像
+FROM python:3.9-slim
+
+# 设置工作目录
+WORKDIR /app
+
+# 复制 requirements.txt 并安装依赖
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# 复制项目所有文件到工作目录
+COPY . .
+
+# 暴露 Flask 应用运行的端口
+EXPOSE 5000
+
+# 定义启动命令
+# 使用 gunicorn 运行 Flask 应用，适配 Hugging Face Spaces
+CMD ["gunicorn", "app:app", "-b", "0.0.0.0:5000"]

README.md

@@ -0,0 +1,102 @@
+# Grok API 逆向封装与改造项目
+
+## 项目简介
+
+本项目旨在将现有的 Grok 网页版逆向封装为 API 的 Python Flask 程序进行全面改造。改造目标是构建一个结构专业、功能完善（包含 Web UI）、文档齐全且易于部署的应用。项目严格遵守内存数据模式，所有运行时数据仅存储在内存中，不进行本地持久化。
+
+## 功能列表
+
+- **Grok API 封装:** 提供稳定可靠的 API 接口，用于访问 Grok 的核心功能。
+- **Web UI 系统状态展示:** 提供一个直观的 Web 界面，展示应用程序的当前运行状态和关键信息（此功能正在开发中）。
+- **模块化代码结构:** 代码按照功能和职责进行拆分，提高了可维护性和可读性。
+- **Hugging Face Spaces Docker 部署支持:** 提供 Dockerfile 和相关配置，方便在 Hugging Face Spaces 等支持 Docker 的平台上进行快速部署。
+
+## 安装部署
+
+本项目支持使用 Docker 在 Hugging Face Spaces 上进行部署。
+
+### 前提条件
+
+- 已安装 Docker。
+- 已安装 Python 3.8 或更高版本。
+- 拥有 Hugging Face 账号。
+
+### 本地运行 (使用 Docker)
+
+1. 克隆项目仓库：
+   ```bash
+   git clone <你的仓库地址>
+   cd <项目目录>
+   ```
+2. 构建 Docker 镜像：
+   ```bash
+   docker build -t grok-api-remodel .
+   ```
+3. 运行 Docker 容器：
+   ```bash
+   docker run -p 5000:5000 grok-api-remodel
+   ```
+   应用程序将在本地的 5000 端口运行。
+
+### 部署到 Hugging Face Spaces (使用 Docker)
+
+1. 在 Hugging Face Spaces 上创建一个新的 Space。
+2. 选择 Docker 作为 Space SDK。
+3. 将本项目仓库关联到你的 Hugging Face Space。
+4. Hugging Face Spaces 将会自动检测项目根目录下的 `Dockerfile` 并进行构建和部署。确保你的 `Dockerfile` 配置正确，暴露了 Flask 应用运行的端口（默认为 5000）。
+
+## 配置说明
+
+本项目的部分配置通过环境变量进行管理。
+
+- `YOUR_API_KEY`: 用于认证或访问外部服务的 API 密钥（如果需要）。
+- `LISTEN_PORT`: 应用程序监听的端口（默认为 5000）。
+
+请根据你的部署环境设置相应的环境变量。在 Hugging Face Spaces 上，可以在 Space 的设置页面配置环境变量。
+
+## API 使用指南
+
+项目的 API 接口提供了对 Grok 功能的访问。详细的 API 文档（包括可用端点、请求方法、参数和响应格式）将在后续提供。
+
+通常，你可以通过向部署后的应用程序 URL 发送 HTTP 请求来使用 API。例如：
+
+```bash
+curl -X POST <部署后的应用URL>/api/<端点> \
+-H "Content-Type: application/json" \
+-d '{"key": "value"}'
+```
+
+请参考后续提供的详细 API 文档以获取准确的使用方法。
+
+## Web UI 使用说明
+
+项目的 Web UI 提供了一个界面来监控应用程序的状态。部署成功后，直接访问应用程序的根 URL 即可访问 Web UI。
+
+例如：`<部署后的应用URL>/`
+
+Web UI 将展示包括但不限于：
+- 应用程序启动时间
+- 当前内存使用情况
+- API 请求统计（如果实现）
+- 其他系统健康指标
+
+## 注意事项
+
+- **内存数据模式:** 本项目设计为仅使用内存存储数据。这意味着应用程序重启后，所有运行时数据将丢失。请勿依赖本项目进行数据持久化。
+- **速率限制:** 底层 Grok API 可能存在速率限制。本项目目前可能未实现复杂的速率限制处理。在使用 API 时，请注意 Grok 自身的速率限制，避免因请求频率过高导致服务不可用。
+- **安全性:** 在生产环境部署时，请务必采取适当的安全措施，例如使用 HTTPS、API 密钥管理等。
+
+## 项目阶段
+
+本项目正在逐步开发中，遵循以下阶段计划：
+
+- **阶段 1:** 规划与设计 (已完成)
+- **阶段 2:** 核心功能实现 (已完成)
+- **阶段 3:** 文档与部署 (当前阶段)
+    - 3.1 编写 README.md 文档 (当前任务)
+    - 3.2 准备 Docker 部署配置
+    - 3.3 编写详细部署文档
+- **阶段 4:** Web UI 完善与优化
+- **阶段 5:** 测试与发布
+
+感谢你的关注和支持！

app.py

@@ -0,0 +1,413 @@
+import os
+import json
+import uuid
+import time
+import base64
+import sys
+import inspect
+import secrets
+from dotenv import load_dotenv
+import requests
+from flask import Flask, request, Response, jsonify, stream_with_context, render_template, redirect, session
+from curl_cffi import requests as curl_requests
+from werkzeug.middleware.proxy_fix import ProxyFix
+
+from src.core.logger import logger # 从新的位置导入 logger
+
+current_dir = os.path.dirname(os.path.abspath(__file__))
+env_path = os.path.join(current_dir, '.env')
+load_dotenv(env_path)
+
+CONFIG = {
+    "MODELS": {
+        'grok-2': 'grok-latest',
+        'grok-2-imageGen': 'grok-latest',
+        'grok-2-search': 'grok-latest',
+        "grok-3": "grok-3",
+        "grok-3-search": "grok-3",
+        "grok-3-imageGen": "grok-3",
+        "grok-3-deepsearch": "grok-3",
+        "grok-3-reasoning": "grok-3"
+    },
+    "API": {
+        "IS_TEMP_CONVERSATION": os.getenv("IS_TEMP_CONVERSATION", "true").lower() == "true",
+        "IS_CUSTOM_SSO": os.getenv("IS_CUSTOM_SSO", "false").lower() == "true",
+        "BASE_URL": "https://grok.com",
+        "API_KEY": os.getenv("API_KEY", "sk-123456"),
+        "SIGNATURE_COOKIE": None,
+        "PICGO_KEY": os.getenv("PICGO_KEY") or None,
+        "TUMY_KEY": os.getenv("TUMY_KEY") or None,
+        "RETRY_TIME": 1000,
+        "PROXY": os.getenv("PROXY") or None
+    },
+    "ADMIN": {
+        "MANAGER_SWITCH": os.getenv("MANAGER_SWITCH") or None,
+        "PASSWORD": os.getenv("ADMINPASSWORD") or None
+    },
+    "SERVER": {
+        "COOKIE": None,
+        "CF_CLEARANCE":os.getenv("CF_CLEARANCE") or None,
+        "PORT": int(os.getenv("PORT", 5200))
+    },
+    "RETRY": {
+        "RETRYSWITCH": False,
+        "MAX_ATTEMPTS": 2
+    },
+    "SHOW_THINKING": os.getenv("SHOW_THINKING") == "true",
+    "IS_THINKING": False,
+    "IS_IMG_GEN": False,
+    "IS_IMG_GEN2": False,
+    "ISSHOW_SEARCH_RESULTS": os.getenv("ISSHOW_SEARCH_RESULTS", "true").lower() == "true"
+}
+
+DEFAULT_HEADERS = {
+    'Accept': '*/*',
+    'Accept-Language': 'zh-CN,zh;q=0.9',
+    'Accept-Encoding': 'gzip, deflate, br, zstd',
+    'Content-Type': 'text/plain;charset=UTF-8',
+    'Connection': 'keep-alive',
+    'Origin': 'https://grok.com',
+    'Priority': 'u=1, i',
+    'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36',
+    'Sec-Ch-Ua': '"Not(A:Brand";v="99", "Google Chrome";v="133", "Chromium";v="133"',
+    'Sec-Ch-Ua-Mobile': '?0',
+    'Sec-Ch-Ua-Platform': '"macOS"',
+    'Sec-Fetch-Dest': 'empty',
+    'Sec-Fetch-Mode': 'cors',
+    'Sec-Fetch-Site': 'same-origin',
+    'Baggage': 'sentry-public_key=b311e0f2690c81f25e2c4cf6d4f7ce1c'
+}
+
+from src.core.auth_token_manager import AuthTokenManager # 从新的位置导入 AuthTokenManager
+
+
+from src.core.utils import Utils # 从新的位置导入 Utils
+
+
+from src.core.grok_api_client import GrokApiClient # 从新的位置导入 GrokApiClient
+
+
+from src.core.message_processor import MessageProcessor # 从新的位置导入 MessageProcessor
+
+
+def initialization():
+    sso_array = os.getenv("SSO", "").split(',')
+    logger.info("开始加载令牌", "Server")
+    for sso in sso_array:
+        if sso:
+            token_manager.add_token(f"sso-rw={sso};sso={sso}")
+    logger.info(f"成功加载令牌: {json.dumps(token_manager.get_all_tokens(), indent=2)}", "Server")
+    logger.info(f"令牌加载完成，共加载: {len(token_manager.get_all_tokens())}个令牌", "Server")
+    if CONFIG["API"]["PROXY"]:
+        logger.info(f"代理已设置: {CONFIG['API']['PROXY']}", "Server")
+    logger.info("初始化完成", "Server")
+
+
+app = Flask(__name__)
+app.wsgi_app = ProxyFix(app.wsgi_app)
+app.secret_key = os.getenv('FLASK_SECRET_KEY') or secrets.token_hex(16)
+app.json.sort_keys = False
+
+@app.route('/manager/login', methods=['GET', 'POST'])
+def manager_login():
+    if CONFIG["ADMIN"]["MANAGER_SWITCH"]:
+        if request.method == 'POST':
+            password = request.form.get('password')
+            if password == CONFIG["ADMIN"]["PASSWORD"]:
+                session['is_logged_in'] = True
+                return redirect('/manager')
+            return render_template('login.html', error=True)
+        return render_template('login.html', error=False)
+    else:
+        return redirect('/')
+
+def check_auth():
+    return session.get('is_logged_in', False)
+
+@app.route('/manager')
+def manager():
+    if not check_auth():
+        return redirect('/manager/login')
+    return render_template('manager.html')
+
+@app.route('/manager/api/get')
+def get_manager_tokens():
+    if not check_auth():
+        return jsonify({"error": "Unauthorized"}), 401
+    return jsonify(token_manager.get_token_status_map())
+
+@app.route('/manager/api/add', methods=['POST'])
+def add_manager_token():
+    if not check_auth():
+        return jsonify({"error": "Unauthorized"}), 401
+    try:
+        sso = request.json.get('sso')
+        if not sso:
+            return jsonify({"error": "SSO token is required"}), 400
+        token_manager.add_token(f"sso-rw={sso};sso={sso}")
+        return jsonify({"success": True})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/manager/api/delete', methods=['POST'])
+def delete_manager_token():
+    if not check_auth():
+        return jsonify({"error": "Unauthorized"}), 401
+    try:
+        sso = request.json.get('sso')
+        if not sso:
+            return jsonify({"error": "SSO token is required"}), 400
+        token_manager.delete_token(f"sso-rw={sso};sso={sso}")
+        return jsonify({"success": True})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/manager/api/cf_clearance', methods=['POST'])
+def setCf_Manager_clearance():
+    if not check_auth():
+        return jsonify({"error": "Unauthorized"}), 401
+    try:
+        cf_clearance = request.json.get('cf_clearance')
+        if not cf_clearance:
+            return jsonify({"error": "cf_clearance is required"}), 400
+        CONFIG["SERVER"]['CF_CLEARANCE'] = cf_clearance
+        return jsonify({"success": True})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+@app.route('/get/tokens', methods=['GET'])
+def get_tokens():
+    auth_token = request.headers.get('Authorization', '').replace('Bearer ', '')
+    if CONFIG["API"]["IS_CUSTOM_SSO"]:
+        return jsonify({"error": '自定义的SSO令牌模式无法获取轮询sso令牌状态'}), 403
+    elif auth_token != CONFIG["API"]["API_KEY"]:
+        return jsonify({"error": 'Unauthorized'}), 401
+    return jsonify(token_manager.get_token_status_map())
+
+@app.route('/add/token', methods=['POST'])
+def add_token():
+    auth_token = request.headers.get('Authorization', '').replace('Bearer ', '')
+    if CONFIG["API"]["IS_CUSTOM_SSO"]:
+        return jsonify({"error": '自定义的SSO令牌模式无法添加sso令牌'}), 403
+    elif auth_token != CONFIG["API"]["API_KEY"]:
+        return jsonify({"error": 'Unauthorized'}), 401
+    try:
+        sso = request.json.get('sso')
+        token_manager.add_token(f"sso-rw={sso};sso={sso}")
+        return jsonify(token_manager.get_token_status_map().get(sso, {})), 200
+    except Exception as error:
+        logger.error(str(error), "Server")
+        return jsonify({"error": '添加sso令牌失败'}), 500
+
+@app.route('/set/cf_clearance', methods=['POST'])
+def setCf_clearance():
+    auth_token = request.headers.get('Authorization', '').replace('Bearer ', '')
+    if auth_token != CONFIG["API"]["API_KEY"]:
+        return jsonify({"error": 'Unauthorized'}), 401
+    try:
+        cf_clearance = request.json.get('cf_clearance')
+        CONFIG["SERVER"]['CF_CLEARANCE'] = cf_clearance
+        return jsonify({"message": '设置cf_clearance成功'}), 200
+    except Exception as error:
+        logger.error(str(error), "Server")
+        return jsonify({"error": '设置cf_clearance失败'}), 500
+
+@app.route('/delete/token', methods=['POST'])
+def delete_token():
+    auth_token = request.headers.get('Authorization', '').replace('Bearer ', '')
+    if CONFIG["API"]["IS_CUSTOM_SSO"]:
+        return jsonify({"error": '自定义的SSO令牌模式无法删除sso令牌'}), 403
+    elif auth_token != CONFIG["API"]["API_KEY"]:
+        return jsonify({"error": 'Unauthorized'}), 401
+    try:
+        sso = request.json.get('sso')
+        token_manager.delete_token(f"sso-rw={sso};sso={sso}")
+        return jsonify({"message": '删除sso令牌成功'}), 200
+    except Exception as error:
+        logger.error(str(error), "Server")
+        return jsonify({"error": '删除sso令牌失败'}), 500
+
+
+@app.route('/v1/models', methods=['GET'])
+def get_models():
+    return jsonify({
+        "object": "list",
+        "data": [
+            {
+                "id": model,
+                "object": "model",
+                "created": int(time.time()),
+                "owned_by": "grok"
+            } for model in CONFIG["MODELS"].keys()
+        ]
+    })
+
+@app.route('/v1/chat/completions', methods=['POST'])
+def chat_completions():
+    response_status_code = 500
+    try:
+        auth_token = request.headers.get('Authorization', '').replace('Bearer ', '')
+        if auth_token:
+            if CONFIG["API"]["IS_CUSTOM_SSO"]:
+                result = f"sso={auth_token};sso-rw={auth_token}"
+                token_manager.set_token(result)
+            elif auth_token != CONFIG["API"]["API_KEY"]:
+                return jsonify({"error": 'Unauthorized'}), 401
+        else:
+            return jsonify({"error": 'API_KEY缺失'}), 401
+
+        data = request.json
+        model = data.get("model")
+        stream = data.get("stream", False)
+        retry_count = 0
+        grok_client = GrokApiClient(model)
+        request_payload = grok_client.prepare_chat_request(data)
+
+        while retry_count < CONFIG["RETRY"]["MAX_ATTEMPTS"]:
+            retry_count += 1
+            CONFIG["API"]["SIGNATURE_COOKIE"] = Utils.create_auth_headers(model)
+            if not CONFIG["API"]["SIGNATURE_COOKIE"]:
+                raise ValueError('该模型无可用令牌')
+
+            logger.info(
+                f"当前令牌: {json.dumps(CONFIG['API']['SIGNATURE_COOKIE'], indent=2)}","Server")
+            logger.info(
+                f"当前可用模型的全部可用数量: {json.dumps(token_manager.get_remaining_token_request_capacity(), indent=2)}","Server")
+
+            if CONFIG['SERVER']['CF_CLEARANCE']:
+                CONFIG["SERVER"]['COOKIE'] = f"{CONFIG['API']['SIGNATURE_COOKIE']};{CONFIG['SERVER']['CF_CLEARANCE']}"
+            else:
+                CONFIG["SERVER"]['COOKIE'] = CONFIG['API']['SIGNATURE_COOKIE']
+
+            logger.info(json.dumps(request_payload,indent=2),"Server")
+
+            try:
+                proxy_options = Utils.get_proxy_options()
+                response = curl_requests.post(
+                    f"{CONFIG['API']['BASE_URL']}/rest/app-chat/conversations/new",
+                    headers={
+                        **DEFAULT_HEADERS,
+                        "Cookie":CONFIG["SERVER"]['COOKIE']
+                    },
+                    json=request_payload,
+                    impersonate="chrome133a",
+                    verify=False,
+                    stream=True,
+                    **proxy_options)
+
+                logger.info(CONFIG["SERVER"]['COOKIE'],"Server")
+
+                if response.status_code == 200:
+                    response_status_code = 200
+                    logger.info("请求成功", "Server")
+                    logger.info(
+                        f"当前{model}剩余可用令牌数: {token_manager.get_token_count_for_model(model)}","Server")
+                    try:
+                        if stream:
+                            return Response(stream_with_context(
+                                MessageProcessor.handle_stream_response(response, model)),
+                                content_type='text/event-stream')
+                        else:
+                            content = MessageProcessor.handle_non_stream_response(response, model)
+                            return jsonify(
+                                MessageProcessor.create_chat_response(content, model))
+                    except Exception as error:
+                        logger.error(str(error), "Server")
+                        if CONFIG["API"]["IS_CUSTOM_SSO"]:
+                            raise ValueError(f"自定义SSO令牌当前模型{model}的请求次数已失效")
+                        token_manager.remove_token_from_model(model, CONFIG["API"]["SIGNATURE_COOKIE"])
+                        if token_manager.get_token_count_for_model(model) == 0:
+                            raise ValueError(f"{model} 次数已达上限，请切换其他模型或者重新对话")
+
+                elif response.status_code == 403:
+                    response_status_code = 403
+                    token_manager.reduce_token_request_count(model,1)#重置去除当前因为错误未成功请求的次数，确保不会因为错误未成功请求的次数导致次数上限
+                    if token_manager.get_token_count_for_model(model) == 0:
+                        raise ValueError(f"{model} 次数已达上限，请切换其他模型或者重新对话")
+                    raise ValueError(f"IP暂时被封无法破盾，请稍后重试或者更换ip")
+
+                elif response.status_code == 429:
+                    response_status_code = 429
+                    token_manager.reduce_token_request_count(model,1)
+                    if CONFIG["API"]["IS_CUSTOM_SSO"]:
+                        raise ValueError(f"自定义SSO令牌当前模型{model}的请求次数已失效")
+                    token_manager.remove_token_from_model(
+                        model, CONFIG["API"]["SIGNATURE_COOKIE"])
+                    if token_manager.get_token_count_for_model(model) == 0:
+                        raise ValueError(f"{model} 次数已达上限，请切换其他模型或者重新对话")
+                else:
+                    if CONFIG["API"]["IS_CUSTOM_SSO"]:
+                        raise ValueError(f"自定义SSO令牌当前模型{model}的请求次数已失效")
+                    logger.error(f"令牌异常错误状态!status: {response.status_code}","Server")
+                    token_manager.remove_token_from_model(model, CONFIG["API"]["SIGNATURE_COOKIE"])
+                    logger.info(
+                        f"当前{model}剩余可用令牌数: {token_manager.get_token_count_for_model(model)}", "Server")
+
+            except Exception as e:
+                logger.error(f"请求处理异常: {str(e)}", "Server")
+                if CONFIG["API"]["IS_CUSTOM_SSO"]:
+                    raise
+                continue
+
+        if response_status_code == 403:
+            raise ValueError('IP暂时被封无法破盾，请稍后重试或者更换ip')
+        elif response_status_code == 500:
+            raise ValueError('当前模型所有令牌暂无可用，请稍后重试')
+
+    except Exception as error:
+        logger.error(str(error), "ChatAPI")
+        return jsonify(
+            {"error": {
+                "message": str(error),
+                "type": "server_error"
+            }}), response_status_code
+
+
+@app.route('/')
+def index():
+    """渲染系统状态展示页面"""
+    return render_template('index.html')
+
+@app.route('/status')
+def get_system_status():
+    """提供系统状态的 JSON 数据"""
+    # 获取配置信息 (需要根据实际CONFIG结构调整)
+    config_info = {
+        "api_base_url": CONFIG["API"]["BASE_URL"],
+        "log_level": logger.level, # 使用logger.level获取日志级别
+        "is_temp_conversation": CONFIG["API"]["IS_TEMP_CONVERSATION"],
+        "is_custom_sso": CONFIG["API"]["IS_CUSTOM_SSO"],
+        "proxy": CONFIG["API"]["PROXY"],
+        "manager_switch": CONFIG["ADMIN"]["MANAGER_SWITCH"],
+        "show_thinking": CONFIG["SHOW_THINKING"],
+        "isshow_search_results": CONFIG["ISSHOW_SEARCH_RESULTS"]
+    }
+
+    # 获取令牌状态
+    token_status = {
+        "total_tokens": token_manager.get_total_token_count(),
+        "available_tokens": token_manager.get_remaining_token_request_capacity(),
+        "total_request_count": token_manager.get_total_request_count(),
+        "expired_tokens_count": len(token_manager.get_expired_tokens()),
+        "token_details": token_manager.get_token_status_map() # 提供更详细的令牌状态
+    }
+
+    # 获取日志摘要
+    log_summary = logger.get_recent_logs()
+
+    return jsonify({
+        "config": config_info,
+        "token_status": token_status,
+        "log_summary": log_summary
+    })
+
+
+if __name__ == '__main__':
+    token_manager = AuthTokenManager() # 创建 AuthTokenManager 实例
+    initialization()
+    app.run(
+        host='0.0.0.0',
+        port=CONFIG["SERVER"]["PORT"],
+        debug=False
+    )

dev_plan/project_remodeling_plan.md

@@ -0,0 +1,92 @@
+# 项目改造计划
+
+**目标：** 将现有的 Grok API Python Flask 程序改造为一个结构专业、功能完善（包含 Web UI）、文档齐全且易于部署（Docker on Hugging Face Spaces）的应用，同时严格遵守内存数据模式。
+
+**阶段 1: 规划与架构设计**
+*   **子任务 1.1: 代码结构设计**
+    *   **描述：** 分析现有 `app.py` 代码，识别不同的功能模块（如日志、配置、认证、API 客户端、消息处理、Flask 应用路由等）。设计清晰的目录结构和模块划分，例如：
+        *   `src/` (存放核心代码)
+            *   `api/` (API 路由和逻辑)
+            *   `core/` (核心类和函数，如 Logger, AuthTokenManager, GrokApiClient, Utils)
+            *   `web/` (Web UI 相关文件，如路由、模板、静态文件)
+            *   `config.py` (配置加载和管理)
+            *   `utils.py` (通用工具函数)
+            *   `__init__.py` 等
+        *   `templates/` (存放 Web UI 模板文件)
+        *   `static/` (存放 Web UI 静态资源，如 CSS, JS)
+        *   `docs/` (存放文档，如 README)
+        *   `tests/` (存放测试文件，可选)
+    *   **预期产出：** 详细的目录结构设计和模块职责说明。
+*   **子任务 1.2: Web UI 技术选型与设计**
+    *   **描述：** 考虑到 Hugging Face Spaces 免费层的资源限制，选择轻量级的 Web 技术栈。设计 Web 页面的布局，包括展示当前的配置信息、令牌状态（总数、可用数、请求次数等）、日志摘要等。页面设计应美观且信息直观。
+    *   **预期产出：** Web UI 技术选型报告和页面原型设计（可以是草图或简单的 HTML 结构）。
+*   **子任务 1.3: README 内容规划**
+    *   **描述：** 规划 README 文档的章节和内容，至少应包含：项目简介、功能列表、安装部署（详细说明 Hugging Face Spaces Docker 部署步骤）、配置说明（环境变量等）、API 使用指南、Web UI 使用说明、注意事项（内存数据模式、速率限制等）。
+    *   **预期产物：** README 文档大纲。
+*   **子任务 1.4: Dockerfile 规划**
+    *   **描述：** 规划 Dockerfile 的内容，包括选择合适的基础镜像（如 Python 官方镜像）、安装依赖（`requirements.txt`）、复制项目文件、设置工作目录、暴露端口、定义启动命令。确保 Dockerfile 能够适配 Hugging Face Spaces 的环境。
+    *   **预期产出：** Dockerfile 大纲。
+*   **子任务 1.5: 内存数据模式确认**
+    *   **描述：** 仔细分析 `app.py` 中 `AuthTokenManager` 类的数据存储方式，确认其是否完全依赖于内存变量，没有使用文件、数据库或其他持久化存储。在后续改造中严格遵守此原则。
+    *   **预期产出：** 内存数据模式确认报告和改造中的注意事项列表。
+
+**阶段 2: 代码实现与改造**
+*   **子任务 2.1: 目录结构创建**
+    *   **描述：** 根据阶段 1.1 的设计，在项目根目录下创建新的文件夹结构。
+    *   **预期产出：** 创建好的项目目录结构。
+*   **子任务 2.2: 模块拆分与重构**
+    *   **描述：** 将 `app.py` 中的类、函数和路由按照阶段 1.1 的规划移动到相应的模块文件中。对代码进行重构，提高模块化程度和可读性。更新相互之间的引用关系。
+    *   **预期产物：** 拆分并重构后的代码文件。
+*   **子任务 2.3: Web UI 实现**
+    *   **描述：** 根据阶段 1.2 的设计，实现 Web UI 的前端（HTML, CSS, JavaScript）和后端（Flask 路由和逻辑）代码。
+    *   **预期产出：** 可用的 Web UI 文件。
+*   **子任务 2.4: API 与 Web UI 集成**
+    *   **描述：** 修改后端代码，使 Web UI 能够调用内部函数或接口获取系统状态信息（如令牌数量、配置等），并在前端页面上展示。
+    *   **预期产物：** 集成 API 和 Web UI 的代码。
+
+**阶段 3: 文档与部署**
+*   **子任务 3.1: README 文档编写**
+    *   **描述：** 根据阶段 1.3 的大纲，编写详细的 README.md 文档。
+    *   **预期产出：** 完成的 README.md 文件。
+*   **子任务 3.2: Dockerfile 编写**
+    *   **描述：** 根据阶段 1.4 的大纲，编写 Dockerfile 文件。
+    *   **预期产物：** 完成的 Dockerfile 文件。
+*   **子任务 3.3: 部署测试**
+    *   **描述：** 在本地使用 Docker 构建镜像并运行，验证程序是否正常工作。如果可能，尝试在 Hugging Face Spaces 上进行测试部署。
+    *   **预期产出：** 本地 Docker 运行截图或 Hugging Face Spaces 部署成功报告。
+
+**阶段 4: 验证与优化**
+*   **子任务 4.1: 功能测试**
+    *   **描述：** 对改造后的程序进行全面的功能测试，包括 API 接口的调用和 Web UI 的交互。
+    *   **预期产出：** 功能测试报告。
+*   **子任务 4.2: 内存使用验证**
+    *   **描述：** 再次检查代码，���保所有数据存储都只在内存中进行，没有引入任何持久化机制。
+    *   **预期产物：** 内存数据模式验证报告。
+*   **子任务 4.3: 部署适配优化**
+    *   **描述：** 根据部署测试的结果，对 Dockerfile 或程序代码进行必要的调整和优化，确保在 Hugging Face Spaces 免费层上稳定运行。
+    *   **预期产物：** 优化后的 Dockerfile 和代码。
+
+**计划可视化 (Mermaid 图):**
+
+```mermaid
+graph TD
+    A[用户任务: 改造 Grok API 程序] --> B{阶段 1: 规划与架构设计}
+    B --> B1[1.1 代码结构设计]
+    B --> B2[1.2 Web UI 技术选型与设计]
+    B --> B3[1.3 README 内容规划]
+    B --> B4[1.4 Dockerfile 规划]
+    B --> B5[1.5 内存数据模式确认]
+    B --> C{阶段 2: 代码实现与改造}
+    C --> C1[2.1 目录结构创建]
+    C --> C2[2.2 模块拆分与重构]
+    C --> C3[2.3 Web UI 实现]
+    C --> C4[2.4 API 与 Web UI 集成]
+    C --> D{阶段 3: 文档与部署}
+    D --> D1[3.1 README 文档编写]
+    D --> D2[3.2 Dockerfile 编写]
+    D --> D3[3.3 部署测试]
+    D --> E{阶段 4: 验证与优化}
+    E --> E1[4.1 功能测试]
+    E --> E2[4.2 内存使用验证]
+    E --> E3[4.3 部署适配优化]
+    E --> F[改造完成]

memory-bank/activeContext.md

@@ -0,0 +1,24 @@
+# 活动上下文
+
+此文件跟踪项目的当前状态，包括最近的变更、当前目标和未解决的问题。
+YYYY-MM-DD HH:mm:ss - 更新日志。
+
+*
+
+## 当前焦点
+
+*
+- 对现有的 Grok API 程序进行改造规划。
+
+## 最近变更
+
+*
+- Memory Bank 初始化完成。
+
+## 未解决的问题/议题
+
+*
+- 暂无。
+
+2025-05-14 17:37:25 - Memory Bank 初始化。
+2025-05-14 17:39:40 - 更新当前焦点为项目改造规划。

memory-bank/decisionLog.md

@@ -0,0 +1,20 @@
+# 决策日志
+
+此文件以列表格式记录架构和实现决策。
+YYYY-MM-DD HH:mm:ss - 更新日志。
+
+*
+
+## 决策
+
+*
+
+## 理由
+
+*
+
+## 实现细节
+
+*
+
+2025-05-14 17:37:42 - Memory Bank 初始化。

memory-bank/productContext.md

@@ -0,0 +1,33 @@
+# 产品上下文
+
+此文件提供项目和预期创建产品的高级概述。初始内容基于 `projectBrief.md`（如果提供）以及工作目录中所有其他与项目相关的信息。此文件应随着项目的发展而更新，并用于为所有其他模式提供项目目标和上下文的信息。
+YYYY-MM-DD HH:mm:ss - 更新日志将作为脚注追加到文件末尾。
+
+*
+
+## 项目目标
+
+- 对现有的 grok 网页版逆向后封装成 API 的 Python Flask 程序进行改造。
+- 以专业的项目视角对代码进行拆分，分门别类放入不同的文件夹进行管理。
+- 增加一个 Web 端展示系统详细情况，网页设计要美观。
+- 根据项目情况生成一份 README 文档。
+- 保持程序设计只使用内存数据模式，不允许本地存储。
+- 适配部署在 Hugging Face Spaces 的免费层上，使用 Docker 部署。
+
+## 关键功能
+
+- 现有的 Grok API 封装功能。
+- Web 端系统状态展示（待实现）。
+- README 文档生成（待实现）。
+- Docker 部署配置（待实现）。
+
+## 整体架构
+
+- 现有的 Flask API 部分。
+- 新增的 Web UI 部分。
+- 代码将按照模块进行拆分和组织。
+- 使用内存进行数据存储。
+- 通过 Dockerfile 进行容器化部署。
+
+2025-05-14 17:37:10 - Memory Bank 初始化。
+2025-05-14 17:38:31 - 添加项目目标和关键功能。

memory-bank/progress.md

@@ -0,0 +1,29 @@
+# 进展
+
+此文件使用任务列表格式跟踪项目的进展。
+YYYY-MM-DD HH:mm:ss - 更新日志。
+
+*
+
+## 已完成任务
+
+*
+- Memory Bank 初始化。
+- 目录结构创建。
+- 模块拆分与重构。
+
+## 当前任务
+
+*
+- 设计并实现 Web 端系统状态展示。
+
+## 下一步
+
+*
+- 编写 README 文档。
+- 准备 Docker 部署配置。
+
+2025-05-14 17:37:34 - Memory Bank 初始化。
+2025-05-14 17:38:51 - 更新当前任务为项目改造规划。
+2025-05-14 17:47:37 - 标记目录结构创建为已完成，更新当前任务为模块拆分与重构。
+2025-05-14 18:04:27 - 标记模块拆分与重构为已完成，更新当前任务为设计并实现 Web 端系统状态展示。

memory-bank/systemPatterns.md

@@ -0,0 +1,21 @@
+# 系统模式 *可选*
+
+此文件记录项目中使用的重复模式和标准。
+此文件为可选，但建议随着项目发展进行更新。
+YYYY-MM-DD HH:mm:ss - 更新日志。
+
+*
+
+## 编码模式
+
+*
+
+## 架构模式
+
+*
+
+## 测试模式
+
+*
+
+2025-05-14 17:37:52 - Memory Bank 初始化。

requirements.txt

@@ -0,0 +1,6 @@
+python-dotenv
+requests
+Flask
+curl_cffi
+Werkzeug
+loguru

src/core/auth_token_manager.py

@@ -0,0 +1,278 @@
+# src/core/auth_token_manager.py
+import time
+import json
+import threading
+from src.core.logger import logger # 从新的位置导入 logger
+
+class AuthTokenManager:
+    def __init__(self):
+        self.token_model_map = {}
+        self.expired_tokens = set()
+        self.token_status_map = {}
+        self.model_config = {
+            "grok-2": {
+                "RequestFrequency": 30,
+                "ExpirationTime": 1 * 60 * 60 * 1000  # 1小时
+            },
+            "grok-3": {
+                "RequestFrequency": 20,
+                "ExpirationTime": 2 * 60 * 60 * 1000  # 2小时
+            },
+            "grok-3-deepsearch": {
+                "RequestFrequency": 10,
+                "ExpirationTime": 24 * 60 * 60 * 1000  # 24小时
+            },
+            "grok-3-reasoning": {
+                "RequestFrequency": 10,
+                "ExpirationTime": 24 * 60 * 60 * 1000  # 24小时
+            }
+        }
+        self.token_reset_switch = False
+        self.token_reset_timer = None
+
+    def add_token(self, token):
+        sso = token.split("sso=")[1].split(";")[0]
+        for model in self.model_config.keys():
+            if model not in self.token_model_map:
+                self.token_model_map[model] = []
+            if sso not in self.token_status_map:
+                self.token_status_map[sso] = {}
+
+            existing_token_entry = next((entry for entry in self.token_model_map[model] if entry["token"] == token), None)
+            if not existing_token_entry:
+                self.token_model_map[model].append({
+                    "token": token,
+                    "RequestCount": 0,
+                    "AddedTime": int(time.time() * 1000),
+                    "StartCallTime": None
+                })
+
+            if model not in self.token_status_map[sso]:
+                self.token_status_map[sso][model] = {
+                    "isValid": True,
+                    "invalidatedTime": None,
+                    "totalRequestCount": 0
+                }
+
+    def set_token(self, token):
+        models = list(self.model_config.keys())
+        self.token_model_map = {model: [{
+            "token": token,
+            "RequestCount": 0,
+            "AddedTime": int(time.time() * 1000),
+            "StartCallTime": None
+        }] for model in models}
+        sso = token.split("sso=")[1].split(";")[0]
+        self.token_status_map[sso] = {model: {
+            "isValid": True,
+            "invalidatedTime": None,
+            "totalRequestCount": 0
+        } for model in models}
+
+
+    def delete_token(self, token):
+        try:
+            sso = token.split("sso=")[1].split(";")[0]
+            for model in self.token_model_map:
+                self.token_model_map[model] = [entry for entry in self.token_model_map[model] if entry["token"] != token]
+            if sso in self.token_status_map:
+                del self.token_status_map[sso]
+            logger.info(f"令牌已成功移除: {token}", "TokenManager")
+            return True
+        except Exception as error:
+            logger.error(f"令牌删除失败: {str(error)}")
+            return False
+
+    def reduce_token_request_count(self, model_id, count):
+        try:
+            normalized_model = self.normalize_model_name(model_id)
+            if normalized_model not in self.token_model_map:
+                logger.error(f"模型 {normalized_model} 不存在", "TokenManager")
+                return False
+            if not self.token_model_map[normalized_model]:
+                logger.error(f"模型 {normalized_model} 没有可用的token", "TokenManager")
+                return False
+
+            token_entry = self.token_model_map[normalized_model][0]
+            # 确保RequestCount不会小于0
+            new_count = max(0, token_entry["RequestCount"] - count)
+            reduction = token_entry["RequestCount"] - new_count
+            token_entry["RequestCount"] = new_count
+
+            # 更新token状态
+            if token_entry["token"]:
+                sso = token_entry["token"].split("sso=")[1].split(";")[0]
+                if sso in self.token_status_map and normalized_model in self.token_status_map[sso]:
+                    self.token_status_map[sso][normalized_model]["totalRequestCount"] = max(
+                        0, self.token_status_map[sso][normalized_model]["totalRequestCount"] - reduction
+                    )
+            return True
+        except Exception as error:
+            logger.error(f"重置校对token请求次数时发生错误: {str(error)}", "TokenManager")
+            return False
+
+
+    def get_next_token_for_model(self, model_id, is_return=False):
+        normalized_model = self.normalize_model_name(model_id)
+        if normalized_model not in self.token_model_map or not self.token_model_map[normalized_model]:
+            return None
+
+        token_entry = self.token_model_map[normalized_model][0]
+
+        if is_return:
+            return token_entry["token"]
+
+        if token_entry:
+            if token_entry["StartCallTime"] is None:
+                token_entry["StartCallTime"] = int(time.time() * 1000)
+            if not self.token_reset_switch:
+                self.start_token_reset_process()
+                self.token_reset_switch = True
+
+            token_entry["RequestCount"] += 1
+
+            if token_entry["RequestCount"] > self.model_config[normalized_model]["RequestFrequency"]:
+                self.remove_token_from_model(normalized_model, token_entry["token"])
+                next_token_entry = self.token_model_map[normalized_model][0] if self.token_model_map[normalized_model] else None
+                return next_token_entry["token"] if next_token_entry else None
+
+            sso = token_entry["token"].split("sso=")[1].split(";")[0]
+            if sso in self.token_status_map and normalized_model in self.token_status_map[sso]:
+                if token_entry["RequestCount"] == self.model_config[normalized_model]["RequestFrequency"]:
+                    self.token_status_map[sso][normalized_model]["isValid"] = False
+                    self.token_status_map[sso][normalized_model]["invalidatedTime"] = int(time.time() * 1000)
+                self.token_status_map[sso][normalized_model]["totalRequestCount"] += 1
+
+            return token_entry["token"]
+        return None
+
+    def remove_token_from_model(self, model_id, token):
+        normalized_model = self.normalize_model_name(model_id)
+        if normalized_model not in self.token_model_map:
+            logger.error(f"模型 {normalized_model} 不存在", "TokenManager")
+            return False
+
+        model_tokens = self.token_model_map[normalized_model]
+        token_index = next((i for i, entry in enumerate(model_tokens) if entry["token"] == token), -1)
+
+        if token_index != -1:
+            removed_token_entry = model_tokens.pop(token_index)
+            self.expired_tokens.add((
+                removed_token_entry["token"],
+                normalized_model,
+                int(time.time() * 1000)
+            ))
+            if not self.token_reset_switch:
+                self.start_token_reset_process()
+                self.token_reset_switch = True
+            logger.info(f"模型{model_id}的令牌已失效，已成功移除令牌: {token}", "TokenManager")
+            return True
+        logger.error(f"在模型 {normalized_model} 中未找到 token: {token}", "TokenManager")
+        return False
+
+    def get_expired_tokens(self):
+        return list(self.expired_tokens)
+
+    def normalize_model_name(self, model):
+        if model.startswith('grok-') and 'deepsearch' not in model and 'reasoning' not in model:
+            return '-'.join(model.split('-')[:2])
+        return model
+
+    def get_token_count_for_model(self, model_id):
+        normalized_model = self.normalize_model_name(model_id)
+        return len(self.token_model_map.get(normalized_model, []))
+
+    def get_remaining_token_request_capacity(self):
+        remaining_capacity_map = {}
+        for model in self.model_config.keys():
+            model_tokens = self.token_model_map.get(model, [])
+            model_request_frequency = self.model_config[model]["RequestFrequency"]
+            total_used_requests = sum(token_entry.get("RequestCount", 0) for token_entry in model_tokens)
+            remaining_capacity = (len(model_tokens) * model_request_frequency) - total_used_requests
+            remaining_capacity_map[model] = max(0, remaining_capacity)
+        return remaining_capacity_map
+
+    def get_token_array_for_model(self, model_id):
+        normalized_model = self.normalize_model_name(model_id)
+        return self.token_model_map.get(normalized_model, [])
+
+    def start_token_reset_process(self):
+        def reset_expired_tokens():
+            now = int(time.time() * 1000)
+            tokens_to_remove = set()
+            for token_info in self.expired_tokens:
+                token, model, expired_time = token_info
+                expiration_time = self.model_config[model]["ExpirationTime"]
+                if now - expired_time >= expiration_time:
+                    if not any(entry["token"] == token for entry in self.token_model_map.get(model, [])):
+                        if model not in self.token_model_map:
+                            self.token_model_map[model] = []
+                        self.token_model_map[model].append({
+                            "token": token,
+                            "RequestCount": 0,
+                            "AddedTime": now,
+                            "StartCallTime": None
+                        })
+                        sso = token.split("sso=")[1].split(";")[0]
+                        if sso in self.token_status_map and model in self.token_status_map[sso]:
+                            self.token_status_map[sso][model]["isValid"] = True
+                            self.token_status_map[sso][model]["invalidatedTime"] = None
+                            self.token_status_map[sso][model]["totalRequestCount"] = 0
+                    tokens_to_remove.add(token_info)
+            self.expired_tokens -= tokens_to_remove
+
+            for model in self.model_config.keys():
+                if model not in self.token_model_map:
+                    continue
+                for token_entry in self.token_model_map[model]:
+                    if not token_entry.get("StartCallTime"):
+                        continue
+                    expiration_time = self.model_config[model]["ExpirationTime"]
+                    if now - token_entry["StartCallTime"] >= expiration_time:
+                        sso = token_entry["token"].split("sso=")[1].split(";")[0]
+                        if sso in self.token_status_map and model in self.token_status_map[sso]:
+                            self.token_status_map[sso][model]["isValid"] = True
+                            self.token_status_map[sso][model]["invalidatedTime"] = None
+                            self.token_status_map[sso][model]["totalRequestCount"] = 0
+                        token_entry["RequestCount"] = 0
+                        token_entry["StartCallTime"] = None
+
+        # 启动一个线程执行定时任务，每小时执行一次
+        def run_timer():
+            while True:
+                reset_expired_tokens()
+                time.sleep(3600)
+
+        timer_thread = threading.Thread(target=run_timer)
+        timer_thread.daemon = True
+        timer_thread.start()
+
+    def get_all_tokens(self):
+        all_tokens = set()
+        for model_tokens in self.token_model_map.values():
+            for entry in model_tokens:
+                all_tokens.add(entry["token"])
+        return list(all_tokens)
+
+    def get_current_token(self, model_id):
+        normalized_model = self.normalize_model_name(model_id)
+        if normalized_model not in self.token_model_map or not self.token_model_map[normalized_model]:
+            return None
+        token_entry = self.token_model_map[normalized_model][0]
+        return token_entry["token"]
+
+    def get_total_token_count(self):
+        """获取总令牌数"""
+        return len(self.get_all_tokens())
+
+    def get_total_request_count(self):
+        """获取总请求次数"""
+        total_count = 0
+        for sso_status in self.token_status_map.values():
+            for model_status in sso_status.values():
+                total_count += model_status.get("totalRequestCount", 0)
+        return total_count
+
+    def get_token_status_map(self):
+        """获取令牌状态映射"""
+        return self.token_status_map

src/core/grok_api_client.py

@@ -0,0 +1,235 @@
+# src/core/grok_api_client.py
+import json
+import time
+import base64
+import re
+import requests
+from curl_cffi import requests as curl_requests
+
+from src.core.logger import logger # 从新的位置导入 logger
+from src.core.utils import Utils # 从新的位置导入 Utils
+from app import CONFIG, DEFAULT_HEADERS # 导入 CONFIG 和 DEFAULT_HEADERS
+
+class GrokApiClient:
+    def __init__(self, model_id):
+        if model_id not in CONFIG["MODELS"]:
+            raise ValueError(f"不支持的模型: {model_id}")
+        self.model_id = CONFIG["MODELS"][model_id]
+
+    def process_message_content(self, content):
+        if isinstance(content, str):
+            return content
+        return None
+
+    def get_image_type(self, base64_string):
+        mime_type = 'image/jpeg'
+        if 'data:image' in base64_string:
+            import re
+            matches = re.search(r'data:([a-zA-Z0-9]+\/[a-zA-Z0-9-.+]+);base64,', base64_string)
+            if matches:
+                mime_type = matches.group(1)
+            extension = mime_type.split('/')[1]
+            file_name = f"image.{extension}"
+            return {
+                "mimeType": mime_type,
+                "fileName": file_name
+            }
+
+    def upload_base64_file(self, message, model):
+        try:
+            message_base64 = base64.b64encode(message.encode('utf-8')).decode('utf-8')
+            upload_data = {
+                "fileName": "message.txt",
+                "fileMimeType": "text/plain",
+                "content": message_base64
+            }
+            logger.info("发送文字文件请求", "Server")
+            cookie = f"{Utils.create_auth_headers(model, True)};{CONFIG['SERVER']['CF_CLEARANCE']}"
+            proxy_options = Utils.get_proxy_options()
+            response = curl_requests.post(
+                "https://grok.com/rest/app-chat/upload-file",
+                headers={
+                    **DEFAULT_HEADERS,
+                    "Cookie":cookie
+                },
+                json=upload_data,
+                impersonate="chrome133a",
+                verify=False,
+                **proxy_options
+            )
+            if response.status_code != 200:
+                logger.error(f"上传文件失败,状态码:{response.status_code}", "Server")
+                raise Exception(f"上传文件失败,状态码:{response.status_code}")
+            result = response.json()
+            logger.info(f"上传文件成功: {result}", "Server")
+            return result.get("fileMetadataId", "")
+        except Exception as error:
+            logger.error(str(error), "Server")
+            raise Exception(f"上传文件失败,状态码:{response.status_code}")
+
+    def upload_base64_image(self, base64_data, url):
+        try:
+            if 'data:image' in base64_data:
+                image_buffer = base64_data.split(',')[1]
+            else:
+                image_buffer = base64_data
+
+            image_info = self.get_image_type(base64_data)
+            mime_type = image_info["mimeType"]
+            file_name = image_info["fileName"]
+
+            upload_data = {
+                "rpc": "uploadFile",
+                "req": {
+                    "fileName": file_name,
+                    "fileMimeType": mime_type,
+                    "content": image_buffer
+                }
+            }
+            logger.info("发送图片请求", "Server")
+            proxy_options = Utils.get_proxy_options()
+            response = curl_requests.post(
+                url,
+                headers={
+                    **DEFAULT_HEADERS,
+                    "Cookie":CONFIG["SERVER"]['COOKIE']
+                },
+                json=upload_data,
+                impersonate="chrome133a",
+                verify=False,
+                **proxy_options
+            )
+            if response.status_code != 200:
+                logger.error(f"上传图片失败,状态码:{response.status_code}", "Server")
+                return ''
+            result = response.json()
+            logger.info(f"上传图片成功: {result}", "Server")
+            return result.get("fileMetadataId", "")
+        except Exception as error:
+            logger.error(str(error), "Server")
+            return ''
+
+    def prepare_chat_request(self, request):
+        if ((request["model"] == 'grok-2-imageGen' or request["model"] == 'grok-3-imageGen') and not CONFIG["API"]["PICGO_KEY"] and not CONFIG["API"]["TUMY_KEY"] and request.get("stream", False)):
+            raise ValueError("该模型流式输出需要配置PICGO或者TUMY图床密钥!")
+
+        todo_messages = request["messages"]
+        if request["model"] in ['grok-2-imageGen', 'grok-3-imageGen', 'grok-3-deepsearch']:
+            last_message = todo_messages[-1]
+            if last_message["role"] != 'user':
+                raise ValueError('此模型最后一条消息必须是用户消息!')
+            todo_messages = [last_message]
+
+        file_attachments = []
+        messages = ''
+        last_role = None
+        last_content = ''
+        message_length = 0
+        convert_to_file = False
+        last_message_content = ''
+        search = request["model"] in ['grok-2-search', 'grok-3-search']
+
+        # 移除标签及其内容和base64图片
+        def remove_think_tags(text):
+            import re
+            text = re.sub(r'[\s\S]*?<\/think>', '', text).strip()
+            text = re.sub(r'!\[image\]\(data:.*?base64,.*?\)', '[图片]', text)
+            return text
+
+        def process_content(content):
+            if isinstance(content, list):
+                text_content = ''
+                for item in content:
+                    if item["type"] == 'image_url':
+                        text_content += ("[图片]" if not text_content else '\n[图片]')
+                    elif item["type"] == 'text':
+                        text_content += (remove_think_tags(item["text"]) if not text_content else '\n' + remove_think_tags(item["text"]))
+                return text_content
+            elif isinstance(content, dict) and content is not None:
+                if content["type"] == 'image_url':
+                    return "[图片]"
+                elif content["type"] == 'text':
+                    return remove_think_tags(content["text"])
+            return remove_think_tags(self.process_message_content(content))
+
+
+        for current in todo_messages:
+            role = 'assistant' if current["role"] == 'assistant' else 'user'
+            is_last_message = current == todo_messages[-1]
+
+            if is_last_message and "content" in current:
+                if isinstance(current["content"], list):
+                    for item in current["content"]:
+                        if item["type"] == 'image_url':
+                            processed_image = self.upload_base64_image(
+                                item["image_url"]["url"],
+                                f"{CONFIG['API']['BASE_URL']}/api/rpc"
+                            )
+                            if processed_image:
+                                file_attachments.append(processed_image)
+                elif isinstance(current["content"], dict) and current["content"].get("type") == 'image_url':
+                    processed_image = self.upload_base64_image(
+                        current["content"]["image_url"]["url"],
+                        f"{CONFIG['API']['BASE_URL']}/api/rpc"
+                    )
+                    if processed_image:
+                        file_attachments.append(processed_image)
+
+            text_content = process_content(current.get("content", ""))
+
+            if is_last_message and convert_to_file:
+                last_message_content = f"{role.upper()}: {text_content or '[图片]'}\n"
+                continue
+
+            if text_content or (is_last_message and file_attachments):
+                if role == last_role and text_content:
+                    last_content += '\n' + text_content
+                    messages = messages[:messages.rindex(f"{role.upper()}: ")] + f"{role.upper()}: {last_content}\n"
+                else:
+                    messages += f"{role.upper()}: {text_content or '[图片]'}\n"
+                    last_content = text_content
+                    last_role = role
+
+            message_length += len(messages)
+            if message_length >= 40000:
+                convert_to_file = True
+
+        if convert_to_file:
+            file_id = self.upload_base64_file(messages, request["model"])
+            if file_id:
+                file_attachments.insert(0, file_id)
+            messages = last_message_content.strip()
+
+        if messages.strip() == '':
+            if convert_to_file:
+                messages = '基于txt文件内容进行回复：'
+            else:
+                raise ValueError('消息内容为空!')
+
+        return {
+            "temporary": CONFIG["API"].get("IS_TEMP_CONVERSATION", False),
+            "modelName": self.model_id,
+            "message": messages.strip(),
+            "fileAttachments": file_attachments[:4],
+            "imageAttachments": [],
+            "disableSearch": False,
+            "enableImageGeneration": True,
+            "returnImageBytes": False,
+            "enableImageStreaming": False,
+            "imageGenerationCount": 1,
+            "forceConcise": False,
+            "toolOverrides": {
+                "imageGen": request["model"] in ['grok-2-imageGen', 'grok-3-imageGen'],
+                "webSearch": search,
+                "xSearch": search,
+                "xMediaSearch": search,
+                "trendsSearch": search,
+                "xPostAnalyze": search
+            },
+            "enableSideBySide": True,
+            "isPreset": False,
+            "sendFinalMetadata": True,
+            "customInstructions": "",
+            "deepsearchPreset": "default" if request["model"] == 'grok-3-deepsearch' else "",
+            "isReasoning": request["model"] == 'grok-3-reasoning'
+        }

src/core/logger.py

@@ -0,0 +1,105 @@
+# src/core/logger.py
+import sys
+import inspect
+import os
+from loguru import logger
+
+class Logger:
+    def __init__(self, level="INFO", colorize=True, format=None, max_logs=100):
+        """
+        初始化 Logger 实例。
+
+        Args:
+            level (str): 日志级别。
+            colorize (bool): 是否彩色输出。
+            format (str): 日志格式。
+            max_logs (int): 存储的最大日志条数。
+        """
+        logger.remove()
+        if format is None:
+            format = (
+                "{time:YYYY-MM-DD HH:mm:ss} | "
+                "{level: <8} | "
+                "{extra[filename]}:{extra[function]}:{extra[lineno]} | "
+                "{message}"
+            )
+        logger.add(
+            sys.stderr,
+            level=level,
+            format=format,
+            colorize=colorize,
+            backtrace=True,
+            diagnose=True
+        )
+        self.logger = logger
+        self._log_history = [] # 存储日志历史
+        self._max_logs = max_logs # 最大日志条数
+
+    def _add_log_to_history(self, message, level, source):
+        """将日志添加到历史记录"""
+        timestamp = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
+        log_entry = f"{timestamp} | {level.upper(): <8} | [{source}] {message}"
+        self._log_history.append(log_entry)
+        # 保持日志历史在最大条数内
+        if len(self._log_history) > self._max_logs:
+            self._log_history = self._log_history[-self._max_logs:]
+
+    def get_recent_logs(self):
+        """获取最近的日志历史"""
+        return "\n".join(self._log_history)
+
+    def _get_caller_info(self):
+        frame = inspect.currentframe()
+        try:
+            caller_frame = frame.f_back.f_back
+            full_path = caller_frame.f_code.co_filename
+            function = caller_frame.f_code.co_name
+            lineno = caller_frame.f_lineno
+            filename = os.path.basename(full_path)
+            return {
+                'filename': filename,
+                'function': function,
+                'lineno': lineno
+            }
+        finally:
+            del frame
+
+    def info(self, message, source="API"):
+        caller_info = self._get_caller_info()
+        log_message = f"[{source}] {message}"
+        self.logger.bind(**caller_info).info(log_message)
+        self._add_log_to_history(message, "INFO", source)
+
+    def error(self, message, source="API"):
+        caller_info = self._get_caller_info()
+        if isinstance(message, Exception):
+            log_message = f"[{source}] {str(message)}"
+            self.logger.bind(**caller_info).exception(log_message)
+        else:
+            log_message = f"[{source}] {message}"
+            self.logger.bind(**caller_info).error(log_message)
+        self._add_log_to_history(message, "ERROR", source)
+
+
+    def warning(self, message, source="API"):
+        caller_info = self._get_caller_info()
+        log_message = f"[{source}] {message}"
+        self.logger.bind(**caller_info).warning(log_message)
+        self._add_log_to_history(message, "WARNING", source)
+
+    def debug(self, message, source="API"):
+        caller_info = self._get_caller_info()
+        log_message = f"[{source}] {message}"
+        self.logger.bind(**caller_info).debug(log_message)
+        self._add_log_to_history(message, "DEBUG", source)
+
+
+    async def request_logger(self, request):
+        caller_info = self._get_caller_info()
+        log_message = f"请求: {request.method} {request.path}"
+        self.logger.bind(**caller_info).info(log_message, "Request")
+        self._add_log_to_history(log_message, "INFO", "Request")
+
+
+# 初始化全局 logger 实例
+logger = Logger(level="INFO")

src/core/message_processor.py

@@ -0,0 +1,245 @@
+# src/core/message_processor.py
+import json
+import time
+import base64
+import uuid
+import requests
+from curl_cffi import requests as curl_requests
+
+from src.core.logger import logger # 从新的位置导入 logger
+from src.core.utils import Utils # 从新的位置导入 Utils
+from app import CONFIG, DEFAULT_HEADERS # 导入 CONFIG 和 DEFAULT_HEADERS
+
+class MessageProcessor:
+    @staticmethod
+    def create_chat_response(message, model, is_stream=False):
+        base_response = {
+            "id": f"chatcmpl-{uuid.uuid4()}",
+            "created": int(time.time()),
+            "model": model
+        }
+        if is_stream:
+            return {
+                **base_response,
+                "object": "chat.completion.chunk",
+                "choices": [{
+                    "index": 0,
+                    "delta": {
+                        "content": message
+                    }
+                }]
+            }
+        return {
+            **base_response,
+            "object": "chat.completion",
+            "choices": [{
+                "index": 0,
+                "message": {
+                    "role": "assistant",
+                    "content": message
+                },
+                "finish_reason": "stop"
+            }],
+            "usage": None
+        }
+
+    def process_model_response(response, model):
+        result = {"token": None, "imageUrl": None}
+        if CONFIG["IS_IMG_GEN"]:
+            if response.get("cachedImageGenerationResponse") and not CONFIG["IS_IMG_GEN2"]:
+                result["imageUrl"] = response["cachedImageGenerationResponse"]["imageUrl"]
+                return result
+
+        if model == 'grok-2':
+            result["token"] = response.get("token")
+        elif model in ['grok-2-search', 'grok-3-search']:
+            if response.get("webSearchResults") and CONFIG["ISSHOW_SEARCH_RESULTS"]:
+                result["token"] = f"\r\n{Utils.organize_search_results(response['webSearchResults'])}\r\n"
+            else:
+                result["token"] = response.get("token")
+        elif model == 'grok-3':
+            result["token"] = response.get("token")
+        elif model == 'grok-3-deepsearch':
+            if response.get("messageStepId") and not CONFIG["SHOW_THINKING"]:
+                return result
+            if response.get("messageStepId") and not CONFIG["IS_THINKING"]:
+                result["token"] = "" + response.get("token", "")
+                CONFIG["IS_THINKING"] = True
+            elif not response.get("messageStepId") and CONFIG["IS_THINKING"] and response.get("messageTag") == "final":
+                result["token"] = "" + response.get("token", "")
+                CONFIG["IS_THINKING"] = False
+            elif (response.get("messageStepId") and CONFIG["IS_THINKING"] and response.get("messageTag") == "assistant") or response.get("messageTag") == "final":
+                result["token"] = response.get("token")
+        elif model == 'grok-3-reasoning':
+            if response.get("isThinking") and not CONFIG["SHOW_THINKING"]:
+                return result
+            if response.get("isThinking") and not CONFIG["IS_THINKING"]:
+                result["token"] = "" + response.get("token", "")
+                CONFIG["IS_THINKING"] = True
+            elif not response.get("isThinking") and CONFIG["IS_THINKING"]:
+                result["token"] = "" + response.get("token", "")
+                CONFIG["IS_THINKING"] = False
+            else:
+                result["token"] = response.get("token")
+
+        return result
+
+    def handle_image_response(image_url):
+        max_retries = 2
+        retry_count = 0
+        image_base64_response = None
+        while retry_count < max_retries:
+            try:
+                proxy_options = Utils.get_proxy_options()
+                image_base64_response = curl_requests.get(
+                    f"https://assets.grok.com/{image_url}",
+                    headers={
+                        **DEFAULT_HEADERS,
+                        "Cookie":CONFIG["SERVER"]['COOKIE']
+                    },
+                    impersonate="chrome133a",
+                    **proxy_options
+                )
+                if image_base64_response.status_code == 200:
+                    break
+                retry_count += 1
+                if retry_count == max_retries:
+                    raise Exception(f"上游服务请求失败! status: {image_base64_response.status_code}")
+                time.sleep(CONFIG["API"]["RETRY_TIME"] / 1000 * retry_count)
+            except Exception as error:
+                logger.error(str(error), "Server")
+                retry_count += 1
+                if retry_count == max_retries:
+                    raise
+                time.sleep(CONFIG["API"]["RETRY_TIME"] / 1000 * retry_count)
+
+        image_buffer = image_base64_response.content
+
+        if not CONFIG["API"]["PICGO_KEY"] and not CONFIG["API"]["TUMY_KEY"]:
+            base64_image = base64.b64encode(image_buffer).decode('utf-8')
+            image_content_type = image_base64_response.headers.get('content-type', 'image/jpeg')
+            return f"![image](data:{image_content_type};base64,{base64_image})"
+
+        logger.info("开始上传图床", "Server")
+        if CONFIG["API"]["PICGO_KEY"]:
+            files = {'source': ('image.jpg', image_buffer, 'image/jpeg')}
+            headers = {
+                "X-API-Key": CONFIG["API"]["PICGO_KEY"]
+            }
+            response_url = requests.post(
+                "https://www.picgo.net/api/1/upload",
+                files=files,
+                headers=headers
+            )
+            if response_url.status_code != 200:
+                return "生图失败，请查看PICGO图床密钥是否设置正确"
+            else:
+                logger.info("生图成功", "Server")
+                result = response_url.json()
+                return f"![image]({result['image']['url']})"
+        elif CONFIG["API"]["TUMY_KEY"]:
+            files = {'file': ('image.jpg', image_buffer, 'image/jpeg')}
+            headers = {
+                "Accept": "application/json",
+                'Authorization': f"Bearer {CONFIG['API']['TUMY_KEY']}"
+            }
+            response_url = requests.post(
+                "https://tu.my/api/v1/upload",
+                files=files,
+                headers=headers
+            )
+            if response_url.status_code != 200:
+                return "生图失败，请查看TUMY图床密钥是否设置正确"
+            else:
+                try:
+                    result = response_url.json()
+                    logger.info("生图成功", "Server")
+                    return f"![image]({result['data']['links']['url']})"
+                except Exception as error:
+                    logger.error(str(error), "Server")
+                    return "生图失败，请查看TUMY图床密钥是否设置正确"
+
+
+    def handle_non_stream_response(response, model):
+        try:
+            logger.info("开始处理非流式响应", "Server")
+            stream = response.iter_lines()
+            full_response = ""
+            CONFIG["IS_THINKING"] = False
+            CONFIG["IS_IMG_GEN"] = False
+            CONFIG["IS_IMG_GEN2"] = False
+            for chunk in stream:
+                if not chunk:
+                    continue
+                try:
+                    line_json = json.loads(chunk.decode("utf-8").strip())
+                    if line_json.get("error"):
+                        logger.error(json.dumps(line_json, indent=2), "Server")
+                        yield json.dumps({"error": "RateLimitError"}) + "\n\n"
+                        return
+
+                    response_data = line_json.get("result", {}).get("response")
+                    if not response_data:
+                        continue
+
+                    if response_data.get("doImgGen") or response_data.get("imageAttachmentInfo"):
+                        CONFIG["IS_IMG_GEN"] = True
+
+                    result = process_model_response(response_data, model)
+                    if result["token"]:
+                        full_response += result["token"]
+                    if result["imageUrl"]:
+                        CONFIG["IS_IMG_GEN2"] = True
+                        return handle_image_response(result["imageUrl"])
+
+                except json.JSONDecodeError:
+                    continue
+                except Exception as e:
+                    logger.error(f"处理流式响应行时出错: {str(e)}", "Server")
+                    continue
+            return full_response
+        except Exception as error:
+            logger.error(str(error), "Server")
+            raise
+
+    def handle_stream_response(response, model):
+        def generate():
+            logger.info("开始处理流式响应", "Server")
+            stream = response.iter_lines()
+            CONFIG["IS_THINKING"] = False
+            CONFIG["IS_IMG_GEN"] = False
+            CONFIG["IS_IMG_GEN2"] = False
+            for chunk in stream:
+                if not chunk:
+                    continue
+                try:
+                    line_json = json.loads(chunk.decode("utf-8").strip())
+                    if line_json.get("error"):
+                        logger.error(json.dumps(line_json, indent=2), "Server")
+                        yield json.dumps({"error": "RateLimitError"}) + "\n\n"
+                        return
+
+                    response_data = line_json.get("result", {}).get("response")
+                    if not response_data:
+                        continue
+
+                    if response_data.get("doImgGen") or response_data.get("imageAttachmentInfo"):
+                        CONFIG["IS_IMG_GEN"] = True
+
+                    result = process_model_response(response_data, model)
+                    if result["token"]:
+                        yield f"data: {json.dumps(MessageProcessor.create_chat_response(result['token'], model, True))}\n\n"
+                    if result["imageUrl"]:
+                        CONFIG["IS_IMG_GEN2"] = True
+                        image_data = handle_image_response(result["imageUrl"])
+                        yield f"data: {json.dumps(MessageProcessor.create_chat_response(image_data, model, True))}\n\n"
+
+                except json.JSONDecodeError:
+                    continue
+                except Exception as e:
+                    logger.error(f"处理流式响应行时出错: {str(e)}", "Server")
+                    continue
+
+            yield "data: [DONE]\n\n"
+
+        return generate()

src/core/utils.py

@@ -0,0 +1,45 @@
+# src/core/utils.py
+import json
+import time
+import base64
+import re
+import requests
+from src.core.logger import logger # 从新的位置导入 logger
+from src.core.auth_token_manager import AuthTokenManager # 从新的位置导入 AuthTokenManager
+from app import CONFIG, DEFAULT_HEADERS, token_manager # 导入 CONFIG, DEFAULT_HEADERS 和 token_manager
+
+class Utils:
+    @staticmethod
+    def organize_search_results(search_results):
+        if not search_results or 'results' not in search_results:
+            return ''
+        results = search_results['results']
+        formatted_results = []
+        for index, result in enumerate(results):
+            title = result.get('title', '未知标题')
+            url = result.get('url', '#')
+            preview = result.get('preview', '无预览内容')
+            formatted_result = f"\r\n资料[{index}]: {title}\r\n{preview}\r\n\n[Link]({url})\r\n"
+            formatted_results.append(formatted_result)
+        return '\n\n'.join(formatted_results)
+
+    @staticmethod
+    def create_auth_headers(model, is_return=False):
+        return token_manager.get_next_token_for_model(model, is_return)
+
+    @staticmethod
+    def get_proxy_options():
+        proxy = CONFIG["API"]["PROXY"]
+        proxy_options = {}
+        if proxy:
+            logger.info(f"使用代理: {proxy}", "Server")
+            if proxy.startswith("socks5://"):
+                proxy_options["proxy"] = proxy
+                if '@' in proxy:
+                    auth_part = proxy.split('@')[0].split('://')[1]
+                    if ':' in auth_part:
+                        username, password = auth_part.split(':')
+                        proxy_options["proxy_auth"] = (username, password)
+            else:
+                proxy_options["proxies"] = {"https": proxy, "http": proxy}
+        return proxy_options

static/script.js

@@ -0,0 +1,35 @@
+// 页面加载完成后执行
+document.addEventListener('DOMContentLoaded', function() {
+    // 获取系统状态数据并更新页面
+    fetchSystemStatus();
+
+    // 可以设置定时器，定期更新数据
+    // setInterval(fetchSystemStatus, 5000); // 每5秒更新一次
+});
+
+function fetchSystemStatus() {
+    // 假设后端有一个 /status 路由返回 JSON 数据
+    fetch('/status')
+        .then(response => response.json())
+        .then(data => {
+            // 更新配置信息
+            document.getElementById('api-base-url').textContent = data.config.api_base_url;
+            document.getElementById('log-level').textContent = data.config.log_level;
+            // 更新其他配置项...
+
+            // 更新令牌状态
+            document.getElementById('total-tokens').textContent = data.token_status.total_tokens;
+            document.getElementById('available-tokens').textContent = data.token_status.available_tokens;
+            document.getElementById('request-count').textContent = data.token_status.request_count;
+            // 更新其他令牌状态...
+
+            // 更新日志摘要
+            document.getElementById('log-summary').textContent = data.log_summary;
+        })
+        .catch(error => {
+            console.error('获取系统状态失败:', error);
+            document.getElementById('config-info').textContent = '加载失败。';
+            document.getElementById('token-status').textContent = '加载失败。';
+            document.getElementById('log-summary').textContent = '加载失败。';
+        });
+}

static/style.css

@@ -0,0 +1,65 @@
+/* 通用样式 */
+body {
+    font-family: sans-serif;
+    line-height: 1.6;
+    margin: 0;
+    padding: 20px;
+    background-color: #f4f4f4;
+    color: #333;
+}
+
+.container {
+    max-width: 900px;
+    margin: auto;
+    background: #fff;
+    padding: 20px;
+    border-radius: 8px;
+    box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
+}
+
+h1, h2 {
+    color: #0056b3;
+}
+
+h1 {
+    text-align: center;
+    margin-bottom: 20px;
+}
+
+.status-section {
+    margin-bottom: 20px;
+    padding: 15px;
+    border: 1px solid #ddd;
+    border-radius: 5px;
+}
+
+.status-section h2 {
+    margin-top: 0;
+    border-bottom: 1px solid #eee;
+    padding-bottom: 10px;
+    margin-bottom: 15px;
+    color: #007bff;
+}
+
+/* 配置信息和令牌状态样式 */
+#config-info p,
+#token-status p {
+    margin: 5px 0;
+}
+
+#config-info strong,
+#token-status strong {
+    display: inline-block;
+    width: 120px; /* 固定宽度以便对齐 */
+}
+
+/* 日志摘要样式 */
+#log-summary {
+    background-color: #e9e9e9;
+    padding: 10px;
+    border-radius: 4px;
+    white-space: pre-wrap; /* 保留换行符和空格 */
+    font-family: monospace;
+    max-height: 300px; /* 限制高度并添加滚动条 */
+    overflow-y: auto;
+}

templates/index.html

@@ -0,0 +1,43 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Grok API System Status</title>
+    <link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">
+</head>
+<body>
+    <div class="container">
+        <h1>Grok API 系统状态</h1>
+
+        <section class="status-section">
+            <h2>配置信息</h2>
+            <div id="config-info">
+                <p><strong>API Base URL:</strong> <span id="api-base-url">加载中...</span></p>
+                <p><strong>Log Level:</strong> <span id="log-level">加载中...</span></p>
+                <!-- 其他配置项 -->
+            </div>
+        </section>
+
+        <section class="status-section">
+            <h2>令牌状态</h2>
+            <div id="token-status">
+                <p><strong>总令牌数:</strong> <span id="total-tokens">加载中...</span></p>
+                <p><strong>可用令牌数:</strong> <span id="available-tokens">加载中...</span></p>
+                <p><strong>请求次数:</strong> <span id="request-count">加载中...</span></p>
+                <!-- 其他令牌状态 -->
+            </div>
+        </section>
+
+        <section class="status-section">
+            <h2>日志摘要</h2>
+            <div id="log-summary">
+                <p>加载中...</p>
+                <!-- 日志内容将在此处加载 -->
+            </div>
+        </section>
+    </div>
+
+    <script src="{{ url_for('static', filename='script.js') }}"></script>
+</body>
+</html>