Merge pull request #210 from komari-monitor/copilot/fix-b576a6c5-0ea2-4f16-8483-2eb7767cd8ad

Add PR and manual triggers to binary build workflow

.github/workflows/auto-merge-dev-to-main.yml

@@ -0,0 +1,109 @@
+name: Auto Merge Dev to Main
+
+on:
+  pull_request:
+    types: [opened, synchronize] # No longer need 'closed' trigger
+    branches:
+      - main
+    paths-ignore:
+      - '**.md'
+      - 'docs/**'
+
+jobs:
+  # Job to enable Auto-Merge for the PR
+  auto-merge:
+    runs-on: ubuntu-latest
+    # Only run for open PRs from dev to main
+    if: github.head_ref == 'dev' && github.base_ref == 'main'
+
+    permissions:
+      contents: write
+      pull-requests: write
+      checks: read
+      statuses: read
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          fetch-depth: 0 # Required for git history
+
+      - name: Configure Git
+        run: |
+          git config --local user.email "action@github.com"
+          git config --local user.name "GitHub Action"
+
+      - name: Get PR number
+        id: get-pr
+        run: |
+          echo "pr_number=${{ github.event.number }}" >> $GITHUB_OUTPUT
+
+      - name: Check for conflicts
+        id: check-conflicts
+        run: |
+          # Ensure local branches are up-to-date
+          git fetch origin main
+          git fetch origin dev
+          
+          # Use merge-base to find the common ancestor and check for conflicts
+          if git merge-tree $(git merge-base origin/main origin/dev) origin/main origin/dev | grep -q '<<<<<<<'; then
+            echo "has_conflicts=true" >> $GITHUB_OUTPUT
+            echo "❌ Merge conflicts detected"
+          else
+            echo "has_conflicts=false" >> $GITHUB_OUTPUT
+            echo "✅ No merge conflicts"
+          fi
+
+      - name: Add conflict comment
+        if: steps.check-conflicts.outputs.has_conflicts == 'true'
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          gh pr comment ${{ steps.get-pr.outputs.pr_number }} \
+            --body "❌ **Merge Conflict Detection**
+
+            This PR has merge conflicts and cannot be automatically merged. Please resolve conflicts manually and push to the dev branch.
+
+            Steps to resolve conflicts:
+            1. \`git checkout dev\`
+            2. \`git merge main\`
+            3. Resolve conflicts
+            4. \`git commit\`
+            5. \`git push origin dev\`"
+          exit 1 # Exit to prevent further steps
+
+      - name: Enable auto-merge
+        if: steps.check-conflicts.outputs.has_conflicts == 'false'
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          # Enable auto-merge using a merge commit
+          gh pr merge ${{ steps.get-pr.outputs.pr_number }} \
+            --auto \
+            --merge \
+            --delete-branch=false
+          
+          # Add success comment
+          gh pr comment ${{ steps.get-pr.outputs.pr_number }} \
+            --body "✅ **Auto-merge Enabled**
+
+            This PR has no merge conflicts and auto-merge has been enabled. It will be automatically merged to the main branch once all checks pass.
+
+            Merge method: Merge commit
+            Branch retention: dev branch will be preserved"
+
+      - name: Summary
+        run: |
+          echo "### 🤖 Auto-merge Summary" >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          echo "- 📝 Processing PR #${{ steps.get-pr.outputs.pr_number }} (dev → main)" >> $GITHUB_STEP_SUMMARY
+          
+          if [ "${{ steps.check-conflicts.outputs.has_conflicts }}" == "true" ]; then
+            echo "- ❌ Merge conflicts detected, manual resolution required" >> $GITHUB_STEP_SUMMARY
+          else
+            echo "- ✅ No merge conflicts, auto-merge enabled" >> $GITHUB_STEP_SUMMARY
+          fi
+          
+          echo "" >> $GITHUB_STEP_SUMMARY
+          echo "**PR Link**: https://github.com/${{ github.repository }}/pull/${{ steps.get-pr.outputs.pr_number }}" >> $GITHUB_STEP_SUMMARY

.github/workflows/build.yml

@@ -1,9 +1,13 @@
-name: Build Binaries on Main Push
+name: Build Binaries on Main Push and PR
 
 on:
   push:
     branches:
       - main
+  pull_request:
+    branches:
+      - main
+  workflow_dispatch:
 
 jobs:
   build-binaries:

.github/workflows/cleanup-packages.yml

@@ -1,8 +1,9 @@
 name: Cleanup Old Packages
 
 on:
-  schedule:
-    - cron: '0 0 * * 0'  # Run every Sunday at midnight
+  #schedule:
+  #  - cron: '0 0 * * 0'  # Run every Sunday at midnight
+  # 会清理掉正常的镜像
   workflow_dispatch:      # Allow manual trigger
 
 jobs:
@@ -57,4 +58,4 @@ jobs:
                 package_version_id: version.id
               });
               console.log(`Deleted package version ${version.id} with tags: ${version.metadata.container.tags.join(', ') || 'none'}`);
-            }
+            }

.github/workflows/docker-publish.yml

@@ -1,9 +1,9 @@
 name: Publish Docker Image on Main
 
 on:
-  push:
-    branches:
-      - main
+  #push:
+  #  branches:
+  #    - main
   workflow_dispatch:
 
 env:

.github/workflows/release-docker.yml

@@ -96,3 +96,5 @@ jobs:
           platforms: linux/amd64,linux/arm64
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}
+          no-cache: true
+          provenance: false

.gitignore

@@ -7,6 +7,7 @@
 *.dll
 *.so
 *.dylib
+__debug*
 
 # local development data
 komari.db

api/AdminAuthMiddleware.go

@@ -10,7 +10,14 @@ import (
 
 func AdminAuthMiddleware() gin.HandlerFunc {
 	return func(c *gin.Context) {
-
+		// API key authentication
+		apiKey := c.GetHeader("Authorization")
+		if isApiKeyValid(apiKey) {
+			c.Set("api_key", apiKey)
+			c.Next()
+			return
+		}
+		// session-based authentication
 		session, err := c.Cookie("session_token")
 		if err != nil {
 			RespondError(c, http.StatusUnauthorized, "Unauthorized.")

api/Common.go

@@ -13,6 +13,7 @@ import (
 
 	"strconv"
 
+	"github.com/komari-monitor/komari/database/config"
 	"github.com/komari-monitor/komari/database/dbcore"
 	"github.com/komari-monitor/komari/database/models"
 	"github.com/komari-monitor/komari/utils"
@@ -119,3 +120,14 @@ func GetVersion(c *gin.Context) {
 		"hash":    utils.VersionHash,
 	})
 }
+
+func isApiKeyValid(apiKey string) bool {
+	cfg, err := config.Get()
+	if err != nil {
+		return false
+	}
+	if cfg.ApiKey == "" || len(cfg.ApiKey) < 12 {
+		return false
+	}
+	return apiKey == "Bearer "+cfg.ApiKey
+}

api/PrivateSiteMiddleware.go

@@ -18,6 +18,7 @@ var (
 		"/api/oauth",
 		"/api/oauth_callback",
 		"/api/version",
+		"/api/recent",
 		"/api/admin",    // 由AdminAuthMiddleware处理
 		"/api/clients/", // 由TokenAuthMiddleware处理
 	}
@@ -25,6 +26,13 @@ var (
 
 func PrivateSiteMiddleware() gin.HandlerFunc {
 	return func(c *gin.Context) {
+		// API key authentication
+		apiKey := c.GetHeader("Authorization")
+		if isApiKeyValid(apiKey) {
+			c.Set("api_key", apiKey)
+			c.Next()
+			return
+		}
 		// 如果是公开的路径，直接放行
 		for _, path := range publicPaths {
 			if len(c.Request.URL.Path) >= len(path) && c.Request.URL.Path[:len(path)] == path {

api/TokenAuthMiddleware.go

@@ -16,6 +16,14 @@ import (
 // TokenAuthMiddleware creates a Gin middleware that validates a token from query parameters or request body.
 func TokenAuthMiddleware() gin.HandlerFunc {
 	return func(c *gin.Context) {
+		// API key authentication
+		apiKey := c.GetHeader("Authorization")
+		if isApiKeyValid(apiKey) {
+			c.Set("api_key", apiKey)
+			c.Next()
+			return
+		}
+
 		var token string
 
 		// Step 1: Check query parameter for token

api/admin/client.go

@@ -68,6 +68,7 @@ func RemoveClient(c *gin.Context) {
 	user_uuid, _ := c.Get("uuid")
 	auditlog.Log(c.ClientIP(), user_uuid.(string), "delete client:"+uuid, "warn")
 	c.JSON(200, gin.H{"status": "success"})
+	ws.DeleteConnectedClients(uuid)
 	ws.DeleteLatestReport(uuid)
 }
 

api/admin/download.go

@@ -14,18 +14,92 @@ import (
 	"github.com/gin-gonic/gin"
 	"github.com/komari-monitor/komari/api"
 	"github.com/komari-monitor/komari/cmd/flags"
+	"github.com/komari-monitor/komari/database/dbcore"
 )
 
+// copyDatabaseToTemp 安全地复制数据库文件到临时目录
+// 对于SQLite数据库，会使用BACKUP命令确保数据一致性
+func copyDatabaseToTemp(dbFilePath, tempDir string) (string, error) {
+	if dbFilePath == "" {
+		return "", fmt.Errorf("database file path is empty")
+	}
+
+	// 检查数据库文件是否存在
+	if _, err := os.Stat(dbFilePath); os.IsNotExist(err) {
+		return "", fmt.Errorf("database file does not exist: %s", dbFilePath)
+	}
+
+	dbFileName := filepath.Base(dbFilePath)
+	tempDbPath := filepath.Join(tempDir, dbFileName)
+
+	// 如果是SQLite数据库，使用SQLite的BACKUP命令来确保一致性
+	if flags.DatabaseType == "sqlite" || flags.DatabaseType == "" {
+		db := dbcore.GetDBInstance()
+
+		// 获取底层的SQLite连接
+		sqlDB, err := db.DB()
+		if err != nil {
+			return "", fmt.Errorf("failed to get underlying database connection: %v", err)
+		}
+
+		// 使用SQLite的BACKUP API来创建一致的备份
+		backupSQL := fmt.Sprintf("BACKUP DATABASE main TO '%s'", tempDbPath)
+		_, err = sqlDB.Exec(backupSQL)
+		if err != nil {
+			// 如果BACKUP命令失败，回退到文件复制方法
+			log.Printf("SQLite BACKUP command failed, falling back to file copy: %v", err)
+			return copyFileToTemp(dbFilePath, tempDbPath)
+		}
+
+		log.Printf("Database backed up using SQLite BACKUP to: %s", tempDbPath)
+		return tempDbPath, nil
+	} else {
+		// 对于非SQLite数据库，直接复制文件
+		return copyFileToTemp(dbFilePath, tempDbPath)
+	}
+}
+
+// copyFileToTemp 简单的文件复制到临时目录
+func copyFileToTemp(srcPath, destPath string) (string, error) {
+	src, err := os.Open(srcPath)
+	if err != nil {
+		return "", fmt.Errorf("failed to open source file: %v", err)
+	}
+	defer src.Close()
+
+	dest, err := os.Create(destPath)
+	if err != nil {
+		return "", fmt.Errorf("failed to create destination file: %v", err)
+	}
+	defer dest.Close()
+
+	_, err = io.Copy(dest, src)
+	if err != nil {
+		return "", fmt.Errorf("failed to copy file: %v", err)
+	}
+
+	log.Printf("Database file copied to: %s", destPath)
+	return destPath, nil
+}
+
 // DownloadBackup 用于打包 ./data 目录及数据库文件为 zip 并通过 HTTP 下载
 func DownloadBackup(c *gin.Context) {
-	backupFileName := fmt.Sprintf("backup-%s.zip", time.Now().Format("20060102-150405"))
+	backupFileName := fmt.Sprintf("backup-%d.zip", time.Now().UnixMicro())
 	c.Writer.Header().Set("Content-Type", "application/zip")
 	c.Writer.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", backupFileName))
 
 	zipWriter := zip.NewWriter(c.Writer)
 	defer zipWriter.Close()
 
-	err := filepath.Walk("./data", func(filePath string, info os.FileInfo, err error) error {
+	// 创建临时目录用于存放数据库备份
+	tempDir, err := os.MkdirTemp("", "komari-backup-*")
+	if err != nil {
+		api.RespondError(c, http.StatusInternalServerError, fmt.Sprintf("Error creating temporary directory: %v", err))
+		return
+	}
+	defer os.RemoveAll(tempDir) // 清理临时目录
+
+	err = filepath.Walk("./data", func(filePath string, info os.FileInfo, err error) error {
 		if err != nil {
 			return err
 		}
@@ -96,27 +170,32 @@ func DownloadBackup(c *gin.Context) {
 
 	// 如果数据库文件的绝对路径不是以 ./data 目录的绝对路径开头，则单独添加它
 	if !strings.HasPrefix(dbAbsPath, dataAbsPath) {
-		dbFileName := filepath.Base(dbFilePath)
-		dbInfo, err := os.Stat(dbFilePath)
+		// 使用安全的数据库复制方法
+		tempDbPath, err := copyDatabaseToTemp(dbFilePath, tempDir)
 		if err != nil {
 			if os.IsNotExist(err) {
 				log.Printf("Database file '%s' does not exist, skipping.\n", dbFilePath)
-				return // 数据库不存在是正常情况，直接返回
+			} else {
+				api.RespondError(c, http.StatusInternalServerError, fmt.Sprintf("Error copying database file: %v", err))
+				return
 			}
-			api.RespondError(c, http.StatusInternalServerError, fmt.Sprintf("Error stating database file: %v", err))
-			return
-		}
-
-		if !dbInfo.IsDir() {
-			file, err := os.Open(dbFilePath)
+		} else {
+			// 将临时数据库文件添加到zip
+			dbInfo, err := os.Stat(tempDbPath)
 			if err != nil {
-				api.RespondError(c, http.StatusInternalServerError, fmt.Sprintf("Error opening database file: %v", err))
+				api.RespondError(c, http.StatusInternalServerError, fmt.Sprintf("Error stating temp database file: %v", err))
+				return
+			}
+
+			file, err := os.Open(tempDbPath)
+			if err != nil {
+				api.RespondError(c, http.StatusInternalServerError, fmt.Sprintf("Error opening temp database file: %v", err))
 				return
 			}
 			defer file.Close()
 
 			writer, err := zipWriter.CreateHeader(&zip.FileHeader{
-				Name:     dbFileName,
+				Name:     filepath.Base(dbFilePath), // 使用原始数据库文件名
 				Method:   zip.Deflate,
 				Modified: dbInfo.ModTime(),
 			})
@@ -136,7 +215,7 @@ func DownloadBackup(c *gin.Context) {
 	}
 
 	// 添加备份标记文件
-	markupContent := "此文件为 Komari 备份标记文件，请勿删除。\nThis is a Komari backup markup file, please do not delete.\n\n备份时间 / Backup Time: " + time.Now().Format("2006-01-02 15:04:05")
+	markupContent := "此文件为 Komari 备份标记文件，请勿删除。\nThis is a Komari backup markup file, please do not delete.\n\n备份时间 / Backup Time: " + time.Now().Format(time.RFC3339)
 	markupWriter, err := zipWriter.CreateHeader(&zip.FileHeader{
 		Name:     "komari-backup-markup",
 		Method:   zip.Deflate,

api/admin/exec.go

@@ -2,11 +2,13 @@ package admin
 
 import (
 	"encoding/json"
+	"time"
 
 	"github.com/gin-gonic/gin"
 	"github.com/gorilla/websocket"
 	"github.com/komari-monitor/komari/api"
 	"github.com/komari-monitor/komari/database/auditlog"
+	"github.com/komari-monitor/komari/database/models"
 	"github.com/komari-monitor/komari/database/tasks"
 	"github.com/komari-monitor/komari/utils"
 	"github.com/komari-monitor/komari/ws"
@@ -21,16 +23,25 @@ func Exec(c *gin.Context) {
 		Clients []string `json:"clients" binding:"required"`
 	}
 	var onlineClients []string
+	var offlineClients []string
 	if err := c.ShouldBindJSON(&req); err != nil {
 		api.RespondError(c, 400, "Invalid or missing request body: "+err.Error())
 		return
 	}
-	for uuid := range ws.GetConnectedClients() {
-		if contain(req.Clients, uuid) {
+	// for uuid := range ws.GetConnectedClients() {
+	// 	if contain(req.Clients, uuid) {
+	// 		onlineClients = append(onlineClients, uuid)
+	// 	}
+	// 	// else {
+	// 	// 	api.RespondError(c, 400, "Client not connected: "+uuid)
+	// 	// 	return
+	// 	// }
+	// }
+	for _, uuid := range req.Clients {
+		if client := ws.GetConnectedClients()[uuid]; client != nil {
 			onlineClients = append(onlineClients, uuid)
 		} else {
-			api.RespondError(c, 400, "Client not connected: "+uuid)
-			return
+			offlineClients = append(offlineClients, uuid)
 		}
 	}
 	if len(onlineClients) == 0 {
@@ -38,7 +49,7 @@ func Exec(c *gin.Context) {
 		return
 	}
 	taskId := utils.GenerateRandomString(16)
-	if err := tasks.CreateTask(taskId, onlineClients, req.Command); err != nil {
+	if err := tasks.CreateTask(taskId, append(onlineClients, offlineClients...), req.Command); err != nil {
 		api.RespondError(c, 500, "Failed to create task: "+err.Error())
 		return
 	}
@@ -55,7 +66,10 @@ func Exec(c *gin.Context) {
 		payload, _ := json.Marshal(send)
 		client := ws.GetConnectedClients()[uuid]
 		if client != nil {
-			client.WriteMessage(websocket.TextMessage, payload)
+			if err := client.WriteMessage(websocket.TextMessage, payload); err != nil {
+				api.RespondError(c, 400, "Client connection is broke: "+uuid)
+				return
+			}
 		} else {
 			api.RespondError(c, 400, "Client connection is null: "+uuid)
 			return
@@ -67,12 +81,18 @@ func Exec(c *gin.Context) {
 		"task_id": taskId,
 		"clients": onlineClients,
 	})
-}
-func contain(clients []string, uuid string) bool {
-	for _, client := range clients {
-		if client == uuid {
-			return true
+	if len(offlineClients) > 0 {
+		for _, uuid := range offlineClients {
+			tasks.SaveTaskResult(taskId, uuid, "Client offline!", -1, models.FromTime(time.Now()))
 		}
 	}
-	return false
 }
+
+// func contain(clients []string, uuid string) bool {
+// 	for _, client := range clients {
+// 		if client == uuid {
+// 			return true
+// 		}
+// 	}
+// 	return false
+// }

api/admin/theme.go

@@ -3,9 +3,11 @@ package admin
 import (
 	"archive/zip"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"net/http"
+	"net/url"
 	"os"
 	"path/filepath"
 	"strings"
@@ -13,6 +15,7 @@ import (
 	"github.com/gin-gonic/gin"
 	"github.com/komari-monitor/komari/api"
 	"github.com/komari-monitor/komari/database/config"
+	"github.com/komari-monitor/komari/database/dbcore"
 	"github.com/komari-monitor/komari/database/models"
 )
 
@@ -281,3 +284,336 @@ func isValidThemeShort(short string) bool {
 
 	return true
 }
+
+// downloadThemeFromURL 从URL下载主题文件
+func downloadThemeFromURL(url string) ([]byte, error) {
+	// 发送HTTP GET请求
+	resp, err := http.Get(url)
+	if err != nil {
+		return nil, fmt.Errorf("下载主题文件失败: %v", err)
+	}
+	defer resp.Body.Close()
+
+	// 检查响应状态码
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("下载主题文件失败，HTTP状态码: %d", resp.StatusCode)
+	}
+
+	// 读取响应内容
+	data, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("读取主题文件内容失败: %v", err)
+	}
+
+	// 检查文件大小
+	if len(data) == 0 {
+		return nil, errors.New("下载的主题文件为空")
+	}
+
+	return data, nil
+}
+
+// getGitHubReleaseDownloadURL 从GitHub API获取最新release的下载链接
+// 该函数通过GitHub API获取指定仓库最新release的资源下载链接
+// 参考API: https://api.github.com/repos/{owner}/{repo}/releases/latest
+// 参数:
+//   - owner: GitHub仓库所有者
+//   - repo: GitHub仓库名称
+//
+// 返回:
+//   - 最新release的第一个资源的下载链接
+//   - 错误信息（如果有）
+func getGitHubReleaseDownloadURL(owner, repo string) (string, error) {
+	if owner == "" || repo == "" {
+		return "", errors.New("GitHub仓库所有者和仓库名称不能为空")
+	}
+
+	// 构建GitHub API URL
+	// 使用GitHub API获取最新release信息
+	apiURL := fmt.Sprintf("https://api.github.com/repos/%s/%s/releases/latest", owner, repo)
+
+	// 发送HTTP GET请求
+	resp, err := http.Get(apiURL)
+	if err != nil {
+		return "", fmt.Errorf("获取GitHub release信息失败: %v", err)
+	}
+	defer resp.Body.Close()
+
+	// 检查响应状态码
+	if resp.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("获取GitHub release信息失败，HTTP状态码: %d", resp.StatusCode)
+	}
+
+	// 解析JSON响应
+	// GitHub API返回的JSON包含assets数组，每个asset包含browser_download_url字段
+	var releaseInfo struct {
+		Assets []struct {
+			BrowserDownloadURL string `json:"browser_download_url"`
+		} `json:"assets"`
+	}
+
+	if err := json.NewDecoder(resp.Body).Decode(&releaseInfo); err != nil {
+		return "", fmt.Errorf("解析GitHub API响应失败: %v", err)
+	}
+
+	// 检查是否有可下载的资源
+	if len(releaseInfo.Assets) == 0 {
+		return "", errors.New("GitHub release中没有可下载的资源")
+	}
+
+	// 返回第一个资源的下载链接
+	// 相当于shell命令: curl -s https://api.github.com/repos/owner/repo/releases/latest | jq -r ".assets[0].browser_download_url"
+	return releaseInfo.Assets[0].BrowserDownloadURL, nil
+}
+
+// isGitHubRepoURL 检查URL是否是GitHub仓库地址
+// 支持的格式:
+// - https://github.com/owner/repo
+// - https://github.com/owner/repo.git
+// - https://www.github.com/owner/repo
+// - http://github.com/owner/repo
+// 返回:
+//   - 是否是GitHub仓库URL
+//   - 仓库所有者
+//   - 仓库名称
+func isGitHubRepoURL(urlStr string) (bool, string, string) {
+	if urlStr == "" {
+		return false, "", ""
+	}
+
+	// 检查URL是否包含github.com
+	if !strings.Contains(strings.ToLower(urlStr), "github.com") {
+		return false, "", ""
+	}
+
+	// 解析URL
+	parsedURL, err := url.Parse(urlStr)
+	if err != nil {
+		return false, "", ""
+	}
+
+	// 检查主机名是否是github.com或www.github.com
+	hostname := strings.ToLower(parsedURL.Host)
+	if hostname != "github.com" && hostname != "www.github.com" {
+		return false, "", ""
+	}
+
+	// 解析路径部分，提取owner和repo
+	// 路径格式应该是 /owner/repo 或 /owner/repo.git
+	path := strings.TrimPrefix(parsedURL.Path, "/")
+	parts := strings.Split(path, "/")
+
+	if len(parts) < 2 {
+		return false, "", ""
+	}
+
+	owner := parts[0]
+	repo := parts[1]
+
+	// 如果repo以.git结尾，去掉这个后缀
+	repo = strings.TrimSuffix(repo, ".git")
+
+	return true, owner, repo
+}
+
+// UpdateTheme 更新主题
+// 支持四种更新方式：
+// 1. 使用主题原有URL下载更新
+// 2. 提供新的直接下载URL进行更新
+// 3. 提供GitHub仓库信息，从最新release下载更新
+// 4. 如果主题URL是GitHub仓库地址，自动获取最新release
+func UpdateTheme(c *gin.Context) {
+	var req struct {
+		Short    string `json:"short" binding:"required"` // 主题短名称
+		URL      string `json:"url"`                      // 新的URL地址（可选）
+		GitOwner string `json:"git_owner"`                // GitHub仓库所有者（可选）
+		GitRepo  string `json:"git_repo"`                 // GitHub仓库名称（可选）
+	}
+
+	if err := c.ShouldBindJSON(&req); err != nil {
+		api.RespondError(c, http.StatusBadRequest, "参数错误: "+err.Error())
+		return
+	}
+
+	// 检查主题是否存在
+	themeDir := filepath.Join("./data/theme", req.Short)
+	themeConfigPath := filepath.Join(themeDir, "komari-theme.json")
+
+	if _, err := os.Stat(themeConfigPath); os.IsNotExist(err) {
+		api.RespondError(c, http.StatusNotFound, "主题不存在")
+		return
+	}
+
+	// 加载现有主题配置
+	themeInfo, err := loadThemeConfig(themeConfigPath)
+	if err != nil {
+		api.RespondError(c, http.StatusInternalServerError, "读取主题配置失败: "+err.Error())
+		return
+	}
+
+	// 方式1和方式4: 尝试从原始URL下载主题
+	// 如果原始URL是GitHub仓库地址，则自动获取最新release
+	var themeData []byte
+	// 不保存下载链接，更新后由主题覆盖
+	//var downloadURL string
+	// var err2 error
+
+	if themeInfo.URL != "" {
+		// 检查原始URL是否是GitHub仓库地址
+		// 例如: https://github.com/owner/repo
+		isGitHub, owner, repo := isGitHubRepoURL(themeInfo.URL)
+		if isGitHub {
+			// 方式4: 如果原始URL是GitHub仓库地址，自动获取最新release
+			// 这是本次需求的核心功能：当主题文件中现有的url地址如果是github仓库的路径，则直接引用该url地址去下载最新的release
+			gitHubURL, err := getGitHubReleaseDownloadURL(owner, repo)
+			if err == nil {
+				// 使用获取到的GitHub release下载链接下载主题
+				themeData, _ = downloadThemeFromURL(gitHubURL)
+				//if err2 == nil {
+				// 注意：这里我们保存的是release的下载链接，而不是GitHub仓库地址
+				// 这样做是为了在下载成功后，将这个具体的release下载链接保存到主题配置中
+				// 但在下次更新时，我们仍然会检测到这是一个GitHub仓库，并获取最新的release
+				// downloadURL = gitHubURL
+				//}
+			}
+		} else {
+			// 原始URL不是GitHub仓库地址，直接尝试下载（方式1）
+			themeData, _ = downloadThemeFromURL(themeInfo.URL)
+			//if err2 == nil {
+			// downloadURL = themeInfo.URL
+			//}
+		}
+	}
+
+	// 如果原始URL下载失败，尝试其他方式下载
+	if themeData == nil || len(themeData) == 0 {
+		// 方式3: 如果提供了GitHub仓库信息，尝试从GitHub最新release下载
+		// 这种方式允许用户只需提供owner和repo信息，系统会自动获取最新release的下载链接
+		if req.GitOwner != "" && req.GitRepo != "" {
+			// 从GitHub API获取下载链接
+			// 相当于: DOWNLOAD_URL=$(curl -s https://api.github.com/repos/owner/repo/releases/latest | jq -r ".assets[0].browser_download_url")
+			gitHubURL, err := getGitHubReleaseDownloadURL(req.GitOwner, req.GitRepo)
+			if err != nil {
+				api.RespondError(c, http.StatusBadRequest, "从GitHub获取下载链接失败: "+err.Error())
+				return
+			}
+
+			// 使用获取到的链接下载主题
+			themeData, err = downloadThemeFromURL(gitHubURL)
+			if err != nil {
+				api.RespondError(c, http.StatusBadRequest, "从GitHub下载主题失败: "+err.Error())
+				return
+			}
+			// 保存下载链接，稍后更新到主题配置中
+			// downloadURL = gitHubURL
+		} else if req.URL != "" {
+			// 方式2: 如果提供了新URL，尝试从新URL下载
+			// 检查新URL是否是GitHub仓库地址
+			isGitHub, owner, repo := isGitHubRepoURL(req.URL)
+			if isGitHub {
+				// 如果新URL是GitHub仓库地址，获取最新release
+				// 这里也应用了自动检测GitHub仓库并下载最新release的功能
+				gitHubURL, err := getGitHubReleaseDownloadURL(owner, repo)
+				if err != nil {
+					api.RespondError(c, http.StatusBadRequest, "从GitHub获取下载链接失败: "+err.Error())
+					return
+				}
+
+				// 使用获取到的链接下载主题
+				themeData, err = downloadThemeFromURL(gitHubURL)
+				if err != nil {
+					api.RespondError(c, http.StatusBadRequest, "从GitHub下载主题失败: "+err.Error())
+					return
+				}
+				// 保存GitHub仓库URL，而不是release下载链接，以便将来可以获取最新版本
+				// 这是一个重要的设计决策：我们保存的是GitHub仓库URL，而不是具体的release下载链接
+				// 这样在下次更新时，系统会再次检测到这是GitHub仓库，并自动获取最新的release
+				// downloadURL = req.URL
+			} else {
+				// 新URL不是GitHub仓库地址，直接尝试下载
+				themeData, err = downloadThemeFromURL(req.URL)
+				if err != nil {
+					api.RespondError(c, http.StatusBadRequest, "从新URL下载主题失败: "+err.Error())
+					return
+				}
+				// downloadURL = req.URL
+			}
+		}
+	}
+
+	// 如果没有成功下载主题数据
+	if themeData == nil || len(themeData) == 0 {
+		api.RespondError(c, http.StatusBadRequest, "无法下载主题，请提供有效的URL或GitHub仓库信息")
+		return
+	}
+
+	// 到这里，我们已经成功获取了主题数据，可能是通过以下四种方式之一：
+	// 1. 原始URL直接下载
+	// 2. 原始URL是GitHub仓库，自动获取最新release下载
+	// 3. 用户提供的新URL下载
+	// 4. 用户提供的GitHub仓库信息，获取最新release下载
+
+	// 临时文件名
+	tempFile := filepath.Join(os.TempDir(), "downloaded_theme.zip")
+	if err := os.WriteFile(tempFile, themeData, 0644); err != nil {
+		api.RespondError(c, http.StatusInternalServerError, "保存文件失败: "+err.Error())
+		return
+	}
+	defer os.Remove(tempFile)
+
+	// 解压ZIP文件并验证
+	updatedThemeInfo, err := extractAndValidateTheme(tempFile)
+	if err != nil {
+		api.RespondError(c, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	// 如果下载URL与原始URL不同，更新主题配置中的URL
+	// if downloadURL != themeInfo.URL {
+	// 	updatedThemeInfo.URL = downloadURL
+
+	// 	// 更新主题配置文件
+	// 	updatedConfigPath := filepath.Join("./data/theme", updatedThemeInfo.Short, "komari-theme.json")
+	// 	updatedConfigData, err := json.MarshalIndent(updatedThemeInfo, "", "  ")
+	// 	if err != nil {
+	// 		api.RespondError(c, http.StatusInternalServerError, "生成主题配置失败: "+err.Error())
+	// 		return
+	// 	}
+
+	// 	if err := os.WriteFile(updatedConfigPath, updatedConfigData, 0644); err != nil {
+	// 		api.RespondError(c, http.StatusInternalServerError, "更新主题配置文件失败: "+err.Error())
+	// 		return
+	// 	}
+	// }
+
+	api.RespondSuccessMessage(c, "主题更新成功", updatedThemeInfo)
+}
+
+func UpdateThemeSettings(c *gin.Context) {
+	theme := c.Query("theme")
+	if theme == "" || theme == "default" {
+		api.RespondError(c, http.StatusBadRequest, "主题名称不能为空或不能是默认主题")
+		return
+	}
+
+	var req map[string]any
+
+	err := c.ShouldBindJSON(&req)
+	if err != nil {
+		api.RespondError(c, http.StatusBadRequest, "参数错误: "+err.Error())
+		return
+	}
+	db := dbcore.GetDBInstance()
+
+	data, err := json.Marshal(&req)
+	if err != nil {
+		api.RespondError(c, http.StatusInternalServerError, "生成主题配置失败: "+err.Error())
+		return
+	}
+
+	var themeCfg models.ThemeConfiguration
+	db.Where("short = ?", theme).
+		Assign(models.ThemeConfiguration{Short: theme, Data: string(data)}).
+		FirstOrCreate(&themeCfg)
+	api.RespondSuccess(c, nil)
+}

api/client/autoDiscovery.go

@@ -0,0 +1,41 @@
+package client
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/komari-monitor/komari/api"
+	"github.com/komari-monitor/komari/database/clients"
+	"github.com/komari-monitor/komari/database/config"
+	"github.com/komari-monitor/komari/utils"
+)
+
+func RegisterClient(c *gin.Context) {
+	auth := c.GetHeader("Authorization")
+	if auth == "" {
+		api.RespondError(c, 403, "Invalid AutoDiscovery Key")
+		return
+	}
+	cfg, err := config.Get()
+	if err != nil {
+		api.RespondError(c, 500, "Failed to get configuration: "+err.Error())
+		return
+	}
+
+	if cfg.AutoDiscoveryKey == "" ||
+		len(cfg.AutoDiscoveryKey) < 12 ||
+		"Bearer "+cfg.AutoDiscoveryKey != auth {
+
+		api.RespondError(c, 403, "Invalid AutoDiscovery Key")
+		return
+	}
+	name := c.Query("name")
+	if name == "" {
+		name = utils.GenerateRandomString(8)
+	}
+	name = "Auto-" + name
+	uuid, token, err := clients.CreateClientWithName(name)
+	if err != nil {
+		api.RespondError(c, 500, "Failed to create client: "+err.Error())
+		return
+	}
+	api.RespondSuccess(c, gin.H{"uuid": uuid, "token": token})
+}

api/client/report.go

@@ -22,6 +22,12 @@ import (
 	"github.com/patrickmn/go-cache"
 )
 
+const (
+	// 如果超过这个时间没有收到任何消息，则认为连接已死
+	// 因为目前server没有存agent的信息上报间隔。只有写一个默认的
+	readWait = 11 * time.Second
+)
+
 func UploadReport(c *gin.Context) {
 	bodyBytes, err := io.ReadAll(c.Request.Body)
 	if err != nil {
@@ -51,7 +57,7 @@ func UploadReport(c *gin.Context) {
 	}
 	// Update report with method and token
 
-	ws.GetLatestReport()[report.UUID] = &report
+	ws.SetLatestReport(report.UUID, &report)
 
 	c.Request.Body = io.NopCloser(bytes.NewBuffer(bodyBytes)) // Restore the body for further use
 	c.JSON(200, gin.H{"status": "success"})
@@ -65,7 +71,7 @@ func WebSocketReport(c *gin.Context) {
 	}
 	upgrader := websocket.Upgrader{
 		CheckOrigin: func(r *http.Request) bool {
-			return true
+			return true // 被控
 		},
 	}
 	// Upgrade the HTTP connection to a WebSocket connection
@@ -109,72 +115,87 @@ func WebSocketReport(c *gin.Context) {
 		return
 	}
 
-	// 只允许一个客户端的连接
-	if _, exists := ws.GetConnectedClients()[uuid]; exists {
-		conn.WriteJSON(gin.H{"status": "error", "error": "Token already in use"})
-		return
+	// 接受新连接，并处理旧连接
+	if oldConn, exists := ws.GetConnectedClients()[uuid]; exists {
+		log.Printf("Client %s is reconnecting. Closing the old connection.", uuid)
+
+		// 强制关闭旧连接。这将导致旧连接的 ReadMessage() 循环出错退出。
+		go oldConn.Close()
 	}
 	ws.SetConnectedClients(uuid, conn)
-	go notifier.OnlineNotification(uuid)
+	log.Printf("Client %s is reconnect success, connID: %d", uuid, conn.ID)
+	go notifier.OnlineNotification(uuid, conn.ID)
 	defer func() {
-		ws.DeleteConnectedClients(uuid)
-		notifier.OfflineNotification(uuid)
+		ws.DeleteClientConditionally(uuid, conn)
+		notifier.OfflineNotification(uuid, conn.ID)
 	}()
 
+	// 首先处理第一次ws conn收到的消息
+	processMessage(conn, message, uuid)
+
 	for {
+		conn.SetReadDeadline(time.Now().Add(readWait))
+
 		_, message, err := conn.ReadMessage()
 		if err != nil {
-			break
+			if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway, websocket.CloseAbnormalClosure) {
+				log.Printf("Client %s connection error: %v", uuid, err)
+			}
+			break // 任何读错误（包括超时）都意味着连接已断开，退出循环
 		}
+		processMessage(conn, message, uuid)
+	}
+}
 
-		type MessageType struct {
-			Type string `json:"type"`
-		}
-		var msgType MessageType
-		err = json.Unmarshal(message, &msgType)
+// 将消息处理逻辑提取到一个函数中，方便复用
+func processMessage(conn *ws.SafeConn, message []byte, uuid string) {
+	type MessageType struct {
+		Type string `json:"type"`
+	}
+	var msgType MessageType
+	err := json.Unmarshal(message, &msgType)
+	if err != nil {
+		conn.WriteJSON(gin.H{"status": "error", "error": "Invalid JSON"})
+		return
+	}
+
+	switch msgType.Type {
+	case "", "report":
+		report := common.Report{}
+		err = json.Unmarshal(message, &report)
 		if err != nil {
-			conn.WriteJSON(gin.H{"status": "error", "error": "Invalid JSON"})
-			continue
+			conn.WriteJSON(gin.H{"status": "error", "error": "Invalid report format"})
+			return
 		}
-		switch msgType.Type {
-		case "", "report":
-			report := common.Report{}
-			err = json.Unmarshal(message, &report)
-			if err != nil {
-				conn.WriteJSON(gin.H{"status": "error", "error": "Invalid report format"})
-				continue
-			}
-			report.UpdatedAt = time.Now()
-			err = SaveClientReport(uuid, report)
-			if err != nil {
-				conn.WriteJSON(gin.H{"status": "error", "error": fmt.Sprintf("%v", err)})
-				continue
-			}
-			ws.SetLatestReport(uuid, &report)
-		case "ping_result":
-			var reqBody struct {
-				PingTaskID uint      `json:"task_id"`
-				PingResult int       `json:"value"`
-				PingType   string    `json:"ping_type"`
-				FinishedAt time.Time `json:"finished_at"`
-			}
-			err = json.Unmarshal(message, &reqBody)
-			if err != nil {
-				conn.WriteJSON(gin.H{"status": "error", "error": "Invalid ping result format"})
-				continue
-			}
-			pingResult := models.PingRecord{
-				Client: uuid,
-				TaskId: reqBody.PingTaskID,
-				Value:  reqBody.PingResult,
-				Time:   models.FromTime(reqBody.FinishedAt),
-			}
-			tasks.SavePingRecord(pingResult)
-		default:
-			log.Printf("Unknown message type: %s", msgType.Type)
-			conn.WriteJSON(gin.H{"status": "error", "error": "Unknown message type"})
+		report.UpdatedAt = time.Now()
+		err = SaveClientReport(uuid, report)
+		if err != nil {
+			conn.WriteJSON(gin.H{"status": "error", "error": fmt.Sprintf("%v", err)})
+			return
 		}
-
+		ws.SetLatestReport(uuid, &report)
+	case "ping_result":
+		var reqBody struct {
+			PingTaskID uint      `json:"task_id"`
+			PingResult int       `json:"value"`
+			PingType   string    `json:"ping_type"`
+			FinishedAt time.Time `json:"finished_at"`
+		}
+		err = json.Unmarshal(message, &reqBody)
+		if err != nil {
+			conn.WriteJSON(gin.H{"status": "error", "error": "Invalid ping result format"})
+			return
+		}
+		pingResult := models.PingRecord{
+			Client: uuid,
+			TaskId: reqBody.PingTaskID,
+			Value:  reqBody.PingResult,
+			Time:   models.FromTime(reqBody.FinishedAt),
+		}
+		tasks.SavePingRecord(pingResult)
+	default:
+		log.Printf("Unknown message type: %s", msgType.Type)
+		conn.WriteJSON(gin.H{"status": "error", "error": "Unknown message type"})
 	}
 }
 

api/client/task.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/gin-gonic/gin"
 	"github.com/komari-monitor/komari/database/clients"
+	"github.com/komari-monitor/komari/database/models"
 	"github.com/komari-monitor/komari/database/tasks"
 )
 
@@ -26,7 +27,7 @@ func TaskResult(c *gin.Context) {
 		return
 	}
 
-	if err := tasks.SaveTaskResult(req.TaskId, clientId, req.Result, req.ExitCode, req.FinishedAt); err != nil {
+	if err := tasks.SaveTaskResult(req.TaskId, clientId, req.Result, req.ExitCode, models.FromTime(req.FinishedAt)); err != nil {
 		c.JSON(500, gin.H{"status": "error", "message": "Failed to update task result: " + err.Error()})
 		return
 	}

api/client/terminal.go

@@ -22,7 +22,7 @@ func EstablishConnection(c *gin.Context) {
 	}
 	upgrader := websocket.Upgrader{
 		CheckOrigin: func(r *http.Request) bool {
-			return true // TODO: 检查源站
+			return true // 被控
 		},
 	}
 	conn, err := upgrader.Upgrade(c.Writer, c.Request, nil)

api/client/uploadBasicInfo.go

@@ -10,6 +10,18 @@ import (
 	"github.com/gin-gonic/gin"
 )
 
+func getClientIPType(ip net.IP) int {
+	// 0:ipv4 1:ipv6 -1:错误的输入
+	if ip == nil {
+		return -1
+	}
+	if ip.To4() == nil {
+		return 1
+	} else {
+		return 0
+	}
+}
+
 func UploadBasicInfo(c *gin.Context) {
 	var cbi = map[string]interface{}{}
 	if err := c.ShouldBindJSON(&cbi); err != nil {
@@ -26,6 +38,28 @@ func UploadBasicInfo(c *gin.Context) {
 
 	cbi["uuid"] = uuid
 
+	if (func() bool {
+		if v4, ok := cbi["ipv4"].(string); !ok || v4 == "" {
+			if v6, ok := cbi["ipv6"].(string); !ok || v6 == "" {
+				return true
+			}
+		}
+		return false
+	})() {
+		ipStr := c.ClientIP()
+		ip := net.ParseIP(ipStr)
+		ipType := getClientIPType(ip)
+
+		switch ipType {
+		case 0:
+			cbi["ipv4"] = ip
+		case 1:
+			cbi["ipv6"] = ip
+		default:
+			break
+		}
+	}
+
 	if cfg, err := config.Get(); err == nil && cfg.GeoIpEnabled {
 		if ipv4, ok := cbi["ipv4"].(string); ok && ipv4 != "" {
 			ip4 := net.ParseIP(ipv4)

api/latestRecord.go

@@ -2,14 +2,43 @@ package api
 
 import (
 	"github.com/gin-gonic/gin"
+	"github.com/komari-monitor/komari/database/accounts"
+	"github.com/komari-monitor/komari/database/dbcore"
+	"github.com/komari-monitor/komari/database/models"
 )
 
 func GetClientRecentRecords(c *gin.Context) {
 	uuid := c.Param("uuid")
+
 	if uuid == "" {
 		RespondError(c, 400, "UUID is required")
 		return
 	}
+
+	// 登录状态检查
+	isLogin := false
+	session, _ := c.Cookie("session_token")
+	_, err := accounts.GetUserBySession(session)
+	if err == nil {
+		isLogin = true
+	}
+
+	// 仅在未登录时需要 Hidden 信息做过滤
+	hiddenMap := map[string]bool{}
+	if !isLogin {
+		var hiddenClients []models.Client
+		db := dbcore.GetDBInstance()
+		_ = db.Select("uuid").Where("hidden = ?", true).Find(&hiddenClients).Error
+		for _, cli := range hiddenClients {
+			hiddenMap[cli.UUID] = true
+		}
+
+		if hiddenMap[uuid] {
+			RespondError(c, 400, "UUID is required") //防止未登录用户获取隐藏客户端数据
+			return
+		}
+	}
+
 	records, _ := Records.Get(uuid)
 	RespondSuccess(c, records)
 }

api/login.go

@@ -48,13 +48,15 @@ func Login(c *gin.Context) {
 	}
 	// 2FA
 	user, _ := accounts.GetUserByUUID(uuid)
-	if user.TwoFactor != "" && data.TwoFa == "" {
-		RespondError(c, http.StatusUnauthorized, "2FA code is required")
-		return
-	}
-	if ok, err := accounts.Verify2Fa(uuid, data.TwoFa); err != nil && ok {
-		RespondError(c, http.StatusUnauthorized, "Invalid 2FA code")
-		return
+	if user.TwoFactor != "" { // 开启了2FA
+		if data.TwoFa == "" {
+			RespondError(c, http.StatusUnauthorized, "2FA code is required")
+			return
+		}
+		if ok, err := accounts.Verify2Fa(uuid, data.TwoFa); err != nil || !ok {
+			RespondError(c, http.StatusUnauthorized, "Invalid 2FA code")
+			return
+		}
 	}
 	// Create session
 	session, err := accounts.CreateSession(uuid, 2592000, c.Request.UserAgent(), c.ClientIP(), "password")

api/nodes.go

@@ -2,6 +2,7 @@ package api
 
 import (
 	"github.com/gin-gonic/gin"
+	"github.com/komari-monitor/komari/database/accounts"
 	"github.com/komari-monitor/komari/database/clients"
 )
 
@@ -11,16 +12,28 @@ func GetNodesInformation(c *gin.Context) {
 		RespondError(c, 500, "Failed to retrieve client information: "+err.Error())
 		return
 	}
+	isLogin := false
+	session, _ := c.Cookie("session_token")
+	_, err = accounts.GetUserBySession(session)
+	if err == nil {
+		isLogin = true
+	}
 
-	count := len(clientList)
-	// 公开信息不展示IP地址,私有备注不展示
-	for i := 0; i < count; i++ {
+	// 过滤掉 Hidden 的客户端，并清理需要隐藏的字段
+	j := 0
+	for i := 0; i < len(clientList); i++ {
+		if clientList[i].Hidden && !isLogin { // 不返回 Hidden 客户端
+			continue
+		}
 		clientList[i].IPv4 = ""
 		clientList[i].IPv6 = ""
-		clientList[i].Remark = ""
+		clientList[i].Remark = "" // 私有备注不展示
 		clientList[i].Version = ""
 		clientList[i].Token = ""
+		clientList[j] = clientList[i]
+		j++
 	}
+	clientList = clientList[:j]
 
 	RespondSuccess(c, clientList)
 }

api/oauth.go

@@ -7,6 +7,7 @@ import (
 	"github.com/komari-monitor/komari/database/accounts"
 	"github.com/komari-monitor/komari/database/auditlog"
 	"github.com/komari-monitor/komari/database/config"
+	"github.com/komari-monitor/komari/utils"
 	"github.com/komari-monitor/komari/utils/oauth"
 )
 
@@ -18,7 +19,7 @@ func OAuth(c *gin.Context) {
 		return
 	}
 
-	authURL, state := oauth.CurrentProvider().GetAuthorizationURL()
+	authURL, state := oauth.CurrentProvider().GetAuthorizationURL(utils.GetCallbackURL(c))
 
 	c.SetCookie("oauth_state", state, 3600, "/", "", false, true)
 
@@ -30,9 +31,23 @@ func OAuthCallback(c *gin.Context) {
 	// 验证state防止CSRF攻击
 	state, _ := c.Cookie("oauth_state")
 	c.SetCookie("oauth_state", "", -1, "/", "", false, true)
-	if state == "" || state != c.Query("state") {
-		c.JSON(400, gin.H{"status": "error", "error": "Invalid state"})
-		return
+	
+	// 获取当前OAuth提供商名称
+	providerName := oauth.CurrentProvider().GetName()
+	
+	// 对于QQ登录，由于是通过QQ聚合登录平台中转，state可能会不匹配
+	// 但我们仍然需要验证state的存在性（不能是空的）
+	if providerName == "qq" {
+		if state == "" {
+			c.JSON(400, gin.H{"status": "error", "error": "Invalid state"})
+			return
+		}
+	} else {
+		// 对于其他提供商，严格验证state匹配
+		if state == "" || state != c.Query("state") {
+			c.JSON(400, gin.H{"status": "error", "error": "Invalid state"})
+			return
+		}
 	}
 
 	queries := make(map[string]string)
@@ -41,7 +56,7 @@ func OAuthCallback(c *gin.Context) {
 			queries[key] = values[0]
 		}
 	}
-	oidcUser, err := oauth.CurrentProvider().OnCallback(c.Request.Context(), state, queries)
+	oidcUser, err := oauth.CurrentProvider().OnCallback(c.Request.Context(), state, queries, utils.GetCallbackURL(c))
 	if err != nil {
 		c.JSON(500, gin.H{"status": "error", "error": "Failed to get user info: " + err.Error()})
 		return
@@ -93,4 +108,4 @@ func OAuthCallback(c *gin.Context) {
 	c.SetCookie("session_token", session, 2592000, "/", "", false, true)
 	auditlog.Log(c.ClientIP(), user.UUID, "logged in (OAuth)", "login")
 	c.Redirect(302, "/admin")
-}
+}

api/public.go

@@ -1,8 +1,16 @@
 package api
 
 import (
+	"encoding/json"
+	"log"
+	"os"
+	"path/filepath"
+	"strings"
+
 	"github.com/gin-gonic/gin"
 	"github.com/komari-monitor/komari/database/config"
+	"github.com/komari-monitor/komari/database/dbcore"
+	"github.com/komari-monitor/komari/database/models"
 )
 
 func GetPublicSettings(c *gin.Context) {
@@ -11,6 +19,70 @@ func GetPublicSettings(c *gin.Context) {
 		RespondError(c, 500, err.Error())
 		return
 	}
+	db := dbcore.GetDBInstance()
+	tc := models.ThemeConfiguration{}
+	err = db.Model(&models.ThemeConfiguration{}).Where("short = ?", cst.Theme).First(&tc).Error
+	if err != nil {
+		tc.Data = "{}"
+	}
+	tc_data := gin.H{}
+	err = json.Unmarshal([]byte(tc.Data), &tc_data)
+	if err != nil {
+		log.Printf("%v", err)
+	}
+	// Try to load theme declaration file and merge defaults for managed configuration
+	// Theme declarations live in ./data/theme/<short>/komari-theme.json
+	if cst.Theme != "" && cst.Theme != "default" {
+		themeConfigPath := filepath.Join("./data/theme", cst.Theme, "komari-theme.json")
+		if _, err := os.Stat(themeConfigPath); err == nil {
+			b, err := os.ReadFile(themeConfigPath)
+			if err == nil {
+				var themeDecl struct {
+					Configuration struct {
+						Type string                                 `json:"type"`
+						Data []models.ManagedThemeConfigurationItem `json:"data"`
+					} `json:"configuration"`
+				}
+				if err := json.Unmarshal(b, &themeDecl); err == nil {
+					if themeDecl.Configuration.Type == "managed" {
+						for _, item := range themeDecl.Configuration.Data {
+							if item.Key == "" {
+								continue
+							}
+							// missing
+							if _, exists := tc_data[item.Key]; !exists {
+								var def any = item.Default
+								// select
+								if item.Type == "select" {
+									if def == nil || def == "" {
+										if item.Options != "" {
+											opts := strings.Split(item.Options, ",")
+											if len(opts) > 0 {
+												def = strings.TrimSpace(opts[0])
+											}
+										}
+									}
+								}
+								// number->0, string->"", switch->false
+								if def == nil {
+									switch item.Type {
+									case "number":
+										def = 0
+									case "switch":
+										def = false
+									default:
+										def = ""
+									}
+								}
+								tc_data[item.Key] = def
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
 	// Return public settings including CORS
 	RespondSuccess(c, gin.H{
 		"sitename":                  cst.Sitename,
@@ -25,6 +97,8 @@ func GetPublicSettings(c *gin.Context) {
 		"record_preserve_time":      cst.RecordPreserveTime,
 		"ping_record_preserve_time": cst.PingRecordPreserveTime,
 		"private_site":              cst.PrivateSite,
+		"theme":                     cst.Theme,
+		"theme_settings":            tc_data,
 	})
 
 }

api/record/record.go

@@ -1,17 +1,46 @@
 package record
 
 import (
+	"slices"
 	"strconv"
 	"time"
 
 	"github.com/gin-gonic/gin"
 	"github.com/komari-monitor/komari/api"
+	"github.com/komari-monitor/komari/database/accounts"
+	"github.com/komari-monitor/komari/database/dbcore"
+	"github.com/komari-monitor/komari/database/models"
 	records "github.com/komari-monitor/komari/database/records"
 	"github.com/komari-monitor/komari/database/tasks"
 )
 
 func GetRecordsByUUID(c *gin.Context) {
 	uuid := c.Query("uuid")
+
+	// 登录状态检查
+	isLogin := false
+	session, _ := c.Cookie("session_token")
+	_, err := accounts.GetUserBySession(session)
+	if err == nil {
+		isLogin = true
+	}
+
+	// 仅在未登录时需要 Hidden 信息做过滤
+	hiddenMap := map[string]bool{}
+	if !isLogin {
+		var hiddenClients []models.Client
+		db := dbcore.GetDBInstance()
+		_ = db.Select("uuid").Where("hidden = ?", true).Find(&hiddenClients).Error
+		for _, cli := range hiddenClients {
+			hiddenMap[cli.UUID] = true
+		}
+
+		if hiddenMap[uuid] {
+			api.RespondError(c, 400, "UUID is required") //防止未登录用户获取隐藏客户端数据
+			return
+		}
+	}
+
 	hours := c.Query("hours")
 	if uuid == "" {
 		api.RespondError(c, 400, "UUID is required")
@@ -41,6 +70,36 @@ func GetRecordsByUUID(c *gin.Context) {
 // GET query: uuid string, hours int
 func GetPingRecords(c *gin.Context) {
 	uuid := c.Query("uuid")
+
+	if uuid == "" {
+		api.RespondError(c, 400, "UUID is required")
+		return
+	}
+
+	// 登录状态检查
+	isLogin := false
+	session, _ := c.Cookie("session_token")
+	_, err := accounts.GetUserBySession(session)
+	if err == nil {
+		isLogin = true
+	}
+
+	// 仅在未登录时需要 Hidden 信息做过滤
+	hiddenMap := map[string]bool{}
+	if !isLogin {
+		var hiddenClients []models.Client
+		db := dbcore.GetDBInstance()
+		_ = db.Select("uuid").Where("hidden = ?", true).Find(&hiddenClients).Error
+		for _, cli := range hiddenClients {
+			hiddenMap[cli.UUID] = true
+		}
+
+		if hiddenMap[uuid] {
+			api.RespondError(c, 400, "UUID is required") //防止未登录用户获取隐藏客户端数据
+			return
+		}
+	}
+
 	hours := c.Query("hours")
 	type RecordsResp struct {
 		TaskId uint   `json:"task_id"`
@@ -53,10 +112,6 @@ func GetPingRecords(c *gin.Context) {
 		Tasks   []gin.H       `json:"tasks,omitempty"` // 任务列表
 	}
 
-	if uuid == "" {
-		api.RespondError(c, 400, "UUID is required")
-		return
-	}
 	if hours == "" {
 		hours = "4"
 	}
@@ -85,7 +140,7 @@ func GetPingRecords(c *gin.Context) {
 		})
 	}
 
-	if len(records) > 0 {
+	if len(records) >= 0 {
 		// 获取当前属于该 uuid 的 pingTasks
 		pingTasks, err := tasks.GetAllPingTasks()
 		if err != nil {
@@ -101,24 +156,34 @@ func GetPingRecords(c *gin.Context) {
 		tasksList := make([]gin.H, 0, len(pingTasks))
 		for _, t := range pingTasks {
 			// 只保留分配给该 uuid 的任务
-			found := false
-			for _, client := range t.Clients {
-				if client == uuid {
-					found = true
-					break
-				}
-			}
+			found := slices.Contains(t.Clients, uuid)
 			if !found {
 				continue
 			}
-			// 只返回有记录的任务
-			if _, ok := taskIdSet[t.Id]; ok {
-				tasksList = append(tasksList, gin.H{
-					"id":       t.Id,
-					"name":     t.Name,
-					"interval": t.Interval,
-				})
+
+			// 计算该任务的丢包率
+			totalCount := 0
+			lossCount := 0
+			for _, r := range records {
+				if r.TaskId == t.Id {
+					totalCount++
+					if r.Value < 0 {
+						lossCount++
+					}
+				}
 			}
+
+			var lossRate float64 = 0
+			if totalCount > 0 {
+				lossRate = float64(lossCount) / float64(totalCount) * 100
+			}
+
+			tasksList = append(tasksList, gin.H{
+				"id":       t.Id,
+				"name":     t.Name,
+				"interval": t.Interval,
+				"loss":     lossRate,
+			})
 		}
 		response.Tasks = tasksList
 	}

api/terminal.go

@@ -30,9 +30,7 @@ func RequestTerminal(c *gin.Context) {
 		return
 	}
 	upgrader := websocket.Upgrader{
-		CheckOrigin: func(r *http.Request) bool {
-			return true
-		},
+		CheckOrigin: ws.CheckOrigin,
 	}
 	conn, err := upgrader.Upgrade(c.Writer, c.Request, nil)
 	if err != nil {

api/ws.go

@@ -0,0 +1,124 @@
+package api
+
+import (
+	"net/http"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+	"github.com/gorilla/websocket"
+	"github.com/komari-monitor/komari/common"
+	"github.com/komari-monitor/komari/database/accounts"
+	"github.com/komari-monitor/komari/database/config"
+	"github.com/komari-monitor/komari/database/dbcore"
+	"github.com/komari-monitor/komari/database/models"
+	"github.com/komari-monitor/komari/ws"
+)
+
+func GetClients(c *gin.Context) {
+	// 升级到ws
+	if !websocket.IsWebSocketUpgrade(c.Request) {
+		c.JSON(http.StatusBadRequest, gin.H{"status": "error", "error": "Require WebSocket upgrade"})
+		return
+	}
+	cfg, _ := config.Get()
+	upgrader := websocket.Upgrader{
+		CheckOrigin: func(r *http.Request) bool {
+			if cfg.AllowCors {
+				return true
+			}
+			return ws.CheckOrigin(r)
+		},
+	}
+	// Upgrade the HTTP connection to a WebSocket connection
+	conn, err := upgrader.Upgrade(c.Writer, c.Request, nil)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"status": "error", "error": "Failed to upgrade to WebSocket"})
+		return
+	}
+	defer conn.Close()
+
+	// 请求
+	for {
+		var resp struct {
+			Online []string                  `json:"online"` // 已建立连接的客户端uuid列表
+			Data   map[string]*common.Report `json:"data"`   // 最后上报的数据
+		}
+		resp.Online = []string{}
+		_, data, err := conn.ReadMessage()
+		if err != nil {
+			//log.Println("Error reading message:", err)
+			return
+		}
+		message := string(data)
+
+		uuID := ""
+		if message != "get" { // 非请求全部内容
+			if strings.HasPrefix(message, "get ") {
+				uuID = strings.TrimSpace(strings.TrimPrefix(message, "get "))
+			} else {
+				conn.WriteJSON(gin.H{"status": "error", "error": "Invalid message"})
+				continue
+			}
+		}
+
+		// 登录状态检查
+		isLogin := false
+		session, _ := c.Cookie("session_token")
+		_, err = accounts.GetUserBySession(session)
+		if err == nil {
+			isLogin = true
+		}
+		// 仅在未登录时需要 Hidden 信息做过滤
+		hiddenMap := map[string]bool{}
+		if !isLogin {
+			var hiddenClients []models.Client
+			db := dbcore.GetDBInstance()
+			_ = db.Select("uuid").Where("hidden = ?", true).Find(&hiddenClients).Error
+			for _, cli := range hiddenClients {
+				hiddenMap[cli.UUID] = true
+			}
+		}
+		// 已建立连接的客户端uuid列表
+		for key := range ws.GetConnectedClients() {
+			if uuID != "" { // 请求特定服务器信息
+				if !(!isLogin && hiddenMap[key]) && key == uuID { // 未登录且 Hidden 或 不符合请求的特定服务器 -> 跳过
+					resp.Online = append(resp.Online, key)
+				}
+			} else {
+				if !(!isLogin && hiddenMap[key]) { // 未登录且 Hidden -> 跳过
+					resp.Online = append(resp.Online, key)
+				}
+			}
+		}
+		// 清除UUID，简化报告单
+		resp.Data = ws.GetLatestReport()
+		if !isLogin { // 未登录过滤 Hidden 的节点报告
+			for uuid := range resp.Data {
+				if hiddenMap[uuid] {
+					delete(resp.Data, uuid)
+				}
+			}
+		}
+
+		if uuID != "" { // 过滤不符合请求的特定服务器
+			for key := range resp.Data {
+				if key != uuID {
+					delete(resp.Data, key)
+				}
+			}
+		}
+
+		for _, report := range resp.Data { // 不暴露 uuid
+			report.UUID = ""
+			if report.CPU.Usage == 0 {
+				report.CPU.Usage = 0.01
+			}
+		}
+
+		err = conn.WriteJSON(gin.H{"status": "success", "data": resp})
+		if err != nil {
+			return
+		}
+	}
+
+}

cmd/server.go

@@ -38,7 +38,6 @@ import (
 	"github.com/komari-monitor/komari/utils/messageSender"
 	"github.com/komari-monitor/komari/utils/notifier"
 	"github.com/komari-monitor/komari/utils/oauth"
-	"github.com/komari-monitor/komari/ws"
 	"github.com/spf13/cobra"
 )
 
@@ -155,7 +154,7 @@ func RunServer() {
 	// #region 公开路由
 	r.POST("/api/login", api.Login)
 	r.GET("/api/me", api.GetMe)
-	r.GET("/api/clients", ws.GetClients)
+	r.GET("/api/clients", api.GetClients)
 	r.GET("/api/nodes", api.GetNodesInformation)
 	r.GET("/api/public", api.GetPublicSettings)
 	r.GET("/api/oauth", api.OAuth)
@@ -167,6 +166,7 @@ func RunServer() {
 	r.GET("/api/records/load", record.GetRecordsByUUID)
 	r.GET("/api/records/ping", record.GetPingRecords)
 	// #region Agent
+	r.POST("/api/clients/register", client.RegisterClient)
 	tokenAuthrized := r.Group("/api/clients", api.TokenAuthMiddleware())
 	{
 		tokenAuthrized.GET("/report", client.WebSocketReport) // websocket
@@ -221,6 +221,8 @@ func RunServer() {
 			themeGroup.GET("/list", admin.ListThemes)
 			themeGroup.POST("/delete", admin.DeleteTheme)
 			themeGroup.GET("/set", admin.SetTheme)
+			themeGroup.POST("/update", admin.UpdateTheme)
+			themeGroup.POST("/settings", admin.UpdateThemeSettings)
 		}
 		// clients
 		clientGroup := adminAuthrized.Group("/client")
@@ -378,6 +380,8 @@ func DoScheduledWork() {
 				records.DeleteAll()
 				tasks.DeleteAllPingRecords()
 			}
+			// 每分钟检查一次流量提醒
+			go notifier.CheckTraffic()
 		}
 	}
 

database/accounts/sessions.go

@@ -2,11 +2,16 @@ package accounts
 
 import (
 	"errors"
+	"fmt"
+	"net"
 	"time"
 
+	"github.com/komari-monitor/komari/database/config"
 	"github.com/komari-monitor/komari/database/dbcore"
 	"github.com/komari-monitor/komari/database/models"
 	"github.com/komari-monitor/komari/utils"
+	"github.com/komari-monitor/komari/utils/geoip"
+	"github.com/komari-monitor/komari/utils/messageSender"
 )
 
 // GetAllSessions 获取所有会话
@@ -33,6 +38,16 @@ func CreateSession(uuid string, expires int, userAgent, ip, login_method string)
 		LoginMethod:  login_method,
 		LatestOnline: models.FromTime(time.Now()),
 	}
+	cfg, _ := config.Get()
+	if cfg.LoginNotification {
+		ipAddr := net.ParseIP(ip)
+		ipinfo, _ := geoip.GetGeoInfo(ipAddr)
+		loc := "unknown"
+		if ipinfo != nil {
+			loc = ipinfo.Name
+		}
+		messageSender.SendTextMessage(fmt.Sprintf("From: %s,(%s)\nMethod: %s\nUser Agent: %s\n\n%s", ip, loc, login_method, userAgent, time.Now().Format(time.RFC3339)), "New Login on Komari")
+	}
 
 	err := db.Create(&sessionRecord).Error
 	if err != nil {

database/clients/client.go

@@ -1,6 +1,7 @@
 package clients
 
 import (
+	"math"
 	"time"
 
 	"github.com/komari-monitor/komari/common"
@@ -47,7 +48,7 @@ func UpdateOrInsertBasicInfo(cbi common.ClientInfo) error {
 	if cbi.Arch != "" {
 		updates["arch"] = cbi.Arch
 	}
-	if cbi.CpuCores != 0 {
+	if cbi.CpuCores > 0 || cbi.CpuCores < math.MaxInt-1 {
 		updates["cpu_cores"] = cbi.CpuCores
 	}
 	if cbi.OS != "" {
@@ -120,6 +121,36 @@ func SaveClientInfo(update map[string]interface{}) error {
 
 	update["updated_at"] = time.Now()
 
+	checkInt64 := func(name string, val float64) error {
+		if val < 0 {
+			return fmt.Errorf("%s must be non-negative, got %d", name, int64(val))
+		}
+		if val > math.MaxInt64-1 {
+			return fmt.Errorf("%s exceeds int64 max limit: %d", name, int64(val))
+		}
+		return nil
+	}
+
+	verify := func(update map[string]interface{}) error {
+		if update["cpu_cores"].(float64) < 0 || update["cpu_cores"].(float64) > math.MaxInt-1 {
+			return fmt.Errorf("Cpu.Cores be not a valid int64 number: %d", update["cpu_cores"])
+		}
+		if err := checkInt64("Ram.Total", update["mem_total"].(float64)); err != nil {
+			return err
+		}
+		if err := checkInt64("Swap.Total", update["swap_total"].(float64)); err != nil {
+			return err
+		}
+		if err := checkInt64("Disk.Total", update["disk_total"].(float64)); err != nil {
+			return err
+		}
+		return nil
+	}
+
+	if err := verify(update); err != nil {
+		return err
+	}
+
 	err := db.Model(&models.Client{}).Where("uuid = ?", clientUUID).Updates(update).Error
 	if err != nil {
 		return err

database/clients/report.go

@@ -3,6 +3,7 @@ package clients
 import (
 	"encoding/json"
 	"fmt"
+	"math"
 	"time"
 
 	"github.com/komari-monitor/komari/common"
@@ -51,10 +52,98 @@ func ParseReport(data map[string]interface{}) (report common.Report, err error)
 	return report, nil
 }
 
+// 检查数据防止异常数据导致数据库损坏
+func ReportVerify(report common.Report) error {
+	// 防止输入不合理范围
+	if report.CPU.Usage < 0 || report.CPU.Usage > 100 {
+		return fmt.Errorf("CPU.Usage must be between 0 and 100")
+	}
+
+	if report.Load.Load1 < 0 || report.Load.Load1 > 1000 {
+		return fmt.Errorf("Load.Load1 must be non-negative, got %.2f", report.Load.Load1)
+	}
+
+	checkFloat64 := func(name string, val float64) error {
+		if val > math.MaxFloat64-1 || val < -math.MaxFloat64+1 {
+			return fmt.Errorf("%s value exceeds float64 range: %g", name, val)
+		}
+		return nil
+	}
+
+	// [float64] 防止数据溢出
+	if err := checkFloat64("CPU.Usage", report.CPU.Usage); err != nil {
+		return err
+	}
+	if err := checkFloat64("Load.Load1", report.Load.Load1); err != nil {
+		return err
+	}
+
+	checkInt64 := func(name string, val int64) error {
+		if val < 0 {
+			return fmt.Errorf("%s must be non-negative, got %d", name, val)
+		}
+		if val > math.MaxInt64-1 {
+			return fmt.Errorf("%s exceeds int64 max limit: %d", name, val)
+		}
+		return nil
+	}
+
+	// [int64] 防止数据溢出
+	// Ram 验证
+	if err := checkInt64("Ram.Used", report.Ram.Used); err != nil {
+		return err
+	}
+	if err := checkInt64("Ram.Total", report.Ram.Total); err != nil {
+		return err
+	}
+	// Swap 验证
+	if err := checkInt64("Swap.Used", report.Swap.Used); err != nil {
+		return err
+	}
+	if err := checkInt64("Swap.Total", report.Swap.Total); err != nil {
+		return err
+	}
+	// Disk 验证
+	if err := checkInt64("Disk.Used", report.Disk.Used); err != nil {
+		return err
+	}
+	if err := checkInt64("Disk.Total", report.Disk.Total); err != nil {
+		return err
+	}
+	// Network 验证
+	if err := checkInt64("Network.Up", report.Network.Up); err != nil {
+		return err
+	}
+	if err := checkInt64("Network.Down", report.Network.Down); err != nil {
+		return err
+	}
+	if err := checkInt64("Network.TotalUp", report.Network.TotalUp); err != nil {
+		return err
+	}
+	if err := checkInt64("Network.TotalDown", report.Network.TotalDown); err != nil {
+		return err
+	}
+	// 拒绝所有负数Int
+	if report.Process < 0 {
+		return fmt.Errorf("Process must be non-negative: %d", report.Process)
+	}
+	if report.Connections.TCP < 0 {
+		return fmt.Errorf("Connections.TCP must be non-negative: %d", report.Connections.TCP)
+	}
+	if report.Connections.UDP < 0 {
+		return fmt.Errorf("Connections.UDP must be non-negative: %d", report.Connections.UDP)
+	}
+	return nil
+}
+
 // SaveClientReport 保存客户端报告到 Record 表
 func SaveClientReport(clientUUID string, report common.Report) (err error) {
 	db := dbcore.GetDBInstance()
 
+	if err := ReportVerify(report); err != nil {
+		return fmt.Errorf("failed to save Record: %v", err)
+	}
+
 	Record := models.Record{
 		Client:         clientUUID,
 		Time:           models.FromTime(time.Now()),

database/dbcore/dbcore.go

@@ -264,6 +264,7 @@ func GetDBInstance() *gorm.DB {
 			&models.PingTask{},
 			&models.OidcProvider{},
 			&models.MessageSenderProvider{},
+			&models.ThemeConfiguration{},
 		)
 		if err != nil {
 			log.Fatalf("Failed to create tables: %v", err)

database/models/config.go

@@ -1,12 +1,14 @@
 package models
 
 type Config struct {
-	ID          uint   `json:"id,omitempty" gorm:"primaryKey;autoIncrement"` // 1
-	Sitename    string `json:"sitename" gorm:"type:varchar(100);not null"`
-	Description string `json:"description" gorm:"type:text"`
-	AllowCors   bool   `json:"allow_cors" gorm:"column:allow_cors;default:false"`
-	Theme       string `json:"theme" gorm:"type:varchar(100);default:'default'"` // 主题名称，默认 'default'
-	PrivateSite bool   `json:"private_site" gorm:"default:false"`                // 是否为私有站点，默认 false
+	ID               uint   `json:"id,omitempty" gorm:"primaryKey;autoIncrement"` // 1
+	Sitename         string `json:"sitename" gorm:"type:varchar(100);not null"`
+	Description      string `json:"description" gorm:"type:text"`
+	AllowCors        bool   `json:"allow_cors" gorm:"column:allow_cors;default:false"`
+	Theme            string `json:"theme" gorm:"type:varchar(100);default:'default'"` // 主题名称，默认 'default'
+	PrivateSite      bool   `json:"private_site" gorm:"default:false"`                // 是否为私有站点，默认 false
+	ApiKey           string `json:"api_key" gorm:"type:varchar(255);default:''"`
+	AutoDiscoveryKey string `json:"auto_discovery_key" gorm:"type:varchar(255);default:''"` // 自动发现密钥
 	// GeoIP 配置
 	GeoIpEnabled  bool   `json:"geo_ip_enabled" gorm:"default:true"`
 	GeoIpProvider string `json:"geo_ip_provider" gorm:"type:varchar(20);default:'ip-api'"` // empty, mmdb, ip-api, geojs
@@ -18,10 +20,12 @@ type Config struct {
 	CustomHead string `json:"custom_head" gorm:"type:longtext"`
 	CustomBody string `json:"custom_body" gorm:"type:longtext"`
 	// 通知
-	NotificationEnabled        bool   `json:"notification_enabled" gorm:"default:false"` // 通知总开关
-	NotificationMethod         string `json:"notification_method" gorm:"type:varchar(64);default:'none'"`
-	ExpireNotificationEnabled  bool   `json:"expire_notification_enabled" gorm:"default:false"` // 是否启用过期通知
-	ExpireNotificationLeadDays int    `json:"expire_notification_lead_days" gorm:"default:7"`   // 过期前多少天通知，默认7天
+	NotificationEnabled        bool    `json:"notification_enabled" gorm:"default:false"` // 通知总开关
+	NotificationMethod         string  `json:"notification_method" gorm:"type:varchar(64);default:'none'"`
+	ExpireNotificationEnabled  bool    `json:"expire_notification_enabled" gorm:"default:false"` // 是否启用过期通知
+	ExpireNotificationLeadDays int     `json:"expire_notification_lead_days" gorm:"default:7"`   // 过期前多少天通知，默认7天
+	LoginNotification          bool    `json:"login_notification" gorm:"default:false"`          // 登录通知
+	TrafficLimitPercentage     float64 `json:"traffic_limit_percentage" gorm:"default:80.00"`    // 流量限制百分比，默认80.00%
 	// Record
 	RecordEnabled          bool `json:"record_enabled" gorm:"default:true"`          // 是否启用记录功能
 	RecordPreserveTime     int  `json:"record_preserve_time" gorm:"default:720"`     // 记录保留时间，单位小时，默认30天

database/models/models.go

@@ -8,35 +8,38 @@ import (
 
 // Client represents a registered client device
 type Client struct {
-	UUID           string    `json:"uuid,omitempty" gorm:"type:varchar(36);primaryKey"`
-	Token          string    `json:"token,omitempty" gorm:"type:varchar(255);unique;not null"`
-	Name           string    `json:"name" gorm:"type:varchar(100)"`
-	CpuName        string    `json:"cpu_name" gorm:"type:varchar(100)"`
-	Virtualization string    `json:"virtualization" gorm:"type:varchar(50)"`
-	Arch           string    `json:"arch" gorm:"type:varchar(50)"`
-	CpuCores       int       `json:"cpu_cores" gorm:"type:int"`
-	OS             string    `json:"os" gorm:"type:varchar(100)"`
-	KernelVersion  string    `json:"kernel_version" gorm:"type:varchar(100)"`
-	GpuName        string    `json:"gpu_name" gorm:"type:varchar(100)"`
-	IPv4           string    `json:"ipv4,omitempty" gorm:"type:varchar(100)"`
-	IPv6           string    `json:"ipv6,omitempty" gorm:"type:varchar(100)"`
-	Region         string    `json:"region" gorm:"type:varchar(100)"`
-	Remark         string    `json:"remark,omitempty" gorm:"type:longtext"`
-	PublicRemark   string    `json:"public_remark,omitempty" gorm:"type:longtext"`
-	MemTotal       int64     `json:"mem_total" gorm:"type:bigint"`
-	SwapTotal      int64     `json:"swap_total" gorm:"type:bigint"`
-	DiskTotal      int64     `json:"disk_total" gorm:"type:bigint"`
-	Version        string    `json:"version,omitempty" gorm:"type:varchar(100)"`
-	Weight         int       `json:"weight" gorm:"type:int"`
-	Price          float64   `json:"price"`
-	BillingCycle   int       `json:"billing_cycle"`
-	AutoRenewal    bool      `json:"auto_renewal" gorm:"default:false"` // 是否自动续费
-	Currency       string    `json:"currency" gorm:"type:varchar(20);default:'$'"`
-	ExpiredAt      LocalTime `json:"expired_at" gorm:"type:timestamp"`
-	Group          string    `json:"group" gorm:"type:varchar(100)"`
-	Tags           string    `json:"tags" gorm:"type:text"` // split by ';'
-	CreatedAt      LocalTime `json:"created_at"`
-	UpdatedAt      LocalTime `json:"updated_at"`
+	UUID             string    `json:"uuid,omitempty" gorm:"type:varchar(36);primaryKey"`
+	Token            string    `json:"token,omitempty" gorm:"type:varchar(255);unique;not null"`
+	Name             string    `json:"name" gorm:"type:varchar(100)"`
+	CpuName          string    `json:"cpu_name" gorm:"type:varchar(100)"`
+	Virtualization   string    `json:"virtualization" gorm:"type:varchar(50)"`
+	Arch             string    `json:"arch" gorm:"type:varchar(50)"`
+	CpuCores         int       `json:"cpu_cores" gorm:"type:int"`
+	OS               string    `json:"os" gorm:"type:varchar(100)"`
+	KernelVersion    string    `json:"kernel_version" gorm:"type:varchar(100)"`
+	GpuName          string    `json:"gpu_name" gorm:"type:varchar(100)"`
+	IPv4             string    `json:"ipv4,omitempty" gorm:"type:varchar(100)"`
+	IPv6             string    `json:"ipv6,omitempty" gorm:"type:varchar(100)"`
+	Region           string    `json:"region" gorm:"type:varchar(100)"`
+	Remark           string    `json:"remark,omitempty" gorm:"type:longtext"`
+	PublicRemark     string    `json:"public_remark,omitempty" gorm:"type:longtext"`
+	MemTotal         int64     `json:"mem_total" gorm:"type:bigint"`
+	SwapTotal        int64     `json:"swap_total" gorm:"type:bigint"`
+	DiskTotal        int64     `json:"disk_total" gorm:"type:bigint"`
+	Version          string    `json:"version,omitempty" gorm:"type:varchar(100)"`
+	Weight           int       `json:"weight" gorm:"type:int"`
+	Price            float64   `json:"price"`
+	BillingCycle     int       `json:"billing_cycle"`
+	AutoRenewal      bool      `json:"auto_renewal" gorm:"default:false"` // 是否自动续费
+	Currency         string    `json:"currency" gorm:"type:varchar(20);default:'$'"`
+	ExpiredAt        LocalTime `json:"expired_at" gorm:"type:timestamp"`
+	Group            string    `json:"group" gorm:"type:varchar(100)"`
+	Tags             string    `json:"tags" gorm:"type:text"` // split by ';'
+	Hidden           bool      `json:"hidden" gorm:"default:false"`
+	TrafficLimit     int64     `json:"traffic_limit" gorm:"type:bigint"`
+	TrafficLimitType string    `json:"traffic_limit_type" gorm:"type:varchar(10);default:'max'"` // 流量阈值类型：sum max min up down
+	CreatedAt        LocalTime `json:"created_at"`
+	UpdatedAt        LocalTime `json:"updated_at"`
 }
 
 // User represents an authenticated user

database/models/theme.go

@@ -2,11 +2,34 @@ package models
 
 // Theme represents a komari theme information
 type Theme struct {
-	Name        string `json:"name"`        // 主题名称
-	Short       string `json:"short"`       // 短名称，用作文件夹名
-	Description string `json:"description"` // 主题描述
-	Version     string `json:"version"`     // 版本号
-	Author      string `json:"author"`      // 作者
-	URL         string `json:"url"`         // 主题URL
-	Preview     string `json:"preview"`     // 预览图片相对路径
+	Name          string        `json:"name"`          // 主题名称
+	Short         string        `json:"short"`         // 短名称，用作文件夹名
+	Description   string        `json:"description"`   // 主题描述
+	Version       string        `json:"version"`       // 版本号
+	Author        string        `json:"author"`        // 作者
+	URL           string        `json:"url"`           // 主题URL
+	Preview       string        `json:"preview"`       // 预览图片相对路径
+	Configuration Configuration `json:"configuration"` // 声明配置项
+}
+
+type Configuration struct {
+	Type string `json:"type"` // managed
+	Icon string `json:"icon"` // 图标
+	Name string `json:"name"`
+	Data any    `json:"data"` // 配置数据
+}
+
+type ManagedThemeConfigurationItem struct {
+	Key      string `json:"key"`
+	Name     string `json:"name"`
+	Required bool   `json:"required"`
+	Type     string `json:"type"` // string number select switch title
+	Options  string `json:"options"`
+	Default  any    `json:"default"`
+	Help     string `json:"help"`
+}
+
+type ThemeConfiguration struct {
+	Short string `json:"short" gorm:"primaryKey;unique;not null"`
+	Data  string `json:"data" gorm:"type:longtext" default:"{}"`
 }

database/tasks/tasks.go

@@ -83,7 +83,7 @@ func DeleteTaskByTaskId(taskId string) error {
 	return dbcore.GetDBInstance().Where("task_id = ?", taskId).Delete(&models.Task{}).Error
 }
 
-func SaveTaskResult(taskId, clientId, result string, exitCode int, timestamp time.Time) error {
+func SaveTaskResult(taskId, clientId, result string, exitCode int, timestamp models.LocalTime) error {
 	return dbcore.GetDBInstance().
 		Model(&models.TaskResult{}).
 		Where("task_id = ? AND client = ?", taskId, clientId).

install-komari.sh

@@ -26,7 +26,7 @@ log_step() {
 
 # Global variables
 INSTALL_DIR="/opt/komari"
-DATA_DIR="/opt/komari/data"
+DATA_DIR="/opt/komari"
 SERVICE_NAME="komari"
 BINARY_PATH="$INSTALL_DIR/komari"
 DEFAULT_PORT="25774"

utils/gin.go

@@ -0,0 +1,31 @@
+package utils
+
+import "github.com/gin-gonic/gin"
+
+// https://github.com/labstack/echo/blob/98ca08e7dd64075b858e758d6693bf9799340756/context.go#L275-L294
+func GetScheme(c *gin.Context) string {
+	// Can't use `r.Request.URL.Scheme`
+	// See: https://groups.google.com/forum/#!topic/golang-nuts/pMUkBlQBDF0
+	if c.Request.TLS != nil {
+		return "https"
+	}
+	if scheme := c.Request.Header.Get("X-Forwarded-Proto"); scheme != "" {
+		return scheme
+	}
+	if scheme := c.Request.Header.Get("X-Forwarded-Protocol"); scheme != "" {
+		return scheme
+	}
+	if ssl := c.Request.Header.Get("X-Forwarded-Ssl"); ssl == "on" {
+		return "https"
+	}
+	if scheme := c.Request.Header.Get("X-Url-Scheme"); scheme != "" {
+		return scheme
+	}
+	return "http"
+}
+
+func GetCallbackURL(c *gin.Context) string {
+	scheme := GetScheme(c)
+	host := c.Request.Host
+	return scheme + "://" + host + "/api/oauth_callback"
+}

utils/item/item.go

@@ -20,10 +20,14 @@ func Parse(v any) []Item {
 	var items []Item
 	for i := 0; i < val.NumField(); i++ {
 		field := val.Type().Field(i)
+		typ := field.Tag.Get("type")
+		if typ != "option" {
+			typ = field.Type.Name()
+		}
 		item := Item{
 			Name:     field.Tag.Get("json"),
 			Required: field.Tag.Get("required") == "true",
-			Type:     field.Type.Name(),
+			Type:     typ,
 			Options:  field.Tag.Get("options"),
 			Default:  field.Tag.Get("default"),
 			Help:     field.Tag.Get("help"),

utils/messageSender/all.go

@@ -1,9 +1,11 @@
 package messageSender
 
 import (
+	_ "github.com/komari-monitor/komari/utils/messageSender/bark"
 	_ "github.com/komari-monitor/komari/utils/messageSender/email"
 	_ "github.com/komari-monitor/komari/utils/messageSender/empty"
 	_ "github.com/komari-monitor/komari/utils/messageSender/telegram"
+	_ "github.com/komari-monitor/komari/utils/messageSender/webhook"
 )
 
 func All() {

utils/messageSender/bark/bark.go

@@ -0,0 +1,124 @@
+package bark
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strings"
+
+	"github.com/komari-monitor/komari/utils/messageSender/factory"
+)
+
+type BarkSender struct {
+	Addition
+}
+
+func (b *BarkSender) GetName() string {
+	return "bark"
+}
+
+func (b *BarkSender) GetConfiguration() factory.Configuration {
+	return &b.Addition
+}
+
+func (b *BarkSender) Init() error {
+	// 验证 ServerURL 格式
+	if b.Addition.ServerURL != "" {
+		if _, err := url.Parse(b.Addition.ServerURL); err != nil {
+			return fmt.Errorf("invalid server URL: %v", err)
+		}
+	}
+	return nil
+}
+
+func (b *BarkSender) Destroy() error {
+	return nil
+}
+
+func (b *BarkSender) SendTextMessage(message, title string) error {
+	if b.Addition.DeviceKey == "" {
+		return fmt.Errorf("device key is required")
+	}
+
+	if message == "" {
+		return fmt.Errorf("message is empty")
+	}
+
+	// 准备请求数据
+	payload := map[string]interface{}{
+		"body":       message,
+		"device_key": b.Addition.DeviceKey,
+	}
+
+	// 如果有标题，添加标题
+	if title != "" {
+		payload["title"] = title
+	}
+
+	// 添加可选参数
+	if b.Addition.Icon != "" {
+		payload["icon"] = b.Addition.Icon
+	}
+
+	if b.Addition.Level != "" {
+		payload["level"] = b.Addition.Level
+	}
+
+	// 序列化 JSON
+	jsonData, err := json.Marshal(payload)
+	if err != nil {
+		return fmt.Errorf("failed to marshal payload: %v", err)
+	}
+
+	// 构建请求 URL
+	serverURL := b.Addition.ServerURL
+	if serverURL == "" {
+		serverURL = "https://api.day.app"
+	}
+	
+	// 确保 URL 以正确的格式结尾
+	serverURL = strings.TrimRight(serverURL, "/")
+	requestURL := fmt.Sprintf("%s/push", serverURL)
+
+	// 发送 HTTP POST 请求
+	resp, err := http.Post(requestURL, "application/json", bytes.NewBuffer(jsonData))
+	if err != nil {
+		return fmt.Errorf("failed to send request: %v", err)
+	}
+	defer resp.Body.Close()
+
+	// 检查响应状态
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("bark API returned non-OK status: %d", resp.StatusCode)
+	}
+
+	// 解析响应
+	var result struct {
+		Code    int    `json:"code"`
+		Message string `json:"message"`
+		Data    interface{} `json:"data"`
+	}
+
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		// 如果解析失败，认为发送成功（某些 Bark 服务器可能返回纯文本）
+		return nil
+	}
+
+	// 检查 Bark API 响应
+	if result.Code != 200 {
+		return fmt.Errorf("bark API error (code: %d): %s", result.Code, result.Message)
+	}
+
+	return nil
+}
+
+func init() {
+	factory.RegisterMessageSender(func() factory.IMessageSender {
+		return &BarkSender{}
+	})
+}
+
+// 确保实现了 IMessageSender 接口
+var _ factory.IMessageSender = (*BarkSender)(nil)

utils/messageSender/bark/meta.go

@@ -0,0 +1,18 @@
+package bark
+
+import (
+	"github.com/komari-monitor/komari/utils/messageSender/factory"
+)
+
+type Addition struct {
+	ServerURL string `json:"server_url" required:"true" default:"https://api.day.app" help:"Bark server URL, e.g., https://api.day.app or your self-hosted server address"`
+	DeviceKey string `json:"device_key" required:"true" help:"Your Bark device key, which can be found in the Bark App"`
+	Icon      string `json:"icon" help:"Push notification icon, supports URL or system icon name"`
+	Level     string `json:"level" type:"option" default:"timeSensitive" options:"active,timeSensitive,passive,critical" help:"Push notification level: active, timeSensitive (default), passive, critical"`
+}
+
+func init() {
+	factory.RegisterMessageSender(func() factory.IMessageSender {
+		return &BarkSender{}
+	})
+}

utils/messageSender/webhook/meta.go

@@ -0,0 +1,21 @@
+package webhook
+
+import (
+	"github.com/komari-monitor/komari/utils/messageSender/factory"
+)
+
+type Addition struct {
+	URL         string `json:"url" required:"true"`
+	Method      string `json:"method" default:"GET" type:"option" options:"POST,GET"`
+	ContentType string `json:"content_type" default:"application/json"`
+	Headers     string `json:"headers" help:"HTTP headers in JSON format"`
+	Body        string `json:"body" default:"{\"message\":\"{{message}}\",\"title\":\"{{title}}\"}"` // 默认使用message和title字段
+	Username    string `json:"username"`
+	Password    string `json:"password"`
+}
+
+func init() {
+	factory.RegisterMessageSender(func() factory.IMessageSender {
+		return &WebhookSender{}
+	})
+}

utils/messageSender/webhook/webhook.go

@@ -0,0 +1,134 @@
+package webhook
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+
+	"github.com/komari-monitor/komari/utils/messageSender/factory"
+)
+
+type WebhookSender struct {
+	Addition
+}
+
+func (w *WebhookSender) GetName() string {
+	return "webhook"
+}
+
+func (w *WebhookSender) GetConfiguration() factory.Configuration {
+	return &w.Addition
+}
+
+func (w *WebhookSender) Init() error {
+	return nil
+}
+
+func (w *WebhookSender) Destroy() error {
+	return nil
+}
+
+func (w *WebhookSender) SendTextMessage(message, title string) error {
+	if w.Addition.URL == "" {
+		return fmt.Errorf("webhook URL is not configured")
+	}
+
+	method := strings.ToUpper(w.Addition.Method)
+	if method == "" {
+		method = "GET" // 默认使用 GET
+	}
+
+	client := &http.Client{
+		Timeout: 30 * time.Second, // 固定30秒超时
+	}
+
+	var req *http.Request
+	var err error
+
+	switch method {
+	case "POST":
+		req, err = w.createPOSTRequest(message, title)
+	case "GET":
+		req, err = w.createGETRequest(message, title)
+	default:
+		return fmt.Errorf("unsupported HTTP method: %s", method)
+	}
+
+	if err != nil {
+		return fmt.Errorf("failed to create request: %v", err)
+	}
+
+	// 解析并设置自定义头部
+	if w.Addition.Headers != "" {
+		var headers map[string]string
+		if err := json.Unmarshal([]byte(w.Addition.Headers), &headers); err == nil {
+			for key, value := range headers {
+				req.Header.Set(key, value)
+			}
+		}
+	}
+
+	// 设置基本认证
+	if w.Addition.Username != "" && w.Addition.Password != "" {
+		req.SetBasicAuth(w.Addition.Username, w.Addition.Password)
+	}
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return fmt.Errorf("failed to send webhook request: %v", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		body, _ := io.ReadAll(resp.Body)
+		return fmt.Errorf("webhook request failed with status %d: %s", resp.StatusCode, string(body))
+	}
+
+	return nil
+}
+
+func (w *WebhookSender) createPOSTRequest(message, title string) (*http.Request, error) {
+	// 替换模板中的占位符
+	body := w.replaceTemplate(w.Addition.Body, message, title)
+
+	contentType := w.Addition.ContentType
+	if contentType == "" {
+		contentType = "application/json"
+	}
+
+	req, err := http.NewRequest("POST", w.Addition.URL, bytes.NewBufferString(body))
+	if err != nil {
+		return nil, err
+	}
+
+	req.Header.Set("Content-Type", contentType)
+	return req, nil
+}
+
+func (w *WebhookSender) createGETRequest(message, title string) (*http.Request, error) {
+	URL := w.replaceTemplate(w.Addition.URL, message, title)
+	u, err := url.Parse(URL)
+	if err != nil {
+		return nil, fmt.Errorf("invalid URL: %v", err)
+	}
+
+	req, err := http.NewRequest("GET", u.String(), nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return req, nil
+}
+
+// replaceTemplate 替换模板中的 {{message}} 和 {{title}} 占位符
+func (w *WebhookSender) replaceTemplate(template, message, title string) string {
+	result := template
+	result = strings.ReplaceAll(result, "{{message}}", message)
+	result = strings.ReplaceAll(result, "{{title}}", title)
+	return result
+}

utils/notifier/offline.go

@@ -20,6 +20,8 @@ type notificationState struct {
 	mu                  sync.Mutex // 互斥锁，保护该客户端状态
 	pendingOfflineSince time.Time  // 客户端离线的时间。为零值表示客户端在线或已发送离线通知。
 	isFirstConnection   bool       // 标记是否为首次上线连接。
+	isConnExist         bool       // 标记是否存在连接
+	connectionID        int64      // 连接ID，用于区分不同的连接会话，防止竞态条件
 }
 
 // clientStates 使用 sync.Map 实现对客户端状态的并发访问。
@@ -52,7 +54,7 @@ func getOrInitState(clientID string) *notificationState {
 }
 
 // OfflineNotification 在启用通知且未在宽限期内发送的情况下，发送客户端离线通知。
-func OfflineNotification(clientID string) {
+func OfflineNotification(clientID string, endedConnectionID int64) {
 	client, err := clients.GetClientByUUID(clientID)
 	if err != nil {
 		return
@@ -73,7 +75,8 @@ func OfflineNotification(clientID string) {
 
 	state.mu.Lock()
 	// 如果已处于待通知状态，则不做处理。
-	if !state.pendingOfflineSince.IsZero() {
+	// 只有当离线事件来自当前的连接会话时，我们才认为它有效。
+	if !state.pendingOfflineSince.IsZero() || state.connectionID != endedConnectionID {
 		state.mu.Unlock()
 		return
 	}
@@ -82,7 +85,7 @@ func OfflineNotification(clientID string) {
 	state.mu.Unlock()
 
 	// 新建协程，等待宽限期后判断是否需要发送通知。
-	go func(startTime time.Time) {
+	go func(startTime time.Time, expectedConnectionID int64) {
 		time.Sleep(gracePeriod)
 
 		state.mu.Lock()
@@ -90,13 +93,16 @@ func OfflineNotification(clientID string) {
 
 		// 检查离线状态是否仍为本次协程启动时的状态。
 		// 若为零值，说明客户端已重连。
-		// 若时间不同，说明客户端重连后又断开，已启动新计时。
-		if state.pendingOfflineSince.IsZero() || !state.pendingOfflineSince.Equal(startTime) {
+		// 当前的 connectionID 是否还是我们触发离线时的那个ID。如果不是，说明客户端重连过，本次离线通知已失效。
+		if state.pendingOfflineSince.IsZero() || state.connectionID != expectedConnectionID {
+			log.Println("%s is reconnected new connID: %d, old connID: %d", clientID, state.connectionID, expectedConnectionID)
 			return
 		}
 
 		// 即将发送通知，重置待通知状态。
+		// 需要多一个boolean 是因为pendingOfflineSince在offline睡眠后才修改，可能导致online判断不对
 		state.pendingOfflineSince = time.Time{}
+		state.isConnExist = false
 
 		// Send notification
 		message := fmt.Sprintf("🔴%s is offline", client.Name)
@@ -111,11 +117,11 @@ func OfflineNotification(clientID string) {
 		if err := db.Model(&models.OfflineNotification{}).Where("client = ?", clientID).Update("last_notified", now).Error; err != nil {
 			log.Printf("Failed to update last_notified for client %s: %v", clientID, err)
 		}
-	}(now)
+	}(now, endedConnectionID)
 }
 
 // OnlineNotification 在启用通知的情况下，发送客户端上线通知。
-func OnlineNotification(clientID string) {
+func OnlineNotification(clientID string, connectionID int64) {
 	client, err := clients.GetClientByUUID(clientID)
 	if err != nil {
 		return
@@ -131,12 +137,14 @@ func OnlineNotification(clientID string) {
 
 	state.mu.Lock()
 	defer state.mu.Unlock()
+	state.connectionID = connectionID
 
 	// 规则1：首次连接不通知。
 	if state.isFirstConnection {
 		state.isFirstConnection = false
 		// 同时清除任何待离线状态（如服务器重启时客户端本已离线）
 		state.pendingOfflineSince = time.Time{}
+		state.isConnExist = true
 		return
 	}
 
@@ -145,12 +153,21 @@ func OnlineNotification(clientID string) {
 	// 上线时总是清除待离线状态。
 	state.pendingOfflineSince = time.Time{}
 
-	// 规则4：宽限期内重连，不通知。
+	// 规则2：宽限期内重连，不通知。
 	if wasPending {
 		return
 	}
 
-	// 规则3：客户端离线足够久已通知（或未待离线），现在重新上线，发送上线通知。
+	// 规则3: 没断开后重连, 不通知
+	// 为了解决OfflineNotify中不是全程加锁
+	if state.isConnExist {
+		log.Println("%s has connection exist: %d", clientID, connectionID)
+		return
+	} else {
+		state.isConnExist = true
+	}
+
+	// 规则4：客户端离线足够久已通知（或未待离线），现在重新上线，发送上线通知。
 	message := fmt.Sprintf("🟢%s is online", client.Name)
 	go func(msg string) {
 		if err := messageSender.SendTextMessage(msg, "Komari Online Notification"); err != nil {

utils/notifier/traffic.go

@@ -0,0 +1,137 @@
+package notifier
+
+import (
+	"fmt"
+	"math"
+	"strings"
+	"time"
+
+	"github.com/komari-monitor/komari/database/clients"
+	"github.com/komari-monitor/komari/database/config"
+	"github.com/komari-monitor/komari/utils/messageSender"
+	"github.com/komari-monitor/komari/ws"
+	cache "github.com/patrickmn/go-cache"
+)
+
+// trafficCache 用于记录每个客户端已触发的阈值步进，避免重复提醒
+// key: "traffic:"+clientUUID, value: int 步进百分比（例如 80, 85, 90 ... 100）
+var trafficCache = cache.New(30*24*time.Hour, time.Hour) // 30天缓存，1小时清理
+
+// CheckTraffic 检查各客户端流量使用情况，并在达到阈值和每+5%时提醒一次；100%时额外提醒一次
+// 由外部协程每分钟调用一次
+func CheckTraffic() {
+	// 获取最新上报与客户端配置
+	reports := ws.GetLatestReport()
+	if len(reports) == 0 {
+		return
+	}
+
+	cfg, err := config.Get()
+	if err != nil {
+		return
+	}
+
+	if cfg.TrafficLimitPercentage <= 0 {
+		return
+	}
+
+	// 起始阈值：例如 80%，非5的倍数则从上取整到最近的5的倍数，例如 83->85
+	startThreshold := cfg.TrafficLimitPercentage
+	if startThreshold < 0 {
+		startThreshold = 0
+	}
+	baseStep := int(math.Ceil(startThreshold/5.0) * 5.0)
+	if baseStep > 100 {
+		baseStep = 100
+	}
+
+	allClients, err := clients.GetAllClientBasicInfo()
+	if err != nil {
+		return
+	}
+
+	for _, c := range allClients {
+		if c.TrafficLimit <= 0 {
+			continue
+		}
+
+		r, ok := reports[c.UUID]
+		if !ok || r == nil {
+			continue
+		}
+
+		// 计算不同类型的使用值
+		used := computeUsedByType(strings.ToLower(c.TrafficLimitType), r.Network.TotalUp, r.Network.TotalDown)
+		if used <= 0 {
+			continue
+		}
+
+		pct := float64(used) / float64(c.TrafficLimit) * 100.0
+		if pct < startThreshold {
+			continue
+		}
+
+		// 当前所在阈值步进（5%的倍数）
+		curStep := int(math.Floor(pct/5.0) * 5.0)
+		if curStep < baseStep {
+			curStep = baseStep
+		}
+		// if curStep > 100 {
+		// 	curStep = 100
+		// }
+
+		key := "traffic:" + c.UUID
+		last, _ := trafficCache.Get(key)
+		lastStep, _ := last.(int)
+
+		if curStep > lastStep { // 只在进入新步进时提醒一次
+			trafficCache.SetDefault(key, curStep)
+
+			title := "Komari Traffic Alert"
+			msg := fmt.Sprintf("%s traffic used %d%% (%s / %s), type=%s", c.Name, curStep, humanBytes(used), humanBytes(c.TrafficLimit), strings.ToLower(c.TrafficLimitType))
+			// 发送通知（内部会检查 NotificationEnabled）
+			_ = messageSender.SendTextMessage(msg, title)
+		}
+	}
+}
+
+func computeUsedByType(t string, up, down int64) int64 {
+	switch t {
+	case "up":
+		return up
+	case "down":
+		return down
+	case "sum":
+		return up + down
+	case "min":
+		if up < down {
+			return up
+		}
+		return down
+	case "max":
+		fallthrough
+	default:
+		if up > down {
+			return up
+		}
+		return down
+	}
+}
+
+func humanBytes(b int64) string {
+	const unit = 1024
+	if b < unit {
+		return fmt.Sprintf("%d B", b)
+	}
+	div, exp := int64(unit), 0
+	for n := b / unit; n >= unit; n /= unit {
+		div *= unit
+		exp++
+	}
+	// KMGTPE
+	prefixes := []string{"K", "M", "G", "T", "P", "E"}
+	if exp >= len(prefixes) {
+		exp = len(prefixes) - 1
+	}
+	return fmt.Sprintf("%.2f %sB", float64(b)/float64(div), prefixes[exp])
+}

utils/oauth/all.go

@@ -4,8 +4,9 @@ import (
 	_ "github.com/komari-monitor/komari/utils/oauth/factory"
 	_ "github.com/komari-monitor/komari/utils/oauth/generic"
 	_ "github.com/komari-monitor/komari/utils/oauth/github"
+	_ "github.com/komari-monitor/komari/utils/oauth/qq"
 )
 
 func All() {
 	//empty function to ensure all OIDC providers are registered
-}
+}

utils/oauth/factory/meta.go

@@ -7,8 +7,8 @@ type IOidcProvider interface {
 	// 请务必返回 &Configuration{} 的指针
 	GetConfiguration() Configuration
 	// 获取授权URL和状态
-	GetAuthorizationURL() (string, string)
-	OnCallback(ctx context.Context, state string, query map[string]string) (OidcCallback, error)
+	GetAuthorizationURL(redirectURI string) (string, string)
+	OnCallback(ctx context.Context, state string, query map[string]string, callbackURI string) (OidcCallback, error)
 	Init() error
 	Destroy() error
 }

utils/oauth/generic/generic.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"net/http"
 	"net/url"
+	"strings"
 	"time"
 
 	"github.com/komari-monitor/komari/utils"
@@ -20,21 +21,22 @@ func (g *Generic) GetConfiguration() factory.Configuration {
 	return &g.Addition
 }
 
-func (g *Generic) GetAuthorizationURL() (string, string) {
+func (g *Generic) GetAuthorizationURL(redirectURI string) (string, string) {
 	state := utils.GenerateRandomString(16)
 
 	// 构建GitHub OAuth授权URL
 	authURL := fmt.Sprintf(
-		"%s?client_id=%s&state=%s&scope=%s&response_type=code",
+		"%s?client_id=%s&state=%s&scope=%s&redirect_uri=%s&response_type=code",
 		g.Addition.AuthURL,
 		url.QueryEscape(g.Addition.ClientId),
 		url.QueryEscape(state),
 		url.QueryEscape(g.Addition.Scope),
+		url.QueryEscape(redirectURI),
 	)
 	g.stateCache.Set(state, true, cache.DefaultExpiration)
 	return authURL, state
 }
-func (g *Generic) OnCallback(ctx context.Context, state string, query map[string]string) (factory.OidcCallback, error) {
+func (g *Generic) OnCallback(ctx context.Context, state string, query map[string]string, callbackURI string) (factory.OidcCallback, error) {
 	code := query["code"]
 
 	// 验证state防止CSRF攻击
@@ -58,12 +60,13 @@ func (g *Generic) OnCallback(ctx context.Context, state string, query map[string
 		"client_id":     {g.Addition.ClientId},
 		"client_secret": {g.Addition.ClientSecret},
 		"code":          {code},
+		"redirect_uri":  {callbackURI},
 		"grant_type":    {"authorization_code"},
 	}
 
-	req, _ := http.NewRequest("POST", g.Addition.TokenURL, nil)
-	req.URL.RawQuery = data.Encode()
+	req, _ := http.NewRequest("POST", g.Addition.TokenURL, strings.NewReader(data.Encode()))
 	req.Header.Set("Accept", "application/json")
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
 
 	resp, err := http.DefaultClient.Do(req)
 	if err != nil {

utils/oauth/github/github.go

@@ -24,7 +24,7 @@ func (g *Github) GetConfiguration() factory.Configuration {
 	return &g.Addition
 }
 
-func (g *Github) GetAuthorizationURL() (string, string) {
+func (g *Github) GetAuthorizationURL(_ string) (string, string) {
 	state := utils.GenerateRandomString(16)
 
 	// 构建GitHub OAuth授权URL
@@ -36,7 +36,7 @@ func (g *Github) GetAuthorizationURL() (string, string) {
 	g.stateCache.Set(state, true, cache.NoExpiration)
 	return authURL, state
 }
-func (g *Github) OnCallback(ctx context.Context, state string, query map[string]string) (factory.OidcCallback, error) {
+func (g *Github) OnCallback(ctx context.Context, state string, query map[string]string, _ string) (factory.OidcCallback, error) {
 	code := query["code"]
 
 	// 验证state防止CSRF攻击

utils/oauth/oauth.go

@@ -27,9 +27,6 @@ func CurrentProvider() factory.IOidcProvider {
 func LoadProvider(name string, configJson string) error {
 	mu.Lock()
 	defer mu.Unlock()
-	if currentProvider != nil && currentProvider.GetName() == name {
-		return nil // 已经加载了相同的提供程序
-	}
 	if currentProvider != nil {
 		if err := currentProvider.Destroy(); err != nil {
 			log.Printf("Failed to destroy provider %s: %v", currentProvider.GetName(), err)

utils/oauth/qq/meta.go

@@ -0,0 +1,24 @@
+package qq
+
+import (
+	"github.com/komari-monitor/komari/utils/oauth/factory"
+	"github.com/patrickmn/go-cache"
+)
+
+func init() {
+	factory.RegisterOidcProvider(func() factory.IOidcProvider {
+		return &QQ{}
+	})
+}
+
+type QQ struct {
+	Addition
+	stateCache *cache.Cache // 用于存储state和用户信息的映射
+}
+
+type Addition struct {
+	AggregationURL string `json:"aggregation_url" required:"true" default:"https://login.qjqq.cn"` // 聚合登录地址
+	AppId          string `json:"app_id" required:"true"`
+	AppKey         string `json:"app_key" required:"true"`
+	LoginType      string `json:"login_type" required:"true"` // 登录方式，如qq, google等
+}

utils/oauth/qq/qq.go

@@ -0,0 +1,171 @@
+package qq
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"time"
+
+	"github.com/komari-monitor/komari/utils"
+	"github.com/komari-monitor/komari/utils/oauth/factory"
+	"github.com/patrickmn/go-cache"
+)
+
+func (q *QQ) GetName() string {
+	return "qq"
+}
+
+func (q *QQ) GetConfiguration() factory.Configuration {
+	return &q.Addition
+}
+
+func (q *QQ) GetAuthorizationURL(redirectURI string) (string, string) {
+	state := utils.GenerateRandomString(16)
+
+	// 构建请求QQ聚合登录平台的URL
+	requestURL := fmt.Sprintf(
+		"%s/connect.php?act=login&appid=%s&appkey=%s&type=%s&redirect_uri=%s",
+		q.Addition.AggregationURL,
+		url.QueryEscape(q.Addition.AppId),
+		url.QueryEscape(q.Addition.AppKey),
+		url.QueryEscape(q.Addition.LoginType),
+		url.QueryEscape(redirectURI),
+	)
+
+	// 向聚合登录平台发送请求
+	resp, err := http.Get(requestURL)
+	if err != nil {
+		// 如果请求失败，返回错误信息
+		return "", state
+	}
+	defer resp.Body.Close()
+
+	// 读取响应内容
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", state
+	}
+
+	// 解析响应JSON
+	var result struct {
+		Code int    `json:"code"`
+		Msg  string `json:"msg"`
+		URL  string `json:"url"`
+	}
+
+	if err := json.Unmarshal(body, &result); err != nil {
+		return "", state
+	}
+
+	// 检查响应状态
+	if result.Code != 0 {
+		return "", state
+	}
+
+	q.stateCache.Set(state, true, cache.DefaultExpiration)
+	return result.URL, state
+}
+
+// OnCallback 处理QQ OAuth回调
+// 例如：http://localhost:25774/api/oauth_callback?type=qq&code=XXXXXXXXXXXXXXXX
+// 然后我们使用code参数向聚合登录平台请求用户信息
+func (q *QQ) OnCallback(ctx context.Context, state string, query map[string]string, callbackURI string) (factory.OidcCallback, error) {
+	// 根据文档，回调地址会附带type和code参数
+	code := query["code"]
+	loginType := query["type"]
+
+	// 如果回调中没有type参数，则使用配置中的LoginType
+	if loginType == "" {
+		loginType = q.Addition.LoginType
+	}
+
+	// 验证state防止CSRF攻击
+	if q.stateCache == nil {
+		return factory.OidcCallback{}, fmt.Errorf("state cache not initialized")
+	}
+	if _, ok := q.stateCache.Get(state); !ok {
+		return factory.OidcCallback{}, fmt.Errorf("invalid state")
+	}
+	if state == "" {
+		return factory.OidcCallback{}, fmt.Errorf("invalid state")
+	}
+
+	// 检查是否提供了Authorization Code
+	if code == "" {
+		return factory.OidcCallback{}, fmt.Errorf("no authorization code provided")
+	}
+
+	// 通过Authorization Code获取用户信息
+	// 根据文档，请求URL应为: {AggregationURL}/connect.php?act=callback&appid={appid}&appkey={appkey}&type={登录方式}&code={code}
+	callbackURL := fmt.Sprintf(
+		"%s/connect.php?act=callback&appid=%s&appkey=%s&type=%s&code=%s",
+		q.Addition.AggregationURL,
+		url.QueryEscape(q.Addition.AppId),
+		url.QueryEscape(q.Addition.AppKey),
+		url.QueryEscape(loginType),
+		url.QueryEscape(code),
+	)
+
+	resp, err := http.Get(callbackURL)
+	if err != nil {
+		return factory.OidcCallback{}, fmt.Errorf("failed to get user info: %v", err)
+	}
+	defer resp.Body.Close()
+
+	// 检查HTTP响应状态
+	if resp.StatusCode != http.StatusOK {
+		return factory.OidcCallback{}, fmt.Errorf("HTTP request failed with status code: %d", resp.StatusCode)
+	}
+
+	// 读取响应
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return factory.OidcCallback{}, fmt.Errorf("failed to read response: %v", err)
+	}
+
+	// 解析响应
+	var result struct {
+		Code        int    `json:"code"`
+		Msg         string `json:"msg"`
+		Type        string `json:"type"`
+		SocialUid   string `json:"social_uid"`
+		AccessToken string `json:"access_token"`
+		FaceImg     string `json:"faceimg"`
+		Nickname    string `json:"nickname"`
+		Gender      string `json:"gender"`
+		Location    string `json:"location"`
+		IP          string `json:"ip"`
+	}
+
+	if err := json.Unmarshal(body, &result); err != nil {
+		return factory.OidcCallback{}, fmt.Errorf("failed to parse callback response: %v, response body: %s", err, string(body))
+	}
+
+	// 检查返回状态码
+	if result.Code != 0 {
+		return factory.OidcCallback{}, fmt.Errorf("QQ login callback failed with code %d: %s", result.Code, result.Msg)
+	}
+
+	// 检查是否返回了用户唯一标识
+	if result.SocialUid == "" {
+		return factory.OidcCallback{}, fmt.Errorf("empty social_uid returned, full response: %s", string(body))
+	}
+
+	// 返回用户唯一标识
+	return factory.OidcCallback{UserId: result.SocialUid}, nil
+}
+
+func (q *QQ) Init() error {
+	q.stateCache = cache.New(time.Minute*5, time.Minute*10)
+	return nil
+}
+
+func (q *QQ) Destroy() error {
+	q.stateCache.Flush()
+	return nil
+}
+
+var _ factory.IOidcProvider = (*QQ)(nil)

utils/pingSchedule.go

@@ -1,6 +1,7 @@
 package utils
 
 import (
+	"context"
 	"sync"
 	"time"
 
@@ -10,16 +11,13 @@ import (
 
 // PingTaskManager 管理定时器和任务
 type PingTaskManager struct {
-	mu       sync.Mutex
-	tickers  map[int]*time.Ticker
-	tasks    map[int][]models.PingTask
-	stopChan chan struct{}
+	mu         sync.Mutex
+	cancelFunc context.CancelFunc
+	tasks      map[int][]models.PingTask
 }
 
 var manager = &PingTaskManager{
-	tickers:  make(map[int]*time.Ticker),
-	tasks:    make(map[int][]models.PingTask),
-	stopChan: make(chan struct{}),
+	tasks: make(map[int][]models.PingTask),
 }
 
 // Reload 重载时间表
@@ -27,60 +25,81 @@ func (m *PingTaskManager) Reload(pingTasks []models.PingTask) error {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 
-	// 停止所有现有定时器
-	for _, ticker := range m.tickers {
-		ticker.Stop()
+	if m.cancelFunc != nil {
+		m.cancelFunc()
 	}
-	m.tickers = make(map[int]*time.Ticker)
+	ctx, cancel := context.WithCancel(context.Background())
+	m.cancelFunc = cancel
+
 	m.tasks = make(map[int][]models.PingTask)
 
 	// 按Interval分组任务
 	taskGroups := make(map[int][]models.PingTask)
 	for _, task := range pingTasks {
+		if task.Interval <= 0 {
+			continue
+		}
 		taskGroups[task.Interval] = append(taskGroups[task.Interval], task)
 	}
 
-	// 为每个唯一的Interval创建定时器
+	// 为每个唯一的Interval创建协程
 	for interval, tasks := range taskGroups {
-		ticker := time.NewTicker(time.Duration(interval) * time.Second)
-		m.tickers[interval] = ticker
 		m.tasks[interval] = tasks
-
-		go func(ticker *time.Ticker, tasks []models.PingTask) {
-			for {
-				select {
-				case <-ticker.C:
-					for _, task := range tasks {
-						go executePingTask(task)
-					}
-				case <-m.stopChan:
-					return
-				}
-			}
-		}(ticker, tasks)
+		go m.runPreciseLoop(ctx, time.Duration(interval)*time.Second, tasks)
 	}
-
 	return nil
 }
 
+func (m *PingTaskManager) runPreciseLoop(ctx context.Context, interval time.Duration, tasks []models.PingTask) {
+	// Start the first timer.
+	timer := time.NewTimer(interval)
+
+	// This will be the reference point for all future ticks.
+	// By adding the interval to this time, we avoid accumulating execution delays.
+	nextTick := time.Now().Add(interval)
+	defer timer.Stop()
+
+	for {
+		select {
+		case <-timer.C:
+			onlineClients := ws.GetConnectedClients()
+			for _, task := range tasks {
+				go executePingTask(ctx, task, onlineClients)
+			}
+
+			nextTick = nextTick.Add(interval)
+			timer.Reset(time.Until(nextTick))
+
+		case <-ctx.Done():
+			return
+		}
+	}
+}
+
 // executePingTask 执行单个PingTask
-func executePingTask(task models.PingTask) {
-	clients := ws.GetConnectedClients()
+func executePingTask(ctx context.Context, task models.PingTask, onlineClients map[string]*ws.SafeConn) {
 	var message struct {
 		TaskID  uint   `json:"ping_task_id"`
 		Message string `json:"message"`
 		Type    string `json:"ping_type"`
 		Target  string `json:"ping_target"`
 	}
+
+	message.Message = "ping"
+	message.TaskID = task.Id
+	message.Type = task.Type
+	message.Target = task.Target
+
 	for _, clientUUID := range task.Clients {
-		if conn, exists := clients[clientUUID]; exists {
-			if conn == nil {
-				continue
-			}
-			message.Message = "ping"
-			message.TaskID = task.Id
-			message.Type = task.Type
-			message.Target = task.Target
+		select {
+		case <-ctx.Done():
+			// Context was canceled, stop sending pings.
+			return
+		default:
+			// Context is still active, continue.
+		}
+
+		if conn, exists := onlineClients[clientUUID]; exists && conn != nil {
 			if err := conn.WriteJSON(message); err != nil {
 				continue
 			}

ws/clients.go

@@ -1,69 +0,0 @@
-package ws
-
-import (
-	"net/http"
-
-	"github.com/gorilla/websocket"
-	"github.com/komari-monitor/komari/common"
-
-	"github.com/gin-gonic/gin"
-)
-
-func GetClients(c *gin.Context) {
-	// 升级到ws
-	if !websocket.IsWebSocketUpgrade(c.Request) {
-		c.JSON(http.StatusBadRequest, gin.H{"status": "error", "error": "Require WebSocket upgrade"})
-		return
-	}
-	upgrader := websocket.Upgrader{
-		CheckOrigin: func(r *http.Request) bool {
-			return true
-		},
-	}
-	// Upgrade the HTTP connection to a WebSocket connection
-	conn, err := upgrader.Upgrade(c.Writer, c.Request, nil)
-	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"status": "error", "error": "Failed to upgrade to WebSocket"})
-		return
-	}
-	defer conn.Close()
-
-	// 请求
-	for {
-		var resp struct {
-			Online []string                  `json:"online"` // 已建立连接的客户端uuid列表
-			Data   map[string]*common.Report `json:"data"`   // 最后上报的数据
-		}
-		resp.Online = []string{}
-		_, data, err := conn.ReadMessage()
-		if err != nil {
-			//log.Println("Error reading message:", err)
-			return
-		}
-		message := string(data)
-
-		if message != "get" {
-			conn.WriteJSON(gin.H{"status": "error", "error": "Invalid message"})
-			continue
-		}
-		// 已建立连接的客户端uuid列表
-		for key := range GetConnectedClients() {
-			resp.Online = append(resp.Online, key)
-		}
-		// 清除UUID，简化报告单
-		resp.Data = GetLatestReport()
-		for _, report := range resp.Data {
-			report.UUID = ""
-		}
-		for _, report := range resp.Data {
-			if report.CPU.Usage == 0 {
-				report.CPU.Usage = 0.01
-			}
-		}
-		err = conn.WriteJSON(gin.H{"status": "success", "data": resp})
-		if err != nil {
-			return
-		}
-	}
-
-}

ws/existingConnection.go

@@ -29,12 +29,19 @@ func SetConnectedClients(uuid string, conn *SafeConn) {
 	defer mu.Unlock()
 	connectedClients[uuid] = conn
 }
+func DeleteClientConditionally(uuid string, connToRemove *SafeConn) {
+	mu.Lock()
+	defer mu.Unlock()
+
+	// 检查当前 map 里的 conn 是否就是要删除的这一个
+	if currentConn, exists := connectedClients[uuid]; exists && currentConn == connToRemove {
+		delete(connectedClients, uuid)
+	}
+}
 func DeleteConnectedClients(uuid string) {
 	mu.Lock()
 	defer mu.Unlock()
-	if conn, exists := connectedClients[uuid]; exists {
-		conn.Close()
-	}
+	// 只从 map 中删除，不再负责关闭连接
 	delete(connectedClients, uuid)
 }
 func GetLatestReport() map[string]*common.Report {

ws/origin.go

@@ -0,0 +1,25 @@
+package ws
+
+import (
+	"net/http"
+	"net/url"
+	"os"
+	"strings"
+)
+
+func CheckOrigin(r *http.Request) bool {
+	origin := r.Header.Get("Origin")
+	// 显式关闭校验
+	if strings.EqualFold(os.Getenv("KOMARI_WS_DISABLE_ORIGIN"), "true") {
+		return true
+	}
+	if origin == "" {
+		return false
+	}
+	host := r.Host
+	originUrl, err := url.Parse(origin)
+	if err != nil {
+		return false
+	}
+	return originUrl.Host == host
+}

ws/safeConn.go

@@ -10,12 +10,14 @@ import (
 type SafeConn struct {
 	conn *websocket.Conn
 	mu   sync.Mutex
+	ID   int64
 }
 
 func NewSafeConn(conn *websocket.Conn) *SafeConn {
 	return &SafeConn{
 		conn: conn,
 		mu:   sync.Mutex{},
+		ID:   time.Now().UnixNano(),
 	}
 }