Update from GitHub Actions

.env.example

@@ -0,0 +1,33 @@
+# Redis 连接配置
+# 格式: redis://default:password@host:port
+# 必填项
+REDIS_CONN_STRING=redis://default:your_secure_password@redis:6379
+
+
+# 面板访问密码
+# 为了安全，此配置必填！
+ACCESS_PWD=your_secure_access_password
+
+
+# API 认证令牌
+# 如果设置，则所有 API 请求需要在 Authorization 头中提供此令牌
+# 格式: 随机数字+字母组合即可
+# 可选项，如果不设置则不启用认证
+AUTH_TOKEN=your_secure_auth_token
+
+
+# API 请求前缀
+# 可自定义，默认为空
+ROUTE_PREFIX=your_api_prefix
+
+# 调试模式
+# 设置为 true 时启用更详细的日志输出
+# 可选项，默认为 false
+DEBUG=false
+
+# 编码模式配置
+# 仅用于开发和调试
+# 可选项，默认为 false
+CODING_MODE=false
+CODING_TOKEN=
+TENANT_URL=

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,45 @@
+# 使用官方 Golang 镜像作为构建环境
+FROM golang:1.23-alpine AS builder
+
+# 设置工作目录
+WORKDIR /app
+
+# 复制 go.mod 和 go.sum 文件
+COPY go.mod go.sum ./
+
+# 下载依赖
+RUN go mod download
+
+# 复制源代码
+COPY . .
+
+# 构建应用
+RUN CGO_ENABLED=0 GOOS=linux go build -o augment2api
+
+# 使用轻量级的 alpine 镜像
+FROM alpine:latest
+
+# 安装 ca-certificates 以支持 HTTPS
+RUN apk --no-cache add ca-certificates tzdata
+
+# 创建非 root 用户
+RUN adduser -D -g '' appuser
+
+# 从构建阶段复制二进制文件
+COPY --from=builder /app/augment2api /app/augment2api
+
+# 复制静态文件和模板
+COPY --from=builder /app/templates /app/templates
+
+# 设置工作目录
+WORKDIR /app
+
+# 使用非 root 用户运行
+USER appuser
+
+# 暴露端口
+EXPOSE 7860
+
+
+# 运行应用
+CMD ["/app/augment2api"] 

api/auth.go

@@ -0,0 +1,43 @@
+package api
+
+import (
+	"augment2api/config"
+	"augment2api/pkg/logger"
+	"fmt"
+	"net/http"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+)
+
+// AuthMiddleware 验证请求的Authorization header
+func AuthMiddleware() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		// 如果未设置 AuthToken，则不启用鉴权
+		if config.AppConfig.AuthToken == "" {
+			c.Next()
+			return
+		}
+
+		authHeader := c.GetHeader("Authorization")
+		if authHeader == "" {
+			logger.Log.Error("Authorization is empty")
+			c.JSON(http.StatusUnauthorized, gin.H{"error": "Authorization header is required"})
+			c.Abort()
+			return
+		}
+
+		// 支持 "Bearer <token>" 格式
+		token := strings.TrimPrefix(authHeader, "Bearer ")
+		token = strings.TrimSpace(token)
+
+		if token != config.AppConfig.AuthToken {
+			logger.Log.Error(fmt.Sprintf("Invalid authorization token:%s", token))
+			c.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid authorization token"})
+			c.Abort()
+			return
+		}
+
+		c.Next()
+	}
+}

api/handler.go

