Merge pull request #42 from komari-monitor/dev

feat: 添加2FA支持

README.md

@@ -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

@@ -5,6 +5,7 @@ import (
 
 	"github.com/gin-gonic/gin"
 	"github.com/komari-monitor/komari/database/clients"
+	"github.com/komari-monitor/komari/database/logOperation"
 	"github.com/komari-monitor/komari/database/records"
 )
 
@@ -15,7 +16,7 @@ func AddClient(c *gin.Context) {
 	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})
@@ -23,30 +24,33 @@ func AddClient(c *gin.Context) {
 	}
 	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
 	}
 	if uuid == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"status": "error", "error": "Invalid or missing UUID"})
+		c.JSON(http.StatusBadRequest, gin.H{"status": "error", "message": "Invalid or missing UUID"})
 		return
 	}
 	req["uuid"] = uuid
 	err := clients.SaveClient(req)
 	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
 	}
-
+	user_uuid, _ := c.Get("uuid")
+	logOperation.Log(c.ClientIP(), user_uuid.(string), "edit client:"+uuid, "info")
 	c.JSON(http.StatusOK, gin.H{"status": "success"})
 }
 
@@ -60,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"})
 }
 
@@ -78,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
 	}
@@ -87,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
 	}
@@ -99,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
 	}
 
@@ -110,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/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(&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/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/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/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, "sso_type": user.SSOType, "sso_id": user.SSOID})
+	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
 	}
 
@@ -22,5 +22,5 @@ func GetNodesInformation(c *gin.Context) {
 		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()

api/version.go

@@ -1,14 +0,0 @@
-package api
-
-import (
-	"github.com/gin-gonic/gin"
-	"github.com/komari-monitor/komari/utils"
-)
-
-func GetVersion(c *gin.Context) {
-	c.JSON(200, gin.H{
-		"version": utils.CurrentVersion,
-		"hash":    utils.VersionHash,
-		"status":  "success",
-	})
-}

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,74 @@
 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"
+	log_api "github.com/komari-monitor/komari/api/admin/log"
+	"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" {
@@ -86,10 +98,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)
@@ -124,21 +161,43 @@ 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)
 		}
 
 		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)
+		}
 
 	},
 }
@@ -173,7 +232,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))
@@ -183,11 +242,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")
+}

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/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,8 +3,6 @@ package dbcore
 import (
 	"fmt"
 	"log"
-	"os"
-	"path/filepath"
 	"sync"
 
 	"github.com/komari-monitor/komari/cmd/flags"
@@ -15,23 +13,18 @@ import (
 	"gorm.io/gorm"
 )
 
-// migrateClientData 将旧版ClientInfo数据迁移到新版Client表
-func migrateClientData(db *gorm.DB) {
-	log.Println("正在迁移旧版ClientInfo数据到新版Client表...")
-
-	// 读取所有ClientInfo记录
+// mergeClientInfo 将旧版ClientInfo数据迁移到新版Client表
+func mergeClientInfo(db *gorm.DB) {
 	var clientInfos []common.ClientInfo
 	if err := db.Find(&clientInfos).Error; err != nil {
-		log.Printf("读取ClientInfo表失败: %v", err)
+		log.Printf("Failed to read ClientInfo table: %v", err)
 		return
 	}
 
-	// 遍历每条记录并更新到Client表
 	for _, info := range clientInfos {
-		// 查找对应的Client记录
 		var client models.Client
 		if err := db.Where("uuid = ?", info.UUID).First(&client).Error; err != nil {
-			log.Printf("找不到UUID为%s的Client记录: %v", info.UUID, err)
+			log.Printf("Could not find Client record with UUID %s: %v", info.UUID, err)
 			continue
 		}
 
@@ -56,21 +49,30 @@ func migrateClientData(db *gorm.DB) {
 		client.Price = info.Price
 		client.BillingCycle = info.BillingCycle
 		client.ExpiredAt = info.ExpiredAt
-
-		// 保存更新后的Client记录
+		// Save updated Client record
 		if err := db.Save(&client).Error; err != nil {
-			log.Printf("更新Client记录失败: %v", err)
+			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("备份ClientInfo表失败: %v", err)
+		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")
+}
 
-	log.Println("数据迁移完成，旧表已备份为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 (
@@ -81,39 +83,39 @@ 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() {
@@ -150,15 +152,14 @@ func GetDBInstance() *gorm.DB {
 		default:
 			log.Fatalf("Unsupported database type: %s", flags.DatabaseType)
 		}
-		// 检查是否存在旧版ClientInfo表
-		hasOldClientInfoTable := instance.Migrator().HasTable(&common.ClientInfo{})
-
+		MergeDatabase(instance)
 		// 自动迁移模型
 		err = instance.AutoMigrate(
 			&models.User{},
 			&models.Client{},
 			&models.Record{},
 			&models.Config{},
+			&models.Log{},
 		)
 		if err != nil {
 			log.Fatalf("Failed to create tables: %v", err)
@@ -169,11 +170,14 @@ func GetDBInstance() *gorm.DB {
 		if err != nil {
 			log.Printf("Failed to create Session table, it may already exist: %v", err)
 		}
-
-		// 如果存在旧表，执行数据迁移
-		if hasOldClientInfoTable {
-			migrateClientData(instance)
+		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/config.go

@@ -0,0 +1,28 @@
+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)"`
+	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

@@ -39,16 +39,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
@@ -73,22 +80,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/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/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=

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/telegram/telegram.go

@@ -0,0 +1,67 @@
+package telegram
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"net/url"
+
+	"github.com/komari-monitor/komari/database/config"
+)
+
+func SendMessage(message, msgType string) error {
+	conf, err := config.Get()
+	if err != nil {
+		return err
+	}
+
+	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 {
+		return fmt.Errorf("failed to send message: %v", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("telegram API returned non-OK status: %d", resp.StatusCode)
+	}
+
+	var result struct {
+		Ok          bool   `json:"ok"`
+		Description string `json:"description"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return err
+	}
+
+	if !result.Ok {
+		return fmt.Errorf("telegram API error: %s", result.Description)
+	}
+
+	return nil
+}
+
+// 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")
+}