ci/cd: 添加 GIN_MODE 环境变量以支持构建

ci/cd: 交叉编译

.github/workflows/development.yml

@@ -0,0 +1,82 @@
+name: Development Environment
+
+on:
+  push:
+    branches:
+      - dev
+  workflow_dispatch:
+
+jobs:
+  build-binaries:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4      
+      
+      #- name: Create dummy index.html
+      #  run: |
+      #    mkdir -p public/dist
+      #    echo "<html><body><h1>This is komari development server.</h1></body></html>" > public/dist/index.html
+      
+      - name: Clone and build frontend
+        run: |
+          git clone https://github.com/komari-monitor/komari-web web
+          cd web
+          npm install
+          npm run build
+          cd ..
+          mkdir -p public/dist
+          cp -r web/dist/* public/dist/
+
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: "1.23"
+
+      - name: Build application
+        env:
+          GOOS: linux
+          GOARCH: amd64
+        run: |
+          VERSION_SHA="${{ github.sha }}"
+          go build -ldflags "-X github.com/komari-monitor/komari/utils.CurrentVersion=dev -X github.com/komari-monitor/komari/utils.VersionHash=${VERSION_SHA}" -o komari .
+
+      - name: Upload binary as artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: komari
+          path: komari
+
+  deploy-to-production:
+    needs: build-binaries
+    runs-on: ubuntu-latest
+    env:
+      PRODUCTION_SERVER: ${{ vars.PRODUCTION_SERVER }}
+    if: github.ref == 'refs/heads/dev'
+
+    steps:
+      - name: Download binary
+        uses: actions/download-artifact@v4
+        with:
+          name: komari
+
+      - name: Setup SSH Key
+        uses: webfactory/ssh-agent@v0.8.0
+        with:
+          ssh-private-key: ${{ secrets.PRODUCTION_SSH_KEY }}
+
+      - name: Add host to known hosts
+        run: |
+          mkdir -p ~/.ssh
+          ssh-keyscan -H ${{ env.PRODUCTION_SERVER }} >> ~/.ssh/known_hosts
+
+      - name: Deploy to production
+        run: |
+          chmod +x komari
+          ssh root@${{ env.PRODUCTION_SERVER }} 'mkdir -p /opt/komari/'
+          ssh root@${{ env.PRODUCTION_SERVER }} 'systemctl stop komari.service || true'
+          ssh root@${{ env.PRODUCTION_SERVER }} 'rm -f /opt/komari/komari.old'
+          ssh root@${{ env.PRODUCTION_SERVER }} 'mv /opt/komari/komari /opt/komari/komari.old || true'
+          scp komari root@${{ env.PRODUCTION_SERVER }}:/opt/komari/komari
+          ssh root@${{ env.PRODUCTION_SERVER }} 'systemctl start komari.service'

.github/workflows/docker-publish.yml

@@ -3,7 +3,7 @@ name: Docker Build and Publish
 on:
   push:
     branches:
-      - dev
+      - main
   workflow_dispatch:
 
 env:
@@ -44,3 +44,6 @@ jobs:
           push: true
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}
+          build-args: |
+            VERSION=${{ github.ref_name }}
+            VERSION_HASH=${{ github.sha }}

.github/workflows/release.yml

@@ -20,6 +20,25 @@ jobs:
       matrix:
         goos: [windows, linux]
         goarch: [amd64, arm64]
+        include:
+          - goos: windows
+            goarch: amd64
+            gcc: x86_64-w64-mingw32-gcc
+            CGO_CFLAGS: ''
+            CGO_LDFLAGS: ''
+          - goos: linux
+            goarch: amd64
+            gcc: gcc
+            CGO_CFLAGS: ''
+            CGO_LDFLAGS: ''
+          - goos: linux
+            goarch: arm64
+            gcc: aarch64-linux-gnu-gcc
+            CGO_CFLAGS: '-pthread'
+            CGO_LDFLAGS: '-pthread'
+        exclude:
+          - goos: windows
+            goarch: arm64
 
     steps:
       - name: Checkout code
@@ -28,7 +47,7 @@ jobs:
       - name: Setup Node.js
         uses: actions/setup-node@v4
         with:
-          node-version: '23'
+          node-version: "23"
 
       - name: Clone and build frontend
         run: |
@@ -43,19 +62,41 @@ jobs:
       - name: Set up Go
         uses: actions/setup-go@v5
         with:
-          go-version: '1.23'
+          go-version: "1.23"
+
+      - name: Install cross-compiler
+        run: |
+          sudo apt-get update
+          if [ "${{ matrix.goarch }}" = "arm64" ] && [ "${{ matrix.goos }}" = "linux" ]; then
+            sudo apt-get install gcc-aarch64-linux-gnu
+          fi
+          if [ "${{ matrix.goarch }}" = "amd64" ] && [ "${{ matrix.goos }}" = "windows" ]; then
+            sudo apt-get install mingw-w64
+          fi
+          if [ "${{ matrix.goarch }}" = "arm64" ] && [ "${{ matrix.goos }}" = "windows" ]; then
+            sudo apt-get install wget xz-utils
+            mkdir -p /tmp/mingw64
+            wget https://github.com/mstorsjo/llvm-mingw/releases/download/20250613/llvm-mingw-20250613-ucrt-ubuntu-22.04-aarch64.tar.xz -O /tmp/mingw64.tar.xz
+            tar -xf /tmp/mingw64.tar.xz -C /tmp/mingw64 --strip-components=1
+          fi
 
       - name: Build binary
         env:
           GOOS: ${{ matrix.goos }}
           GOARCH: ${{ matrix.goarch }}
-          CGO_ENABLED: 0
+          CGO_ENABLED: 1
+          CC: ${{ matrix.gcc }}
+          CGO_CFLAGS: ${{ matrix.CGO_CFLAGS }}
+          CGO_LDFLAGS: ${{ matrix.CGO_LDFLAGS }}
+          GIN_MODE: release
         run: |
           BINARY_NAME=komari-${{ matrix.goos }}-${{ matrix.goarch }}
           if [ "${{ matrix.goos }}" = "windows" ]; then
             BINARY_NAME=${BINARY_NAME}.exe
           fi
-          go build -trimpath -ldflags="-s -w" -o $BINARY_NAME
+          VERSION="${{ github.event.release.tag_name }}"
+          VERSION_HASH="${{ github.sha }}"
+          go build -trimpath -ldflags="-s -w -X github.com/komari-monitor/komari/utils.CurrentVersion=${VERSION} -X github.com/komari-monitor/komari/utils.VersionHash=${VERSION_HASH}" -o $BINARY_NAME
 
       - name: Upload binary to release
         env:
@@ -97,4 +138,7 @@ jobs:
           context: .
           push: true
           tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}
+          labels: ${{ steps.meta.outputs.labels }}
+          build-args: |
+            VERSION=${{ github.event.release.tag_name }}
+            VERSION_HASH=${{ github.sha }}

Dockerfile

@@ -16,8 +16,10 @@ COPY . .
 COPY --from=frontend /web/dist ./public/dist
 
 ENV CGO_ENABLED=1
+ARG VERSION=unknown
+ARG VERSION_HASH=unknown
 # RUN CC=musl-gcc go build -trimpath -ldflags="-s -w -linkmode external -extldflags -static" -o komari .
-RUN go build -trimpath -ldflags="-s -w -linkmode external -extldflags -static" -o komari .
+RUN go build -trimpath -ldflags="-s -w -linkmode external -extldflags -static -X github.com/komari-monitor/komari/utils.CurrentVersion=${VERSION} -X github.com/komari-monitor/komari/utils.VersionHash=${VERSION_HASH}" -o komari .
 
 # FROM scratch
 FROM alpine:3.21

README.md

@@ -84,7 +84,7 @@ Komari 是一款轻量级的自托管服务器监控工具，旨在提供简单
 欢迎提交 Issue 或 Pull Request！
 
 ## 鸣谢
- - 感谢 [Alice Networks LTD](https://app.alice.ws/) 提供的免费服务器
+ - 感谢我自己能这么闲
 
 ## 引用
  - [gorm.io](https://gorm.io/)
@@ -101,6 +101,15 @@ Komari 是一款轻量级的自托管服务器监控工具，旨在提供简单
 ## 许可证
 [MIT License](LICENSE)
 
+## 截图
+
+![PixPin_2025-06-07_15-28-30](https://github.com/user-attachments/assets/edce5694-c6c8-4647-bc11-8b27105fd55c)
+![PixPin_2025-06-07_15-28-49](https://github.com/user-attachments/assets/23b58032-211a-4b59-b444-c8267606a0bb)
+![PixPin_2025-06-07_15-29-05](https://github.com/user-attachments/assets/f4325d4d-fa69-41c6-9251-19f530476e65)
+![PixPin_2025-06-07_15-30-05](https://github.com/user-attachments/assets/69be38f6-6681-4afb-9a04-965d39b7fcc2)
+![PixPin_2025-06-07_15-30-46](https://github.com/user-attachments/assets/01d84dd1-3c81-4424-a041-7dbc2ae5822e)
+
+
 ## 碎碎念
 
 ### 我为什么做Komari？

api/AdminAuthMiddleware.go

@@ -13,18 +13,22 @@ func AdminAuthMiddleware() gin.HandlerFunc {
 
 		session, err := c.Cookie("session_token")
 		if err != nil {
-			c.JSON(http.StatusUnauthorized, gin.H{"status": "error", "error": "Unauthorized"})
+			RespondError(c, http.StatusUnauthorized, "Unauthorized.")
 			c.Abort()
 			return
 		}
 
 		// Komari is a single user system
-		_, err = accounts.GetSession(session)
+		uuid, err := accounts.GetSession(session)
 		if err != nil {
-			c.JSON(http.StatusUnauthorized, gin.H{"status": "error", "error": "Unauthorized."})
+			RespondError(c, http.StatusUnauthorized, "Unauthorized.")
 			c.Abort()
 			return
 		}
+		accounts.UpdateLatest(session, c.Request.UserAgent(), c.ClientIP())
+		// 将 session 和 用户 UUID 传递到后续处理器
+		c.Set("session", session)
+		c.Set("uuid", uuid)
 
 		c.Next()
 	}

api/Common.go

@@ -1,9 +1,11 @@
 package api
 
 import (
+	"net/http"
 	"sync"
 	"time"
 
+	"github.com/gin-gonic/gin"
 	"github.com/gorilla/websocket"
 	"github.com/komari-monitor/komari/common"
 
@@ -17,9 +19,10 @@ var (
 )
 
 type TerminalSession struct {
-	UUID    string
-	Browser *websocket.Conn
-	Agent   *websocket.Conn
+	UUID     string
+	UserUUID string
+	Browser  *websocket.Conn
+	Agent    *websocket.Conn
 }
 
 var TerminalSessionsMutex = &sync.Mutex{}
@@ -51,3 +54,35 @@ func SaveClientReportToDB() error {
 
 	return nil
 }
+
+type Response struct {
+	Status  string      `json:"status"`
+	Message string      `json:"message"`
+	Data    interface{} `json:"data,omitempty"`
+}
+
+// Respond sends a standardized JSON response.
+func Respond(c *gin.Context, httpStatus int, status string, message string, data interface{}) {
+	c.JSON(httpStatus, Response{Status: status, Message: message, Data: data})
+}
+
+// RespondSuccess sends a success response with data.
+func RespondSuccess(c *gin.Context, data interface{}) {
+	Respond(c, http.StatusOK, "success", "", data)
+}
+
+// RespondSuccessMessage sends a success response with message and data.
+func RespondSuccessMessage(c *gin.Context, message string, data interface{}) {
+	Respond(c, http.StatusOK, "success", message, data)
+}
+
+// RespondError sends an error response with message.
+func RespondError(c *gin.Context, httpStatus int, message string) {
+	Respond(c, httpStatus, "error", message, nil)
+}
+func GetVersion(c *gin.Context) {
+	RespondSuccess(c, gin.H{
+		"version": utils.CurrentVersion,
+		"hash":    utils.VersionHash,
+	})
+}

api/admin/2fa.go

@@ -0,0 +1,54 @@
+package admin
+
+import (
+	"image/png"
+
+	"github.com/gin-gonic/gin"
+	"github.com/komari-monitor/komari/api"
+	"github.com/komari-monitor/komari/database/accounts"
+	"github.com/pquerna/otp/totp"
+)
+
+func Generate2FA(c *gin.Context) {
+	secret, img, err := accounts.Generate2Fa()
+	if err != nil {
+		api.RespondError(c, 500, "Failed to generate 2FA: "+err.Error())
+		return
+	}
+	c.SetCookie("2fa_secret", secret, 1800, "/", "", false, true)
+	c.Header("Content-Type", "image/png")
+	c.Writer.WriteHeader(200)
+	png.Encode(c.Writer, img)
+}
+
+func Enable2FA(c *gin.Context) {
+	uuid, _ := c.Get("uuid")
+	secret, _ := c.Cookie("2fa_secret")
+	code := c.Query("code")
+	if secret == "" || uuid == nil || code == "" {
+		api.RespondError(c, 400, "2FA secret or code not provided")
+		return
+	}
+	if !totp.Validate(code, secret) {
+		api.RespondError(c, 400, "Invalid 2FA code")
+		return
+	}
+	err := accounts.Enable2Fa(uuid.(string), secret)
+	if err != nil {
+		api.RespondError(c, 500, "Failed to enable 2FA: "+err.Error())
+		return
+	}
+	c.SetCookie("2fa_secret", "", -1, "/", "", false, true)
+
+	api.RespondSuccess(c, "2FA enabled successfully")
+}
+
+func Disable2FA(c *gin.Context) {
+	uuid, _ := c.Get("uuid")
+	err := accounts.Disable2Fa(uuid.(string))
+	if err != nil {
+		api.RespondError(c, 500, "Failed to disable 2FA: "+err.Error())
+		return
+	}
+	api.RespondSuccess(c, "")
+}

api/admin/client.go

@@ -2,70 +2,55 @@ package admin
 
 import (
 	"net/http"
-	"time"
 
 	"github.com/gin-gonic/gin"
-	"github.com/komari-monitor/komari/common"
 	"github.com/komari-monitor/komari/database/clients"
-	"github.com/komari-monitor/komari/database/dbcore"
-	"github.com/komari-monitor/komari/database/models"
+	"github.com/komari-monitor/komari/database/logOperation"
 	"github.com/komari-monitor/komari/database/records"
 )
 
 func AddClient(c *gin.Context) {
 	var req struct {
-		name string
+		Name string `json:"name"`
 	}
-	if err := c.ShouldBindJSON(&req); err != nil || req.name == "" {
+	if err := c.ShouldBindJSON(&req); err != nil || req.Name == "" {
 		uuid, token, err := clients.CreateClient()
 		if err != nil {
-			c.JSON(http.StatusInternalServerError, gin.H{"status": "error", "error": err.Error()})
+			c.JSON(http.StatusInternalServerError, gin.H{"status": "error", "message": err.Error()})
 			return
 		}
 		c.JSON(http.StatusOK, gin.H{"status": "success", "uuid": uuid, "token": token})
 		return
 	}
-	uuid, token, err := clients.CreateClientWithName(req.name)
+	uuid, token, err := clients.CreateClientWithName(req.Name)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"status": "error", "error": err.Error()})
+		c.JSON(http.StatusInternalServerError, gin.H{"status": "error", "message": err.Error()})
 		return
 	}
-	c.JSON(http.StatusOK, gin.H{"status": "success", "uuid": uuid, "token": token})
+	user_uuid, _ := c.Get("uuid")
+	logOperation.Log(c.ClientIP(), user_uuid.(string), "create client:"+uuid, "info")
+	c.JSON(http.StatusOK, gin.H{"status": "success", "uuid": uuid, "token": token, "message": ""})
 }
 
 func EditClient(c *gin.Context) {
 	var req = make(map[string]interface{})
 	uuid := c.Param("uuid")
 	if err := c.ShouldBindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"status": "error", "error": err.Error()})
+		c.JSON(http.StatusBadRequest, gin.H{"status": "error", "message": err.Error()})
 		return
 	}
-	db := dbcore.GetDBInstance()
-	var err error
-	if req["token"] != "" {
-		err = db.Model(&models.Client{}).Where("uuid = ?", uuid).
-			Updates(map[string]interface{}{"token": req["token"], "updated_at": time.Now()}).Error
-		if err != nil {
-			c.JSON(http.StatusInternalServerError, gin.H{"status": "error", "error": err.Error()})
-			return
-		}
+	if uuid == "" {
+		c.JSON(http.StatusBadRequest, gin.H{"status": "error", "message": "Invalid or missing UUID"})
+		return
 	}
-	allowed_fields := []string{"name", "remark", "public_remark", "weight", "price", "expired_at"}
-	updateFields := map[string]interface{}{
-		"updated_at": time.Now(),
+	req["uuid"] = uuid
+	err := clients.SaveClient(req)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"status": "error", "message": err.Error()})
+		return
 	}
-	for _, field := range allowed_fields {
-		if req[field] != nil {
-			updateFields[field] = req[field]
-		}
-	}
-	if len(updateFields) > 1 { // 大于1是因为至少包含了updated_at
-		if err := db.Model(&common.ClientInfo{}).Where("uuid = ?", uuid).Updates(updateFields).Error; err != nil {
-			c.JSON(http.StatusInternalServerError, gin.H{"status": "error", "error": err.Error()})
-			return
-		}
-	}
-
+	user_uuid, _ := c.Get("uuid")
+	logOperation.Log(c.ClientIP(), user_uuid.(string), "edit client:"+uuid, "info")
 	c.JSON(http.StatusOK, gin.H{"status": "success"})
 }
 
@@ -79,17 +64,21 @@ func RemoveClient(c *gin.Context) {
 		})
 		return
 	}
+	user_uuid, _ := c.Get("uuid")
+	logOperation.Log(c.ClientIP(), user_uuid.(string), "delete client:"+uuid, "warn")
 	c.JSON(200, gin.H{"status": "success"})
 }
 
 func ClearRecord(c *gin.Context) {
 	if err := records.DeleteAll(); err != nil {
 		c.JSON(500, gin.H{
-			"status": "error",
-			"error":  "Failed to delete Record" + err.Error(),
+			"status":  "error",
+			"message": "Failed to delete Record" + err.Error(),
 		})
 		return
 	}
+	user_uuid, _ := c.Get("uuid")
+	logOperation.Log(c.ClientIP(), user_uuid.(string), "clear records", "warn")
 	c.JSON(200, gin.H{"status": "success"})
 }
 
@@ -97,8 +86,8 @@ func GetClient(c *gin.Context) {
 	uuid := c.Param("uuid")
 	if uuid == "" {
 		c.JSON(400, gin.H{
-			"status": "error",
-			"error":  "Invalid or missing UUID",
+			"status":  "error",
+			"message": "Invalid or missing UUID",
 		})
 		return
 	}
@@ -106,8 +95,8 @@ func GetClient(c *gin.Context) {
 	result, err := clients.GetClientByUUID(uuid)
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{
-			"status": "error",
-			"error":  err.Error(),
+			"status":  "error",
+			"message": err.Error(),
 		})
 		return
 	}
@@ -118,7 +107,7 @@ func GetClient(c *gin.Context) {
 func ListClients(c *gin.Context) {
 	cls, err := clients.GetAllClientBasicInfo()
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"status": "error", "error": err.Error()})
+		c.JSON(http.StatusInternalServerError, gin.H{"status": "error", "message": err.Error()})
 		return
 	}
 
@@ -129,17 +118,17 @@ func GetClientToken(c *gin.Context) {
 	uuid := c.Param("uuid")
 	if uuid == "" {
 		c.JSON(400, gin.H{
-			"status": "error",
-			"error":  "Invalid or missing UUID",
+			"status":  "error",
+			"message": "Invalid or missing UUID",
 		})
 		return
 	}
 
 	token, err := clients.GetClientTokenByUUID(uuid)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"status": "error", "error": err.Error()})
+		c.JSON(http.StatusInternalServerError, gin.H{"status": "error", "message": err.Error()})
 		return
 	}
 
-	c.JSON(http.StatusOK, gin.H{"status": "success", "token": token})
+	c.JSON(http.StatusOK, gin.H{"status": "success", "token": token, "message:": ""})
 }

api/admin/client_weight.go

@@ -2,32 +2,27 @@ package admin
 
 import (
 	"github.com/gin-gonic/gin"
-	"github.com/komari-monitor/komari/common"
+	"github.com/komari-monitor/komari/api"
 	"github.com/komari-monitor/komari/database/dbcore"
+	"github.com/komari-monitor/komari/database/logOperation"
+	"github.com/komari-monitor/komari/database/models"
 )
 
 func OrderWeight(c *gin.Context) {
 	var req = make(map[string]int)
 	if err := c.ShouldBindJSON(&req); err != nil {
-		c.JSON(400, gin.H{
-			"status": "error",
-			"error":  "Invalid or missing request body",
-		})
+		api.RespondError(c, 400, "Invalid or missing request body: "+err.Error())
 		return
 	}
 	db := dbcore.GetDBInstance()
 	for uuid, weight := range req {
-		err := db.Model(&common.ClientInfo{}).Where("uuid = ?", uuid).Update("weight", weight).Error
+		err := db.Model(&models.Client{}).Where("uuid = ?", uuid).Update("weight", weight).Error
 		if err != nil {
-			c.JSON(500, gin.H{
-				"status": "error",
-				"error":  "Failed to update client weight",
-			})
+			api.RespondError(c, 500, "Failed to update client weight: "+err.Error())
 			return
 		}
 	}
-	c.JSON(200, gin.H{
-		"status":  "success",
-		"message": "Client weight updated successfully",
-	})
+	uuid, _ := c.Get("uuid")
+	logOperation.Log(c.ClientIP(), uuid.(string), "order clients", "info")
+	api.RespondSuccess(c, nil)
 }

api/admin/clipboard/clipboard.go

@@ -0,0 +1,115 @@
+package clipboard
+
+import (
+	"net/http"
+	"strconv"
+
+	"github.com/gin-gonic/gin"
+	"github.com/komari-monitor/komari/api"
+	clipboardDB "github.com/komari-monitor/komari/database/clipboard"
+	"github.com/komari-monitor/komari/database/logOperation"
+	"github.com/komari-monitor/komari/database/models"
+)
+
+// GetClipboard retrieves a clipboard entry by ID
+func GetClipboard(c *gin.Context) {
+	idStr := c.Param("id")
+	id, err := strconv.Atoi(idStr)
+	if err != nil {
+		api.RespondError(c, http.StatusBadRequest, "Invalid ID")
+		return
+	}
+	cb, err := clipboardDB.GetClipboardByID(id)
+	if err != nil {
+		api.RespondError(c, http.StatusInternalServerError, "Failed to get clipboard: "+err.Error())
+		return
+	}
+	api.RespondSuccess(c, cb)
+}
+
+// ListClipboard lists all clipboard entries
+func ListClipboard(c *gin.Context) {
+	list, err := clipboardDB.ListClipboard()
+	if err != nil {
+		api.RespondError(c, http.StatusInternalServerError, "Failed to list clipboard: "+err.Error())
+		return
+	}
+	api.RespondSuccess(c, list)
+}
+
+// CreateClipboard creates a new clipboard entry
+func CreateClipboard(c *gin.Context) {
+	var req models.Clipboard
+	if err := c.ShouldBindJSON(&req); err != nil {
+		api.RespondError(c, http.StatusBadRequest, "Invalid request: "+err.Error())
+		return
+	}
+	if err := clipboardDB.CreateClipboard(&req); err != nil {
+		api.RespondError(c, http.StatusInternalServerError, "Failed to create clipboard: "+err.Error())
+		return
+	}
+	userUUID, _ := c.Get("uuid")
+	logOperation.Log(c.ClientIP(), userUUID.(string), "create clipboard:"+strconv.Itoa(req.Id), "info")
+	api.RespondSuccess(c, req)
+}
+
+// UpdateClipboard updates an existing clipboard entry
+func UpdateClipboard(c *gin.Context) {
+	idStr := c.Param("id")
+	id, err := strconv.Atoi(idStr)
+	if err != nil {
+		api.RespondError(c, http.StatusBadRequest, "Invalid ID")
+		return
+	}
+	var fields map[string]interface{}
+	if err := c.ShouldBindJSON(&fields); err != nil {
+		api.RespondError(c, http.StatusBadRequest, "Invalid request: "+err.Error())
+		return
+	}
+	if err := clipboardDB.UpdateClipboardFields(id, fields); err != nil {
+		api.RespondError(c, http.StatusInternalServerError, "Failed to update clipboard: "+err.Error())
+		return
+	}
+	userUUID, _ := c.Get("uuid")
+	logOperation.Log(c.ClientIP(), userUUID.(string), "update clipboard:"+strconv.Itoa(id), "info")
+	api.RespondSuccess(c, nil)
+}
+
+// DeleteClipboard deletes a clipboard entry
+func DeleteClipboard(c *gin.Context) {
+	idStr := c.Param("id")
+	id, err := strconv.Atoi(idStr)
+	if err != nil {
+		api.RespondError(c, http.StatusBadRequest, "Invalid ID")
+		return
+	}
+	if err := clipboardDB.DeleteClipboard(id); err != nil {
+		api.RespondError(c, http.StatusInternalServerError, "Failed to delete clipboard: "+err.Error())
+		return
+	}
+	userUUID, _ := c.Get("uuid")
+	logOperation.Log(c.ClientIP(), userUUID.(string), "delete clipboard:"+strconv.Itoa(id), "warn")
+	api.RespondSuccess(c, nil)
+}
+
+// BatchDeleteClipboard deletes multiple clipboard entries
+func BatchDeleteClipboard(c *gin.Context) {
+	var req struct {
+		IDs []int `json:"ids" binding:"required"`
+	}
+	if err := c.ShouldBindJSON(&req); err != nil {
+		api.RespondError(c, http.StatusBadRequest, "Invalid request: "+err.Error())
+		return
+	}
+	if len(req.IDs) == 0 {
+		api.RespondError(c, http.StatusBadRequest, "IDs cannot be empty")
+		return
+	}
+	if err := clipboardDB.DeleteClipboardBatch(req.IDs); err != nil {
+		api.RespondError(c, http.StatusInternalServerError, "Failed to batch delete clipboard: "+err.Error())
+		return
+	}
+	userUUID, _ := c.Get("uuid")
+	logOperation.Log(c.ClientIP(), userUUID.(string), "batch delete clipboard: "+strconv.Itoa(len(req.IDs))+" items", "warn")
+	api.RespondSuccess(c, nil)
+}

api/admin/exec.go

@@ -0,0 +1,78 @@
+package admin
+
+import (
+	"encoding/json"
+
+	"github.com/gin-gonic/gin"
+	"github.com/gorilla/websocket"
+	"github.com/komari-monitor/komari/api"
+	"github.com/komari-monitor/komari/database/logOperation"
+	"github.com/komari-monitor/komari/database/tasks"
+	"github.com/komari-monitor/komari/utils"
+	"github.com/komari-monitor/komari/ws"
+)
+
+// 接受数据类型：
+// - command: string
+// - clients: []string (客户端 UUID 列表)
+func Exec(c *gin.Context) {
+	var req struct {
+		Command string   `json:"command" binding:"required"`
+		Clients []string `json:"clients" binding:"required"`
+	}
+	var onlineClients []string
+	if err := c.ShouldBindJSON(&req); err != nil {
+		api.RespondError(c, 400, "Invalid or missing request body: "+err.Error())
+		return
+	}
+	for uuid := range ws.ConnectedClients {
+		if contain(req.Clients, uuid) {
+			onlineClients = append(onlineClients, uuid)
+		} else {
+			api.RespondError(c, 400, "Client not connected: "+uuid)
+			return
+		}
+	}
+	if len(onlineClients) == 0 {
+		api.RespondError(c, 400, "No clients connected")
+		return
+	}
+	taskId := utils.GenerateRandomString(16)
+	if err := tasks.CreateTask(taskId, onlineClients, req.Command); err != nil {
+		api.RespondError(c, 500, "Failed to create task: "+err.Error())
+		return
+	}
+	for _, uuid := range onlineClients {
+		var send struct {
+			Message string `json:"message"`
+			Command string `json:"command"`
+			TaskId  string `json:"task_id"`
+		}
+		send.Message = "exec"
+		send.Command = req.Command
+		send.TaskId = taskId
+
+		payload, _ := json.Marshal(send)
+		client := ws.ConnectedClients[uuid]
+		if client != nil {
+			client.WriteMessage(websocket.TextMessage, payload)
+		} else {
+			api.RespondError(c, 400, "Client connection is null: "+uuid)
+			return
+		}
+	}
+	uuid, _ := c.Get("uuid")
+	logOperation.Log(c.ClientIP(), uuid.(string), "REC, task id: "+taskId, "warn")
+	api.RespondSuccess(c, gin.H{
+		"task_id": taskId,
+		"clients": onlineClients,
+	})
+}
+func contain(clients []string, uuid string) bool {
+	for _, client := range clients {
+		if client == uuid {
+			return true
+		}
+	}
+	return false
+}

api/admin/log/log.go

@@ -0,0 +1,49 @@
+package log
+
+import (
+	"strconv"
+
+	"github.com/gin-gonic/gin"
+	"github.com/komari-monitor/komari/api"
+	"github.com/komari-monitor/komari/database/dbcore"
+	"github.com/komari-monitor/komari/database/models"
+)
+
+func GetLogs(c *gin.Context) {
+	limit := c.Query("limit")
+	if limit == "" {
+		limit = "100" // Default to 100 logs if not specified
+	}
+	page := c.Query("page")
+	if page == "" {
+		page = "1" // Default to page 1 if not specified
+	}
+	// Convert limit and page to integers
+	// If conversion fails, return an error
+	limitInt, err := strconv.Atoi(limit)
+	if err != nil || limitInt <= 0 {
+		api.RespondError(c, 400, "Invalid limit: "+limit)
+		return
+	}
+	pageInt, err := strconv.Atoi(page)
+	if err != nil || pageInt <= 0 {
+		api.RespondError(c, 400, "Invalid page: "+page)
+		return
+	}
+	db := dbcore.GetDBInstance()
+	var logs []models.Log
+	// 添加分页：计算偏移量并限制数量
+	offset := (pageInt - 1) * limitInt
+
+	var total int64
+	if err := db.Model(&models.Log{}).Count(&total).Error; err != nil {
+		api.RespondError(c, 500, "Failed to count logs: "+err.Error())
+		return
+	}
+
+	if err := db.Order("time desc").Limit(limitInt).Offset(offset).Find(&logs).Error; err != nil {
+		api.RespondError(c, 500, "Failed to retrieve logs: "+err.Error())
+		return
+	}
+	api.RespondSuccess(c, gin.H{"logs": logs, "total": total})
+}

api/admin/notification/offline.go

@@ -0,0 +1,109 @@
+package notification
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/komari-monitor/komari/api"
+	"github.com/komari-monitor/komari/database/dbcore"
+	"github.com/komari-monitor/komari/database/models"
+	"gorm.io/gorm/clause"
+)
+
+// POST body : []uuid
+func EnableOfflineNotification(c *gin.Context) {
+	var uuids []string
+	if err := c.ShouldBindJSON(&uuids); err != nil {
+		api.RespondError(c, 400, "Invalid request body: "+err.Error())
+		return
+	}
+	var notifications []models.OfflineNotification
+	for _, uuid := range uuids {
+		notifications = append(notifications, models.OfflineNotification{
+			Client: uuid,
+			Enable: true,
+		})
+	}
+	err := dbcore.GetDBInstance().Model(&models.OfflineNotification{}).
+		Clauses(clause.OnConflict{
+			Columns:   []clause.Column{{Name: "client"}},
+			DoUpdates: clause.AssignmentColumns([]string{"enable"}),
+		}).
+		Select("client", "enable").
+		Create(notifications).Error
+	if err != nil {
+		api.RespondError(c, 500, "Failed to enable offline notifications: "+err.Error())
+		return
+	}
+	api.RespondSuccess(c, nil)
+}
+
+// POST body : []uuid
+func DisableOfflineNotification(c *gin.Context) {
+	var uuids []string
+	if err := c.ShouldBindJSON(&uuids); err != nil {
+		api.RespondError(c, 400, "Invalid request body: "+err.Error())
+		return
+	}
+	var notifications []models.OfflineNotification
+	for _, uuid := range uuids {
+		notifications = append(notifications, models.OfflineNotification{
+			Client: uuid,
+			Enable: false,
+		})
+	}
+	err := dbcore.GetDBInstance().Model(&models.OfflineNotification{}).
+		Clauses(clause.OnConflict{
+			Columns:   []clause.Column{{Name: "client"}},
+			DoUpdates: clause.AssignmentColumns([]string{"enable"}),
+		}).
+		Select("client", "enable").
+		Create(notifications).Error
+	if err != nil {
+		api.RespondError(c, 500, "Failed to disable offline notifications: "+err.Error())
+		return
+	}
+	api.RespondSuccess(c, nil)
+}
+
+func EditOfflineNotification(c *gin.Context) {
+	var notifications []models.OfflineNotification
+	if err := c.ShouldBindJSON(&notifications); err != nil {
+		api.RespondError(c, 400, "Invalid request body: "+err.Error())
+		return
+	}
+	if len(notifications) == 0 {
+		api.RespondError(c, 400, "At least one notification is required")
+		return
+	}
+	for _, noti := range notifications {
+		if noti.Client == "" {
+			api.RespondError(c, 400, "Client UUID cannot be empty")
+			return
+		}
+		if noti.GracePeriod <= 0 || noti.Cooldown <= 0 {
+			api.RespondError(c, 400, "GracePeriod and Cooldown must be positive integers")
+			return
+		}
+	}
+	err := dbcore.GetDBInstance().Model(&models.OfflineNotification{}).
+		Clauses(clause.OnConflict{
+			Columns:   []clause.Column{{Name: "client"}},
+			DoUpdates: clause.AssignmentColumns([]string{"enable", "cooldown", "grace_period"}),
+		}).
+		Select("*").
+		Create(notifications).Error
+	if err != nil {
+		api.RespondError(c, 500, "Failed to edit offline notifications: "+err.Error())
+		return
+	}
+	api.RespondSuccess(c, nil)
+}
+
+func ListOfflineNotifications(c *gin.Context) {
+	var notifications []models.OfflineNotification
+	err := dbcore.GetDBInstance().Model(&models.OfflineNotification{}).Find(&notifications).Error
+	if err != nil {
+		api.RespondError(c, 500, "Failed to list offline notifications: "+err.Error())
+		return
+	}
+	api.RespondSuccess(c, notifications)
+}

api/admin/oauth.go

@@ -2,6 +2,7 @@ package admin
 
 import (
 	"github.com/gin-gonic/gin"
+	"github.com/komari-monitor/komari/api"
 	"github.com/komari-monitor/komari/database/accounts"
 )
 
@@ -9,7 +10,7 @@ func BindingExternalAccount(c *gin.Context) {
 	session, _ := c.Cookie("session_token")
 	user, err := accounts.GetUserBySession(session)
 	if err != nil {
-		c.JSON(500, gin.H{"status": "error", "error": "No user found"})
+		api.RespondError(c, 500, "No user found: "+err.Error())
 		return
 	}
 
@@ -20,15 +21,15 @@ func UnbindExternalAccount(c *gin.Context) {
 	session, _ := c.Cookie("session_token")
 	user, err := accounts.GetUserBySession(session)
 	if err != nil {
-		c.JSON(500, gin.H{"status": "error", "error": "No user found"})
+		api.RespondError(c, 500, "No user found: "+err.Error())
 		return
 	}
 
 	err = accounts.UnbindExternalAccount(user.UUID)
 	if err != nil {
-		c.JSON(500, gin.H{"status": "error", "error": "Failed to unbind external account"})
+		api.RespondError(c, 500, "Failed to unbind external account: "+err.Error())
 		return
 	}
 
-	c.JSON(200, gin.H{"status": "success", "message": "External account unbound"})
+	api.RespondSuccess(c, nil)
 }

api/admin/sessions.go

@@ -1,7 +1,9 @@
 package admin
 
 import (
+	"github.com/komari-monitor/komari/api"
 	"github.com/komari-monitor/komari/database/accounts"
+	"github.com/komari-monitor/komari/database/logOperation"
 
 	"github.com/gin-gonic/gin"
 )
@@ -10,10 +12,7 @@ func GetSessions(c *gin.Context) {
 
 	ss, err := accounts.GetAllSessions()
 	if err != nil {
-		c.JSON(500, gin.H{
-			"status": "error",
-			"error":  "Failed to get sessions",
-		})
+		api.RespondError(c, 500, "Failed to retrieve sessions: "+err.Error())
 		return
 	}
 	current, _ := c.Cookie("session_token")
@@ -25,40 +24,27 @@ func DeleteSession(c *gin.Context) {
 		Session string `json:"session" binding:"required"`
 	}
 	if err := c.ShouldBindJSON(&req); err != nil {
-		c.JSON(400, gin.H{
-			"status": "error",
-			"error":  "Invalid or missing session",
-		})
+		api.RespondError(c, 400, "Invalid request: "+err.Error())
 		return
 	}
 	err := accounts.DeleteSession(req.Session)
 	if err != nil {
-		c.JSON(500, gin.H{
-			"status": "error",
-			"error":  "Failed to delete session",
-		})
+		api.RespondError(c, 500, "Failed to delete session: "+err.Error())
 		return
 	}
-
-	c.JSON(200, gin.H{
-		"status":  "success",
-		"message": "Session deleted successfully",
-	})
+	uuid, _ := c.Get("uuid")
+	logOperation.Log(c.ClientIP(), uuid.(string), "delete session", "info")
+	api.RespondSuccess(c, nil)
 }
 
 func DeleteAllSession(c *gin.Context) {
 
 	err := accounts.DeleteAllSessions()
 	if err != nil {
-		c.JSON(500, gin.H{
-			"status": "error",
-			"error":  "Failed to delete session",
-		})
+		api.RespondError(c, 500, "Failed to delete all sessions: "+err.Error())
 		return
 	}
-
-	c.JSON(200, gin.H{
-		"status":  "success",
-		"message": "Session deleted successfully",
-	})
+	uuid, _ := c.Get("uuid")
+	logOperation.Log(c.ClientIP(), uuid.(string), "delete all sessions", "warn")
+	api.RespondSuccess(c, nil)
 }

api/admin/settings.go

@@ -3,7 +3,9 @@ package admin
 import (
 	"database/sql"
 
+	"github.com/komari-monitor/komari/api"
 	"github.com/komari-monitor/komari/database/config"
+	"github.com/komari-monitor/komari/database/logOperation"
 	"github.com/komari-monitor/komari/database/models"
 
 	"github.com/gin-gonic/gin"
@@ -18,35 +20,52 @@ func GetSettings(c *gin.Context) {
 			cst = models.Config{Sitename: "Komari"}
 			cst.ID = 1
 			config.Save(cst)
-			c.JSON(200, cst)
+			api.RespondSuccess(c, cst)
 			return
 		}
 		c.JSON(500, gin.H{
-			"status": "error",
-			"error":  "Internal Server Error: " + err.Error(),
+			"status":  "error",
+			"message": "Internal Server Error: " + err.Error(),
 		})
 	}
-	c.JSON(200, cst)
+	api.RespondSuccess(c, cst)
 }
 
 // EditSettings 更新自定义配置
 func EditSettings(c *gin.Context) {
 	cfg := make(map[string]interface{})
 	if err := c.ShouldBindJSON(&cfg); err != nil {
-		c.JSON(400, gin.H{
-			"status": "error",
-			"error":  "Bad Request: " + err.Error(),
-		})
+		api.RespondError(c, 400, "Invalid or missing request body: "+err.Error())
 		return
 	}
 
 	cfg["id"] = 1 // Only one record
 	if err := config.Update(cfg); err != nil {
-		c.JSON(500, gin.H{
-			"status": "error",
-			"error":  "Internal Server Error: " + err.Error(),
-		})
+		api.RespondError(c, 500, "Failed to update settings: "+err.Error())
 		return
 	}
-	c.JSON(200, gin.H{"status": "success"})
+
+	uuid, _ := c.Get("uuid")
+	message := "update settings: "
+	for key := range cfg {
+		ignoredKeys := []string{"id", "updated_at"}
+		if contains(ignoredKeys, key) {
+			continue
+		}
+		message += key + ", "
+	}
+	if len(message) > 2 {
+		message = message[:len(message)-2]
+	}
+	logOperation.Log(c.ClientIP(), uuid.(string), message, "info")
+	api.RespondSuccess(c, nil)
+}
+
+func contains(slice []string, item string) bool {
+	for _, v := range slice {
+		if v == item {
+			return true
+		}
+	}
+	return false
 }

api/admin/task.go

@@ -0,0 +1,154 @@
+package admin
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/komari-monitor/komari/api"
+	"github.com/komari-monitor/komari/database/tasks"
+)
+
+func GetTasks(c *gin.Context) {
+	dbTasks, err := tasks.GetAllTasks()
+	if err != nil {
+		api.RespondError(c, 500, "Failed to retrieve tasks: "+err.Error())
+		return
+	}
+	var responseTasks []gin.H
+	for _, t := range dbTasks {
+		results, err := tasks.GetTaskResultsByTaskId(t.TaskId)
+		if err != nil {
+			api.RespondError(c, 500, "Failed to retrieve task results: "+err.Error())
+			return
+		}
+
+		var filteredResults []gin.H
+		for _, r := range results {
+			filteredResults = append(filteredResults, gin.H{
+				"client":      r.Client,
+				"result":      r.Result,
+				"exit_code":   r.ExitCode,
+				"finished_at": r.FinishedAt,
+				"created_at":  r.CreatedAt,
+			})
+		}
+
+		responseTasks = append(responseTasks, gin.H{
+			"task_id": t.TaskId,
+			"clients": t.Clients,
+			"command": t.Command,
+			"results": filteredResults,
+		})
+	}
+	api.RespondSuccess(c, responseTasks)
+}
+
+func GetTaskById(c *gin.Context) {
+	taskId := c.Param("task_id")
+	if taskId == "" {
+		api.RespondError(c, 400, "Task ID is required")
+		return
+	}
+	task, err := tasks.GetTaskByTaskId(taskId)
+	if err != nil {
+		api.RespondError(c, 500, "Failed to retrieve task: "+err.Error())
+		return
+	}
+	if task == nil {
+		api.RespondError(c, 404, "Task not found")
+		return
+	}
+	results, err := tasks.GetTaskResultsByTaskId(taskId)
+	if err != nil {
+		api.RespondError(c, 500, "Failed to retrieve task results: "+err.Error())
+		return
+	}
+	var filteredResults []gin.H
+	for _, r := range results {
+		filteredResults = append(filteredResults, gin.H{
+			"client":      r.Client,
+			"result":      r.Result,
+			"exit_code":   r.ExitCode,
+			"finished_at": r.FinishedAt,
+			"created_at":  r.CreatedAt,
+		})
+	}
+	api.RespondSuccess(c, gin.H{
+		"task_id": task.TaskId,
+		"clients": task.Clients,
+		"command": task.Command,
+		"results": filteredResults,
+	})
+}
+
+func GetTasksByClientId(c *gin.Context) {
+	clientId := c.Param("uuid")
+	if clientId == "" {
+		api.RespondError(c, 400, "Client ID is required")
+		return
+	}
+	tasks, err := tasks.GetTasksByClientId(clientId)
+	if err != nil {
+		api.RespondError(c, 500, "Failed to retrieve tasks: "+err.Error())
+		return
+	}
+	if len(tasks) == 0 {
+		api.RespondError(c, 404, "No tasks found for this client")
+		return
+	}
+	api.RespondSuccess(c, tasks)
+}
+
+func GetSpecificTaskResult(c *gin.Context) {
+	taskId := c.Param("task_id")
+	clientId := c.Param("uuid")
+	if taskId == "" || clientId == "" {
+		api.RespondError(c, 400, "Task ID and Client ID are required")
+		return
+	}
+	result, err := tasks.GetSpecificTaskResult(taskId, clientId)
+	if err != nil {
+		api.RespondError(c, 500, "Failed to retrieve task result: "+err.Error())
+		return
+	}
+	if result == nil {
+		api.RespondError(c, 404, "No result found for this task and client")
+		return
+	}
+	api.RespondSuccess(c, result)
+}
+
+// Param: task_id
+func GetTaskResultsByTaskId(c *gin.Context) {
+	taskId := c.Param("task_id")
+	if taskId == "" {
+		api.RespondError(c, 400, "Task ID is required")
+		return
+	}
+	results, err := tasks.GetTaskResultsByTaskId(taskId)
+	if err != nil {
+		api.RespondError(c, 500, "Failed to retrieve task results: "+err.Error())
+		return
+	}
+	if len(results) == 0 {
+		api.RespondError(c, 404, "No results found for this task")
+		return
+	}
+	api.RespondSuccess(c, results)
+}
+
+func GetAllTaskResultByUUID(c *gin.Context) {
+	clientId := c.Param("uuid")
+	if clientId == "" {
+		api.RespondError(c, 400, "Client ID is required")
+		return
+	}
+	results, err := tasks.GetAllTasksResultByUUID(clientId)
+	if err != nil {
+		api.RespondError(c, 500, "Failed to retrieve tasks: "+err.Error())
+		return
+	}
+	if len(results) == 0 {
+		api.RespondError(c, 404, "No tasks found for this client")
+		return
+	}
+	api.RespondSuccess(c, results)
+}

api/admin/test/test.go

@@ -0,0 +1,47 @@
+package test
+
+import (
+	"net"
+
+	"github.com/gin-gonic/gin"
+	"github.com/komari-monitor/komari/api"
+	"github.com/komari-monitor/komari/database/config"
+	"github.com/komari-monitor/komari/utils/geoip"
+	"github.com/komari-monitor/komari/utils/telegram"
+)
+
+func TestTelegram(c *gin.Context) {
+	message := "Komari test message."
+	err := telegram.SendTextMessage(message)
+	if err != nil {
+		api.RespondError(c, 500, "Failed to send Telegram message: "+err.Error())
+		return
+	}
+	api.RespondSuccess(c, nil)
+}
+
+func TestGeoIp(c *gin.Context) {
+	ip := c.Query("ip")
+	if ip == "" {
+		if cfIP := c.GetHeader("CF-Connecting-IP"); cfIP != "" {
+			ip = cfIP
+		} else {
+			ip = c.ClientIP()
+		}
+	}
+	conf, err := config.Get()
+	if err != nil {
+		api.RespondError(c, 500, "Failed to get configuration: "+err.Error())
+		return
+	}
+	if !conf.GeoIpEnabled {
+		api.RespondError(c, 400, "GeoIP is not enabled in the configuration.")
+		return
+	}
+	GeoIpRecord, err := geoip.GetGeoIpInfo(net.ParseIP(ip))
+	if err != nil {
+		api.RespondError(c, 500, "Failed to get GeoIP record: "+err.Error())
+		return
+	}
+	api.RespondSuccess(c, GeoIpRecord)
+}

api/admin/update/favicon.go

@@ -0,0 +1,46 @@
+package update
+
+import (
+	"io"
+	"net/http"
+	"os"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+	"github.com/komari-monitor/komari/api"
+	"github.com/komari-monitor/komari/database/logOperation"
+)
+
+func UploadFavicon(c *gin.Context) {
+	c.Request.Body = http.MaxBytesReader(c.Writer, c.Request.Body, 5<<20) // 5MB
+	data, err := io.ReadAll(c.Request.Body)
+	if err != nil {
+		if strings.Contains(err.Error(), "request body too large") {
+			api.RespondError(c, http.StatusRequestEntityTooLarge, "File too large. Maximum size is 5MB")
+		} else {
+			api.RespondError(c, http.StatusBadRequest, err.Error())
+		}
+		return
+	}
+	if err := os.WriteFile("./data/favicon.ico", data, 0644); err != nil {
+		api.RespondError(c, http.StatusInternalServerError, "Failed to save favicon: "+err.Error())
+		return
+	}
+	uuid, _ := c.Get("uuid")
+	logOperation.Log(c.ClientIP(), uuid.(string), "Favicon uploaded", "info")
+	api.RespondSuccess(c, nil)
+}
+
+func DeleteFavicon(c *gin.Context) {
+	if err := os.Remove("./data/favicon.ico"); err != nil {
+		if os.IsNotExist(err) {
+			api.RespondError(c, http.StatusNotFound, "Favicon not found")
+		} else {
+			api.RespondError(c, http.StatusInternalServerError, "Failed to delete favicon: "+err.Error())
+		}
+		return
+	}
+	uuid, _ := c.Get("uuid")
+	logOperation.Log(c.ClientIP(), uuid.(string), "Favicon deleted", "info")
+	api.RespondSuccess(c, nil)
+}

api/admin/update/geoip.go

@@ -0,0 +1,18 @@
+package update
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/komari-monitor/komari/api"
+	"github.com/komari-monitor/komari/database/logOperation"
+	"github.com/komari-monitor/komari/utils/geoip"
+)
+
+func UpdateMmdbGeoIP(c *gin.Context) {
+	if err := geoip.UpdateGeoIpDatabase(); err != nil {
+		api.RespondError(c, 500, "Failed to update GeoIP database "+err.Error())
+		return
+	}
+	uuid, _ := c.Get("uuid")
+	logOperation.Log(c.ClientIP(), uuid.(string), "GeoIP database updated", "info")
+	api.RespondSuccess(c, nil)
+}

api/admin/update/user.go

@@ -0,0 +1,40 @@
+package update
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/komari-monitor/komari/api"
+	"github.com/komari-monitor/komari/database/accounts"
+	"github.com/komari-monitor/komari/database/logOperation"
+)
+
+func UpdateUser(c *gin.Context) {
+	var req struct {
+		Uuid     string  `json:"uuid" binding:"required"`
+		Name     *string `json:"username"`
+		Password *string `json:"password"`
+		SsoType  *string `json:"sso_type"`
+	}
+	if err := c.ShouldBindJSON(&req); err != nil {
+		api.RespondError(c, 400, "Invalid or missing request body: "+err.Error())
+		return
+	}
+	if req.Password == nil && req.Name == nil {
+		api.RespondError(c, 400, "At least one field (username or password) must be provided")
+		return
+	}
+	if req.Name != nil && len(*req.Name) < 3 {
+		api.RespondError(c, 400, "Username must be at least 3 characters long")
+		return
+	}
+	if req.Password != nil && len(*req.Password) < 6 {
+		api.RespondError(c, 400, "Password must be at least 6 characters long")
+		return
+	}
+	if err := accounts.UpdateUser(req.Uuid, req.Name, req.Password, req.SsoType); err != nil {
+		api.RespondError(c, 500, "Failed to update user: "+err.Error())
+		return
+	}
+	uuid, _ := c.Get("uuid")
+	logOperation.Log(c.ClientIP(), uuid.(string), "User updated", "warn")
+	api.RespondSuccess(c, gin.H{"uuid": req.Uuid})
+}

api/client/report.go

@@ -15,6 +15,7 @@ import (
 	"github.com/komari-monitor/komari/api"
 	"github.com/komari-monitor/komari/common"
 	"github.com/komari-monitor/komari/database/clients"
+	"github.com/komari-monitor/komari/utils/notification"
 	"github.com/komari-monitor/komari/ws"
 )
 
@@ -109,10 +110,11 @@ func WebSocketReport(c *gin.Context) {
 		conn.WriteJSON(gin.H{"status": "error", "error": "Token already in use"})
 		return
 	}
-
 	ws.ConnectedClients[uuid] = conn
+	go notification.OnlineNotification(uuid)
 	defer func() {
 		delete(ws.ConnectedClients, uuid)
+		notification.OfflineNotification(uuid)
 	}()
 
 	for {

api/client/task.go

@@ -0,0 +1,35 @@
+package client
+
+import (
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/komari-monitor/komari/database/clients"
+	"github.com/komari-monitor/komari/database/tasks"
+)
+
+func TaskResult(c *gin.Context) {
+	token := c.Query("token")
+	clientId, _ := clients.GetClientUUIDByToken(token)
+	if clientId == "" {
+		c.JSON(400, gin.H{"status": "error", "message": "Invalid or missing token"})
+		return
+	}
+	var req struct {
+		TaskId     string    `json:"task_id" binding:"required"`
+		Result     string    `json:"result" binding:"required"`
+		ExitCode   int       `json:"exit_code"`
+		FinishedAt time.Time `json:"finished_at" binding:"required"`
+	}
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(400, gin.H{"status": "error", "message": "Invalid request"})
+		return
+	}
+
+	if err := tasks.SaveTaskResult(req.TaskId, clientId, req.Result, req.ExitCode, req.FinishedAt); err != nil {
+		c.JSON(500, gin.H{"status": "error", "message": "Failed to update task result: " + err.Error()})
+		return
+	}
+
+	c.JSON(200, gin.H{"status": "success", "message": "Task result updated successfully"})
+}

api/latestRecord.go

@@ -7,11 +7,8 @@ import (
 func GetClientRecentRecords(c *gin.Context) {
 	uuid := c.Param("uuid")
 	if uuid == "" {
-		c.JSON(400, gin.H{
-			"status": "error",
-			"error":  "Invalid or missing UUID",
-		})
+		RespondError(c, 400, "UUID is required")
 		return
 	}
-	c.JSON(200, Records[uuid])
+	RespondSuccess(c, Records[uuid])
 }

api/login.go

@@ -6,6 +6,8 @@ import (
 	"net/http"
 
 	"github.com/komari-monitor/komari/database/accounts"
+	"github.com/komari-monitor/komari/database/config"
+	"github.com/komari-monitor/komari/database/logOperation"
 
 	"github.com/gin-gonic/gin"
 )
@@ -13,38 +15,61 @@ import (
 type LoginRequest struct {
 	Username string `json:"username"`
 	Password string `json:"password"`
+	TwoFa    string `json:"2fa_code"`
 }
 
 func Login(c *gin.Context) {
+	conf, _ := config.Get()
+	if conf.DisablePasswordLogin {
+		RespondError(c, http.StatusForbidden, "Password login is disabled")
+		return
+	}
+
 	bodyBytes, err := io.ReadAll(c.Request.Body)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"status": "error", "error": "Invalid request body"})
+		RespondError(c, http.StatusBadRequest, "Invalid request body: "+err.Error())
 		return
 	}
 	var data LoginRequest
 	err = json.Unmarshal(bodyBytes, &data)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"status": "error", "error": "Invalid request body"})
+		RespondError(c, http.StatusBadRequest, "Invalid request body: "+err.Error())
 		return
 	}
 	if data.Username == "" || data.Password == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"status": "error", "error": "Invalid request body"})
+		RespondError(c, http.StatusBadRequest, "Invalid request body: Username and password are required")
 		return
 	}
 
-	if uuid, success := accounts.CheckPassword(data.Username, data.Password); success {
-
-		session, err := accounts.CreateSession(uuid, 2592000)
-
-		if err != nil {
-			c.JSON(http.StatusInternalServerError, gin.H{"status": "error", "error": "Failed to create session" + err.Error()})
-			return
-		}
-		c.SetCookie("session_token", session, 2592000, "/", "", false, true)
-		c.JSON(200, gin.H{"set-cookie": map[string]interface{}{"session_token": session}})
+	uuid, success := accounts.CheckPassword(data.Username, data.Password)
+	if !success {
+		RespondError(c, http.StatusUnauthorized, "Invalid credentials")
 		return
-	} else {
-		c.JSON(http.StatusUnauthorized, gin.H{"status": "error", "error": "Invalid credentials"})
 	}
-
+	// 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
+	}
+	// Create session
+	session, err := accounts.CreateSession(uuid, 2592000, c.Request.UserAgent(), c.ClientIP(), "password")
+	if err != nil {
+		RespondError(c, http.StatusInternalServerError, "Failed to create session: "+err.Error())
+		return
+	}
+	c.SetCookie("session_token", session, 2592000, "/", "", false, true)
+	logOperation.Log(c.ClientIP(), uuid, "logged in (password)", "login")
+	RespondSuccess(c, gin.H{"set-cookie": gin.H{"session_token": session}})
+}
+func Logout(c *gin.Context) {
+	session, _ := c.Cookie("session_token")
+	accounts.DeleteSession(session)
+	c.SetCookie("session_token", "", -1, "/", "", false, true)
+	logOperation.Log(c.ClientIP(), "", "logged out", "logout")
+	c.Redirect(302, "/")
 }

api/logout.go

@@ -1,13 +0,0 @@
-package api
-
-import (
-	"github.com/gin-gonic/gin"
-	"github.com/komari-monitor/komari/database/accounts"
-)
-
-func Logout(c *gin.Context) {
-	session, _ := c.Cookie("session_token")
-	accounts.DeleteSession(session)
-	c.SetCookie("session_token", "", -1, "/", "", false, true)
-	c.Redirect(302, "/")
-}

api/me.go

@@ -22,6 +22,6 @@ func GetMe(c *gin.Context) {
 		c.JSON(200, gin.H{"username": "Guest", "logged_in": false})
 		return
 	}
-	c.JSON(200, gin.H{"username": user.Username, "logged_in": true, "uuid": user.UUID})
+	c.JSON(200, gin.H{"username": user.Username, "logged_in": true, "uuid": user.UUID, "sso_type": user.SSOType, "sso_id": user.SSOID, "2fa_enabled": user.TwoFactor != ""})
 
 }

api/me_test.go

@@ -21,7 +21,7 @@ func TestGetMe(t *testing.T) {
 		t.Fatalf("Failed to create test user: %v", err)
 	}
 	uuid := user.UUID
-	sessionToken, _ := accounts.CreateSession(uuid, 2592000)
+	sessionToken, _ := accounts.CreateSession(uuid, 2592000, "test_user_agent", "127.0.0.1", "oauth")
 
 	tests := []struct {
 		name           string

api/nodes.go

@@ -8,7 +8,7 @@ import (
 func GetNodesInformation(c *gin.Context) {
 	clientList, err := clients.GetAllClientBasicInfo()
 	if err != nil {
-		c.JSON(500, gin.H{"status": "error", "error": err.Error()})
+		RespondError(c, 500, "Failed to retrieve client information: "+err.Error())
 		return
 	}
 
@@ -19,7 +19,8 @@ func GetNodesInformation(c *gin.Context) {
 		clientList[i].IPv6 = ""
 		clientList[i].Remark = ""
 		clientList[i].Version = ""
+		clientList[i].Token = ""
 	}
 
-	c.JSON(200, gin.H{"status": "success", "data": clientList})
+	RespondSuccess(c, clientList)
 }

api/oauth.go

@@ -6,6 +6,7 @@ import (
 	"github.com/gin-gonic/gin"
 	"github.com/komari-monitor/komari/database/accounts"
 	"github.com/komari-monitor/komari/database/config"
+	"github.com/komari-monitor/komari/database/logOperation"
 	"github.com/komari-monitor/komari/utils/oauth"
 )
 
@@ -59,15 +60,16 @@ func OAuthCallback(c *gin.Context) {
 		session, _ := c.Cookie("session_token")
 		user, err := accounts.GetUserBySession(session)
 		if err != nil || user.UUID != uuid {
-			c.JSON(500, gin.H{"status": "error", "error": "Binding failed"})
+			c.JSON(500, gin.H{"status": "error", "message": "Binding failed"})
 			return
 		}
 		err = accounts.BindingExternalAccount(user.UUID, sso_id)
 		if err != nil {
-			c.JSON(500, gin.H{"status": "error", "error": "Binding failed"})
+			c.JSON(500, gin.H{"status": "error", "message": "Binding failed"})
 			return
 		}
-		c.Redirect(302, "/")
+		logOperation.Log(c.ClientIP(), user.UUID, "bound external account (OAuth)"+fmt.Sprintf(",sso_id: %s", sso_id), "login")
+		c.Redirect(302, "/manage")
 		return
 	}
 
@@ -75,20 +77,21 @@ func OAuthCallback(c *gin.Context) {
 	user, err := accounts.GetUserBySSO(sso_id)
 	if err != nil {
 		c.JSON(401, gin.H{
-			"status": "error",
-			"error":  "please log in and bind your GitHub account first.",
+			"status":  "error",
+			"message": "please log in and bind your GitHub account first.",
 		})
 		return
 	}
 
 	// 创建会话
-	session, err := accounts.CreateSession(user.UUID, 2592000)
+	session, err := accounts.CreateSession(user.UUID, 2592000, c.Request.UserAgent(), c.ClientIP(), "oauth")
 	if err != nil {
-		c.JSON(500, gin.H{"status": "error", "error": err.Error()})
+		c.JSON(500, gin.H{"status": "error", "message": err.Error()})
 		return
 	}
 
 	// 设置cookie并返回
 	c.SetCookie("session_token", session, 2592000, "/", "", false, true)
-	c.Redirect(302, "/")
+	logOperation.Log(c.ClientIP(), user.UUID, "logged in (OAuth)", "login")
+	c.Redirect(302, "/manage")
 }

api/public.go

@@ -8,20 +8,18 @@ import (
 func GetPublicSettings(c *gin.Context) {
 	cst, err := config.Get()
 	if err != nil {
-		c.JSON(500, gin.H{
-			"status": "error",
-			"error":  "Internal Server Error: " + err.Error(),
-		})
+		RespondError(c, 500, err.Error())
 		return
 	}
-	c.JSON(200, gin.H{
-		"status": "success",
-		"data": gin.H{
-			"sitename":     cst.Sitename,
-			"desc":         cst.Description,
-			"custom_head":  cst.CustomHead,
-			"oauth_enable": cst.OAuthEnabled,
-			"allow_cros":   cst.AllowCros,
-		},
+	// Return public settings including CORS
+	RespondSuccess(c, gin.H{
+		"sitename":               cst.Sitename,
+		"description":            cst.Description,
+		"custom_head":            cst.CustomHead,
+		"custom_body":            cst.CustomBody,
+		"oauth_enable":           cst.OAuthEnabled,
+		"disable_password_login": cst.DisablePasswordLogin,
+		"allow_cors":             cst.AllowCors,
 	})
+
 }

api/terminal.go

@@ -8,27 +8,30 @@ import (
 	"github.com/gin-gonic/gin"
 	"github.com/gorilla/websocket"
 	"github.com/komari-monitor/komari/database/clients"
+	"github.com/komari-monitor/komari/database/logOperation"
 	"github.com/komari-monitor/komari/utils"
 	"github.com/komari-monitor/komari/ws"
 )
 
 func RequestTerminal(c *gin.Context) {
 	uuid := c.Param("uuid")
+	user_uuid, _ := c.Get("uuid")
 	_, err := clients.GetClientByUUID(uuid)
 	if err != nil {
 		c.JSON(400, gin.H{
-			"error": "Client not found",
+			"status":  "error",
+			"message": "Client not found",
 		})
 		return
 	}
 	// 建立ws
 	if !websocket.IsWebSocketUpgrade(c.Request) {
-		c.JSON(http.StatusBadRequest, gin.H{"status": "error", "error": "Require WebSocket upgrade"})
+		c.JSON(http.StatusBadRequest, gin.H{"status": "error", "message": "Require WebSocket upgrade"})
 		return
 	}
 	upgrader := websocket.Upgrader{
 		CheckOrigin: func(r *http.Request) bool {
-			return true // TODO: 检查源站
+			return true
 		},
 	}
 	conn, err := upgrader.Upgrade(c.Writer, c.Request, nil)
@@ -38,9 +41,10 @@ func RequestTerminal(c *gin.Context) {
 	// 新建一个终端连接
 	id := utils.GenerateRandomString(32)
 	session := &TerminalSession{
-		UUID:    uuid,
-		Browser: conn,
-		Agent:   nil,
+		UserUUID: user_uuid.(string),
+		UUID:     uuid,
+		Browser:  conn,
+		Agent:    nil,
 	}
 
 	TerminalSessionsMutex.Lock()
@@ -59,7 +63,7 @@ func RequestTerminal(c *gin.Context) {
 	})
 
 	if ws.ConnectedClients[uuid] == nil {
-		conn.WriteMessage(1, []byte("Client offline!"))
+		conn.WriteMessage(1, []byte("Client offline!\n被控端离线!"))
 		conn.Close()
 		TerminalSessionsMutex.Lock()
 		delete(TerminalSessions, id)
@@ -77,13 +81,13 @@ func RequestTerminal(c *gin.Context) {
 		TerminalSessionsMutex.Unlock()
 		return
 	}
-	conn.WriteMessage(1, []byte("waiting for agent..."))
+	conn.WriteMessage(1, []byte("等待被控端连接 waiting for agent..."))
 	// 如果没有连接上，则关闭连接
 	time.AfterFunc(30*time.Second, func() {
 		TerminalSessionsMutex.Lock()
 		if session.Agent == nil {
 			if session.Browser != nil {
-				session.Browser.WriteMessage(1, []byte("timeout"))
+				session.Browser.WriteMessage(1, []byte("被控端连接超时 timeout"))
 				session.Browser.Close()
 			}
 			conn.Close()
@@ -91,13 +95,17 @@ func RequestTerminal(c *gin.Context) {
 		}
 		TerminalSessionsMutex.Unlock()
 	})
+	logOperation.Log(c.ClientIP(), user_uuid.(string), "request, terminal id:"+id+",client:"+session.UUID, "terminal")
 }
 
 func ForwardTerminal(id string) {
 	session, exists := TerminalSessions[id]
+
 	if !exists || session == nil || session.Agent == nil || session.Browser == nil {
 		return
 	}
+	logOperation.Log("", session.UserUUID, "established, terminal id:"+id, "terminal")
+	established_time := time.Now()
 	errChan := make(chan error, 1)
 
 	go func() {
@@ -152,6 +160,8 @@ func ForwardTerminal(id string) {
 	if session.Browser != nil {
 		session.Browser.Close()
 	}
+	disconnect_time := time.Now()
+	logOperation.Log("", session.UserUUID, "disconnected, terminal id:"+id+", duration:"+disconnect_time.Sub(established_time).String(), "terminal")
 	TerminalSessionsMutex.Lock()
 	delete(TerminalSessions, id)
 	TerminalSessionsMutex.Unlock()

cmd/chpasswd.go

@@ -5,11 +5,13 @@ import (
 
 	"github.com/komari-monitor/komari/cmd/flags"
 	"github.com/komari-monitor/komari/database/accounts"
+	"github.com/komari-monitor/komari/database/dbcore"
+	"github.com/komari-monitor/komari/database/models"
 	"github.com/spf13/cobra"
 )
 
 var (
-	Username    string
+	//Username    string
 	NewPassword string
 )
 
@@ -17,7 +19,7 @@ var ChpasswdCmd = &cobra.Command{
 	Use:     "chpasswd",
 	Short:   "Force change password",
 	Long:    `Force change password`,
-	Example: `komari chpasswd -u <username> -p <password>`,
+	Example: `komari chpasswd -p <password>`,
 	Run: func(cmd *cobra.Command, args []string) {
 		if NewPassword == "" {
 			cmd.Help()
@@ -27,9 +29,10 @@ var ChpasswdCmd = &cobra.Command{
 			cmd.Println("Database file does not exist.")
 			return
 		}
-
-		cmd.Println("Changing password for user:", Username)
-		if err := accounts.ForceResetPassword(Username, NewPassword); err != nil {
+		user := &models.User{}
+		dbcore.GetDBInstance().Model(&models.User{}).First(user)
+		cmd.Println("Changing password for user:", user.Username)
+		if err := accounts.ForceResetPassword(user.Username, NewPassword); err != nil {
 			cmd.Println("Error:", err)
 			return
 		}
@@ -45,7 +48,7 @@ var ChpasswdCmd = &cobra.Command{
 }
 
 func init() {
-	ChpasswdCmd.PersistentFlags().StringVarP(&Username, "user", "u", "admin", "The username of the account to change password")
+	//ChpasswdCmd.PersistentFlags().StringVarP(&Username, "user", "u", "admin", "The username of the account to change password")
 	ChpasswdCmd.PersistentFlags().StringVarP(&NewPassword, "password", "p", "", "New password")
 	RootCmd.AddCommand(ChpasswdCmd)
 }

cmd/disable2FA.go

@@ -0,0 +1,33 @@
+package cmd
+
+import (
+	"os"
+
+	"github.com/komari-monitor/komari/database/dbcore"
+	"github.com/komari-monitor/komari/database/models"
+	"github.com/spf13/cobra"
+	"gorm.io/gorm"
+)
+
+var Disable2FA = &cobra.Command{
+	Use:   "disable-2fa",
+	Short: "Force disable 2FA",
+	Long:  `Force disable 2FA`,
+	Run: func(cmd *cobra.Command, args []string) {
+		db := dbcore.GetDBInstance()
+		err := db.Transaction(func(tx *gorm.DB) error {
+			return tx.Model(&models.User{}).Where("two_factor != ?", "").
+				Update("two_factor", "").Error
+		})
+		if err != nil {
+			cmd.Println("Error:", err)
+			os.Exit(1)
+		}
+		cmd.Println("2FA has been disabled.")
+		cmd.Println("Please restart the server to apply the changes.")
+	},
+}
+
+func init() {
+	RootCmd.AddCommand(Disable2FA)
+}

cmd/permitPasswordLogin.go

@@ -0,0 +1,33 @@
+package cmd
+
+import (
+	"os"
+
+	"github.com/komari-monitor/komari/database/dbcore"
+	"github.com/komari-monitor/komari/database/models"
+	"github.com/spf13/cobra"
+	"gorm.io/gorm"
+)
+
+var PermitPasswordLoginCmd = &cobra.Command{
+	Use:   "permit-login",
+	Short: "Force permit password login",
+	Long:  `Force permit password login`,
+	Run: func(cmd *cobra.Command, args []string) {
+		db := dbcore.GetDBInstance()
+		err := db.Transaction(func(tx *gorm.DB) error {
+			return tx.Model(&models.Config{}).Where("id = ?", 1).
+				Update("disable_password_login", false).Error
+		})
+		if err != nil {
+			cmd.Println("Error:", err)
+			os.Exit(1)
+		}
+		cmd.Println("Password login has been permitted.")
+		cmd.Println("Please restart the server to apply the changes.")
+	},
+}
+
+func init() {
+	RootCmd.AddCommand(PermitPasswordLoginCmd)
+}

cmd/server.go

@@ -1,62 +1,76 @@
 package cmd
 
 import (
+	"context"
 	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
 	"time"
 
+	"github.com/gin-gonic/gin"
 	"github.com/komari-monitor/komari/api"
 	"github.com/komari-monitor/komari/api/admin"
+	"github.com/komari-monitor/komari/api/admin/clipboard"
+	log_api "github.com/komari-monitor/komari/api/admin/log"
+	"github.com/komari-monitor/komari/api/admin/notification"
+	"github.com/komari-monitor/komari/api/admin/test"
+	"github.com/komari-monitor/komari/api/admin/update"
 	"github.com/komari-monitor/komari/api/client"
 	"github.com/komari-monitor/komari/cmd/flags"
 	"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/logOperation"
 	"github.com/komari-monitor/komari/database/models"
 	"github.com/komari-monitor/komari/database/records"
+	"github.com/komari-monitor/komari/database/tasks"
 	"github.com/komari-monitor/komari/public"
 	"github.com/komari-monitor/komari/utils/geoip"
 	"github.com/komari-monitor/komari/ws"
-
-	"github.com/gin-contrib/cors"
-	"github.com/gin-gonic/gin"
 	"github.com/spf13/cobra"
 )
 
+var (
+	DynamicCorsEnabled bool = false
+)
+
 var ServerCmd = &cobra.Command{
 	Use:   "server",
 	Short: "Start the server",
 	Long:  `Start the server`,
 	Run: func(cmd *cobra.Command, args []string) {
 		InitDatabase()
-
-		go DoRecordsWork()
+		go geoip.InitGeoIp()
+		go DoScheduledWork()
 
 		r := gin.Default()
-		cfg, err := config.Get()
+
+		// 动态 CORS 中间件
+		conf, err := config.Get()
 		if err != nil {
-			log.Fatalln("Failed to get config:", err)
+			log.Fatal(err)
 		}
-
-		if cfg.AllowCros {
-			r.Use(cors.New(cors.Config{
-				AllowOrigins:     []string{"*"},
-				AllowMethods:     []string{"GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"},
-				AllowHeaders:     []string{"Origin", "Content-Length", "Content-Type", "Authorization"},
-				ExposeHeaders:    []string{"Content-Length"},
-				AllowCredentials: true,
-				MaxAge:           12 * time.Hour,
-			}))
-		}
-
-		if cfg.GeoIpEnabled {
-			geoip.InitGeoIp()
-			go func() {
-				ticker := time.NewTicker(time.Hour * 24)
-				for range ticker.C {
-					geoip.UpdateGeoIpDatabase()
+		DynamicCorsEnabled = conf.AllowCors
+		config.Subscribe(func(event config.ConfigEvent) {
+			DynamicCorsEnabled = event.New.AllowCors
+		})
+		r.Use(func(c *gin.Context) {
+			if DynamicCorsEnabled {
+				c.Header("Access-Control-Allow-Origin", "*")
+				c.Header("Access-Control-Allow-Methods", "GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS")
+				c.Header("Access-Control-Allow-Headers", "Origin, Content-Length, Content-Type, Authorization, Accept, X-CSRF-Token, X-Requested-With, Set-Cookie")
+				c.Header("Access-Control-Expose-Headers", "Content-Length, Authorization, Set-Cookie")
+				c.Header("Access-Control-Allow-Credentials", "true")
+				c.Header("Access-Control-Max-Age", "43200") // 12 hours
+				if c.Request.Method == "OPTIONS" {
+					c.AbortWithStatus(204)
+					return
 				}
-			}()
-		}
+			}
+			c.Next()
+		})
 
 		r.Use(func(c *gin.Context) {
 			if len(c.Request.URL.Path) >= 4 && c.Request.URL.Path[:4] == "/api" {
@@ -77,6 +91,7 @@ var ServerCmd = &cobra.Command{
 		r.GET("/api/oauth", api.OAuth)
 		r.GET("/api/oauth_callback", api.OAuthCallback)
 		r.GET("/api/logout", api.Logout)
+		r.GET("/api/version", api.GetVersion)
 		r.GET("/api/recent/:uuid", api.GetClientRecentRecords)
 
 		tokenAuthrized := r.Group("/api/clients", api.TokenAuthMiddleware())
@@ -85,10 +100,35 @@ var ServerCmd = &cobra.Command{
 			tokenAuthrized.POST("/uploadBasicInfo", client.UploadBasicInfo)
 			tokenAuthrized.POST("/report", client.UploadReport)
 			tokenAuthrized.GET("/terminal", client.EstablishConnection)
+			tokenAuthrized.POST("/task/result", client.TaskResult)
 		}
 
 		adminAuthrized := r.Group("/api/admin", api.AdminAuthMiddleware())
 		{
+			// test
+			testGroup := adminAuthrized.Group("/test")
+			{
+				testGroup.GET("/telegram", test.TestTelegram)
+				testGroup.GET("/geoip", test.TestGeoIp)
+			}
+			// update
+			updateGroup := adminAuthrized.Group("/update")
+			{
+				updateGroup.POST("/mmdb", update.UpdateMmdbGeoIP)
+				updateGroup.POST("/user", update.UpdateUser)
+				updateGroup.PUT("/favicon", update.UploadFavicon)
+				updateGroup.POST("/favicon", update.DeleteFavicon)
+			}
+			// tasks
+			taskGroup := adminAuthrized.Group("/task")
+			{
+				taskGroup.GET("/all", admin.GetTasks)
+				taskGroup.POST("/exec", admin.Exec)
+				taskGroup.GET("/:task_id", admin.GetTaskById)
+				taskGroup.GET("/:task_id/result", admin.GetTaskResultsByTaskId)
+				taskGroup.GET("/:task_id/result/:uuid", admin.GetSpecificTaskResult)
+				taskGroup.GET("/client/:uuid", admin.GetTasksByClientId)
+			}
 			// settings
 			adminAuthrized.GET("/settings", admin.GetSettings)
 			adminAuthrized.POST("/settings", admin.EditSettings)
@@ -123,21 +163,63 @@ var ServerCmd = &cobra.Command{
 				sessionGroup.POST("/remove", admin.DeleteSession)
 				sessionGroup.POST("/remove/all", admin.DeleteAllSession)
 			}
+			two_factorGroup := adminAuthrized.Group("/2fa")
+			{
+				two_factorGroup.GET("/generate", admin.Generate2FA)
+				two_factorGroup.POST("/enable", admin.Enable2FA)
+				two_factorGroup.POST("/disable", admin.Disable2FA)
+			}
+			adminAuthrized.GET("/logs", log_api.GetLogs)
+
+			// clipboard
+			clipboardGroup := adminAuthrized.Group("/clipboard")
+			{
+				clipboardGroup.GET("/:id", clipboard.GetClipboard)
+				clipboardGroup.GET("", clipboard.ListClipboard)
+				clipboardGroup.POST("", clipboard.CreateClipboard)
+				clipboardGroup.POST("/:id", clipboard.UpdateClipboard)
+				clipboardGroup.POST("/remove", clipboard.BatchDeleteClipboard)
+				clipboardGroup.POST("/:id/remove", clipboard.DeleteClipboard)
+			}
+
+			notificationGroup := adminAuthrized.Group("/notification")
+			{
+				// offline notifications
+				notificationGroup.GET("/offline", notification.ListOfflineNotifications)
+				notificationGroup.POST("/offline/edit", notification.EditOfflineNotification)
+				notificationGroup.POST("/offline/enable", notification.EnableOfflineNotification)
+				notificationGroup.POST("/offline/disable", notification.DisableOfflineNotification)
+			}
 		}
 
 		public.Static(r.Group("/"), func(handlers ...gin.HandlerFunc) {
 			r.NoRoute(handlers...)
 		})
+		// 静态文件服务
+		public.UpdateIndex(conf)
+		config.Subscribe(func(event config.ConfigEvent) {
+			public.UpdateIndex(event.New)
+		})
 
+		srv := &http.Server{
+			Addr:    flags.Listen,
+			Handler: r,
+		}
 		go func() {
-			cfg, err := config.Get()
-			if err != nil {
-				log.Fatalln("Failed to get config:", err)
+			if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+				OnFatal(err)
+				log.Fatalf("listen: %s\n", err)
 			}
-			public.UpdateIndex(cfg)
 		}()
-
-		r.Run(flags.Listen)
+		quit := make(chan os.Signal, 1)
+		signal.Notify(quit, os.Interrupt, syscall.SIGTERM)
+		<-quit
+		OnShutdown()
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer cancel()
+		if err := srv.Shutdown(ctx); err != nil {
+			log.Fatalf("Server forced to shutdown: %v", err)
+		}
 
 	},
 }
@@ -172,7 +254,7 @@ func InitDatabase() {
 	}
 }
 
-func DoRecordsWork() {
+func DoScheduledWork() {
 	ticker := time.NewTicker(time.Minute * 30)
 	ticker1 := time.NewTicker(60 * time.Second)
 	records.DeleteRecordBefore(time.Now().Add(-time.Hour * 24 * 30))
@@ -182,11 +264,19 @@ func DoRecordsWork() {
 		case <-ticker.C:
 			records.DeleteRecordBefore(time.Now().Add(-time.Hour * 24 * 30))
 			records.CompactRecord()
-			break
+			tasks.ClearTaskResultsByTimeBefore(time.Now().Add(-time.Hour * 24 * 30))
+			logOperation.RemoveOldLogs()
 		case <-ticker1.C:
 			api.SaveClientReportToDB()
-			break
 		}
 	}
 
 }
+
+func OnShutdown() {
+	logOperation.Log("", "", "server is shutting down", "info")
+}
+
+func OnFatal(err error) {
+	logOperation.Log("", "", "server encountered a fatal error: "+err.Error(), "error")
+}

common/modules.go

@@ -29,6 +29,7 @@ type ClientConfig struct {
 }
 
 // ClientInfo stores static client information
+// Deprecated: Use models.Client instead.
 type ClientInfo struct {
 	UUID           string    `json:"uuid,omitempty" gorm:"type:varchar(36);primaryKey;foreignKey:ClientUUID;references:UUID;constraint:OnDelete:CASCADE"`
 	Name           string    `json:"name" gorm:"type:varchar(100);not null"`

database/accounts/2fa.go

@@ -0,0 +1,58 @@
+package accounts
+
+import (
+	"image"
+
+	"github.com/komari-monitor/komari/database/dbcore"
+	"github.com/komari-monitor/komari/database/models"
+	"github.com/pquerna/otp/totp"
+)
+
+var (
+	TwoFactorIssuer = "Komari Monitor"
+)
+
+func Generate2Fa() (string, image.Image, error) {
+	otp, err := totp.Generate(totp.GenerateOpts{
+		Issuer:      TwoFactorIssuer,
+		AccountName: "komari",
+	})
+	if err != nil {
+		return "", nil, err
+	}
+	img, err := otp.Image(250, 250)
+	if err != nil {
+		return "", nil, err
+	}
+	return otp.Secret(), img, nil
+}
+
+func Enable2Fa(uuid, secret string) error {
+	db := dbcore.GetDBInstance()
+	return db.Model(&models.User{}).Where("uuid = ?", uuid).Update("two_factor", secret).Error
+}
+
+func Verify2Fa(uuid, code string) (bool, error) {
+	db := dbcore.GetDBInstance()
+	var user models.User
+	err := db.Where("uuid = ?", uuid).First(&user).Error
+	if err != nil {
+		return false, err
+	}
+
+	if user.TwoFactor == "" {
+		return false, nil // 用户未启用2FA
+	}
+
+	valid := totp.Validate(code, user.TwoFactor)
+	if !valid {
+		return false, nil
+	}
+
+	return true, nil
+}
+
+func Disable2Fa(uuid string) error {
+	db := dbcore.GetDBInstance()
+	return db.Model(&models.User{}).Where("uuid = ?", uuid).Update("two_factor", "").Error
+}

database/accounts/accounts.go

@@ -152,3 +152,32 @@ func UnbindExternalAccount(uuid string) error {
 	}
 	return nil
 }
+
+func UpdateUser(uuid string, name, password, sso_type *string) error {
+	db := dbcore.GetDBInstance()
+	// Check if user exists
+	var existingUser models.User
+	result := db.Where("uuid = ?", uuid).First(&existingUser)
+	if result.Error != nil {
+		return fmt.Errorf("user not found: %s", uuid)
+	}
+	updates := make(map[string]interface{})
+	if name != nil {
+		updates["username"] = *name
+	}
+	if password != nil {
+		updates["passwd"] = hashPasswd(*password)
+	}
+	if sso_type != nil {
+		updates["sso_type"] = *sso_type
+	}
+	updates["updated_at"] = time.Now()
+	err := db.Model(&models.User{}).Where("uuid = ?", uuid).Updates(updates).Error
+	if err != nil {
+		return err
+	}
+	if password != nil {
+		DeleteAllSessions()
+	}
+	return nil
+}

database/accounts/sessions.go

@@ -20,14 +20,18 @@ func GetAllSessions() (sessions []models.Session, err error) {
 }
 
 // CreateSession 创建新会话
-func CreateSession(uuid string, expires int) (string, error) {
+func CreateSession(uuid string, expires int, userAgent, ip, login_method string) (string, error) {
 	db := dbcore.GetDBInstance()
 	session := utils.GenerateRandomString(32)
 
 	sessionRecord := models.Session{
-		UUID:    uuid,
-		Session: session,
-		Expires: time.Now().Add(time.Duration(expires) * time.Second),
+		UUID:         uuid,
+		Session:      session,
+		Expires:      time.Now().Add(time.Duration(expires) * time.Second),
+		UserAgent:    userAgent,
+		Ip:           ip,
+		LoginMethod:  login_method,
+		LatestOnline: time.Now(),
 	}
 
 	err := db.Create(&sessionRecord).Error
@@ -83,3 +87,26 @@ func DeleteAllSessions() error {
 	}
 	return nil
 }
+
+func UpdateLatestOnline(session string) error {
+	db := dbcore.GetDBInstance()
+	return db.Model(&models.Session{}).Where("session = ?", session).Update("latest_online", time.Now()).Error
+}
+
+func UpdateLatestUserAgent(session, userAgent string) error {
+	db := dbcore.GetDBInstance()
+	return db.Model(&models.Session{}).Where("session = ?", session).Update("latest_user_agent", userAgent).Error
+}
+func UpdateLatestIp(session, ip string) error {
+	db := dbcore.GetDBInstance()
+	return db.Model(&models.Session{}).Where("session = ?", session).Update("latest_ip", ip).Error
+}
+
+func UpdateLatest(session, useragent, ip string) error {
+	db := dbcore.GetDBInstance()
+	return db.Model(&models.Session{}).Where("session = ?", session).Updates(map[string]interface{}{
+		"latest_online":     time.Now(),
+		"latest_user_agent": useragent,
+		"latest_ip":         ip,
+	}).Error
+}

database/clients/client.go

@@ -30,14 +30,10 @@ func DeleteClient(clientUuid string) error {
 	if err != nil {
 		return err
 	}
-	err = db.Delete(&common.ClientInfo{}, "uuid = ?", clientUuid).Error
-	if err != nil {
-		return err
-	}
 	return nil
 }
 
-// Decprecated: UpdateOrInsertBasicInfo is deprecated and will be removed in a future release. Use SaveClientInfo instead.
+// Deprecated: UpdateOrInsertBasicInfo is deprecated and will be removed in a future release. Use SaveClientInfo instead.
 func UpdateOrInsertBasicInfo(cbi common.ClientInfo) error {
 	db := dbcore.GetDBInstance()
 	updates := make(map[string]interface{})
@@ -78,10 +74,33 @@ func UpdateOrInsertBasicInfo(cbi common.ClientInfo) error {
 	updates["version"] = cbi.Version
 	updates["updated_at"] = time.Now()
 
-	err := db.Clauses(clause.OnConflict{
+	// 转换为更新Client表
+	client := models.Client{
+		UUID: cbi.UUID,
+	}
+
+	err := db.Model(&client).Clauses(clause.OnConflict{
 		Columns:   []clause.Column{{Name: "uuid"}},
 		DoUpdates: clause.Assignments(updates),
-	}).Create(&cbi).Error
+	}).Create(map[string]interface{}{
+		"uuid":       cbi.UUID,
+		"name":       cbi.Name,
+		"cpu_name":   cbi.CpuName,
+		"arch":       cbi.Arch,
+		"cpu_cores":  cbi.CpuCores,
+		"os":         cbi.OS,
+		"gpu_name":   cbi.GpuName,
+		"ipv4":       cbi.IPv4,
+		"ipv6":       cbi.IPv6,
+		"region":     cbi.Region,
+		"remark":     cbi.Remark,
+		"mem_total":  cbi.MemTotal,
+		"swap_total": cbi.SwapTotal,
+		"disk_total": cbi.DiskTotal,
+		"version":    cbi.Version,
+		"updated_at": time.Now(),
+	}).Error
+
 	if err != nil {
 		return err
 	}
@@ -101,7 +120,7 @@ func SaveClientInfo(update map[string]interface{}) error {
 
 	update["updated_at"] = time.Now()
 
-	err := db.Model(&common.ClientInfo{}).Where("uuid = ?", clientUUID).Updates(update).Error
+	err := db.Model(&models.Client{}).Where("uuid = ?", clientUUID).Updates(update).Error
 	if err != nil {
 		return err
 	}
@@ -120,7 +139,7 @@ func UpdateClientConfig(config common.ClientConfig) error {
 
 func EditClientName(clientUUID, clientName string) error {
 	db := dbcore.GetDBInstance()
-	err := db.Model(&models.Client{}).Where("uuid = ?", clientUUID).Update("client_name", clientName).Error
+	err := db.Model(&models.Client{}).Where("uuid = ?", clientUUID).Update("name", clientName).Error
 	if err != nil {
 		return err
 	}
@@ -160,6 +179,7 @@ func CreateClient() (clientUUID, token string, err error) {
 	client := models.Client{
 		UUID:      clientUUID,
 		Token:     token,
+		Name:      "client_" + clientUUID[0:8],
 		CreatedAt: time.Now(),
 		UpdatedAt: time.Now(),
 	}
@@ -168,14 +188,6 @@ func CreateClient() (clientUUID, token string, err error) {
 	if err != nil {
 		return "", "", err
 	}
-	clientInfo := common.ClientInfo{
-		UUID: clientUUID,
-		Name: "client_" + clientUUID[0:8],
-	}
-	err = db.Create(&clientInfo).Error
-	if err != nil {
-		return "", "", err
-	}
 	return clientUUID, token, nil
 }
 
@@ -189,6 +201,7 @@ func CreateClientWithName(name string) (clientUUID, token string, err error) {
 	client := models.Client{
 		UUID:      clientUUID,
 		Token:     token,
+		Name:      name,
 		CreatedAt: time.Now(),
 		UpdatedAt: time.Now(),
 	}
@@ -197,14 +210,6 @@ func CreateClientWithName(name string) (clientUUID, token string, err error) {
 	if err != nil {
 		return "", "", err
 	}
-	clientInfo := common.ClientInfo{
-		UUID: clientUUID,
-		Name: name,
-	}
-	err = db.Create(&clientInfo).Error
-	if err != nil {
-		return "", "", err
-	}
 	return clientUUID, token, nil
 }
 
@@ -230,14 +235,14 @@ func GetClientByUUID(uuid string) (client models.Client, err error) {
 }
 
 // GetClientBasicInfo 获取指定 UUID 的客户端基本信息
-func GetClientBasicInfo(uuid string) (client common.ClientInfo, err error) {
+func GetClientBasicInfo(uuid string) (client models.Client, err error) {
 	db := dbcore.GetDBInstance()
 	err = db.Where("uuid = ?", uuid).First(&client).Error
 	if err != nil {
 		if err == gorm.ErrRecordNotFound {
-			return common.ClientInfo{}, fmt.Errorf("客户端不存在: %s", uuid)
+			return models.Client{}, fmt.Errorf("客户端不存在: %s", uuid)
 		}
-		return common.ClientInfo{}, err
+		return models.Client{}, err
 	}
 	return client, nil
 }
@@ -252,7 +257,7 @@ func GetClientTokenByUUID(uuid string) (token string, err error) {
 	return client.Token, nil
 }
 
-func GetAllClientBasicInfo() (clients []common.ClientInfo, err error) {
+func GetAllClientBasicInfo() (clients []models.Client, err error) {
 	db := dbcore.GetDBInstance()
 	err = db.Find(&clients).Error
 	if err != nil {
@@ -260,3 +265,24 @@ func GetAllClientBasicInfo() (clients []common.ClientInfo, err error) {
 	}
 	return clients, nil
 }
+
+func SaveClient(updates map[string]interface{}) error {
+	db := dbcore.GetDBInstance()
+	clientUUID, ok := updates["uuid"].(string)
+	if !ok || clientUUID == "" {
+		return fmt.Errorf("invalid client UUID")
+	}
+
+	// 确保更新的字段不为空
+	if len(updates) == 0 {
+		return fmt.Errorf("no fields to update")
+	}
+
+	updates["updated_at"] = time.Now()
+
+	err := db.Model(&models.Client{}).Where("uuid = ?", clientUUID).Updates(updates).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}

database/clipboard/clipboard.go

@@ -0,0 +1,58 @@
+package clipboard
+
+import (
+	"github.com/komari-monitor/komari/database/dbcore"
+	"github.com/komari-monitor/komari/database/models"
+)
+
+// CreateClipboard 创建剪贴板记录
+func CreateClipboard(cb *models.Clipboard) error {
+	db := dbcore.GetDBInstance()
+	return db.Create(cb).Error
+}
+
+// GetClipboardByID 根据ID获取剪贴板记录
+func GetClipboardByID(id int) (*models.Clipboard, error) {
+	var cb models.Clipboard
+	db := dbcore.GetDBInstance()
+	if err := db.First(&cb, id).Error; err != nil {
+		return nil, err
+	}
+	return &cb, nil
+}
+
+// UpdateClipboardFields 更新剪贴板记录
+func UpdateClipboardFields(id int, fields map[string]interface{}) error {
+	db := dbcore.GetDBInstance()
+	return db.Model(&models.Clipboard{}).Where("id = ?", id).Updates(fields).Error
+}
+
+// DeleteClipboard 删除剪贴板记录
+func DeleteClipboard(id int) error {
+	db := dbcore.GetDBInstance()
+	// Check if record exists first
+	var cb models.Clipboard
+	if err := db.First(&cb, id).Error; err != nil {
+		return err // Record not found or other error
+	}
+	return db.Delete(&cb).Error
+}
+
+// DeleteClipboardBatch 批量删除剪贴板记录
+func DeleteClipboardBatch(ids []int) error {
+	if len(ids) == 0 {
+		return nil
+	}
+	db := dbcore.GetDBInstance()
+	return db.Where("id IN ?", ids).Delete(&models.Clipboard{}).Error
+}
+
+// ListClipboard 列出所有剪贴板记录
+func ListClipboard() ([]models.Clipboard, error) {
+	var list []models.Clipboard
+	db := dbcore.GetDBInstance()
+	if err := db.Find(&list).Error; err != nil {
+		return nil, err
+	}
+	return list, nil
+}

database/config/config.go

@@ -1,6 +1,7 @@
 package config
 
 import (
+	"errors"
 	"log"
 	"time"
 
@@ -18,7 +19,7 @@ func Get() (models.Config, error) {
 				ID:            1,
 				Sitename:      "Komari",
 				Description:   "Komari Monitor, a simple server monitoring tool.",
-				AllowCros:     false,
+				AllowCors:     false,
 				OAuthEnabled:  false,
 				GeoIpEnabled:  true,
 				GeoIpProvider: "mmdb",
@@ -37,6 +38,7 @@ func Get() (models.Config, error) {
 
 func Save(cst models.Config) error {
 	db := dbcore.GetDBInstance()
+	oldConfig, _ := Get()
 	// Only one records
 	cst.ID = 1
 	cst.UpdatedAt = time.Now()
@@ -44,7 +46,7 @@ func Save(cst models.Config) error {
 	if err := db.Model(&models.Config{}).Where("id = ?", cst.ID).
 		Select("sitename",
 			"description",
-			"allow_cros",
+			"allow_cors",
 			"geo_ip_enabled",
 			"geo_ip_provider",
 			"o_auth_client_id",
@@ -55,18 +57,45 @@ func Save(cst models.Config) error {
 		Updates(cst).Error; err != nil {
 		return err
 	}
+	newConfig, _ := Get()
+	publishEvent(oldConfig, newConfig)
 	return nil
 }
 
 func Update(cst map[string]interface{}) error {
 	db := dbcore.GetDBInstance()
-
+	oldConfig, _ := Get()
 	// Proceed with update
 	cst["id"] = 1
 	cst["updated_at"] = time.Now()
 	delete(cst, "created_at")
 	delete(cst, "CreatedAt")
-	if err := db.Model(&models.Config{}).Where("id = ?", 1).Updates(cst).Error; err != nil {
+
+	// 至少有一种登录方式启用
+	newDisablePasswordLogin := oldConfig.DisablePasswordLogin
+	newOAuthEnabled := oldConfig.OAuthEnabled
+	if val, exists := cst["disable_password_login"]; exists {
+		newDisablePasswordLogin = val.(bool)
+	}
+	if val, exists := cst["o_auth_enabled"]; exists {
+		newOAuthEnabled = val.(bool)
+	}
+	if newDisablePasswordLogin && !newOAuthEnabled {
+		return errors.New("at least one login method must be enabled (password/oauth)")
+	}
+
+	err := db.Transaction(func(tx *gorm.DB) error {
+		if err := tx.Model(&models.Config{}).Where("id = ?", oldConfig.ID).Updates(cst).Error; err != nil {
+			return errors.Join(err, errors.New("failed to update configuration"))
+		}
+		newConfig := &models.Config{}
+		if err := tx.Where("id = ?", oldConfig.ID).First(newConfig).Error; err != nil {
+			return errors.Join(err, errors.New("failed to retrieve updated configuration"))
+		}
+		publishEvent(oldConfig, *newConfig)
+		return nil
+	})
+	if err != nil {
 		return err
 	}
 	return nil

database/config/events.go

@@ -0,0 +1,38 @@
+package config
+
+import (
+	"sync"
+
+	"github.com/komari-monitor/komari/database/models"
+)
+
+// ConfigEvent represents a configuration change event
+type ConfigEvent struct {
+	Old models.Config
+	New models.Config
+}
+
+// ConfigSubscriber handles config events
+type ConfigSubscriber func(event ConfigEvent)
+
+var (
+	subscribersMu sync.RWMutex
+	subscribers   []ConfigSubscriber
+)
+
+// Subscribe registers a subscriber for all config events.
+func Subscribe(subscriber ConfigSubscriber) {
+	subscribersMu.Lock()
+	defer subscribersMu.Unlock()
+	subscribers = append(subscribers, subscriber)
+}
+
+// publishEvent notifies all subscribers of a config change.
+func publishEvent(oldVal, newVal models.Config) {
+	subscribersMu.RLock()
+	defer subscribersMu.RUnlock()
+	event := ConfigEvent{Old: oldVal, New: newVal}
+	for _, sub := range subscribers {
+		go sub(event)
+	}
+}

database/dbcore/dbcore.go

@@ -3,18 +3,80 @@ package dbcore
 import (
 	"fmt"
 	"log"
-	"os"
-	"path/filepath"
 	"sync"
 
 	"github.com/komari-monitor/komari/cmd/flags"
 	"github.com/komari-monitor/komari/common"
 	"github.com/komari-monitor/komari/database/models"
+	"github.com/komari-monitor/komari/utils"
 	"gorm.io/driver/mysql"
 	"gorm.io/driver/sqlite"
 	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
 )
 
+// mergeClientInfo 将旧版ClientInfo数据迁移到新版Client表
+func mergeClientInfo(db *gorm.DB) {
+	var clientInfos []common.ClientInfo
+	if err := db.Find(&clientInfos).Error; err != nil {
+		log.Printf("Failed to read ClientInfo table: %v", err)
+		return
+	}
+
+	for _, info := range clientInfos {
+		var client models.Client
+		if err := db.Where("uuid = ?", info.UUID).First(&client).Error; err != nil {
+			log.Printf("Could not find Client record with UUID %s: %v", info.UUID, err)
+			continue
+		}
+
+		// 更新Client记录
+		client.Name = info.Name
+		client.CpuName = info.CpuName
+		client.Virtualization = info.Virtualization
+		client.Arch = info.Arch
+		client.CpuCores = info.CpuCores
+		client.OS = info.OS
+		client.GpuName = info.GpuName
+		client.IPv4 = info.IPv4
+		client.IPv6 = info.IPv6
+		client.Region = info.Region
+		client.Remark = info.Remark
+		client.PublicRemark = info.PublicRemark
+		client.MemTotal = info.MemTotal
+		client.SwapTotal = info.SwapTotal
+		client.DiskTotal = info.DiskTotal
+		client.Version = info.Version
+		client.Weight = info.Weight
+		client.Price = info.Price
+		client.BillingCycle = info.BillingCycle
+		client.ExpiredAt = info.ExpiredAt
+		// Save updated Client record
+		if err := db.Save(&client).Error; err != nil {
+			log.Printf("Failed to update Client record: %v", err)
+			continue
+		}
+	}
+
+	// Backup and rename old table after migration
+	if err := db.Migrator().RenameTable("client_infos", "client_infos_backup"); err != nil {
+		log.Printf("Failed to backup ClientInfo table: %v", err)
+		return
+	}
+	log.Println("Data migration completed, old table has been backed up as client_infos_backup")
+}
+
+func MergeDatabase(db *gorm.DB) {
+	if db.Migrator().HasTable("client_infos") {
+		log.Println("[>0.0.5] Legacy ClientInfo table detected, starting data migration...")
+		mergeClientInfo(db)
+	}
+	if db.Migrator().HasColumn(&models.Config{}, "allow_cros") {
+		log.Println("[>0.0.5a] Renaming column 'allow_cros' to 'allow_cors' in config table...")
+		db.Migrator().RenameColumn(&models.Config{}, "allow_cros", "allow_cors")
+	}
+}
+
 var (
 	instance *gorm.DB
 	once     sync.Once
@@ -23,46 +85,52 @@ var (
 // 初始化数据库
 // 对于 SQLite：true 如果数据库文件存在，false 如果数据库文件不存在并被创建
 // 对于 MySQL/其他数据库：总是返回 true
-func InitDatabase() bool {
-	// 默认使用 SQLite 如果未指定类型
-	if flags.DatabaseType == "" || flags.DatabaseType == "sqlite" {
-		if _, err := os.Stat(flags.DatabaseFile); os.IsNotExist(err) {
-			log.Printf("SQLite database file %q does not exist, creating...", flags.DatabaseFile)
-			dbDir := filepath.Dir(flags.DatabaseFile)
-			if dbDir != "" {
-				if err := os.MkdirAll(dbDir, 0755); err != nil {
-					log.Fatalf("Failed to create database file directory %q: %v", dbDir, err)
-				}
-			}
-			file, err := os.Create(flags.DatabaseFile)
-			if err != nil {
-				log.Fatalf("Failed to create SQLite database file %q: %v", flags.DatabaseFile, err)
-			}
-			if err := file.Close(); err != nil {
-				log.Fatalf("Failed to close database file %q: %v", flags.DatabaseFile, err)
-			}
-			return false
-		} else if err != nil {
-			log.Fatalf("Failed to check database file %q: %v", flags.DatabaseFile, err)
-		}
-		return true
-	} else if flags.DatabaseType == "mysql" {
-		// 对于 MySQL，我们不需要创建文件，只需检查连接信息是否有效
-		log.Printf("Using MySQL database: %s@%s:%s/%s",
-			flags.DatabaseUser, flags.DatabaseHost, flags.DatabasePort, flags.DatabaseName)
-		return true
-	} else {
-		log.Fatalf("Unsupported database type: %s", flags.DatabaseType)
-		return false
-	}
-}
+// func InitDatabase() bool {
+// 	// 默认使用 SQLite 如果未指定类型
+// 	if flags.DatabaseType == "" || flags.DatabaseType == "sqlite" {
+// 		if _, err := os.Stat(flags.DatabaseFile); os.IsNotExist(err) {
+// 			log.Printf("SQLite database file %q does not exist, creating...", flags.DatabaseFile)
+// 			dbDir := filepath.Dir(flags.DatabaseFile)
+// 			if dbDir != "" {
+// 				if err := os.MkdirAll(dbDir, 0755); err != nil {
+// 					log.Fatalf("Failed to create database file directory %q: %v", dbDir, err)
+// 				}
+// 			}
+// 			file, err := os.Create(flags.DatabaseFile)
+// 			if err != nil {
+// 				log.Fatalf("Failed to create SQLite database file %q: %v", flags.DatabaseFile, err)
+// 			}
+// 			if err := file.Close(); err != nil {
+// 				log.Fatalf("Failed to close database file %q: %v", flags.DatabaseFile, err)
+// 			}
+// 			return false
+// 		} else if err != nil {
+// 			log.Fatalf("Failed to check database file %q: %v", flags.DatabaseFile, err)
+// 		}
+// 		return true
+// 	} else if flags.DatabaseType == "mysql" {
+// 		// 对于 MySQL，我们不需要创建文件，只需检查连接信息是否有效
+// 		log.Printf("Using MySQL database: %s@%s:%s/%s",
+// 			flags.DatabaseUser, flags.DatabaseHost, flags.DatabasePort, flags.DatabaseName)
+// 		return true
+// 	} else {
+// 		log.Fatalf("Unsupported database type: %s", flags.DatabaseType)
+// 		return false
+// 	}
+// }
 
 func GetDBInstance() *gorm.DB {
 	once.Do(func() {
 		var err error
 
 		logConfig := &gorm.Config{
-			//Logger: logger.Default.LogMode(logger.Silent),
+			Logger: logger.Default.LogMode(logger.Silent),
+		}
+
+		if utils.VersionHash == "unknown" {
+			logConfig = &gorm.Config{
+				Logger: logger.Default.LogMode(logger.Info),
+			}
 		}
 
 		// 根据数据库类型选择不同的连接方式
@@ -77,7 +145,7 @@ func GetDBInstance() *gorm.DB {
 
 		case "mysql":
 			// MySQL 连接
-			dsn := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8mb4&parseTime=True&loc=Local",
+			dsn := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8mb4&collation=utf8mb4_unicode_ci&parseTime=True&loc=Local",
 				flags.DatabaseUser,
 				flags.DatabasePass,
 				flags.DatabaseHost,
@@ -92,15 +160,17 @@ func GetDBInstance() *gorm.DB {
 		default:
 			log.Fatalf("Unsupported database type: %s", flags.DatabaseType)
 		}
-
+		MergeDatabase(instance)
 		// 自动迁移模型
 		err = instance.AutoMigrate(
 			&models.User{},
 			&models.Client{},
-			// &models.Session{}, Error 1061 (42000): Duplicate key name 'idx_sessions_session'
 			&models.Record{},
-			&common.ClientInfo{},
 			&models.Config{},
+			&models.Log{},
+			&models.Clipboard{},
+			&models.LoadNotification{},
+			&models.OfflineNotification{},
 		)
 		if err != nil {
 			log.Fatalf("Failed to create tables: %v", err)
@@ -111,6 +181,14 @@ func GetDBInstance() *gorm.DB {
 		if err != nil {
 			log.Printf("Failed to create Session table, it may already exist: %v", err)
 		}
+		err = instance.AutoMigrate(
+			&models.Task{},
+			&models.TaskResult{},
+		)
+		if err != nil {
+			log.Printf("Failed to create Task and TaskResult table, it may already exist: %v", err)
+		}
+
 	})
 	return instance
 }

database/logOperation/log.go

@@ -0,0 +1,31 @@
+package logOperation
+
+import (
+	"log"
+	"time"
+
+	"github.com/komari-monitor/komari/database/dbcore"
+	"github.com/komari-monitor/komari/database/models"
+)
+
+func Log(ip, uuid, message, msgType string) {
+	now := time.Now()
+	db := dbcore.GetDBInstance()
+	logEntry := &models.Log{
+		IP:      ip,
+		UUID:    uuid,
+		Message: message,
+		MsgType: msgType,
+		Time:    now,
+	}
+	db.Create(logEntry)
+}
+
+// Delete logs older than 30 days
+func RemoveOldLogs() {
+	db := dbcore.GetDBInstance()
+	threshold := time.Now().AddDate(0, 0, -30)
+	if err := db.Where("time < ?", threshold).Delete(&models.Log{}).Error; err != nil {
+		log.Println("Failed to remove old logs:", err)
+	}
+}

database/models/clipboard.go

@@ -0,0 +1,13 @@
+package models
+
+import "time"
+
+type Clipboard struct {
+	Id        int       `json:"id" gorm:"primaryKey;autoIncrement;unique"`
+	Text      string    `json:"text" gorm:"type:longtext"`
+	Name      string    `json:"name" gorm:"type:varchar(255)"`
+	Weight    int       `json:"weight" gorm:"type:int"`
+	Remark    string    `json:"remark" gorm:"type:text"`
+	CreatedAt time.Time `json:"created_at"`
+	UpdatedAt time.Time `json:"updated_at"`
+}

database/models/config.go

@@ -0,0 +1,30 @@
+package models
+
+import "time"
+
+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"`
+	// GeoIP 配置
+	GeoIpEnabled  bool   `json:"geo_ip_enabled" gorm:"default:true"`
+	GeoIpProvider string `json:"geo_ip_provider" gorm:"type:varchar(20);default:'mmdb'"` // mmdb, bilibili, ip-api. 暂时只实现了mmdb
+	// OAuth 配置
+	OAuthClientID        string `json:"o_auth_client_id" gorm:"type:varchar(255)"`
+	OAuthClientSecret    string `json:"o_auth_client_secret" gorm:"type:varchar(255)"`
+	OAuthEnabled         bool   `json:"o_auth_enabled" gorm:"default:false"`
+	DisablePasswordLogin bool   `json:"disable_password_login" gorm:"default:false"`
+	// 自定义美化
+	CustomHead string `json:"custom_head" gorm:"type:longtext"`
+	CustomBody string `json:"custom_body" gorm:"type:longtext"`
+	// Telegram Bot 配置
+	TelegramEnabled  bool   `json:"telegram_enabled" gorm:"default:false"`
+	TelegramEndpoint string `json:"telegram_endpoint" gorm:"type:varchar(255);default:'https://api.telegram.org/bot'"`
+	TelegramBotToken string `json:"telegram_bot_token" gorm:"type:varchar(255)"`
+	TelegramChatID   string `json:"telegram_chat_id" gorm:"type:varchar(255)"`
+	// 通知
+	NotificationEnabled bool `json:"notification_enabled" gorm:"default:false"` // 通知总开关
+	CreatedAt           time.Time
+	UpdatedAt           time.Time
+}

database/models/log.go

@@ -0,0 +1,12 @@
+package models
+
+import "time"
+
+type Log struct {
+	ID      uint      `json:"id,omitempty" gorm:"primaryKey;autoIncrement"`
+	IP      string    `json:"ip" gorm:"type:varchar(45);"` // IPv4 or IPv6
+	UUID    string    `json:"uuid" gorm:"type:varchar(36);"`
+	Message string    `json:"message" gorm:"type:text;not null"`
+	MsgType string    `json:"msg_type" gorm:"type:varchar(20);not null"`
+	Time    time.Time `json:"time" gorm:"autoCreateTime;not null"`
+}

database/models/models.go

@@ -6,10 +6,31 @@ 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"`
-	CreatedAt time.Time `json:"created_at"`
-	UpdatedAt time.Time `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)"`
+	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"`
+	Currency       string    `json:"currency" gorm:"type:varchar(20);default:'$'"`
+	ExpiredAt      time.Time `json:"expired_at" gorm:"type:timestamp"`
+	CreatedAt      time.Time `json:"created_at"`
+	UpdatedAt      time.Time `json:"updated_at"`
 }
 
 // User represents an authenticated user
@@ -19,16 +40,23 @@ type User struct {
 	Passwd    string    `json:"passwd,omitempty" gorm:"type:varchar(255);not null"` // Hashed password
 	SSOType   string    `json:"sso_type" gorm:"type:varchar(20)"`                   // e.g., "github", "google"
 	SSOID     string    `json:"sso_id" gorm:"type:varchar(100)"`                    // OAuth provider's user ID
+	TwoFactor string    `json:"two_factor,omitempty" gorm:"type:varchar(255)"`      // 2FA secret
 	CreatedAt time.Time `json:"created_at"`
 	UpdatedAt time.Time `json:"updated_at"`
 }
 
 // Session manages user sessions
 type Session struct {
-	UUID      string    `gorm:"type:varchar(36);foreignKey:UserUUID;references:UUID;constraint:OnDelete:CASCADE"`
-	Session   string    `gorm:"type:varchar(255);uniqueIndex:idx_sessions_session;not null"`
-	Expires   time.Time `gorm:"not null"`
-	CreatedAt time.Time
+	UUID            string    `json:"uuid" gorm:"type:varchar(36);foreignKey:UserUUID;references:UUID;constraint:OnDelete:CASCADE"`
+	Session         string    `json:"session" gorm:"type:varchar(255);uniqueIndex:idx_sessions_session;not null"`
+	UserAgent       string    `json:"user_agent" gorm:"type:text"`
+	Ip              string    `json:"ip" gorm:"type:varchar(100)"`
+	LoginMethod     string    `json:"login_method" gorm:"type:varchar(50)"`
+	LatestOnline    time.Time `json:"latest_online" gorm:"type:timestamp"`
+	LatestUserAgent string    `json:"latest_user_agent" gorm:"type:text"`
+	LatestIp        string    `json:"latest_ip" gorm:"type:varchar(100)"`
+	Expires         time.Time `json:"expires" gorm:"not null"`
+	CreatedAt       time.Time `json:"created_at"`
 }
 
 // Record logs client metrics over time
@@ -53,22 +81,3 @@ type Record struct {
 	Connections    int       `json:"connections"`
 	ConnectionsUdp int       `json:"connections_udp"`
 }
-
-// Config stores site-wide settings
-type Config struct {
-	ID          uint   `json:"id,omitempty" gorm:"primaryKey;autoIncrement"`
-	Sitename    string `json:"sitename" gorm:"type:varchar(100);not null"`
-	Description string `json:"description" gorm:"type:text"`
-	AllowCros   bool   `json:"allow_cros" gorm:"default:false"`
-	// GeoIP 配置
-	GeoIpEnabled  bool   `json:"geo_ip_enabled" gorm:"default:true"`
-	GeoIpProvider string `json:"geo_ip_provider" gorm:"type:varchar(20);default:'mmdb'"` // mmdb, bilibili, ip-api. 暂时只实现了mmdb
-	// OAuth 配置
-	OAuthClientID     string `json:"o_auth_client_id" gorm:"type:varchar(255);not null"`
-	OAuthClientSecret string `json:"o_auth_client_secret" gorm:"type:varchar(255);not null"`
-	OAuthEnabled      bool   `json:"o_auth_enabled" gorm:"default:false"`
-	// 自定义美化
-	CustomHead string `json:"custom_head" gorm:"type:longtext"`
-	CreatedAt  time.Time
-	UpdatedAt  time.Time
-}

database/models/notification.go

@@ -0,0 +1,20 @@
+package models
+
+// Notification 定义了通知相关的数据库模型
+type OfflineNotification struct {
+	Client      string `json:"client" gorm:"type:varchar(36);not null;index;unique;constraint:OnDelete:CASCADE"`
+	Enable      bool   `json:"enable" gorm:"type:boolean;default:false"`
+	Cooldown    int    `json:"cooldown" gorm:"type:int;not null;default:1800"`    // 冷却时间（秒），默认 30 分钟
+	GracePeriod int    `json:"grace_period" gorm:"type:int;not null;default:180"` // 宽限期（秒），默认 3 分钟
+}
+
+// LoadNotification 定义了基于资源占用达标时间比的负载通知规则
+type LoadNotification struct {
+	Client    string  `json:"client" gorm:"type:varchar(36);not null;index;constraint:OnDelete:CASCADE"`
+	Enable    bool    `json:"enable" gorm:"type:boolean;default:false"`
+	Metric    string  `json:"metric" gorm:"type:varchar(50);not null;default:'cpu'"`     // 监控指标，如 cpu, ram, load
+	Threshold float32 `json:"threshold" gorm:"type:decimal(5,2);not null;default:80.00"` // 阈值百分比
+	Window    int     `json:"window" gorm:"type:int;not null;default:300"`               // 观测窗口（秒）
+	Ratio     float32 `json:"ratio" gorm:"type:decimal(5,2);not null;default:0.80"`      // 达标时间比
+	Cooldown  int     `json:"cooldown" gorm:"type:int;not null;default:1800"`            // 冷却时间（秒）
+}

database/models/task.go

@@ -0,0 +1,37 @@
+package models
+
+import (
+	"database/sql/driver"
+	"encoding/json"
+	"fmt"
+	"time"
+)
+
+// StringArray represents a slice of strings stored as JSON in the database
+type StringArray []string
+
+func (sa *StringArray) Scan(value interface{}) error {
+	bytes, ok := value.([]byte)
+	if !ok {
+		return fmt.Errorf("failed to scan StringArray: value is not []byte")
+	}
+	return json.Unmarshal(bytes, sa)
+}
+
+func (sa StringArray) Value() (driver.Value, error) {
+	return json.Marshal(sa)
+}
+
+type Task struct {
+	TaskId  string      `json:"task_id" gorm:"type:varchar(36);primaryKey;unique"`
+	Clients StringArray `json:"clients" gorm:"type:longtext"`
+	Command string      `json:"command" gorm:"type:text"`
+}
+type TaskResult struct {
+	TaskId     string     `json:"task_id" gorm:"type:varchar(36)"`
+	Client     string     `json:"client" gorm:"type:varchar(36)"`
+	Result     string     `json:"result" gorm:"type:longtext"`
+	ExitCode   *int       `json:"exit_code" gorm:"type:int"`
+	FinishedAt *time.Time `json:"finished_at" gorm:"type:timestamp"`
+	CreatedAt  time.Time  `json:"created_at" gorm:"type:timestamp"`
+}

database/notification/offline.go

@@ -0,0 +1 @@
+package notification

database/records/records.go

@@ -69,7 +69,7 @@ func QuantileMean(values []float32) float32 {
 // 压缩数据库，针对每个ClientUUID，10分钟内的数据不动，24小时内的数据精简为每15分钟一条，3天为每30分钟一条，7天为每1小时一条，30天为每12小时一条。所有精简的数据是取 [0.02,0.98] 区间内的平均值
 func CompactRecord() error {
 	db := dbcore.GetDBInstance()
-	log.Printf("Compacting records...")
+	//log.Printf("Compacting records...")
 	var clientUUIDs []string
 	if err := db.Model(&models.Record{}).Distinct("client").Pluck("client", &clientUUIDs).Error; err != nil {
 		return err

database/tasks/tasks.go

@@ -0,0 +1,99 @@
+package tasks
+
+import (
+	"time"
+
+	"github.com/komari-monitor/komari/database/dbcore"
+	"github.com/komari-monitor/komari/database/models"
+)
+
+func CreateTask(taskId string, clients []string, command string) error {
+	db := dbcore.GetDBInstance()
+	// Create a new task in the database with clients as JSON array
+	task := models.Task{
+		TaskId:  taskId,
+		Clients: models.StringArray(clients),
+		Command: command,
+	}
+	if err := db.Create(&task).Error; err != nil {
+		return err
+	}
+	var taskResults []models.TaskResult
+	for _, client := range clients {
+		taskResults = append(taskResults, models.TaskResult{
+			TaskId:     taskId,
+			Client:     client,
+			Result:     "",
+			ExitCode:   nil,
+			FinishedAt: nil,
+			CreatedAt:  time.Now(),
+		})
+	}
+	if len(taskResults) > 0 {
+		return db.Create(&taskResults).Error
+	}
+	return nil
+}
+func GetTaskByTaskId(taskId string) (*models.Task, error) {
+	var task models.Task
+	if err := dbcore.GetDBInstance().Where("task_id = ?", taskId).First(&task).Error; err != nil {
+		return nil, err
+	}
+	return &task, nil
+}
+func GetTasksByClientId(clientId string) ([]models.Task, error) {
+	var tasks []models.Task
+	if err := dbcore.GetDBInstance().Where("clients LIKE ?", "%"+clientId+"%").Find(&tasks).Error; err != nil {
+		return nil, err
+	}
+	return tasks, nil
+}
+
+func GetSpecificTaskResult(taskId, clientId string) (*models.TaskResult, error) {
+	var result models.TaskResult
+	if err := dbcore.GetDBInstance().Where("task_id = ? AND client = ?", taskId, clientId).First(&result).Error; err != nil {
+		return nil, err
+	}
+	return &result, nil
+}
+
+func GetAllTasksResultByUUID(uuid string) ([]models.TaskResult, error) {
+	var results []models.TaskResult
+	if err := dbcore.GetDBInstance().Where("client = ?", uuid).Find(&results).Error; err != nil {
+		return nil, err
+	}
+	return results, nil
+}
+func GetAllTasks() ([]models.Task, error) {
+	var tasks []models.Task
+	if err := dbcore.GetDBInstance().Find(&tasks).Error; err != nil {
+		return nil, err
+	}
+	return tasks, nil
+}
+
+func GetTaskResultsByTaskId(taskId string) ([]models.TaskResult, error) {
+	var results []models.TaskResult
+	if err := dbcore.GetDBInstance().Where("task_id = ?", taskId).Find(&results).Error; err != nil {
+		return nil, err
+	}
+	return results, nil
+}
+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 {
+	return dbcore.GetDBInstance().
+		Model(&models.TaskResult{}).
+		Where("task_id = ? AND client = ?", taskId, clientId).
+		Updates(map[string]interface{}{
+			"result":      result,
+			"exit_code":   exitCode,
+			"finished_at": timestamp,
+		}).Error
+}
+
+func ClearTaskResultsByTimeBefore(before time.Time) error {
+	return dbcore.GetDBInstance().Where("created_at < ?", before.Format(time.RFC3339)).Delete(&models.TaskResult{}).Error
+}

go.mod

@@ -3,11 +3,11 @@ module github.com/komari-monitor/komari
 go 1.23.2
 
 require (
-	github.com/gin-contrib/cors v1.7.5
 	github.com/gin-gonic/gin v1.10.0
 	github.com/google/uuid v1.6.0
 	github.com/gorilla/websocket v1.5.3
 	github.com/oschwald/maxminddb-golang v1.13.1
+	github.com/pquerna/otp v1.5.0
 	github.com/spf13/cobra v1.9.1
 	github.com/stretchr/testify v1.10.0
 	gorm.io/driver/mysql v1.5.7
@@ -26,6 +26,7 @@ require golang.org/x/net v0.39.0 // indirect
 
 require (
 	filippo.io/edwards25519 v1.1.0 // indirect
+	github.com/boombuler/barcode v1.0.1-0.20190219062509-6c824513bacc // indirect
 	github.com/bytedance/sonic v1.13.2 // indirect
 	github.com/bytedance/sonic/loader v0.2.4 // indirect
 	github.com/cloudwego/base64x v0.1.5 // indirect
@@ -43,7 +44,7 @@ require (
 	github.com/jinzhu/now v1.1.5 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
 	github.com/klauspost/cpuid/v2 v2.2.10 // indirect
-	github.com/kr/text v0.2.0 // indirect
+	github.com/kr/pretty v0.3.0 // indirect
 	github.com/leodido/go-urn v1.4.0 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-sqlite3 v1.14.27 // indirect
@@ -51,6 +52,7 @@ require (
 	github.com/modern-go/reflect2 v1.0.2 // indirect
 	github.com/pelletier/go-toml/v2 v2.2.3 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/rogpeppe/go-internal v1.8.0 // indirect
 	github.com/spf13/pflag v1.0.6 // indirect
 	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
 	github.com/ugorji/go/codec v1.2.12 // indirect
@@ -58,5 +60,6 @@ require (
 	golang.org/x/sys v0.32.0 // indirect
 	golang.org/x/text v0.25.0 // indirect
 	google.golang.org/protobuf v1.36.6 // indirect
+	gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -1,5 +1,7 @@
 filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
 filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
+github.com/boombuler/barcode v1.0.1-0.20190219062509-6c824513bacc h1:biVzkmvwrH8WK8raXaxBx6fRVTlJILwEwQGL1I/ByEI=
+github.com/boombuler/barcode v1.0.1-0.20190219062509-6c824513bacc/go.mod h1:paBWMcWSl3LHKBqUq+rly7CNSldXjb2rDl3JlRe0mD8=
 github.com/bytedance/sonic v1.13.2 h1:8/H1FempDZqC4VqjptGo14QQlJx8VdZJegxs6wwfqpQ=
 github.com/bytedance/sonic v1.13.2/go.mod h1:o68xyaF9u2gvVBuGHPlUVCy+ZfmNNO5ETf1+KgkJhz4=
 github.com/bytedance/sonic/loader v0.1.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
@@ -15,8 +17,6 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/gabriel-vasile/mimetype v1.4.8 h1:FfZ3gj38NjllZIeJAmMhr+qKL8Wu+nOoI3GqacKw1NM=
 github.com/gabriel-vasile/mimetype v1.4.8/go.mod h1:ByKUIKGjh1ODkGM1asKUbQZOLGrPjydw3hYPU2YU9t8=
-github.com/gin-contrib/cors v1.7.5 h1:cXC9SmofOrRg0w9PigwGlHG3ztswH6bqq4vJVXnvYMk=
-github.com/gin-contrib/cors v1.7.5/go.mod h1:4q3yi7xBEDDWKapjT2o1V7mScKDDr8k+jZ0fSquGoy0=
 github.com/gin-contrib/sse v1.0.0 h1:y3bT1mUWUxDpW4JLQg/HnTqV4rozuW4tC9eFKTxYI9E=
 github.com/gin-contrib/sse v1.0.0/go.mod h1:zNuFdwarAygJBht0NTKiSi3jRf6RbqeILZ9Sp6Slhe0=
 github.com/gin-gonic/gin v1.10.0 h1:nTuyha1TYqgedzytsKYqna+DfLos46nTv2ygFy86HFU=
@@ -53,8 +53,12 @@ github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa02
 github.com/klauspost/cpuid/v2 v2.2.10 h1:tBs3QSyvjDyFTq3uoc/9xFpCuOsJQFNPiAhYdw2skhE=
 github.com/klauspost/cpuid/v2 v2.2.10/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
 github.com/knz/go-libedit v1.10.1/go.mod h1:MZTVkCWyz0oBc7JOWP3wNAzd002ZbM/5hgShxwh4x8M=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
 github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0=
 github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
@@ -72,8 +76,12 @@ github.com/oschwald/maxminddb-golang v1.13.1 h1:G3wwjdN9JmIK2o/ermkHM+98oX5fS+k5
 github.com/oschwald/maxminddb-golang v1.13.1/go.mod h1:K4pgV9N/GcK694KSTmVSDTODk4IsCNThNdTmnaBZ/F8=
 github.com/pelletier/go-toml/v2 v2.2.3 h1:YmeHyLY8mFWbdkNWwpr+qIL2bEqT0o95WSdkNHvL12M=
 github.com/pelletier/go-toml/v2 v2.2.3/go.mod h1:MfCQTFTvCcUyyvvwm1+G6H/jORL20Xlb6rzQu9GuUkc=
+github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/pquerna/otp v1.5.0 h1:NMMR+WrmaqXU4EzdGJEE1aUUI0AMRzsp96fFFWNPwxs=
+github.com/pquerna/otp v1.5.0/go.mod h1:dkJfzwRKNiegxyNb54X/3fLwhCynbMspSyWKnvi1AEg=
+github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
 github.com/rogpeppe/go-internal v1.8.0 h1:FCbCCtXNOY3UtUuHUYaghJg4y7Fd14rXifAYUAtL9R8=
 github.com/rogpeppe/go-internal v1.8.0/go.mod h1:WmiCO8CzOY8rg0OYDC4/i/2WRWAB6poM+XZ2dLUbcbE=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
@@ -111,8 +119,10 @@ golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
 google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY=
 google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
+gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

main.go

@@ -1,9 +1,13 @@
 package main
 
 import (
+	"log"
+
 	"github.com/komari-monitor/komari/cmd"
+	"github.com/komari-monitor/komari/utils"
 )
 
 func main() {
+	log.Printf("Komari Monitor %s (hash: %s)", utils.CurrentVersion, utils.VersionHash)
 	cmd.Execute()
 }

public/public.go

@@ -8,6 +8,7 @@ import (
 	"io/fs"
 	"log"
 	"net/http"
+	"os" // added for file existence check
 	"strings"
 
 	"github.com/gin-gonic/gin"
@@ -47,11 +48,14 @@ func initIndex() {
 }
 func UpdateIndex(cfg models.Config) {
 	replaceMap := map[string]string{
-		"<!-- customize head -->": cfg.CustomHead,
+		"</head>": cfg.CustomHead + "</head>",
+		"</body>": cfg.CustomBody + "</body>",
 	}
+	updated := RawIndexFile
 	for k, v := range replaceMap {
-		IndexFile = strings.Replace(RawIndexFile, k, v, 1)
+		updated = strings.Replace(updated, k, v, 1)
 	}
+	IndexFile = updated
 }
 
 func Static(r *gin.RouterGroup, noRoute func(handlers ...gin.HandlerFunc)) {
@@ -71,6 +75,25 @@ func Static(r *gin.RouterGroup, noRoute func(handlers ...gin.HandlerFunc)) {
 		}
 		r.StaticFS(fmt.Sprintf("/%s/", folders[i]), http.FS(sub))
 	}
+	// Serve favicon.ico: use local file if exists, fallback to embedded
+	r.GET("/favicon.ico", func(c *gin.Context) {
+		if _, err := os.Stat("data/favicon.ico"); err == nil {
+			c.File("data/favicon.ico")
+			return
+		}
+		f, err := DistFS.Open("favicon.ico")
+		if err != nil {
+			c.Status(http.StatusNotFound)
+			return
+		}
+		defer f.Close()
+		data, err := io.ReadAll(f)
+		if err != nil {
+			c.Status(http.StatusInternalServerError)
+			return
+		}
+		c.Data(http.StatusOK, "image/x-icon", data)
+	})
 
 	noRoute(func(c *gin.Context) {
 		if c.Request.Method != "GET" && c.Request.Method != "POST" {

todo.md

@@ -6,9 +6,9 @@
 
 - [x] Web终端
 
-- [ ] 一键部署脚本
+- [x] 一键部署脚本
 
-- [ ] 远程命令执行
+- [x] 远程命令执行
 
 ## Serser
 
@@ -20,7 +20,7 @@
 
 - [x] 命令行指令 chpasswd 强制更换密码
 
-- [ ] Github单点登录、绑定、解绑
+- [x] Github单点登录、绑定、解绑
 
 - [ ] 2FA
 

utils/geoip/geoip.go

@@ -15,7 +15,7 @@ import (
 )
 
 var (
-	GeoIpUrl                        = "https://gh-proxy.com/raw.githubusercontent.com/Loyalsoldier/geoip/release/GeoLite2-Country.mmdb"
+	GeoIpUrl                        = "https://raw.githubusercontent.com/Loyalsoldier/geoip/release/GeoLite2-Country.mmdb"
 	GeoIpFilePath                   = "./data/GeoLite2-Country.mmdb"
 	geoIpDb       *maxminddb.Reader = nil
 	lock                            = &sync.RWMutex{}

utils/notification/offline.go

@@ -0,0 +1,149 @@
+package notification
+
+import (
+	"fmt"
+	"log"
+	"sync"
+	"time"
+
+	"github.com/komari-monitor/komari/database/clients"
+	"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/telegram"
+)
+
+var (
+	lastNotified       = make(map[string]time.Time)
+	lastOnlineNotified = make(map[string]time.Time)
+	pendingOffline     = make(map[string]time.Time)
+
+	mu sync.Mutex
+)
+
+// OfflineNotification sends an offline notification for the client if enabled and not sent in cooldown period
+func OfflineNotification(clientID string) {
+	client, err := clients.GetClientByUUID(clientID)
+	if err != nil {
+		return
+	}
+	now := time.Now()
+
+	conf, _ := config.Get()
+	if !conf.NotificationEnabled {
+		return
+	}
+
+	noti_conf := models.OfflineNotification{
+		Client: clientID,
+	}
+
+	db := dbcore.GetDBInstance()
+	err = db.Model(&models.OfflineNotification{}).Where("client = ?", clientID).FirstOrCreate(&noti_conf).Error
+	if err != nil {
+		log.Println("Failed to get or create offline notification config:", err)
+		return
+	}
+	if !noti_conf.Enable {
+		return
+	}
+
+	cooldownDuration := time.Duration(noti_conf.Cooldown) * time.Second
+	gracePeriod := time.Duration(noti_conf.GracePeriod) * time.Second
+	if cooldownDuration <= 0 {
+		cooldownDuration = 30 * time.Minute // default cooldown if not set
+	}
+	if gracePeriod <= 0 {
+		gracePeriod = 5 * time.Minute // default grace period if not set
+	}
+
+	mu.Lock()
+	if _, exists := pendingOffline[clientID]; exists {
+		mu.Unlock()
+		return
+	}
+	pendingOffline[clientID] = now
+	mu.Unlock()
+
+	go func(start time.Time) {
+		time.Sleep(gracePeriod)
+		mu.Lock()
+		defer mu.Unlock()
+		// if no longer pending (client reconnected), skip
+		if ts, ok := pendingOffline[clientID]; !ok || !ts.Equal(start) {
+			return
+		}
+		// check cooldown
+		if last, ok := lastNotified[clientID]; ok && time.Since(last) < cooldownDuration {
+			delete(pendingOffline, clientID)
+			return
+		}
+		// record notification time and clear pending
+		lastNotified[clientID] = time.Now()
+		delete(pendingOffline, clientID)
+
+		message := fmt.Sprintf("🔴<code>%s</code> is offline", client.Name)
+		go func(msg string) {
+			if err := telegram.SendHTMLMessage(msg); err != nil {
+				log.Println("Failed to send offline notification:", err)
+			}
+		}(message)
+	}(now)
+}
+
+// OnlineNotification sends an online notification for the client if enabled and not sent in cooldown period
+func OnlineNotification(clientID string) {
+	client, err := clients.GetClientByUUID(clientID)
+	if err != nil {
+		return
+	}
+	noti_conf := models.OfflineNotification{
+		Client: clientID,
+	}
+
+	db := dbcore.GetDBInstance()
+	err = db.Model(&models.OfflineNotification{}).Where("client = ?", clientID).FirstOrCreate(&noti_conf).Error
+	if err != nil {
+		log.Println("Failed to get or create offline notification config:", err)
+		return
+	}
+	if !noti_conf.Enable {
+		return
+	}
+	cooldownDuration := time.Duration(noti_conf.Cooldown) * time.Second
+	gracePeriod := time.Duration(noti_conf.GracePeriod) * time.Second
+	if cooldownDuration <= 0 {
+		cooldownDuration = 30 * time.Minute // default cooldown if not set
+	}
+	if gracePeriod <= 0 {
+		gracePeriod = 5 * time.Minute // default grace period if not set
+	}
+	// clear any pending offline debounce
+	mu.Lock()
+	delete(pendingOffline, clientID)
+	mu.Unlock()
+
+	now := time.Now()
+
+	mu.Lock()
+	defer mu.Unlock()
+
+	// if never went offline before, skip first online notification
+	if _, wasOffline := lastNotified[clientID]; !wasOffline {
+		return
+	}
+	// cooldown for online notifications
+	if last, exists := lastOnlineNotified[clientID]; exists && now.Sub(last) < cooldownDuration {
+		return
+	}
+	// send online notification
+	message := fmt.Sprintf("🟢<code>%s</code> is online", client.Name)
+	go func(msg string) {
+		if err := telegram.SendHTMLMessage(msg); err != nil {
+			log.Println("Failed to send online notification:", err)
+		}
+	}(message)
+
+	lastOnlineNotified[clientID] = now
+	delete(lastNotified, clientID)
+}

utils/telegram/telegram.go

@@ -0,0 +1,76 @@
+package telegram
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"net/url"
+
+	"github.com/komari-monitor/komari/database/config"
+)
+
+func SendMessage(message, msgType string) error {
+	var lastErr error
+	for i := 0; i < 3; i++ {
+		conf, err := config.Get()
+		if err != nil {
+			lastErr = err
+			continue
+		}
+
+		if !conf.TelegramEnabled || message == "" {
+			return errors.New("telegram is disabled or message is empty")
+		}
+
+		endpoint := conf.TelegramEndpoint + conf.TelegramBotToken + "/sendMessage"
+
+		data := url.Values{}
+		data.Set("chat_id", conf.TelegramChatID)
+		data.Set("text", message)
+		if msgType != "text" {
+			data.Set("parse_mode", msgType)
+		}
+		resp, err := http.PostForm(endpoint, data)
+		if err != nil {
+			lastErr = fmt.Errorf("failed to send message: %v", err)
+			continue
+		}
+		defer resp.Body.Close()
+
+		if resp.StatusCode != http.StatusOK {
+			lastErr = fmt.Errorf("telegram API returned non-OK status: %d", resp.StatusCode)
+			continue
+		}
+
+		var result struct {
+			Ok          bool   `json:"ok"`
+			Description string `json:"description"`
+		}
+		if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+			lastErr = err
+			continue
+		}
+
+		if !result.Ok {
+			lastErr = fmt.Errorf("telegram API error: %s", result.Description)
+			continue
+		}
+
+		return nil
+	}
+	return lastErr
+}
+
+// SendTextMessage sends a text message via Telegram API
+func SendTextMessage(message string) error {
+	return SendMessage(message, "text")
+}
+
+// SendMarkdownMessage sends a message formatted in Markdown via Telegram API
+func SendMarkdownMessage(message string) error {
+	return SendMessage(message, "MarkdownV2")
+}
+func SendHTMLMessage(message string) error {
+	return SendMessage(message, "HTML")
+}

utils/version.go

@@ -0,0 +1,6 @@
+package utils
+
+var (
+	CurrentVersion = "0.0.1"
+	VersionHash    = "unknown"
+)