@@ -0,0 +1,1358 @@
+package api
+
+import (
+	"augment2api/config"
+	"augment2api/pkg/logger"
+	"bufio"
+	"crypto/sha256"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"math/rand"
+	"net/http"
+	"net/url"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
+	"github.com/sirupsen/logrus"
+)
+
+// OpenAIRequest OpenAI兼容的请求结构
+type OpenAIRequest struct {
+	Model       string        `json:"model,omitempty"`
+	Messages    []ChatMessage `json:"messages,omitempty"`
+	Stream      bool          `json:"stream,omitempty"`
+	Temperature float64       `json:"temperature,omitempty"`
+	MaxTokens   int           `json:"max_tokens,omitempty"`
+}
+
+// OpenAIResponse OpenAI兼容的响应结构
+type OpenAIResponse struct {
+	ID      string   `json:"id"`
+	Object  string   `json:"object"`
+	Created int64    `json:"created"`
+	Model   string   `json:"model"`
+	Choices []Choice `json:"choices"`
+	Usage   Usage    `json:"usage"`
+}
+
+// OpenAIStreamResponse OpenAI兼容的流式响应结构
+type OpenAIStreamResponse struct {
+	ID      string         `json:"id"`
+	Object  string         `json:"object"`
+	Created int64          `json:"created"`
+	Model   string         `json:"model"`
+	Choices []StreamChoice `json:"choices"`
+}
+
+type StreamChoice struct {
+	Index        int         `json:"index"`
+	Delta        ChatMessage `json:"delta"`
+	FinishReason *string     `json:"finish_reason"`
+}
+
+type Choice struct {
+	Index        int         `json:"index"`
+	Message      ChatMessage `json:"message"`
+	FinishReason *string     `json:"finish_reason"`
+}
+
+type ChatMessage struct {
+	Role    string      `json:"role"`
+	Content interface{} `json:"content"`
+}
+
+// GetContent 添加一个辅助方法来获取消息内容
+func (m ChatMessage) GetContent() string {
+	switch v := m.Content.(type) {
+	case string:
+		return v
+	case []interface{}:
+		var result string
+		for _, item := range v {
+			if contentMap, ok := item.(map[string]interface{}); ok {
+				if text, exists := contentMap["text"]; exists {
+					if textStr, ok := text.(string); ok {
+						result += textStr
+					}
+				}
+			}
+		}
+		return result
+	default:
+		return ""
+	}
+}
+
+type Usage struct {
+	PromptTokens     int `json:"prompt_tokens"`
+	CompletionTokens int `json:"completion_tokens"`
+	TotalTokens      int `json:"total_tokens"`
+}
+
+// ToolDefinition 工具定义结构
+type ToolDefinition struct {
+	Name            string `json:"name"`
+	Description     string `json:"description"`
+	InputSchemaJSON string `json:"input_schema_json"`
+	ToolSafety      int    `json:"tool_safety"`
+}
+
+// Node 节点结构
+type Node struct {
+	ID          int         `json:"id"`
+	Type        int         `json:"type"`
+	Content     string      `json:"content"`
+	ToolUse     ToolUse     `json:"tool_use"`
+	AgentMemory AgentMemory `json:"agent_memory"`
+}
+
+type ToolUse struct {
+	ToolUseID string `json:"tool_use_id"`
+	ToolName  string `json:"tool_name"`
+	InputJSON string `json:"input_json"`
+}
+
+type AgentMemory struct {
+	Content string `json:"content"`
+}
+
+// AugmentRequest Augment API请求结构
+type AugmentRequest struct {
+	ChatHistory    []AugmentChatHistory `json:"chat_history"`
+	Message        string               `json:"message"`
+	AgentMemories  string               `json:"agent_memories"`
+	Mode           string               `json:"mode"`
+	Prefix         string               `json:"prefix"`
+	Suffix         string               `json:"suffix"`
+	Lang           string               `json:"lang"`
+	Path           string               `json:"path"`
+	UserGuideLines string               `json:"user_guidelines"`
+	Blobs          struct {
+		CheckpointID string        `json:"checkpoint_id"`
+		AddedBlobs   []interface{} `json:"added_blobs"`
+		DeletedBlobs []interface{} `json:"deleted_blobs"`
+	} `json:"blobs"`
+	UserGuidedBlobs       []interface{} `json:"user_guided_blobs"`
+	ExternalSourceIds     []interface{} `json:"external_source_ids"`
+	FeatureDetectionFlags struct {
+		SupportRawOutput bool `json:"support_raw_output"`
+	} `json:"feature_detection_flags"`
+	ToolDefinitions []ToolDefinition `json:"tool_definitions"`
+	Nodes           []Node           `json:"nodes"`
+}
+
+type AugmentChatHistory struct {
+	ResponseText   string `json:"response_text"`
+	RequestMessage string `json:"request_message"`
+	RequestID      string `json:"request_id"`
+	RequestNodes   []Node `json:"request_nodes"`
+	ResponseNodes  []Node `json:"response_nodes"`
+}
+
+// AugmentResponse Augment API响应结构
+type AugmentResponse struct {
+	Text string `json:"text"`
+	Done bool   `json:"done"`
+}
+
+// CodeResponse 用于解析从授权服务返回的代码
+type CodeResponse struct {
+	Code      string `json:"code"`
+	State     string `json:"state"`
+	TenantURL string `json:"tenant_url"`
+}
+
+// ModelObject OpenAI模型对象结构
+type ModelObject struct {
+	ID      string `json:"id"`
+	Object  string `json:"object"`
+	Created int    `json:"created"`
+	OwnedBy string `json:"owned_by"`
+}
+
+// ModelsResponse OpenAI模型列表响应结构
+type ModelsResponse struct {
+	Object string        `json:"object"`
+	Data   []ModelObject `json:"data"`
+}
+
+// 全局变量
+var (
+	accessToken string
+	tenantURL   string
+)
+
+const (
+	// 错误信息
+	errBlocked = "Request blocked. Please reach out to support@augmentcode.com if you think this was a mistake."
+)
+
+// SetAuthInfo 设置认证信息
+func SetAuthInfo(token, tenant string) {
+	accessToken = token
+	tenantURL = tenant
+}
+
+// GetAuthInfo 获取认证信息
+func GetAuthInfo() (string, string) {
+	if config.AppConfig.CodingMode == "true" {
+		// 调试模式
+		return config.AppConfig.CodingToken, config.AppConfig.TenantURL
+	}
+
+	// 直接返回内存中的token和tenantURL
+	return accessToken, tenantURL
+}
+
+const (
+	// 默认提示，不加这个会导致Agent触发文件创建，回复截断
+	defaultPrompt = "Your are claude3.7, All replies cannot create, modify, or delete files, and must provide content directly!"
+	// 默认上下文，影响模型回复风格
+	defaultPrefix = "You are AI assistant,help me to solve problems!"
+)
+
+// generateCheckpointID 生成一个基于时间戳的SHA-256哈希值作为CheckpointID
+func generateCheckpointID() string {
+	// 使用当前时间戳作为输入
+	timestamp := fmt.Sprintf("%d", time.Now().UnixNano())
+	hash := sha256.New()
+	hash.Write([]byte(timestamp))
+	// 将哈希值转换为十六进制字符串
+	return fmt.Sprintf("%x", hash.Sum(nil))
+}
+
+// generatePath 生成一个随机文件路径（暂时无用）
+func generatePath() string {
+	extensions := []string{".txt", ".md", ".go", ".py", ".js", ".html", ".css"}
+	dirs := []string{"src", "docs", "test", "lib", "utils"}
+	dir := dirs[rand.Intn(len(dirs))]
+	ext := extensions[rand.Intn(len(extensions))]
+	filename := fmt.Sprintf("%x", rand.Int31())
+	return fmt.Sprintf("%s/%s%s", dir, filename, ext)
+}
+
+// convertToAugmentRequest 将OpenAI请求转换为Augment请求
+func convertToAugmentRequest(req OpenAIRequest) AugmentRequest {
+	// 确定模式和其他参数基于模型名称
+	mode := "CHAT" // 默认使用CHAT模式
+	userGuideLines := "must answer in Chinese."
+	includeToolDefinitions := false
+	includeDefaultPrompt := false
+
+	// 将模型名称转换为小写，然后检查后缀
+	modelLower := strings.ToLower(req.Model)
+
+	// 检查模型名称后缀 (不区分大小写)
+	if strings.HasSuffix(modelLower, "-chat") {
+		// 保持使用CHAT模式的默认设置
+		mode = "CHAT"
+	} else if strings.HasSuffix(modelLower, "-agent") {
+		// 使用AGENT模式
+		mode = "AGENT"
+		userGuideLines = "Answer in Chinese, do not use any tools, and for questions involving internet searches, please answer based on your existing knowledge."
+		includeToolDefinitions = true
+		includeDefaultPrompt = true
+	}
+
+	augmentReq := AugmentRequest{
+		Path:           "",                  // 这个是关联的项目文件路径，暂时传空，不影响对话
+		Mode:           mode,                // 根据模型名称决定模式
+		Prefix:         defaultPrefix,       // 固定前缀，影响模型回复风格
+		Suffix:         " ",                 // 固定后缀，暂时传空，不影响对话
+		Lang:           detectLanguage(req), // 简单检测当前对话语言类型，不传好像回答有问题
+		Message:        "",                  // 当前对话消息
+		UserGuideLines: userGuideLines,      // 根据模型类型设置指南
+		// 初始化为空列表
+		ChatHistory: make([]AugmentChatHistory, 0),
+		Blobs: struct {
+			CheckpointID string        `json:"checkpoint_id"`
+			AddedBlobs   []interface{} `json:"added_blobs"`
+			DeletedBlobs []interface{} `json:"deleted_blobs"`
+		}{
+			CheckpointID: generateCheckpointID(),
+			AddedBlobs:   make([]interface{}, 0),
+			DeletedBlobs: make([]interface{}, 0),
+		},
+		UserGuidedBlobs:   make([]interface{}, 0),
+		ExternalSourceIds: make([]interface{}, 0),
+		FeatureDetectionFlags: struct {
+			SupportRawOutput bool `json:"support_raw_output"`
+		}{
+			SupportRawOutput: true,
+		},
+		ToolDefinitions: []ToolDefinition{}, // 初始化为空
+		Nodes:           make([]Node, 0),
+	}
+
+	// 根据模型类型决定是否包含工具定义
+	if includeToolDefinitions {
+		augmentReq.ToolDefinitions = getFullToolDefinitions()
+	}
+
+	// 处理消息历史
+	if len(req.Messages) > 1 { // 有历史消息
+		// 每次处理一对消息（用户问题和助手回答）
+		for i := 0; i < len(req.Messages)-1; i += 2 {
+			if i+1 < len(req.Messages) {
+				userMsg := req.Messages[i]
+				assistantMsg := req.Messages[i+1]
+
+				chatHistory := AugmentChatHistory{
+					RequestMessage: userMsg.GetContent(),
+					ResponseText:   assistantMsg.GetContent(),
+					RequestID:      generateRequestID(), // 生成唯一的请求ID
+					RequestNodes:   make([]Node, 0),
+					ResponseNodes: []Node{
+						{
+							ID:      0,
+							Type:    0,
+							Content: assistantMsg.GetContent(),
+							ToolUse: ToolUse{
+								ToolUseID: "",
+								ToolName:  "",
+								InputJSON: "",
+							},
+							AgentMemory: AgentMemory{
+								Content: "",
+							},
+						},
+					},
+				}
+				augmentReq.ChatHistory = append(augmentReq.ChatHistory, chatHistory)
+			}
+		}
+	}
+
+	// 设置当前消息
+	if len(req.Messages) > 0 {
+		lastMsg := req.Messages[len(req.Messages)-1]
+		if includeDefaultPrompt {
+			augmentReq.Message = defaultPrompt + "\n" + lastMsg.GetContent()
+		} else {
+			augmentReq.Message = lastMsg.GetContent()
+		}
+	}
+
+	return augmentReq
+}
+
+// generateRequestID 生成唯一的请求ID
+func generateRequestID() string {
+	// 使用UUID v4生成唯一ID
+	return uuid.New().String()
+}
+
+// detectLanguage 检测编程语言
+func detectLanguage(req OpenAIRequest) string {
+	if len(req.Messages) == 0 {
+		return ""
+	}
+
+	content := req.Messages[len(req.Messages)-1].GetContent()
+	// 简单判断一下当前对话语言类型
+	if strings.Contains(strings.ToLower(content), "html") {
+		return "HTML"
+	} else if strings.Contains(strings.ToLower(content), "python") {
+		return "Python"
+	} else if strings.Contains(strings.ToLower(content), "javascript") {
+		return "JavaScript"
+	} else if strings.Contains(strings.ToLower(content), "go") {
+		return "Go"
+	} else if strings.Contains(strings.ToLower(content), "rust") {
+		return "Rust"
+	} else if strings.Contains(strings.ToLower(content), "java") {
+		return "Java"
+	} else if strings.Contains(strings.ToLower(content), "c++") {
+		return "C++"
+	} else if strings.Contains(strings.ToLower(content), "c#") {
+		return "C#"
+	} else if strings.Contains(strings.ToLower(content), "php") {
+		return "PHP"
+	} else if strings.Contains(strings.ToLower(content), "ruby") {
+		return "Ruby"
+	} else if strings.Contains(strings.ToLower(content), "swift") {
+		return "Swift"
+	} else if strings.Contains(strings.ToLower(content), "kotlin") {
+		return "Kotlin"
+	} else if strings.Contains(strings.ToLower(content), "typescript") {
+		return "TypeScript"
+	} else if strings.Contains(strings.ToLower(content), "c") {
+		return "C"
+	}
+	return "HTML"
+}
+
+// getFullToolDefinitions 返回官方定义的完整工具定义列表
+// TODO 验证实际作用
+func getFullToolDefinitions() []ToolDefinition {
+	return []ToolDefinition{
+		{
+			Name:        "web-search",
+			Description: "Search the web for information. Returns results in markdown format.\nEach result includes the URL, title, and a snippet from the page if available.\n\nThis tool uses Google's Custom Search API to find relevant web pages.",
+			InputSchemaJSON: `{
+				"description": "Input schema for the web search tool.",
+				"properties": {
+					"query": {
+						"description": "The search query to send.",
+						"title": "Query",
+						"type": "string"
+					},
+					"num_results": {
+						"default": 5,
+						"description": "Number of results to return",
+						"maximum": 10,
+						"minimum": 1,
+						"title": "Num Results",
+						"type": "integer"
+					}
+				},
+				"required": ["query"],
+				"title": "WebSearchInput",
+				"type": "object"
+			}`,
+			ToolSafety: 0,
+		},
+		{
+			Name:        "web-fetch",
+			Description: "Fetches data from a webpage and converts it into Markdown.\n\n1. The tool takes in a URL and returns the content of the page in Markdown format;\n2. If the return is not valid Markdown, it means the tool cannot successfully parse this page.",
+			InputSchemaJSON: `{
+				"type": "object",
+				"properties": {
+					"url": {
+						"type": "string",
+						"description": "The URL to fetch."
+					}
+				},
+				"required": ["url"]
+			}`,
+			ToolSafety: 0,
+		},
+		{
+			Name:        "codebase-retrieval",
+			Description: "This tool is Augment's context engine, the world's best codebase context engine. It:\n1. Takes in a natural language description of the code you are looking for;\n2. Uses a proprietary retrieval/embedding model suite that produces the highest-quality recall of relevant code snippets from across the codebase;\n3. Maintains a real-time index of the codebase, so the results are always up-to-date and reflects the current state of the codebase;\n4. Can retrieve across different programming languages;\n5. Only reflects the current state of the codebase on the disk, and has no information on version control or code history.",
+			InputSchemaJSON: `{
+				"type": "object",
+				"properties": {
+					"information_request": {
+						"type": "string",
+						"description": "A description of the information you need."
+					}
+				},
+				"required": ["information_request"]
+			}`,
+			ToolSafety: 1,
+		},
+		{
+			Name:        "shell",
+			Description: "Execute a shell command.\n\n- You can use this tool to interact with the user's local version control system. Do not use the\nretrieval tool for that purpose.\n- If there is a more specific tool available that can perform the function, use that tool instead of\nthis one.\n\nThe OS is darwin. The shell is 'bash'.",
+			InputSchemaJSON: `{
+				"type": "object",
+				"properties": {
+					"command": {
+						"type": "string",
+						"description": "The shell command to execute."
+					}
+				},
+				"required": ["command"]
+			}`,
+			ToolSafety: 2,
+		},
+		{
+			Name:        "str-replace-editor",
+			Description: "Custom editing tool for viewing, creating and editing files\n* `path` is a file path relative to the workspace root\n* command `view` displays the result of applying `cat -n`.\n* If a `command` generates a long output, it will be truncated and marked with `<response clipped>`\n* `insert` and `str_replace` commands output a snippet of the edited section for each entry. This snippet reflects the final state of the file after all edits and IDE auto-formatting have been applied.\n\n\nNotes for using the `str_replace` command:\n* Use the `str_replace_entries` parameter with an array of objects\n* Each object should have `old_str`, `new_str`, `old_str_start_line_number` and `old_str_end_line_number` properties\n* The `old_str_start_line_number` and `old_str_end_line_number` parameters are 1-based line numbers\n* Both `old_str_start_line_number` and `old_str_end_line_number` are INCLUSIVE\n* The `old_str` parameter should match EXACTLY one or more consecutive lines from the original file. Be mindful of whitespace!\n* Empty `old_str` is allowed only when the file is empty or contains only whitespaces\n* It is important to specify `old_str_start_line_number` and `old_str_end_line_number` to disambiguate between multiple occurrences of `old_str` in the file\n* Make sure that `old_str_start_line_number` and `old_str_end_line_number` do not overlap with other entries in `str_replace_entries`\n* The `new_str` parameter should contain the edited lines that should replace the `old_str`. Can be an empty string to delete content\n\nNotes for using the `insert` command:\n* Use the `insert_line_entries` parameter with an array of objects\n* Each object should have `insert_line` and `new_str` properties\n* The `insert_line` parameter specifies the line number after which to insert the new string\n* The `insert_line` parameter is 1-based line number\n* To insert at the very beginning of the file, use `insert_line: 0`\n\nNotes for using the `view` command:\n* Strongly prefer to use larger ranges of at least 1000 lines when scanning through files. One call with large range is much more efficient than many calls with small ranges\n* Prefer to use grep instead of view when looking for a specific symbol in the file\n\nIMPORTANT:\n* This is the only tool you should use for editing files.\n* If it fails try your best to fix inputs and retry.\n* DO NOT fall back to removing the whole file and recreating it from scratch.\n* DO NOT use sed or any other command line tools for editing files.\n* Try to fit as many edits in one tool call as possible\n* Use view command to read the file before editing it.\n",
+			InputSchemaJSON: `{
+				"type": "object",
+				"properties": {
+					"command": {
+						"type": "string",
+						"enum": ["view", "str_replace", "insert"],
+						"description": "The commands to run. Allowed options are: 'view', 'str_replace', 'insert'."
+					},
+					"path": {
+						"description": "Full path to file relative to the workspace root, e.g. 'services/api_proxy/file.py' or 'services/api_proxy'.",
+						"type": "string"
+					},
+					"view_range": {
+						"description": "Optional parameter of 'view' command when 'path' points to a file. If none is given, the full file is shown. If provided, the file will be shown in the indicated line number range, e.g. [11, 12] will show lines 11 and 12. Indexing at 1 to start. Setting '[start_line, -1]' shows all lines from 'start_line' to the end of the file.",
+						"type": "array",
+						"items": {
+							"type": "integer"
+						}
+					},
+					"insert_line_entries": {
+						"description": "Required parameter of 'insert' command. A list of entries to insert. Each entry is a dictionary with keys 'insert_line' and 'new_str'.",
+						"type": "array",
+						"items": {
+							"type": "object",
+							"properties": {
+								"insert_line": {
+									"description": "The line number after which to insert the new string. This line number is relative to the state of the file before any insertions in the current tool call have been applied.",
+									"type": "integer"
+								},
+								"new_str": {
+									"description": "The string to insert. Can be an empty string.",
+									"type": "string"
+								}
+							},
+							"required": ["insert_line", "new_str"]
+						}
+					},
+					"str_replace_entries": {
+						"description": "Required parameter of 'str_replace' command. A list of entries to replace. Each entry is a dictionary with keys 'old_str', 'old_str_start_line_number', 'old_str_end_line_number' and 'new_str'. 'old_str' from different entries should not overlap.",
+						"type": "array",
+						"items": {
+							"type": "object",
+							"properties": {
+								"old_str": {
+									"description": "The string in 'path' to replace.",
+									"type": "string"
+								},
+								"old_str_start_line_number": {
+									"description": "The line number of the first line of 'old_str' in the file. This is used to disambiguate between multiple occurrences of 'old_str' in the file.",
+									"type": "integer"
+								},
+								"old_str_end_line_number": {
+									"description": "The line number of the last line of 'old_str' in the file. This is used to disambiguate between multiple occurrences of 'old_str' in the file.",
+									"type": "integer"
+								},
+								"new_str": {
+									"description": "The string to replace 'old_str' with. Can be an empty string to delete content.",
+									"type": "string"
+								}
+							},
+							"required": ["old_str", "new_str", "old_str_start_line_number", "old_str_end_line_number"]
+						}
+					}
+				},
+				"required": ["command", "path"]
+			}`,
+			ToolSafety: 1,
+		},
+		{
+			Name:        "save-file",
+			Description: "Save a file.",
+			InputSchemaJSON: `{
+				"type": "object",
+				"properties": {
+					"file_path": {
+						"type": "string",
+						"description": "The path of the file to save."
+					},
+					"file_content": {
+						"type": "string",
+						"description": "The content of the file to save."
+					},
+					"add_last_line_newline": {
+						"type": "boolean",
+						"description": "Whether to add a newline at the end of the file (default: true)."
+					}
+				},
+				"required": ["file_path", "file_content"]
+			}`,
+			ToolSafety: 1,
+		},
+		{
+			Name:        "launch-process",
+			Description: "Launch a new process.\nIf wait is specified, waits up to that many seconds for the process to complete.\nIf the process completes within wait seconds, returns its output.\nIf it doesn't complete within wait seconds, returns partial output and process ID.\nIf wait is not specified, returns immediately with just the process ID.\nThe process's stdin is always enbled, so you can use write_process to send input if needed.",
+			InputSchemaJSON: `{
+				"type": "object",
+				"properties": {
+					"command": {
+						"type": "string",
+						"description": "The shell command to execute"
+					},
+					"wait": {
+						"type": "number",
+						"description": "Optional: number of seconds to wait for the command to complete."
+					},
+					"cwd": {
+						"type": "string",
+						"description": "Working directory for the command. If not supplied, uses the current working directory."
+					}
+				},
+				"required": ["command"]
+			}`,
+			ToolSafety: 2,
+		},
+		{
+			Name:        "read-process",
+			Description: "Read output from a terminal.",
+			InputSchemaJSON: `{
+				"type": "object",
+				"properties": {
+					"terminal_id": {
+						"type": "number",
+						"description": "Terminal ID to read from."
+					}
+				},
+				"required": ["terminal_id"]
+			}`,
+			ToolSafety: 1,
+		},
+		{
+			Name:        "kill-process",
+			Description: "Kill a process by its terminal ID.",
+			InputSchemaJSON: `{
+				"type": "object",
+				"properties": {
+					"terminal_id": {
+						"type": "number",
+						"description": "Terminal ID to kill."
+					}
+				},
+				"required": ["terminal_id"]
+			}`,
+			ToolSafety: 1,
+		},
+	}
+}
+
+// AuthHandler 处理授权请求
+func AuthHandler(c *gin.Context, authorizeURL string) {
+	c.JSON(http.StatusOK, gin.H{
+		"authorize_url": authorizeURL,
+	})
+}
+
+// CallbackHandler 处理回调请求
+func CallbackHandler(c *gin.Context, getAccessTokenFunc func(string, string, string) (string, error)) {
+	// 1. 解析请求数据
+	var codeResp CodeResponse
+	if err := c.ShouldBindJSON(&codeResp); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "无效的请求数据"})
+		return
+	}
+
+	// 2. 使用授权码获取访问令牌
+	token, err := getAccessTokenFunc(codeResp.TenantURL, "", codeResp.Code)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	// 3. 保存令牌和租户URL
+	SetAuthInfo(token, codeResp.TenantURL)
+
+	// 4. 保存到Redis
+	if err := SaveTokenToRedis(token, codeResp.TenantURL); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "保存token到Redis失败: " + err.Error()})
+		return
+	}
+
+	// 5. 返回成功响应
+	c.JSON(http.StatusOK, gin.H{
+		"status": "success",
+		"token":  token,
+	})
+}
+
+// ModelsHandler 处理模型请求
+func ModelsHandler(c *gin.Context) {
+	// 这里直接返回写死的模型
+	response := ModelsResponse{
+		Object: "list",
+		Data: []ModelObject{
+			{
+				ID:      "claude-3.7-agent",
+				Object:  "model",
+				Created: 1708387200,
+				OwnedBy: "anthropic",
+			},
+			{
+				ID:      "augment-chat",
+				Object:  "model",
+				Created: 1708387200,
+				OwnedBy: "augment",
+			},
+		},
+	}
+
+	c.JSON(http.StatusOK, response)
+}
+
+// ChatCompletionsHandler 处理OpenAI兼容的聊天完成请求
+func ChatCompletionsHandler(c *gin.Context) {
+	// 获取请求数据
+	var req OpenAIRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "无效的请求数据"})
+		// 确保在错误情况下也清理请求状态
+		cleanupRequestStatus(c)
+		return
+	}
+
+	// 转换为Augment请求格式
+	augmentReq := convertToAugmentRequest(req)
+
+	// 处理流式请求
+	if req.Stream {
+		handleStreamRequest(c, augmentReq, req.Model)
+		return
+	}
+
+	// 处理非流式请���
+	handleNonStreamRequest(c, augmentReq, req.Model)
+}
+
+// 处理流式请求
+func handleStreamRequest(c *gin.Context, augmentReq AugmentRequest, model string) {
+	defer cleanupRequestStatus(c)
+
+	c.Header("Content-Type", "text/event-stream")
+	c.Header("Cache-Control", "no-cache")
+	c.Header("Connection", "keep-alive")
+
+	// 从上下文中获取token和tenant_url
+	tokenInterface, exists := c.Get("token")
+	tenantURLInterface, exists2 := c.Get("tenant_url")
+
+	var token, tenant string
+
+	if exists && exists2 {
+		token, _ = tokenInterface.(string)
+		tenant, _ = tenantURLInterface.(string)
+	}
+
+	// 如果上下文中没有，则使用GetAuthInfo获取
+	if token == "" || tenant == "" {
+		token, tenant = GetAuthInfo()
+	}
+
+	if token == "" || tenant == "" {
+		c.JSON(http.StatusUnauthorized, gin.H{"error": "无可用Token,请先在管理页面获取"})
+		return
+	}
+
+	// 增加token使用计数
+	incrementTokenUsage(token, model)
+
+	// 准备请求数据
+	jsonData, err := json.Marshal(augmentReq)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "序列化请求失败"})
+		return
+	}
+
+	// 创建请求
+	req, err := http.NewRequest("POST", tenant+"chat-stream", strings.NewReader(string(jsonData)))
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "创建请求失败"})
+		return
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", "Bearer "+token)
+	req.Header.Set("User-Agent", "augment.intellij/0.160.0 (Mac OS X; aarch64; 15.2) WebStorm/2024.3.5")
+	req.Header.Set("x-api-version", "2")
+	req.Header.Set("x-request-id", uuid.New().String())
+	req.Header.Set("x-request-session-id", uuid.New().String())
+
+	// 使用createHTTPClient创建客户端
+	client := createHTTPClient()
+
+	// 设置刷新器以确保数据立即发送
+	flusher, ok := c.Writer.(http.Flusher)
+	if !ok {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "流式传输不支持"})
+		return
+	}
+
+	// 第一次尝试使用原始模式请求
+	resp, err := client.Do(req)
+	if err != nil {
+		logger.Log.WithFields(logrus.Fields{
+			"error": err.Error(),
+			"mode":  augmentReq.Mode,
+		}).Error("请求失败")
+
+		// 切换到CHAT模式
+		augmentReq.Mode = "CHAT"
+		augmentReq.UserGuideLines = "使用中文回答"
+		augmentReq.ToolDefinitions = []ToolDefinition{}
+
+		// 重新准备请求数据
+		jsonData, err = json.Marshal(augmentReq)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": "序列化请求失败"})
+			return
+		}
+
+		// 创建新的请求
+		req, err = http.NewRequest("POST", tenant+"chat-stream", strings.NewReader(string(jsonData)))
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": "创建请求失败"})
+			return
+		}
+
+		// 设置相同的请求头
+		req.Header.Set("Content-Type", "application/json")
+		req.Header.Set("Authorization", "Bearer "+token)
+		req.Header.Set("User-Agent", "augment.intellij/0.160.0 (Mac OS X; aarch64; 15.2) WebStorm/2024.3.5")
+		req.Header.Set("x-api-version", "2")
+		req.Header.Set("x-request-id", uuid.New().String())
+		req.Header.Set("x-request-session-id", uuid.New().String())
+
+		// 重新发送请求
+		resp, err = client.Do(req)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": "请求失败: " + err.Error()})
+			return
+		}
+	}
+	defer resp.Body.Close()
+
+	// 检查响应状态码
+	if resp.StatusCode != http.StatusOK {
+		body, err := io.ReadAll(resp.Body)
+		errMsg := "Augment response error"
+		if err == nil {
+			errMsg = errMsg + ": " + string(body)
+		}
+		c.JSON(resp.StatusCode, gin.H{"error": errMsg})
+		return
+	}
+
+	// 读取并转发响应
+	reader := bufio.NewReader(resp.Body)
+	responseID := fmt.Sprintf("chatcmpl-%d", time.Now().Unix())
+
+	var fullText string
+	var hasError bool
+
+	for {
+		line, err := reader.ReadString('\n')
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			logger.Log.WithFields(logrus.Fields{
+				"error": err.Error(),
+				"mode":  augmentReq.Mode,
+			}).Error("读取响应失败")
+
+			// 切换到CHAT模式
+			if augmentReq.Mode != "CHAT" {
+				logger.Log.WithFields(logrus.Fields{
+					"error": err.Error(),
+					"mode":  augmentReq.Mode,
+				}).Info("切换到CHAT模式")
+
+				augmentReq.Mode = "CHAT"
+				augmentReq.UserGuideLines = "使用中文回答"
+				augmentReq.ToolDefinitions = []ToolDefinition{}
+
+				// 重新准备请求数据
+				jsonData, err = json.Marshal(augmentReq)
+				if err != nil {
+					c.JSON(http.StatusInternalServerError, gin.H{"error": "序列化请求失败"})
+					return
+				}
+
+				// 创建新的请求
+				req, err = http.NewRequest("POST", tenant+"chat-stream", strings.NewReader(string(jsonData)))
+				if err != nil {
+					c.JSON(http.StatusInternalServerError, gin.H{"error": "创建请求失败"})
+					return
+				}
+
+				// 设置相同的请求头
+				req.Header.Set("Content-Type", "application/json")
+				req.Header.Set("Authorization", "Bearer "+token)
+				req.Header.Set("User-Agent", "augment.intellij/0.160.0 (Mac OS X; aarch64; 15.2) WebStorm/2024.3.5")
+				req.Header.Set("x-api-version", "2")
+				req.Header.Set("x-request-id", uuid.New().String())
+				req.Header.Set("x-request-session-id", uuid.New().String())
+
+				// 重新发送请求
+				resp, err = client.Do(req)
+				if err != nil {
+					c.JSON(http.StatusInternalServerError, gin.H{"error": "请求失败: " + err.Error()})
+					return
+				}
+				defer resp.Body.Close()
+
+				// 检查响应状态码
+				if resp.StatusCode != http.StatusOK {
+					body, err := io.ReadAll(resp.Body)
+					errMsg := "Augment response error"
+					if err == nil {
+						errMsg = errMsg + ": " + string(body)
+					}
+					c.JSON(resp.StatusCode, gin.H{"error": errMsg})
+					return
+				}
+
+				// 重新设置reader
+				reader = bufio.NewReader(resp.Body)
+				continue
+			}
+			break
+		}
+
+		line = strings.TrimSpace(line)
+		if line == "" {
+			continue
+		}
+
+		var augmentResp AugmentResponse
+		if err := json.Unmarshal([]byte(line), &augmentResp); err != nil {
+			log.Printf("解析响应失败: %v", err)
+			continue
+		}
+
+		// 检查响应内容是否包含错误信息
+		if strings.Contains(augmentResp.Text, errBlocked) {
+			hasError = true
+
+			// 将当前token加入冷却队列，冷却时间10分钟
+			logger.Log.WithFields(logrus.Fields{
+				"token": token,
+				"mode":  augmentReq.Mode,
+			}).Info("检测到block信息，将token加入冷却队列10分钟")
+
+			err := SetTokenCoolStatus(token, 10*time.Minute)
+			if err != nil {
+				logger.Log.WithFields(logrus.Fields{
+					"token": token,
+					"error": err.Error(),
+				}).Error("将token加入冷却队列失败")
+			}
+
+			break
+		}
+
+		fullText += augmentResp.Text
+
+		// 创建OpenAI兼容的流式响应
+		streamResp := OpenAIStreamResponse{
+			ID:      responseID,
+			Object:  "chat.completion.chunk",
+			Created: time.Now().Unix(),
+			Model:   model,
+			Choices: []StreamChoice{
+				{
+					Index: 0,
+					Delta: ChatMessage{
+						Role:    "assistant",
+						Content: augmentResp.Text,
+					},
+					FinishReason: nil,
+				},
+			},
+		}
+
+		// 如果是最后一条消息，设置完成原因
+		if augmentResp.Done {
+			finishReason := "stop"
+			streamResp.Choices[0].FinishReason = &finishReason
+		}
+
+		// 序列化并发送响应
+		jsonResp, err := json.Marshal(streamResp)
+		if err != nil {
+			log.Printf("序列化响应失败: %v", err)
+			continue
+		}
+
+		fmt.Fprintf(c.Writer, "data: %s\n\n", jsonResp)
+		flusher.Flush()
+
+		// 如果完成，发送最后的[DONE]标记
+		if augmentResp.Done {
+			fmt.Fprintf(c.Writer, "data: [DONE]\n\n")
+			flusher.Flush()
+			break
+		}
+	}
+
+	// 如果检测到错误信息，尝试切换到CHAT模式重新请求
+	if hasError && augmentReq.Mode != "CHAT" {
+		logger.Log.WithFields(logrus.Fields{
+			"mode": augmentReq.Mode,
+		}).Info("检测到block信息，尝试切换到 CHAT 模式回复！")
+
+		// 切换到CHAT模式
+		augmentReq.Mode = "CHAT"
+		augmentReq.UserGuideLines = "使用中文回答"
+		augmentReq.ToolDefinitions = []ToolDefinition{}
+
+		// 重新准备请求数据
+		jsonData, err = json.Marshal(augmentReq)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": "序列化请求失败"})
+			return
+		}
+
+		// 创建新的请求
+		req, err = http.NewRequest("POST", tenant+"chat-stream", strings.NewReader(string(jsonData)))
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": "创建请求失败"})
+			return
+		}
+
+		// 设置相同的请求头
+		req.Header.Set("Content-Type", "application/json")
+		req.Header.Set("Authorization", "Bearer "+token)
+		req.Header.Set("User-Agent", "augment.intellij/0.160.0 (Mac OS X; aarch64; 15.2) WebStorm/2024.3.5")
+		req.Header.Set("x-api-version", "2")
+		req.Header.Set("x-request-id", uuid.New().String())
+		req.Header.Set("x-request-session-id", uuid.New().String())
+
+		// 重新发送请求
+		resp, err = client.Do(req)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": "请求失败: " + err.Error()})
+			return
+		}
+		defer resp.Body.Close()
+
+		// 检查响应状态码
+		if resp.StatusCode != http.StatusOK {
+			body, err := io.ReadAll(resp.Body)
+			errMsg := "Augment response error"
+			if err == nil {
+				errMsg = errMsg + ": " + string(body)
+			}
+			c.JSON(resp.StatusCode, gin.H{"error": errMsg})
+			return
+		}
+
+		// 读取并转发响应
+		reader = bufio.NewReader(resp.Body)
+		responseID = fmt.Sprintf("chatcmpl-%d", time.Now().Unix())
+
+		fullText = ""
+		for {
+			line, err := reader.ReadString('\n')
+			if err != nil {
+				if err == io.EOF {
+					break
+				}
+				log.Printf("读取响应失败: %v", err)
+				break
+			}
+
+			line = strings.TrimSpace(line)
+			if line == "" {
+				continue
+			}
+
+			var augmentResp AugmentResponse
+			if err := json.Unmarshal([]byte(line), &augmentResp); err != nil {
+				log.Printf("解析响应失败: %v", err)
+				continue
+			}
+
+			fullText += augmentResp.Text
+
+			// 创建OpenAI兼容的流式响应
+			streamResp := OpenAIStreamResponse{
+				ID:      responseID,
+				Object:  "chat.completion.chunk",
+				Created: time.Now().Unix(),
+				Model:   model,
+				Choices: []StreamChoice{
+					{
+						Index: 0,
+						Delta: ChatMessage{
+							Role:    "assistant",
+							Content: augmentResp.Text,
+						},
+						FinishReason: nil,
+					},
+				},
+			}
+
+			// 如果是最后一条消息，设置完成原因
+			if augmentResp.Done {
+				finishReason := "stop"
+				streamResp.Choices[0].FinishReason = &finishReason
+			}
+
+			// 序列化并发送响应
+			jsonResp, err := json.Marshal(streamResp)
+			if err != nil {
+				log.Printf("序列化响应失败: %v", err)
+				continue
+			}
+
+			fmt.Fprintf(c.Writer, "data: %s\n\n", jsonResp)
+			flusher.Flush()
+
+			// 如果完成，发送最后的[DONE]标记
+			if augmentResp.Done {
+				fmt.Fprintf(c.Writer, "data: [DONE]\n\n")
+				flusher.Flush()
+				break
+			}
+		}
+	}
+}
+
+// estimateTokenCount 粗略估计文本中的token数量
+// 这是一个简单的估算方法，实际token数量取决于具体的分词算法
+func estimateTokenCount(text string) int {
+	// 英文单词和标点符号大约是1个token
+	// 中文字符大约是1.5个token（每个字符约为0.75个token）
+	// 按空格分割英文单词
+	words := strings.Fields(text)
+	wordCount := len(words)
+
+	// 计算中文字符数量
+	chineseCount := 0
+	for _, r := range text {
+		if r >= 0x4E00 && r <= 0x9FFF {
+			chineseCount++
+		}
+	}
+
+	// 粗略估计：英文单词按1个token计算，中文字符按0.75个token计算
+	return wordCount + int(float64(chineseCount)*0.75)
+}
+
+// 处理非流式请求
+func handleNonStreamRequest(c *gin.Context, augmentReq AugmentRequest, model string) {
+	defer cleanupRequestStatus(c)
+
+	// 从上下文中获取token和tenant_url
+	tokenInterface, exists := c.Get("token")
+	tenantURLInterface, exists2 := c.Get("tenant_url")
+
+	var token, tenant string
+
+	if exists && exists2 {
+		token, _ = tokenInterface.(string)
+		tenant, _ = tenantURLInterface.(string)
+	}
+
+	// 如果上下文中没有，则使用GetAuthInfo获取
+	if token == "" || tenant == "" {
+		token, tenant = GetAuthInfo()
+	}
+
+	if token == "" || tenant == "" {
+		c.JSON(http.StatusUnauthorized, gin.H{"error": "无可用Token,请先在管理页面获取"})
+		return
+	}
+
+	// 增加token使用计数
+	incrementTokenUsage(token, model)
+
+	// 准备请求数据
+	jsonData, err := json.Marshal(augmentReq)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "序列化请求失败"})
+		return
+	}
+
+	// 打印请求参数
+	//log.Printf("发送到远程接口的请求参数: %s", string(jsonData))
+
+	// 创建请求 - 使用获取到的tenant_url
+	req, err := http.NewRequest("POST", tenant+"chat-stream", strings.NewReader(string(jsonData)))
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "创建请求失败"})
+		return
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+	// 使用获取到的token
+	req.Header.Set("Authorization", "Bearer "+token)
+
+	client := createHTTPClient()
+	resp, err := client.Do(req)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "请求失败: " + err.Error()})
+		return
+	}
+	defer resp.Body.Close()
+
+	// 检查响应状态码
+	if resp.StatusCode != http.StatusOK {
+		body, err := io.ReadAll(resp.Body)
+		errMsg := "Augment response error"
+		if err == nil {
+			errMsg = errMsg + ": " + string(body)
+		}
+		c.JSON(resp.StatusCode, gin.H{"error": errMsg})
+		return
+	}
+
+	// 读取完整响应
+	reader := bufio.NewReader(resp.Body)
+	var fullText string
+
+	for {
+		line, err := reader.ReadString('\n')
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			c.JSON(http.StatusInternalServerError, gin.H{"error": "读取响应失败: " + err.Error()})
+			return
+		}
+
+		line = strings.TrimSpace(line)
+		if line == "" {
+			continue
+		}
+
+		var augmentResp AugmentResponse
+		if err := json.Unmarshal([]byte(line), &augmentResp); err != nil {
+			continue
+		}
+
+		fullText += augmentResp.Text
+
+		// 检查响应内容是否包含错误信息
+		if strings.Contains(augmentResp.Text, errBlocked) {
+			// 将当前token加入冷却队列，冷却时间10分钟
+			logger.Log.WithFields(logrus.Fields{
+				"token": token,
+				"mode":  augmentReq.Mode,
+			}).Info("检测到block信息，将token加入冷却队列10分钟")
+
+			err := SetTokenCoolStatus(token, 10*time.Minute)
+			if err != nil {
+				logger.Log.WithFields(logrus.Fields{
+					"token": token,
+					"error": err.Error(),
+				}).Error("将token加入冷却队列失败")
+			}
+		}
+
+		if augmentResp.Done {
+			break
+		}
+	}
+
+	// 创建OpenAI兼容的响应
+	finishReason := "stop"
+
+	// 估算token数量
+	promptTokens := estimateTokenCount(augmentReq.Message)
+	for _, history := range augmentReq.ChatHistory {
+		promptTokens += estimateTokenCount(history.RequestMessage)
+		promptTokens += estimateTokenCount(history.ResponseText)
+	}
+	completionTokens := estimateTokenCount(fullText)
+
+	openAIResp := OpenAIResponse{
+		ID:      fmt.Sprintf("chatcmpl-%d", time.Now().Unix()),
+		Object:  "chat.completion",
+		Created: time.Now().Unix(),
+		Model:   model,
+		Choices: []Choice{
+			{
+				Index: 0,
+				Message: ChatMessage{
+					Role:    "assistant",
+					Content: fullText,
+				},
+				FinishReason: &finishReason,
+			},
+		},
+		Usage: Usage{
+			PromptTokens:     promptTokens,
+			CompletionTokens: completionTokens,
+			TotalTokens:      promptTokens + completionTokens,
+		},
+	}
+
+	c.JSON(http.StatusOK, openAIResp)
+}
+
+// 清理请求状态
+func cleanupRequestStatus(c *gin.Context) {
+	// 获取锁和 token
+	lockInterface, exists := c.Get("token_lock")
+	if !exists {
+		return
+	}
+
+	tokenInterface, exists := c.Get("token")
+	if !exists {
+		return
+	}
+
+	lock, ok := lockInterface.(*sync.Mutex)
+	if !ok {
+		return
+	}
+
+	token, ok := tokenInterface.(string)
+	if !ok {
+		return
+	}
+
+	// 更新请求状态为已完成
+	err := SetTokenRequestStatus(token, TokenRequestStatus{
+		InProgress:    false,
+		LastRequestAt: time.Now(),
+	})
+
+	// 无论更新状态是否成功，都要释放锁
+	defer lock.Unlock()
+
+	if err != nil {
+		log.Printf("清理请求状态失败: %v", err)
+		return
+	}
+}
+
+// 创建 HTTP 客户端，如果配置了代理则使用
+func createHTTPClient() *http.Client {
+	client := &http.Client{}
+
+	// 检查是否配置了代理
+	if config.AppConfig.ProxyURL != "" {
+		proxyURL, err := url.Parse(config.AppConfig.ProxyURL)
+		if err == nil {
+			transport := &http.Transport{
+				Proxy: http.ProxyURL(proxyURL),
+			}
+			client.Transport = transport
+			log.Printf("使用代理: %s", config.AppConfig.ProxyURL)
+		} else {
+			log.Printf("代理URL格式错误: %v", err)
+		}
+	}
+
+	return client
+}
+
+// 在处理聊天请求时增加token使用计数
+func incrementTokenUsage(token string, model string) {
+	// 先将模型名称转换为小写
+	modelLower := strings.ToLower(model)
+
+	// 根据模型类型确定计数键 (不区分大小写)
+	var countKey string
+	if strings.HasSuffix(modelLower, "-chat") {
+		countKey = "token_usage_chat:" + token
+	} else if strings.HasSuffix(modelLower, "-agent") {
+		countKey = "token_usage_agent:" + token
+	} else {
+		countKey = "token_usage:" + token // 默认键
+	}
+
+	// 使用Redis的INCR命令增加计数
+	err := config.RedisIncr(countKey)
+	if err != nil {
+		logger.Log.Error("增加token使用计数失败: %v", err)
+	}
+
+	// 同时增加总使用计数
+	totalCountKey := "token_usage:" + token
+	if countKey != totalCountKey { // 避免重复计数
+		err = config.RedisIncr(totalCountKey)
+		if err != nil {
+			logger.Log.Error("增加token总使用计数失败: %v", err)
+		}
+	}
+}

api/login.go

@@ -0,0 +1,134 @@
+package api
+
+import (
+	"augment2api/config"
+	"augment2api/pkg/logger"
+	"net/http"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
+)
+
+const (
+	TokenKey = "login:token:"
+)
+
+// 生成随机会话令牌
+func generateSessionToken() string {
+	tokenUUID := uuid.New()
+	return tokenUUID.String()
+}
+
+// LoginRequest 登录请求结构
+type LoginRequest struct {
+	Password string `json:"password"`
+}
+
+// LoginHandler 处理登录请求
+func LoginHandler(c *gin.Context) {
+	var req LoginRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{
+			"status": "error",
+			"error":  "无效的请求数据",
+		})
+		return
+	}
+
+	// 验证密码
+	if req.Password == config.AppConfig.AccessPwd {
+		// 生成会话令牌
+		token := generateSessionToken()
+
+		// 将会话令牌保存到Redis，有效期24小时
+		sessionKey := TokenKey + token
+		err := config.RedisSet(sessionKey, "valid", 24*time.Hour)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"status": "error",
+				"error":  "保存会话失败: " + err.Error(),
+			})
+			return
+		}
+
+		c.JSON(http.StatusOK, gin.H{
+			"status": "success",
+			"token":  token,
+		})
+		return
+	}
+
+	// 密码错误
+	c.JSON(http.StatusUnauthorized, gin.H{
+		"status": "error",
+		"error":  "密码错误",
+	})
+}
+
+// ValidateToken 验证Token
+func ValidateToken(token string) bool {
+	if token == "" {
+		return false
+	}
+
+	// 检查Redis中是否存在该token
+	tokenKey := TokenKey + token
+	exists, err := config.RedisExists(tokenKey)
+	if err != nil || !exists {
+		return false
+	}
+
+	return true
+}
+
+// AuthTokenMiddleware 会话认证中间件
+func AuthTokenMiddleware() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		// 如果未设置访问密码，则不需要验证
+		if config.AppConfig.AccessPwd == "" {
+			c.Next()
+			return
+		}
+
+		// 从查询参数或Cookie中获取会话令牌
+		token := c.GetHeader("X-Auth-Token")
+		if token == "" {
+			token = c.Query("token")
+		}
+		if token == "" {
+			token, _ = c.Cookie("auth_token")
+		}
+
+		// 验证会话令牌
+		if !ValidateToken(token) {
+			logger.Log.Info("无效的会话令牌:", token)
+			c.Redirect(http.StatusFound, "/login?error=token_expired")
+			c.Abort()
+			return
+		}
+
+		c.Next()
+	}
+}
+
+// LogoutHandler 处理登出请求
+func LogoutHandler(c *gin.Context) {
+	token := c.GetHeader("X-Auth-Token")
+	if token != "" {
+		// 从Redis中删除会话token
+		tokenKey := TokenKey + token
+		err := config.RedisDel(tokenKey)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"status": "error",
+				"error":  "删除会话失败: " + err.Error(),
+			})
+			return
+		}
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"status": "success",
+	})
+}

api/token_handler.go

@@ -0,0 +1,869 @@
+package api
+
+import (
+	"augment2api/config"
+	"augment2api/pkg/logger"
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"math/rand"
+	"net/http"
+	"strconv"
+	"sync"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/go-redis/redis/v8"
+	"github.com/google/uuid"
+	"github.com/sirupsen/logrus"
+)
+
+// TokenInfo 存储token信息
+type TokenInfo struct {
+	Token           string    `json:"token"`
+	TenantURL       string    `json:"tenant_url"`
+	UsageCount      int       `json:"usage_count"`        // 总对话次数
+	ChatUsageCount  int       `json:"chat_usage_count"`   // CHAT模式对话次数
+	AgentUsageCount int       `json:"agent_usage_count"`  // AGENT模式对话次数
+	Remark          string    `json:"remark"`             // 备注字段
+	InCool          bool      `json:"in_cool"`            // 是否在冷却中
+	CoolEnd         time.Time `json:"cool_end,omitempty"` // 冷却结束时间
+}
+
+// TokenItem token项结构
+type TokenItem struct {
+	Token     string `json:"token"`
+	TenantUrl string `json:"tenantUrl"`
+}
+
+// TokenRequestStatus 记录 token 请求状态
+type TokenRequestStatus struct {
+	InProgress    bool      `json:"in_progress"`
+	LastRequestAt time.Time `json:"last_request_at"`
+}
+
+// TokenCoolStatus 记录 token 冷却状态
+type TokenCoolStatus struct {
+	InCool  bool      `json:"in_cool"`
+	CoolEnd time.Time `json:"cool_end"`
+}
+
+// GetRedisTokenHandler 从Redis获取token列表，支持分页
+func GetRedisTokenHandler(c *gin.Context) {
+	// 获取分页参数（可选）
+	page := c.DefaultQuery("page", "1")
+	pageSize := c.DefaultQuery("page_size", "0") // 0表示不分页，返回所有
+
+	pageNum, _ := strconv.Atoi(page)
+	pageSizeNum, _ := strconv.Atoi(pageSize)
+
+	if pageNum < 1 {
+		pageNum = 1
+	}
+
+	// 获取所有token的key (使用通配符模式)
+	keys, err := config.RedisKeys("token:*")
+	if err != nil {
+		c.JSON(http.StatusOK, gin.H{
+			"status": "error",
+			"error":  "获取token列表失败: " + err.Error(),
+		})
+		return
+	}
+
+	// 如果没有token
+	if len(keys) == 0 {
+		c.JSON(http.StatusOK, gin.H{
+			"status":      "success",
+			"tokens":      []TokenInfo{},
+			"total":       0,
+			"page":        pageNum,
+			"page_size":   pageSizeNum,
+			"total_pages": 0,
+		})
+		return
+	}
+
+	// 构建token列表
+	var tokenList []TokenInfo
+	for _, key := range keys {
+		// 从key中提取token (格式: "token:{token}")
+		token := key[6:] // 去掉前缀 "token:"
+
+		// 获取对应的tenant_url
+		tenantURL, err := config.RedisHGet(key, "tenant_url")
+		if err != nil {
+			continue // 跳过无效的token
+		}
+
+		// 获取token状态
+		status, err := config.RedisHGet(key, "status")
+		if err == nil && status == "disabled" {
+			continue // 跳过被标记为不可用的token
+		}
+
+		// 获取备注信息
+		remark, _ := config.RedisHGet(key, "remark")
+
+		// 获取token的冷却状态
+		coolStatus, _ := GetTokenCoolStatus(token)
+
+		// 在获取token信息时，同时获取对话次数、备注和冷却状态
+		tokenList = append(tokenList, TokenInfo{
+			Token:           token,
+			TenantURL:       tenantURL,
+			UsageCount:      getTokenUsageCount(token),
+			ChatUsageCount:  getTokenChatUsageCount(token),
+			AgentUsageCount: getTokenAgentUsageCount(token),
+			Remark:          remark,
+			InCool:          coolStatus.InCool,
+			CoolEnd:         coolStatus.CoolEnd,
+		})
+	}
+
+	// 计算总页数和分页数据
+	totalItems := len(tokenList)
+	totalPages := 1
+
+	// 如果需要分页
+	if pageSizeNum > 0 {
+		totalPages = (totalItems + pageSizeNum - 1) / pageSizeNum
+
+		// 确保页码有效
+		if pageNum > totalPages && totalPages > 0 {
+			pageNum = totalPages
+		}
+
+		// 计算分页的起始和结束索引
+		startIndex := (pageNum - 1) * pageSizeNum
+		endIndex := startIndex + pageSizeNum
+
+		if startIndex < totalItems {
+			if endIndex > totalItems {
+				endIndex = totalItems
+			}
+			tokenList = tokenList[startIndex:endIndex]
+		} else {
+			tokenList = []TokenInfo{}
+		}
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"status":      "success",
+		"tokens":      tokenList,
+		"total":       totalItems,
+		"page":        pageNum,
+		"page_size":   pageSizeNum,
+		"total_pages": totalPages,
+	})
+}
+
+// SaveTokenToRedis 保存token到Redis
+func SaveTokenToRedis(token, tenantURL string) error {
+	// 创建一个唯一的key，包含token和tenant_url
+	tokenKey := "token:" + token
+
+	// token已存在，则跳过
+	exists, err := config.RedisExists(tokenKey)
+	if err != nil {
+		return err
+	}
+	if exists {
+		return nil
+	}
+
+	// 将tenant_url存储在token对应的哈希表中
+	err = config.RedisHSet(tokenKey, "tenant_url", tenantURL)
+	if err != nil {
+		return err
+	}
+
+	// 默认将新添加的token标记为活跃状态
+	err = config.RedisHSet(tokenKey, "status", "active")
+	if err != nil {
+		return err
+	}
+
+	// 初始化备注为空字符串
+	return config.RedisHSet(tokenKey, "remark", "")
+}
+
+// DeleteTokenHandler 删除指定的token
+func DeleteTokenHandler(c *gin.Context) {
+	token := c.Param("token")
+	if token == "" {
+		c.JSON(http.StatusBadRequest, gin.H{
+			"status": "error",
+			"error":  "未指定token",
+		})
+		return
+	}
+
+	tokenKey := "token:" + token
+
+	// 检查token是否存在
+	exists, err := config.RedisExists(tokenKey)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"status": "error",
+			"error":  "检查token失败: " + err.Error(),
+		})
+		return
+	}
+
+	if !exists {
+		c.JSON(http.StatusNotFound, gin.H{
+			"status": "error",
+			"error":  "token不存在",
+		})
+		return
+	}
+
+	// 删除token
+	if err := config.RedisDel(tokenKey); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"status": "error",
+			"error":  "删除token失败: " + err.Error(),
+		})
+		return
+	}
+
+	// 删除token关联的使用次数（如果存在）
+	// 删除总使用次数
+	tokenUsageKey := "token_usage:" + token
+	exists, err = config.RedisExists(tokenUsageKey)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"status": "error",
+			"error":  "检查token使用次数失败: " + err.Error(),
+		})
+		return
+	}
+	if exists {
+		if err := config.RedisDel(tokenUsageKey); err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"status": "error",
+				"error":  "删除token使用次数失败: " + err.Error(),
+			})
+		}
+	}
+
+	// 删除CHAT模式使用次数
+	tokenChatUsageKey := "token_usage_chat:" + token
+	exists, err = config.RedisExists(tokenChatUsageKey)
+	if err == nil && exists {
+		config.RedisDel(tokenChatUsageKey)
+	}
+
+	// 删除AGENT模式使用次数
+	tokenAgentUsageKey := "token_usage_agent:" + token
+	exists, err = config.RedisExists(tokenAgentUsageKey)
+	if err == nil && exists {
+		config.RedisDel(tokenAgentUsageKey)
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"status": "success",
+	})
+}
+
+// AddTokenHandler 批量添加token到Redis
+func AddTokenHandler(c *gin.Context) {
+	var tokens []TokenItem
+	if err := c.ShouldBindJSON(&tokens); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{
+			"status": "error",
+			"error":  "无效的请求数据",
+		})
+		return
+	}
+
+	// 检查是否有token数据
+	if len(tokens) == 0 {
+		c.JSON(http.StatusBadRequest, gin.H{
+			"status": "error",
+			"error":  "token列表为空",
+		})
+		return
+	}
+
+	// 批量保存token
+	successCount := 0
+	failedTokens := make([]string, 0)
+
+	for _, item := range tokens {
+		// 验证token格式
+		if item.Token == "" || item.TenantUrl == "" {
+			failedTokens = append(failedTokens, item.Token)
+			continue
+		}
+
+		// 保存到Redis
+		err := SaveTokenToRedis(item.Token, item.TenantUrl)
+		if err != nil {
+			failedTokens = append(failedTokens, item.Token)
+			continue
+		}
+		successCount++
+	}
+
+	// 返回处理结果
+	result := gin.H{
+		"status":        "success",
+		"total":         len(tokens),
+		"success_count": successCount,
+	}
+
+	if len(failedTokens) > 0 {
+		result["failed_tokens"] = failedTokens
+		result["failed_count"] = len(failedTokens)
+	}
+
+	c.JSON(http.StatusOK, result)
+}
+
+// CheckTokenTenantURL 检测token的租户地址
+func CheckTokenTenantURL(token string) (string, error) {
+	// 构建测试消息
+	testMsg := map[string]interface{}{
+		"message":              "hello，what is your name",
+		"mode":                 "CHAT",
+		"prefix":               "You are AI assistant,help me to solve problems!",
+		"suffix":               " ",
+		"lang":                 "HTML",
+		"user_guidelines":      "You are a helpful assistant, you can help me to solve problems and always answer in Chinese.",
+		"workspace_guidelines": "",
+		"feature_detection_flags": map[string]interface{}{
+			"support_raw_output": true,
+		},
+		"tool_definitions": []map[string]interface{}{},
+		"blobs": map[string]interface{}{
+			"checkpoint_id": nil,
+			"added_blobs":   []string{},
+			"deleted_blobs": []string{},
+		},
+	}
+
+	jsonData, err := json.Marshal(testMsg)
+	if err != nil {
+		return "", fmt.Errorf("序列化测试消息失败: %v", err)
+	}
+
+	tokenKey := "token:" + token
+
+	currentTenantURL, err := config.RedisHGet(tokenKey, "tenant_url")
+
+	var tenantURLResult string
+	var foundValid bool
+	var tenantURLsToTest []string
+
+	// 如果Redis中有有效的租户地址，优先测试该地址
+	if err == nil && currentTenantURL != "" {
+		tenantURLsToTest = append(tenantURLsToTest, currentTenantURL)
+	}
+
+	// 添加其他租户地址
+	for i := 20; i >= 1; i-- {
+		newTenantURL := fmt.Sprintf("https://d%d.api.augmentcode.com/", i)
+		// 避免重复测试已有的租户地址
+		if newTenantURL != currentTenantURL {
+			tenantURLsToTest = append(tenantURLsToTest, newTenantURL)
+		}
+	}
+
+	// 测试租户地址
+	for _, tenantURL := range tenantURLsToTest {
+		// 创建请求
+		req, err := http.NewRequest("POST", tenantURL+"chat-stream", bytes.NewReader(jsonData))
+		if err != nil {
+			continue
+		}
+
+		req.Header.Set("Content-Type", "application/json")
+		req.Header.Set("Authorization", "Bearer "+token)
+		req.Header.Set("User-Agent", "augment.intellij/0.160.0 (Mac OS X; aarch64; 15.2) WebStorm/2024.3.5")
+		req.Header.Set("x-api-version", "2")
+		req.Header.Set("x-request-id", uuid.New().String())
+		req.Header.Set("x-request-session-id", uuid.New().String())
+
+		client := createHTTPClient()
+		resp, err := client.Do(req)
+		if err != nil {
+			fmt.Printf("请求失败: %v\n", err)
+			continue
+		}
+
+		isInvalid := false
+		func() {
+			defer resp.Body.Close()
+
+			// 检查是否返回401状态码（未授权）
+			if resp.StatusCode == http.StatusUnauthorized {
+				// 读取响应体内容
+				buf := make([]byte, 1024)
+				n, readErr := resp.Body.Read(buf)
+				responseBody := ""
+				if readErr == nil && n > 0 {
+					responseBody = string(buf[:n])
+				}
+
+				// 只有当响应中包含"Invalid token"时才标记为不可用
+				if readErr == nil && n > 0 && bytes.Contains(buf[:n], []byte("Invalid token")) {
+					// 将token标记为不可用
+					err = config.RedisHSet(tokenKey, "status", "disabled")
+					if err != nil {
+						fmt.Printf("标记token为不可用失败: %v\n", err)
+					}
+					logger.Log.WithFields(logrus.Fields{
+						"token":         token,
+						"response_body": responseBody,
+					}).Info("token: 已被标记为不可用,返回401未授权")
+					isInvalid = true
+				}
+				return
+			}
+
+			// 检查响应状态
+			if resp.StatusCode == http.StatusOK {
+				// 尝试读取一小部分响应以确认是否有效
+				buf := make([]byte, 1024)
+				n, err := resp.Body.Read(buf)
+				if err == nil && n > 0 {
+					// 更新Redis中的租户地址和状态
+					err = config.RedisHSet(tokenKey, "tenant_url", tenantURL)
+					if err != nil {
+						return
+					}
+					// 将token标记为可用
+					err = config.RedisHSet(tokenKey, "status", "active")
+					if err != nil {
+						fmt.Printf("标记token为可用失败: %v\n", err)
+					}
+					logger.Log.WithFields(logrus.Fields{
+						"token":          token,
+						"new_tenant_url": tenantURL,
+					}).Info("token: 更新租户地址成功")
+					tenantURLResult = tenantURL
+					foundValid = true
+				}
+			}
+		}()
+
+		// 如果token无效，立即返回错误，不再测试其他地址
+		if isInvalid {
+			return "", fmt.Errorf("token被标记为不可用")
+		}
+
+		// 如果找到有效的租户地址，跳出循环
+		if foundValid {
+			return tenantURLResult, nil
+		}
+	}
+
+	return "", fmt.Errorf("未找到有效的租户地址")
+}
+
+// CheckAllTokensHandler 批量检测所有token的租户地址
+func CheckAllTokensHandler(c *gin.Context) {
+	// 获取所有token的key
+	keys, err := config.RedisKeys("token:*")
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"status": "error",
+			"error":  "获取token列表失败: " + err.Error(),
+		})
+		return
+	}
+
+	if len(keys) == 0 {
+		c.JSON(http.StatusOK, gin.H{
+			"status":   "success",
+			"total":    0,
+			"updated":  0,
+			"disabled": 0,
+		})
+		return
+	}
+
+	var wg sync.WaitGroup
+	// 使用互斥锁保护计数器
+	var mu sync.Mutex
+	var updatedCount int
+	var disabledCount int
+
+	for _, key := range keys {
+		// 获取token状态，跳过已标记为不可用的token
+		status, err := config.RedisHGet(key, "status")
+		if err == nil && status == "disabled" {
+			mu.Lock()
+			mu.Unlock()
+			continue // 跳过此token
+		}
+
+		wg.Add(1)
+		go func(key string) {
+			defer wg.Done()
+
+			// 从key中提取token
+			token := key[6:] // 去掉前缀 "token:"
+
+			// 获取当前的租户地址
+			oldTenantURL, _ := config.RedisHGet(key, "tenant_url")
+
+			// 检测租户地址
+			newTenantURL, err := CheckTokenTenantURL(token)
+			logger.Log.WithFields(logrus.Fields{
+				"token":          token,
+				"old_tenant_url": oldTenantURL,
+				"new_tenant_url": newTenantURL,
+			}).Info("检测token租户地址")
+
+			mu.Lock()
+			if err != nil && err.Error() == "token被标记为不可用" {
+				disabledCount++
+			} else if err == nil && newTenantURL != oldTenantURL {
+				updatedCount++
+			}
+			mu.Unlock()
+		}(key)
+	}
+
+	wg.Wait()
+
+	c.JSON(http.StatusOK, gin.H{
+		"status":   "success",
+		"total":    len(keys),
+		"updated":  updatedCount,
+		"disabled": disabledCount,
+	})
+}
+
+// SetTokenRequestStatus 设置token请求状态
+func SetTokenRequestStatus(token string, status TokenRequestStatus) error {
+	// 使用Redis存储token请求状态
+	key := "token_status:" + token
+
+	// 将状态转换为JSON
+	statusJSON, err := json.Marshal(status)
+	if err != nil {
+		return err
+	}
+
+	// 存储到Redis，设置过期时间为1小时
+	return config.RedisSet(key, string(statusJSON), time.Hour)
+}
+
+// GetTokenRequestStatus 获取token请求状态
+func GetTokenRequestStatus(token string) (TokenRequestStatus, error) {
+	key := "token_status:" + token
+
+	// 从Redis获取状态
+	statusJSON, err := config.RedisGet(key)
+	if err != nil {
+		// 如果key不存在，返回默认状态
+		if errors.Is(err, redis.Nil) {
+			return TokenRequestStatus{
+				InProgress:    false,
+				LastRequestAt: time.Time{}, // 零值时间
+			}, nil
+		}
+		return TokenRequestStatus{}, err
+	}
+
+	// 解析JSON
+	var status TokenRequestStatus
+	if err := json.Unmarshal([]byte(statusJSON), &status); err != nil {
+		return TokenRequestStatus{}, err
+	}
+
+	return status, nil
+}
+
+// SetTokenCoolStatus 将token加入冷却队列
+func SetTokenCoolStatus(token string, duration time.Duration) error {
+	// 使用Redis存储token冷却状态
+	key := "token_cool_status:" + token
+
+	coolStatus := TokenCoolStatus{
+		InCool:  true,
+		CoolEnd: time.Now().Add(duration),
+	}
+
+	// 将状态转换为JSON
+	coolStatusJSON, err := json.Marshal(coolStatus)
+	if err != nil {
+		return err
+	}
+
+	// 存储到Redis，设置过期时间与冷却时间相同
+	return config.RedisSet(key, string(coolStatusJSON), duration)
+}
+
+// GetTokenCoolStatus 获取token冷却状态
+func GetTokenCoolStatus(token string) (TokenCoolStatus, error) {
+	key := "token_cool_status:" + token
+
+	// 从Redis获取状态
+	coolStatusJSON, err := config.RedisGet(key)
+	if err != nil {
+		// 如果key不存在，返回默认状态
+		if errors.Is(err, redis.Nil) {
+			return TokenCoolStatus{
+				InCool:  false,
+				CoolEnd: time.Time{}, // 零值时间
+			}, nil
+		}
+		return TokenCoolStatus{}, err
+	}
+
+	// 解析JSON
+	var coolStatus TokenCoolStatus
+	if err := json.Unmarshal([]byte(coolStatusJSON), &coolStatus); err != nil {
+		return TokenCoolStatus{}, err
+	}
+
+	// 检查冷却时间是否已过
+	if time.Now().After(coolStatus.CoolEnd) {
+		coolStatus.InCool = false
+	}
+
+	return coolStatus, nil
+}
+
+// GetAvailableToken 获取一个可用的token（未在使用中且冷却时间已过）
+func GetAvailableToken() (string, string) {
+	// 获取所有token的key
+	keys, err := config.RedisKeys("token:*")
+	if err != nil || len(keys) == 0 {
+		return "No token", ""
+	}
+
+	// 筛选可用的token
+	var availableTokens []string
+	var availableTenantURLs []string
+	var cooldownTokens []string
+	var cooldownTenantURLs []string
+
+	for _, key := range keys {
+		// 获取token状态
+		status, err := config.RedisHGet(key, "status")
+		if err == nil && status == "disabled" {
+			continue // 跳过被标记为不可用的token
+		}
+
+		// 从key中提取token
+		token := key[6:] // 去掉前缀 "token:"
+
+		// 获取token的请求状态
+		requestStatus, err := GetTokenRequestStatus(token)
+		if err != nil {
+			continue
+		}
+
+		// 如果token正在使用中，跳过
+		if requestStatus.InProgress {
+			continue
+		}
+
+		// 如果距离上次请求不足3秒，跳过
+		if time.Since(requestStatus.LastRequestAt) < 3*time.Second {
+			continue
+		}
+
+		// 检查CHAT模式和AGENT模式的使用次数限制
+		chatUsageCount := getTokenChatUsageCount(token)
+		agentUsageCount := getTokenAgentUsageCount(token)
+
+		// 如果CHAT模式已达到3000次限制，跳过
+		if chatUsageCount >= 3000 {
+			continue
+		}
+
+		// 如果AGENT模式已达到50次限制，跳过
+		if agentUsageCount >= 50 {
+			continue
+		}
+
+		// 获取对应的tenant_url
+		tenantURL, err := config.RedisHGet(key, "tenant_url")
+		if err != nil {
+			continue
+		}
+
+		// 检查token是否在冷却中
+		coolStatus, err := GetTokenCoolStatus(token)
+		if err != nil {
+			continue
+		}
+
+		// 如果token在冷却中，放入冷却队列
+		if coolStatus.InCool {
+			cooldownTokens = append(cooldownTokens, token)
+			cooldownTenantURLs = append(cooldownTenantURLs, tenantURL)
+		} else {
+			// 否则放入可用队列
+			availableTokens = append(availableTokens, token)
+			availableTenantURLs = append(availableTenantURLs, tenantURL)
+		}
+	}
+
+	// 优先从可用队列中选择token
+	if len(availableTokens) > 0 {
+		// 随机选择一个token
+		randomIndex := rand.Intn(len(availableTokens))
+		return availableTokens[randomIndex], availableTenantURLs[randomIndex]
+	}
+
+	// 如果没有非冷却token可用，则从冷却队列中选择
+	if len(cooldownTokens) > 0 {
+		// 随机选择一个token
+		randomIndex := rand.Intn(len(cooldownTokens))
+		return cooldownTokens[randomIndex], cooldownTenantURLs[randomIndex]
+	}
+
+	// 如果没有任何可用的token
+	return "No available token", ""
+}
+
+// getTokenUsageCount 获取token的使用次数
+func getTokenUsageCount(token string) int {
+	// 使用Redis中的计数器获取使用次数
+	countKey := "token_usage:" + token
+	count, err := config.RedisGet(countKey)
+	if err != nil {
+		return 0 // 如果出错或不存在，返回0
+	}
+
+	// 将字符串转换为整数
+	countInt, err := strconv.Atoi(count)
+	if err != nil {
+		return 0
+	}
+
+	return countInt
+}
+
+// getTokenChatUsageCount 获取token的CHAT模式使用次数
+func getTokenChatUsageCount(token string) int {
+	// 使用Redis中的计数器获取使用次数
+	countKey := "token_usage_chat:" + token
+	count, err := config.RedisGet(countKey)
+	if err != nil {
+		return 0 // 如果出错或不存在，返回0
+	}
+
+	// 将字符串转换为整数
+	countInt, err := strconv.Atoi(count)
+	if err != nil {
+		return 0
+	}
+
+	return countInt
+}
+
+// getTokenAgentUsageCount 获取token的AGENT模式使用次数
+func getTokenAgentUsageCount(token string) int {
+	// 使用Redis中的计数器获取使用次数
+	countKey := "token_usage_agent:" + token
+	count, err := config.RedisGet(countKey)
+	if err != nil {
+		return 0 // 如果出错或不存在，返回0
+	}
+
+	// 将字符串转换为整数
+	countInt, err := strconv.Atoi(count)
+	if err != nil {
+		return 0
+	}
+
+	return countInt
+}
+
+// UpdateTokenRemark 更新token的备注信息
+func UpdateTokenRemark(c *gin.Context) {
+	token := c.Param("token")
+	if token == "" {
+		c.JSON(http.StatusBadRequest, gin.H{
+			"status": "error",
+			"error":  "未指定token",
+		})
+		return
+	}
+
+	var req struct {
+		Remark string `json:"remark"`
+	}
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{
+			"status": "error",
+			"error":  "无效的请求数据",
+		})
+		return
+	}
+
+	tokenKey := "token:" + token
+
+	// 检查token是否存在
+	exists, err := config.RedisExists(tokenKey)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"status": "error",
+			"error":  "检查token失败: " + err.Error(),
+		})
+		return
+	}
+
+	if !exists {
+		c.JSON(http.StatusNotFound, gin.H{
+			"status": "error",
+			"error":  "token不存在",
+		})
+		return
+	}
+
+	// 更新备注
+	err = config.RedisHSet(tokenKey, "remark", req.Remark)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"status": "error",
+			"error":  "更新备注失败: " + err.Error(),
+		})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"status": "success",
+	})
+}
+
+// MigrateTokensRemark 确保所有token都有remark字段
+func MigrateTokensRemark() error {
+	// 获取所有token的key
+	keys, err := config.RedisKeys("token:*")
+	if err != nil {
+		return fmt.Errorf("获取token列表失败: %v", err)
+	}
+
+	for _, key := range keys {
+		// 检查是否已有remark字段
+		exists, err := config.RedisHExists(key, "remark")
+		if err != nil {
+			logger.Log.Error("check remark field of token %s failed: %v", key, err)
+			continue
+		}
+
+		// 如果没有remark字段，添加一个空的remark
+		if !exists {
+			err = config.RedisHSet(key, "remark", "")
+			if err != nil {
+				logger.Log.Error("add remark field to token %s failed: %v", key, err)
+				continue
+			}
+			logger.Log.Info("add remark field to token %s success", key)
+		}
+	}
+	logger.Log.Info("migrate remark field to all tokens success!")
+
+	return nil
+}

api/token_reset.go

@@ -0,0 +1,96 @@
+package api
+
+import (
+	"augment2api/config"
+	"augment2api/pkg/logger"
+
+	"github.com/robfig/cron/v3"
+	"github.com/sirupsen/logrus"
+)
+
+// ResetTokenUsage 重置所有token的使用次数
+func ResetTokenUsage() error {
+	// 获取所有token的key
+	keys, err := config.RedisKeys("token:*")
+	if err != nil {
+		return err
+	}
+
+	for _, key := range keys {
+		// 从key中提取token
+		token := key[6:] // 去掉前缀 "token:"
+
+		// 重置总使用次数
+		totalUsageKey := "token_usage:" + token
+		err = config.RedisSet(totalUsageKey, "0", 0) // 0表示永不过期
+		if err != nil {
+			logger.Log.WithFields(logrus.Fields{
+				"token": token,
+				"error": err,
+			}).Error("重置Token总使用次数失败")
+			continue
+		}
+
+		// 重置CHAT模式使用次数
+		chatUsageKey := "token_usage_chat:" + token
+		err = config.RedisSet(chatUsageKey, "0", 0) // 0表示永不过期
+		if err != nil {
+			logger.Log.WithFields(logrus.Fields{
+				"token": token,
+				"error": err,
+			}).Error("重置Token CHAT模式使用次数失败")
+			continue
+		}
+
+		// 重置AGENT模式使用次数
+		agentUsageKey := "token_usage_agent:" + token
+		err = config.RedisSet(agentUsageKey, "0", 0) // 0表示永不过期
+		if err != nil {
+			logger.Log.WithFields(logrus.Fields{
+				"token": token,
+				"error": err,
+			}).Error("重置Token AGENT模式使用次数失败")
+			continue
+		}
+
+		logger.Log.WithFields(logrus.Fields{
+			"token": token,
+		}).Info("重置token使用次数成功")
+	}
+
+	return nil
+}
+
+// StartTokenUsageResetScheduler 启动token使用次数重置调度器
+func StartTokenUsageResetScheduler() {
+	// 创建cron调度器
+	c := cron.New(cron.WithSeconds()) // 启用秒级精度
+
+	// 添加定时任务，每月1号零点一分执行
+	// 格式：秒 分 时 日 月 周
+	_, err := c.AddFunc("0 1 0 1 * *", func() {
+		logger.Log.Info("开始执行Token使用次数重置任务")
+		err := ResetTokenUsage()
+		if err != nil {
+			logger.Log.WithFields(logrus.Fields{
+				"error": err,
+			}).Error("执行Token使用次数重置任务失败")
+		} else {
+			logger.Log.Info("Token使用次数重置任务执行完成")
+		}
+	})
+
+	if err != nil {
+		logger.Log.WithFields(logrus.Fields{
+			"error": err,
+		}).Error("添加Token使用次数重置定时任务失败")
+		return
+	}
+
+	// 启动cron调度器
+	c.Start()
+	logger.Log.Info("Token使用次数重置调度器启动成功!")
+
+	// 保持程序运行
+	select {}
+}

config/config.go

@@ -0,0 +1,75 @@
+package config
+
+import (
+	"augment2api/pkg/logger"
+	"os"
+)
+
+type Config struct {
+	RedisConnString string
+	AuthToken       string
+	CodingMode      string
+	CodingToken     string
+	TenantURL       string
+	AccessPwd       string
+	RoutePrefix     string
+	ProxyURL        string
+}
+
+const version = "v1.0.2"
+
+var AppConfig Config
+
+func InitConfig() error {
+	// 从环境变量读取配置
+	AppConfig = Config{
+		// 必填配置
+		RedisConnString: getEnv("REDIS_CONN_STRING", ""),
+		AccessPwd:       getEnv("ACCESS_PWD", ""),
+		// 非必填配置
+		AuthToken:   getEnv("AUTH_TOKEN", ""),   // api鉴权token
+		RoutePrefix: getEnv("ROUTE_PREFIX", ""), // 自定义openai接口路由前缀
+		CodingMode:  getEnv("CODING_MODE", "false"),
+		CodingToken: getEnv("CODING_TOKEN", ""),
+		TenantURL:   getEnv("TENANT_URL", ""),
+		ProxyURL:    getEnv("PROXY_URL", ""), // 代理URL配置
+	}
+
+	if AppConfig.CodingMode == "false" {
+
+		// redis连接字符串 示例: redis://default:pwd@localhost:6379
+		if AppConfig.RedisConnString == "" {
+			logger.Log.Fatalln("未配置环境变量 REDIS_CONN_STRING")
+		}
+
+	}
+
+	// 为了安全，必须配置访问密码
+	if AppConfig.AccessPwd == "" {
+		logger.Log.Fatalln("未配置环境变量 ACCESS_PWD")
+	}
+
+	// 打印欢迎信息
+	logger.Log.Info("Welcome to use Augment2Api! Current Version: " + version)
+
+	logger.Log.Info("Augment2Api配置加载完成:\n" +
+		"----------------------------------------\n" +
+		"AuthToken:    " + AppConfig.AuthToken + "\n" +
+		"AccessPwd:    " + AppConfig.AccessPwd + "\n" +
+		"RedisConnString: " + AppConfig.RedisConnString + "\n" +
+		"RoutePrefix: " + AppConfig.RoutePrefix + "\n" +
+		"ProxyURL: " + AppConfig.ProxyURL + "\n" +
+		"----------------------------------------")
+
+	logger.Log.Info("Everything is set up, now start to fully enjoy the charm of AI ！")
+
+	return nil
+}
+
+func getEnv(key, defaultValue string) string {
+	value := os.Getenv(key)
+	if value == "" {
+		return defaultValue
+	}
+	return value
+}

config/redis.go

@@ -0,0 +1,107 @@
+package config
+
+import (
+	"augment2api/pkg/logger"
+	"context"
+	"os"
+	"time"
+
+	"github.com/go-redis/redis/v8"
+)
+
+var RDB redis.Cmdable
+
+// InitRedisClient This function is called after init()
+func InitRedisClient() (err error) {
+
+	RedisConnString := AppConfig.RedisConnString
+	if RedisConnString == "" {
+		logger.Log.Debug("REDIS_CONN_STRING not set, Redis is not enabled")
+		return nil
+	}
+
+	opt, err := redis.ParseURL(RedisConnString)
+	if err != nil {
+		logger.Log.Fatalln("failed to parse Redis connection string: " + err.Error())
+	}
+	RDB = redis.NewClient(opt)
+
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	_, err = RDB.Ping(ctx).Result()
+	if err != nil {
+		logger.Log.Fatalln("Redis ping test failed: " + err.Error())
+	}
+	return err
+}
+
+func ParseRedisOption() *redis.Options {
+	opt, err := redis.ParseURL(os.Getenv("REDIS_CONN_STRING"))
+	if err != nil {
+		logger.Log.Fatalln("failed to parse Redis connection string: " + err.Error())
+	}
+	return opt
+}
+
+func RedisSet(key string, value string, expiration time.Duration) error {
+	ctx := context.Background()
+	return RDB.Set(ctx, key, value, expiration).Err()
+}
+
+func RedisGet(key string) (string, error) {
+	ctx := context.Background()
+	return RDB.Get(ctx, key).Result()
+}
+
+func RedisDel(key string) error {
+	ctx := context.Background()
+	return RDB.Del(ctx, key).Err()
+}
+
+// RedisHSet 设置哈希表字段值
+func RedisHSet(key, field, value string) error {
+	ctx := context.Background()
+	return RDB.HSet(ctx, key, field, value).Err()
+}
+
+// RedisHGet 获取哈希表字段值
+func RedisHGet(key, field string) (string, error) {
+	ctx := context.Background()
+	return RDB.HGet(ctx, key, field).Result()
+}
+
+// RedisExpire 设置键的过期时间
+func RedisExpire(key string, expiration time.Duration) error {
+	ctx := context.Background()
+	return RDB.Expire(ctx, key, expiration).Err()
+}
+
+// RedisKeys 获取匹配指定模式的所有键
+func RedisKeys(pattern string) ([]string, error) {
+	ctx := context.Background()
+	return RDB.Keys(ctx, pattern).Result()
+}
+
+// RedisExists 检查键是否存在
+func RedisExists(key string) (bool, error) {
+	ctx := context.Background()
+	result, err := RDB.Exists(ctx, key).Result()
+	if err != nil {
+		return false, err
+	}
+	return result > 0, nil
+}
+
+// RedisIncr 增加Redis中的计数器
+func RedisIncr(key string) error {
+	ctx := context.Background()
+	_, err := RDB.Incr(ctx, key).Result()
+	return err
+}
+
+// RedisHExists 检查哈希表字段是否存在
+func RedisHExists(key, field string) (bool, error) {
+	ctx := context.Background()
+	return RDB.HExists(ctx, key, field).Result()
+}

docker-compose.yml

@@ -0,0 +1,38 @@
+version: '3.8'
+
+services:
+  redis:
+    image: redis:alpine
+    restart: always
+    volumes:
+      - redis_data:/data
+    command: redis-server --requirepass $${REDIS_PASSWORD:-yourpassword}
+    healthcheck:
+      test: ["CMD", "redis-cli", "-a", "$${REDIS_PASSWORD:-yourpassword}", "ping"]
+      interval: 5s
+      timeout: 3s
+      retries: 5
+    environment:
+      - TZ=Asia/Shanghai
+      - REDIS_PASSWORD=${REDIS_PASSWORD:-yourpassword}
+
+  augment2api:
+    build: .
+    restart: always
+    ports:
+      - "27080:27080"
+    environment:
+      - REDIS_CONN_STRING=redis://default:${REDIS_PASSWORD:-yourpassword}@redis:6379
+      - ACCESS_PWD=${ACCESS_PWD:-your-access-password}
+      - AUTH_TOKEN=${AUTH_TOKEN:-your-auth-token}
+      - TZ=Asia/Shanghai
+    depends_on:
+      redis:
+        condition: service_healthy
+
+volumes:
+  redis_data:
+
+networks:
+  default:
+    driver: bridge 

go.mod

@@ -0,0 +1,46 @@
+module augment2api
+
+go 1.23.0
+
+toolchain go1.23.6
+
+require (
+	github.com/gin-contrib/cors v1.7.4
+	github.com/gin-gonic/gin v1.10.0
+	github.com/go-redis/redis/v8 v8.11.5
+	github.com/google/uuid v1.6.0
+	github.com/robfig/cron/v3 v3.0.1
+	github.com/sirupsen/logrus v1.9.3
+)
+
+require (
+	github.com/bytedance/sonic v1.12.6 // indirect
+	github.com/bytedance/sonic/loader v0.2.1 // indirect
+	github.com/cespare/xxhash/v2 v2.1.2 // indirect
+	github.com/cloudwego/base64x v0.1.4 // indirect
+	github.com/cloudwego/iasm v0.2.0 // indirect
+	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
+	github.com/gabriel-vasile/mimetype v1.4.7 // indirect
+	github.com/gin-contrib/sse v0.1.0 // indirect
+	github.com/go-playground/locales v0.14.1 // indirect
+	github.com/go-playground/universal-translator v0.18.1 // indirect
+	github.com/go-playground/validator/v10 v10.23.0 // indirect
+	github.com/goccy/go-json v0.10.4 // indirect
+	github.com/json-iterator/go v1.1.12 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.9 // indirect
+	github.com/kr/text v0.2.0 // indirect
+	github.com/leodido/go-urn v1.4.0 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
+	github.com/modern-go/reflect2 v1.0.2 // indirect
+	github.com/pelletier/go-toml/v2 v2.2.3 // indirect
+	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
+	github.com/ugorji/go/codec v1.2.12 // indirect
+	golang.org/x/arch v0.12.0 // indirect
+	golang.org/x/crypto v0.36.0 // indirect
+	golang.org/x/net v0.37.0 // indirect
+	golang.org/x/sys v0.31.0 // indirect
+	golang.org/x/text v0.23.0 // indirect
+	google.golang.org/protobuf v1.36.1 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)

go.sum

@@ -0,0 +1,120 @@
+github.com/bytedance/sonic v1.12.6 h1:/isNmCUF2x3Sh8RAp/4mh4ZGkcFAX/hLrzrK3AvpRzk=
+github.com/bytedance/sonic v1.12.6/go.mod h1:B8Gt/XvtZ3Fqj+iSKMypzymZxw/FVwgIGKzMzT9r/rk=
+github.com/bytedance/sonic/loader v0.1.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
+github.com/bytedance/sonic/loader v0.2.1 h1:1GgorWTqf12TA8mma4DDSbaQigE2wOgQo7iCjjJv3+E=
+github.com/bytedance/sonic/loader v0.2.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
+github.com/cespare/xxhash/v2 v2.1.2 h1:YRXhKfTDauu4ajMg1TPgFO5jnlC2HCbmLXMcTG5cbYE=
+github.com/cespare/xxhash/v2 v2.1.2/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/cloudwego/base64x v0.1.4 h1:jwCgWpFanWmN8xoIUHa2rtzmkd5J2plF/dnLS6Xd/0Y=
+github.com/cloudwego/base64x v0.1.4/go.mod h1:0zlkT4Wn5C6NdauXdJRhSKRlJvmclQ1hhJgA0rcu/8w=
+github.com/cloudwego/iasm v0.2.0 h1:1KNIy1I1H9hNNFEEH3DVnI4UujN+1zjpuk6gwHLTssg=
+github.com/cloudwego/iasm v0.2.0/go.mod h1:8rXZaNYT2n95jn+zTI1sDr+IgcD2GVs0nlbbQPiEFhY=
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
+github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
+github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4=
+github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
+github.com/gabriel-vasile/mimetype v1.4.7 h1:SKFKl7kD0RiPdbht0s7hFtjl489WcQ1VyPW8ZzUMYCA=
+github.com/gabriel-vasile/mimetype v1.4.7/go.mod h1:GDlAgAyIRT27BhFl53XNAFtfjzOkLaF35JdEG0P7LtU=
+github.com/gin-contrib/cors v1.7.4 h1:/fC6/wk7rCRtqKqki8lLr2Xq+hnV49aXDLIuSek9g4k=
+github.com/gin-contrib/cors v1.7.4/go.mod h1:vGc/APSgLMlQfEJV5NAzkrAHb0C8DetL3K6QZuvGii0=
+github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
+github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
+github.com/gin-gonic/gin v1.10.0 h1:nTuyha1TYqgedzytsKYqna+DfLos46nTv2ygFy86HFU=
+github.com/gin-gonic/gin v1.10.0/go.mod h1:4PMNQiOhvDRa013RKVbsiNwoyezlm2rm0uX/T7kzp5Y=
+github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
+github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
+github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
+github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
+github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
+github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
+github.com/go-playground/validator/v10 v10.23.0 h1:/PwmTwZhS0dPkav3cdK9kV1FsAmrL8sThn8IHr/sO+o=
+github.com/go-playground/validator/v10 v10.23.0/go.mod h1:dbuPbCMFw/DrkbEynArYaCwl3amGuJotoKCe95atGMM=
+github.com/go-redis/redis/v8 v8.11.5 h1:AcZZR7igkdvfVmQTPnu9WE37LRrO/YrBH5zWyjDC0oI=
+github.com/go-redis/redis/v8 v8.11.5/go.mod h1:gREzHqY1hg6oD9ngVRbLStwAWKhA0FEgq8Jd4h5lpwo=
+github.com/goccy/go-json v0.10.4 h1:JSwxQzIqKfmFX1swYPpUThQZp/Ka4wzJdK0LWVytLPM=
+github.com/goccy/go-json v0.10.4/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
+github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
+github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
+github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
+github.com/klauspost/cpuid/v2 v2.2.9 h1:66ze0taIn2H33fBvCkXuv9BmCwDfafmiIVpKV9kKGuY=
+github.com/klauspost/cpuid/v2 v2.2.9/go.mod h1:rqkxqrZ1EhYM9G+hXH7YdowN5R5RGN6NK4QwQ3WMXF8=
+github.com/knz/go-libedit v1.10.1/go.mod h1:MZTVkCWyz0oBc7JOWP3wNAzd002ZbM/5hgShxwh4x8M=
+github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0=
+github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
+github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
+github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
+github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE=
+github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU=
+github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE=
+github.com/onsi/ginkgo v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042wbpU=
+github.com/onsi/gomega v1.18.1 h1:M1GfJqGRrBrrGGsbxzV5dqM2U2ApXefZCQpkukxYRLE=
+github.com/onsi/gomega v1.18.1/go.mod h1:0q+aL8jAiMXy9hbwj2mr5GziHiwhAIQpFmmtT5hitRs=
+github.com/pelletier/go-toml/v2 v2.2.3 h1:YmeHyLY8mFWbdkNWwpr+qIL2bEqT0o95WSdkNHvL12M=
+github.com/pelletier/go-toml/v2 v2.2.3/go.mod h1:MfCQTFTvCcUyyvvwm1+G6H/jORL20Xlb6rzQu9GuUkc=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs=
+github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro=
+github.com/rogpeppe/go-internal v1.8.0 h1:FCbCCtXNOY3UtUuHUYaghJg4y7Fd14rXifAYUAtL9R8=
+github.com/rogpeppe/go-internal v1.8.0/go.mod h1:WmiCO8CzOY8rg0OYDC4/i/2WRWAB6poM+XZ2dLUbcbE=
+github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
+github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
+github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
+github.com/ugorji/go/codec v1.2.12 h1:9LC83zGrHhuUA9l16C9AHXAqEV/2wBQ4nkvumAE65EE=
+github.com/ugorji/go/codec v1.2.12/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
+golang.org/x/arch v0.12.0 h1:UsYJhbzPYGsT0HbEdmYcqtCv8UNGvnaL561NnIUvaKg=
+golang.org/x/arch v0.12.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
+golang.org/x/crypto v0.36.0 h1:AnAEvhDddvBdpY+uR+MyHmuZzzNqXSe/GvuDeob5L34=
+golang.org/x/crypto v0.36.0/go.mod h1:Y4J0ReaxCR1IMaabaSMugxJES1EpwhBHhv2bDHklZvc=
+golang.org/x/net v0.37.0 h1:1zLorHbz+LYj7MQlSf1+2tPIIgibq2eL5xkrGk6f+2c=
+golang.org/x/net v0.37.0/go.mod h1:ivrbrMbzFq5J41QOQh0siUuly180yBYtLp+CKbEaFx8=
+golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.31.0 h1:ioabZlmFYtWhL+TRYpcnNlLwhyxaM9kWTDEmfnprqik=
+golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/text v0.23.0 h1:D71I7dUrlY+VX0gQShAThNGHFxZ13dGLBHQLVl1mJlY=
+golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/protobuf v1.36.1 h1:yBPeRvTftaleIgM3PZ/WBIZ7XM/eEYAaEyCwvyjq/gk=
+google.golang.org/protobuf v1.36.1/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
+gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
+gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+nullprogram.com/x/optparse v1.0.0/go.mod h1:KdyPE+Igbe0jQUrVfMqDMeJQIJZEuyV7pjYmp6pbG50=

main.go

@@ -0,0 +1,288 @@
+package main
+
+import (
+	"augment2api/api"
+	"augment2api/config"
+	"augment2api/middleware"
+	"augment2api/pkg/logger"
+	"crypto/rand"
+	"crypto/sha256"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"log"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+
+	"github.com/gin-gonic/gin"
+)
+
+const clientID = "v"
+
+// OAuthState 存储OAuth状态信息
+type OAuthState struct {
+	CodeVerifier  string    `json:"code_verifier"`
+	CodeChallenge string    `json:"code_challenge"`
+	State         string    `json:"state"`
+	CreationTime  time.Time `json:"creation_time"`
+}
+
+// 全局变量存储OAuth状态
+var (
+	globalOAuthState OAuthState
+)
+
+// base64URLEncode 编码Buffer为base64 URL安全格式
+func base64URLEncode(data []byte) string {
+	encoded := base64.StdEncoding.EncodeToString(data)
+	encoded = strings.ReplaceAll(encoded, "+", "-")
+	encoded = strings.ReplaceAll(encoded, "/", "_")
+	encoded = strings.ReplaceAll(encoded, "=", "")
+	return encoded
+}
+
+// sha256Hash 计算SHA256哈希
+func sha256Hash(input []byte) []byte {
+	hash := sha256.Sum256(input)
+	return hash[:]
+}
+
+// createOAuthState 创建OAuth状态
+func createOAuthState() OAuthState {
+	codeVerifierBytes := make([]byte, 32)
+	_, err := rand.Read(codeVerifierBytes)
+	if err != nil {
+		log.Fatalf("生成随机字节失败: %v", err)
+	}
+
+	codeVerifier := base64URLEncode(codeVerifierBytes)
+	codeChallenge := base64URLEncode(sha256Hash([]byte(codeVerifier)))
+
+	stateBytes := make([]byte, 8)
+	_, err = rand.Read(stateBytes)
+	if err != nil {
+		log.Fatalf("生成随机状态失败: %v", err)
+	}
+	state := base64URLEncode(stateBytes)
+
+	return OAuthState{
+		CodeVerifier:  codeVerifier,
+		CodeChallenge: codeChallenge,
+		State:         state,
+		CreationTime:  time.Now(),
+	}
+}
+
+// generateAuthorizeURL 生成授权URL
+func generateAuthorizeURL(oauthState OAuthState) string {
+	params := url.Values{}
+	params.Add("response_type", "code")
+	params.Add("code_challenge", oauthState.CodeChallenge)
+	params.Add("client_id", clientID)
+	params.Add("state", oauthState.State)
+	params.Add("prompt", "login")
+
+	authorizeURL := fmt.Sprintf("https://auth.augmentcode.com/authorize?%s", params.Encode())
+	return authorizeURL
+}
+
+// getAccessToken 获取访问令牌
+func getAccessToken(tenantURL, codeVerifier, code string) (string, error) {
+	data := map[string]string{
+		"grant_type":    "authorization_code",
+		"client_id":     clientID,
+		"code_verifier": codeVerifier,
+		"redirect_uri":  "",
+		"code":          code,
+	}
+
+	jsonData, err := json.Marshal(data)
+	if err != nil {
+		return "", fmt.Errorf("序列化数据失败: %v", err)
+	}
+
+	resp, err := http.Post(tenantURL+"token", "application/json", strings.NewReader(string(jsonData)))
+	if err != nil {
+		return "", fmt.Errorf("请求令牌失败: %v", err)
+	}
+	defer resp.Body.Close()
+
+	var result map[string]interface{}
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return "", fmt.Errorf("解析响应失败: %v", err)
+	}
+
+	token, ok := result["access_token"].(string)
+	if !ok {
+		return "", fmt.Errorf("响应中没有访问令牌")
+	}
+
+	return token, nil
+}
+
+// 初始化路由
+func setupRouter() *gin.Engine {
+	r := gin.Default()
+
+	// 跨域
+	r.Use(middleware.CORS())
+
+	// 初始化OAuth状态
+	globalOAuthState = createOAuthState()
+
+	// 静态文件服务
+	r.Static("/static", "./static")
+	r.LoadHTMLGlob("templates/*")
+
+	// 登录页面
+	r.GET("/login", func(c *gin.Context) {
+		c.HTML(http.StatusOK, "login.html", gin.H{})
+	})
+
+	// 登录
+	r.POST("/api/login", api.LoginHandler)
+
+	// 登出
+	r.POST("/api/logout", api.LogoutHandler)
+
+	// 管理页面 - 需要会话验证
+	r.GET("/", func(c *gin.Context) {
+		// 如果设置了访问密码，检查是否已登录
+		if config.AppConfig.AccessPwd != "" {
+			// 从查询参数或Cookie中获取会话令牌
+			token := c.Query("token")
+			if token == "" {
+				// 尝试从Cookie获取
+				token, _ = c.Cookie("auth_token")
+			}
+
+			// 从请求头获取
+			if token == "" {
+				token = c.GetHeader("X-Auth-Token")
+			}
+
+			// 验证会话令牌
+			if !api.ValidateToken(token) {
+				c.Redirect(http.StatusFound, "/login")
+				return
+			}
+		}
+		c.HTML(http.StatusOK, "admin.html", gin.H{})
+	})
+
+	// 管理页面 - 需要会话验证
+	r.GET("/admin", api.AuthTokenMiddleware(), func(c *gin.Context) {
+		c.HTML(http.StatusOK, "admin.html", gin.H{})
+	})
+
+	// 授权端点 - 需要会话验证
+	r.GET("/auth", api.AuthTokenMiddleware(), func(c *gin.Context) {
+		authorizeURL := generateAuthorizeURL(globalOAuthState)
+		api.AuthHandler(c, authorizeURL)
+	})
+
+	// 获取token - 需要会话验证
+	r.GET("/api/tokens", api.AuthTokenMiddleware(), api.GetRedisTokenHandler)
+
+	// 删除token - 需要会话验证
+	r.DELETE("/api/token/:token", api.AuthTokenMiddleware(), api.DeleteTokenHandler)
+
+	// 更新token备注 - 需要会话验证
+	r.PUT("/api/token/:token/remark", api.AuthTokenMiddleware(), api.UpdateTokenRemark)
+
+	// 批量检测token - 需要会话���证
+	r.GET("/api/check-tokens", api.AuthTokenMiddleware(), api.CheckAllTokensHandler)
+
+	// 回调端点，用于处理授权码 - 需要会话验证
+	r.POST("/callback", api.AuthTokenMiddleware(), func(c *gin.Context) {
+		api.CallbackHandler(c, func(tenantURL, _, code string) (string, error) {
+			return getAccessToken(tenantURL, globalOAuthState.CodeVerifier, code)
+		})
+	})
+
+	// 鉴权路由组
+	authGroup := r.Group(ProcessPath(config.AppConfig.RoutePrefix))
+	authGroup.Use(api.AuthMiddleware())
+	{
+		// OpenAI兼容的聊天端点
+		chatGroup := authGroup.Group("/")
+		// 并发控制
+		chatGroup.Use(middleware.TokenConcurrencyMiddleware())
+		{
+			chatGroup.POST("/v1/chat/completions", api.ChatCompletionsHandler)
+			chatGroup.POST("/v1", api.ChatCompletionsHandler)
+			chatGroup.POST("/v1/chat", api.ChatCompletionsHandler)
+		}
+
+		authGroup.GET("/v1/models", api.ModelsHandler)
+		authGroup.POST("/api/add/tokens", api.AddTokenHandler)
+	}
+
+	return r
+}
+
+func ProcessPath(path string) string {
+	// 判断字符串是否为空
+	if path == "" {
+		return ""
+	}
+
+	// 判断开头是否为/，不是则添加
+	if !strings.HasPrefix(path, "/") {
+		path = "/" + path
+	}
+
+	// 判断结尾是否为/，是则去掉
+	if strings.HasSuffix(path, "/") {
+		path = path[:len(path)-1]
+	}
+
+	return path
+}
+
+func main() {
+	// 设置全局时区为东八区（CST）
+	time.Local = time.FixedZone("CST", 8*3600)
+
+	// 设置 Gin 为发布模式
+	gin.SetMode(gin.ReleaseMode)
+
+	// 初始化日志
+	logger.Init()
+
+	// 初始化配置
+	err := config.InitConfig()
+	if err != nil {
+		logger.Log.Fatalln("failed to initialize config: " + err.Error())
+		return
+	}
+
+	// 初始化Redis
+	err = config.InitRedisClient()
+	if err != nil {
+		logger.Log.Fatalln("failed to initialize Redis: " + err.Error())
+	}
+
+	// token备注字段迁移
+	err = api.MigrateTokensRemark()
+	if err != nil {
+		logger.Log.Error("Token备注字段迁移失败: %v", err)
+	}
+
+	// 启动token使用次数重置调度器
+	go api.StartTokenUsageResetScheduler()
+
+	r := setupRouter()
+
+	// 启动服务器
+	if err := r.Run(":7860"); err != nil {
+		logger.Log.Fatalf("启动服务失败: %v", err)
+	}
+
+	logger.Log.WithFields(map[string]interface{}{
+		"port": 27080,
+		"mode": gin.Mode(),
+	}).Info("Augment2API 服务启动成功")
+}

middleware/concurrency.go

@@ -0,0 +1,97 @@
+package middleware
+
+import (
+	"augment2api/api"
+	"augment2api/config"
+	"augment2api/pkg/logger"
+	"net/http"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+)
+
+// 全局锁映射，用于控制每个 token 的并发请求
+var (
+	tokenLocks      = make(map[string]*sync.Mutex)
+	tokenLocksGuard = sync.Mutex{}
+)
+
+// getTokenLock 获取指定 token 的锁
+func getTokenLock(token string) *sync.Mutex {
+	tokenLocksGuard.Lock()
+	defer tokenLocksGuard.Unlock()
+
+	if lock, exists := tokenLocks[token]; exists {
+		return lock
+	}
+
+	lock := &sync.Mutex{}
+	tokenLocks[token] = lock
+	return lock
+}
+
+// TokenConcurrencyMiddleware 控制Redis中token的使用频率
+func TokenConcurrencyMiddleware() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		// 只对聊天完成请求进行并发控制
+		if !strings.HasSuffix(c.Request.URL.Path, "/chat/completions") {
+			c.Next()
+			return
+		}
+
+		// 调试模式无需限制
+		if config.AppConfig.CodingMode == "true" {
+			token := config.AppConfig.CodingToken
+			tenantURL := config.AppConfig.TenantURL
+			c.Set("token", token)
+			c.Set("tenant_url", tenantURL)
+			c.Next()
+		}
+
+		// 获取一个可用的token
+		token, tenantURL := api.GetAvailableToken()
+		if token == "No token" {
+			c.JSON(http.StatusTooManyRequests, gin.H{"error": "当前无可用token，请在页面添加"})
+			c.Abort()
+			return
+		}
+		if token == "No available token" || tenantURL == "" {
+			c.JSON(http.StatusTooManyRequests, gin.H{"error": "当前请求过多，请稍后再试"})
+			c.Abort()
+			return
+		}
+
+		// 获取该token的锁
+		lock := getTokenLock(token)
+
+		// 尝试获取锁，会阻塞直到获取到锁
+		lock.Lock()
+
+		// 更新请求状态
+		err := api.SetTokenRequestStatus(token, api.TokenRequestStatus{
+			InProgress:    true,
+			LastRequestAt: time.Now(),
+		})
+
+		if err != nil {
+			lock.Unlock()
+			c.JSON(http.StatusInternalServerError, gin.H{"error": "更新token请求状态失败"})
+			c.Abort()
+			return
+		}
+
+		logger.Log.WithFields(logrus.Fields{
+			"token": token,
+		}).Info("本次请求使用的token: ")
+
+		// 在请求完成后释放锁
+		c.Set("token_lock", lock)
+		c.Set("token", token)
+		c.Set("tenant_url", tenantURL)
+
+		c.Next()
+	}
+}

middleware/cors.go

@@ -0,0 +1,15 @@
+package middleware
+
+import (
+	"github.com/gin-contrib/cors"
+	"github.com/gin-gonic/gin"
+)
+
+func CORS() gin.HandlerFunc {
+	config := cors.DefaultConfig()
+	config.AllowAllOrigins = true
+	config.AllowCredentials = true
+	config.AllowMethods = []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"}
+	config.AllowHeaders = []string{"*"}
+	return cors.New(config)
+}

pkg/logger/logger.go

@@ -0,0 +1,61 @@
+package logger
+
+import (
+	"fmt"
+	"github.com/sirupsen/logrus"
+	"os"
+	"strings"
+	"time"
+)
+
+// CustomFormatter 自定义格式化器
+type CustomFormatter struct {
+	TimestampFormat string
+}
+
+func (f *CustomFormatter) Format(entry *logrus.Entry) ([]byte, error) {
+	// 将时间调整为东八区
+	localTime := entry.Time.In(time.FixedZone("CST", 8*3600))
+	// 构建日志消息
+	timestamp := localTime.Format(f.TimestampFormat)
+	level := strings.ToUpper(entry.Level.String())
+
+	// 将所有字段合并到一个字符串中，添加适当的分隔
+	var fieldsStr string
+	if len(entry.Data) > 0 {
+		pairs := make([]string, 0, len(entry.Data))
+		for k, v := range entry.Data {
+			pairs = append(pairs, fmt.Sprintf("%s: %v", k, v))
+		}
+		fieldsStr = " | " + strings.Join(pairs, " | ")
+	}
+
+	// 简化的日志格式，移除文件名和行号
+	logMsg := fmt.Sprintf("[%s] %-5s %s%s\n",
+		timestamp,
+		level,
+		entry.Message,
+		fieldsStr,
+	)
+
+	return []byte(logMsg), nil
+}
+
+var Log = logrus.New()
+
+func Init() {
+	// 使用自定义格式化器
+	Log.SetFormatter(&CustomFormatter{
+		TimestampFormat: "2006-01-02 15:04:05",
+	})
+
+	// 设置输出到标准输出
+	Log.SetOutput(os.Stdout)
+
+	// 设置日志级别
+	if os.Getenv("DEBUG") == "true" {
+		Log.SetLevel(logrus.DebugLevel)
+	} else {
+		Log.SetLevel(logrus.InfoLevel)
+	}
+}

templates/admin.html

@@ -0,0 +1,1529 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Augment2Api-Panel</title>
+    <link rel="icon" href="../static/augment.svg" type="image/svg+xml">
+    <link rel="alternate icon" href="../static/augment.svg" type="image/x-icon">
+    <style>
+        :root {
+            --primary-color: #4a6cf7;
+            --primary-hover: #3a5ce4;
+            --bg-color: #f5f7fa;
+            --card-bg: #ffffff;
+            --text-color: #333333;
+            --text-secondary: #6c757d;
+            --border-color: #e9ecef;
+            --header-bg: #ffffff;
+            --header-color: #333333;
+            --sidebar-bg: #ffffff;
+            --sidebar-color: #333333;
+            --sidebar-hover: #f0f4ff;
+            --sidebar-active: #e6edff;
+            --footer-bg: #ffffff;
+            --footer-color: #6c757d;
+            --success-color: #28a745;
+            --error-color: #dc3545;
+            --warning-color: #ffc107;
+            --radius: 8px;
+            --shadow: 0 2px 10px rgba(0, 0, 0, 0.05);
+            --transition: all 0.3s ease;
+        }
+
+        html, body {
+            height: 100%;
+            margin: 0;
+            padding: 0;
+            overflow: hidden;
+        }
+
+        body {
+            display: flex;
+            flex-direction: column;
+            background-color: var(--bg-color);
+            color: var(--text-color);
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            line-height: 1.6;
+        }
+
+        .container {
+            display: flex;
+            flex-direction: column;
+            height: 100vh;
+            width: 100%;
+            max-width: 100%;
+            margin: 0;
+            padding: 0;
+        }
+
+        header {
+            background-color: var(--header-bg);
+            color: var(--header-color);
+            padding: 8px 20px;
+            box-shadow: var(--shadow);
+            z-index: 10;
+            border-bottom: 1px solid var(--border-color);
+        }
+
+        .header-content {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            width: 100%;
+            height: 40px; /* 固定高度 */
+        }
+
+        .header-content h1 {
+            font-size: 18px;
+            margin: 0;
+            font-weight: 600;
+        }
+
+        .logout-btn {
+            background-color: var(--primary-color);
+            color: white;
+            border: none;
+            border-radius: var(--radius);
+            padding: 6px 12px;
+            cursor: pointer;
+            font-size: 14px;
+            transition: var(--transition);
+            display: flex;
+            align-items: center;
+            gap: 5px;
+        }
+
+        .logout-btn:hover {
+            background-color: var(--primary-hover);
+        }
+
+        .dashboard {
+            display: flex;
+            flex: 1;
+            height: calc(100vh - 100px);
+            overflow: hidden;
+            margin: 0;
+            padding: 15px;
+            gap: 15px;
+        }
+
+        .sidebar {
+            width: 200px;
+            height: 100%;
+            background-color: var(--sidebar-bg);
+            color: var(--sidebar-color);
+            transition: width 0.3s ease;
+            border-radius: var(--radius);
+            box-shadow: var(--shadow);
+            overflow: hidden;
+            display: flex;
+            flex-direction: column;
+        }
+
+        .sidebar.collapsed {
+            width: 80px;
+        }
+
+        .sidebar.collapsed .sidebar-header h3 {
+            display: none;
+        }
+
+        .sidebar-header {
+            padding: 15px;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            border-bottom: 1px solid var(--border-color);
+        }
+
+        .sidebar-header h3 {
+            margin: 0;
+            color: var(--text-color);
+            font-size: 16px;
+            font-weight: 600;
+            white-space: nowrap;
+        }
+
+        .toggle-btn {
+            background: transparent;
+            border: none;
+            color: var(--text-secondary);
+            cursor: pointer;
+            font-size: 16px;
+            padding: 5px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            transition: transform 0.3s, background-color 0.2s;
+            border-radius: 4px;
+        }
+
+        .toggle-btn:hover {
+            background-color: #f1f1f1;
+        }
+
+        .sidebar.collapsed .toggle-btn {
+            transform: rotate(180deg);
+        }
+
+        .sidebar-menu {
+            display: flex;
+            flex-direction: column;
+            padding: 10px 0;
+            flex: 1;
+        }
+
+        .menu-item {
+            padding: 10px 15px;
+            display: flex;
+            align-items: center;
+            cursor: pointer;
+            transition: var(--transition);
+            white-space: nowrap;
+            border-radius: 4px;
+            margin: 2px 8px;
+        }
+
+        .menu-item:hover {
+            background-color: var(--sidebar-hover);
+            color: var(--primary-color);
+        }
+
+        .menu-item.active {
+            background-color: var(--sidebar-active);
+            color: var(--primary-color);
+            font-weight: 500;
+        }
+
+        .menu-item i {
+            font-size: 18px;
+            margin-right: 12px;
+        }
+
+        .sidebar.collapsed .menu-item {
+            padding: 10px 8px;
+            justify-content: center;
+        }
+
+        .sidebar.collapsed .menu-text {
+            display: none;
+        }
+
+        .sidebar.collapsed .menu-item i {
+            margin-right: 0;
+            font-size: 20px;
+        }
+
+        .sidebar.collapsed .sidebar-header {
+            justify-content: center;
+            padding: 15px 5px;
+        }
+
+        /* 主内容区样式优化 */
+        .main-content {
+            flex: 1;
+            height: 100%;
+            overflow: hidden;
+            display: flex;
+            flex-direction: column;
+            background-color: var(--card-bg);
+            border-radius: var(--radius);
+            box-shadow: var(--shadow);
+        }
+
+        .content-panel {
+            padding: 20px;
+            display: none;
+            flex: 1;
+            overflow-y: auto;
+            height: 100%;
+            flex-direction: column;
+        }
+
+        .content-panel.active {
+            display: flex;
+            flex-direction: column;
+        }
+
+        /* 添加token列表容器样式，使其可滚动 */
+        .token-list-container {
+            flex: 1;
+            overflow-y: auto;
+            margin-bottom: 15px;
+        }
+
+        /* 面板标题样式优化 */
+        .panel-title {
+            display: flex;
+            align-items: center;
+            margin-bottom: 20px;
+            padding-bottom: 12px;
+            border-bottom: 1px solid var(--border-color);
+        }
+
+        .panel-title h2 {
+            margin: 0 0 0 10px;
+            font-size: 18px;
+            font-weight: 600;
+            color: var(--text-color);
+        }
+
+        .panel-title i {
+            font-size: 20px;
+            color: var(--primary-color);
+        }
+
+        .panel-actions {
+            margin-left: auto;
+            display: flex;
+            gap: 10px;
+        }
+
+        /* 按钮样式统一 */
+        button {
+            background-color: var(--primary-color);
+            color: white;
+            border: none;
+            border-radius: var(--radius);
+            padding: 8px 12px;
+            cursor: pointer;
+            font-size: 14px;
+            transition: var(--transition);
+            display: flex;
+            align-items: center;
+            gap: 5px;
+        }
+
+        button:hover {
+            background-color: var(--primary-hover);
+        }
+
+        button.secondary {
+            background-color: transparent;
+            color: var(--text-color);
+            border: 1px solid var(--border-color);
+        }
+
+        button.secondary:hover {
+            background-color: #f8f9fa;
+        }
+
+        button.secondary i {
+            color: var(--text-color);
+        }
+
+        /* Token列表样式优化 */
+        .token-list {
+            display: flex;
+            flex-direction: column;
+            gap: 10px;
+            margin-bottom: 15px;
+        }
+
+        .token-item {
+            border: 1px solid var(--border-color);
+            border-radius: var(--radius);
+            overflow: hidden;
+            transition: var(--transition);
+            margin-bottom: 10px;
+        }
+
+        .token-item:hover {
+            box-shadow: 0 2px 8px rgba(0, 0, 0, 0.05);
+        }
+
+        .token-header {
+            display: flex;
+            align-items: center;
+            padding: 12px 15px;
+            background-color: #f8f9fa;
+            cursor: pointer;
+        }
+
+        .token-number {
+            width: 30px;
+            font-weight: 500;
+            color: var(--text-secondary);
+        }
+
+        .token-summary {
+            flex: 1;
+            font-family: monospace;
+            color: var(--text-color);
+            white-space: nowrap;
+            overflow: hidden;
+            text-overflow: ellipsis;
+            font-size: 13px;
+            display: flex;
+            align-items: center;
+            gap: 8px;
+        }
+
+        .token-remark {
+            background-color: #e3f2fd;
+            color: #1976d2;
+            padding: 2px 8px;
+            border-radius: 4px;
+            font-size: 12px;
+            font-family: system-ui;
+            cursor: pointer;
+            border: 1px solid transparent;
+            transition: all 0.2s;
+        }
+
+        .token-remark:hover {
+            border-color: #1976d2;
+        }
+
+        .token-remark.empty {
+            background-color: #f5f5f5;
+            color: #9e9e9e;
+        }
+
+        .token-remark input {
+            background: none;
+            border: none;
+            outline: none;
+            font-size: inherit;
+            font-family: inherit;
+            color: inherit;
+            width: 100%;
+            min-width: 100px;
+        }
+
+        .token-usage-count {
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            color: var(--text-color);
+            font-size: 13px;
+            font-weight: 500;
+            margin-left: 10px;
+        }
+
+        /* 根据使用次数变化颜色 - 只应用于数字 */
+        .token-usage-count .low {
+            color: #28a745; /* 绿色 - 使用次数少 */
+        }
+        
+        .token-usage-count .medium {
+            color: #ffc107; /* 黄色 - 使用次数中等 */
+        }
+        
+        .token-usage-count .high {
+            color: #dc3545; /* 红色 - 使用次数多 */
+        }
+
+        .token-toggle {
+            margin-left: 10px;
+            transition: transform 0.3s;
+        }
+
+        .token-toggle.open i {
+            transform: rotate(180deg);
+        }
+
+        .token-details {
+            padding: 0;
+            max-height: 0;
+            overflow: hidden;
+            transition: all 0.3s ease;
+            background-color: #ffffff;
+        }
+
+        .token-details.open {
+            padding: 15px;
+            max-height: 200px;
+            border-top: 1px solid var(--border-color);
+            overflow-y: auto;
+        }
+
+        .token-label {
+            font-weight: 500;
+            margin-bottom: 5px;
+            color: var(--text-secondary);
+            font-size: 13px;
+        }
+
+        .token-display {
+            padding: 8px 10px;
+            background-color: #f8f9fa;
+            border-radius: 4px;
+            font-family: monospace;
+            margin-bottom: 10px;
+            word-break: break-all;
+            font-size: 13px;
+            overflow-x: auto;
+        }
+
+        .token-actions {
+            display: flex;
+            justify-content: flex-end;
+            margin-top: 10px;
+        }
+
+        .delete-token {
+            background-color: var(--error-color);
+        }
+
+        .delete-token:hover {
+            background-color: #c82333;
+        }
+
+        /* 分页控件样式优化 */
+        .pagination-container {
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            padding: 15px 0;
+            border-top: 1px solid var(--border-color);
+        }
+
+        .pagination-btn {
+            background-color: transparent;
+            border: 1px solid var(--border-color);
+            color: var(--text-color);
+            border-radius: var(--radius);
+            padding: 6px 10px;
+            margin: 0 5px;
+            cursor: pointer;
+            transition: var(--transition);
+        }
+
+        .pagination-btn:hover:not([disabled]) {
+            background-color: var(--primary-color);
+            color: white;
+            border-color: var(--primary-color);
+        }
+
+        .pagination-btn[disabled] {
+            opacity: 0.5;
+            cursor: not-allowed;
+        }
+
+        #page-info {
+            margin: 0 15px;
+            font-size: 14px;
+            color: var(--text-secondary);
+        }
+
+        .page-size-select {
+            margin-left: 15px;
+            padding: 6px 8px;
+            border-radius: var(--radius);
+            border: 1px solid var(--border-color);
+            background-color: white;
+            color: var(--text-color);
+            font-size: 14px;
+            cursor: pointer;
+        }
+
+        /* 页脚样式优化 */
+        footer {
+            text-align: center;
+            padding: 10px 0;
+            background-color: var(--footer-bg);
+            color: var(--footer-color);
+            font-size: 13px;
+            border-top: 1px solid var(--border-color);
+        }
+
+        footer a {
+            color: var(--primary-color);
+            text-decoration: none;
+        }
+
+        footer a:hover {
+            text-decoration: underline;
+        }
+
+        /* 响应式设计优化 */
+        @media (max-width: 768px) {
+            .dashboard {
+                flex-direction: column;
+                height: auto;
+                padding: 10px;
+            }
+            
+            .sidebar {
+                width: 100% !important;
+                margin-bottom: 15px;
+                max-height: 200px;
+            }
+            
+            .main-content {
+                height: calc(100vh - 300px);
+                overflow-y: auto;
+            }
+            
+            .content-panel {
+                padding: 15px;
+                max-height: none;
+            }
+            
+            .sidebar.collapsed .menu-text {
+                display: inline;
+            }
+            
+            .toggle-btn {
+                display: none;
+            }
+        }
+
+        @media (max-width: 1200px) {
+            .token-display {
+                max-width: 100%;
+                white-space: nowrap;
+            }
+        }
+
+        @media (min-width: 1201px) {
+            .token-display {
+                white-space: normal;
+            }
+        }
+
+        .token-details.open .token-display {
+            white-space: normal;
+            word-break: break-all;
+        }
+
+        /* 添加Token面板样式优化 */
+        .auth-steps {
+            display: flex;
+            flex-direction: column;
+            gap: 25px;
+            padding-bottom: 20px;
+        }
+
+        .step {
+            background-color: #f8f9fa;
+            border-radius: var(--radius);
+            padding: 20px;
+            border: 1px solid var(--border-color);
+        }
+
+        .step h3 {
+            display: flex;
+            align-items: center;
+            margin-top: 0;
+            margin-bottom: 15px;
+            font-size: 16px;
+            font-weight: 600;
+        }
+
+        .step-number {
+            display: inline-flex;
+            align-items: center;
+            justify-content: center;
+            width: 24px;
+            height: 24px;
+            background-color: var(--primary-color);
+            color: white;
+            border-radius: 50%;
+            margin-right: 10px;
+            font-size: 14px;
+        }
+
+        .step p {
+            margin-bottom: 15px;
+            color: var(--text-secondary);
+        }
+
+        textarea {
+            width: 100%;
+            padding: 10px;
+            border: 1px solid var(--border-color);
+            border-radius: var(--radius);
+            font-family: monospace;
+            min-height: 100px;
+            margin-bottom: 10px;
+            resize: vertical;
+        }
+
+        .error {
+            color: var(--error-color);
+            margin: 10px 0;
+            display: none;
+        }
+
+        .success {
+            color: var(--success-color);
+            margin: 10px 0;
+            display: none;
+        }
+
+        button:not(.secondary):not(.pagination-btn):not(.toggle-btn) i {
+            color: white;
+        }
+
+        /* 刷新按钮加载动画 */
+        .refresh-btn, #check-all-tokens {
+            position: relative;
+        }
+        
+        .refresh-btn i, #check-all-tokens i {
+            transition: transform 0.3s ease;
+        }
+        
+        .refresh-btn.loading i, #check-all-tokens.loading i {
+            animation: spin 1s linear infinite;
+        }
+        
+        @keyframes spin {
+            0% { transform: rotate(0deg); }
+            100% { transform: rotate(360deg); }
+        }
+        
+        /* 禁用状态 */
+        .refresh-btn.loading, #check-all-tokens.loading {
+            pointer-events: none;
+            opacity: 0.7;
+        }
+
+        /* 检测结果样式 */
+        .check-result {
+            color: var(--success-color);
+            background-color: rgba(40, 167, 69, 0.1);
+            border: 1px solid var(--success-color);
+            border-radius: var(--radius);
+            padding: 10px 15px;
+            margin: 10px 0;
+            display: none;
+        }
+
+
+        /* 弹出输入框样式 */
+        .remark-input-modal {
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            background-color: rgba(0, 0, 0, 0.5);
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            z-index: 1000;
+        }
+
+        .remark-input-container {
+            background-color: white;
+            padding: 20px;
+            border-radius: var(--radius);
+            box-shadow: var(--shadow);
+            width: 250px;
+        }
+
+        .remark-input-container h3 {
+            margin: 0 0 15px 0;
+            font-size: 16px;
+            color: var(--text-color);
+        }
+
+        .remark-input-container input {
+            width: 100%;
+            padding: 8px 10px;
+            border: 1px solid var(--border-color);
+            border-radius: 4px;
+            margin-bottom: 15px;
+            font-size: 14px;
+            box-sizing: border-box;
+        }
+
+        .remark-input-container .char-count {
+            font-size: 12px;
+            color: var(--text-secondary);
+            margin-bottom: 15px;
+            text-align: right;
+        }
+
+        .remark-input-actions {
+            display: flex;
+            justify-content: flex-end;
+            gap: 10px;
+        }
+
+        /* Token模糊化样式 */
+        .token-blur {
+            filter: blur(3px);
+            transition: all 0.3s ease;
+        }
+
+        .token-blur:hover {
+            filter: blur(0);
+        }
+
+        /* 删除背景颜色变化样式 */
+        #toggle-token-visibility.active i {
+            color: var(--primary-color);
+        }
+        
+        /* 冷却状态图标样式 */
+        .cool-status {
+            color: #1e88e5;
+            font-size: 18px;
+            margin-left: 5px;
+            vertical-align: middle;
+        }
+        
+        .cool-status-tooltip {
+            position: relative;
+            display: inline-block;
+        }
+        
+        .cool-status-tooltip .tooltip-text {
+            visibility: hidden;
+            width: 200px;
+            background-color: #333;
+            color: #fff;
+            text-align: center;
+            border-radius: 6px;
+            padding: 5px;
+            position: absolute;
+            z-index: 1;
+            bottom: 125%;
+            left: 50%;
+            margin-left: -100px;
+            opacity: 0;
+            transition: opacity 0.3s;
+            font-size: 12px;
+        }
+        
+        .cool-status-tooltip:hover .tooltip-text {
+            visibility: visible;
+            opacity: 1;
+        }
+    </style>
+    <!-- 添加图标 -->
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap-icons@1.10.0/font/bootstrap-icons.css">
+</head>
+<body>
+    <div class="container">
+        <header>
+            <div class="header-content">
+                <h1>Augment面板｜v1.0.2</h1>
+                <button id="logout-btn" class="logout-btn">
+                    <i class="bi bi-box-arrow-right"></i> 登出
+                </button>
+            </div>
+        </header>
+
+        <div class="dashboard">
+            <!-- 左侧导航栏 -->
+            <div class="sidebar" id="sidebar">
+                <div class="sidebar-header">
+                    <h3>面板功能导航</h3>
+                    <button id="toggle-sidebar" class="toggle-btn">
+                        <i class="bi bi-chevron-left"></i>
+                    </button>
+                </div>
+                <div class="sidebar-menu">
+                    <div class="menu-item active" data-target="token-list-panel">
+                        <i class="bi bi-list-ul"></i>
+                        <span class="menu-text">Token列表</span>
+                    </div>
+                    <div class="menu-item" data-target="token-add-panel">
+                        <i class="bi bi-plus-circle"></i>
+                        <span class="menu-text">添加Token</span>
+                    </div>
+                </div>
+            </div>
+
+            <!-- 右侧主内容区 -->
+            <div class="main-content" id="main-content">
+                <!-- Token列表面板 -->
+                <div class="content-panel active" id="token-list-panel">
+                    <div class="panel-title">
+                        <i class="bi bi-key-fill"></i>
+                        <h2>Token列表</h2>
+                        <div class="panel-actions">
+                            <button id="toggle-token-visibility" class="secondary">
+                                <i class="bi bi-eye-slash"></i> 隐藏Token
+                            </button>
+                            <button id="refresh-token" class="refresh-btn">
+                                <i class="bi bi-arrow-clockwise"></i> 刷新列表
+                            </button>
+                            <button id="check-all-tokens"><i class="bi bi-shield-check btn-icon"></i> <span class="btn-text">批量检测</span></button>
+                        </div>
+                    </div>
+                    
+                    <!-- 添加可滚动容器 -->
+                    <div class="token-list-container">
+                        <div id="token-list">加载中...</div>
+                    </div>
+                    
+                    <!-- 分页控件 -->
+                    <div class="pagination-container" id="pagination-container">
+                        <button class="pagination-btn" id="prev-page" disabled><i class="bi bi-chevron-left"></i></button>
+                        <span id="page-info">第 <span id="current-page">1</span> 页，共 <span id="total-pages">1</span> 页</span>
+                        <button class="pagination-btn" id="next-page"><i class="bi bi-chevron-right"></i></button>
+                        <select id="page-size" class="page-size-select">
+                            <option value="10">10条/页</option>
+                            <option value="20">20条/页</option>
+                            <option value="50">50条/页</option>
+                        </select>
+                    </div>
+                </div>
+
+                <!-- 添加Token面板 -->
+                <div class="content-panel" id="token-add-panel">
+                    <div class="panel-title">
+                        <i class="bi bi-shield-lock-fill"></i>
+                        <h2>授权获取Token</h2>
+                    </div>
+
+                    <div class="auth-steps">
+                        <div class="step">
+                            <h3><span class="step-number">1</span> 获取授权地址</h3>
+                            <p>点击下方按钮获取授权���址，然后在浏览器中打开该地址进行授权。</p>
+                            <button id="get-auth-url"><i class="bi bi-link-45deg" class="btn-icon"></i> <span class="btn-text">获取授权地址</span></button>
+                            <div id="auth-url" class="token-display" style="display: none;"></div>
+                        </div>
+
+                        <div class="step">
+                            <h3><span class="step-number">2</span> 提交授权响应</h3>
+                            <p>完成授权后，将获得的授权响应粘贴到下面的文本框中：</p>
+                            <textarea id="auth-response" placeholder='{"code":"_000baec407c57c4bf9xxxxxxxxxxxxxx","state":"0uXxxxxxxxx","tenant_url":"https://dxx.api.augmentcode.com/"}'></textarea>
+                            <div id="validation-message" class="error"></div>
+                            <button id="submit-auth"><i class="bi bi-check2-circle" class="btn-text"></i> <span class="btn-text">获取Token</span></button>
+                            <div id="submit-result" class="success"></div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+        
+        <!-- 添加页脚 -->
+        <footer>
+            <a href="https://linux.do/u/bifang/summary" target="_blank">开发者：彼方</a> | <a href="https://2api-docs.pages.dev/page/augment2api/func-intro" target="_blank">文档中心</a>
+        </footer>
+    </div>
+
+    <script>
+        // 检查会话是否有效
+        function checkSession() {
+            // 从Cookie中获取token
+            const cookies = document.cookie.split(';');
+            let token = null;
+            
+            for (let i = 0; i < cookies.length; i++) {
+                const cookie = cookies[i].trim();
+                if (cookie.startsWith('auth_token=')) {
+                    token = cookie.substring('auth_token='.length);
+                    break;
+                }
+            }
+            
+            if (!token) {
+                window.location.href = '/login';
+                return false;
+            }
+            
+            // 将token添加到所有API请求中
+            return token;
+        }
+
+        // 页面加载时检查会话
+        const authToken = checkSession();
+        if (!authToken) {
+            // 如果没有有效会话，不继续执行后续代码
+            throw new Error('No valid session');
+        }
+
+        // 为所有fetch请求添加认证头
+        const originalFetch = window.fetch;
+        window.fetch = function(url, options = {}) {
+            // 创建新的options对象，避免修改原始对象
+            const newOptions = { ...options };
+            
+            // 确保headers对象存在
+            newOptions.headers = newOptions.headers || {};
+            
+            // 如果是对象形式，转换为Headers对象
+            if (!(newOptions.headers instanceof Headers)) {
+                const headers = new Headers(newOptions.headers);
+                headers.append('X-Auth-Token', authToken);
+                newOptions.headers = headers;
+            } else {
+                newOptions.headers.append('X-Auth-Token', authToken);
+            }
+            
+            return originalFetch(url, newOptions);
+        };
+
+        document.addEventListener('DOMContentLoaded', function() {
+            // 侧边栏切换
+            const sidebar = document.getElementById('sidebar');
+            const toggleBtn = document.getElementById('toggle-sidebar');
+            const menuItems = document.querySelectorAll('.menu-item');
+            const contentPanels = document.querySelectorAll('.content-panel');
+            
+            // 分页变量
+            let currentPage = 1;
+            let pageSize = 10;
+            let allTokens = [];
+            
+            // 侧边栏折叠/展开
+            toggleBtn.addEventListener('click', function() {
+                sidebar.classList.toggle('collapsed');
+            });
+            
+            // 菜单项切换
+            menuItems.forEach(item => {
+                item.addEventListener('click', function() {
+                    // 移除所有菜单项的active类
+                    menuItems.forEach(i => i.classList.remove('active'));
+                    // 为当前点击的菜单项添加active类
+                    this.classList.add('active');
+                    
+                    // 获取目标面板ID
+                    const targetId = this.getAttribute('data-target');
+                    
+                    // 隐藏所有内容面板
+                    contentPanels.forEach(panel => {
+                        panel.classList.remove('active');
+                    });
+                    
+                    // 显示目标面板
+                    document.getElementById(targetId).classList.add('active');
+                });
+            });
+            
+            // 分页功能
+            const prevPageBtn = document.getElementById('prev-page');
+            const nextPageBtn = document.getElementById('next-page');
+            const currentPageSpan = document.getElementById('current-page');
+            const totalPagesSpan = document.getElementById('total-pages');
+            const pageSizeSelect = document.getElementById('page-size');
+            
+            // 页面大小变化
+            pageSizeSelect.addEventListener('change', function() {
+                pageSize = parseInt(this.value);
+                currentPage = 1;
+                fetchCurrentToken();
+            });
+            
+            // 上一页
+            prevPageBtn.addEventListener('click', function() {
+                if (currentPage > 1) {
+                    currentPage--;
+                    fetchCurrentToken();
+                }
+            });
+            
+            // 下一页
+            nextPageBtn.addEventListener('click', function() {
+                currentPage++;
+                fetchCurrentToken();
+            });
+            
+            // 修改获取当前Token列表函数，使用后端分页
+            function fetchCurrentToken() {
+                // 显示加载动画
+                const refreshBtn = document.getElementById('refresh-token');
+                const tokenListElement = document.getElementById('token-list');
+                refreshBtn.classList.add('loading');
+                
+                // 设置超时处理
+                const timeoutId = setTimeout(() => {
+                    refreshBtn.classList.remove('loading');
+                    tokenListElement.innerHTML = '<div class="error" style="display:block;">请求超时,请重试</div>';
+                }, 10000); // 10秒超时
+                
+                fetch(`/api/tokens?page=${currentPage}&page_size=${pageSize}`)
+                .then(response => {
+                    if (!response.ok) {
+                        throw new Error(`HTTP error! status: ${response.status}`);
+                    }
+                    return response.json();
+                })
+                .then(data => {
+                    clearTimeout(timeoutId); // 清除超时定时器
+                    
+                    if (data.status === 'success') {
+                        // 使用后端返回的token列表
+                        allTokens = data.tokens || [];
+                        
+                        // 更新分页信息
+                        const totalItems = data.total || 0;
+                        const totalPages = data.total_pages || 1;
+                        currentPage = data.page || 1;
+                        
+                        // 渲染token列表和分页控件
+                        renderTokenList(totalItems, totalPages);
+                    } else {
+                        tokenListElement.innerHTML = 
+                            '<div class="error" style="display:block;">获取Token列表失败: ' + (data.error || '未知错误') + '</div>';
+                    }
+                })
+                .catch(error => {
+                    clearTimeout(timeoutId); // 清除超时定时器
+                    tokenListElement.innerHTML = 
+                        '<div class="error" style="display:block;">请求失败: ' + error.message + '</div>';
+                })
+                .finally(() => {
+                    refreshBtn.classList.remove('loading');
+                });
+            }
+            
+            // 修改渲染token列表函数，使用后端返回的分页信息
+            function renderTokenList(totalItems, totalPages) {
+                const tokenListElement = document.getElementById('token-list');
+                
+                // 如果没有token
+                if (totalItems === 0) {
+                    tokenListElement.innerHTML = '<div class="no-tokens">暂无可用Token，请点击"添加Token"获取</div>';
+                    
+                    // 隐藏分页控件
+                    document.getElementById('pagination-container').style.display = 'none';
+                    return;
+                }
+                
+                // 显示分页控件
+                document.getElementById('pagination-container').style.display = 'flex';
+                
+                // 更新分页信息显示
+                totalPagesSpan.textContent = totalPages;
+                currentPageSpan.textContent = currentPage;
+                
+                // 更新分页按钮状态
+                prevPageBtn.disabled = currentPage === 1;
+                nextPageBtn.disabled = currentPage === totalPages;
+                
+                // 创建token列表容器
+                tokenListElement.innerHTML = '<div class="token-list"></div>';
+                const listContainer = tokenListElement.querySelector('.token-list');
+                
+                // 添加每个token项
+                allTokens.forEach((tokenInfo, index) => {
+                    // 计算在当前页中���索引
+                    const displayIndex = index + 1 + (currentPage - 1) * pageSize;
+                    
+                    // 获取使用次数并设置样式类
+                    const usageCount = tokenInfo.usage_count || 0;
+                    const chatUsageCount = tokenInfo.chat_usage_count || 0;
+                    const agentUsageCount = tokenInfo.agent_usage_count || 0;
+                    let usageClass = '';
+                    
+                    // 根据CHAT和AGENT模式的使用次数来确定样式类
+                    if (chatUsageCount < 1000 && agentUsageCount < 20) {
+                        usageClass = 'low';
+                    } else if (chatUsageCount < 2000 && agentUsageCount < 40) {
+                        usageClass = 'medium';
+                    } else {
+                        usageClass = 'high';
+                    }
+                    
+                    // 显示完整token，不再截断
+                    const tokenItem = document.createElement('div');
+                    tokenItem.className = 'token-item';
+                    tokenItem.innerHTML = `
+                        <div class="token-header">
+                            <div class="token-number">${displayIndex}</div>
+                            <div class="token-summary">
+                                ${tokenInfo.token}
+                                <span class="token-remark${!tokenInfo.remark ? ' empty' : ''}" data-token="${tokenInfo.token}" data-remark="${tokenInfo.remark || ''}">${tokenInfo.remark || '添加备注'}</span>
+                                ${tokenInfo.in_cool ? `
+                                <span class="cool-status-tooltip">
+                                    <i class="bi bi-snow cool-status"></i>
+                                    <span class="tooltip-text">冷却中，直到: ${new Date(tokenInfo.cool_end).toLocaleString()}</span>
+                                </span>` : ''}
+                            </div>
+                            <div class="token-usage-count">
+                                CHAT使用:&nbsp;&nbsp; <span class="${usageClass}">${chatUsageCount}</span>&nbsp;&nbsp;次 | AGENT使用:&nbsp;&nbsp; <span class="${usageClass}">${agentUsageCount}</span>&nbsp;&nbsp;次
+                            </div>
+                            <div class="token-toggle"><i class="bi bi-chevron-down"></i></div>
+                        </div>
+                        <div class="token-details">
+                            <div class="token-label">Token:</div>
+                            <div class="token-display">${tokenInfo.token}</div>
+                            <div class="token-label">租户URL:</div>
+                            <div class="token-display">${tokenInfo.tenant_url}</div>
+                            <div class="token-actions">
+                                <button class="delete-token" data-token="${tokenInfo.token}">
+                                    <i class="bi bi-trash"></i> 删除
+                                </button>
+                            </div>
+                        </div>
+                    `;
+                    
+                    listContainer.appendChild(tokenItem);
+                    
+                    // 添加事件处理
+                    const header = tokenItem.querySelector('.token-header');
+                    const details = tokenItem.querySelector('.token-details');
+                    const toggle = tokenItem.querySelector('.token-toggle');
+                    const remarkSpan = tokenItem.querySelector('.token-remark');
+                    
+                    // 为备注添加点击事件
+                    remarkSpan.addEventListener('click', function(e) {
+                        e.stopPropagation(); // 阻止事件冒泡到header
+                        
+                        const token = this.dataset.token;
+                        const currentRemark = this.dataset.remark;
+                        
+                        // 创建弹出层
+                        const modal = document.createElement('div');
+                        modal.className = 'remark-input-modal';
+                        
+                        modal.innerHTML = `
+                            <div class="remark-input-container">
+                                <h3>编辑备注</h3>
+                                <input type="text" maxlength="30" placeholder="请输入备注（30字以内）" value="${currentRemark}">
+                                <div class="char-count"><span>${currentRemark.length}</span>/30</div>
+                                <div class="remark-input-actions">
+                                    <button class="secondary" onclick="this.closest('.remark-input-modal').remove()">取消</button>
+                                    <button class="save-remark" data-token="${token}">保存</button>
+                                </div>
+                            </div>
+                        `;
+                        
+                        document.body.appendChild(modal);
+                        
+                        // 获取输入框并聚焦
+                        const input = modal.querySelector('input');
+                        input.focus();
+                        
+                        // 更新字符计数
+                        input.addEventListener('input', () => {
+                            const count = input.value.length;
+                            modal.querySelector('.char-count span').textContent = count;
+                        });
+                        
+                        // 点击背景关闭弹窗
+                        modal.addEventListener('click', (e) => {
+                            if (e.target === modal) {
+                                modal.remove();
+                            }
+                        });
+                        
+                        // 处理保存按钮点击
+                        modal.querySelector('.save-remark').addEventListener('click', async function() {
+                            const token = this.dataset.token;
+                            const newRemark = input.value.trim();
+                            
+                            try {
+                                const response = await fetch(`/api/token/${token}/remark`, {
+                                    method: 'PUT',
+                                    headers: {
+                                        'Content-Type': 'application/json'
+                                    },
+                                    body: JSON.stringify({ remark: newRemark })
+                                });
+                                
+                                const data = await response.json();
+                                if (data.status === 'success') {
+                                    // 关闭弹窗
+                                    modal.remove();
+                                    // 刷新列表
+                                    fetchCurrentToken();
+                                } else {
+                                    alert('更新备注失败: ' + (data.error || '未知错误'));
+                                }
+                            } catch (error) {
+                                alert('请求失败: ' + error.message);
+                            }
+                        });
+                    });
+                    
+                    // 为header添加点击事件（展开/折叠详情）
+                    header.addEventListener('click', function() {
+                        details.classList.toggle('open');
+                        toggle.classList.toggle('open');
+                    });
+                });
+            }
+            
+            // 为token列表添加事件委托,只处理删除按钮
+            document.getElementById('token-list').addEventListener('click', function(e) {
+                // 检查点击的是否是删除按钮
+                if (e.target.closest('.delete-token')) {
+                    const deleteBtn = e.target.closest('.delete-token');
+                    const token = deleteBtn.getAttribute('data-token');
+                    
+                    if (confirm('确定要删除此Token吗？')) {
+                        // 发送删除请求
+                        fetch(`/api/token/${encodeURIComponent(token)}`, {
+                            method: 'DELETE'
+                        })
+                            .then(response => response.json())
+                            .then(data => {
+                                if (data.status === 'success') {
+                                    // 刷新token列表
+                                    fetchCurrentToken();
+                                } else {
+                                    alert('删除失败: ' + (data.error || '未知错误'));
+                                }
+                            })
+                            .catch(error => {
+                                alert('请求失败: ' + error.message);
+                            });
+                    }
+                }
+            });
+
+            // 刷新Token按钮事件
+            document.getElementById('refresh-token').addEventListener('click', function() {
+                fetchCurrentToken();
+            });
+
+            // 添加登出处理逻辑
+            document.getElementById('logout-btn').addEventListener('click', function() {
+                if(confirm('确定要登出吗？')) {
+                    fetch('/api/logout', {
+                        method: 'POST',
+                        headers: {
+                            'X-Auth-Token': authToken
+                        }
+                    })
+                    .then(response => response.json())
+                    .then(data => {
+                        if(data.status === 'success') {
+                            // 清除Cookie
+                            document.cookie = "auth_token=; path=/; expires=Thu, 01 Jan 1970 00:00:00 GMT";
+                            // 重定向到登录页
+                            window.location.href = '/login';
+                        } else {
+                            alert('登出失败: ' + (data.error || '未知错误'));
+                        }
+                    })
+                    .catch(error => {
+                        alert('登出请求失败: ' + error.message);
+                    });
+                }
+            });
+
+            // 批量检测token
+            document.getElementById('check-all-tokens').addEventListener('click', function() {
+                const button = this;
+                button.classList.add('loading');
+                
+                fetch('/api/check-tokens')
+                    .then(response => response.json())
+                    .then(data => {
+                        if(data.status === 'success') {
+                            // 创建或获取检测结果显示元素
+                            let checkResult = document.querySelector('.check-result');
+                            if(!checkResult) {
+                                checkResult = document.createElement('div');
+                                checkResult.className = 'check-result';
+                                document.querySelector('.panel-title').after(checkResult);
+                            }
+                            
+                            // 显示检测结果
+                            checkResult.textContent = `检测完成! 共检测 ${data.total} 个Token，更新 ${data.updated} 个Token租户地址，禁用 ${data.disabled} 个无效Token`;
+                            checkResult.style.display = 'block';
+                            
+                            // 如果有更新或禁用，则刷新token列表
+                            if(data.updated > 0 || data.disabled > 0) {
+                                fetchCurrentToken();
+                            }
+                            
+                            // 5秒后隐藏提示
+                            setTimeout(() => {
+                                checkResult.style.display = 'none';
+                            }, 5000);
+                        } else {
+                            alert('检测失败: ' + (data.error || '未知错误'));
+                        }
+                    })
+                    .catch(error => {
+                        alert('请求失败: ' + error.message);
+                    })
+                    .finally(() => {
+                        button.classList.remove('loading');
+                    });
+            });
+
+            // 获取授权地址按钮事件
+            document.getElementById('get-auth-url').addEventListener('click', function() {
+                const button = this;
+                const btnText = button.querySelector('.btn-text');
+                const originalText = btnText.textContent;
+                
+                // 显示加载状态
+                button.disabled = true;
+                btnText.textContent = '获取中...';
+                
+                // 请求授权地址
+                fetch('/auth')
+                    .then(response => response.json())
+                    .then(data => {
+                        if (data.authorize_url) {
+                            // 显示授权地址
+                            const authUrlElement = document.getElementById('auth-url');
+                            authUrlElement.textContent = data.authorize_url;
+                            authUrlElement.style.display = 'block';
+                        } else {
+                            alert('获取授权地址失败: ' + (data.error || '未知错误'));
+                        }
+                    })
+                    .catch(error => {
+                        alert('请求失败: ' + error.message);
+                    })
+                    .finally(() => {
+                        // 恢复按钮状态
+                        button.disabled = false;
+                        btnText.textContent = originalText;
+                    });
+            });
+
+            // 验证JSON格式
+            function isValidJSON(str) {
+                try {
+                    JSON.parse(str);
+                    return true;
+                } catch (e) {
+                    return false;
+                }
+            }
+
+            // 验证授权响应格式
+            function validateAuthResponse(response) {
+                try {
+                    const data = JSON.parse(response);
+                    // 检查必要字段
+                    if (!data.code || !data.state || !data.tenant_url) {
+                        return { valid: false, message: '缺少必要字段 (code, state, tenant_url)' };
+                    }
+                    return { valid: true, data: data };
+                } catch (e) {
+                    return { valid: false, message: 'JSON格式无效: ' + e.message };
+                }
+            }
+
+            // 提��授权响应按钮事件
+            document.getElementById('submit-auth').addEventListener('click', function() {
+                const button = this;
+                const btnText = button.querySelector('.btn-text');
+                const originalText = btnText.textContent;
+                const responseText = document.getElementById('auth-response').value.trim();
+                const validationMessage = document.getElementById('validation-message');
+                const submitResult = document.getElementById('submit-result');
+                
+                // 重置消息
+                validationMessage.style.display = 'none';
+                submitResult.style.display = 'none';
+                
+                // 验证输入
+                if (!responseText) {
+                    validationMessage.textContent = '请输入授权响应';
+                    validationMessage.style.display = 'block';
+                    return;
+                }
+                
+                // 验证JSON格式
+                if (!isValidJSON(responseText)) {
+                    validationMessage.textContent = 'JSON格式无效，请检查输入';
+                    validationMessage.style.display = 'block';
+                    return;
+                }
+                
+                // 验证授权响应格式
+                const validation = validateAuthResponse(responseText);
+                if (!validation.valid) {
+                    validationMessage.textContent = validation.message;
+                    validationMessage.style.display = 'block';
+                    return;
+                }
+                
+                // 显示加载状态
+                button.disabled = true;
+                btnText.textContent = '处理中...';
+                
+                // 提交授权响应
+                fetch('/callback', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: responseText
+                })
+                    .then(response => response.json())
+                    .then(data => {
+                        if (data.status === 'success') {
+                            // 显示成功消息
+                            submitResult.textContent = 'Token获取成功！';
+                            submitResult.style.display = 'block';
+                            
+                            // 清空输入框
+                            document.getElementById('auth-response').value = '';
+                            
+                            // 刷新Token列表
+                            setTimeout(() => {
+                                fetchCurrentToken();
+                                
+                                // 切换到Token列表面板
+                                document.querySelector('.menu-item[data-target="token-list-panel"]').click();
+                            }, 1000);
+                        } else {
+                            // 显示错误消息但不影响样式
+                            validationMessage.textContent = '获取Token失败: ' + (data.error || '未知错误');
+                            validationMessage.style.display = 'block';
+                        }
+                    })
+                    .catch(error => {
+                        // 显示错误消息但不影响样式
+                        validationMessage.textContent = '请求失败: ' + error.message;
+                        validationMessage.style.display = 'block';
+                    })
+                    .finally(() => {
+                        // 恢复按钮状态
+                        button.disabled = false;
+                        btnText.textContent = originalText;
+                    });
+            });
+
+            // 初始加载token列表
+            fetchCurrentToken();
+            
+            // 添加Token隐藏/显示功能
+            let tokenVisible = true;
+            const toggleTokenVisibilityBtn = document.getElementById('toggle-token-visibility');
+            
+            toggleTokenVisibilityBtn.addEventListener('click', function() {
+                tokenVisible = !tokenVisible;
+                
+                // 更新按钮状态和文本
+                if (tokenVisible) {
+                    this.innerHTML = '<i class="bi bi-eye-slash"></i> 隐藏Token';
+                    this.classList.remove('active');
+                } else {
+                    this.innerHTML = '<i class="bi bi-eye"></i> 显示Token';
+                    this.classList.add('active');
+                }
+                
+                // 应用模糊效果到所有Token展示区域
+                applyTokenVisibility();
+            });
+            
+            // 应用Token可见性设置到列表中
+            function applyTokenVisibility() {
+                // 获取所有Token显示元素
+                const tokenElements = document.querySelectorAll('.token-summary, .token-display');
+                
+                tokenElements.forEach(element => {
+                    if (tokenVisible) {
+                        element.classList.remove('token-blur');
+                    } else {
+                        element.classList.add('token-blur');
+                    }
+                });
+            }
+            
+            // 在渲染Token列表后应用可见性设置
+            const originalRenderTokenList = renderTokenList;
+            renderTokenList = function(totalItems, totalPages) {
+                originalRenderTokenList(totalItems, totalPages);
+                
+                // 如果当前状态是隐藏的，则应用模糊效果
+                if (!tokenVisible) {
+                    applyTokenVisibility();
+                }
+            };
+        });
+    </script>
+</body>
+</html> 

templates/login.html

@@ -0,0 +1,275 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Augment2Api - 登录</title>
+    <link rel="icon" href="../static/augment.svg" type="image/svg+xml">
+    <link rel="alternate icon" href="../static/augment.svg" type="image/x-icon">
+    <style>
+        :root {
+            --primary-color: #4361ee;
+            --secondary-color: #3f37c9;
+            --success-color: #4caf50;
+            --error-color: #f44336;
+            --bg-color: #f8f9fa;
+            --card-bg: #ffffff;
+            --text-color: #333333;
+            --border-color: #e0e0e0;
+            --shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+            --radius: 12px;
+        }
+
+        * {
+            box-sizing: border-box;
+            margin: 0;
+            padding: 0;
+        }
+
+        body {
+            font-family: 'PingFang SC', 'Microsoft YaHei', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;
+            background-color: var(--bg-color);
+            color: var(--text-color);
+            line-height: 1.6;
+            padding: 20px;
+            min-height: 100vh;
+            display: flex;
+            flex-direction: column;
+            justify-content: center;
+            align-items: center;
+            position: relative;
+            overflow: hidden;
+        }
+
+        #bg-canvas {
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            z-index: -1;
+        }
+
+        .login-container {
+            width: 100%;
+            max-width: 400px;
+            background: var(--card-bg);
+            border-radius: var(--radius);
+            box-shadow: var(--shadow);
+            padding: 30px;
+            margin-bottom: 20px;
+        }
+
+        h1 {
+            font-size: 24px;
+            font-weight: 600;
+            color: black;
+            text-align: center;
+            margin-bottom: 20px;
+        }
+
+        .form-group {
+            margin-bottom: 20px;
+        }
+
+        label {
+            display: block;
+            margin-bottom: 8px;
+            font-weight: 500;
+            text-align: center;
+        }
+
+        input[type="password"] {
+            width: 100%;
+            padding: 10px 12px;
+            border: 1px solid var(--border-color);
+            border-radius: 8px;
+            font-size: 16px;
+            transition: border-color 0.3s;
+        }
+
+        input[type="password"]:focus {
+            border-color: var(--primary-color);
+            outline: none;
+        }
+
+        button {
+            display: block;
+            width: 100%;
+            padding: 12px;
+            background-color: var(--primary-color);
+            color: white;
+            border: none;
+            border-radius: 8px;
+            font-size: 16px;
+            font-weight: 500;
+            cursor: pointer;
+            transition: background-color 0.3s;
+        }
+
+        button:hover {
+            background-color: var(--secondary-color);
+        }
+
+        .error-message {
+            color: var(--error-color);
+            margin-top: 15px;
+            text-align: center;
+            display: none;
+        }
+
+        footer {
+            text-align: center;
+            margin-top: 20px;
+            color: #666;
+            font-size: 14px;
+        }
+
+        footer a {
+            color: var(--primary-color);
+            text-decoration: none;
+            transition: color 0.3s;
+        }
+
+        footer a:hover {
+            color: var(--secondary-color);
+            text-decoration: underline;
+        }
+    </style>
+</head>
+<body>
+    <canvas id="bg-canvas"></canvas>
+    <div class="login-container">
+        <h1>Augment面板登录</h1>
+        <form id="login-form">
+            <div class="form-group">
+                <label for="password">访问密码</label>
+                <input type="password" id="password" name="password" placeholder="请输入访问密码" required>
+            </div>
+            <button type="submit">登录</button>
+            <div id="error-message" class="error-message">密码错误，请重试</div>
+        </form>
+    </div>
+
+    <script>
+        document.addEventListener('DOMContentLoaded', function() {
+            const loginForm = document.getElementById('login-form');
+            const errorMessage = document.getElementById('error-message');
+            
+            // 检查是否有错误消息参数
+            const urlParams = new URLSearchParams(window.location.search);
+            if (urlParams.get('error') === 'invalid_password') {
+                errorMessage.style.display = 'block';
+                errorMessage.textContent = '密码错误，请重试';
+            } else if (urlParams.get('error') === 'token_expired') {
+                errorMessage.style.display = 'block';
+                errorMessage.textContent = '会话已过期，请重新登录';
+            }
+            
+            // 背景动画
+            const canvas = document.getElementById('bg-canvas');
+            const ctx = canvas.getContext('2d');
+            let width = window.innerWidth;
+            let height = window.innerHeight;
+            
+            canvas.width = width;
+            canvas.height = height;
+            
+            // 线条数量
+            const lineCount = 15;
+            const lines = [];
+            
+            // 创建线条
+            for (let i = 0; i < lineCount; i++) {
+                lines.push({
+                    x: Math.random() * width,
+                    y: Math.random() * height,
+                    length: Math.random() * 100 + 50,
+                    angle: Math.random() * Math.PI * 2,
+                    speed: Math.random() * 0.5 + 0.1,
+                    opacity: Math.random() * 0.2 + 0.1
+                });
+            }
+            
+            function drawLines() {
+                ctx.clearRect(0, 0, width, height);
+                
+                for (let i = 0; i < lineCount; i++) {
+                    const line = lines[i];
+                    
+                    ctx.beginPath();
+                    ctx.moveTo(line.x, line.y);
+                    ctx.lineTo(
+                        line.x + Math.cos(line.angle) * line.length,
+                        line.y + Math.sin(line.angle) * line.length
+                    );
+                    
+                    ctx.strokeStyle = `rgba(67, 97, 238, ${line.opacity})`;
+                    ctx.lineWidth = 1;
+                    ctx.stroke();
+                    
+                    // 更新线条位置
+                    line.x += Math.cos(line.angle) * line.speed;
+                    line.y += Math.sin(line.angle) * line.speed;
+                    
+                    // 如果线条移出画布，重新放置
+                    if (line.x < -line.length || line.x > width + line.length || 
+                        line.y < -line.length || line.y > height + line.length) {
+                        line.x = Math.random() * width;
+                        line.y = Math.random() * height;
+                        line.angle = Math.random() * Math.PI * 2;
+                    }
+                }
+                
+                requestAnimationFrame(drawLines);
+            }
+            
+            drawLines();
+            
+            // 窗口大小变化时重新设置画布尺寸
+            window.addEventListener('resize', function() {
+                width = window.innerWidth;
+                height = window.innerHeight;
+                canvas.width = width;
+                canvas.height = height;
+            });
+            
+            loginForm.addEventListener('submit', function(e) {
+                e.preventDefault();
+                const password = document.getElementById('password').value;
+                
+                // 发送登录请求
+                fetch('/api/login', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({ password: password })
+                })
+                .then(response => response.json())
+                .then(data => {
+                    if (data.status === 'success') {
+                        // 登录成功，保存会话到Cookie并跳转到管理页面
+                        // 设置安全的Cookie，确保路径正确
+                        document.cookie = "auth_token=" + data.token + "; path=/; max-age=86400;";
+                        console.log("设置Cookie成功: auth_token=" + data.token);
+
+                        setTimeout(() => {
+                            window.location.href = '/admin';
+                        }, 300);
+                    } else {
+                        // 显示错误消息
+                        errorMessage.style.display = 'block';
+                        errorMessage.textContent = data.error || '登录失败，请重试';
+                    }
+                })
+                .catch(error => {
+                    console.error('登录请求失败:', error);
+                    errorMessage.style.display = 'block';
+                    errorMessage.textContent = '网络错误，请重试';
+                });
+            });
+        });
+    </script>
+</body>
+</html>