test(auth): remove obsolete dev cookie bypass coverage (#547)

Replace the legacy allow_cors setting with cors_origin_check_enabled
throughout server setup, public info output, and configuration constants.
This clarifies that the option controls API CORS origin validation rather
than broadly enabling CORS.

.github/workflows/build.yml

@@ -65,13 +65,20 @@ jobs:
 
       - name: Clone and build frontend
         run: |
-          git clone https://github.com/komari-monitor/komari-web web
-          cd web
+          git clone https://github.com/komari-monitor/komari-web komari-web
+          cd komari-web
           npm install
           npm run build
           cd ..
-          mkdir -p public/dist
-          cp -r web/dist/* public/dist/
+          mkdir -p web/public/defaultTheme/dist
+          rm -rf web/public/defaultTheme/dist/*
+          cp -r komari-web/dist/* web/public/defaultTheme/dist/
+          cp -f komari-web/komari-theme.json web/public/defaultTheme/
+          if [ -f komari-web/preview.png ]; then cp -f komari-web/preview.png web/public/defaultTheme/; fi
+          if [ -f komari-web/perview.png ]; then cp -f komari-web/perview.png web/public/defaultTheme/; fi
+          # Compatibility: ensure both filenames exist if only one is present
+          if [ -f web/public/defaultTheme/preview.png ] && [ ! -f web/public/defaultTheme/perview.png ]; then cp -f web/public/defaultTheme/preview.png web/public/defaultTheme/perview.png; fi
+          if [ -f web/public/defaultTheme/perview.png ] && [ ! -f web/public/defaultTheme/preview.png ]; then cp -f web/public/defaultTheme/perview.png web/public/defaultTheme/preview.png; fi
 
       - name: Set up Go
         uses: actions/setup-go@v5
@@ -101,7 +108,7 @@ jobs:
           fi
           VERSION="${{ github.sha }}"
           VERSION_HASH="${{ github.sha }}"
-          go build -trimpath -ldflags="-s -w -X github.com/komari-monitor/komari/internal/conf.Version=${VERSION} -X github.com/komari-monitor/komari/internal/conf.CommitHash=${VERSION_HASH}" -o $BINARY_NAME
+          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 as artifact
         uses: actions/upload-artifact@v4

.github/workflows/development.yml

@@ -1,9 +1,9 @@
 name: Development Environment
 
 on:
-  # push:
-  #   branches:
-  #     - dev
+  push:
+    branches:
+      - dev
   workflow_dispatch:
 
 jobs:
@@ -16,18 +16,25 @@ jobs:
 
       #- 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
+      #    mkdir -p web/public/defaultTheme/dist
+      #    echo "<html><body><h1>This is komari development server.</h1></body></html>" > web/public/defaultTheme/dist/index.html
 
       - name: Clone and build frontend
         run: |
-          git clone https://github.com/komari-monitor/komari-web web
-          cd web
+          git clone https://github.com/komari-monitor/komari-web komari-web
+          cd komari-web
           npm install
           npm run build
           cd ..
-          mkdir -p public/dist
-          cp -r web/dist/* public/dist/
+          mkdir -p web/public/defaultTheme/dist
+          rm -rf web/public/defaultTheme/dist/*
+          cp -r komari-web/dist/* web/public/defaultTheme/dist/
+          cp -f komari-web/komari-theme.json web/public/defaultTheme/
+          if [ -f komari-web/preview.png ]; then cp -f komari-web/preview.png web/public/defaultTheme/; fi
+          if [ -f komari-web/perview.png ]; then cp -f komari-web/perview.png web/public/defaultTheme/; fi
+          # Compatibility: ensure both filenames exist if only one is present
+          if [ -f web/public/defaultTheme/preview.png ] && [ ! -f web/public/defaultTheme/perview.png ]; then cp -f web/public/defaultTheme/preview.png web/public/defaultTheme/perview.png; fi
+          if [ -f web/public/defaultTheme/perview.png ] && [ ! -f web/public/defaultTheme/preview.png ]; then cp -f web/public/defaultTheme/perview.png web/public/defaultTheme/preview.png; fi
 
       - name: Set up Go
         uses: actions/setup-go@v5
@@ -40,7 +47,7 @@ jobs:
           GOARCH: amd64
         run: |
           VERSION_SHA="${{ github.sha }}"
-          go build -ldflags "-X github.com/komari-monitor/komari/internal/conf.Version=dev -X github.com/komari-monitor/komari/internal/conf.CommitHash=${VERSION_SHA}" -o komari .
+          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

.github/workflows/docker-publish.yml

@@ -28,13 +28,20 @@ jobs:
 
       - name: Clone and build frontend
         run: |
-          git clone https://github.com/komari-monitor/komari-web web
-          cd web
+          git clone https://github.com/komari-monitor/komari-web komari-web
+          cd komari-web
           npm install
           npm run build
           cd ..
-          mkdir -p public/dist
-          cp -r web/dist/* public/dist/
+          mkdir -p web/public/defaultTheme/dist
+          rm -rf web/public/defaultTheme/dist/*
+          cp -r komari-web/dist/* web/public/defaultTheme/dist/
+          cp -f komari-web/komari-theme.json web/public/defaultTheme/
+          if [ -f komari-web/preview.png ]; then cp -f komari-web/preview.png web/public/defaultTheme/; fi
+          if [ -f komari-web/perview.png ]; then cp -f komari-web/perview.png web/public/defaultTheme/; fi
+          # Compatibility: ensure both filenames exist if only one is present
+          if [ -f web/public/defaultTheme/preview.png ] && [ ! -f web/public/defaultTheme/perview.png ]; then cp -f web/public/defaultTheme/preview.png web/public/defaultTheme/perview.png; fi
+          if [ -f web/public/defaultTheme/perview.png ] && [ ! -f web/public/defaultTheme/preview.png ]; then cp -f web/public/defaultTheme/perview.png web/public/defaultTheme/preview.png; fi
 
       - name: Set up Go
         uses: actions/setup-go@v5
@@ -55,7 +62,7 @@ jobs:
         run: |
           VERSION="${{ github.ref_name }}"
           VERSION_HASH="${{ github.sha }}"
-          LDFLAGS="-s -w -X github.com/komari-monitor/komari/internal/conf.Version=${VERSION} -X github.com/komari-monitor/komari/internal/conf.CommitHash=${VERSION_HASH}"
+          LDFLAGS="-s -w -X github.com/komari-monitor/komari/utils.CurrentVersion=${VERSION} -X github.com/komari-monitor/komari/utils.VersionHash=${VERSION_HASH}"
 
           echo "Building for linux/amd64..."
           GOARCH=amd64 CC="zig cc -target x86_64-linux-musl" go build -trimpath -ldflags="$LDFLAGS" -o komari-linux-amd64

.github/workflows/generate-release-notes.yml

@@ -0,0 +1,62 @@
+name: Generate Release Notes
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: "Release tag to regenerate notes for."
+        required: true
+        type: string
+
+permissions:
+  contents: write
+
+jobs:
+  update-release-notes:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Generate and apply release notes
+        uses: actions/github-script@v9
+        with:
+          script: |
+            const tag = context.payload.release?.tag_name || core.getInput("tag");
+            if (!tag) {
+              core.setFailed("No release tag was provided.");
+              return;
+            }
+
+            const { owner, repo } = context.repo;
+            const release = context.payload.release?.tag_name === tag
+              ? context.payload.release
+              : (await github.rest.repos.getReleaseByTag({ owner, repo, tag })).data;
+
+            const generated = await github.request(
+              "POST /repos/{owner}/{repo}/releases/generate-notes",
+              {
+                owner,
+                repo,
+                tag_name: tag,
+                target_commitish: release.target_commitish || undefined,
+              },
+            );
+
+            const body = generated.data.body?.trim();
+            if (!body) {
+              core.setFailed(`GitHub returned empty release notes for ${tag}.`);
+              return;
+            }
+
+            await github.rest.repos.updateRelease({
+              owner,
+              repo,
+              release_id: release.id,
+              body,
+            });
+
+            await core.summary
+              .addHeading("Release Notes")
+              .addRaw(`Updated release notes for ${tag}.`)
+              .write();

.github/workflows/release-docker.yml

@@ -31,13 +31,20 @@ jobs:
 
       - name: Clone and build frontend
         run: |
-          git clone https://github.com/komari-monitor/komari-web web
-          cd web
+          git clone https://github.com/komari-monitor/komari-web komari-web
+          cd komari-web
           npm install
           npm run build
           cd ..
-          mkdir -p public/dist
-          cp -r web/dist/* public/dist/
+          mkdir -p web/public/defaultTheme/dist
+          rm -rf web/public/defaultTheme/dist/*
+          cp -r komari-web/dist/* web/public/defaultTheme/dist/
+          cp -f komari-web/komari-theme.json web/public/defaultTheme/
+          if [ -f komari-web/preview.png ]; then cp -f komari-web/preview.png web/public/defaultTheme/; fi
+          if [ -f komari-web/perview.png ]; then cp -f komari-web/perview.png web/public/defaultTheme/; fi
+          # Compatibility: ensure both filenames exist if only one is present
+          if [ -f web/public/defaultTheme/preview.png ] && [ ! -f web/public/defaultTheme/perview.png ]; then cp -f web/public/defaultTheme/preview.png web/public/defaultTheme/perview.png; fi
+          if [ -f web/public/defaultTheme/perview.png ] && [ ! -f web/public/defaultTheme/preview.png ]; then cp -f web/public/defaultTheme/perview.png web/public/defaultTheme/preview.png; fi
 
       - name: Set up Go
         uses: actions/setup-go@v5
@@ -58,7 +65,7 @@ jobs:
         run: |
           VERSION="${{ github.event.release.tag_name }}"
           VERSION_HASH="${{ github.sha }}"
-          LDFLAGS="-s -w -X github.com/komari-monitor/komari/internal/conf.Version=${VERSION} -X github.com/komari-monitor/komari/internal/conf.CommitHash=${VERSION_HASH}"
+          LDFLAGS="-s -w -X github.com/komari-monitor/komari/utils.CurrentVersion=${VERSION} -X github.com/komari-monitor/komari/utils.VersionHash=${VERSION_HASH}"
 
           echo "Building for linux/amd64..."
           GOARCH=amd64 CC="zig cc -target x86_64-linux-musl" go build -trimpath -ldflags="$LDFLAGS" -o komari-linux-amd64

.github/workflows/release.yml

@@ -68,13 +68,20 @@ jobs:
 
       - name: Clone and build frontend
         run: |
-          git clone https://github.com/komari-monitor/komari-web web
-          cd web
+          git clone https://github.com/komari-monitor/komari-web komari-web
+          cd komari-web
           npm install
           npm run build
           cd ..
-          mkdir -p public/dist
-          cp -r web/dist/* public/dist/
+          mkdir -p web/public/defaultTheme/dist
+          rm -rf web/public/defaultTheme/dist/*
+          cp -r komari-web/dist/* web/public/defaultTheme/dist/
+          cp -f komari-web/komari-theme.json web/public/defaultTheme/
+          if [ -f komari-web/preview.png ]; then cp -f komari-web/preview.png web/public/defaultTheme/; fi
+          if [ -f komari-web/perview.png ]; then cp -f komari-web/perview.png web/public/defaultTheme/; fi
+          # Compatibility: ensure both filenames exist if only one is present
+          if [ -f web/public/defaultTheme/preview.png ] && [ ! -f web/public/defaultTheme/perview.png ]; then cp -f web/public/defaultTheme/preview.png web/public/defaultTheme/perview.png; fi
+          if [ -f web/public/defaultTheme/perview.png ] && [ ! -f web/public/defaultTheme/preview.png ]; then cp -f web/public/defaultTheme/perview.png web/public/defaultTheme/preview.png; fi
 
       - name: Set up Go
         uses: actions/setup-go@v5
@@ -103,7 +110,7 @@ jobs:
           fi
           VERSION="${{ github.event.release.tag_name }}"
           VERSION_HASH="${{ github.sha }}" # Use commit SHA for hash
-          go build -trimpath -ldflags="-s -w -X github.com/komari-monitor/komari/internal/conf.Version=${VERSION} -X github.com/komari-monitor/komari/internal/conf.CommitHash=${VERSION_HASH}" -o $BINARY_NAME
+          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:

.gitignore

@@ -33,4 +33,5 @@ go.work.sum
 .env
 
 # build
-komari
+komari
+.codex

Dockerfile

@@ -6,7 +6,18 @@ WORKDIR /app
 ARG TARGETOS
 ARG TARGETARCH
 
-RUN apk add --no-cache tzdata
+RUN apk add --no-cache ca-certificates curl tzdata
+
+RUN set -eux; \
+    case "${TARGETARCH}" in \
+      amd64) cloudflared_arch="amd64" ;; \
+      386) cloudflared_arch="386" ;; \
+      arm64) cloudflared_arch="arm64" ;; \
+      arm) cloudflared_arch="arm" ;; \
+      *) echo "Unsupported TARGETARCH: ${TARGETARCH}" >&2; exit 1 ;; \
+    esac; \
+    curl -fsSL "https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-${cloudflared_arch}" -o /usr/local/bin/cloudflared; \
+    chmod +x /usr/local/bin/cloudflared
 
 COPY komari-${TARGETOS}-${TARGETARCH} /app/komari
 
@@ -24,4 +35,4 @@ ENV KOMARI_LISTEN=0.0.0.0:25774
 
 EXPOSE 25774
 
-CMD ["/app/komari", "server"]
+CMD ["/app/komari", "server"]

README.md

@@ -25,6 +25,10 @@ Komari is a lightweight, self-hosted server monitoring tool designed to provide
 
 [![](https://rainyun-apps.cn-nb1.rains3.com/materials/deploy-on-rainyun-cn.svg)](https://app.rainyun.com/apps/rca/store/6780/NzYxNzAz_)
 
+- 1Panel App Store
+
+Available on 1Panel App Store. Install via **App Store > Utilities > Komari**.
+
 ### 1. Use the One-click Install Script
 
 Suitable for distributions using systemd (Ubuntu, Debian...).
@@ -75,7 +79,7 @@ sudo ./install-komari.sh
 
 #### Dependencies
 
-- Go 1.24+ and Node.js 20+ (for manual build)
+- Go 1.18+ and Node.js 20+ (for manual build)
 
 1. Build the frontend static files:
    ```bash
@@ -89,7 +93,7 @@ sudo ./install-komari.sh
    git clone https://github.com/komari-monitor/komari
    cd komari
    ```
-   Copy the static files generated in step 1 to the `/public/dist` folder in the root of the `komari` project.
+   Copy the static files generated in step 1 to the `/web/public/defaultTheme/dist` folder in the root of the `komari` project, and copy `komari-theme.json` + `preview.png`/`perview.png` to `/web/public/defaultTheme`.
    ```bash
    go build -o komari
    ```
@@ -113,6 +117,10 @@ Issues and Pull Requests are welcome!
 
 ## Acknowledgements
 
+### 破碎工坊云
+
+[破碎工坊云 - 专业云计算服务平台，提供高效、稳定、安全的高防服务器与CDN解决方案](https://www.crash.work/)
+
 ### DreamCloud
 
 [DreamCloud - 极高性价比解锁直连亚太高防](https://as211392.com/)
@@ -123,7 +131,7 @@ Issues and Pull Requests are welcome!
 
 SharonNetworks 为您的业务起飞保驾护航！
 
-亚太数据中心提供顶级的中国优化网络接入 · 低延时&高带宽&提供 Tbps 级本地清洗高防服务, 为您的业务保驾护航, 为您的客户提供极致体验. 加入社区 [Telegram 群组](https://t.me/SharonNetwork) 可参与公益募捐或群内抽奖免费使用
+亚太数据中心提供顶级的中国优化网络接入 · 低延时&高带宽&提供Tbps级本地清洗高防服务, 为您的业务保驾护航, 为您的客户提供极致体验. 加入社区 [Telegram群组](https://t.me/SharonNetwork) 可参与公益募捐或群内抽奖免费使用
 
 ### The open source software community
 

cmd/chpasswd.go

@@ -1,14 +1,12 @@
 package cmd
 
 import (
-	"context"
 	"os"
 
-	"github.com/komari-monitor/komari/internal/app"
-	"github.com/komari-monitor/komari/internal/conf"
-	"github.com/komari-monitor/komari/internal/database/accounts"
-	"github.com/komari-monitor/komari/internal/database/models"
-	"github.com/komari-monitor/komari/internal/dbcore"
+	"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"
 )
 
@@ -27,31 +25,25 @@ var ChpasswdCmd = &cobra.Command{
 			cmd.Help()
 			return
 		}
-		a := app.New().With(dbcore.NewDBModule())
-		err := a.RunWith(context.Background(), func(ctx context.Context) error {
-			if _, err := os.Stat(conf.Conf.Database.DatabaseFile); os.IsNotExist(err) {
-				cmd.Println("Database file does not exist.")
-				return 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 nil
-			}
-			cmd.Println("Password changed successfully, new password:", NewPassword)
-
-			if err := accounts.DeleteAllSessions(); err != nil {
-				cmd.Println("Unable to force logout of other devices:", err)
-				return nil
-			}
-			cmd.Println("Please restart the server to apply the changes.")
-			return nil
-		})
-		if err != nil {
-			cmd.Println("Error:", err)
+		if _, err := os.Stat(flags.DatabaseFile); os.IsNotExist(err) {
+			cmd.Println("Database file does not exist.")
+			return
 		}
+		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
+		}
+		cmd.Println("Password changed successfully, new password:", NewPassword)
+
+		if err := accounts.DeleteAllSessions(); err != nil {
+			cmd.Println("Unable to force logout of other devices:", err)
+			return
+		}
+
+		cmd.Println("Please restart the server to apply the changes.")
 	},
 }
 

cmd/disable2FA.go

@@ -1,12 +1,10 @@
 package cmd
 
 import (
-	"context"
 	"os"
 
-	"github.com/komari-monitor/komari/internal/app"
-	"github.com/komari-monitor/komari/internal/database/models"
-	"github.com/komari-monitor/komari/internal/dbcore"
+	"github.com/komari-monitor/komari/database/dbcore"
+	"github.com/komari-monitor/komari/database/models"
 	"github.com/spf13/cobra"
 	"gorm.io/gorm"
 )
@@ -16,13 +14,10 @@ var Disable2FA = &cobra.Command{
 	Short: "Force disable 2FA",
 	Long:  `Force disable 2FA`,
 	Run: func(cmd *cobra.Command, args []string) {
-		a := app.New().With(dbcore.NewDBModule())
-		err := a.RunWith(context.Background(), func(ctx context.Context) error {
-			db := dbcore.GetDBInstance()
-			return db.Transaction(func(tx *gorm.DB) error {
-				return tx.Model(&models.User{}).Where("two_factor != ?", "").
-					Update("two_factor", "").Error
-			})
+		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)

cmd/flags/config.go

@@ -1,6 +1,41 @@
 package flags
 
-var (
-	ConfigFile string // 配置文件路径
-	Listen     string
+import "strings"
+
+const (
+	DatabaseTypeSQLite = "sqlite"
 )
+
+var (
+	// 数据库配置
+	DatabaseType string // 数据库类型：sqlite
+	DatabaseFile string // SQLite数据库文件路径
+	DatabaseHost string // 保留的兼容参数，当前未使用
+	DatabasePort string // 保留的兼容参数，当前未使用
+	DatabaseUser string // 保留的兼容参数，当前未使用
+	DatabasePass string // 保留的兼容参数，当前未使用
+	DatabaseName string // 保留的兼容参数，当前未使用
+
+	Listen string
+)
+
+func NormalizeDatabaseType(databaseType string) string {
+	databaseType = strings.ToLower(strings.TrimSpace(databaseType))
+	if databaseType == "" {
+		return DatabaseTypeSQLite
+	}
+	return databaseType
+}
+
+func ApplyDatabaseTypeNormalization() string {
+	DatabaseType = NormalizeDatabaseType(DatabaseType)
+	return DatabaseType
+}
+
+func IsSQLite() bool {
+	return NormalizeDatabaseType(DatabaseType) == DatabaseTypeSQLite
+}
+
+func SupportedDatabaseTypes() string {
+	return DatabaseTypeSQLite
+}

cmd/flags/config_test.go

@@ -0,0 +1,20 @@
+package flags
+
+import "testing"
+
+func TestNormalizeDatabaseType(t *testing.T) {
+	tests := map[string]string{
+		"":          DatabaseTypeSQLite,
+		"sqlite":    DatabaseTypeSQLite,
+		" SQLite ":  DatabaseTypeSQLite,
+		"SQLITE":    DatabaseTypeSQLite,
+		"postgres":  "postgres",
+		" postgres": "postgres",
+	}
+
+	for input, want := range tests {
+		if got := NormalizeDatabaseType(input); got != want {
+			t.Fatalf("NormalizeDatabaseType(%q) = %q, want %q", input, got, want)
+		}
+	}
+}

cmd/permitPasswordLogin.go

@@ -1,14 +1,11 @@
 package cmd
 
 import (
-	"context"
 	"os"
 
-	"github.com/komari-monitor/komari/internal/app"
-	"github.com/komari-monitor/komari/internal/conf"
-	"github.com/komari-monitor/komari/internal/dbcore"
+	"github.com/komari-monitor/komari/database/dbcore"
+	"github.com/komari-monitor/komari/pkg/config"
 	"github.com/spf13/cobra"
-	"gorm.io/gorm"
 )
 
 var PermitPasswordLoginCmd = &cobra.Command{
@@ -16,15 +13,8 @@ var PermitPasswordLoginCmd = &cobra.Command{
 	Short: "Force permit password login",
 	Long:  `Force permit password login`,
 	Run: func(cmd *cobra.Command, args []string) {
-		a := app.New().With(dbcore.NewDBModule())
-		err := a.RunWith(context.Background(), func(ctx context.Context) error {
-			db := dbcore.GetDBInstance()
-			return db.Transaction(func(tx *gorm.DB) error {
-				return tx.Model(&conf.V1Struct{}).Where("id = ?", 1).
-					Update("disable_password_login", false).Error
-			})
-		})
-		if err != nil {
+		dbcore.GetDBInstance()
+		if err := config.Set(config.DisablePasswordLoginKey, false); err != nil {
 			cmd.Println("Error:", err)
 			os.Exit(1)
 		}

cmd/root.go

@@ -4,8 +4,6 @@ import (
 	"fmt"
 	"os"
 
-	"log/slog"
-
 	"github.com/komari-monitor/komari/cmd/flags"
 
 	"github.com/spf13/cobra"
@@ -21,7 +19,13 @@ func GetEnv(key, defaultValue string) string {
 
 // 从环境变量获取默认值
 var (
-	configFileEnv = GetEnv("KOMARI_CONFIG_FILE", "./data/komari.json")
+	dbTypeEnv = GetEnv("KOMARI_DB_TYPE", "sqlite")
+	dbFileEnv = GetEnv("KOMARI_DB_FILE", "./data/komari.db")
+	dbHostEnv = GetEnv("KOMARI_DB_HOST", "localhost")
+	dbPortEnv = GetEnv("KOMARI_DB_PORT", "3306")
+	dbUserEnv = GetEnv("KOMARI_DB_USER", "root")
+	dbPassEnv = GetEnv("KOMARI_DB_PASS", "")
+	dbNameEnv = GetEnv("KOMARI_DB_NAME", "komari")
 )
 
 var RootCmd = &cobra.Command{
@@ -29,63 +33,29 @@ var RootCmd = &cobra.Command{
 	Short: "Komari is a simple server monitoring tool",
 	Long: `Komari is a simple server monitoring tool. 
 Made by Akizon77 with love.`,
+	Run: func(cmd *cobra.Command, args []string) {
+		cmd.SetArgs([]string{"server"})
+		cmd.Execute()
+	},
 }
 
 func Execute() {
-	detectDeprecatedFlags()
-	// Default to server when no subcommand is provided.
-	if len(os.Args) <= 1 {
-		RootCmd.SetArgs([]string{"server"})
-	}
-	// 创建目录
-	if err := os.MkdirAll("./data/theme", os.ModePerm); err != nil {
-		slog.Error("Failed to create theme directory", slog.Any("error", err))
-	}
 	if err := RootCmd.Execute(); err != nil {
 		fmt.Fprintln(os.Stderr, err)
 		os.Exit(1)
 	}
 }
 
-// detectDeprecatedFlags 检测过时的数据库相关命令行参数
-func detectDeprecatedFlags() {
-	deprecatedFlags := map[string]bool{
-		"db-host":  false,
-		"database": false,
-		"db-user":  false,
-		"db-pass":  false,
-		"db-port":  false,
-		"db-name":  false,
-		"db-type":  false,
-	}
-
-	// 检查命令行参数
-	for _, arg := range os.Args[1:] {
-		for flagName := range deprecatedFlags {
-			if arg == "--"+flagName || arg == "-"+string(flagName[0]) {
-				deprecatedFlags[flagName] = true
-				break
-			}
-		}
-	}
-
-	// 如果检测到过时参数，记录警告
-	hasDeprecated := false
-	for flagName, found := range deprecatedFlags {
-		if found {
-			hasDeprecated = true
-			slog.Warn("Deprecated command-line flag detected", slog.String("flag", "--"+flagName))
-		}
-	}
-
-	if hasDeprecated {
-		slog.Warn("Command-line database configuration flags are deprecated. " +
-			"Please migrate to komari.json file. ")
-	}
-}
-
 func init() {
 	// 设置命令行参数，提供环境变量作为默认值
-	RootCmd.PersistentFlags().StringVarP(&flags.ConfigFile, "config", "c", configFileEnv, "Configuration file path [env: KOMARI_CONFIG_FILE]")
-	RootCmd.PersistentFlags().StringVarP(&flags.Listen, "listen", "l", GetEnv("KOMARI_LISTEN", ":8080"), "Listen address [env: KOMARI_LISTEN]")
+	RootCmd.PersistentFlags().StringVarP(&flags.DatabaseType, "db-type", "t", dbTypeEnv, "Database type (sqlite) [env: KOMARI_DB_TYPE]")
+	RootCmd.PersistentFlags().StringVarP(&flags.DatabaseFile, "database", "d", dbFileEnv, "SQLite database file path [env: KOMARI_DB_FILE]")
+	RootCmd.PersistentFlags().StringVar(&flags.DatabaseHost, "db-host", dbHostEnv, "Reserved database host parameter [env: KOMARI_DB_HOST]")
+	RootCmd.PersistentFlags().StringVar(&flags.DatabasePort, "db-port", dbPortEnv, "Reserved database port parameter [env: KOMARI_DB_PORT]")
+	RootCmd.PersistentFlags().StringVar(&flags.DatabaseUser, "db-user", dbUserEnv, "Reserved database username parameter [env: KOMARI_DB_USER]")
+	RootCmd.PersistentFlags().StringVar(&flags.DatabasePass, "db-pass", dbPassEnv, "Reserved database password parameter [env: KOMARI_DB_PASS]")
+	RootCmd.PersistentFlags().StringVar(&flags.DatabaseName, "db-name", dbNameEnv, "Reserved database name parameter [env: KOMARI_DB_NAME]")
+	for _, name := range []string{"db-host", "db-port", "db-user", "db-pass", "db-name"} {
+		_ = RootCmd.PersistentFlags().MarkHidden(name)
+	}
 }

cmd/server.go

@@ -2,12 +2,39 @@ package cmd
 
 import (
 	"context"
+	"fmt"
+	"log"
+	"net/http"
 	"os"
+	"os/signal"
+	"syscall"
 	"time"
 
-	"github.com/komari-monitor/komari/internal/app"
-	"github.com/komari-monitor/komari/internal/scheduler"
-	"github.com/komari-monitor/komari/internal/server"
+	"github.com/gin-gonic/gin"
+	"github.com/komari-monitor/komari/cmd/flags"
+	"github.com/komari-monitor/komari/pkg/corn"
+	"github.com/komari-monitor/komari/web/api"
+
+	"github.com/komari-monitor/komari/database"
+	"github.com/komari-monitor/komari/database/accounts"
+	"github.com/komari-monitor/komari/database/auditlog"
+	"github.com/komari-monitor/komari/database/dbcore"
+	"github.com/komari-monitor/komari/database/models"
+	d_notification "github.com/komari-monitor/komari/database/notification"
+	"github.com/komari-monitor/komari/database/records"
+	"github.com/komari-monitor/komari/database/tasks"
+	"github.com/komari-monitor/komari/pkg/config"
+	"github.com/komari-monitor/komari/utils"
+	"github.com/komari-monitor/komari/utils/cloudflared"
+	"github.com/komari-monitor/komari/utils/geoip"
+	logutil "github.com/komari-monitor/komari/utils/log"
+	"github.com/komari-monitor/komari/utils/messageSender"
+	"github.com/komari-monitor/komari/utils/notifier"
+	"github.com/komari-monitor/komari/web/nezha"
+	"github.com/komari-monitor/komari/web/oauth"
+	report_cache "github.com/komari-monitor/komari/web/report"
+	"github.com/komari-monitor/komari/web/router"
+	"github.com/komari-monitor/komari/web/security"
 	"github.com/spf13/cobra"
 )
 
@@ -16,17 +43,195 @@ var ServerCmd = &cobra.Command{
 	Short: "Start the server",
 	Long:  `Start the server`,
 	Run: func(cmd *cobra.Command, args []string) {
-		a := app.New().
-			WithShutdownTimeout(5 * time.Second).
-			With(server.NewHTTPModule()).
-			With(scheduler.NewModule())
-		if err := a.RunUntilSignal(context.Background()); err != nil {
-			cmd.PrintErrln(err)
-			os.Exit(1)
-		}
+		RunServer()
 	},
 }
 
 func init() {
+	// 从环境变量获取监听地址
+	listenAddr := GetEnv("KOMARI_LISTEN", "0.0.0.0:25774")
+	ServerCmd.PersistentFlags().StringVarP(&flags.Listen, "listen", "l", listenAddr, "监听地址 [env: KOMARI_LISTEN]")
 	RootCmd.AddCommand(ServerCmd)
 }
+
+func RunServer() {
+	// #region 初始化
+	if err := os.MkdirAll("./data/theme", os.ModePerm); err != nil {
+		log.Fatalf("Failed to create theme directory: %v", err)
+	}
+	InitDatabase()
+	if utils.VersionHash != "unknown" {
+		gin.SetMode(gin.ReleaseMode)
+	}
+	conf, err := config.GetManyAs[config.Settings]()
+	if err != nil {
+		log.Fatal(err)
+	}
+	go geoip.InitGeoIp()
+	go DoScheduledWork()
+	go messageSender.Initialize()
+	// oidcInit
+	go oauth.Initialize()
+
+	if conf.NezhaCompatEnabled {
+		go func() {
+			if err := nezha.StartNezhaCompat(conf.NezhaCompatListen); err != nil {
+				log.Printf("Nezha compat server error: %v", err)
+				auditlog.EventLog("error", fmt.Sprintf("Nezha compat server error: %v", err))
+			}
+		}()
+	}
+
+	config.Subscribe(func(event config.ConfigEvent) {
+		if ok, t := config.IsChangedT[string](event, config.OAuthProviderKey); ok {
+			if t == "" || t == "none" {
+				t = "github"
+			}
+			oidcProvider, err := database.GetOidcConfigByName(t)
+			if err != nil {
+				log.Printf("Failed to get OIDC provider config: %v", err)
+			} else {
+				log.Printf("Using %s as OIDC provider", oidcProvider.Name)
+			}
+			err = oauth.LoadProvider(oidcProvider.Name, oidcProvider.Addition)
+			if err != nil {
+				auditlog.EventLog("error", fmt.Sprintf("Failed to load OIDC provider: %v", err))
+			}
+		}
+
+		if ok, t := config.IsChangedT[bool](event, config.NezhaCompatEnabledKey); ok {
+			if t {
+				l, _ := config.GetAs[string](config.NezhaCompatListenKey)
+				if err := nezha.StartNezhaCompat(l); err != nil {
+					log.Printf("start Nezha compat server error: %v", err)
+					auditlog.EventLog("error", fmt.Sprintf("start Nezha compat server error: %v", err))
+				}
+			} else {
+				if err := nezha.StopNezhaCompat(); err != nil {
+					log.Printf("stop Nezha compat server error: %v", err)
+					auditlog.EventLog("error", fmt.Sprintf("stop Nezha compat server error: %v", err))
+				}
+			}
+		}
+
+	})
+	// 初始化 cloudflared
+	if err := cloudflared.AutoStart(GetEnv("KOMARI_CLOUDFLARED_TOKEN", "")); err != nil {
+		log.Printf("failed to auto start cloudflared: %v", err)
+	}
+
+	r := gin.New()
+	r.Use(logutil.GinLogger())
+	r.Use(logutil.GinRecovery())
+
+	config.Subscribe(func(event config.ConfigEvent) {
+		if event.IsChanged(config.GeoIpProviderKey) {
+			go geoip.InitGeoIp()
+		}
+
+		if event.IsChanged(config.NotificationMethodKey) {
+			go messageSender.Initialize()
+		}
+
+	})
+	r.Use(security.CorsMiddleware(conf.CorsOriginCheckEnabled, conf.CorsAllowedOrigins))
+
+	r.Use(api.IdentityMiddleware())
+	r.Use(api.PrivateSiteMiddleware())
+
+	r.Use(func(c *gin.Context) {
+		if len(c.Request.URL.Path) >= 4 && c.Request.URL.Path[:4] == "/api" {
+			c.Header("Cache-Control", "no-store")
+		}
+		c.Next()
+	})
+
+	router.Register(r)
+
+	srv := &http.Server{
+		Addr:    flags.Listen,
+		Handler: r,
+	}
+	log.Printf("Starting server on %s ...", flags.Listen)
+	go func() {
+		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			OnFatal(err)
+			log.Fatalf("listen: %s\n", err)
+		}
+	}()
+	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)
+	}
+
+}
+
+func InitDatabase() {
+	var count int64 = 0
+	if dbcore.GetDBInstance().Model(&models.User{}).Count(&count); count == 0 {
+		user, passwd, err := accounts.CreateDefaultAdminAccount()
+		if err != nil {
+			panic(err)
+		}
+		log.Println("Default admin account created. Username:", user, ", Password:", passwd)
+	}
+}
+
+// #region 定时任务
+func DoScheduledWork() {
+	if err := tasks.ReloadPingSchedule(); err != nil {
+		log.Println("Failed to reload ping schedule:", err)
+	}
+	if err := d_notification.ReloadLoadNotificationSchedule(); err != nil {
+		log.Println("Failed to reload load notification schedule:", err)
+	}
+	records.CompactRecord()
+
+	if err := corn.AddFunc("records:cleanup", "@every 30m", cleanupScheduledData); err != nil {
+		log.Println("Failed to add cleanup scheduled task:", err)
+	}
+	if err := corn.AddFunc("records:minute", "@every 1m", minuteScheduledWork); err != nil {
+		log.Println("Failed to add minute scheduled task:", err)
+	}
+	if err := corn.AddFunc("notifier:expire", "0 0 9 * * *", notifier.CheckExpireScheduledWork); err != nil {
+		log.Println("Failed to add expire notification scheduled task:", err)
+	}
+	notifier.InitTrafficReportSchedule()
+}
+
+func cleanupScheduledData() {
+	cfg, _ := config.GetManyAs[config.Settings]()
+	records.DeleteRecordBefore(time.Now().Add(-time.Hour * time.Duration(cfg.RecordPreserveTime)))
+	records.CompactRecord()
+	tasks.ClearTaskResultsByTimeBefore(time.Now().Add(-time.Hour * time.Duration(cfg.RecordPreserveTime)))
+	tasks.DeletePingRecordsBefore(time.Now().Add(-time.Hour * time.Duration(cfg.PingRecordPreserveTime)))
+	auditlog.RemoveOldLogs()
+	accounts.RemoveExpiredSessions()
+}
+
+func minuteScheduledWork() {
+	cfg, _ := config.GetManyAs[config.Settings]()
+	report_cache.SaveClientReportToDB()
+	if !cfg.RecordEnabled {
+		records.DeleteAll()
+		tasks.DeleteAllPingRecords()
+	}
+	// 每分钟检查一次流量提醒
+	notifier.CheckTraffic()
+}
+
+func OnShutdown() {
+	auditlog.Log("", "", "server is shutting down", "info")
+	corn.StopAll()
+	cloudflared.Shutdown()
+}
+
+func OnFatal(err error) {
+	auditlog.Log("", "", "server encountered a fatal error: "+err.Error(), "error")
+	cloudflared.Shutdown()
+}

database/accounts/2fa.go

@@ -3,10 +3,8 @@ package accounts
 import (
 	"image"
 
-	"github.com/gookit/event"
-	"github.com/komari-monitor/komari/internal/database/models"
-	"github.com/komari-monitor/komari/internal/dbcore"
-	"github.com/komari-monitor/komari/internal/eventType"
+	"github.com/komari-monitor/komari/database/dbcore"
+	"github.com/komari-monitor/komari/database/models"
 	"github.com/pquerna/otp/totp"
 )
 
@@ -31,14 +29,7 @@ func Generate2Fa() (string, image.Image, error) {
 
 func Enable2Fa(uuid, secret string) error {
 	db := dbcore.GetDBInstance()
-	err := db.Model(&models.User{}).Where("uuid = ?", uuid).Update("two_factor", secret).Error
-	if err != nil {
-		event.Trigger(eventType.UserTwoFaAdded, event.M{
-			"user": uuid,
-		})
-		return err
-	}
-	return nil
+	return db.Model(&models.User{}).Where("uuid = ?", uuid).Update("two_factor", secret).Error
 }
 
 func Verify2Fa(uuid, code string) (bool, error) {
@@ -63,12 +54,5 @@ func Verify2Fa(uuid, code string) (bool, error) {
 
 func Disable2Fa(uuid string) error {
 	db := dbcore.GetDBInstance()
-	err := db.Model(&models.User{}).Where("uuid = ?", uuid).Update("two_factor", "").Error
-	if err != nil {
-		return err
-	}
-	event.Trigger(eventType.UserTwoFaRemoved, event.M{
-		"user": uuid,
-	})
-	return nil
+	return db.Model(&models.User{}).Where("uuid = ?", uuid).Update("two_factor", "").Error
 }

database/accounts/accounts.go

@@ -7,11 +7,9 @@ import (
 	"os"
 	"time"
 
-	"github.com/gookit/event"
-	"github.com/komari-monitor/komari/internal/database/models"
-	"github.com/komari-monitor/komari/internal/dbcore"
-	"github.com/komari-monitor/komari/internal/eventType"
-	"github.com/komari-monitor/komari/pkg/utils"
+	"github.com/komari-monitor/komari/database/dbcore"
+	"github.com/komari-monitor/komari/database/models"
+	"github.com/komari-monitor/komari/utils"
 
 	"github.com/google/uuid"
 )
@@ -181,18 +179,5 @@ func UpdateUser(uuid string, name, password, sso_type *string) error {
 	if password != nil {
 		DeleteAllSessions()
 	}
-	if name != nil {
-		event.Trigger(eventType.UserUpdateUsername, event.M{
-			"user": uuid,
-		})
-	} else if password != nil {
-		event.Trigger(eventType.UserUpdatePassword, event.M{
-			"user": uuid,
-		})
-	} else if sso_type != nil && *sso_type == "" {
-		event.Trigger(eventType.UserOidcUnbound, event.M{
-			"user": uuid,
-		})
-	}
 	return nil
 }

database/accounts/sessions.go

@@ -6,15 +6,13 @@ import (
 	"net"
 	"time"
 
-	"github.com/gookit/event"
-	"github.com/komari-monitor/komari/internal/conf"
-	"github.com/komari-monitor/komari/internal/database/models"
-	messageevent "github.com/komari-monitor/komari/internal/database/models/messageEvent"
-	"github.com/komari-monitor/komari/internal/dbcore"
-	"github.com/komari-monitor/komari/internal/eventType"
-	"github.com/komari-monitor/komari/internal/geoip"
-	"github.com/komari-monitor/komari/internal/messageSender"
-	"github.com/komari-monitor/komari/pkg/utils"
+	"github.com/komari-monitor/komari/database/dbcore"
+	"github.com/komari-monitor/komari/database/models"
+	messageevent "github.com/komari-monitor/komari/database/models/messageEvent"
+	"github.com/komari-monitor/komari/pkg/config"
+	"github.com/komari-monitor/komari/utils"
+	"github.com/komari-monitor/komari/utils/geoip"
+	"github.com/komari-monitor/komari/utils/messageSender"
 )
 
 // GetAllSessions 获取所有会话
@@ -41,21 +39,23 @@ func CreateSession(uuid string, expires int, userAgent, ip, login_method string)
 		LoginMethod:  login_method,
 		LatestOnline: models.FromTime(time.Now()),
 	}
-	cfg, _ := conf.GetWithV1Format()
-	if cfg.LoginNotification {
-		ipAddr := net.ParseIP(ip)
-		ipinfo, _ := geoip.GetGeoInfo(ipAddr)
-		loc := "unknown"
-		if ipinfo != nil {
-			loc = ipinfo.Name
+	go func() {
+		LoginNotification, _ := config.GetAs[bool](config.LoginNotificationKey, false)
+		if LoginNotification {
+			ipAddr := net.ParseIP(ip)
+			ipinfo, _ := geoip.GetGeoInfo(ipAddr)
+			loc := "unknown"
+			if ipinfo != nil && ipinfo.Name != "" {
+				loc = ipinfo.Name
+			}
+			messageSender.SendEvent(models.EventMessage{
+				Event:   messageevent.Login,
+				Time:    time.Now(),
+				Message: fmt.Sprintf("%s: %s (%s)\n%s", login_method, ip, loc, userAgent),
+				Emoji:   "🔑",
+			})
 		}
-		messageSender.SendEvent(models.EventMessage{
-			Event:   messageevent.Login,
-			Time:    time.Now(),
-			Message: fmt.Sprintf("%s: %s (%s)\n%s", login_method, ip, loc, userAgent),
-			Emoji:   "🔑",
-		})
-	}
+	}()
 
 	err := db.Create(&sessionRecord).Error
 	if err != nil {
@@ -99,9 +99,6 @@ func DeleteSession(session string) (err error) {
 	if result.Error != nil {
 		return result.Error
 	}
-	event.Trigger(eventType.UserSessionRevoked, event.M{
-		"session": session,
-	})
 	return nil
 }
 
@@ -136,3 +133,12 @@ func UpdateLatest(session, useragent, ip string) error {
 		"latest_ip":         ip,
 	}).Error
 }
+
+func RemoveExpiredSessions() error {
+	db := dbcore.GetDBInstance()
+	result := db.Where("expires < ?", time.Now()).Delete(&models.Session{})
+	if result.Error != nil {
+		return result.Error
+	}
+	return nil
+}

database/auditlog/log.go

@@ -1,12 +1,11 @@
 package auditlog
 
 import (
-	"fmt"
 	"log"
 	"time"
 
-	"github.com/komari-monitor/komari/internal/database/models"
-	"github.com/komari-monitor/komari/internal/dbcore"
+	"github.com/komari-monitor/komari/database/dbcore"
+	"github.com/komari-monitor/komari/database/models"
 )
 
 func Log(ip, uuid, message, msgType string) {
@@ -26,14 +25,6 @@ func EventLog(eventType, message string) {
 	Log("", "", message, eventType)
 }
 
-func InternalInfof(message string, v ...interface{}) {
-	Log("", "", fmt.Sprintf(message, v...), "info")
-}
-
-func InternalErrorf(message string, v ...interface{}) {
-	Log("", "", fmt.Sprintf(message, v...), "error")
-}
-
 // Delete logs older than 30 days
 func RemoveOldLogs() {
 	db := dbcore.GetDBInstance()

database/clients/client.go

@@ -0,0 +1,272 @@
+package clients
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"math"
+	"time"
+
+	"github.com/komari-monitor/komari/database/dbcore"
+	"github.com/komari-monitor/komari/database/models"
+	"github.com/komari-monitor/komari/database/tasks"
+	"github.com/komari-monitor/komari/utils"
+	"gorm.io/gorm"
+
+	"github.com/google/uuid"
+)
+
+func DeleteClient(clientUuid string) error {
+	db := dbcore.GetDBInstance()
+	err := db.Delete(&models.Client{}, "uuid = ?", clientUuid).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func SaveClientInfo(update map[string]interface{}) error {
+	db := dbcore.GetDBInstance()
+	clientUUID, ok := update["uuid"].(string)
+	if !ok || clientUUID == "" {
+		return fmt.Errorf("invalid client UUID")
+	}
+
+	// 确保更新的字段不为空
+	if len(update) == 0 {
+		return fmt.Errorf("no fields to update")
+	}
+
+	update["updated_at"] = time.Now()
+
+	toFloat64 := func(value interface{}) (float64, bool) {
+		switch typed := value.(type) {
+		case float64:
+			return typed, true
+		case float32:
+			return float64(typed), true
+		case int:
+			return float64(typed), true
+		case int8:
+			return float64(typed), true
+		case int16:
+			return float64(typed), true
+		case int32:
+			return float64(typed), true
+		case int64:
+			return float64(typed), true
+		case uint:
+			return float64(typed), true
+		case uint8:
+			return float64(typed), true
+		case uint16:
+			return float64(typed), true
+		case uint32:
+			return float64(typed), true
+		case uint64:
+			return float64(typed), true
+		case json.Number:
+			parsed, err := typed.Float64()
+			if err != nil {
+				return 0, false
+			}
+			return parsed, true
+		default:
+			return 0, false
+		}
+	}
+
+	checkOptionalInt := func(name, key string, maxValue float64) error {
+		value, exists := update[key]
+		if !exists || value == nil {
+			return nil
+		}
+
+		numericValue, ok := toFloat64(value)
+		if !ok {
+			return fmt.Errorf("%s must be a valid number", name)
+		}
+		if numericValue < 0 || numericValue > maxValue {
+			return fmt.Errorf("%s must be a valid non-negative number: %v", name, value)
+		}
+		return nil
+	}
+
+	verify := func(update map[string]interface{}) error {
+		if err := checkOptionalInt("Cpu.Cores", "cpu_cores", math.MaxInt-1); err != nil {
+			return err
+		}
+		if err := checkOptionalInt("Cpu.PhysicalCores", "cpu_physical_cores", math.MaxInt-1); err != nil {
+			return err
+		}
+		if err := checkOptionalInt("Ram.Total", "mem_total", math.MaxInt64-1); err != nil {
+			return err
+		}
+		if err := checkOptionalInt("Swap.Total", "swap_total", math.MaxInt64-1); err != nil {
+			return err
+		}
+		if err := checkOptionalInt("Disk.Total", "disk_total", math.MaxInt64-1); err != nil {
+			return err
+		}
+		return nil
+	}
+
+	if err := verify(update); err != nil {
+		return err
+	}
+
+	err := db.Model(&models.Client{}).Where("uuid = ?", clientUUID).Updates(update).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func EditClientName(clientUUID, clientName string) error {
+	db := dbcore.GetDBInstance()
+	err := db.Model(&models.Client{}).Where("uuid = ?", clientUUID).Update("name", clientName).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func EditClientToken(clientUUID, token string) error {
+	db := dbcore.GetDBInstance()
+	err := db.Model(&models.Client{}).Where("uuid = ?", clientUUID).Update("token", token).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// CreateClient 创建新客户端
+func CreateClient() (clientUUID, token string, err error) {
+	db := dbcore.GetDBInstance()
+	token = utils.GenerateToken()
+	clientUUID = uuid.New().String()
+
+	client := models.Client{
+		UUID:      clientUUID,
+		Token:     token,
+		Name:      "client_" + clientUUID[0:8],
+		CreatedAt: models.FromTime(time.Now()),
+		UpdatedAt: models.FromTime(time.Now()),
+	}
+
+	err = db.Create(&client).Error
+	if err != nil {
+		return "", "", err
+	}
+	if err := tasks.AddDefaultOnClientUUID(clientUUID); err != nil {
+		log.Println("Failed to apply default-on ping tasks to new client:", err)
+	}
+	return clientUUID, token, nil
+}
+
+func CreateClientWithName(name string) (clientUUID, token string, err error) {
+	if name == "" {
+		return CreateClient()
+	}
+	db := dbcore.GetDBInstance()
+	token = utils.GenerateToken()
+	clientUUID = uuid.New().String()
+	client := models.Client{
+		UUID:      clientUUID,
+		Token:     token,
+		Name:      name,
+		CreatedAt: models.FromTime(time.Now()),
+		UpdatedAt: models.FromTime(time.Now()),
+	}
+
+	err = db.Create(&client).Error
+	if err != nil {
+		return "", "", err
+	}
+	if err := tasks.AddDefaultOnClientUUID(clientUUID); err != nil {
+		log.Println("Failed to apply default-on ping tasks to new client:", err)
+	}
+	return clientUUID, token, nil
+}
+
+/*
+// GetAllClients 获取所有客户端配置
+
+	func getAllClients() (clients []models.Client, err error) {
+		db := dbcore.GetDBInstance()
+		err = db.Find(&clients).Error
+		if err != nil {
+			return nil, err
+		}
+		return clients, nil
+	}
+*/
+func GetClientByUUID(uuid string) (client models.Client, err error) {
+	db := dbcore.GetDBInstance()
+	err = db.Where("uuid = ?", uuid).First(&client).Error
+	if err != nil {
+		return models.Client{}, err
+	}
+	return client, nil
+}
+
+// GetClientBasicInfo 获取指定 UUID 的客户端基本信息
+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 models.Client{}, fmt.Errorf("客户端不存在: %s", uuid)
+		}
+		return models.Client{}, err
+	}
+	return client, nil
+}
+
+func GetClientTokenByUUID(uuid string) (token string, err error) {
+	db := dbcore.GetDBInstance()
+	var client models.Client
+	err = db.Where("uuid = ?", uuid).First(&client).Error
+	if err != nil {
+		return "", err
+	}
+	return client.Token, nil
+}
+
+func GetAllClientBasicInfo() (clients []models.Client, err error) {
+	db := dbcore.GetDBInstance()
+	err = db.Find(&clients).Error
+	if err != nil {
+		return nil, err
+	}
+	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")
+	}
+
+	if v, exists := updates["traffic_limit"]; exists {
+		if val, ok := v.(float64); ok {
+			if val < 0 || val > math.MaxInt64-1 {
+				return fmt.Errorf("traffic_limit must be a valid non-negative int64 value, got %v", val)
+			}
+		}
+	}
+
+	updates["updated_at"] = time.Now()
+
+	err := db.Model(&models.Client{}).Where("uuid = ?", clientUUID).Updates(updates).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}

database/clients/report.go

@@ -0,0 +1,307 @@
+package clients
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"math"
+	"sync"
+	"time"
+
+	"github.com/komari-monitor/komari/database/dbcore"
+	"github.com/komari-monitor/komari/database/models"
+	v1 "github.com/komari-monitor/komari/protocol/v1"
+
+	"gorm.io/gorm"
+)
+
+var reportSaveLocks sync.Map
+
+func getReportSaveLock(clientUUID string) *sync.Mutex {
+	lock, _ := reportSaveLocks.LoadOrStore(clientUUID, &sync.Mutex{})
+	return lock.(*sync.Mutex)
+}
+
+func computeTrafficDelta(current, previous int64) int64 {
+	if previous < 0 {
+		return 0
+	}
+	if current >= previous {
+		return current - previous
+	}
+	// Counter reset or reboot: treat the new counter value as traffic since reset.
+	return current
+}
+
+func getLatestTrafficRecord(tx *gorm.DB, clientUUID string) (*models.Record, error) {
+	var record models.Record
+	err := tx.Where("client = ?", clientUUID).Order("time DESC").First(&record).Error
+	if err == nil {
+		return &record, nil
+	}
+	if !errors.Is(err, gorm.ErrRecordNotFound) {
+		return nil, err
+	}
+
+	err = tx.Table("records_long_term").Where("client = ?", clientUUID).Order("time DESC").First(&record).Error
+	if err == nil {
+		return &record, nil
+	}
+	if !errors.Is(err, gorm.ErrRecordNotFound) {
+		return nil, err
+	}
+
+	return nil, nil
+}
+
+// Report 表示客户端报告数据
+// SaveReport 保存报告数据
+func SaveReport(uuid string, data map[string]interface{}) (err error) {
+
+	report, err := ParseReport(data)
+	if err != nil {
+		return err
+	}
+	err = SaveClientReport(uuid, report)
+	if err != nil {
+
+		return err
+	}
+	return nil
+
+}
+
+func GetClientUUIDByToken(token string) (clientUUID string, err error) {
+	db := dbcore.GetDBInstance()
+	var client models.Client
+	err = db.Where("token = ?", token).First(&client).Error
+	if err != nil {
+		return "", err
+	}
+	return client.UUID, nil
+}
+
+func ParseReport(data map[string]interface{}) (report v1.Report, err error) {
+	jsonData, err := json.Marshal(data)
+	if err != nil {
+		return v1.Report{}, err
+	}
+	err = json.Unmarshal(jsonData, &report)
+	if err != nil {
+		return v1.Report{}, err
+	}
+	return report, nil
+}
+
+// 检查数据防止异常数据导致数据库损坏
+func ReportVerify(report v1.Report) error {
+	// 防止输入不合理范围
+	if report.CPU.Usage < 0 || report.CPU.Usage > 100 {
+		return fmt.Errorf("CPU.Usage must be between 0 and 100")
+	}
+
+	if report.Load.Load1 < 0 || report.Load.Load1 > 1000 {
+		return fmt.Errorf("Load.Load1 must be non-negative, got %.2f", report.Load.Load1)
+	}
+
+	checkFloat64 := func(name string, val float64) error {
+		if val > math.MaxFloat64-1 || val < -math.MaxFloat64+1 {
+			return fmt.Errorf("%s value exceeds float64 range: %g", name, val)
+		}
+		return nil
+	}
+
+	// [float64] 防止数据溢出
+	if err := checkFloat64("CPU.Usage", report.CPU.Usage); err != nil {
+		return err
+	}
+	if err := checkFloat64("Load.Load1", report.Load.Load1); err != nil {
+		return err
+	}
+
+	checkInt64 := func(name string, val int64) error {
+		if val < 0 {
+			return fmt.Errorf("%s must be non-negative, got %d", name, val)
+		}
+		if val > math.MaxInt64-1 {
+			return fmt.Errorf("%s exceeds int64 max limit: %d", name, val)
+		}
+		return nil
+	}
+
+	// [int64] 防止数据溢出
+	// Ram 验证
+	if err := checkInt64("Ram.Used", report.Ram.Used); err != nil {
+		return err
+	}
+	if err := checkInt64("Ram.Total", report.Ram.Total); err != nil {
+		return err
+	}
+	// Swap 验证
+	if err := checkInt64("Swap.Used", report.Swap.Used); err != nil {
+		return err
+	}
+	if err := checkInt64("Swap.Total", report.Swap.Total); err != nil {
+		return err
+	}
+	// Disk 验证
+	if err := checkInt64("Disk.Used", report.Disk.Used); err != nil {
+		return err
+	}
+	if err := checkInt64("Disk.Total", report.Disk.Total); err != nil {
+		return err
+	}
+	// Network 验证
+	if err := checkInt64("Network.Up", report.Network.Up); err != nil {
+		return err
+	}
+	if err := checkInt64("Network.Down", report.Network.Down); err != nil {
+		return err
+	}
+	if err := checkInt64("Network.TotalUp", report.Network.TotalUp); err != nil {
+		return err
+	}
+	if err := checkInt64("Network.TotalDown", report.Network.TotalDown); err != nil {
+		return err
+	}
+	// 拒绝所有负数Int
+	if report.Process < 0 {
+		return fmt.Errorf("Process must be non-negative: %d", report.Process)
+	}
+	if report.Connections.TCP < 0 {
+		return fmt.Errorf("Connections.TCP must be non-negative: %d", report.Connections.TCP)
+	}
+	if report.Connections.UDP < 0 {
+		return fmt.Errorf("Connections.UDP must be non-negative: %d", report.Connections.UDP)
+	}
+	return nil
+}
+
+// SaveClientReport 保存客户端报告到 Record 表
+func SaveClientReport(clientUUID string, report v1.Report) (err error) {
+	db := dbcore.GetDBInstance()
+	lock := getReportSaveLock(clientUUID)
+	lock.Lock()
+	defer lock.Unlock()
+
+	if err := ReportVerify(report); err != nil {
+		return fmt.Errorf("failed to save Record: %w", err)
+	}
+
+	// 保存GPU详细记录到独立表
+	currentTime := time.Now()
+	if report.GPU != nil && len(report.GPU.DetailedInfo) > 0 {
+		for idx, gpu := range report.GPU.DetailedInfo {
+			gpuRecord := models.GPURecord{
+				Client:      clientUUID,
+				Time:        models.FromTime(currentTime),
+				DeviceIndex: idx,
+				DeviceName:  gpu.Name,
+				MemTotal:    gpu.MemoryTotal,
+				MemUsed:     gpu.MemoryUsed,
+				Utilization: float32(gpu.Utilization),
+				Temperature: gpu.Temperature,
+			}
+			if err := db.Create(&gpuRecord).Error; err != nil {
+				return fmt.Errorf("failed to save GPU record: %w", err)
+			}
+		}
+	}
+
+	// 计算平均GPU使用率，用于向后兼容
+	averageGPUUsage := float32(0)
+	if report.GPU != nil && len(report.GPU.DetailedInfo) > 0 {
+		averageGPUUsage = float32(report.GPU.AverageUsage)
+	}
+
+	Record := models.Record{
+		Client:         clientUUID,
+		Time:           models.FromTime(currentTime),
+		Cpu:            float32(report.CPU.Usage),
+		Gpu:            averageGPUUsage, // 使用平均GPU使用率
+		Ram:            report.Ram.Used,
+		RamTotal:       report.Ram.Total,
+		Swap:           report.Swap.Used,
+		SwapTotal:      report.Swap.Total,
+		Load:           float32(report.Load.Load1), // 使用 Load1 作为主要负载指标
+		Temp:           0,                          // Report 未提供 TEMP，设为 0（与原 nil 行为类似）
+		Disk:           report.Disk.Used,
+		DiskTotal:      report.Disk.Total,
+		NetIn:          report.Network.Down,
+		NetOut:         report.Network.Up,
+		NetTotalUp:     report.Network.TotalUp,
+		NetTotalDown:   report.Network.TotalDown,
+		TrafficUp:      0,
+		TrafficDown:    0,
+		Process:        report.Process,
+		Connections:    report.Connections.TCP,
+		ConnectionsUdp: report.Connections.UDP,
+		//Uptime:         report.Uptime,
+	}
+
+	// 使用事务确保 Record 和 ClientsInfo 一致性
+	err = db.Transaction(func(tx *gorm.DB) error {
+		previous, err := getLatestTrafficRecord(tx, clientUUID)
+		if err != nil {
+			return fmt.Errorf("failed to load previous Record: %w", err)
+		}
+		if previous != nil {
+			Record.TrafficUp = computeTrafficDelta(report.Network.TotalUp, previous.NetTotalUp)
+			Record.TrafficDown = computeTrafficDelta(report.Network.TotalDown, previous.NetTotalDown)
+		}
+
+		// 保存 Record
+		if err := tx.Create(&Record).Error; err != nil {
+			return fmt.Errorf("failed to save Record: %w", err)
+		}
+		return nil
+	})
+
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+/*
+// getString 从 map 中获取字符串
+func getString(data map[string]interface{}, key string) string {
+	if val, ok := data[key]; ok {
+		if str, ok := val.(string); ok {
+			return str
+		}
+	}
+	return ""
+}
+
+// getInt 从 map 中获取整数
+func getInt(data map[string]interface{}, key string) int {
+	if val, ok := data[key]; ok {
+		if num, ok := val.(float64); ok {
+			return int(num)
+		}
+	}
+	return 0
+}
+
+// getInt64 从 map 中获取 int64
+func getInt64(data map[string]interface{}, key string) int64 {
+	if val, ok := data[key]; ok {
+		if num, ok := val.(float64); ok {
+			return int64(num)
+		}
+	}
+	return 0
+}
+
+// getFloat 从 map 中获取 float64
+func getFloat(data map[string]interface{}, key string) float64 {
+	if val, ok := data[key]; ok {
+		if num, ok := val.(float64); ok {
+			return num
+		}
+	}
+	return 0.0
+}
+*/

database/clients/report_test.go

@@ -0,0 +1,82 @@
+package clients
+
+import (
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestComputeTrafficDeltaHandlesZeroAndReset(t *testing.T) {
+	tests := []struct {
+		name     string
+		current  int64
+		previous int64
+		want     int64
+	}{
+		{name: "previous zero counts current delta", current: 120, previous: 0, want: 120},
+		{name: "monotonic counter uses difference", current: 250, previous: 200, want: 50},
+		{name: "counter reset uses current", current: 15, previous: 250, want: 15},
+		{name: "negative previous remains guarded", current: 15, previous: -1, want: 0},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			assert.Equal(t, test.want, computeTrafficDelta(test.current, test.previous))
+		})
+	}
+}
+
+func TestReportSaveLockSerializesSameClient(t *testing.T) {
+	clientUUID := "client-lock-same"
+	lock := getReportSaveLock(clientUUID)
+	lock.Lock()
+	defer lock.Unlock()
+
+	acquired := make(chan struct{})
+	go func() {
+		secondLock := getReportSaveLock(clientUUID)
+		secondLock.Lock()
+		defer secondLock.Unlock()
+		close(acquired)
+	}()
+
+	select {
+	case <-acquired:
+		t.Fatal("same-client report save lock was acquired while already held")
+	case <-time.After(20 * time.Millisecond):
+	}
+
+	lock.Unlock()
+	select {
+	case <-acquired:
+	case <-time.After(time.Second):
+		t.Fatal("same-client report save lock was not released")
+	}
+	lock.Lock()
+}
+
+func TestReportSaveLockAllowsDifferentClients(t *testing.T) {
+	firstLock := getReportSaveLock("client-lock-a")
+	firstLock.Lock()
+	defer firstLock.Unlock()
+
+	var waitGroup sync.WaitGroup
+	waitGroup.Add(1)
+	acquired := make(chan struct{})
+	go func() {
+		defer waitGroup.Done()
+		secondLock := getReportSaveLock("client-lock-b")
+		secondLock.Lock()
+		defer secondLock.Unlock()
+		close(acquired)
+	}()
+
+	select {
+	case <-acquired:
+	case <-time.After(time.Second):
+		t.Fatal("different-client report save lock should not block")
+	}
+	waitGroup.Wait()
+}

database/clipboard/clipboard.go

@@ -1,8 +1,8 @@
 package clipboard
 
 import (
-	"github.com/komari-monitor/komari/internal/database/models"
-	"github.com/komari-monitor/komari/internal/dbcore"
+	"github.com/komari-monitor/komari/database/dbcore"
+	"github.com/komari-monitor/komari/database/models"
 )
 
 // CreateClipboard 创建剪贴板记录

database/dbcore/dbcore.go

@@ -0,0 +1,308 @@
+package dbcore
+
+import (
+	"archive/zip"
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/komari-monitor/komari/cmd/flags"
+	"github.com/komari-monitor/komari/database/models"
+	"github.com/komari-monitor/komari/pkg/config"
+	"github.com/komari-monitor/komari/pkg/migrations"
+	logutil "github.com/komari-monitor/komari/utils/log"
+	"gorm.io/driver/sqlite"
+	"gorm.io/gorm"
+)
+
+// zipDirectoryExcluding 将 srcDir 打包为 dstZip，exclude 是绝对路径集合需要排除
+func zipDirectoryExcluding(srcDir, dstZip string, exclude map[string]struct{}) error {
+	// 规范化排除路径为绝对路径
+	normExclude := make(map[string]struct{}, len(exclude))
+	for p := range exclude {
+		abs, _ := filepath.Abs(p)
+		normExclude[abs] = struct{}{}
+	}
+
+	out, err := os.Create(dstZip)
+	if err != nil {
+		return err
+	}
+	defer out.Close()
+
+	zw := zip.NewWriter(out)
+	defer zw.Close()
+
+	absSrc, _ := filepath.Abs(srcDir)
+	walkErr := filepath.Walk(absSrc, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+		// 排除 backup.zip 本身
+		if _, ok := normExclude[path]; ok {
+			if info.IsDir() {
+				return filepath.SkipDir
+			}
+			return nil
+		}
+		// 计算 zip 内相对路径
+		rel, err := filepath.Rel(absSrc, path)
+		if err != nil {
+			return err
+		}
+		// 根目录跳过
+		if rel == "." {
+			return nil
+		}
+		// 替换为正斜杠
+		zipName := filepath.ToSlash(rel)
+
+		if info.IsDir() {
+			_, err := zw.Create(zipName + "/")
+			return err
+		}
+		// 普通文件
+		fh, err := os.Open(path)
+		if err != nil {
+			return err
+		}
+		w, err := zw.Create(zipName)
+		if err != nil {
+			fh.Close()
+			return err
+		}
+		if _, err := io.Copy(w, fh); err != nil {
+			fh.Close()
+			return err
+		}
+		fh.Close()
+		return nil
+	})
+	if walkErr != nil {
+		return walkErr
+	}
+	return zw.Close()
+}
+
+// removeAllInDirExcept 删除 dir 下除 exclude 指定绝对路径外的所有文件和文件夹
+func removeAllInDirExcept(dir string, exclude map[string]struct{}) error {
+	absDir, err := filepath.Abs(dir)
+	if err != nil {
+		return err
+	}
+	normExclude := make(map[string]struct{}, len(exclude))
+	for p := range exclude {
+		abs, _ := filepath.Abs(p)
+		normExclude[abs] = struct{}{}
+	}
+	entries, err := os.ReadDir(absDir)
+	if err != nil {
+		return err
+	}
+	for _, e := range entries {
+		full := filepath.Join(absDir, e.Name())
+		if _, ok := normExclude[full]; ok {
+			continue
+		}
+		if err := os.RemoveAll(full); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// unzipToDir 将 zipPath 解压到 dstDir，包含路径遍历保护
+func unzipToDir(zipPath, dstDir string) error {
+	zr, err := zip.OpenReader(zipPath)
+	if err != nil {
+		return err
+	}
+	defer zr.Close()
+
+	if err := os.MkdirAll(dstDir, 0755); err != nil {
+		return err
+	}
+	absDst, _ := filepath.Abs(dstDir)
+
+	for _, f := range zr.File {
+		// 构造目标路径并做路径遍历保护
+		cleanName := filepath.Clean(f.Name)
+		targetPath := filepath.Join(absDst, cleanName)
+		if !strings.HasPrefix(targetPath, absDst+string(os.PathSeparator)) && targetPath != absDst {
+			return fmt.Errorf("illegal file path in zip: %s", f.Name)
+		}
+		if f.FileInfo().IsDir() {
+			if err := os.MkdirAll(targetPath, 0755); err != nil {
+				return err
+			}
+			continue
+		}
+		if err := os.MkdirAll(filepath.Dir(targetPath), 0755); err != nil {
+			return err
+		}
+		rc, err := f.Open()
+		if err != nil {
+			return err
+		}
+		out, err := os.Create(targetPath)
+		if err != nil {
+			rc.Close()
+			return err
+		}
+		if _, err := io.Copy(out, rc); err != nil {
+			out.Close()
+			rc.Close()
+			return err
+		}
+		out.Close()
+		rc.Close()
+	}
+	return nil
+}
+
+var (
+	instance *gorm.DB
+	once     sync.Once
+)
+
+func GetDBInstance() *gorm.DB {
+	once.Do(func() {
+
+		var err error
+
+		// 在数据库初始化前执行：如果存在 ./data/backup.zip，则进行恢复逻辑
+		func() {
+			backupZipPath := filepath.Join(".", "data", "backup.zip")
+			if _, statErr := os.Stat(backupZipPath); statErr == nil {
+				// 4. 把除了 ./data/backup.zip 之外的所有文件压缩到 ./backup/{time}.zip
+				if err := os.MkdirAll("./backup", 0755); err != nil {
+					log.Printf("[restore] failed to create backup dir: %v", err)
+				} else {
+					tsName := time.Now().Format("20060102-150405")
+					bakPath := filepath.Join("./backup", fmt.Sprintf("%s.zip", tsName))
+					if zipErr := zipDirectoryExcluding("./data", bakPath, map[string]struct{}{backupZipPath: {}}); zipErr != nil {
+						log.Printf("[restore] failed to zip current data: %v", zipErr)
+					} else {
+						log.Printf("[restore] current data zipped to %s", bakPath)
+					}
+				}
+
+				// 5. 删除除了 ./data/backup.zip 之外的所有文件
+				if delErr := removeAllInDirExcept("./data", map[string]struct{}{backupZipPath: {}}); delErr != nil {
+					log.Printf("[restore] failed to cleanup data dir: %v", delErr)
+				}
+
+				// 6. 解压 ./data/backup.zip 到 ./data
+				if unzipErr := unzipToDir(backupZipPath, "./data"); unzipErr != nil {
+					log.Printf("[restore] failed to unzip backup into data: %v", unzipErr)
+				} else {
+					log.Printf("[restore] backup.zip extracted to ./data")
+				}
+
+				// 7. 删除 ./data/backup.zip
+				if rmErr := os.Remove(backupZipPath); rmErr != nil {
+					log.Printf("[restore] failed to remove backup.zip: %v", rmErr)
+				} else {
+					log.Printf("[restore] backup.zip removed")
+				}
+				// 8. 删除标记
+				if rmErr := os.Remove("./data/komari-backup-markup"); rmErr != nil {
+					log.Printf("[restore] failed to remove komari-backup-markup: %v", rmErr)
+				} else {
+					log.Printf("[restore] komari-backup-markup removed")
+				}
+			}
+		}()
+
+		logConfig := &gorm.Config{
+			Logger: logutil.NewGormLogger(),
+		}
+
+		// 根据数据库类型选择不同的连接方式
+		switch flags.ApplyDatabaseTypeNormalization() {
+		case flags.DatabaseTypeSQLite:
+			// SQLite 连接
+			instance, err = gorm.Open(sqlite.Open(flags.DatabaseFile), logConfig)
+			if err != nil {
+				log.Fatalf("Failed to connect to SQLite3 database: %v", err)
+			}
+			log.Printf("Using SQLite database file: %s", flags.DatabaseFile)
+			instance.Exec("PRAGMA wal = ON;")
+			if err := instance.Exec("PRAGMA journal_mode = WAL;").Error; err != nil {
+				log.Printf("Failed to enable WAL mode for SQLite: %v", err)
+			}
+			instance.Exec("PRAGMA synchronous = NORMAL;")
+			instance.Exec("PRAGMA cache_size = -65536;")
+			instance.Exec("PRAGMA temp_store = MEMORY;")
+			instance.Exec("PRAGMA wal_checkpoint(TRUNCATE);")
+		default:
+			log.Fatalf("Unsupported database type: %s (supported: %s)", flags.DatabaseType, flags.SupportedDatabaseTypes())
+		}
+		if err := migrations.Run(migrations.Context{DB: instance}); err != nil {
+			log.Fatalf("Failed to run startup migrations: %v", err)
+		}
+		config.SetDb(instance)
+		// 自动迁移模型
+		err = instance.AutoMigrate(
+			&models.User{},
+			&models.Client{},
+			&models.Record{},
+			&models.GPURecord{},
+			&models.Log{},
+			&models.Clipboard{},
+			&models.LoadNotification{},
+			&models.OfflineNotification{},
+			&models.TrafficReportNotification{},
+			&models.PingRecord{},
+			&models.PingTask{},
+			&models.OidcProvider{},
+			&models.MessageSenderProvider{},
+			&models.ThemeConfiguration{},
+		)
+		if err != nil {
+			log.Fatalf("Failed to create tables: %v", err)
+		}
+		err = instance.Table("records_long_term").AutoMigrate(
+			&models.Record{},
+		)
+		if err != nil {
+			log.Printf("Failed to create records_long_term table, it may already exist: %v", err)
+		}
+		err = instance.Table("gpu_records_long_term").AutoMigrate(
+			&models.GPURecord{},
+		)
+		if err != nil {
+			log.Printf("Failed to create gpu_records_long_term table, it may already exist: %v", err)
+		}
+		err = instance.AutoMigrate(
+			&models.Session{},
+		)
+		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)
+		}
+
+		// Manually create composite indexes
+		if flags.IsSQLite() {
+			instance.Exec("CREATE INDEX IF NOT EXISTS idx_record_client_time ON records(client, time)")
+			instance.Exec("CREATE INDEX IF NOT EXISTS idx_record_lt_client_time ON records_long_term(client, time)")
+			instance.Exec("CREATE INDEX IF NOT EXISTS idx_gpu_record_client_time ON gpu_records(client, time)")
+			instance.Exec("CREATE INDEX IF NOT EXISTS idx_gpu_record_lt_client_time ON gpu_records_long_term(client, time)")
+			instance.Exec("CREATE INDEX IF NOT EXISTS idx_ping_record_client_time ON ping_records(client, time)")
+		}
+
+	})
+
+	return instance
+}

database/messageSender.go

@@ -1,8 +1,8 @@
 package database
 
 import (
-	"github.com/komari-monitor/komari/internal/database/models"
-	"github.com/komari-monitor/komari/internal/dbcore"
+	"github.com/komari-monitor/komari/database/dbcore"
+	"github.com/komari-monitor/komari/database/models"
 )
 
 func GetAllMessageSenderConfigs() []models.MessageSenderProvider {

database/models/UTCTime.go

@@ -0,0 +1,121 @@
+package models
+
+import (
+	"database/sql/driver"
+	"fmt"
+	"log"
+	"os"
+	"strings"
+	"sync"
+	"time"
+)
+
+// LocalTime is a custom time type for GORM to handle time.Time correctly.
+// It ensures that all times are stored and retrieved based on the application's configured timezone.
+type LocalTime time.Time
+
+// Value implements the driver.Valuer interface.
+// It converts UTCTime to a TEXT format that the database understands.
+// The time is formatted as a string in the application's local timezone, without timezone information.
+func (t LocalTime) Value() (driver.Value, error) {
+	if time.Time(t).IsZero() {
+		return nil, nil
+	}
+	return time.Time(t).In(GetAppLocation()).Format("2006-01-02 15:04:05.0000000"), nil
+}
+
+// Scan implements the sql.Scanner interface.
+// It scans a value from the database into a UTCTime object.
+func (t *LocalTime) Scan(v interface{}) error {
+	if v == nil {
+		*t = LocalTime(time.Time{})
+		return nil
+	}
+
+	loc := GetAppLocation()
+
+	switch val := v.(type) {
+	case time.Time:
+		// CRITICAL FIX: When the driver reads a timezone-less string (e.g., "16:00:00"),
+		// it often incorrectly assumes it's UTC. We must correct this by re-interpreting
+		// the date and clock values in the application's actual timezone.
+		year, month, day := val.Date()
+		hour, min, sec := val.Clock()
+		nanosec := val.Nanosecond()
+		*t = LocalTime(time.Date(year, month, day, hour, min, sec, nanosec, loc))
+		return nil
+	case []byte:
+		return t.parseTime(string(val), loc)
+	case string:
+		return t.parseTime(val, loc)
+	default:
+		return fmt.Errorf("UTCTime scan source was not string, []byte or time.Time: %T (%v)", v, v)
+	}
+}
+
+// parseTime handles parsing a string into UTCTime.
+func (t *LocalTime) parseTime(timeStr string, loc *time.Location) error {
+	timeStr = strings.TrimSpace(timeStr)
+	if timeStr == "" {
+		*t = LocalTime(time.Time{})
+		return nil
+	}
+
+	layouts := []string{
+		time.RFC3339Nano, time.RFC3339,
+		"2006-01-02 15:04:05.0000000-07:00", "2006-01-02 15:04:05-07:00",
+		"2006-01-02 15:04:05.0000000", "2006-01-02 15:04:05", "2006-01-02",
+	}
+
+	for _, layout := range layouts {
+		if parsedTime, err := time.ParseInLocation(layout, timeStr, loc); err == nil {
+			*t = LocalTime(parsedTime)
+			return nil
+		}
+	}
+	return fmt.Errorf("unable to parse time string '%s' into UTCTime", timeStr)
+}
+
+// MarshalJSON implements the json.Marshaler interface.
+// Serializes UTCTime to JSON in RFC3339 format with the correct timezone offset.
+func (t LocalTime) MarshalJSON() ([]byte, error) {
+	if time.Time(t).IsZero() {
+		return []byte("null"), nil
+	}
+	formattedTime := time.Time(t).In(GetAppLocation()).Format(time.RFC3339)
+	return []byte(fmt.Sprintf(`"%s"`, formattedTime)), nil
+}
+
+// ToTime converts UTCTime to Go's native time.Time type.
+func (t LocalTime) ToTime() time.Time { return time.Time(t) }
+
+// FromTime converts Go's native time.Time type to UTCTime.
+func FromTime(t time.Time) LocalTime { return LocalTime(t) }
+
+// Now returns the current time in the application's configured location.
+func Now() LocalTime { return LocalTime(time.Now().In(GetAppLocation())) }
+
+var (
+	appLocation  *time.Location
+	locationOnce sync.Once
+)
+
+// GetAppLocation retrieves the application's global timezone from the "TZ" environment variable.
+func GetAppLocation() *time.Location {
+	locationOnce.Do(func() {
+		tz := os.Getenv("TZ")
+		if tz == "" {
+			tz = "UTC"
+		}
+		loc, err := time.LoadLocation(tz)
+		if err != nil {
+			log.Printf("Warning: Failed to load timezone '%s', falling back to UTC. Error: %v", tz, err)
+			appLocation = time.UTC
+		} else {
+			appLocation = loc
+		}
+		time.Local = appLocation
+		log.Printf("Application timezone is set to '%s'.", appLocation.String())
+	})
+	return appLocation
+}

database/models/clipboard.go

@@ -1,7 +1,7 @@
 package models
 
 type Clipboard struct {
-	Id        int       `json:"id" gorm:"primaryKey;autoIncrement"`
+	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"`

database/models/messageEvent/MessageEvent.go

@@ -8,4 +8,7 @@ const (
 	Login   = "Login"
 	Alert   = "Alert"
 	Traffic = "Traffic"
+	DReport = "DReport" // 日报
+	WReport = "WReport" // 周报
+	MReport = "MReport" // 月报
 )

database/models/messageSender.go

@@ -3,7 +3,7 @@ package models
 import "time"
 
 type MessageSenderProvider struct {
-	Name     string `json:"name" gorm:"primaryKey;type:varchar(100);not null"`
+	Name     string `json:"name" gorm:"primaryKey;unique;not null"`
 	Addition string `json:"addition" gorm:"type:longtext" default:"{}"`
 }
 

database/models/models.go

@@ -15,6 +15,7 @@ type Client struct {
 	Virtualization   string    `json:"virtualization" gorm:"type:varchar(50)"`
 	Arch             string    `json:"arch" gorm:"type:varchar(50)"`
 	CpuCores         int       `json:"cpu_cores" gorm:"type:int"`
+	CpuPhysicalCores int       `json:"cpu_physical_cores" gorm:"type:int"`
 	OS               string    `json:"os" gorm:"type:varchar(100)"`
 	KernelVersion    string    `json:"kernel_version" gorm:"type:varchar(100)"`
 	GpuName          string    `json:"gpu_name" gorm:"type:varchar(100)"`
@@ -57,8 +58,8 @@ type User struct {
 
 // Session manages user sessions
 type Session struct {
-	UUID            string    `json:"uuid" gorm:"type:varchar(36);index"`
-	Session         string    `json:"session" gorm:"type:varchar(255);primaryKey;not null"`
+	UUID            string    `json:"uuid" gorm:"type:varchar(36)"`
+	Session         string    `json:"session" gorm:"type:varchar(255);primaryKey;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)"`
@@ -87,6 +88,8 @@ type Record struct {
 	NetOut         int64     `json:"net_out" gorm:"type:bigint"`
 	NetTotalUp     int64     `json:"net_total_up" gorm:"type:bigint"`
 	NetTotalDown   int64     `json:"net_total_down" gorm:"type:bigint"`
+	TrafficUp      int64     `json:"traffic_up" gorm:"type:bigint"`
+	TrafficDown    int64     `json:"traffic_down" gorm:"type:bigint"`
 	Process        int       `json:"process"`
 	Connections    int       `json:"connections"`
 	ConnectionsUdp int       `json:"connections_udp"`
@@ -110,9 +113,21 @@ type GPURecord struct {
 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")
+	var bytes []byte
+	switch v := value.(type) {
+	case nil:
+		*sa = StringArray{}
+		return nil
+	case []byte:
+		bytes = v
+	case string:
+		bytes = []byte(v)
+	default:
+		return fmt.Errorf("failed to scan StringArray: unsupported value type %T", value)
+	}
+	if len(bytes) == 0 {
+		*sa = StringArray{}
+		return nil
 	}
 	return json.Unmarshal(bytes, sa)
 }

database/models/models_test.go

@@ -0,0 +1,30 @@
+package models
+
+import "testing"
+
+func TestStringArrayScanAcceptsSQLiteTextShapes(t *testing.T) {
+	tests := map[string]interface{}{
+		"bytes": []byte(`["a","b"]`),
+		"text":  `["a","b"]`,
+		"empty": "",
+		"nil":   nil,
+	}
+
+	for name, input := range tests {
+		t.Run(name, func(t *testing.T) {
+			var got StringArray
+			if err := got.Scan(input); err != nil {
+				t.Fatalf("scan StringArray: %v", err)
+			}
+			if input == "" || input == nil {
+				if len(got) != 0 {
+					t.Fatalf("expected empty StringArray, got %v", got)
+				}
+				return
+			}
+			if len(got) != 2 || got[0] != "a" || got[1] != "b" {
+				t.Fatalf("unexpected StringArray: %v", got)
+			}
+		})
+	}
+}

database/models/notification.go

@@ -21,3 +21,13 @@ type LoadNotification struct {
 	Interval     int         `json:"interval" gorm:"type:int;not null;default:15"`              // 监测间隔（分钟）
 	LastNotified LocalTime   `json:"last_notified"`                                             // 上次通知时间
 }
+
+// TrafficReportNotification 定义了流量定时报告的数据库模型
+type TrafficReportNotification struct {
+	Client     string `json:"client" gorm:"type:varchar(36);not null;index;unique;constraint:OnDelete:CASCADE,OnUpdate:CASCADE;foreignKey:client;references:UUID"`
+	ClientInfo Client `json:"client_info,omitempty" gorm:"foreignKey:Client;references:UUID"`
+	Enable     bool   `json:"enable" gorm:"type:boolean;default:false"`
+	Daily      bool   `json:"daily" gorm:"type:boolean;default:false"`  // 日报
+	Weekly     bool   `json:"weekly" gorm:"type:boolean;default:false"` // 周报
+	Monthly    bool   `json:"monthly" gorm:"type:boolean;default:false"` // 月报
+}

database/models/oauth.go

@@ -1,6 +1,6 @@
 package models
 
 type OidcProvider struct {
-	Name     string `json:"name" gorm:"primaryKey;type:varchar(100);not null"`
+	Name     string `json:"name" gorm:"primaryKey;unique;not null"`
 	Addition string `json:"addition" gorm:"type:longtext" default:"{}"`
 }

database/models/pingTask.go

@@ -0,0 +1,35 @@
+package models
+
+type PingRecord struct {
+	Client     string    `json:"client" gorm:"type:varchar(36);not null;index"`
+	ClientInfo Client    `json:"client_info" gorm:"foreignKey:Client;references:UUID;constraint:OnDelete:CASCADE,OnUpdate:CASCADE"`
+	TaskId     uint      `json:"task_id" gorm:"not null;index"`
+	Task       PingTask  `json:"task" gorm:"foreignKey:TaskId;references:Id;constraint:OnDelete:CASCADE,OnUpdate:CASCADE;"`
+	Time       LocalTime `json:"time" gorm:"index;not null"`
+	Value      int       `json:"value" gorm:"type:int;not null"` // Ping 值，单位毫秒
+}
+
+// PingTask 表示一次延迟监测任务配置。
+type PingTask struct {
+	Id        uint        `json:"id,omitempty" gorm:"primaryKey;autoIncrement"`
+	Weight    int         `json:"weight" gorm:"type:int;not null;default:0;index"`
+	Name      string      `json:"name" gorm:"type:varchar(255);not null;index"`
+	Clients   StringArray `json:"clients" gorm:"type:longtext"`
+	DefaultOn bool        `json:"default_on" gorm:"column:all_clients;not null;default:false"` // 新加入的服务器是否自动开启此监测；现有服务器不受此字段影响
+	Type      string      `json:"type" gorm:"type:varchar(12);not null;default:'icmp'"`        // icmp tcp http
+	Target    string      `json:"target" gorm:"type:varchar(255);not null"`                    // Ping 目标地址
+	Interval  int         `json:"interval" gorm:"type:int;not null;default:60"`                // 间隔时间
+}
+
+// AppliesToClient 判断当前 PingTask 是否适用于指定服务器。
+func (task PingTask) AppliesToClient(uuid string) bool {
+	if uuid == "" {
+		return false
+	}
+	for _, client := range task.Clients {
+		if client == uuid {
+			return true
+		}
+	}
+	return false
+}

database/models/task.go

@@ -1,7 +1,7 @@
 package models
 
 type Task struct {
-	TaskId  string       `json:"task_id" gorm:"type:varchar(36);primaryKey"`
+	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"`
 	Results []TaskResult `gorm:"foreignKey:TaskId;references:TaskId;constraint:OnDelete:CASCADE,OnUpdate:CASCADE"`

database/models/theme.go

@@ -0,0 +1,146 @@
+package models
+
+import (
+	"fmt"
+	"net/url"
+	"path"
+	"strings"
+)
+
+const (
+	ThemeConfigurationManaged  = "managed"
+	ThemeConfigurationRaw      = "raw"
+	ThemeConfigurationRedirect = "redirect"
+)
+
+// Theme represents a komari theme information
+type Theme struct {
+	Name          string        `json:"name"`          // 主题名称
+	Short         string        `json:"short"`         // 短名称，用作文件夹名
+	Description   string        `json:"description"`   // 主题描述
+	Version       string        `json:"version"`       // 版本号
+	Author        string        `json:"author"`        // 作者
+	URL           string        `json:"url"`           // 主题URL
+	Preview       string        `json:"preview"`       // 预览图片相对路径
+	Configuration Configuration `json:"configuration"` // 声明配置项
+}
+
+type Configuration struct {
+	Type string `json:"type"` // managed raw redirect
+	Icon string `json:"icon"` // 图标
+	Name any    `json:"name"`
+	Data any    `json:"data"` // 配置数据
+}
+
+type ManagedThemeConfigurationItem struct {
+	Key      string `json:"key"`
+	Name     any    `json:"name"`
+	Required bool   `json:"required"`
+	Type     string `json:"type"` // string number select switch title
+	Options  string `json:"options"`
+	Default  any    `json:"default"`
+	Help     any    `json:"help"`
+}
+
+type ThemeConfiguration struct {
+	Short string `json:"short" gorm:"primaryKey;unique;not null"`
+	Data  string `json:"data" gorm:"type:longtext" default:"{}"`
+}
+
+func (t Theme) ConfigurationType() string {
+	typ := strings.ToLower(strings.TrimSpace(t.Configuration.Type))
+	if typ == "" {
+		return ThemeConfigurationManaged
+	}
+	return typ
+}
+
+func (t Theme) RawHTML() (string, bool) {
+	if t.ConfigurationType() != ThemeConfigurationRaw {
+		return "", false
+	}
+	return configurationDataString(t.Configuration.Data)
+}
+
+func (t Theme) RedirectTarget() (string, bool) {
+	if t.ConfigurationType() != ThemeConfigurationRedirect {
+		return "", false
+	}
+	return NormalizeThemeRedirectTarget(t.Configuration.Data)
+}
+
+func (t Theme) ValidateConfiguration() error {
+	switch t.ConfigurationType() {
+	case ThemeConfigurationManaged:
+		return nil
+	case ThemeConfigurationRaw:
+		html, ok := t.RawHTML()
+		if !ok || strings.TrimSpace(html) == "" {
+			return fmt.Errorf("raw 类型主题需要在 configuration.data 中提供 HTML 字符串")
+		}
+		return nil
+	case ThemeConfigurationRedirect:
+		if _, ok := t.RedirectTarget(); !ok {
+			return fmt.Errorf("redirect 类型主题需要在 configuration.data 中提供站内相对路径")
+		}
+		return nil
+	default:
+		return fmt.Errorf("不支持的主题类型: %s", t.Configuration.Type)
+	}
+}
+
+func NormalizeThemeRedirectTarget(data any) (string, bool) {
+	target, ok := configurationDataString(data)
+	if !ok {
+		return "", false
+	}
+
+	target = strings.TrimSpace(target)
+	if target == "" || strings.Contains(target, "\\") || strings.HasPrefix(target, "//") {
+		return "", false
+	}
+
+	parsed, err := url.Parse(target)
+	if err != nil || parsed.IsAbs() || parsed.Host != "" {
+		return "", false
+	}
+
+	cleanInputPath := parsed.Path
+	if strings.HasPrefix(cleanInputPath, "/") {
+		cleanInputPath = strings.TrimLeft(cleanInputPath, "/")
+	} else {
+		for strings.HasPrefix(cleanInputPath, "../") {
+			cleanInputPath = strings.TrimPrefix(cleanInputPath, "../")
+		}
+	}
+
+	for _, segment := range strings.Split(cleanInputPath, "/") {
+		if segment == ".." {
+			return "", false
+		}
+	}
+
+	cleanPath := cleanInputPath
+	if cleanPath == "" {
+		cleanPath = "/"
+	} else {
+		cleanPath = path.Clean(cleanPath)
+		if cleanPath == "." {
+			cleanPath = "/"
+		} else {
+			cleanPath = "/" + strings.TrimPrefix(cleanPath, "/")
+		}
+	}
+
+	normalized := url.URL{
+		Path:     cleanPath,
+		RawQuery: parsed.RawQuery,
+		Fragment: parsed.Fragment,
+	}
+	return normalized.String(), true
+}
+
+func configurationDataString(data any) (string, bool) {
+	value, ok := data.(string)
+	return value, ok
+}

database/models/theme_test.go

@@ -0,0 +1,141 @@
+package models
+
+import "testing"
+
+func TestThemeValidateConfiguration(t *testing.T) {
+	tests := map[string]struct {
+		theme   Theme
+		wantErr bool
+	}{
+		"managed empty data": {
+			theme: Theme{
+				Configuration: Configuration{Type: ThemeConfigurationManaged},
+			},
+		},
+		"missing type defaults to managed": {
+			theme: Theme{},
+		},
+		"raw html": {
+			theme: Theme{
+				Configuration: Configuration{
+					Type: ThemeConfigurationRaw,
+					Data: "<!doctype html><title>raw</title>",
+				},
+			},
+		},
+		"raw rejects empty html": {
+			theme: Theme{
+				Configuration: Configuration{
+					Type: ThemeConfigurationRaw,
+					Data: "  ",
+				},
+			},
+			wantErr: true,
+		},
+		"redirect relative path": {
+			theme: Theme{
+				Configuration: Configuration{
+					Type: ThemeConfigurationRedirect,
+					Data: "/dashboard?tab=nodes",
+				},
+			},
+		},
+		"redirect rejects absolute url": {
+			theme: Theme{
+				Configuration: Configuration{
+					Type: ThemeConfigurationRedirect,
+					Data: "https://example.com",
+				},
+			},
+			wantErr: true,
+		},
+		"redirect rejects parent traversal": {
+			theme: Theme{
+				Configuration: Configuration{
+					Type: ThemeConfigurationRedirect,
+					Data: "/../admin",
+				},
+			},
+			wantErr: true,
+		},
+		"unknown type": {
+			theme: Theme{
+				Configuration: Configuration{Type: "hosted"},
+			},
+			wantErr: true,
+		},
+	}
+
+	for name, tt := range tests {
+		t.Run(name, func(t *testing.T) {
+			err := tt.theme.ValidateConfiguration()
+			if tt.wantErr && err == nil {
+				t.Fatal("expected error, got nil")
+			}
+			if !tt.wantErr && err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+		})
+	}
+}
+
+func TestNormalizeThemeRedirectTarget(t *testing.T) {
+	tests := map[string]struct {
+		input string
+		want  string
+		ok    bool
+	}{
+		"leading slash": {
+			input: "/nodes",
+			want:  "/nodes",
+			ok:    true,
+		},
+		"missing leading slash": {
+			input: "nodes",
+			want:  "/nodes",
+			ok:    true,
+		},
+		"parent prefix points to root path": {
+			input: "../settings",
+			want:  "/settings",
+			ok:    true,
+		},
+		"multiple parent prefixes point to root path": {
+			input: "../../settings/site",
+			want:  "/settings/site",
+			ok:    true,
+		},
+		"query and fragment": {
+			input: "nodes?id=1#cpu",
+			want:  "/nodes?id=1#cpu",
+			ok:    true,
+		},
+		"absolute parent traversal": {
+			input: "/../admin",
+		},
+		"nested parent traversal": {
+			input: "nodes/../admin",
+		},
+		"protocol relative": {
+			input: "//example.com",
+		},
+		"backslash": {
+			input: `\admin`,
+		},
+		"absolute url": {
+			input: "https://example.com",
+		},
+	}
+
+	for name, tt := range tests {
+		t.Run(name, func(t *testing.T) {
+			got, ok := NormalizeThemeRedirectTarget(tt.input)
+			if ok != tt.ok {
+				t.Fatalf("ok = %v, want %v", ok, tt.ok)
+			}
+			if got != tt.want {
+				t.Fatalf("target = %q, want %q", got, tt.want)
+			}
+		})
+	}
+}

database/notification/load.go

@@ -1,9 +1,9 @@
 package notification
 
 import (
-	"github.com/komari-monitor/komari/internal/database/models"
-	"github.com/komari-monitor/komari/internal/dbcore"
-	"github.com/komari-monitor/komari/internal/notifier"
+	"github.com/komari-monitor/komari/database/dbcore"
+	"github.com/komari-monitor/komari/database/models"
+	"github.com/komari-monitor/komari/utils/notifier"
 	"gorm.io/gorm"
 )
 
@@ -59,5 +59,10 @@ func SaveLoadNotification(record models.LoadNotification) error {
 }
 
 func ReloadLoadNotificationSchedule() error {
-	return notifier.ReloadLoadNotification()
+	db := dbcore.GetDBInstance()
+	var loadNotifications []models.LoadNotification
+	if err := db.Find(&loadNotifications).Error; err != nil {
+		return err
+	}
+	return notifier.ReloadLoadNotificationSchedule(loadNotifications)
 }

database/notification/traffic_report.go

@@ -0,0 +1,144 @@
+package notification
+
+import (
+	"fmt"
+
+	"github.com/komari-monitor/komari/database/dbcore"
+	"github.com/komari-monitor/komari/database/models"
+	"gorm.io/gorm/clause"
+)
+
+func validateTrafficReportNotification(notification models.TrafficReportNotification) error {
+	if notification.Client == "" {
+		return fmt.Errorf("client UUID cannot be empty")
+	}
+	if notification.Enable && !notification.Daily && !notification.Weekly && !notification.Monthly {
+		return fmt.Errorf("at least one cadence must be selected when enabling traffic reports")
+	}
+	return nil
+}
+
+func ValidateTrafficReportNotifications(notifications []models.TrafficReportNotification) error {
+	for _, notification := range notifications {
+		if err := validateTrafficReportNotification(notification); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func buildEnabledTrafficReportNotifications(uuids []string, existing []models.TrafficReportNotification) ([]models.TrafficReportNotification, error) {
+	if len(uuids) == 0 {
+		return nil, fmt.Errorf("at least one client UUID is required")
+	}
+
+	existingByClient := make(map[string]models.TrafficReportNotification, len(existing))
+	for _, notification := range existing {
+		existingByClient[notification.Client] = notification
+	}
+
+	notifications := make([]models.TrafficReportNotification, 0, len(uuids))
+	for _, uuid := range uuids {
+		if uuid == "" {
+			return nil, fmt.Errorf("client UUID cannot be empty")
+		}
+		existingNotification, ok := existingByClient[uuid]
+		if !ok || (!existingNotification.Daily && !existingNotification.Weekly && !existingNotification.Monthly) {
+			return nil, fmt.Errorf("at least one cadence must be selected when enabling traffic reports")
+		}
+		notifications = append(notifications, models.TrafficReportNotification{
+			Client: uuid,
+			Enable: true,
+		})
+	}
+
+	return notifications, nil
+}
+
+// ListTrafficReportNotifications 获取所有流量定时报告配置（关联客户端信息）
+func ListTrafficReportNotifications() ([]models.TrafficReportNotification, error) {
+	db := dbcore.GetDBInstance()
+	var notifications []models.TrafficReportNotification
+	err := db.Model(&models.TrafficReportNotification{}).Preload("ClientInfo").Find(&notifications).Error
+	return notifications, err
+}
+
+// EditTrafficReportNotifications 批量更新流量定时报告配置
+func EditTrafficReportNotifications(notifications []models.TrafficReportNotification) error {
+	if err := ValidateTrafficReportNotifications(notifications); err != nil {
+		return err
+	}
+	db := dbcore.GetDBInstance()
+	return db.Model(&models.TrafficReportNotification{}).
+		Clauses(clause.OnConflict{
+			Columns:   []clause.Column{{Name: "client"}},
+			DoUpdates: clause.AssignmentColumns([]string{"enable", "daily", "weekly", "monthly"}),
+		}).
+		Select("client", "enable", "daily", "weekly", "monthly").
+		Create(notifications).Error
+}
+
+// EnableTrafficReportNotifications 批量启用（仅更新 enable 字段）
+func EnableTrafficReportNotifications(uuids []string) error {
+	if len(uuids) == 0 {
+		return fmt.Errorf("at least one client UUID is required")
+	}
+
+	db := dbcore.GetDBInstance()
+	var existing []models.TrafficReportNotification
+	if err := db.Where("client IN ?", uuids).Find(&existing).Error; err != nil {
+		return err
+	}
+	notifications, err := buildEnabledTrafficReportNotifications(uuids, existing)
+	if err != nil {
+		return err
+	}
+	return db.Model(&models.TrafficReportNotification{}).
+		Clauses(clause.OnConflict{
+			Columns:   []clause.Column{{Name: "client"}},
+			DoUpdates: clause.AssignmentColumns([]string{"enable"}),
+		}).
+		Select("client", "enable").
+		Create(notifications).Error
+}
+
+// DisableTrafficReportNotifications 批量禁用
+func DisableTrafficReportNotifications(uuids []string) error {
+	if len(uuids) == 0 {
+		return fmt.Errorf("at least one client UUID is required")
+	}
+	db := dbcore.GetDBInstance()
+	var notifications []models.TrafficReportNotification
+	for _, uuid := range uuids {
+		if uuid == "" {
+			return fmt.Errorf("client UUID cannot be empty")
+		}
+		notifications = append(notifications, models.TrafficReportNotification{
+			Client: uuid,
+			Enable: false,
+		})
+	}
+	return db.Model(&models.TrafficReportNotification{}).
+		Clauses(clause.OnConflict{
+			Columns:   []clause.Column{{Name: "client"}},
+			DoUpdates: clause.AssignmentColumns([]string{"enable"}),
+		}).
+		Select("client", "enable").
+		Create(notifications).Error
+}
+
+// GetEnabledTrafficReportByType 获取启用了指定类型报告的客户端配置
+func GetEnabledTrafficReportByType(daily, weekly, monthly bool) ([]models.TrafficReportNotification, error) {
+	db := dbcore.GetDBInstance()
+	var notifications []models.TrafficReportNotification
+	query := db.Model(&models.TrafficReportNotification{}).Where("enable = ?", true)
+	if daily {
+		query = query.Where("daily = ?", true)
+	} else if weekly {
+		query = query.Where("weekly = ?", true)
+	} else if monthly {
+		query = query.Where("monthly = ?", true)
+	}
+	err := query.Find(&notifications).Error
+	return notifications, err
+}

database/notification/traffic_report_test.go

@@ -0,0 +1,36 @@
+package notification
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/komari-monitor/komari/database/models"
+)
+
+func TestValidateTrafficReportNotificationsRejectsEnabledWithoutCadence(t *testing.T) {
+	err := ValidateTrafficReportNotifications([]models.TrafficReportNotification{{
+		Client: "client-a",
+		Enable: true,
+	}})
+
+	assert.Error(t, err)
+}
+
+func TestBuildEnabledTrafficReportNotificationsRequiresExistingCadence(t *testing.T) {
+	_, err := buildEnabledTrafficReportNotifications([]string{"client-a"}, nil)
+	assert.Error(t, err)
+
+	_, err = buildEnabledTrafficReportNotifications([]string{"client-a"}, []models.TrafficReportNotification{{Client: "client-a"}})
+	assert.Error(t, err)
+
+	notifications, err := buildEnabledTrafficReportNotifications([]string{"client-a"}, []models.TrafficReportNotification{{
+		Client: "client-a",
+		Daily:  true,
+	}})
+	require.NoError(t, err)
+	require.Len(t, notifications, 1)
+	assert.Equal(t, "client-a", notifications[0].Client)
+	assert.True(t, notifications[0].Enable)
+}

database/oauth.go

@@ -1,8 +1,8 @@
 package database
 
 import (
-	"github.com/komari-monitor/komari/internal/database/models"
-	"github.com/komari-monitor/komari/internal/dbcore"
+	"github.com/komari-monitor/komari/database/dbcore"
+	"github.com/komari-monitor/komari/database/models"
 )
 
 func GetAllOidcConfigs() []models.OidcProvider {

database/records/records.go

@@ -8,8 +8,9 @@ import (
 
 	"gorm.io/gorm"
 
-	"github.com/komari-monitor/komari/internal/database/models"
-	"github.com/komari-monitor/komari/internal/dbcore"
+	"github.com/komari-monitor/komari/cmd/flags"
+	"github.com/komari-monitor/komari/database/dbcore"
+	"github.com/komari-monitor/komari/database/models"
 )
 
 func RecordOne(rec models.Record) error {
@@ -170,16 +171,28 @@ func CompactRecord() error {
 		log.Printf("Error migrating GPU records: %v", err)
 		return err
 	}
+
+	if flags.IsSQLite() {
+		db.Exec("PRAGMA wal_checkpoint(PASSIVE);")
+	}
+	//log.Printf("Record compaction completed")
 	return nil
 }
 
 func migrateOldRecords(db *gorm.DB) error {
-	// 计算 4 小时前的时间
-	fourHoursAgo := time.Now().Add(-4 * time.Hour)
+	return migrateOldRecordsAt(db, time.Now())
+}
+
+func compactRecordCutoff(now time.Time) time.Time {
+	return now.Add(-4 * time.Hour).Truncate(15 * time.Minute)
+}
+
+func migrateOldRecordsAt(db *gorm.DB, now time.Time) error {
+	cutoff := compactRecordCutoff(now)
 
 	// 查询 records 表中超过 4 小时的记录
 	var records []models.Record
-	if err := db.Table("records").Where("time < ?", fourHoursAgo).Find(&records).Error; err != nil {
+	if err := db.Table("records").Where("time < ?", cutoff).Find(&records).Error; err != nil {
 		return err
 	}
 
@@ -189,24 +202,29 @@ func migrateOldRecords(db *gorm.DB) error {
 
 	// 按 Client 和 15 分钟时间段分组，并存储所有记录以计算分位数
 	type groupData struct {
-		Cpu            []float32
-		Gpu            []float32
-		Load           []float32
-		Temp           []float32
-		Ram            []int64
-		RamTotal       []int64
-		Swap           []int64
-		SwapTotal      []int64
-		Disk           []int64
-		DiskTotal      []int64
-		NetIn          []int64
-		NetOut         []int64
-		NetTotalUp     []int64
-		NetTotalDown   []int64
-		Process        []int
-		Connections    []int
-		ConnectionsUdp []int
-		Uptime         []int64
+		Cpu             []float32
+		Gpu             []float32
+		Load            []float32
+		Temp            []float32
+		Ram             []int64
+		RamTotal        []int64
+		Swap            []int64
+		SwapTotal       []int64
+		Disk            []int64
+		DiskTotal       []int64
+		NetIn           []int64
+		NetOut          []int64
+		NetTotalUp      []int64
+		NetTotalDown    []int64
+		TrafficUp       int64
+		TrafficDown     int64
+		LatestTime      time.Time
+		LatestTotalUp   int64
+		LatestTotalDown int64
+		Process         []int
+		Connections     []int
+		ConnectionsUdp  []int
+		Uptime          []int64
 	}
 
 	groupedRecords := make(map[string]*groupData)
@@ -230,6 +248,13 @@ func migrateOldRecords(db *gorm.DB) error {
 		data.NetOut = append(data.NetOut, record.NetOut)
 		data.NetTotalUp = append(data.NetTotalUp, record.NetTotalUp)
 		data.NetTotalDown = append(data.NetTotalDown, record.NetTotalDown)
+		data.TrafficUp += record.TrafficUp
+		data.TrafficDown += record.TrafficDown
+		if data.LatestTime.IsZero() || record.Time.ToTime().After(data.LatestTime) {
+			data.LatestTime = record.Time.ToTime()
+			data.LatestTotalUp = record.NetTotalUp
+			data.LatestTotalDown = record.NetTotalDown
+		}
 		data.Process = append(data.Process, record.Process)
 		data.Connections = append(data.Connections, record.Connections)
 		data.ConnectionsUdp = append(data.ConnectionsUdp, record.ConnectionsUdp)
@@ -323,8 +348,10 @@ func migrateOldRecords(db *gorm.DB) error {
 				DiskTotal:      getIntPercentile(data.DiskTotal, high_percentile),
 				NetIn:          getIntPercentile(data.NetIn, 0.2),
 				NetOut:         getIntPercentile(data.NetOut, 0.2),
-				NetTotalUp:     getIntPercentile(data.NetTotalUp, high_percentile),
-				NetTotalDown:   getIntPercentile(data.NetTotalDown, high_percentile),
+				NetTotalUp:     data.LatestTotalUp,
+				NetTotalDown:   data.LatestTotalDown,
+				TrafficUp:      data.TrafficUp,
+				TrafficDown:    data.TrafficDown,
 				Process:        getInt32Percentile(data.Process, high_percentile),
 				Connections:    getInt32Percentile(data.Connections, high_percentile),
 				ConnectionsUdp: getInt32Percentile(data.ConnectionsUdp, high_percentile),
@@ -344,7 +371,7 @@ func migrateOldRecords(db *gorm.DB) error {
 		}
 
 		// 删除 records 表中的旧数据
-		if err := tx.Table("records").Where("time < ?", fourHoursAgo.Add(-1*time.Hour)).Delete(&models.Record{}).Error; err != nil {
+		if err := tx.Table("records").Where("time < ?", cutoff.Add(-1*time.Hour)).Delete(&models.Record{}).Error; err != nil {
 			return err
 		}
 
@@ -354,11 +381,11 @@ func migrateOldRecords(db *gorm.DB) error {
 
 // migrateGPURecords 压缩GPU记录数据
 func migrateGPURecords(db *gorm.DB) error {
-	fourHoursAgo := time.Now().Add(-4 * time.Hour)
+	cutoff := compactRecordCutoff(time.Now())
 
 	// 查询超过4小时的GPU记录
 	var gpuRecords []models.GPURecord
-	if err := db.Where("time < ?", fourHoursAgo).Find(&gpuRecords).Error; err != nil {
+	if err := db.Where("time < ?", cutoff).Find(&gpuRecords).Error; err != nil {
 		return err
 	}
 
@@ -488,7 +515,7 @@ func migrateGPURecords(db *gorm.DB) error {
 		}
 
 		// 删除已压缩的原始GPU数据
-		if err := tx.Where("time < ?", fourHoursAgo.Add(-1*time.Hour)).Delete(&models.GPURecord{}).Error; err != nil {
+		if err := tx.Where("time < ?", cutoff.Add(-1*time.Hour)).Delete(&models.GPURecord{}).Error; err != nil {
 			return err
 		}
 

database/records/records_test.go

@@ -0,0 +1,234 @@
+package records
+
+import (
+	"encoding/csv"
+	"os"
+	"strconv"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"gorm.io/driver/sqlite"
+	"gorm.io/gorm"
+
+	"github.com/komari-monitor/komari/database/models"
+)
+
+var uuid = "7901508c-304f-49aa-b84f-957c33ae6f8a"
+
+var _ = func() bool {
+	// 确保 Test 环境中使用 sqlite 内存数据库
+	return true
+}()
+
+// TestCompactRecord tests the database compaction logic by inserting 4h30m of data (one record per minute),
+// then running migrateOldRecords and verifying the aggregation and cleanup.
+func TestCompactRecord(t *testing.T) {
+	const totalMinutes = 12*60 + 30
+	now := time.Now().UTC().Truncate(time.Minute)
+	threshold := compactRecordCutoff(now)
+	overlapCutoff := threshold.Add(-1 * time.Hour)
+
+	// 使用 sqlite 内存数据库并迁移表结构
+	db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
+	assert.NoError(t, err)
+	assert.NoError(t, db.AutoMigrate(&models.Record{}))
+	assert.NoError(t, db.Table("records_long_term").AutoMigrate(&models.Record{}))
+
+	expectedGroups := make(map[time.Time]struct{})
+	expectedRawRemain := 0
+
+	// 插入数据
+	for i := 0; i < totalMinutes; i++ {
+		recTime := now.Add(-time.Duration(i) * time.Minute)
+		rec := models.Record{Client: uuid, Time: models.FromTime(recTime), Cpu: float32(i), Gpu: float32(i), Load: float32(i), Temp: float32(i), Ram: int64(i)}
+		err := db.Create(&rec).Error
+		assert.NoError(t, err)
+
+		if recTime.Before(threshold) {
+			slot := recTime.Truncate(15 * time.Minute)
+			expectedGroups[slot] = struct{}{}
+		}
+		if !recTime.Before(overlapCutoff) {
+			expectedRawRemain++
+		}
+	}
+
+	// 导出原始数据到 CSV
+	os.MkdirAll("../../data", 0755)
+	var origRecs []models.Record
+	db.Order("time desc").Find(&origRecs)
+	fOrig, err := os.Create("../../data/original.csv")
+	assert.NoError(t, err)
+	defer fOrig.Close()
+	wOrig := csv.NewWriter(fOrig)
+	defer wOrig.Flush()
+	wOrig.Write([]string{"Client", "Time", "Cpu", "Gpu", "Load", "Temp", "Ram"})
+	for _, r := range origRecs {
+		wOrig.Write([]string{
+			r.Client,
+			r.Time.ToTime().Format(time.RFC3339),
+			strconv.FormatFloat(float64(r.Cpu), 'f', -1, 32),
+			strconv.FormatFloat(float64(r.Gpu), 'f', -1, 32),
+			strconv.FormatFloat(float64(r.Load), 'f', -1, 32),
+			strconv.FormatFloat(float64(r.Temp), 'f', -1, 32),
+			strconv.FormatInt(r.Ram, 10),
+		})
+	}
+
+	// 运行压缩（迁移）逻辑
+	err = migrateOldRecordsAt(db, now)
+	assert.NoError(t, err)
+
+	// 验证 long-term 表中的聚合记录数
+	var longCount int64
+	assert.NoError(t, db.Table("records_long_term").Count(&longCount).Error)
+	assert.Equal(t, int64(len(expectedGroups)), longCount)
+
+	// 验证原始表中剩余记录数
+	var remainCount int64
+	assert.NoError(t, db.Table("records").Count(&remainCount).Error)
+	assert.Equal(t, int64(expectedRawRemain), remainCount)
+
+	// 导出压缩后的数据到 CSV
+	var compRecs []models.Record
+	db.Table("records_long_term").Order("time desc").Find(&compRecs)
+	fComp, err := os.Create("../../data/compressed.csv")
+	assert.NoError(t, err)
+	defer fComp.Close()
+	wComp := csv.NewWriter(fComp)
+	defer wComp.Flush()
+	wComp.Write([]string{"Client", "Time", "Cpu", "Gpu", "Load", "Temp", "Ram"})
+	for _, r := range compRecs {
+		wComp.Write([]string{
+			r.Client,
+			r.Time.ToTime().Format(time.RFC3339),
+			strconv.FormatFloat(float64(r.Cpu), 'f', -1, 32),
+			strconv.FormatFloat(float64(r.Gpu), 'f', -1, 32),
+			strconv.FormatFloat(float64(r.Load), 'f', -1, 32),
+			strconv.FormatFloat(float64(r.Temp), 'f', -1, 32),
+			strconv.FormatInt(r.Ram, 10),
+		})
+	}
+
+	db.Table("records").Order("time desc").Find(&compRecs)
+	fComp, err = os.Create("../../data/compressed_records.csv")
+	assert.NoError(t, err)
+	defer fComp.Close()
+	wComp = csv.NewWriter(fComp)
+	defer wComp.Flush()
+	wComp.Write([]string{"Client", "Time", "Cpu", "Gpu", "Load", "Temp", "Ram"})
+	for _, r := range compRecs {
+		wComp.Write([]string{
+			r.Client,
+			r.Time.ToTime().Format(time.RFC3339),
+			strconv.FormatFloat(float64(r.Cpu), 'f', -1, 32),
+			strconv.FormatFloat(float64(r.Gpu), 'f', -1, 32),
+			strconv.FormatFloat(float64(r.Load), 'f', -1, 32),
+			strconv.FormatFloat(float64(r.Temp), 'f', -1, 32),
+			strconv.FormatInt(r.Ram, 10),
+		})
+	}
+}
+
+func TestCompactRecordPreservesExactTrafficDelta(t *testing.T) {
+	currentTime := time.Now().UTC().Truncate(time.Minute)
+	now := currentTime.Truncate(15 * time.Minute).Add(-5*time.Hour + time.Minute)
+	db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
+	assert.NoError(t, err)
+	assert.NoError(t, db.AutoMigrate(&models.Record{}))
+	assert.NoError(t, db.Table("records_long_term").AutoMigrate(&models.Record{}))
+
+	records := []models.Record{
+		{
+			Client:       uuid,
+			Time:         models.FromTime(now),
+			NetTotalUp:   100,
+			NetTotalDown: 200,
+			TrafficUp:    0,
+			TrafficDown:  0,
+		},
+		{
+			Client:       uuid,
+			Time:         models.FromTime(now.Add(5 * time.Minute)),
+			NetTotalUp:   150,
+			NetTotalDown: 260,
+			TrafficUp:    50,
+			TrafficDown:  60,
+		},
+		{
+			Client:       uuid,
+			Time:         models.FromTime(now.Add(10 * time.Minute)),
+			NetTotalUp:   10,
+			NetTotalDown: 30,
+			TrafficUp:    10,
+			TrafficDown:  30,
+		},
+	}
+
+	for _, rec := range records {
+		assert.NoError(t, db.Create(&rec).Error)
+	}
+
+	assert.NoError(t, migrateOldRecordsAt(db, currentTime))
+
+	var compacted []models.Record
+	assert.NoError(t, db.Table("records_long_term").Find(&compacted).Error)
+	assert.Len(t, compacted, 1)
+	assert.Equal(t, int64(60), compacted[0].TrafficUp)
+	assert.Equal(t, int64(90), compacted[0].TrafficDown)
+	assert.Equal(t, int64(10), compacted[0].NetTotalUp)
+	assert.Equal(t, int64(30), compacted[0].NetTotalDown)
+	assert.True(t, compacted[0].Time.ToTime().Equal(records[2].Time.ToTime().Truncate(15*time.Minute)))
+}
+
+func TestCompactRecordRetainsOneHourOverlapWindow(t *testing.T) {
+	now := time.Date(2026, 6, 7, 12, 7, 0, 0, time.UTC)
+	cutoff := compactRecordCutoff(now)
+	db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
+	assert.NoError(t, err)
+	assert.NoError(t, db.AutoMigrate(&models.Record{}))
+	assert.NoError(t, db.Table("records_long_term").AutoMigrate(&models.Record{}))
+
+	records := []models.Record{
+		{Client: uuid, Time: models.FromTime(cutoff.Add(-time.Hour - time.Minute)), TrafficUp: 5},
+		{Client: uuid, Time: models.FromTime(cutoff.Add(-30 * time.Minute)), TrafficUp: 7},
+		{Client: uuid, Time: models.FromTime(now.Add(-3 * time.Hour)), TrafficUp: 11},
+	}
+	for _, rec := range records {
+		assert.NoError(t, db.Create(&rec).Error)
+	}
+
+	assert.NoError(t, migrateOldRecordsAt(db, now))
+
+	var remainTimes []models.Record
+	assert.NoError(t, db.Table("records").Order("time ASC").Find(&remainTimes).Error)
+	assert.Len(t, remainTimes, 2)
+	assert.True(t, remainTimes[0].Time.ToTime().Equal(records[1].Time.ToTime()))
+	assert.True(t, remainTimes[1].Time.ToTime().Equal(records[2].Time.ToTime()))
+}
+
+func TestCompactRecordOnlyMigratesCompleteFifteenMinuteBuckets(t *testing.T) {
+	now := time.Date(2026, 6, 7, 12, 7, 0, 0, time.UTC)
+	cutoff := compactRecordCutoff(now)
+	db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
+	assert.NoError(t, err)
+	assert.NoError(t, db.AutoMigrate(&models.Record{}))
+	assert.NoError(t, db.Table("records_long_term").AutoMigrate(&models.Record{}))
+
+	compactable := models.Record{Client: uuid, Time: models.FromTime(cutoff.Add(-time.Minute)), TrafficUp: 5}
+	partialSlot := models.Record{Client: uuid, Time: models.FromTime(cutoff.Add(time.Minute)), TrafficUp: 7}
+	assert.NoError(t, db.Create(&compactable).Error)
+	assert.NoError(t, db.Create(&partialSlot).Error)
+
+	assert.NoError(t, migrateOldRecordsAt(db, now))
+
+	var compacted []models.Record
+	assert.NoError(t, db.Table("records_long_term").Order("time ASC").Find(&compacted).Error)
+	assert.Len(t, compacted, 1)
+	assert.True(t, compacted[0].Time.ToTime().Equal(compactable.Time.ToTime().Truncate(15*time.Minute)))
+
+	var rawCount int64
+	assert.NoError(t, db.Table("records").Where("time = ?", partialSlot.Time).Count(&rawCount).Error)
+	assert.Equal(t, int64(1), rawCount)
+}

database/tasks/ping.go

@@ -0,0 +1,217 @@
+package tasks
+
+import (
+	"time"
+
+	"github.com/komari-monitor/komari/database/dbcore"
+	"github.com/komari-monitor/komari/database/models"
+	"github.com/komari-monitor/komari/utils"
+	"gorm.io/gorm"
+)
+
+// AddPingTask 创建延迟监测任务。defaultOn 表示新加入的服务器是否自动开启此监测。
+func AddPingTask(clients []string, defaultOn bool, name string, target, task_type string, interval int) (uint, error) {
+	db := dbcore.GetDBInstance()
+	normalizedClients := normalizePingClients(models.StringArray(clients))
+	task := models.PingTask{
+		Clients:   normalizedClients,
+		DefaultOn: defaultOn,
+		Name:      name,
+		Type:      task_type,
+		Target:    target,
+		Interval:  interval,
+	}
+	err := db.Transaction(func(tx *gorm.DB) error {
+		if err := tx.Create(&task).Error; err != nil {
+			return err
+		}
+
+		// Append by id to avoid races between concurrent create requests.
+		result := tx.Model(&models.PingTask{}).Where("id = ?", task.Id).Update("weight", int(task.Id))
+		if result.Error != nil {
+			return result.Error
+		}
+		if result.RowsAffected == 0 {
+			return gorm.ErrRecordNotFound
+		}
+
+		return nil
+	})
+	if err != nil {
+		return 0, err
+	}
+	ReloadPingSchedule()
+	return task.Id, nil
+}
+
+func DeletePingTask(id []uint) error {
+	db := dbcore.GetDBInstance()
+	result := db.Where("id IN ?", id).Delete(&models.PingTask{})
+	if result.RowsAffected == 0 {
+		return gorm.ErrRecordNotFound
+	}
+	ReloadPingSchedule()
+	return result.Error
+}
+
+// EditPingTask 批量更新延迟监测任务配置。
+func EditPingTask(tasks []*models.PingTask) error {
+	db := dbcore.GetDBInstance()
+	for _, task := range tasks {
+		task.Clients = normalizePingClients(task.Clients)
+		// 使用 map 显式更新，避免 GORM struct Updates 跳过 false/0/空切片等零值。
+		updates := map[string]interface{}{
+			"name":        task.Name,
+			"clients":     task.Clients,
+			"all_clients": task.DefaultOn,
+			"type":        task.Type,
+			"target":      task.Target,
+			"interval":    task.Interval,
+		}
+		result := db.Model(&models.PingTask{}).Where("id = ?", task.Id).Updates(updates)
+		if result.RowsAffected == 0 {
+			return gorm.ErrRecordNotFound
+		}
+	}
+	ReloadPingSchedule()
+	return nil
+}
+
+// normalizePingClients 保持 clients 字段序列化为 JSON 数组，避免空值变成 null。
+func normalizePingClients(clients models.StringArray) models.StringArray {
+	if clients == nil {
+		return models.StringArray{}
+	}
+	return clients
+}
+
+func GetAllPingTasks() ([]models.PingTask, error) {
+	db := dbcore.GetDBInstance()
+	var tasks []models.PingTask
+	if err := db.Order("weight ASC").Order("id ASC").Find(&tasks).Error; err != nil {
+		return nil, err
+	}
+	return tasks, nil
+}
+
+// GetPingTasksByClient 获取指定服务器需要执行的延迟监测任务。
+func GetPingTasksByClient(uuid string) []models.PingTask {
+	db := dbcore.GetDBInstance()
+	var tasks []models.PingTask
+	if err := db.Where("clients LIKE ?", `%"`+uuid+`"%`).Find(&tasks).Error; err != nil {
+		return nil
+	}
+	return tasks
+}
+
+func UpdatePingTaskOrder(order map[uint]int) error {
+	db := dbcore.GetDBInstance()
+	err := db.Transaction(func(tx *gorm.DB) error {
+		for id, weight := range order {
+			result := tx.Model(&models.PingTask{}).Where("id = ?", id).Update("weight", weight)
+			if result.Error != nil {
+				return result.Error
+			}
+			if result.RowsAffected == 0 {
+				return gorm.ErrRecordNotFound
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		return err
+	}
+	ReloadPingSchedule()
+	return nil
+}
+
+func SavePingRecord(record models.PingRecord) error {
+	db := dbcore.GetDBInstance()
+	return db.Create(&record).Error
+}
+
+func DeletePingRecordsBefore(time time.Time) error {
+	db := dbcore.GetDBInstance()
+	err := db.Where("time < ?", time).Delete(&models.PingRecord{}).Error
+	return err
+}
+
+func DeletePingRecords(id []uint) error {
+	db := dbcore.GetDBInstance()
+	result := db.Where("task_id IN ?", id).Delete(&models.PingRecord{})
+	if result.RowsAffected == 0 {
+		return gorm.ErrRecordNotFound
+	}
+	return result.Error
+}
+
+func DeleteAllPingRecords() error {
+	db := dbcore.GetDBInstance()
+	result := db.Exec("DELETE FROM ping_records")
+	if result.RowsAffected == 0 {
+		return gorm.ErrRecordNotFound
+	}
+	return result.Error
+}
+func ReloadPingSchedule() error {
+	db := dbcore.GetDBInstance()
+	var pingTasks []models.PingTask
+	if err := db.Find(&pingTasks).Error; err != nil {
+		return err
+	}
+	return utils.ReloadPingSchedule(pingTasks)
+}
+
+// AddDefaultOnClientUUID 在新客户端注册后，把该 UUID 追加到所有 default_on=true 的任务的 clients 中（去重）。
+func AddDefaultOnClientUUID(uuid string) error {
+	if uuid == "" {
+		return nil
+	}
+	db := dbcore.GetDBInstance()
+	var tasks []models.PingTask
+	if err := db.Where("all_clients = ?", true).Find(&tasks).Error; err != nil {
+		return err
+	}
+	if len(tasks) == 0 {
+		return nil
+	}
+	changed := false
+	for _, task := range tasks {
+		exists := false
+		for _, c := range task.Clients {
+			if c == uuid {
+				exists = true
+				break
+			}
+		}
+		if exists {
+			continue
+		}
+		next := append(models.StringArray{}, task.Clients...)
+		next = append(next, uuid)
+		if err := db.Model(&models.PingTask{}).Where("id = ?", task.Id).Update("clients", next).Error; err != nil {
+			return err
+		}
+		changed = true
+	}
+	if changed {
+		return ReloadPingSchedule()
+	}
+	return nil
+}
+
+func GetPingRecords(uuid string, taskId int, start, end time.Time) ([]models.PingRecord, error) {
+	db := dbcore.GetDBInstance()
+	var records []models.PingRecord
+	dbQuery := db.Model(&models.PingRecord{})
+	if uuid != "" {
+		dbQuery = dbQuery.Where("client = ?", uuid)
+	}
+	if taskId >= 0 {
+		dbQuery = dbQuery.Where("task_id = ?", uint(taskId))
+	}
+	if err := dbQuery.Where("time >= ? AND time <= ?", start, end).Order("time DESC").Find(&records).Error; err != nil {
+		return nil, err
+	}
+	return records, nil
+}

database/tasks/tasks.go

@@ -3,10 +3,8 @@ package tasks
 import (
 	"time"
 
-	"github.com/gookit/event"
-	"github.com/komari-monitor/komari/internal/database/models"
-	"github.com/komari-monitor/komari/internal/dbcore"
-	"github.com/komari-monitor/komari/internal/eventType"
+	"github.com/komari-monitor/komari/database/dbcore"
+	"github.com/komari-monitor/komari/database/models"
 )
 
 func CreateTask(taskId string, clients []string, command string) error {
@@ -34,11 +32,6 @@ func CreateTask(taskId string, clients []string, command string) error {
 	if len(taskResults) > 0 {
 		return db.Create(&taskResults).Error
 	}
-	event.Trigger(eventType.TaskCreated, event.M{
-		"task":    taskId,
-		"clients": clients,
-		"command": command,
-	})
 	return nil
 }
 func GetTaskByTaskId(taskId string) (*models.Task, error) {

database/utils.go

@@ -8,16 +8,60 @@ import (
 	"strings"
 
 	"github.com/gin-gonic/gin"
-	"github.com/komari-monitor/komari/internal/conf"
-	"github.com/komari-monitor/komari/internal/database/models"
-	"github.com/komari-monitor/komari/internal/dbcore"
+	"github.com/komari-monitor/komari/database/dbcore"
+	"github.com/komari-monitor/komari/database/models"
+	"github.com/komari-monitor/komari/pkg/config"
 )
 
-func GetPublicInfo() (any, error) {
-	cst, err := conf.GetWithV1Format()
+func GetPublicInfo() (map[string]interface{}, error) {
+	cstPtr, err := config.GetManyAs[config.Settings]()
 	if err != nil {
 		return nil, err
 	}
+	cst := *cstPtr
+
+	all, allErr := config.GetAll()
+	hasKey := func(k string) bool {
+		if allErr != nil {
+			return false
+		}
+		_, ok := all[k]
+		return ok
+	}
+
+	// Apply defaults only when a key is missing.
+	if !hasKey("sitename") {
+		cst.Sitename = "Komari"
+	}
+	if !hasKey("description") {
+		cst.Description = "Komari Monitor, a simple server monitoring tool."
+	}
+	if !hasKey("theme") {
+		cst.Theme = "default"
+	}
+	if !hasKey("o_auth_provider") {
+		cst.OAuthProvider = "github"
+	}
+	if !hasKey("record_enabled") {
+		cst.RecordEnabled = true
+	}
+	if !hasKey("record_preserve_time") {
+		cst.RecordPreserveTime = 720
+	}
+	if !hasKey("ping_record_preserve_time") {
+		cst.PingRecordPreserveTime = 24
+	}
+
+	// Fallback defaults if we couldn't enumerate keys.
+	if allErr != nil {
+		if cst.Sitename == "" {
+			cst.Sitename = "Komari"
+		}
+		if cst.Description == "" {
+			cst.Description = "Komari Monitor, a simple server monitoring tool."
+		}
+	}
+
 	db := dbcore.GetDBInstance()
 	tc := models.ThemeConfiguration{}
 	err = db.Model(&models.ThemeConfiguration{}).Where("short = ?", cst.Theme).First(&tc).Error
@@ -90,7 +134,7 @@ func GetPublicInfo() (any, error) {
 		"oauth_enable":              cst.OAuthEnabled,
 		"oauth_provider":            cst.OAuthProvider,
 		"disable_password_login":    cst.DisablePasswordLogin,
-		"allow_cors":                cst.AllowCors,
+		"cors_origin_check_enabled": cst.CorsOriginCheckEnabled,
 		"record_enabled":            cst.RecordEnabled,
 		"record_preserve_time":      cst.RecordPreserveTime,
 		"ping_record_preserve_time": cst.PingRecordPreserveTime,

docs/README_ja.md

@@ -4,15 +4,15 @@
 
 ![komari](https://socialify.git.ci/komari-monitor/komari/image?description=1&font=Inter&forks=1&issues=1&language=1&logo=https%3A%2F%2Fraw.githubusercontent.com%2Fkomari-monitor%2Fkomari-web%2Fd54ce1288df41ead08aa19f8700186e68028a889%2Fpublic%2Ffavicon.png&name=1&owner=1&pattern=Plus&pulls=1&stargazers=1&theme=Auto)
 
-Komari は、サーバーのパフォーマンスを監視するためのシンプルで効率的なソリューションを提供することを目的とした、軽量の自己ホスト型サーバー監視ツールです。Web インターフェースを介してサーバーのステータスを表示し、軽量エージェントを介してデータを収集します。
+Komariは、サーバーのパフォーマンスを監視するためのシンプルで効率的なソリューションを提供することを目的とした、軽量の自己ホスト型サーバー監視ツールです。Webインターフェースを介してサーバーのステータスを表示し、軽量エージェントを介してデータを収集します。
 
-[ドキュメント](https://komari-document.pages.dev/) | [Telegram グループ](https://t.me/komari_monitor)
+[ドキュメント](https://komari-document.pages.dev/) | [Telegramグループ](https://t.me/komari_monitor)
 
 ## 特徴
 
 - **軽量で効率的**: リソース消費が少なく、あらゆる規模のサーバーに適しています。
 - **自己ホスト型**: データプライバシーを完全に制御でき、展開も簡単です。
-- **Web インターフェース**: 直感的な監視ダッシュボードで、使いやすいです。
+- **Webインターフェース**: 直感的な監視ダッシュボードで、使いやすいです。
 
 ## クイックスタート
 
@@ -22,9 +22,13 @@ Komari は、サーバーのパフォーマンスを監視するためのシン
 
 [![](https://rainyun-apps.cn-nb1.rains3.com/materials/deploy-on-rainyun-cn.svg)](https://app.rainyun.com/apps/rca/store/6780/NzYxNzAz_)
 
+- 1Panel アプリストア
+
+1Panel アプリストアで利用可能です。「アプリストア」>「ユーティリティ」>「Komari」からインストールしてください。
+
 ### 1. ワンクリックインストールスクリプトを使用する
 
-systemd を使用するディストリビューション（Ubuntu、Debian など）に適しています。
+systemdを使用するディストリビューション（Ubuntu、Debianなど）に適しています。
 
 ```bash
 curl -fsSL https://raw.githubusercontent.com/komari-monitor/komari/main/install-komari.sh -o install-komari.sh
@@ -32,13 +36,13 @@ chmod +x install-komari.sh
 sudo ./install-komari.sh
 ```
 
-### 2. Docker 展開
+### 2. Docker展開
 
 1. データディレクトリを作成します:
    ```bash
    mkdir -p ./data
    ```
-2. Docker コンテナを実行します:
+2. Dockerコンテナを実行します:
    ```bash
    docker run -d \
      -p 25774:25774 \
@@ -57,8 +61,8 @@ sudo ./install-komari.sh
 
 ### 3. バイナリファイル展開
 
-1. Komari の[GitHub リリース](https://github.com/komari-monitor/komari/releases)ページにアクセスして、お使いのオペレーティングシステム用の最新のバイナリをダウンロードします。
-2. Komari を実行します:
+1. Komariの[GitHubリリース](https://github.com/komari-monitor/komari/releases)ページにアクセスして、お使いのオペレーティングシステム用の最新のバイナリをダウンロードします。
+2. Komariを実行します:
    ```bash
    ./komari server -l 0.0.0.0:25774
    ```
@@ -72,7 +76,7 @@ sudo ./install-komari.sh
 
 #### 依存関係
 
-- Go 1.24+ および Node.js 20+（手動ビルド用）
+- Go 1.18+ および Node.js 20+（手動ビルド用）
 
 1. フロントエンドの静的ファイルをビルドします:
    ```bash
@@ -86,7 +90,7 @@ sudo ./install-komari.sh
    git clone https://github.com/komari-monitor/komari
    cd komari
    ```
-   ステップ 1 で生成された静的ファイルを `komari` プロジェクトのルートにある `/public/dist` フォルダにコピーします。
+   ステップ1で生成された静的ファイルを `komari` プロジェクトのルートにある `/web/public/defaultTheme/dist` フォルダにコピーし、`komari-theme.json` と `preview.png`/`perview.png` を `/web/public/defaultTheme` にコピーします。
    ```bash
    go build -o komari
    ```
@@ -98,20 +102,24 @@ sudo ./install-komari.sh
 
 ## フロントエンド開発ガイド
 
-[Komari テーマ開発ガイド | Komari](https://komari-document.pages.dev/dev/theme.html)
+[Komariテーマ開発ガイド | Komari](https://komari-document.pages.dev/dev/theme.html)
 
-[Crowdin で Komari を翻訳する](https://crowdin.com/project/komari/invite?h=cd051bf172c9a9f7f1360e87ffb521692507706)
+[CrowdinでKomariを翻訳する](https://crowdin.com/project/komari/invite?h=cd051bf172c9a9f7f1360e87ffb521692507706)
 
 ## クライアントエージェント開発ガイド
 
-[Komari エージェント情報レポートおよびイベント処理ドキュメント](https://komari-document.pages.dev/dev/agent.html)
+[Komariエージェント情報レポートおよびイベント処理ドキュメント](https://komari-document.pages.dev/dev/agent.html)
 
 ## 貢献
 
-Issue や Pull Request を歓迎します！
+IssueやPull Requestを歓迎します！
 
 ## 謝辞
 
+### 破碎工坊云 (Crash Work)
+
+[破碎工坊云 - 効率的で安定した、安全な高防御サーバーとCDNソリューションを提供する専門的なクラウドコンピューティングプラットフォーム](https://www.crash.work/)
+
 ### DreamCloud
 
 [DreamCloud - コストパフォーマンスに優れたアジア太平洋向け高防御直通](https://as211392.com/)
@@ -130,6 +138,6 @@ PR を送ってくれた方、テーマを作成してくれた全ての開発
 
 —— そして：こんなに暇でいられる自分に感謝
 
-## Star 履歴
+## Star履歴
 
 [![Star History Chart](https://api.star-history.com/svg?repos=komari-monitor/komari&type=Date)](https://www.star-history.com/#komari-monitor/komari&Date)

docs/README_zh-TW.md

@@ -22,6 +22,10 @@ Komari 是一款輕量級的自託管伺服器監控工具，旨在提供簡單
 
 [![](https://rainyun-apps.cn-nb1.rains3.com/materials/deploy-on-rainyun-cn.svg)](https://app.rainyun.com/apps/rca/store/6780/NzYxNzAz_)
 
+- 1Panel 應用商店
+
+已上架 1Panel 應用商店，應用商店-實用工具-Komari 即可安裝
+
 ### 1. 使用一鍵安裝腳本
 
 適用於使用了 systemd 的發行版（Ubuntu、Debian...）。
@@ -72,7 +76,7 @@ sudo ./install-komari.sh
 
 #### 依賴
 
-- Go 1.24+ 和 Node.js 20+（手工建置）
+- Go 1.18+ 和 Node.js 20+（手工建置）
 
 1. 建置前端靜態檔案：
    ```bash
@@ -86,7 +90,7 @@ sudo ./install-komari.sh
    git clone https://github.com/komari-monitor/komari
    cd komari
    ```
-   將步驟 1 中產生的靜態檔案複製到 `komari` 專案根目錄下的 `/public/dist` 資料夾。
+   將步驟1中產生的靜態檔案複製到 `komari` 專案根目錄下的 `/web/public/defaultTheme/dist` 資料夾，並將 `komari-theme.json` 與 `preview.png`/`perview.png` 複製到 `/web/public/defaultTheme`。
    ```bash
    go build -o komari
    ```
@@ -112,6 +116,10 @@ sudo ./install-komari.sh
 
 ## 鳴謝
 
+### 破碎工坊雲
+
+[破碎工坊雲 - 專業雲計算服務平台，提供高效、穩定、安全的高防伺服器與CDN解決方案](https://www.crash.work/)
+
 ### DreamCloud
 
 [DreamCloud - 極高性價比解鎖直連亞太高防](https://as211392.com/)

docs/README_zh.md

@@ -22,6 +22,10 @@ Komari 是一款轻量级的自托管服务器监控工具，旨在提供简单
 
 [![](https://rainyun-apps.cn-nb1.rains3.com/materials/deploy-on-rainyun-cn.svg)](https://app.rainyun.com/apps/rca/store/6780/NzYxNzAz_)
 
+- 1Panel 应用商店
+
+已上架1Panel应用商店，应用商店-实用工具-Komari 即可安装
+
 ### 1. 使用一键安装脚本
 
 适用于使用了 systemd 的发行版（Ubuntu、Debian...）。
@@ -72,7 +76,7 @@ sudo ./install-komari.sh
 
 #### 依赖
 
-- Go 1.24+ 和 Node.js 20+（手工构建）
+- Go 1.18+ 和 Node.js 20+（手工构建）
 
 1. 构建前端静态文件：
    ```bash
@@ -86,7 +90,7 @@ sudo ./install-komari.sh
    git clone https://github.com/komari-monitor/komari
    cd komari
    ```
-   将步骤 1 中生成的静态文件复制到 `komari` 项目根目录下的 `/public/dist` 文件夹。
+   将步骤1中生成的静态文件复制到 `komari` 项目根目录下的 `/web/public/defaultTheme/dist` 文件夹，并将 `komari-theme.json` 与 `preview.png`/`perview.png` 复制到 `/web/public/defaultTheme`。
    ```bash
    go build -o komari
    ```
@@ -112,6 +116,10 @@ sudo ./install-komari.sh
 
 ## 鸣谢
 
+### 破碎工坊云
+
+[破碎工坊云 - 专业云计算服务平台，提供高效、稳定、安全的高防服务器与CDN解决方案](https://www.crash.work/)
+
 ### DreamCloud
 
 [DreamCloud - 极高性价比解锁直连亚太高防](https://as211392.com/)

go.mod

@@ -10,17 +10,15 @@ require (
 	github.com/dop251/goja_nodejs v0.0.0-20251015164255-5e94316bedaf
 	github.com/gin-gonic/gin v1.10.0
 	github.com/google/uuid v1.6.0
-	github.com/gookit/event v1.2.0
 	github.com/gorilla/websocket v1.5.3
 	github.com/oschwald/maxminddb-golang v1.13.1
 	github.com/patrickmn/go-cache v2.1.0+incompatible
 	github.com/pquerna/otp v1.5.0
 	github.com/spf13/cobra v1.9.1
 	github.com/stretchr/testify v1.10.0
-	golang.org/x/image v0.33.0
+	golang.org/x/image v0.35.0
 	google.golang.org/grpc v1.75.0
 	google.golang.org/protobuf v1.36.6
-	gorm.io/driver/mysql v1.5.7
 	gorm.io/driver/sqlite v1.5.7
 	gorm.io/gorm v1.26.1
 )
@@ -34,7 +32,6 @@ require golang.org/x/crypto v0.39.0 // indirect
 require golang.org/x/net v0.41.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
@@ -48,10 +45,8 @@ require (
 	github.com/go-playground/universal-translator v0.18.1 // indirect
 	github.com/go-playground/validator/v10 v10.26.0 // indirect
 	github.com/go-sourcemap/sourcemap v2.1.4+incompatible // indirect
-	github.com/go-sql-driver/mysql v1.9.2 // indirect
 	github.com/goccy/go-json v0.10.5 // indirect
 	github.com/google/pprof v0.0.0-20240727154555-813a5fbdbec8 // indirect
-	github.com/gookit/goutil v0.7.1 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/jinzhu/inflection v1.0.0 // indirect
 	github.com/jinzhu/now v1.1.5 // indirect
@@ -72,7 +67,7 @@ require (
 	golang.org/x/arch v0.15.0 // indirect
 	golang.org/x/oauth2 v0.30.0 // indirect
 	golang.org/x/sys v0.33.0 // indirect
-	golang.org/x/text v0.31.0 // indirect
+	golang.org/x/text v0.33.0 // indirect
 	google.golang.org/genproto/googleapis/rpc v0.0.0-20250707201910-8d1bb00bc6a7 // indirect
 	gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect

go.sum

@@ -1,5 +1,3 @@
-filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
-filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
 github.com/Masterminds/semver/v3 v3.2.1 h1:RN9w6+7QoMeJVGyfmbcgs28Br8cvmnucEXnY0rYXWg0=
 github.com/Masterminds/semver/v3 v3.2.1/go.mod h1:qvl/7zhW3nngYb5+80sSMF+FG2BjYrf8m9wsX0PNOMQ=
 github.com/boombuler/barcode v1.0.1-0.20190219062509-6c824513bacc h1:biVzkmvwrH8WK8raXaxBx6fRVTlJILwEwQGL1I/ByEI=
@@ -47,9 +45,6 @@ github.com/go-playground/validator/v10 v10.26.0 h1:SP05Nqhjcvz81uJaRfEV0YBSSSGMc
 github.com/go-playground/validator/v10 v10.26.0/go.mod h1:I5QpIEbmr8On7W0TktmJAumgzX4CA1XNl4ZmDuVHKKo=
 github.com/go-sourcemap/sourcemap v2.1.4+incompatible h1:a+iTbH5auLKxaNwQFg0B+TCYl6lbukKPc7b5x0n1s6Q=
 github.com/go-sourcemap/sourcemap v2.1.4+incompatible/go.mod h1:F8jJfvm2KbVjc5NqelyYJmf/v5J0dwNLS2mL4sNA1Jg=
-github.com/go-sql-driver/mysql v1.7.0/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI=
-github.com/go-sql-driver/mysql v1.9.2 h1:4cNKDYQ1I84SXslGddlsrMhc8k4LeDVj6Ad6WRjiHuU=
-github.com/go-sql-driver/mysql v1.9.2/go.mod h1:qn46aNg1333BRMNU69Lq93t8du/dwxI64Gl8i5p1WMU=
 github.com/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4=
 github.com/goccy/go-json v0.10.5/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
 github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
@@ -61,10 +56,6 @@ github.com/google/pprof v0.0.0-20240727154555-813a5fbdbec8 h1:FKHo8hFI3A+7w0aUQu
 github.com/google/pprof v0.0.0-20240727154555-813a5fbdbec8/go.mod h1:K1liHPHnj73Fdn/EKuT8nrFqBihUSKXoLYU0BuatOYo=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/gookit/event v1.2.0 h1:aa8ouNVlo4E/NRhHVXNU/JbWvlr91Gjh423WtCDYQ4Q=
-github.com/gookit/event v1.2.0/go.mod h1:gGYybJL0HEEo/+UmBN+MgLqUBIxcCGOP8FrLPk+J8w4=
-github.com/gookit/goutil v0.7.1 h1:AaFJPN9mrdeYBv8HOybri26EHGCC34WJVT7jUStGJsI=
-github.com/gookit/goutil v0.7.1/go.mod h1:vJS9HXctYTCLtCsZot5L5xF+O1oR17cDYO9R0HxBmnU=
 github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
 github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
@@ -148,8 +139,8 @@ golang.org/x/arch v0.15.0 h1:QtOrQd0bTUnhNVNndMpLHNWrDmYzZ2KDqSrEymqInZw=
 golang.org/x/arch v0.15.0/go.mod h1:JmwW7aLIoRUKgaTzhkiEFxvcEiQGyOg9BMonBJUS7EE=
 golang.org/x/crypto v0.39.0 h1:SHs+kF4LP+f+p14esP5jAoDpHU8Gu/v9lFRK6IT5imM=
 golang.org/x/crypto v0.39.0/go.mod h1:L+Xg3Wf6HoL4Bn4238Z6ft6KfEpN0tJGo53AAPC632U=
-golang.org/x/image v0.33.0 h1:LXRZRnv1+zGd5XBUVRFmYEphyyKJjQjCRiOuAP3sZfQ=
-golang.org/x/image v0.33.0/go.mod h1:DD3OsTYT9chzuzTQt+zMcOlBHgfoKQb1gry8p76Y1sc=
+golang.org/x/image v0.35.0 h1:LKjiHdgMtO8z7Fh18nGY6KDcoEtVfsgLDPeLyguqb7I=
+golang.org/x/image v0.35.0/go.mod h1:MwPLTVgvxSASsxdLzKrl8BRFuyqMyGhLwmC+TO1Sybk=
 golang.org/x/net v0.41.0 h1:vBTly1HeNPEn3wtREYfy4GZ/NECgw2Cnl+nK6Nz3uvw=
 golang.org/x/net v0.41.0/go.mod h1:B/K4NNqkfmg07DQYrbwvSluqCJOOXwUjeb/5lOisjbA=
 golang.org/x/oauth2 v0.30.0 h1:dnDm7JmhM45NNpd8FDDeLhK6FwqbOf4MLCM9zb1BOHI=
@@ -157,10 +148,8 @@ golang.org/x/oauth2 v0.30.0/go.mod h1:B++QgG3ZKulg6sRPGD/mqlHQs5rB3Ml9erfeDY7xKl
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
 golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/term v0.32.0 h1:DR4lr0TjUs3epypdhTOkMmuF5CDFJ/8pOnbzMZPQ7bg=
-golang.org/x/term v0.32.0/go.mod h1:uZG1FhGx848Sqfsq4/DlJr3xGGsYMu/L5GW4abiaEPQ=
-golang.org/x/text v0.31.0 h1:aC8ghyu4JhP8VojJ2lEHBnochRno1sgL6nEi9WGFGMM=
-golang.org/x/text v0.31.0/go.mod h1:tKRAlv61yKIjGGHX/4tP1LTbc13YSec1pxVEWXzfoeM=
+golang.org/x/text v0.33.0 h1:B3njUFyqtHDUI5jMn1YIr5B0IE2U0qck04r6d4KPAxE=
+golang.org/x/text v0.33.0/go.mod h1:LuMebE6+rBincTi9+xWTY8TztLzKHc/9C1uBCG27+q8=
 gonum.org/v1/gonum v0.16.0 h1:5+ul4Swaf3ESvrOnidPp4GZbzf0mxVQpDCYUQE7OJfk=
 gonum.org/v1/gonum v0.16.0/go.mod h1:fef3am4MQ93R2HHpKnLk4/Tbh/s0+wqD5nfa6Pnwy4E=
 google.golang.org/genproto/googleapis/rpc v0.0.0-20250707201910-8d1bb00bc6a7 h1:pFyd6EwwL2TqFf8emdthzeX+gZE1ElRq3iM8pui4KBY=
@@ -179,11 +168,8 @@ gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gorm.io/driver/mysql v1.5.7 h1:MndhOPYOfEp2rHKgkZIhJ16eVUIRf2HmzgoPmh7FCWo=
-gorm.io/driver/mysql v1.5.7/go.mod h1:sEtPWMiqiN1N1cMXoXmBbd8C6/l+TESwriotuRRpkDM=
 gorm.io/driver/sqlite v1.5.7 h1:8NvsrhP0ifM7LX9G4zPB97NwovUakUxc+2V2uuf3Z1I=
 gorm.io/driver/sqlite v1.5.7/go.mod h1:U+J8craQU6Fzkcvu8oLeAQmi50TkwPEhHDEjQZXDah4=
-gorm.io/gorm v1.25.7/go.mod h1:hbnx/Oo0ChWMn1BIhpy1oYozzpM15i4YPuHDmfYtwg8=
 gorm.io/gorm v1.26.1 h1:ghB2gUI9FkS46luZtn6DLZ0f6ooBJ5IbVej2ENFDjRw=
 gorm.io/gorm v1.26.1/go.mod h1:8Z33v652h4//uMA76KjeDH8mJXPm1QNCYrMeatR0DOE=
 nullprogram.com/x/optparse v1.0.0/go.mod h1:KdyPE+Igbe0jQUrVfMqDMeJQIJZEuyV7pjYmp6pbG50=

internal/all.go

@@ -1,29 +0,0 @@
-package internal
-
-import (
-	// Import all internal packages to ensure their init() functions are executed
-	_ "github.com/komari-monitor/komari/internal/api_rpc"
-	_ "github.com/komari-monitor/komari/internal/api_v1"
-	_ "github.com/komari-monitor/komari/internal/client"
-	_ "github.com/komari-monitor/komari/internal/cloudflared"
-	_ "github.com/komari-monitor/komari/internal/common"
-	_ "github.com/komari-monitor/komari/internal/conf"
-	_ "github.com/komari-monitor/komari/internal/database"
-	_ "github.com/komari-monitor/komari/internal/eventType"
-	_ "github.com/komari-monitor/komari/internal/geoip"
-	_ "github.com/komari-monitor/komari/internal/jsruntime"
-	_ "github.com/komari-monitor/komari/internal/log"
-	_ "github.com/komari-monitor/komari/internal/messageSender"
-	_ "github.com/komari-monitor/komari/internal/mjpeg"
-	_ "github.com/komari-monitor/komari/internal/nezha"
-	_ "github.com/komari-monitor/komari/internal/notifier"
-	_ "github.com/komari-monitor/komari/internal/oauth"
-	_ "github.com/komari-monitor/komari/internal/patch"
-	_ "github.com/komari-monitor/komari/internal/pingSchedule"
-	_ "github.com/komari-monitor/komari/internal/plugin"
-	_ "github.com/komari-monitor/komari/internal/renewal"
-	_ "github.com/komari-monitor/komari/internal/restore"
-	_ "github.com/komari-monitor/komari/internal/ws"
-)
-
-func All() {}

internal/api_rpc/client.go

@@ -1,31 +0,0 @@
-package api_rpc
-
-import (
-	"context"
-
-	"github.com/komari-monitor/komari/pkg/rpc"
-)
-
-const GroupClient = "client"
-
-func init() {
-	RegisterWithGroupAndMeta("register", GroupClient, registerClient, &rpc.MethodMeta{
-		Name:        "RegisterClient",
-		Description: "Register a new client with the server (Auto discovery).",
-		Params: []rpc.ParamMeta{
-			{
-				Name:        "name",
-				Type:        "string",
-				Description: "The name of the client to register.",
-			},
-		},
-	})
-}
-
-func registerClient(ctx context.Context, req *rpc.JsonRpcRequest) (any, *rpc.JsonRpcError) {
-	var params struct {
-		Name string `json:"name"`
-	}
-	req.BindParams(&params)
-	return nil, rpc.MakeError(rpc.InternalError, "Not impl yet", nil)
-}

internal/api_rpc/init.go

@@ -1,15 +0,0 @@
-package api_rpc
-
-import (
-	"github.com/gin-gonic/gin"
-	"github.com/gookit/event"
-	"github.com/komari-monitor/komari/internal/eventType"
-)
-
-func init() {
-	event.On(eventType.ServerInitializeStart, event.ListenerFunc(func(e event.Event) error {
-		r := e.Get("engine").(*gin.Engine)
-		RegisterRouters("/api/rpc2", r)
-		return nil
-	}))
-}

internal/api_v1/AdminAuthMiddleware.go

@@ -1,48 +0,0 @@
-package api_v1
-
-import (
-	"net/http"
-	"strings"
-
-	"github.com/komari-monitor/komari/internal/api_v1/resp"
-	"github.com/komari-monitor/komari/internal/database/accounts"
-
-	"github.com/gin-gonic/gin"
-)
-
-func AdminAuthMiddleware() gin.HandlerFunc {
-	return func(c *gin.Context) {
-		if !strings.HasPrefix(c.Request.URL.Path, "/api/admin") {
-			c.Next()
-			return
-		}
-		// API key authentication
-		apiKey := c.GetHeader("Authorization")
-		if isApiKeyValid(apiKey) {
-			c.Set("api_key", apiKey)
-			c.Next()
-			return
-		}
-		// session-based authentication
-		session, err := c.Cookie("session_token")
-		if err != nil {
-			resp.RespondError(c, http.StatusUnauthorized, "Unauthorized.")
-			c.Abort()
-			return
-		}
-
-		// Komari is a single user system
-		uuid, err := accounts.GetSession(session)
-		if err != nil {
-			resp.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()
-	}
-}

internal/api_v1/PrivateSiteMiddleware.go

@@ -1,105 +0,0 @@
-package api_v1
-
-import (
-	"net/http"
-	"strings"
-
-	"github.com/komari-monitor/komari/internal/api_v1/resp"
-	"github.com/komari-monitor/komari/internal/conf"
-	"github.com/komari-monitor/komari/internal/database/accounts"
-
-	"github.com/gin-gonic/gin"
-)
-
-var (
-	requireAuthPaths = []string{
-		// v1 API at 2025-12-06
-		// "/api/rpc2",
-		// "/ping",
-		// "/api/login",
-		// "/api/me",
-		"/api/clients",
-		"/api/nodes",
-		// "/api/public",
-		// "/api/oauth",
-		// "/api/oauth_callback",
-		// "/api/logout",
-		// "/api/version",
-		"/api/recent/",
-		"/api/records/",
-		"/api/task/",
-		// "/api/clients/register",
-		// "/api/clients/report",
-		// "/api/clients/uploadBasicInfo",
-		// "/api/clients/terminal",
-		// "/api/clients/task/result",
-		// "/api/admin/download/backup",
-	}
-)
-
-func PrivateSiteMiddleware() gin.HandlerFunc {
-	return func(c *gin.Context) {
-		// API key authentication
-		apiKey := c.GetHeader("Authorization")
-		if isApiKeyValid(apiKey) {
-			c.Set("api_key", apiKey)
-			c.Next()
-			return
-		}
-		path := c.Request.URL.Path
-		// 如果不是 /api 开头的路径，直接放行
-		if !strings.HasPrefix(path, "/api") {
-			c.Next()
-			return
-		}
-
-		// /api/clients/* 由 TokenAuthMiddleware 处理
-		// /api/rpc2 由 api_rpc 处理
-		// /api/admin/* 由 AdminAuthMiddleware 处理
-		if strings.HasPrefix(path, "/api/clients/") ||
-			strings.HasPrefix(path, "/api/admin") ||
-			strings.HasPrefix(path, "/api/rpc2") {
-			c.Next()
-			return
-		}
-
-		require := false
-		for _, p := range requireAuthPaths {
-			if strings.HasPrefix(path, p) {
-				require = true
-				break
-			}
-		}
-
-		if !require {
-			c.Next()
-			return
-		}
-		conf, err := conf.GetWithV1Format()
-		if err != nil {
-			resp.RespondError(c, http.StatusInternalServerError, "Failed to get configuration.")
-			c.Abort()
-			return
-		}
-		// 验证私有, 如果不是私有站点，直接放行
-		if !conf.PrivateSite {
-			c.Next()
-			return
-		}
-		// 如果是私有站点，检查是否有 session
-		session, err := c.Cookie("session_token")
-		if err != nil {
-			resp.RespondError(c, http.StatusUnauthorized, "Private site is enabled, please login first.")
-			c.Abort()
-			return
-		}
-		_, err = accounts.GetSession(session)
-		if err != nil {
-			resp.RespondError(c, http.StatusUnauthorized, "Private site is enabled, please login first.")
-			c.Abort()
-			return
-		}
-
-		c.Next()
-	}
-}

internal/api_v1/TokenAuthMiddleware.go

@@ -1,89 +0,0 @@
-package api_v1
-
-import (
-	"bytes"
-	"database/sql"
-	"encoding/json"
-	"io"
-	"net/http"
-
-	clients "github.com/komari-monitor/komari/internal/client"
-	"gorm.io/gorm"
-
-	"github.com/gin-gonic/gin"
-)
-
-// TokenAuthMiddleware creates a Gin middleware that validates a token from query parameters or request body.
-func TokenAuthMiddleware() gin.HandlerFunc {
-	return func(c *gin.Context) {
-		// API key authentication
-		apiKey := c.GetHeader("Authorization")
-		if isApiKeyValid(apiKey) {
-			c.Set("api_key", apiKey)
-			c.Next()
-			return
-		}
-
-		var token string
-
-		// Step 1: Check query parameter for token
-		token = c.Query("token")
-
-		// Step 2: If no token in query, check request body for non-GET requests
-		if token == "" && c.Request.Method != http.MethodGet {
-			// Read the body
-			bodyBytes, err := io.ReadAll(c.Request.Body)
-			if err != nil {
-				c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"status": "error", "error": "failed to read request body"})
-				return
-			}
-
-			// Restore the body for downstream handlers
-			c.Request.Body = io.NopCloser(bytes.NewReader(bodyBytes))
-
-			// Try to extract token from JSON body
-			var bodyMap map[string]interface{}
-			if len(bodyBytes) > 0 {
-				if err := json.Unmarshal(bodyBytes, &bodyMap); err == nil {
-					if tokenVal, exists := bodyMap["token"]; exists {
-						if str, ok := tokenVal.(string); ok && str != "" {
-							token = str
-						}
-					}
-				}
-			}
-		}
-
-		if token == "" {
-			c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"status": "error", "error": "token is required"})
-			return
-		}
-
-		exists, err := checkTokenExists(token)
-		if err != nil {
-			c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"status": "error", "error": "failed to validate token"})
-			return
-		}
-		if !exists {
-			c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"status": "error", "error": "invalid token"})
-			return
-		}
-
-		c.Next()
-	}
-}
-
-func checkTokenExists(token string) (bool, error) {
-	_, err := clients.GetClientUUIDByToken(token)
-
-	if err == sql.ErrNoRows {
-		return false, nil
-	}
-	if err == gorm.ErrRecordNotFound {
-		return false, nil
-	}
-	if err != nil {
-		return false, err
-	}
-	return true, nil
-}

internal/api_v1/admin/exec.go

@@ -1,98 +0,0 @@
-package admin
-
-import (
-	"encoding/json"
-	"time"
-
-	"github.com/gin-gonic/gin"
-	"github.com/gorilla/websocket"
-	"github.com/komari-monitor/komari/internal/api_v1/resp"
-	"github.com/komari-monitor/komari/internal/database/auditlog"
-	"github.com/komari-monitor/komari/internal/database/models"
-	"github.com/komari-monitor/komari/internal/database/tasks"
-	"github.com/komari-monitor/komari/internal/ws"
-	"github.com/komari-monitor/komari/pkg/utils"
-)
-
-// 接受数据类型：
-// - 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
-	var offlineClients []string
-	if err := c.ShouldBindJSON(&req); err != nil {
-		resp.RespondError(c, 400, "Invalid or missing request body: "+err.Error())
-		return
-	}
-	// for uuid := range ws.GetConnectedClients() {
-	// 	if contain(req.Clients, uuid) {
-	// 		onlineClients = append(onlineClients, uuid)
-	// 	}
-	// 	// else {
-	// 	// 	resp.RespondError(c, 400, "Client not connected: "+uuid)
-	// 	// 	return
-	// 	// }
-	// }
-	for _, uuid := range req.Clients {
-		if client := ws.GetConnectedClients()[uuid]; client != nil {
-			onlineClients = append(onlineClients, uuid)
-		} else {
-			offlineClients = append(offlineClients, uuid)
-		}
-	}
-	if len(onlineClients) == 0 {
-		resp.RespondError(c, 400, "No clients connected")
-		return
-	}
-	taskId := utils.GenerateRandomString(16)
-	if err := tasks.CreateTask(taskId, append(onlineClients, offlineClients...), req.Command); err != nil {
-		resp.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.GetConnectedClients()[uuid]
-		if client != nil {
-			if err := client.WriteMessage(websocket.TextMessage, payload); err != nil {
-				resp.RespondError(c, 400, "Client connection is broke: "+uuid)
-				return
-			}
-		} else {
-			resp.RespondError(c, 400, "Client connection is null: "+uuid)
-			return
-		}
-	}
-	uuid, _ := c.Get("uuid")
-	auditlog.Log(c.ClientIP(), uuid.(string), "REC, task id: "+taskId, "warn")
-	resp.RespondSuccess(c, gin.H{
-		"task_id": taskId,
-		"clients": onlineClients,
-	})
-	if len(offlineClients) > 0 {
-		for _, uuid := range offlineClients {
-			tasks.SaveTaskResult(taskId, uuid, "Client offline!", -1, models.FromTime(time.Now()))
-		}
-	}
-}
-
-// func contain(clients []string, uuid string) bool {
-// 	for _, client := range clients {
-// 		if client == uuid {
-// 			return true
-// 		}
-// 	}
-// 	return false
-// }

internal/api_v1/admin/messageSender.go

@@ -1,63 +0,0 @@
-package admin
-
-import (
-	"github.com/gin-gonic/gin"
-	"github.com/komari-monitor/komari/internal/api_v1/resp"
-	"github.com/komari-monitor/komari/internal/conf"
-	"github.com/komari-monitor/komari/internal/database"
-	"github.com/komari-monitor/komari/internal/database/models"
-	"github.com/komari-monitor/komari/internal/messageSender"
-	"github.com/komari-monitor/komari/internal/messageSender/factory"
-)
-
-func GetMessageSenderProvider(c *gin.Context) {
-	provider := c.Query("provider")
-	if provider != "" {
-		// 如果指定了provider，返回单个提供者的配置
-		config, err := database.GetMessageSenderConfigByName(provider)
-		if err != nil {
-			resp.RespondError(c, 404, "Provider not found: "+err.Error())
-			return
-		}
-		resp.RespondSuccess(c, config)
-		return
-	}
-	// 否则返回所有提供者的配置项模板
-	providers := factory.GetSenderConfigs()
-	if len(providers) == 0 {
-		resp.RespondError(c, 404, "No message sender providers found")
-		return
-	}
-	resp.RespondSuccess(c, providers)
-}
-
-func SetMessageSenderProvider(c *gin.Context) {
-	var senderConfig models.MessageSenderProvider
-	if err := c.ShouldBindJSON(&senderConfig); err != nil {
-		resp.RespondError(c, 400, "Invalid configuration: "+err.Error())
-		return
-	}
-	if senderConfig.Name == "" {
-		resp.RespondError(c, 400, "Provider name is required")
-		return
-	}
-	_, exists := factory.GetConstructor(senderConfig.Name)
-	if !exists {
-		resp.RespondError(c, 404, "Provider not found: "+senderConfig.Name)
-		return
-	}
-	if err := database.SaveMessageSenderConfig(&senderConfig); err != nil {
-		resp.RespondError(c, 500, "Failed to save message sender provider configuration: "+err.Error())
-		return
-	}
-	cfg, _ := conf.GetWithV1Format()
-	// 正在使用，重载
-	if cfg.NotificationMethod == senderConfig.Name {
-		err := messageSender.LoadProvider(senderConfig.Name, senderConfig.Addition)
-		if err != nil {
-			resp.RespondError(c, 500, "Failed to load message sender provider: "+err.Error())
-			return
-		}
-	}
-	resp.RespondSuccess(c, gin.H{"message": "Message sender provider set successfully"})
-}

internal/api_v1/admin/ping.go

@@ -1,80 +0,0 @@
-package admin
-
-import (
-	"net/http"
-
-	"github.com/gin-gonic/gin"
-	"github.com/komari-monitor/komari/internal/api_v1/resp"
-	"github.com/komari-monitor/komari/internal/database/models"
-	"github.com/komari-monitor/komari/internal/database/tasks"
-)
-
-// POST body: clients []string, target, task_type string, interval int
-func AddPingTask(c *gin.Context) {
-	var req struct {
-		Clients  []string `json:"clients" binding:"required"`
-		Name     string   `json:"name" binding:"required"`
-		Target   string   `json:"target" binding:"required"`
-		TaskType string   `json:"type" binding:"required"`     // icmp, tcp, http
-		Interval int      `json:"interval" binding:"required"` // 间隔时间，单位秒
-	}
-
-	if err := c.ShouldBindJSON(&req); err != nil {
-		resp.RespondError(c, http.StatusBadRequest, err.Error())
-		return
-	}
-
-	if taskID, err := tasks.AddPingTask(req.Clients, req.Name, req.Target, req.TaskType, req.Interval); err != nil {
-		resp.RespondError(c, http.StatusInternalServerError, err.Error())
-	} else {
-		resp.RespondSuccess(c, gin.H{"task_id": taskID})
-	}
-}
-
-// POST body: id []uint
-func DeletePingTask(c *gin.Context) {
-	var req struct {
-		ID []uint `json:"id" binding:"required"`
-	}
-	if err := c.ShouldBindJSON(&req); err != nil {
-		resp.RespondError(c, http.StatusBadRequest, err.Error())
-		return
-	}
-
-	if err := tasks.DeletePingTask(req.ID); err != nil {
-		resp.RespondError(c, http.StatusInternalServerError, err.Error())
-	} else {
-		resp.RespondSuccess(c, nil)
-	}
-}
-
-// POST body: id []uint, updates map[string]interface{}
-func EditPingTask(c *gin.Context) {
-	var req struct {
-		Tasks []*models.PingTask `json:"tasks" binding:"required"`
-	}
-
-	if err := c.ShouldBindJSON(&req); err != nil {
-		resp.RespondError(c, http.StatusBadRequest, "Invalid request data")
-		return
-	}
-
-	if err := tasks.EditPingTask(req.Tasks); err != nil {
-		resp.RespondError(c, http.StatusInternalServerError, err.Error())
-	} else {
-		// for _, task := range req.Tasks {
-		// 	tasks.DeletePingRecords([]uint{task.Id})
-		// }
-		resp.RespondSuccess(c, nil)
-	}
-}
-
-func GetAllPingTasks(c *gin.Context) {
-	tasks, err := tasks.GetAllPingTasks()
-	if err != nil {
-		resp.RespondError(c, http.StatusInternalServerError, err.Error())
-		return
-	}
-
-	resp.RespondSuccess(c, tasks)
-}

internal/api_v1/admin/settings.go

@@ -1,80 +0,0 @@
-package admin
-
-import (
-	"database/sql"
-
-	"github.com/komari-monitor/komari/internal/api_v1/resp"
-	"github.com/komari-monitor/komari/internal/conf"
-	"github.com/komari-monitor/komari/internal/database/auditlog"
-	"github.com/komari-monitor/komari/internal/database/records"
-	"github.com/komari-monitor/komari/internal/database/tasks"
-
-	"github.com/gin-gonic/gin"
-)
-
-// GetSettings 获取自定义配置
-func GetSettings(c *gin.Context) {
-	cst, err := conf.GetWithV1Format()
-	if err != nil {
-		if err == sql.ErrNoRows {
-			//override
-			cst = conf.V1Struct{Sitename: "Komari"}
-			cst.ID = 1
-			conf.Save(cst)
-			resp.RespondSuccess(c, cst)
-			return
-		}
-		c.JSON(500, gin.H{
-			"status":  "error",
-			"message": "Internal Server Error: " + err.Error(),
-		})
-	}
-	resp.RespondSuccess(c, cst)
-}
-
-// EditSettings 更新自定义配置
-func EditSettings(c *gin.Context) {
-	cfg := make(map[string]interface{})
-	if err := c.ShouldBindJSON(&cfg); err != nil {
-		resp.RespondError(c, 400, "Invalid or missing request body: "+err.Error())
-		return
-	}
-
-	cfg["id"] = 1 // Only one record
-	if err := conf.Update(cfg); err != nil {
-		resp.RespondError(c, 500, "Failed to update settings: "+err.Error())
-		return
-	}
-
-	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]
-	}
-	auditlog.Log(c.ClientIP(), uuid.(string), message, "info")
-	resp.RespondSuccess(c, nil)
-}
-
-func contains(slice []string, item string) bool {
-	for _, v := range slice {
-		if v == item {
-			return true
-		}
-	}
-	return false
-}
-
-func ClearAllRecords(c *gin.Context) {
-	records.DeleteAll()
-	tasks.DeleteAllPingRecords()
-	uuid, _ := c.Get("uuid")
-	auditlog.Log(c.ClientIP(), uuid.(string), "clear all records", "info")
-	resp.RespondSuccess(c, nil)
-}

internal/api_v1/admin/test/test.go

@@ -1,50 +0,0 @@
-package test
-
-import (
-	"net"
-
-	"github.com/gin-gonic/gin"
-	"github.com/komari-monitor/komari/internal/api_v1/resp"
-	"github.com/komari-monitor/komari/internal/conf"
-	"github.com/komari-monitor/komari/internal/database/models"
-	"github.com/komari-monitor/komari/internal/geoip"
-	"github.com/komari-monitor/komari/internal/messageSender"
-)
-
-func TestSendMessage(c *gin.Context) {
-	err := messageSender.SendEvent(models.EventMessage{
-		Event:   "Test",
-		Message: "This is a test message from Komari.",
-	})
-	if err != nil {
-		resp.RespondError(c, 500, "Failed to send message: "+err.Error())
-		return
-	}
-	resp.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 := conf.GetWithV1Format()
-	if err != nil {
-		resp.RespondError(c, 500, "Failed to get configuration: "+err.Error())
-		return
-	}
-	if !conf.GeoIpEnabled {
-		resp.RespondError(c, 400, "GeoIP is not enabled in the configuration.")
-		return
-	}
-	GeoIpRecord, err := geoip.GetGeoInfo(net.ParseIP(ip))
-	if err != nil {
-		resp.RespondError(c, 500, "Failed to get GeoIP record: "+err.Error())
-		return
-	}
-	resp.RespondSuccess(c, GeoIpRecord)
-}

internal/api_v1/admin/update/geoip.go

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

internal/api_v1/admin/update/user.go

@@ -1,40 +0,0 @@
-package update
-
-import (
-	"github.com/gin-gonic/gin"
-	"github.com/komari-monitor/komari/internal/api_v1/resp"
-	"github.com/komari-monitor/komari/internal/database/accounts"
-	"github.com/komari-monitor/komari/internal/database/auditlog"
-)
-
-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 {
-		resp.RespondError(c, 400, "Invalid or missing request body: "+err.Error())
-		return
-	}
-	if req.Password == nil && req.Name == nil {
-		resp.RespondError(c, 400, "At least one field (username or password) must be provided")
-		return
-	}
-	if req.Name != nil && len(*req.Name) < 3 {
-		resp.RespondError(c, 400, "Username must be at least 3 characters long")
-		return
-	}
-	if req.Password != nil && len(*req.Password) < 6 {
-		resp.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 {
-		resp.RespondError(c, 500, "Failed to update user: "+err.Error())
-		return
-	}
-	uuid, _ := c.Get("uuid")
-	auditlog.Log(c.ClientIP(), uuid.(string), "User updated", "warn")
-	resp.RespondSuccess(c, gin.H{"uuid": req.Uuid})
-}

internal/api_v1/client/autoDiscovery.go

@@ -1,47 +0,0 @@
-package client
-
-import (
-	"github.com/gin-gonic/gin"
-	"github.com/gookit/event"
-	"github.com/komari-monitor/komari/internal/api_v1/resp"
-	clients "github.com/komari-monitor/komari/internal/client"
-	"github.com/komari-monitor/komari/internal/conf"
-	"github.com/komari-monitor/komari/internal/eventType"
-	"github.com/komari-monitor/komari/pkg/utils"
-)
-
-func RegisterClient(c *gin.Context) {
-	auth := c.GetHeader("Authorization")
-	if auth == "" {
-		resp.RespondError(c, 403, "Invalid AutoDiscovery Key")
-		return
-	}
-	cfg, err := conf.GetWithV1Format()
-	if err != nil {
-		resp.RespondError(c, 500, "Failed to get configuration: "+err.Error())
-		return
-	}
-
-	if cfg.AutoDiscoveryKey == "" ||
-		len(cfg.AutoDiscoveryKey) < 12 ||
-		"Bearer "+cfg.AutoDiscoveryKey != auth {
-
-		resp.RespondError(c, 403, "Invalid AutoDiscovery Key")
-		return
-	}
-	name := c.Query("name")
-	if name == "" {
-		name = utils.GenerateRandomString(8)
-	}
-	name = "Auto-" + name
-	uuid, token, err := clients.CreateClientWithName(name)
-	if err != nil {
-		resp.RespondError(c, 500, "Failed to create client: "+err.Error())
-		return
-	}
-	event.Trigger(eventType.ClientCreated, event.M{
-		"client": uuid,
-		"token":  token,
-	})
-	resp.RespondSuccess(c, gin.H{"uuid": uuid, "token": token})
-}

internal/api_v1/client/uploadBasicInfo.go

@@ -1,92 +0,0 @@
-package client
-
-import (
-	"net"
-
-	"github.com/gookit/event"
-	clients "github.com/komari-monitor/komari/internal/client"
-	"github.com/komari-monitor/komari/internal/conf"
-	"github.com/komari-monitor/komari/internal/eventType"
-	"github.com/komari-monitor/komari/internal/geoip"
-
-	"github.com/gin-gonic/gin"
-)
-
-func getClientIPType(ip net.IP) int {
-	// 0:ipv4 1:ipv6 -1:错误的输入
-	if ip == nil {
-		return -1
-	}
-	if ip.To4() == nil {
-		return 1
-	} else {
-		return 0
-	}
-}
-
-func UploadBasicInfo(c *gin.Context) {
-	var cbi = map[string]interface{}{}
-	if err := c.ShouldBindJSON(&cbi); err != nil {
-		c.JSON(400, gin.H{"status": "error", "error": "Invalid or missing data"})
-		return
-	}
-
-	token := c.Query("token")
-	uuid, err := clients.GetClientUUIDByToken(token)
-	if uuid == "" || err != nil {
-		c.JSON(400, gin.H{"status": "error", "error": "Invalid token"})
-		return
-	}
-
-	cbi["uuid"] = uuid
-
-	if (func() bool {
-		if v4, ok := cbi["ipv4"].(string); !ok || v4 == "" {
-			if v6, ok := cbi["ipv6"].(string); !ok || v6 == "" {
-				return true
-			}
-		}
-		return false
-	})() {
-		ipStr := c.ClientIP()
-		ip := net.ParseIP(ipStr)
-		ipType := getClientIPType(ip)
-
-		switch ipType {
-		case 0:
-			cbi["ipv4"] = ip
-		case 1:
-			cbi["ipv6"] = ip
-		default:
-			break
-		}
-	}
-
-	if cfg, err := conf.GetWithV1Format(); err == nil && cfg.GeoIpEnabled {
-		if ipv4, ok := cbi["ipv4"].(string); ok && ipv4 != "" {
-			ip4 := net.ParseIP(ipv4)
-			ip4_record, _ := geoip.GetGeoInfo(ip4)
-			if ip4_record != nil {
-				cbi["region"] = geoip.GetRegionUnicodeEmoji(ip4_record.ISOCode)
-			}
-		} else if ipv6, ok := cbi["ipv6"].(string); ok && ipv6 != "" {
-			ip6 := net.ParseIP(ipv6)
-			ip6_record, _ := geoip.GetGeoInfo(ip6)
-			if ip6_record != nil {
-				cbi["region"] = geoip.GetRegionUnicodeEmoji(ip6_record.ISOCode)
-			}
-		}
-	}
-
-	if err := clients.PartialUpdate(cbi); err != nil {
-		c.JSON(500, gin.H{"status": "error", "error": err})
-		return
-	}
-	event.Trigger(eventType.ClientMessageReceived, event.M{
-		"client": cbi["uuid"],
-		"type":   "basic_info",
-		"data":   cbi,
-	})
-	c.JSON(200, gin.H{"status": "success"})
-
-}

internal/api_v1/login.go

@@ -1,106 +0,0 @@
-package api_v1
-
-import (
-	"encoding/json"
-	"io"
-	"net/http"
-
-	"github.com/gookit/event"
-	"github.com/komari-monitor/komari/internal/api_v1/resp"
-	"github.com/komari-monitor/komari/internal/conf"
-	"github.com/komari-monitor/komari/internal/database/accounts"
-	"github.com/komari-monitor/komari/internal/database/auditlog"
-	"github.com/komari-monitor/komari/internal/eventType"
-
-	"github.com/gin-gonic/gin"
-)
-
-type LoginRequest struct {
-	Username string `json:"username"`
-	Password string `json:"password"`
-	TwoFa    string `json:"2fa_code"`
-}
-
-func Login(c *gin.Context) {
-	conf, _ := conf.GetWithV1Format()
-	if conf.DisablePasswordLogin {
-		resp.RespondError(c, http.StatusForbidden, "Password login is disabled")
-		return
-	}
-
-	bodyBytes, err := io.ReadAll(c.Request.Body)
-	if err != nil {
-		resp.RespondError(c, http.StatusBadRequest, "Invalid request body: "+err.Error())
-		return
-	}
-	var data LoginRequest
-	err = json.Unmarshal(bodyBytes, &data)
-	if err != nil {
-		resp.RespondError(c, http.StatusBadRequest, "Invalid request body: "+err.Error())
-		return
-	}
-	if data.Username == "" || data.Password == "" {
-		resp.RespondError(c, http.StatusBadRequest, "Invalid request body: Username and password are required")
-		return
-	}
-
-	uuid, success := accounts.CheckPassword(data.Username, data.Password)
-	if !success {
-		resp.RespondError(c, http.StatusUnauthorized, "Invalid credentials")
-		event.Trigger(eventType.LoginFailed, event.M{
-			"username": data.Username,
-			"method":   "password",
-			"ip":       c.ClientIP(),
-			"ua":       c.Request.UserAgent(),
-			"header":   c.Request.Header,
-			"referrer": c.Request.Referer(),
-			"host":     c.Request.Host,
-		})
-		return
-	}
-	// 2FA
-	user, _ := accounts.GetUserByUUID(uuid)
-	if user.TwoFactor != "" { // 开启了2FA
-		if data.TwoFa == "" {
-			resp.RespondError(c, http.StatusUnauthorized, "2FA code is required")
-			return
-		}
-		if ok, err := accounts.Verify2Fa(uuid, data.TwoFa); err != nil || !ok {
-			resp.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 {
-		resp.RespondError(c, http.StatusInternalServerError, "Failed to create session: "+err.Error())
-		return
-	}
-	c.SetCookie("session_token", session, 2592000, "/", "", false, true)
-	auditlog.Log(c.ClientIP(), uuid, "logged in (password)", "login")
-	resp.RespondSuccess(c, gin.H{"set-cookie": gin.H{"session_token": session}})
-	event.Trigger(eventType.UserLogin, event.M{
-		"username": data.Username,
-		"method":   "password",
-		"ip":       c.ClientIP(),
-		"ua":       c.Request.UserAgent(),
-		"header":   c.Request.Header,
-		"referrer": c.Request.Referer(),
-		"host":     c.Request.Host,
-	})
-}
-func Logout(c *gin.Context) {
-	session, _ := c.Cookie("session_token")
-	accounts.DeleteSession(session)
-	c.SetCookie("session_token", "", -1, "/", "", false, true)
-	auditlog.Log(c.ClientIP(), "", "logged out", "logout")
-	event.Trigger(eventType.UserLogout, event.M{
-		"ip":       c.ClientIP(),
-		"ua":       c.Request.UserAgent(),
-		"header":   c.Request.Header,
-		"referrer": c.Request.Referer(),
-		"host":     c.Request.Host,
-	})
-	c.Redirect(302, "/")
-
-}

internal/api_v1/public.go

@@ -1,16 +0,0 @@
-package api_v1
-
-import (
-	"github.com/gin-gonic/gin"
-	"github.com/komari-monitor/komari/internal/api_v1/resp"
-	"github.com/komari-monitor/komari/internal/database"
-)
-
-func GetPublicSettings(c *gin.Context) {
-	p, e := database.GetPublicInfo()
-	if e != nil {
-		resp.RespondError(c, 500, e.Error())
-		return
-	}
-	resp.RespondSuccess(c, p)
-}

internal/api_v1/task/ping.go

@@ -1,38 +0,0 @@
-package task
-
-import (
-	"net/http"
-
-	"github.com/gin-gonic/gin"
-	"github.com/komari-monitor/komari/internal/api_v1/resp"
-	"github.com/komari-monitor/komari/internal/database/tasks"
-)
-
-type PublicPingTask struct {
-	Id       uint     `json:"id"`
-	Name     string   `json:"name"`
-	Clients  []string `json:"clients"`
-	Type     string   `json:"type"`
-	Interval int      `json:"interval"`
-}
-
-func GetPublicPingTasks(c *gin.Context) {
-	tasks, err := tasks.GetAllPingTasks()
-	if err != nil {
-		resp.RespondError(c, http.StatusInternalServerError, err.Error())
-		return
-	}
-
-	publicTasks := make([]PublicPingTask, len(tasks))
-	for i, task := range tasks {
-		publicTasks[i] = PublicPingTask{
-			Id:       task.Id,
-			Name:     task.Name,
-			Clients:  task.Clients,
-			Type:     task.Type,
-			Interval: task.Interval,
-		}
-	}
-
-	resp.RespondSuccess(c, publicTasks)
-}

internal/api_v1/terminal/terminal.go

@@ -1,181 +0,0 @@
-package terminal
-
-import (
-	"sync"
-
-	"log"
-	"net/http"
-	"time"
-
-	"github.com/gorilla/websocket"
-
-	"github.com/gin-gonic/gin"
-	clients "github.com/komari-monitor/komari/internal/client"
-	"github.com/komari-monitor/komari/internal/database/auditlog"
-	"github.com/komari-monitor/komari/internal/ws"
-	"github.com/komari-monitor/komari/pkg/utils"
-)
-
-type TerminalSession struct {
-	UUID        string
-	UserUUID    string
-	Browser     *websocket.Conn
-	Agent       *websocket.Conn
-	RequesterIp string
-}
-
-var TerminalSessionsMutex = &sync.Mutex{}
-var TerminalSessions = make(map[string]*TerminalSession)
-
-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{
-			"status":  "error",
-			"message": "Client not found",
-		})
-		return
-	}
-	// 建立ws
-	if !websocket.IsWebSocketUpgrade(c.Request) {
-		c.JSON(http.StatusBadRequest, gin.H{"status": "error", "message": "Require WebSocket upgrade"})
-		return
-	}
-	upgrader := websocket.Upgrader{
-		CheckOrigin: ws.CheckOrigin,
-	}
-	conn, err := upgrader.Upgrade(c.Writer, c.Request, nil)
-	if err != nil {
-		return
-	}
-	// 新建一个终端连接
-	id := utils.GenerateRandomString(32)
-	session := &TerminalSession{
-		UserUUID:    user_uuid.(string),
-		UUID:        uuid,
-		Browser:     conn,
-		Agent:       nil,
-		RequesterIp: c.ClientIP(),
-	}
-
-	TerminalSessionsMutex.Lock()
-	TerminalSessions[id] = session
-	TerminalSessionsMutex.Unlock()
-	conn.SetCloseHandler(func(code int, text string) error {
-		log.Println("Terminal connection closed:", code, text)
-		TerminalSessionsMutex.Lock()
-		delete(TerminalSessions, id)
-		TerminalSessionsMutex.Unlock()
-		// 通知 Agent 关闭终端连接
-		if session.Agent != nil {
-			session.Agent.Close()
-		}
-		return nil
-	})
-
-	if ws.GetConnectedClients()[uuid] == nil {
-		conn.WriteMessage(1, []byte("Client offline!\n被控端离线!"))
-		conn.Close()
-		TerminalSessionsMutex.Lock()
-		delete(TerminalSessions, id)
-		TerminalSessionsMutex.Unlock()
-		return
-	}
-	err = ws.GetConnectedClients()[uuid].WriteJSON(gin.H{
-		"message":    "terminal",
-		"request_id": id,
-	})
-	if err != nil {
-		conn.Close()
-		TerminalSessionsMutex.Lock()
-		delete(TerminalSessions, id)
-		TerminalSessionsMutex.Unlock()
-		return
-	}
-	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.Close()
-			}
-			conn.Close()
-			delete(TerminalSessions, id)
-		}
-		TerminalSessionsMutex.Unlock()
-	})
-	//auditlog.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
-	}
-	auditlog.Log(session.RequesterIp, session.UserUUID, "established, terminal id:"+id, "terminal")
-	established_time := time.Now()
-	errChan := make(chan error, 1)
-
-	go func() {
-		for {
-			messageType, data, err := session.Browser.ReadMessage()
-			if err != nil {
-				errChan <- err
-				return
-			}
-
-			if messageType == websocket.TextMessage {
-				if session.Agent != nil && string(data[0:1]) == "{" {
-					err = session.Agent.WriteMessage(websocket.TextMessage, data)
-				} else if session.Agent != nil {
-					err = session.Agent.WriteMessage(websocket.BinaryMessage, data)
-				}
-			} else if session.Agent != nil {
-				// 二进制消息，原样传递
-				err = session.Agent.WriteMessage(websocket.BinaryMessage, data)
-			}
-
-			if err != nil {
-				errChan <- err
-				return
-			}
-		}
-	}()
-
-	go func() {
-		for {
-			_, data, err := session.Agent.ReadMessage()
-			if err != nil {
-				errChan <- err
-				return
-			}
-			if session.Browser != nil {
-				err = session.Browser.WriteMessage(websocket.BinaryMessage, data)
-				if err != nil {
-					errChan <- err
-					return
-				}
-			}
-		}
-	}()
-
-	// 等待错误或主动关闭
-	<-errChan
-	// 关闭连接
-	if session.Agent != nil {
-		session.Agent.Close()
-	}
-	if session.Browser != nil {
-		session.Browser.Close()
-	}
-	disconnect_time := time.Now()
-	auditlog.Log(session.RequesterIp, session.UserUUID, "disconnected, terminal id:"+id+", duration:"+disconnect_time.Sub(established_time).String(), "terminal")
-	TerminalSessionsMutex.Lock()
-	delete(TerminalSessions, id)
-	TerminalSessionsMutex.Unlock()
-}

internal/api_v1/vars/vars.go

@@ -1,11 +0,0 @@
-package vars
-
-import (
-	"time"
-
-	"github.com/patrickmn/go-cache"
-)
-
-var (
-	Records = cache.New(1*time.Minute, 1*time.Minute)
-)

internal/app/app.go

@@ -1,287 +0,0 @@
-package app
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"os/signal"
-	"sort"
-	"syscall"
-	"time"
-)
-
-type Hooks struct {
-	Init  any
-	Start any
-	Stop  any
-}
-
-// Module is the single, explicit lifecycle unit.
-//
-//   - Provide registers DI providers (optional; return nil if none).
-//   - Hooks returns optional hook functions; dependencies are expressed as
-//     parameters and injected by the container.
-//
-// Hook function shapes:
-//
-//	func(context.Context, ...deps) error
-//	func(...deps) error
-//	func(context.Context, ...deps)
-//	func(...deps)
-type Module interface {
-	Name() string
-	Depends() []string
-	Provide(r Registry) error
-	Hooks() Hooks
-}
-
-type App struct {
-	container       *container
-	shutdownTimeout time.Duration
-	started         bool
-	regErr          error
-	modules         map[string]Module
-	moduleList      []Module
-	order           []string
-	startedOrder    []string
-}
-
-func New() *App {
-	return &App{container: newContainer("root"), shutdownTimeout: 5 * time.Second, modules: make(map[string]Module)}
-}
-
-func (a *App) With(mod Module) *App {
-	if a.regErr != nil {
-		return a
-	}
-	if a.container == nil {
-		a.container = newContainer("root")
-	}
-	a.regErr = a.register(mod)
-	if a.regErr == nil {
-		a.moduleList = append(a.moduleList, mod)
-		a.ensureDeps(mod, map[string]bool{})
-	}
-	return a
-}
-
-func (a *App) WithShutdownTimeout(d time.Duration) *App {
-	if d > 0 {
-		a.shutdownTimeout = d
-	}
-	return a
-}
-
-func (a *App) Start(ctx context.Context) error {
-	if a.regErr != nil {
-		return a.regErr
-	}
-	if a.container == nil {
-		a.container = newContainer("root")
-	}
-	if ctx == nil {
-		ctx = context.Background()
-	}
-	ctx = withContainerInContext(ctx, a.container)
-
-	// Register providers before hooks.
-	for _, mod := range a.moduleList {
-		if err := mod.Provide(a.container); err != nil {
-			return fmt.Errorf("provide module %s: %w", mod.Name(), err)
-		}
-	}
-
-	order, err := a.resolveOrder()
-	if err != nil {
-		return err
-	}
-
-	// Init hooks.
-	for _, name := range order {
-		h := a.modules[name].Hooks()
-		if h.Init == nil {
-			continue
-		}
-		if err := a.container.Invoke(ctx, h.Init); err != nil {
-			return fmt.Errorf("init module %s: %w", name, err)
-		}
-	}
-
-	// Start hooks.
-	a.startedOrder = a.startedOrder[:0]
-	for _, name := range order {
-		h := a.modules[name].Hooks()
-		if h.Start == nil {
-			a.startedOrder = append(a.startedOrder, name)
-			continue
-		}
-		if err := a.container.Invoke(ctx, h.Start); err != nil {
-			_ = a.stopHooks(ctx)
-			return fmt.Errorf("start module %s: %w", name, err)
-		}
-		a.startedOrder = append(a.startedOrder, name)
-	}
-	a.started = true
-	return nil
-}
-
-func (a *App) Stop(ctx context.Context) error {
-	if !a.started {
-		return nil
-	}
-	stopCtx := ctx
-	cancel := func() {}
-	if stopCtx == nil {
-		stopCtx, cancel = context.WithTimeout(context.Background(), a.shutdownTimeout)
-	} else {
-		stopCtx, cancel = context.WithTimeout(stopCtx, a.shutdownTimeout)
-	}
-	defer cancel()
-	if stopCtx == nil {
-		stopCtx = context.Background()
-	}
-	stopCtx = withContainerInContext(stopCtx, a.container)
-	err := a.stopHooks(stopCtx)
-	_ = a.container.Shutdown(stopCtx)
-	a.started = false
-	return err
-}
-
-// RunWith starts the app, executes fn, then stops the app.
-func (a *App) RunWith(ctx context.Context, fn func(context.Context) error) error {
-	if ctx == nil {
-		ctx = context.Background()
-	}
-	ctx = withContainerInContext(ctx, a.container)
-	if err := a.Start(ctx); err != nil {
-		_ = a.Stop(context.Background())
-		return err
-	}
-	defer func() { _ = a.Stop(context.Background()) }()
-	if fn == nil {
-		return nil
-	}
-	return fn(ctx)
-}
-
-// RunUntilSignal starts the app and blocks until ctx cancellation or SIGINT/SIGTERM.
-func (a *App) RunUntilSignal(ctx context.Context) error {
-	if ctx == nil {
-		ctx = context.Background()
-	}
-	ctx = withContainerInContext(ctx, a.container)
-	if err := a.Start(ctx); err != nil {
-		_ = a.Stop(context.Background())
-		return err
-	}
-	defer func() { _ = a.Stop(context.Background()) }()
-
-	quit := make(chan os.Signal, 1)
-	signal.Notify(quit, os.Interrupt, syscall.SIGTERM)
-	defer signal.Stop(quit)
-
-	select {
-	case <-ctx.Done():
-		return ctx.Err()
-	case <-quit:
-		return nil
-	}
-}
-
-func (a *App) register(mod Module) error {
-	if mod == nil {
-		return fmt.Errorf("module is nil")
-	}
-	name := mod.Name()
-	if name == "" {
-		return fmt.Errorf("module name is empty")
-	}
-	if _, exists := a.modules[name]; exists {
-		return fmt.Errorf("duplicate module name: %s", name)
-	}
-	a.modules[name] = mod
-	a.order = nil
-	return nil
-}
-
-func (a *App) has(name string) bool {
-	_, ok := a.modules[name]
-	return ok
-}
-
-func (a *App) resolveOrder() ([]string, error) {
-	if a.order != nil {
-		return a.order, nil
-	}
-
-	inDegree := make(map[string]int, len(a.modules))
-	deps := make(map[string][]string, len(a.modules))
-	reverse := make(map[string][]string, len(a.modules))
-
-	for name, mod := range a.modules {
-		inDegree[name] = 0
-		deps[name] = append([]string(nil), mod.Depends()...)
-	}
-
-	for name := range a.modules {
-		for _, dep := range deps[name] {
-			if _, ok := a.modules[dep]; !ok {
-				return nil, fmt.Errorf("module %s depends on missing module %s", name, dep)
-			}
-			inDegree[name]++
-			reverse[dep] = append(reverse[dep], name)
-		}
-	}
-
-	q := make([]string, 0, len(a.modules))
-	for name, d := range inDegree {
-		if d == 0 {
-			q = append(q, name)
-		}
-	}
-	sort.Strings(q)
-
-	order := make([]string, 0, len(a.modules))
-	for len(q) > 0 {
-		n := q[0]
-		q = q[1:]
-		order = append(order, n)
-		for _, child := range reverse[n] {
-			inDegree[child]--
-			if inDegree[child] == 0 {
-				q = append(q, child)
-			}
-		}
-		sort.Strings(q)
-	}
-
-	if len(order) != len(a.modules) {
-		remaining := make([]string, 0)
-		for name, d := range inDegree {
-			if d != 0 {
-				remaining = append(remaining, name)
-			}
-		}
-		sort.Strings(remaining)
-		return nil, fmt.Errorf("dependency cycle detected among: %v", remaining)
-	}
-
-	a.order = order
-	return order, nil
-}
-
-func (a *App) stopHooks(ctx context.Context) error {
-	var firstErr error
-	for i := len(a.startedOrder) - 1; i >= 0; i-- {
-		name := a.startedOrder[i]
-		h := a.modules[name].Hooks()
-		if h.Stop == nil {
-			continue
-		}
-		if err := a.container.Invoke(ctx, h.Stop); err != nil && firstErr == nil {
-			firstErr = fmt.Errorf("stop module %s: %w", name, err)
-		}
-	}
-	a.startedOrder = a.startedOrder[:0]
-	return firstErr
-}

internal/app/di.go

@@ -1,355 +0,0 @@
-package app
-
-import (
-	"context"
-	"fmt"
-	"reflect"
-	"sync"
-)
-
-type containerCtxKey struct{}
-
-func withContainerInContext(ctx context.Context, c *container) context.Context {
-	if ctx == nil {
-		ctx = context.Background()
-	}
-	if c == nil {
-		return ctx
-	}
-	return context.WithValue(ctx, containerCtxKey{}, c)
-}
-
-func containerFromContext(ctx context.Context) (*container, bool) {
-	if ctx == nil {
-		return nil, false
-	}
-	c, ok := ctx.Value(containerCtxKey{}).(*container)
-	return c, ok && c != nil
-}
-
-// Resolve is an explicit escape hatch for the rare cases where passing
-// dependencies via hook parameters is not ergonomic.
-//
-// Prefer declaring dependencies on hook function parameters instead.
-func Resolve[T any](ctx context.Context) (T, error) {
-	var zero T
-	c, ok := containerFromContext(ctx)
-	if !ok {
-		return zero, fmt.Errorf("no container in context")
-	}
-
-	t := reflect.TypeOf((*T)(nil)).Elem()
-	v, err := c.resolve(ctx, key{t: t})
-	if err != nil {
-		return zero, err
-	}
-	return v.Interface().(T), nil
-}
-
-// ResolveNamed resolves a named registration from ctx.
-func ResolveNamed[T any](ctx context.Context, name string) (T, error) {
-	var zero T
-	c, ok := containerFromContext(ctx)
-	if !ok {
-		return zero, fmt.Errorf("no container in context")
-	}
-
-	t := reflect.TypeOf((*T)(nil)).Elem()
-	v, err := c.resolve(ctx, key{t: t, name: name})
-	if err != nil {
-		return zero, err
-	}
-	return v.Interface().(T), nil
-}
-
-// Registry is the minimal surface a module needs to register providers.
-//
-// It intentionally does NOT expose resolution, so modules can't turn DI into a
-// service locator.
-type Registry interface {
-	Provide(fn any, opts ...ProvideOption) error
-}
-
-type key struct {
-	t    reflect.Type
-	name string
-}
-
-// container is a lightweight DI container with optional named registrations and scopes.
-//
-// It supports:
-// - Singleton instances per-scope.
-// - Providers declared as functions with injectable parameters.
-// - Scopes for plugin hot-plug (child container inherits parent providers/values).
-// - Optional shutdown hooks for providers (for scope disposal).
-//
-// Provider function shapes:
-// - func(...) T
-// - func(...) (T, error)
-// - func(...) (T, func(context.Context) error)
-// - func(...) (T, func(context.Context) error, error)
-//
-// Injectable parameters:
-// - context.Context: passed through from Invoke.
-// - any provided type (resolved recursively).
-//
-// Notes:
-// - For multiple implementations, use Named registrations.
-// - Cycles are detected during resolution.
-type container struct {
-	name   string
-	parent *container
-
-	mu        sync.Mutex
-	values    map[key]reflect.Value
-	providers map[key]provider
-	resolving map[key]bool
-	closers   []func(context.Context) error
-	closed    bool
-}
-
-type provider struct {
-	fn          reflect.Value
-	outKey      key
-	hasErr      bool
-	hasCloser   bool
-	closerIndex int
-}
-
-func newContainer(name string) *container {
-	return &container{
-		name:      name,
-		values:    make(map[key]reflect.Value),
-		providers: make(map[key]provider),
-		resolving: make(map[key]bool),
-	}
-}
-
-type ProvideOption func(*provideOptions)
-
-type provideOptions struct {
-	name string
-}
-
-func Named(name string) ProvideOption {
-	return func(o *provideOptions) { o.name = name }
-}
-
-func (c *container) Provide(fn any, opts ...ProvideOption) error {
-	if fn == nil {
-		return fmt.Errorf("provider is nil")
-	}
-	var o provideOptions
-	for _, opt := range opts {
-		if opt != nil {
-			opt(&o)
-		}
-	}
-
-	v := reflect.ValueOf(fn)
-	t := v.Type()
-	if t.Kind() != reflect.Func {
-		return fmt.Errorf("provider must be a func, got %s", t.Kind())
-	}
-	if t.NumOut() < 1 || t.NumOut() > 3 {
-		return fmt.Errorf("provider must return 1..3 values, got %d", t.NumOut())
-	}
-
-	outT := t.Out(0)
-	p := provider{fn: v, outKey: key{t: outT, name: o.name}, closerIndex: -1}
-
-	switch t.NumOut() {
-	case 1:
-		// T
-	case 2:
-		// (T, error) or (T, closer)
-		if isErrorType(t.Out(1)) {
-			p.hasErr = true
-		} else if isCloserType(t.Out(1)) {
-			p.hasCloser = true
-			p.closerIndex = 1
-		} else {
-			return fmt.Errorf("provider second return must be error or func(context.Context) error")
-		}
-	case 3:
-		// (T, closer, error)
-		if !isCloserType(t.Out(1)) || !isErrorType(t.Out(2)) {
-			return fmt.Errorf("provider must return (T, func(context.Context) error, error)")
-		}
-		p.hasCloser = true
-		p.closerIndex = 1
-		p.hasErr = true
-	}
-
-	c.mu.Lock()
-	defer c.mu.Unlock()
-	if c.closed {
-		return fmt.Errorf("container %s is closed", c.name)
-	}
-	if _, exists := c.providers[p.outKey]; exists {
-		return fmt.Errorf("duplicate provider for %s (name=%q)", outT, o.name)
-	}
-	c.providers[p.outKey] = p
-	return nil
-}
-
-func (c *container) Invoke(ctx context.Context, fn any) error {
-	if fn == nil {
-		return fmt.Errorf("invoke fn is nil")
-	}
-	v := reflect.ValueOf(fn)
-	if v.Kind() != reflect.Func {
-		return fmt.Errorf("invoke target must be func")
-	}
-	args, err := c.buildArgs(ctx, v.Type())
-	if err != nil {
-		return err
-	}
-	outs := v.Call(args)
-	if len(outs) == 0 {
-		return nil
-	}
-	last := outs[len(outs)-1]
-	if isErrorType(last.Type()) && !last.IsNil() {
-		return last.Interface().(error)
-	}
-	return nil
-}
-
-func (c *container) Shutdown(ctx context.Context) error {
-	c.mu.Lock()
-	if c.closed {
-		c.mu.Unlock()
-		return nil
-	}
-	closers := append([]func(context.Context) error(nil), c.closers...)
-	c.closed = true
-	c.mu.Unlock()
-
-	var firstErr error
-	for i := len(closers) - 1; i >= 0; i-- {
-		if err := closers[i](ctx); err != nil && firstErr == nil {
-			firstErr = err
-		}
-	}
-	return firstErr
-}
-
-func (c *container) resolve(ctx context.Context, k key) (reflect.Value, error) {
-	// Fast path: check local cache.
-	c.mu.Lock()
-	if v, ok := c.values[k]; ok {
-		c.mu.Unlock()
-		return v, nil
-	}
-	if c.resolving[k] {
-		c.mu.Unlock()
-		return reflect.Value{}, fmt.Errorf("dependency cycle resolving %s (name=%q)", k.t, k.name)
-	}
-	p, ok := c.providers[k]
-	if !ok {
-		parent := c.parent
-		c.mu.Unlock()
-		if parent != nil {
-			return parent.resolve(ctx, k)
-		}
-		return reflect.Value{}, fmt.Errorf("no provider for %s (name=%q)", k.t, k.name)
-	}
-	c.resolving[k] = true
-	c.mu.Unlock()
-
-	// Build args and call provider.
-	args, err := c.buildArgs(ctx, p.fn.Type())
-	if err != nil {
-		c.mu.Lock()
-		delete(c.resolving, k)
-		c.mu.Unlock()
-		return reflect.Value{}, err
-	}
-	outs := p.fn.Call(args)
-
-	var outV reflect.Value
-	var closerFn reflect.Value
-	var errV reflect.Value
-
-	switch len(outs) {
-	case 1:
-		outV = outs[0]
-	case 2:
-		outV = outs[0]
-		if p.hasErr {
-			errV = outs[1]
-		} else if p.hasCloser {
-			closerFn = outs[1]
-		}
-	case 3:
-		outV = outs[0]
-		closerFn = outs[1]
-		errV = outs[2]
-	}
-
-	if p.hasErr && !errV.IsNil() {
-		err := errV.Interface().(error)
-		c.mu.Lock()
-		delete(c.resolving, k)
-		c.mu.Unlock()
-		return reflect.Value{}, err
-	}
-
-	c.mu.Lock()
-	delete(c.resolving, k)
-	// Another goroutine could have resolved it while we were building; keep singleton semantics.
-	if existing, ok := c.values[k]; ok {
-		c.mu.Unlock()
-		return existing, nil
-	}
-	c.values[k] = outV
-	if p.hasCloser {
-		cf := closerFn
-		if cf.IsValid() && !cf.IsNil() {
-			c.closers = append(c.closers, func(ctx context.Context) error {
-				outs := cf.Call([]reflect.Value{reflect.ValueOf(ctx)})
-				if len(outs) == 1 && !outs[0].IsNil() {
-					return outs[0].Interface().(error)
-				}
-				return nil
-			})
-		}
-	}
-	c.mu.Unlock()
-
-	return outV, nil
-}
-
-func (c *container) buildArgs(ctx context.Context, fnType reflect.Type) ([]reflect.Value, error) {
-	in := fnType.NumIn()
-	args := make([]reflect.Value, 0, in)
-
-	ctxType := reflect.TypeOf((*context.Context)(nil)).Elem()
-
-	for i := 0; i < in; i++ {
-		paramT := fnType.In(i)
-		switch {
-		case paramT == ctxType:
-			args = append(args, reflect.ValueOf(ctx))
-		default:
-			v, err := c.resolve(ctx, key{t: paramT})
-			if err != nil {
-				return nil, err
-			}
-			args = append(args, v)
-		}
-	}
-
-	return args, nil
-}
-
-func isErrorType(t reflect.Type) bool {
-	errT := reflect.TypeOf((*error)(nil)).Elem()
-	return t == errT
-}
-
-func isCloserType(t reflect.Type) bool {
-	closerT := reflect.TypeOf((func(context.Context) error)(nil))
-	return t == closerT
-}

internal/app/registry.go

@@ -1,76 +0,0 @@
-package app
-
-import (
-	"fmt"
-	"sync"
-)
-
-var (
-	factoryMu sync.RWMutex
-	factories = make(map[string]func() Module)
-)
-
-// RegisterModuleFactory registers a factory used by App to auto-materialize missing dependencies.
-// Intended for core modules (config/db) and plugin-provided modules.
-func RegisterModuleFactory(name string, factory func() Module) {
-	if name == "" || factory == nil {
-		return
-	}
-	factoryMu.Lock()
-	factories[name] = factory
-	factoryMu.Unlock()
-}
-
-func getModuleFactory(name string) (func() Module, bool) {
-	factoryMu.RLock()
-	f, ok := factories[name]
-	factoryMu.RUnlock()
-	return f, ok
-}
-
-func (a *App) ensureDeps(mod Module, visiting map[string]bool) {
-	if a.regErr != nil {
-		return
-	}
-	if mod == nil {
-		a.regErr = fmt.Errorf("module is nil")
-		return
-	}
-
-	name := mod.Name()
-	if visiting[name] {
-		a.regErr = fmt.Errorf("dependency cycle while materializing: %s", name)
-		return
-	}
-	visiting[name] = true
-	defer func() { visiting[name] = false }()
-
-	for _, dep := range mod.Depends() {
-		if dep == "" {
-			continue
-		}
-		if a.has(dep) {
-			continue
-		}
-		f, ok := getModuleFactory(dep)
-		if !ok {
-			a.regErr = fmt.Errorf("missing module %q (no factory registered)", dep)
-			return
-		}
-		depMod := f()
-		if depMod == nil {
-			a.regErr = fmt.Errorf("module factory for %q returned nil", dep)
-			return
-		}
-		// Register dependency module and its dependencies recursively.
-		a.regErr = a.register(depMod)
-		if a.regErr != nil {
-			return
-		}
-		a.moduleList = append(a.moduleList, depMod)
-		a.ensureDeps(depMod, visiting)
-		if a.regErr != nil {
-			return
-		}
-	}
-}

internal/client/client.go

@@ -1,178 +0,0 @@
-package client
-
-import (
-	"math"
-	"time"
-
-	"github.com/gookit/event"
-	"github.com/komari-monitor/komari/internal/database/models"
-	"github.com/komari-monitor/komari/internal/dbcore"
-	"github.com/komari-monitor/komari/internal/eventType"
-	"github.com/komari-monitor/komari/pkg/utils"
-
-	"fmt"
-
-	"github.com/google/uuid"
-)
-
-func DeleteClient(clientUuid string) error {
-	db := dbcore.GetDBInstance()
-	c := models.Client{}
-	err := db.Model(&models.Client{}).Where("uuid = ?", clientUuid).First(&c).Error
-	if err != nil {
-		return err
-	}
-	err = db.Delete(&models.Client{}, "uuid = ?", clientUuid).Error
-	if err != nil {
-		return err
-	}
-	event.Trigger(eventType.ClientDeleted, event.M{
-		"client": c})
-	return nil
-}
-
-func PartialUpdate(update map[string]interface{}) error {
-	db := dbcore.GetDBInstance()
-	clientUUID, ok := update["uuid"].(string)
-	if !ok || clientUUID == "" {
-		return fmt.Errorf("invalid client UUID")
-	}
-
-	// 确保更新的字段不为空
-	if len(update) == 0 {
-		return fmt.Errorf("no fields to update")
-	}
-
-	c := models.Client{}
-	err := db.Model(&models.Client{}).Where("uuid = ?", clientUUID).First(&c).Error
-	if err != nil {
-		return err
-	}
-
-	update["updated_at"] = time.Now()
-
-	checkInt64 := func(name string, val float64) error {
-		if val < 0 {
-			return fmt.Errorf("%s must be non-negative, got %d", name, int64(val))
-		}
-		if val > math.MaxInt64-1 {
-			return fmt.Errorf("%s exceeds int64 max limit: %d", name, int64(val))
-		}
-		return nil
-	}
-
-	verify := func(update map[string]interface{}) error {
-		if update["cpu_cores"].(float64) < 0 || update["cpu_cores"].(float64) > math.MaxInt-1 {
-			return fmt.Errorf("Cpu.Cores be not a valid int64 number: %d", update["cpu_cores"])
-		}
-		if err := checkInt64("Ram.Total", update["mem_total"].(float64)); err != nil {
-			return err
-		}
-		if err := checkInt64("Swap.Total", update["swap_total"].(float64)); err != nil {
-			return err
-		}
-		if err := checkInt64("Disk.Total", update["disk_total"].(float64)); err != nil {
-			return err
-		}
-		return nil
-	}
-
-	if err := verify(update); err != nil {
-		return err
-	}
-
-	err = db.Model(&models.Client{}).Where("uuid = ?", clientUUID).Updates(update).Error
-	if err != nil {
-		return err
-	}
-
-	new_c := models.Client{}
-	err = db.Model(&models.Client{}).Where("uuid = ?", clientUUID).First(&new_c).Error
-	if err != nil {
-		return err
-	}
-
-	event.Trigger(eventType.ClientUpdated, event.M{
-		"old": c,
-		"new": new_c,
-	})
-	return nil
-}
-
-// CreateClient 创建新客户端
-func CreateClient() (clientUUID, token string, err error) {
-	db := dbcore.GetDBInstance()
-	token = utils.GenerateToken()
-	clientUUID = uuid.New().String()
-
-	client := models.Client{
-		UUID:      clientUUID,
-		Token:     token,
-		Name:      "client_" + clientUUID[0:8],
-		CreatedAt: models.FromTime(time.Now()),
-		UpdatedAt: models.FromTime(time.Now()),
-	}
-
-	err = db.Create(&client).Error
-	if err != nil {
-		return "", "", err
-	}
-
-	event.Trigger(eventType.ClientCreated, event.M{
-		"client": client,
-	})
-	return clientUUID, token, nil
-}
-
-func CreateClientWithName(name string) (clientUUID, token string, err error) {
-	if name == "" {
-		return CreateClient()
-	}
-	db := dbcore.GetDBInstance()
-	token = utils.GenerateToken()
-	clientUUID = uuid.New().String()
-	client := models.Client{
-		UUID:      clientUUID,
-		Token:     token,
-		Name:      name,
-		CreatedAt: models.FromTime(time.Now()),
-		UpdatedAt: models.FromTime(time.Now()),
-	}
-
-	err = db.Create(&client).Error
-	if err != nil {
-		return "", "", err
-	}
-	event.Trigger(eventType.ClientCreated, event.M{
-		"client": client,
-	})
-	return clientUUID, token, nil
-}
-
-func GetClientByUUID(uuid string) (client models.Client, err error) {
-	db := dbcore.GetDBInstance()
-	err = db.Where("uuid = ?", uuid).First(&client).Error
-	if err != nil {
-		return models.Client{}, err
-	}
-	return client, nil
-}
-
-func GetClientTokenByUUID(uuid string) (token string, err error) {
-	db := dbcore.GetDBInstance()
-	var client models.Client
-	err = db.Where("uuid = ?", uuid).First(&client).Error
-	if err != nil {
-		return "", err
-	}
-	return client.Token, nil
-}
-
-func GetAllClientBasicInfo() (clients []models.Client, err error) {
-	db := dbcore.GetDBInstance()
-	err = db.Find(&clients).Error
-	if err != nil {
-		return nil, err
-	}
-	return clients, nil
-}

internal/client/report.go

@@ -1,219 +0,0 @@
-package client
-
-import (
-	"fmt"
-	"math"
-
-	"github.com/komari-monitor/komari/internal/common"
-	"github.com/komari-monitor/komari/internal/database/models"
-	"github.com/komari-monitor/komari/internal/dbcore"
-)
-
-func GetClientUUIDByToken(token string) (clientUUID string, err error) {
-	db := dbcore.GetDBInstance()
-	var client models.Client
-	err = db.Where("token = ?", token).First(&client).Error
-	if err != nil {
-		return "", err
-	}
-	return client.UUID, nil
-}
-
-// 检查数据防止异常数据导致数据库损坏
-func ReportVerify(report common.Report) error {
-	// 防止输入不合理范围
-	if report.CPU.Usage < 0 || report.CPU.Usage > 100 {
-		return fmt.Errorf("CPU.Usage must be between 0 and 100")
-	}
-
-	if report.Load.Load1 < 0 || report.Load.Load1 > 1000 {
-		return fmt.Errorf("Load.Load1 must be non-negative, got %.2f", report.Load.Load1)
-	}
-
-	checkFloat64 := func(name string, val float64) error {
-		if val > math.MaxFloat64-1 || val < -math.MaxFloat64+1 {
-			return fmt.Errorf("%s value exceeds float64 range: %g", name, val)
-		}
-		return nil
-	}
-
-	// [float64] 防止数据溢出
-	if err := checkFloat64("CPU.Usage", report.CPU.Usage); err != nil {
-		return err
-	}
-	if err := checkFloat64("Load.Load1", report.Load.Load1); err != nil {
-		return err
-	}
-
-	checkInt64 := func(name string, val int64) error {
-		if val < 0 {
-			return fmt.Errorf("%s must be non-negative, got %d", name, val)
-		}
-		if val > math.MaxInt64-1 {
-			return fmt.Errorf("%s exceeds int64 max limit: %d", name, val)
-		}
-		return nil
-	}
-
-	// [int64] 防止数据溢出
-	// Ram 验证
-	if err := checkInt64("Ram.Used", report.Ram.Used); err != nil {
-		return err
-	}
-	if err := checkInt64("Ram.Total", report.Ram.Total); err != nil {
-		return err
-	}
-	// Swap 验证
-	if err := checkInt64("Swap.Used", report.Swap.Used); err != nil {
-		return err
-	}
-	if err := checkInt64("Swap.Total", report.Swap.Total); err != nil {
-		return err
-	}
-	// Disk 验证
-	if err := checkInt64("Disk.Used", report.Disk.Used); err != nil {
-		return err
-	}
-	if err := checkInt64("Disk.Total", report.Disk.Total); err != nil {
-		return err
-	}
-	// Network 验证
-	if err := checkInt64("Network.Up", report.Network.Up); err != nil {
-		return err
-	}
-	if err := checkInt64("Network.Down", report.Network.Down); err != nil {
-		return err
-	}
-	if err := checkInt64("Network.TotalUp", report.Network.TotalUp); err != nil {
-		return err
-	}
-	if err := checkInt64("Network.TotalDown", report.Network.TotalDown); err != nil {
-		return err
-	}
-	// 拒绝所有负数Int
-	if report.Process < 0 {
-		return fmt.Errorf("process must be non-negative: %d", report.Process)
-	}
-	if report.Connections.TCP < 0 {
-		return fmt.Errorf("Connections.TCP must be non-negative: %d", report.Connections.TCP)
-	}
-	if report.Connections.UDP < 0 {
-		return fmt.Errorf("Connections.UDP must be non-negative: %d", report.Connections.UDP)
-	}
-	return nil
-}
-
-// // SaveClientReport 保存客户端报告到 Record 表
-// func SaveClientReport(clientUUID string, report common.Report) (err error) {
-// 	db := dbcore.GetDBInstance()
-
-// 	if err := ReportVerify(report); err != nil {
-// 		return fmt.Errorf("failed to save Record: %v", err)
-// 	}
-
-// 	// 保存GPU详细记录到独立表
-// 	currentTime := time.Now()
-// 	if report.GPU != nil && len(report.GPU.DetailedInfo) > 0 {
-// 		for idx, gpu := range report.GPU.DetailedInfo {
-// 			gpuRecord := models.GPURecord{
-// 				Client:      clientUUID,
-// 				Time:        models.FromTime(currentTime),
-// 				DeviceIndex: idx,
-// 				DeviceName:  gpu.Name,
-// 				MemTotal:    gpu.MemoryTotal,
-// 				MemUsed:     gpu.MemoryUsed,
-// 				Utilization: float32(gpu.Utilization),
-// 				Temperature: gpu.Temperature,
-// 			}
-// 			if err := db.Create(&gpuRecord).Error; err != nil {
-// 				return fmt.Errorf("failed to save GPU record: %v", err)
-// 			}
-// 		}
-// 	}
-
-// 	// 计算平均GPU使用率，用于向后兼容
-// 	averageGPUUsage := float32(0)
-// 	if report.GPU != nil && len(report.GPU.DetailedInfo) > 0 {
-// 		averageGPUUsage = float32(report.GPU.AverageUsage)
-// 	}
-
-// 	Record := models.Record{
-// 		Client:         clientUUID,
-// 		Time:           models.FromTime(currentTime),
-// 		Cpu:            float32(report.CPU.Usage),
-// 		Gpu:            averageGPUUsage, // 使用平均GPU使用率
-// 		Ram:            report.Ram.Used,
-// 		RamTotal:       report.Ram.Total,
-// 		Swap:           report.Swap.Used,
-// 		SwapTotal:      report.Swap.Total,
-// 		Load:           float32(report.Load.Load1), // 使用 Load1 作为主要负载指标
-// 		Temp:           0,                          // Report 未提供 TEMP，设为 0（与原 nil 行为类似）
-// 		Disk:           report.Disk.Used,
-// 		DiskTotal:      report.Disk.Total,
-// 		NetIn:          report.Network.Down,
-// 		NetOut:         report.Network.Up,
-// 		NetTotalUp:     report.Network.TotalUp,
-// 		NetTotalDown:   report.Network.TotalDown,
-// 		Process:        report.Process,
-// 		Connections:    report.Connections.TCP,
-// 		ConnectionsUdp: report.Connections.UDP,
-// 		//Uptime:         report.Uptime,
-// 	}
-
-// 	// 使用事务确保 Record 和 ClientsInfo 一致性
-// 	err = db.Transaction(func(tx *gorm.DB) error {
-// 		// 保存 Record
-// 		if err := tx.Create(&Record).Error; err != nil {
-// 			return fmt.Errorf("failed to save Record: %v", err)
-// 		}
-// 		return nil
-// 	})
-
-// 	if err != nil {
-// 		return err
-// 	}
-
-// 	return nil
-// }
-
-/*
-// getString 从 map 中获取字符串
-func getString(data map[string]interface{}, key string) string {
-	if val, ok := data[key]; ok {
-		if str, ok := val.(string); ok {
-			return str
-		}
-	}
-	return ""
-}
-
-// getInt 从 map 中获取整数
-func getInt(data map[string]interface{}, key string) int {
-	if val, ok := data[key]; ok {
-		if num, ok := val.(float64); ok {
-			return int(num)
-		}
-	}
-	return 0
-}
-
-// getInt64 从 map 中获取 int64
-func getInt64(data map[string]interface{}, key string) int64 {
-	if val, ok := data[key]; ok {
-		if num, ok := val.(float64); ok {
-			return int64(num)
-		}
-	}
-	return 0
-}
-
-// getFloat 从 map 中获取 float64
-func getFloat(data map[string]interface{}, key string) float64 {
-	if val, ok := data[key]; ok {
-		if num, ok := val.(float64); ok {
-			return num
-		}
-	}
-	return 0.0
-}
-*/

internal/cloudflared/cloudflared.go

@@ -1,149 +0,0 @@
-package cloudflared
-
-import (
-	"bufio"
-	"fmt"
-	"io"
-	"log"
-	"net/http"
-	"os"
-	"os/exec"
-	"runtime"
-)
-
-func downloadCloudflared(downloadURL, filePath string) error {
-	log.Println("downloading cloudflared...")
-	resp, err := http.Get(downloadURL)
-	if err != nil {
-		return err
-	}
-	defer resp.Body.Close()
-	out, err := os.Create(filePath)
-	if err != nil {
-		return err
-	}
-	_, err = io.Copy(out, resp.Body)
-	closeErr := out.Close() // 先关闭文件
-	if err != nil {
-		return err
-	}
-	if closeErr != nil {
-		return closeErr
-	}
-	if runtime.GOOS != "windows" {
-		err = os.Chmod(filePath, 0755)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-var cloudflaredCmd *exec.Cmd
-
-func RunCloudflared() error {
-	var (
-		downloadURL string
-		fileName    = "cloudflared"
-	)
-	if _, err := os.Stat("data"); os.IsNotExist(err) {
-		os.Mkdir("data", 0755)
-	}
-
-	switch runtime.GOOS {
-	case "windows":
-		fileName = "cloudflared.exe"
-		switch runtime.GOARCH {
-		case "amd64":
-			downloadURL = "https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-windows-amd64.exe"
-		case "386":
-			downloadURL = "https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-windows-386.exe"
-		default:
-			return fmt.Errorf("unsupported architecture: %s", runtime.GOARCH)
-		}
-	case "linux":
-		switch runtime.GOARCH {
-		case "amd64":
-			downloadURL = "https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64"
-		case "386":
-			downloadURL = "https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-386"
-		case "arm":
-			downloadURL = "https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-arm"
-		case "arm64":
-			downloadURL = "https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-arm64"
-		default:
-			return fmt.Errorf("unsupported architecture: %s", runtime.GOARCH)
-		}
-	case "darwin":
-		switch runtime.GOARCH {
-		case "amd64":
-			downloadURL = "https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-darwin-amd64.tgz"
-		case "arm64":
-			downloadURL = "https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-darwin-arm64.tgz"
-		default:
-			return fmt.Errorf("unsupported architecture: %s", runtime.GOARCH)
-		}
-	default:
-		return fmt.Errorf("unsupported os: %s", runtime.GOOS)
-	}
-
-	filePath := "data/" + fileName
-	if _, err := os.Stat(filePath); os.IsNotExist(err) {
-		err := downloadCloudflared(downloadURL, filePath)
-		if err != nil {
-			return err
-		}
-	}
-
-	args := []string{"tunnel", "--no-autoupdate", "run", "--token"}
-	token := os.Getenv("KOMARI_CLOUDFLARED_TOKEN")
-	args = append(args, token)
-
-	cmd := exec.Command(filePath, args...)
-	cloudflaredCmd = cmd
-	stdout, err := cmd.StdoutPipe()
-	if err != nil {
-		return err
-	}
-	stderr, err := cmd.StderrPipe()
-	if err != nil {
-		return err
-	}
-	if err := cmd.Start(); err != nil {
-		return err
-	}
-	go func() {
-		scanner := bufio.NewScanner(stdout)
-		for scanner.Scan() {
-			log.Printf("[cloudflared] %s", scanner.Text())
-		}
-	}()
-	go func() {
-		scanner := bufio.NewScanner(stderr)
-		for scanner.Scan() {
-			log.Printf("[cloudflared] %s", scanner.Text())
-		}
-	}()
-	go func() {
-		if err := cmd.Wait(); err != nil {
-			log.Printf("cloudflared exited with error: %v", err)
-		} else {
-			log.Println("cloudflared exited successfully")
-		}
-		os.Exit(1)
-	}()
-	log.Println("cloudflared started")
-	return nil
-}
-
-func Kill() {
-	if cloudflaredCmd != nil && cloudflaredCmd.Process != nil {
-		err := cloudflaredCmd.Process.Kill()
-		if err != nil {
-			log.Printf("failed to kill cloudflared: %v", err)
-		} else {
-			log.Println("cloudflared killed")
-		}
-		cloudflaredCmd = nil
-	}
-}

internal/cloudflared/cloudflared_test.go

@@ -1,21 +0,0 @@
-package cloudflared_test
-
-import (
-	"os"
-	"testing"
-	"time"
-
-	"github.com/komari-monitor/komari/internal/cloudflared"
-)
-
-func TestRunCloudflared(t *testing.T) {
-	os.Setenv("KOMARI_CLOUDFLARED_TOKEN", "test-token")
-
-	err := cloudflared.RunCloudflared()
-	if err != nil {
-		t.Fatalf("RunCloudflared failed: %v", err)
-	}
-
-	// 等待一段时间，确保子进程已启动
-	time.Sleep(2 * time.Second)
-}

internal/cloudflared/init.go

@@ -1,28 +0,0 @@
-package cloudflared
-
-import (
-	"fmt"
-	"os"
-	"strings"
-
-	"github.com/gookit/event"
-	"github.com/komari-monitor/komari/internal/eventType"
-)
-
-func init() {
-	event.On(eventType.ServerInitializeStart, event.ListenerFunc(func(e event.Event) error {
-		if strings.ToLower(strings.ToLower(os.Getenv("KOMARI_ENABLE_CLOUDFLARED"))) == "true" {
-			err := RunCloudflared()
-			if err != nil {
-				// Error in ServerInitializeStart will cause the process to exit
-				return fmt.Errorf("failed to run cloudflared: %v", err)
-			}
-		}
-		return nil
-	}))
-
-	event.On(eventType.ProcessExit, event.ListenerFunc(func(e event.Event) error {
-		Kill()
-		return nil
-	}))
-}

internal/common/modules.go

@@ -1,135 +0,0 @@
-package common
-
-import "time"
-
-type Message struct {
-	Type      string `json:"type"`
-	Content   string `json:"content"`
-	Sender    string `json:"sender"`
-	Timestamp int64  `json:"timestamp"`
-}
-
-type ClientConfig struct {
-	ClientUUID  string    `json:"client_uuid" gorm:"type:uuid;primaryKey;foreignKey:ClientUUID;references:UUID;constraint:OnDelete:CASCADE"`
-	CPU         bool      `json:"cpu" gorm:"default:true"`
-	GPU         bool      `json:"gpu" gorm:"default:true"`
-	RAM         bool      `json:"ram" gorm:"default:true"`
-	SWAP        bool      `json:"swap" gorm:"default:true"`
-	LOAD        bool      `json:"load" gorm:"default:true"`
-	UPTIME      bool      `json:"uptime" gorm:"default:true"`
-	TEMP        bool      `json:"temp" gorm:"default:true"`
-	OS          bool      `json:"os" gorm:"default:true"`
-	DISK        bool      `json:"disk" gorm:"default:true"`
-	NET         bool      `json:"net" gorm:"default:true"`
-	PROCESS     bool      `json:"process" gorm:"default:true"`
-	Connections bool      `json:"connections" gorm:"default:true"`
-	Interval    int       `json:"interval" gorm:"default:3;check:Interval >= 1"`
-	CreatedAt   time.Time `json:"created_at"`
-	UpdatedAt   time.Time `json:"updated_at"`
-}
-
-// 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"`
-	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"`
-	ExpiredAt      time.Time `json:"expired_at" gorm:"type:timestamp"`
-	CreatedAt      time.Time
-	UpdatedAt      time.Time
-}
-
-type IPAddress struct {
-	Ipv4 string `json:"ipv4"`
-	Ipv6 string `json:"ipv6"`
-}
-type Report struct {
-	UUID        string            `json:"uuid,omitempty"`
-	CPU         CPUReport         `json:"cpu"`
-	Ram         RamReport         `json:"ram"`
-	Swap        RamReport         `json:"swap"`
-	Load        LoadReport        `json:"load"`
-	Disk        DiskReport        `json:"disk"`
-	Network     NetworkReport     `json:"network"`
-	Connections ConnectionsReport `json:"connections"`
-	GPU         *GPUDetailReport  `json:"gpu,omitempty"` // 新增GPU详细信息
-	Uptime      int64             `json:"uptime"`
-	Process     int               `json:"process"`
-	Message     string            `json:"message"`
-	Method      string            `json:"method,omitempty"`
-	UpdatedAt   time.Time         `json:"updated_at"`
-}
-
-type CPUReport struct {
-	Name  string  `json:"name,omitempty"`
-	Cores int     `json:"cores,omitempty"`
-	Arch  string  `json:"arch,omitempty"`
-	Usage float64 `json:"usage,omitempty"`
-}
-
-// GPUDetailReport 详细GPU信息报告
-type GPUDetailReport struct {
-	Count        int             `json:"count"`         // GPU数量
-	AverageUsage float64         `json:"average_usage"` // 平均使用率
-	DetailedInfo []GPUDeviceInfo `json:"detailed_info"` // 每个GPU的详细信息
-}
-
-// GPUDeviceInfo 单个GPU设备信息
-type GPUDeviceInfo struct {
-	Name        string  `json:"name"`         // GPU型号名称
-	MemoryTotal int64   `json:"memory_total"` // 显存总量(字节)
-	MemoryUsed  int64   `json:"memory_used"`  // 显存已用(字节)
-	Utilization float64 `json:"utilization"`  // GPU使用率(%)
-	Temperature int     `json:"temperature"`  // GPU温度(°C)
-}
-
-// 保持向后兼容的旧GPUReport结构
-type GPUReport struct {
-	Name  string  `json:"name,omitempty"`
-	Usage float64 `json:"usage,omitempty"`
-}
-
-type RamReport struct {
-	Total int64 `json:"total"`
-	Used  int64 `json:"used"`
-}
-
-type LoadReport struct {
-	Load1  float64 `json:"load1"`
-	Load5  float64 `json:"load5"`
-	Load15 float64 `json:"load15"`
-}
-
-type DiskReport struct {
-	Total int64 `json:"total"`
-	Used  int64 `json:"used"`
-}
-
-type NetworkReport struct {
-	Up        int64 `json:"up"`
-	Down      int64 `json:"down"`
-	TotalUp   int64 `json:"totalUp"`
-	TotalDown int64 `json:"totalDown"`
-}
-
-type ConnectionsReport struct {
-	TCP int `json:"tcp"`
-	UDP int `json:"udp"`
-}

internal/conf/config.go

@@ -1,280 +0,0 @@
-package conf
-
-import (
-	"encoding/json"
-	"fmt"
-	"os"
-
-	"log/slog"
-
-	"github.com/gookit/event"
-	"github.com/komari-monitor/komari/cmd/flags"
-	"github.com/komari-monitor/komari/internal/eventType"
-)
-
-// 返回默认配置对象
-func Default() Config {
-	return Config{
-		Site: Site{
-			Sitename:    "Komari",
-			Description: "Komari Monitor, a simple server monitoring tool.",
-			AllowCors:   false,
-			Theme:       "default",
-		},
-		GeoIp: GeoIp{
-			GeoIpEnabled:  true,
-			GeoIpProvider: GeoIp_IPInfo,
-		},
-		Notification: Notification{
-			NotificationEnabled:        true,
-			TrafficLimitPercentage:     80.00,
-			NotificationTemplate:       "{{emoji}}{{emoji}}{{emoji}}\n{{event}}\n{{client}}\n{{message}}\n{{time}}",
-			NotificationMethod:         "empty",
-			ExpireNotificationEnabled:  true,
-			ExpireNotificationLeadDays: 7,
-			LoginNotification:          true,
-		},
-		Login: Login{
-			OAuthEnabled:  false,
-			OAuthProvider: "github",
-		},
-		Record: Record{
-			RecordEnabled:          true,
-			RecordPreserveTime:     720,
-			PingRecordPreserveTime: 24,
-		},
-		Database: Database{
-			DatabaseType: "sqlite",
-			DatabaseFile: "./data/komari.db",
-		},
-		Listen:     "0.0.0.0:25774",
-		Extensions: map[string]interface{}{},
-	}
-}
-
-// 强制覆盖当前内存中的配置并写入配置文件
-func Override(cst Config) error {
-	ensureExtensionsDefaults(&cst)
-
-	b, err := json.MarshalIndent(cst, "", "  ")
-	if err != nil {
-		return err
-	}
-
-	oldConf := *Conf
-	Conf = &cst
-
-	err, _ = event.Trigger(eventType.ConfigUpdated, event.M{
-		"old": oldConf,
-		"new": cst,
-	})
-	if err != nil {
-		// 撤回配置修改
-		Conf = &oldConf
-		b, _ = json.MarshalIndent(oldConf, "", "  ")
-
-		//TODO: 循环引用，解耦dbcore与其他数据库模块
-		//auditlog.EventLog("error", fmt.Sprintf("Configuration update reverted due to error in ConfigUpdated event: %v", err))
-		slog.Error("Configuration update reverted due to error in ConfigUpdated event.", slog.Any("error", err))
-	}
-	if err := os.WriteFile(flags.ConfigFile, b, 0644); err != nil {
-		return err
-	}
-	return err
-}
-
-// 保存部分配置更改到文件，会对V1的旧字段进行转换
-func SavePartial(cst map[string]interface{}) error {
-	// 将当前内存中的配置转换为通用 map，便于合并
-	baseBytes, err := json.Marshal(Conf)
-	if err != nil {
-		return err
-	}
-	var base map[string]interface{}
-	if err := json.Unmarshal(baseBytes, &base); err != nil {
-		return err
-	}
-
-	// 兼容旧版扁平字段：把扁平键映射到新版分组结构
-	normalized := normalizePartialMap(cst)
-
-	// 深度合并（normalized 覆盖 base）
-	merged := deepMerge(base, normalized)
-
-	// 回写到强类型 Config
-	mergedBytes, err := json.Marshal(merged)
-	if err != nil {
-		return err
-	}
-	var newConf Config
-	if err := json.Unmarshal(mergedBytes, &newConf); err != nil {
-		return err
-	}
-
-	// 更新内存并落盘
-	return Override(newConf)
-}
-
-func EditAndTrigger(fn func()) error {
-	oldConf := *Conf
-	fn()
-	event.Trigger(eventType.ConfigUpdated, event.M{
-		"old": oldConf,
-		"new": *Conf,
-	})
-	return nil
-}
-
-// 保存完整配置到文件 同Override
-func SaveFull(cst Config) error {
-	return Override(cst)
-}
-
-// 以 v1 API 格式获取配置对象,使用 Conf 直接获取对象引用
-func GetWithV1Format() (V1Struct, error) {
-	return Conf.ToV1Format(), nil
-}
-
-// 以 v1 API 格式保存配置对象
-func Save(cst V1Struct) error {
-	cfg := cst.ToConfig()
-	return Override(cfg)
-}
-
-// 语义等同于 SavePartial，保持对旧数据格式兼容
-func Update(cst map[string]interface{}) error {
-	// Update 的语义等同于 SavePartial，保持对旧数据格式兼容
-	return SavePartial(cst)
-}
-
-// 将V1字段的输入映射为Config结构。
-// 包含 site/login/... 等嵌套结构，则原样保留并与映射结果合并。
-func normalizePartialMap(in map[string]interface{}) map[string]interface{} {
-	if in == nil {
-		return map[string]interface{}{}
-	}
-
-	// 先复制一份，避免修改入参
-	out := make(map[string]interface{})
-	for k, v := range in {
-		out[k] = v
-	}
-
-	// 准备确保分组 map 存在
-	ensureGroup := func(name string) map[string]interface{} {
-		v, ok := out[name]
-		if !ok || v == nil {
-			m := map[string]interface{}{}
-			out[name] = m
-			return m
-		}
-		if m, ok := v.(map[string]interface{}); ok {
-			return m
-		}
-		// 若类型非 map，则覆盖为 map
-		m := map[string]interface{}{}
-		out[name] = m
-		return m
-	}
-
-	site := ensureGroup("site")
-	login := ensureGroup("login")
-	geo := ensureGroup("geo_ip")
-	notif := ensureGroup("notification")
-	record := ensureGroup("record")
-	extensions := ensureGroup("extensions")
-
-	// 扁平 -> 分组字段映射表
-	move := func(flatKey string, group map[string]interface{}, groupKey string) {
-		if v, ok := out[flatKey]; ok {
-			group[groupKey] = v
-			delete(out, flatKey)
-		}
-	}
-
-	// Site
-	move("sitename", site, "sitename")
-	move("description", site, "description")
-	move("allow_cors", site, "allow_cors")
-	move("theme", site, "theme")
-	move("private_site", site, "private_site")
-	move("script_domain", site, "script_domain")
-	move("send_ip_addr_to_guest", site, "send_ip_addr_to_guest")
-	move("eula_accepted", site, "eula_accepted")
-	move("custom_head", site, "custom_head")
-	move("custom_body", site, "custom_body")
-
-	// Login
-	move("api_key", login, "api_key")
-	move("auto_discovery_key", login, "auto_discovery_key")
-	move("o_auth_enabled", login, "o_auth_enabled")
-	move("o_auth_provider", login, "o_auth_provider")
-	move("disable_password_login", login, "disable_password_login")
-
-	// GeoIP
-	move("geo_ip_enabled", geo, "geo_ip_enabled")
-	move("geo_ip_provider", geo, "geo_ip_provider")
-
-	// Notification
-	move("notification_enabled", notif, "notification_enabled")
-	move("notification_method", notif, "notification_method")
-	move("notification_template", notif, "notification_template")
-	move("expire_notification_enabled", notif, "expire_notification_enabled")
-	move("expire_notification_lead_days", notif, "expire_notification_lead_days")
-	move("login_notification", notif, "login_notification")
-	move("traffic_limit_percentage", notif, "traffic_limit_percentage")
-
-	// Record
-	move("record_enabled", record, "record_enabled")
-	move("record_preserve_time", record, "record_preserve_time")
-	move("ping_record_preserve_time", record, "ping_record_preserve_time")
-
-	// Nezha 兼容字段
-	nezha := map[string]interface{}{}
-	move("nezha_compat_enabled", nezha, "nezha_compat_enabled")
-	move("nezha_compat_listen", nezha, "nezha_compat_listen")
-	extensions["nezha"] = nezha
-
-	return out
-}
-
-// = 以src更新dst，返回合并结果
-func deepMerge(dst, src map[string]interface{}) map[string]interface{} {
-	if dst == nil {
-		dst = map[string]interface{}{}
-	}
-	for k, v := range src {
-		if v == nil {
-			// 忽略空覆盖，避免误删值
-			continue
-		}
-		if dv, ok := dst[k]; ok {
-			dm, dIsMap := dv.(map[string]interface{})
-			sm, sIsMap := v.(map[string]interface{})
-			if dIsMap && sIsMap {
-				dst[k] = deepMerge(dm, sm)
-				continue
-			}
-		}
-		dst[k] = v
-	}
-	return dst
-}
-
-// FromEvent 从事件对象中提取旧配置和新配置 returns (old,new,error)。
-func FromEvent(e event.Event) (Config, Config, error) {
-	oldVal := e.Get("old")
-	newVal := e.Get("new")
-
-	oldConf, ok := oldVal.(Config)
-	if !ok {
-		return Config{}, Config{}, fmt.Errorf("FromEvent: 'old' key value is not of type Config. Got: %T", oldVal)
-	}
-
-	newConf, ok := newVal.(Config)
-	if !ok {
-		return Config{}, Config{}, fmt.Errorf("FromEvent: 'new' key value is not of type Config. Got: %T", newVal)
-	}
-
-	return oldConf, newConf, nil
-}

internal/conf/const.go

@@ -1,10 +0,0 @@
-package conf
-
-const (
-	GeoIp_MMDB          = "mmdb"
-	GeoIp_IPAPI         = "ip-api"
-	GeoIp_GeoJS         = "geojs"
-	GeoIp_IPInfo        = "ipinfo"
-	GeoIp_Empty         = "empty"
-	Version_Development = "development"
-)

internal/conf/init.go

@@ -1,146 +0,0 @@
-package conf
-
-import (
-	"io/fs"
-	"log/slog"
-	"net/http"
-	"strings"
-
-	"github.com/gin-gonic/gin"
-	"github.com/komari-monitor/komari/internal/app"
-)
-
-func init() {
-	app.RegisterModuleFactory(NewConfigModule().Name(), NewConfigModule)
-}
-
-// InstallGuideFS 用于存储安装引导页面的静态文件系统，由外部包注入以避免循环引用
-var InstallGuideFS fs.FS
-
-func installGuide() {
-	// 未来支持
-	/*
-		listen := flags.Listen
-		if envListen := os.Getenv("LISTEN"); envListen != "" {
-			listen = envListen
-		}
-		if listen == "" {
-			listen = "0.0.0.0:25774"
-		}
-
-		gin.SetMode(gin.ReleaseMode)
-		r := gin.New()
-		r.Use(gin.Recovery())
-
-		if InstallGuideFS == nil {
-			panic("InstallGuideFS is not set, please inject it before starting the server")
-		}
-
-		// 注册 API handlers
-		api := r.Group("/api/init")
-		api.POST("/set_https", handleSetHTTPS)
-
-		// 处理所有请求
-		r.NoRoute(func(c *gin.Context) {
-			path := c.Request.URL.Path
-
-			cleanPath := strings.TrimPrefix(path, "/")
-			file, err := InstallGuideFS.Open(cleanPath)
-			if err == nil {
-				defer file.Close()
-				data, err := io.ReadAll(file)
-				if err == nil {
-					c.Data(http.StatusOK, getContentType(path), data)
-					return
-				}
-			}
-
-			// 文件不存在，如果是 GET 请求返回 index.html（SPA 路由）
-			if c.Request.Method == "GET" && strings.HasPrefix(path, "/init") {
-				indexFile, err := InstallGuideFS.Open("index.html")
-				if err == nil {
-					defer indexFile.Close()
-					data, err := io.ReadAll(indexFile)
-					if err == nil {
-						c.Header("Content-Type", "text/html")
-						c.Data(http.StatusOK, "text/html", data)
-						return
-					}
-				}
-			}
-
-			// 其他情况返回 404
-			c.Redirect(302, "/init")
-		})
-
-		// 启动服务器（阻塞）
-		slog.Info("Starting install guide server...", slog.String("listen", listen))
-		if err := r.Run(listen); err != nil {
-			panic("failed to start install guide server: " + err.Error())
-		}
-	*/
-
-}
-
-// getContentType 根据路径获取Content-Type
-func getContentType(path string) string {
-	if strings.HasSuffix(path, ".html") {
-		return "text/html"
-	}
-	if strings.HasSuffix(path, ".css") {
-		return "text/css"
-	}
-	if strings.HasSuffix(path, ".js") {
-		return "application/javascript"
-	}
-	if strings.HasSuffix(path, ".json") {
-		return "application/json"
-	}
-	if strings.HasSuffix(path, ".png") {
-		return "image/png"
-	}
-	if strings.HasSuffix(path, ".jpg") || strings.HasSuffix(path, ".jpeg") {
-		return "image/jpeg"
-	}
-	if strings.HasSuffix(path, ".gif") {
-		return "image/gif"
-	}
-	if strings.HasSuffix(path, ".svg") {
-		return "image/svg+xml"
-	}
-	if strings.HasSuffix(path, ".ico") {
-		return "image/x-icon"
-	}
-	if strings.HasSuffix(path, ".woff") {
-		return "font/woff"
-	}
-	if strings.HasSuffix(path, ".woff2") {
-		return "font/woff2"
-	}
-	if strings.HasSuffix(path, ".ttf") {
-		return "font/ttf"
-	}
-	return "application/octet-stream"
-}
-
-// handleSetHTTPS 处理 HTTPS 配置
-func handleSetHTTPS(c *gin.Context) {
-	var req struct {
-		Enabled bool   `json:"enabled"`
-		CertURL string `json:"cert_url,omitempty"`
-		KeyURL  string `json:"key_url,omitempty"`
-	}
-
-	if err := c.ShouldBindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
-		return
-	}
-
-	// TODO: 实现 HTTPS 配置逻辑
-	slog.Info("Setting HTTPS configuration", slog.Bool("enabled", req.Enabled))
-
-	c.JSON(http.StatusOK, gin.H{
-		"message": "HTTPS configuration updated",
-		"enabled": req.Enabled,
-	})
-}

internal/conf/module.go

@@ -1,84 +0,0 @@
-package conf
-
-import (
-	"encoding/json"
-	"os"
-
-	"github.com/gookit/event"
-	"github.com/komari-monitor/komari/cmd/flags"
-	"github.com/komari-monitor/komari/internal/app"
-	"github.com/komari-monitor/komari/internal/eventType"
-)
-
-type configModule struct{}
-
-var _ app.Module = (*configModule)(nil)
-
-// NewConfigModule provides the "config" module for the lifecycle app.
-//
-// It loads configuration and also keeps the legacy global variable Conf updated
-// to minimize downstream changes.
-func NewConfigModule() app.Module { return &configModule{} }
-
-func (m *configModule) Name() string      { return "config" }
-func (m *configModule) Depends() []string { return nil }
-
-func (m *configModule) Provide(r app.Registry) error {
-	return r.Provide(func() (*Config, error) {
-		var cst *Config
-		if _, err := os.Stat(flags.ConfigFile); os.IsNotExist(err) {
-			// --- 初始化流程 ---
-			installGuide()
-			t := Default()
-			cst = &t
-
-			// 序列化默认配置
-			b, err := json.MarshalIndent(cst, "", "  ")
-			if err != nil {
-				return nil, err
-			}
-
-			// 写入文件
-			if err := os.WriteFile(flags.ConfigFile, b, 0644); err != nil {
-				return nil, err
-			}
-		} else {
-			// --- 读取流程 ---
-			b, err := os.ReadFile(flags.ConfigFile)
-			if err != nil {
-				return nil, err
-			}
-
-			cst = &Config{}
-			if err := json.Unmarshal(b, cst); err != nil {
-				return nil, err
-			}
-		}
-
-		ensureExtensionsDefaults(cst)
-		Conf = cst
-
-		return Conf, nil
-	})
-}
-
-func (m *configModule) Hooks() app.Hooks {
-	return app.Hooks{
-		Init: func(_ *Config) error { return nil },
-		Start: func(cfg *Config) {
-			// Keep legacy behavior: once the HTTP stack is initialized,
-			// broadcast a ConfigUpdated to populate consumers (e.g. CORS, public index).
-			event.On(eventType.ServerInitializeDone, event.ListenerFunc(func(e event.Event) error {
-				event.Trigger(eventType.ConfigUpdated, event.M{
-					"old": Config{},
-					"new": *cfg,
-				})
-				return nil
-			}), event.Low)
-		},
-	}
-}
-
-func init() {
-	app.RegisterModuleFactory("config", NewConfigModule)
-}

internal/conf/registry.go

@@ -1,341 +0,0 @@
-package conf
-
-import (
-	"encoding/json"
-	"fmt"
-	"sync"
-)
-
-// CustomFieldProvider 是自定义字段提供者需要实现的接口
-type CustomFieldProvider interface {
-	// Key 返回配置中的唯一键名（JSON 字段名）
-	Key() string
-	// Default 返回默认值
-	Default() interface{}
-	// Validate 验证配置值是否有效（可选，返回 nil 表示验证通过）
-	Validate(value interface{}) error
-}
-
-// BaseFieldProvider 提供一个基础实现，简化自定义字段的创建
-type BaseFieldProvider struct {
-	key          string
-	defaultValue interface{}
-	validator    func(interface{}) error
-}
-
-// NewFieldProvider 创建一个基础字段提供者
-func NewFieldProvider(key string, defaultValue interface{}, validator func(interface{}) error) *BaseFieldProvider {
-	return &BaseFieldProvider{
-		key:          key,
-		defaultValue: defaultValue,
-		validator:    validator,
-	}
-}
-
-func (p *BaseFieldProvider) Key() string {
-	return p.key
-}
-
-func (p *BaseFieldProvider) Default() interface{} {
-	return p.defaultValue
-}
-
-func (p *BaseFieldProvider) Validate(value interface{}) error {
-	if p.validator != nil {
-		return p.validator(value)
-	}
-	return nil
-}
-
-// registry 存储所有注册的自定义字段提供者（只存储 provider，值存在 Conf.Extensions 中）
-var (
-	registryMu      sync.RWMutex
-	customProviders = make(map[string]CustomFieldProvider)
-)
-
-// RegisterField 注册一个自定义字段提供者
-// 应在 init() 函数中调用，以确保在配置加载前完成注册
-func RegisterField(provider CustomFieldProvider) error {
-	registryMu.Lock()
-	defer registryMu.Unlock()
-
-	key := provider.Key()
-	if key == "" {
-		return fmt.Errorf("custom field key cannot be empty")
-	}
-
-	if _, exists := customProviders[key]; exists {
-		return fmt.Errorf("custom field '%s' is already registered", key)
-	}
-
-	customProviders[key] = provider
-	return nil
-}
-
-// MustRegisterField 注册一个自定义字段提供者，失败时 panic
-func MustRegisterField(provider CustomFieldProvider) {
-	if err := RegisterField(provider); err != nil {
-		panic(err)
-	}
-}
-
-// RegisterSimpleField 简化的字段注册，无需实现接口
-func RegisterSimpleField(key string, defaultValue interface{}) error {
-	return RegisterField(NewFieldProvider(key, defaultValue, nil))
-}
-
-// MustRegisterSimpleField 简化的字段注册，失败时 panic
-func MustRegisterSimpleField(key string, defaultValue interface{}) {
-	MustRegisterField(NewFieldProvider(key, defaultValue, nil))
-}
-
-// GetExtension 获取扩展字段的值
-func GetExtension(key string) (interface{}, bool) {
-	if Conf == nil || Conf.Extensions == nil {
-		return nil, false
-	}
-	val, ok := Conf.Extensions[key]
-	return val, ok
-}
-
-// GetExtensionAs 获取扩展字段并转换为指定类型
-// 使用示例: val, ok := GetExtensionAs[MyConfig]("my_module")
-func GetExtensionAs[T any](key string) (T, bool) {
-	val, ok := GetExtension(key)
-	if !ok {
-		var zero T
-		return zero, false
-	}
-
-	// 尝试直接类型断言
-	if typed, ok := val.(T); ok {
-		return typed, true
-	}
-
-	// 尝试通过 JSON 反序列化转换
-	var result T
-	bytes, err := json.Marshal(val)
-	if err != nil {
-		var zero T
-		return zero, false
-	}
-	if err := json.Unmarshal(bytes, &result); err != nil {
-		var zero T
-		return zero, false
-	}
-
-	return result, true
-}
-
-// SetExtension 设置扩展字段的值（不自动保存）
-func SetExtension(key string, value interface{}) error {
-	registryMu.RLock()
-	provider, exists := customProviders[key]
-	registryMu.RUnlock()
-
-	if !exists {
-		return fmt.Errorf("extension field '%s' is not registered", key)
-	}
-
-	if err := provider.Validate(value); err != nil {
-		return fmt.Errorf("validation failed for field '%s': %w", key, err)
-	}
-
-	if Conf.Extensions == nil {
-		Conf.Extensions = make(map[string]interface{})
-	}
-	Conf.Extensions[key] = value
-	return nil
-}
-
-// SetExtensionAndSave 设置扩展字段的值并保存到文件
-func SetExtensionAndSave(key string, value interface{}) error {
-	if err := SetExtension(key, value); err != nil {
-		return err
-	}
-	return Override(*Conf)
-}
-
-// GetAllExtensions 获取所有扩展字段
-func GetAllExtensions() map[string]interface{} {
-	if Conf == nil || Conf.Extensions == nil {
-		return make(map[string]interface{})
-	}
-
-	result := make(map[string]interface{}, len(Conf.Extensions))
-	for k, v := range Conf.Extensions {
-		result[k] = v
-	}
-	return result
-}
-
-// GetRegisteredKeys 获取所有已注册的字段键名
-func GetRegisteredKeys() []string {
-	registryMu.RLock()
-	defer registryMu.RUnlock()
-
-	keys := make([]string, 0, len(customProviders))
-	for k := range customProviders {
-		keys = append(keys, k)
-	}
-	return keys
-}
-
-// IsFieldRegistered 检查字段是否已注册
-func IsFieldRegistered(key string) bool {
-	registryMu.RLock()
-	defer registryMu.RUnlock()
-
-	_, exists := customProviders[key]
-	return exists
-}
-
-// ResetExtension 重置扩展字段为默认值
-func ResetExtension(key string) error {
-	registryMu.RLock()
-	provider, exists := customProviders[key]
-	registryMu.RUnlock()
-
-	if !exists {
-		return fmt.Errorf("extension field '%s' is not registered", key)
-	}
-
-	if Conf.Extensions == nil {
-		Conf.Extensions = make(map[string]interface{})
-	}
-	Conf.Extensions[key] = provider.Default()
-	return nil
-}
-
-// ResetAllExtensions 重置所有扩展字段为默认值
-func ResetAllExtensions() {
-	registryMu.RLock()
-	defer registryMu.RUnlock()
-
-	if Conf.Extensions == nil {
-		Conf.Extensions = make(map[string]interface{})
-	}
-
-	for key, provider := range customProviders {
-		Conf.Extensions[key] = provider.Default()
-	}
-}
-
-// ensureExtensionsDefaults 确保所有已注册的扩展字段都有值
-func ensureExtensionsDefaults(cfg *Config) {
-	registryMu.RLock()
-	defer registryMu.RUnlock()
-
-	if cfg.Extensions == nil {
-		cfg.Extensions = make(map[string]interface{})
-	}
-
-	for key, provider := range customProviders {
-		if _, exists := cfg.Extensions[key]; !exists {
-			cfg.Extensions[key] = provider.Default()
-		}
-	}
-}
-
-// GetExtensionDefault 获取扩展字段的默认值
-func GetExtensionDefault(key string) (interface{}, bool) {
-	registryMu.RLock()
-	defer registryMu.RUnlock()
-
-	provider, exists := customProviders[key]
-	if !exists {
-		return nil, false
-	}
-	return provider.Default(), true
-}
-
-// FromEventExtension 从 ConfigUpdated 事件中获取指定扩展字段的旧值和新值
-// 返回 (oldValue, newValue, exists)
-func FromEventExtension(e interface{ Get(string) interface{} }, key string) (interface{}, interface{}, bool) {
-	oldConf, oldOk := e.Get("old").(Config)
-	newConf, newOk := e.Get("new").(Config)
-
-	if !oldOk || !newOk {
-		return nil, nil, false
-	}
-
-	var oldVal, newVal interface{}
-	var oldExists, newExists bool
-
-	if oldConf.Extensions != nil {
-		oldVal, oldExists = oldConf.Extensions[key]
-	}
-	if newConf.Extensions != nil {
-		newVal, newExists = newConf.Extensions[key]
-	}
-
-	if !oldExists && !newExists {
-		return nil, nil, false
-	}
-
-	return oldVal, newVal, true
-}
-
-// FromEventExtensionAs 从 ConfigUpdated 事件中获取指定扩展字段的旧值和新值（泛型版本）
-// 使用示例: old, new, ok := FromEventExtensionAs[MyConfig](e, "my_module")
-func FromEventExtensionAs[T any](e interface{ Get(string) interface{} }, key string) (T, T, bool) {
-	oldVal, newVal, exists := FromEventExtension(e, key)
-	if !exists {
-		var zero T
-		return zero, zero, false
-	}
-
-	convertTo := func(val interface{}) (T, bool) {
-		if val == nil {
-			var zero T
-			return zero, true
-		}
-		if typed, ok := val.(T); ok {
-			return typed, true
-		}
-		// JSON 转换
-		var result T
-		bytes, err := json.Marshal(val)
-		if err != nil {
-			var zero T
-			return zero, false
-		}
-		if err := json.Unmarshal(bytes, &result); err != nil {
-			var zero T
-			return zero, false
-		}
-		return result, true
-	}
-
-	oldTyped, oldOk := convertTo(oldVal)
-	newTyped, newOk := convertTo(newVal)
-
-	if !oldOk || !newOk {
-		var zero T
-		return zero, zero, false
-	}
-
-	return oldTyped, newTyped, true
-}
-
-// ---- 兼容旧 API（已废弃，建议使用新的 Extension 系列函数）----
-
-// GetCustomField 已废弃，请使用 GetExtension
-func GetCustomField(key string) (interface{}, bool) {
-	return GetExtension(key)
-}
-
-// GetCustomFieldAs 已废弃，请使用 GetExtensionAs
-func GetCustomFieldAs[T any](key string) (T, bool) {
-	return GetExtensionAs[T](key)
-}
-
-// SetCustomField 已废弃，请使用 SetExtension
-func SetCustomField(key string, value interface{}) error {
-	return SetExtension(key, value)
-}
-
-// SetCustomFieldAndSave 已废弃，请使用 SetExtensionAndSave
-func SetCustomFieldAndSave(key string, value interface{}) error {
-	return SetExtensionAndSave(key, value)
-}

internal/conf/vars.go

@@ -1,227 +0,0 @@
-package conf
-
-import "time"
-
-var (
-	Version    = Version_Development
-	CommitHash = "unknown"
-)
-
-var (
-	// Conf is the global config for legacy code paths.
-	// Lifecycle-managed startup overwrites it by calling Boot().
-	Conf = func() *Config {
-		c := Default()
-		return &c
-	}()
-)
-
-type Config struct {
-	Site         Site                   `json:"site"`
-	Login        Login                  `json:"login"`
-	GeoIp        GeoIp                  `json:"geo_ip"`
-	Notification Notification           `json:"notification"`
-	Record       Record                 `json:"record"`
-	Listen       string                 `json:"listen"`
-	Database     Database               `json:"database"`
-	Extensions   map[string]interface{} `json:"extensions,omitempty"` // 扩展配置，由各模块注册
-}
-
-type Site struct {
-	Sitename          string `json:"sitename"`
-	Description       string `json:"description"`
-	AllowCors         bool   `json:"allow_cors"`
-	PrivateSite       bool   `json:"private_site"`          // 是否为私有站点，默认 false
-	SendIpAddrToGuest bool   `json:"send_ip_addr_to_guest"` // 是否向访客页面发送 IP 地址，默认 false
-	ScriptDomain      string `json:"script_domain"`         // 自定义脚本域名
-	EulaAccepted      bool   `json:"eula_accepted"`
-	// 自定义美化
-	CustomHead string `json:"custom_head"`
-	CustomBody string `json:"custom_body"`
-	Theme      string `json:"theme"` // 主题名称，默认 'default'
-}
-
-type Login struct {
-	ApiKey           string `json:"api_key"`
-	AutoDiscoveryKey string `json:"auto_discovery_key"` // 自动发现密钥
-
-	// OAuth 配置
-	OAuthEnabled         bool   `json:"o_auth_enabled"`
-	OAuthProvider        string `json:"o_auth_provider"`
-	DisablePasswordLogin bool   `json:"disable_password_login"`
-}
-
-type Database struct {
-	DatabaseType string `json:"database_type"` // 数据库类型：sqlite, mysql
-	DatabaseFile string `json:"database_file"` // SQLite数据库文件路径
-	DatabaseHost string `json:"database_host"` // MySQL/其他数据库主机地址
-	DatabasePort string `json:"database_port"` // MySQL/其他数据库端口
-	DatabaseUser string `json:"database_user"` // MySQL/其他数据库用户名
-	DatabasePass string `json:"database_pass"` // MySQL/其他数据库密码
-	DatabaseName string `json:"database_name"` // MySQL/其他数据库名称
-}
-
-type GeoIp struct {
-	GeoIpEnabled  bool   `json:"geo_ip_enabled"`
-	GeoIpProvider string `json:"geo_ip_provider"` // empty, mmdb, ip-api, geojs
-}
-
-type Notification struct {
-	NotificationEnabled        bool    `json:"notification_enabled"` // 通知总开关
-	NotificationMethod         string  `json:"notification_method"`
-	NotificationTemplate       string  `json:"notification_template"`
-	ExpireNotificationEnabled  bool    `json:"expire_notification_enabled"`   // 是否启用过期通知
-	ExpireNotificationLeadDays int     `json:"expire_notification_lead_days"` // 过期前多少天通知，默认7天
-	LoginNotification          bool    `json:"login_notification"`            // 登录通知
-	TrafficLimitPercentage     float64 `json:"traffic_limit_percentage"`      // 流量限制百分比，默认80.00%
-}
-
-type Record struct {
-	RecordEnabled          bool `json:"record_enabled"`            // 是否启用记录功能
-	RecordPreserveTime     int  `json:"record_preserve_time"`      // 记录保留时间，单位小时，默认30天
-	PingRecordPreserveTime int  `json:"ping_record_preserve_time"` // Ping 记录保留时间，单位小时，默认1天
-}
-
-// [DEPRECATED] 旧的数据结构，将不再维护，请考虑使用 conf.Config 结构体
-type V1Struct struct {
-	ID                uint   `json:"id,omitempty" gorm:"primaryKey;autoIncrement"` // 1
-	Sitename          string `json:"sitename" gorm:"type:varchar(100);not null"`
-	Description       string `json:"description" gorm:"type:text"`
-	AllowCors         bool   `json:"allow_cors" gorm:"column:allow_cors;default:false"`
-	Theme             string `json:"theme" gorm:"type:varchar(100);default:'default'"` // 主题名称，默认 'default'
-	PrivateSite       bool   `json:"private_site" gorm:"default:false"`                // 是否为私有站点，默认 false
-	ApiKey            string `json:"api_key" gorm:"type:varchar(255);default:''"`
-	AutoDiscoveryKey  string `json:"auto_discovery_key" gorm:"type:varchar(255);default:''"` // 自动发现密钥
-	ScriptDomain      string `json:"script_domain" gorm:"type:varchar(255);default:''"`      // 自定义脚本域名
-	SendIpAddrToGuest bool   `json:"send_ip_addr_to_guest" gorm:"default:false"`             // 是否向访客页面发送 IP 地址，默认 false
-	EulaAccepted      bool   `json:"eula_accepted" gorm:"default:false"`
-	// GeoIP 配置
-	GeoIpEnabled  bool   `json:"geo_ip_enabled" gorm:"default:true"`
-	GeoIpProvider string `json:"geo_ip_provider" gorm:"type:varchar(20);default:'ip-api'"` // empty, mmdb, ip-api, geojs
-	// [DEPRECATED] Nezha 兼容字段已迁移到 extensions，保留用于数据库迁移
-	NezhaCompatEnabled bool   `json:"nezha_compat_enabled" gorm:"default:false"`
-	NezhaCompatListen  string `json:"nezha_compat_listen" gorm:"type:varchar(100);default:''"` // 例如 0.0.0.0:5555
-	// OAuth 配置
-	OAuthEnabled         bool   `json:"o_auth_enabled" gorm:"default:false"`
-	OAuthProvider        string `json:"o_auth_provider" gorm:"type:varchar(50);default:'github'"`
-	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"`
-	// 通知
-	NotificationEnabled        bool    `json:"notification_enabled" gorm:"default:false"` // 通知总开关
-	NotificationMethod         string  `json:"notification_method" gorm:"type:varchar(64);default:'none'"`
-	NotificationTemplate       string  `json:"notification_template" gorm:"type:longtext;default:'{{emoji}}{{emoji}}{{emoji}}\nEvent: {{event}}\nClients: {{client}}\nMessage: {{message}}\nTime: {{time}}'"`
-	ExpireNotificationEnabled  bool    `json:"expire_notification_enabled" gorm:"default:false"` // 是否启用过期通知
-	ExpireNotificationLeadDays int     `json:"expire_notification_lead_days" gorm:"default:7"`   // 过期前多少天通知，默认7天
-	LoginNotification          bool    `json:"login_notification" gorm:"default:false"`          // 登录通知
-	TrafficLimitPercentage     float64 `json:"traffic_limit_percentage" gorm:"default:80.00"`    // 流量限制百分比，默认80.00%
-	// Record
-	RecordEnabled          bool `json:"record_enabled" gorm:"default:true"`          // 是否启用记录功能
-	RecordPreserveTime     int  `json:"record_preserve_time" gorm:"default:720"`     // 记录保留时间，单位小时，默认30天
-	PingRecordPreserveTime int  `json:"ping_record_preserve_time" gorm:"default:24"` // Ping 记录保留时间，单位小时，默认1天
-	CreatedAt              time.Time
-	UpdatedAt              time.Time
-}
-
-func (cst *V1Struct) ToConfig() Config {
-	// 同步 V1 中的 Nezha 字段到 extensions
-	if IsFieldRegistered("nezha") {
-		nezhaCfg := map[string]interface{}{
-			"nezha_compat_enabled": cst.NezhaCompatEnabled,
-			"nezha_compat_listen":  cst.NezhaCompatListen,
-		}
-		SetCustomField("nezha", nezhaCfg)
-	}
-
-	return Config{
-		Site: Site{
-			Sitename:          cst.Sitename,
-			Description:       cst.Description,
-			AllowCors:         cst.AllowCors,
-			PrivateSite:       cst.PrivateSite,
-			SendIpAddrToGuest: cst.SendIpAddrToGuest,
-			ScriptDomain:      cst.ScriptDomain,
-			EulaAccepted:      cst.EulaAccepted,
-			CustomHead:        cst.CustomHead,
-			CustomBody:        cst.CustomBody,
-			Theme:             cst.Theme,
-		},
-		Login: Login{
-			ApiKey:               cst.ApiKey,
-			AutoDiscoveryKey:     cst.AutoDiscoveryKey,
-			OAuthEnabled:         cst.OAuthEnabled,
-			OAuthProvider:        cst.OAuthProvider,
-			DisablePasswordLogin: cst.DisablePasswordLogin,
-		},
-		GeoIp: GeoIp{
-			GeoIpEnabled:  cst.GeoIpEnabled,
-			GeoIpProvider: cst.GeoIpProvider,
-		},
-		Notification: Notification{
-			NotificationEnabled:        cst.NotificationEnabled,
-			NotificationMethod:         cst.NotificationMethod,
-			NotificationTemplate:       cst.NotificationTemplate,
-			ExpireNotificationEnabled:  cst.ExpireNotificationEnabled,
-			ExpireNotificationLeadDays: cst.ExpireNotificationLeadDays,
-			LoginNotification:          cst.LoginNotification,
-			TrafficLimitPercentage:     cst.TrafficLimitPercentage,
-		},
-		Record: Record{
-			RecordEnabled:          cst.RecordEnabled,
-			RecordPreserveTime:     cst.RecordPreserveTime,
-			PingRecordPreserveTime: cst.PingRecordPreserveTime,
-		},
-	}
-}
-
-func (cfg *Config) ToV1Format() V1Struct {
-	v1 := V1Struct{
-		ID:                         1,
-		Sitename:                   cfg.Site.Sitename,
-		Description:                cfg.Site.Description,
-		AllowCors:                  cfg.Site.AllowCors,
-		Theme:                      cfg.Site.Theme,
-		PrivateSite:                cfg.Site.PrivateSite,
-		ApiKey:                     cfg.Login.ApiKey,
-		AutoDiscoveryKey:           cfg.Login.AutoDiscoveryKey,
-		ScriptDomain:               cfg.Site.ScriptDomain,
-		SendIpAddrToGuest:          cfg.Site.SendIpAddrToGuest,
-		EulaAccepted:               cfg.Site.EulaAccepted,
-		GeoIpEnabled:               cfg.GeoIp.GeoIpEnabled,
-		GeoIpProvider:              cfg.GeoIp.GeoIpProvider,
-		OAuthEnabled:               cfg.Login.OAuthEnabled,
-		OAuthProvider:              cfg.Login.OAuthProvider,
-		DisablePasswordLogin:       cfg.Login.DisablePasswordLogin,
-		CustomHead:                 cfg.Site.CustomHead,
-		CustomBody:                 cfg.Site.CustomBody,
-		NotificationEnabled:        cfg.Notification.NotificationEnabled,
-		NotificationMethod:         cfg.Notification.NotificationMethod,
-		NotificationTemplate:       cfg.Notification.NotificationTemplate,
-		ExpireNotificationEnabled:  cfg.Notification.ExpireNotificationEnabled,
-		ExpireNotificationLeadDays: cfg.Notification.ExpireNotificationLeadDays,
-		LoginNotification:          cfg.Notification.LoginNotification,
-		TrafficLimitPercentage:     cfg.Notification.TrafficLimitPercentage,
-		RecordEnabled:              cfg.Record.RecordEnabled,
-		RecordPreserveTime:         cfg.Record.RecordPreserveTime,
-		PingRecordPreserveTime:     cfg.Record.PingRecordPreserveTime,
-		CreatedAt:                  time.Now(),
-		UpdatedAt:                  time.Now(),
-	}
-
-	// 从 extensions 中填充 Nezha 兼容字段
-	if cfg.Extensions != nil {
-		if nezha, ok := cfg.Extensions["nezha"]; ok {
-			if nezhaMap, ok := nezha.(map[string]interface{}); ok {
-				if enabled, ok := nezhaMap["nezha_compat_enabled"].(bool); ok {
-					v1.NezhaCompatEnabled = enabled
-				}
-				if listen, ok := nezhaMap["nezha_compat_listen"].(string); ok {
-					v1.NezhaCompatListen = listen
-				}
-			}
-		}
-	}
-
-	return v1
-}

internal/database/accounts/init.go

@@ -1,24 +0,0 @@
-package accounts
-
-import (
-	"log"
-
-	"github.com/gookit/event"
-	"github.com/komari-monitor/komari/internal/database/models"
-	"github.com/komari-monitor/komari/internal/dbcore"
-	"github.com/komari-monitor/komari/internal/eventType"
-)
-
-func init() {
-	event.On(eventType.ServerInitializeStart, event.ListenerFunc(func(e event.Event) error {
-		var count int64 = 0
-		if dbcore.GetDBInstance().Model(&models.User{}).Count(&count); count == 0 {
-			user, passwd, err := CreateDefaultAdminAccount()
-			if err != nil {
-				return err
-			}
-			log.Println("Default admin account created. Username:", user, ", Password:", passwd)
-		}
-		return nil
-	}))
-}

internal/database/models/UTCTime.go

@@ -1,153 +0,0 @@
-package models
-
-import (
-	"database/sql/driver"
-	"fmt"
-	"log"
-	"os"
-	"strings"
-	"time"
-)
-
-// LocalTime is a custom time type for GORM to handle time.Time correctly.
-// CORE PRINCIPLE: Database always stores UTC time. Business logic always uses UTC.
-// Only JSON output converts to user's display timezone.
-// This ensures correct time comparisons in SQL queries (WHERE time < xxx).
-type LocalTime time.Time
-
-// Value implements the driver.Valuer interface.
-// Always stores time in UTC format to ensure correct database comparisons.
-func (t LocalTime) Value() (driver.Value, error) {
-	if time.Time(t).IsZero() {
-		return nil, nil
-	}
-	// Always store as UTC to ensure correct SQL comparisons
-	return time.Time(t).UTC().Format("2006-01-02 15:04:05.0000000"), nil
-}
-
-// Scan implements the sql.Scanner interface.
-// Reads time from database as UTC (since we always store UTC).
-func (t *LocalTime) Scan(v interface{}) error {
-	if v == nil {
-		*t = LocalTime(time.Time{})
-		return nil
-	}
-
-	switch val := v.(type) {
-	case time.Time:
-		// Database stores UTC, so interpret as UTC
-		*t = LocalTime(val.UTC())
-		return nil
-	case []byte:
-		return t.parseTime(string(val))
-	case string:
-		return t.parseTime(val)
-	default:
-		return fmt.Errorf("LocalTime scan source was not string, []byte or time.Time: %T (%v)", v, v)
-	}
-}
-
-// parseTime handles parsing a string into LocalTime.
-// Database stores UTC time, so we parse as UTC.
-func (t *LocalTime) parseTime(timeStr string) error {
-	timeStr = strings.TrimSpace(timeStr)
-	if timeStr == "" {
-		*t = LocalTime(time.Time{})
-		return nil
-	}
-
-	layouts := []string{
-		time.RFC3339Nano, time.RFC3339,
-		"2006-01-02 15:04:05.0000000-07:00", "2006-01-02 15:04:05-07:00",
-		"2006-01-02 15:04:05.0000000", "2006-01-02 15:04:05", "2006-01-02",
-	}
-
-	for _, layout := range layouts {
-		// For formats without timezone, parse as UTC (database stores UTC)
-		// For formats with timezone, parse normally then convert to UTC
-		if parsedTime, err := time.ParseInLocation(layout, timeStr, time.UTC); err == nil {
-			*t = LocalTime(parsedTime.UTC())
-			return nil
-		}
-	}
-	return fmt.Errorf("unable to parse time string '%s' into LocalTime", timeStr)
-}
-
-// MarshalJSON implements the json.Marshaler interface.
-// Converts UTC time to user's display timezone for JSON output.
-func (t LocalTime) MarshalJSON() ([]byte, error) {
-	if time.Time(t).IsZero() {
-		return []byte("null"), nil
-	}
-	// Convert from UTC to display timezone for user-facing output
-	formattedTime := time.Time(t).In(GetDisplayLocation()).Format(time.RFC3339)
-	return []byte(fmt.Sprintf(`"%s"`, formattedTime)), nil
-}
-
-// UnmarshalJSON implements the json.Unmarshaler interface.
-// Parses JSON time and converts to UTC for internal storage.
-func (t *LocalTime) UnmarshalJSON(data []byte) error {
-	str := strings.Trim(string(data), `"`)
-	if str == "null" || str == "" {
-		*t = LocalTime(time.Time{})
-		return nil
-	}
-
-	layouts := []string{
-		time.RFC3339Nano, time.RFC3339,
-		"2006-01-02T15:04:05", "2006-01-02 15:04:05", "2006-01-02",
-	}
-
-	for _, layout := range layouts {
-		if parsedTime, err := time.Parse(layout, str); err == nil {
-			// Convert to UTC for internal storage
-			*t = LocalTime(parsedTime.UTC())
-			return nil
-		}
-	}
-	return fmt.Errorf("unable to parse time string '%s' into LocalTime", str)
-}
-
-// ToTime converts LocalTime to Go's native time.Time type (in UTC).
-func (t LocalTime) ToTime() time.Time { return time.Time(t).UTC() }
-
-// ToLocal converts LocalTime to user's display timezone.
-func (t LocalTime) ToLocal() time.Time { return time.Time(t).In(GetDisplayLocation()) }
-
-// FromTime converts Go's native time.Time type to LocalTime (stored as UTC).
-func FromTime(t time.Time) LocalTime { return LocalTime(t.UTC()) }
-
-// Now returns the current time in UTC.
-func Now() LocalTime { return LocalTime(time.Now().UTC()) }
-
-var (
-	displayLocation *time.Location
-	//locationOnce    sync.Once
-)
-
-// GetDisplayLocation retrieves the user's display timezone from the "TZ" environment variable.
-// This is only used for JSON output formatting, not for internal storage or comparisons.
-func GetDisplayLocation() *time.Location {
-	return displayLocation
-}
-
-func init() {
-	tz := os.Getenv("TZ")
-	if tz == "" {
-		tz = time.Now().Location().String()
-	}
-	loc, err := time.LoadLocation(tz)
-	if err != nil {
-		log.Printf("Warning: Failed to load timezone '%s', falling back to UTC. Error: %v", tz, err)
-		displayLocation = time.UTC
-	} else {
-		displayLocation = loc
-	}
-	//log.Printf("Display timezone is set to '%s'. Database always uses UTC.", displayLocation.String())
-}
-
-// Deprecated: GetAppLocation is deprecated, use GetDisplayLocation instead.
-// Kept for backward compatibility.
-func GetAppLocation() *time.Location {
-	return GetDisplayLocation()
-}

internal/database/models/config.go

@@ -1,4 +0,0 @@
-package models
-
-type Config struct {
-}

internal/database/models/pingTask.go

@@ -1,19 +0,0 @@
-package models
-
-type PingRecord struct {
-	Client     string    `json:"client" gorm:"type:varchar(36);not null;index"`
-	ClientInfo Client    `json:"client_info" gorm:"foreignKey:Client;references:UUID;constraint:OnDelete:CASCADE,OnUpdate:CASCADE"`
-	TaskId     uint      `json:"task_id" gorm:"not null;index"`
-	Task       PingTask  `json:"task" gorm:"foreignKey:TaskId;references:Id;constraint:OnDelete:CASCADE,OnUpdate:CASCADE;"`
-	Time       LocalTime `json:"time" gorm:"index;not null"`
-	Value      int       `json:"value" gorm:"type:int;not null"` // Ping 值，单位毫秒
-}
-
-type PingTask struct {
-	Id       uint        `json:"id,omitempty" gorm:"primaryKey;autoIncrement"`
-	Name     string      `json:"name" gorm:"type:varchar(255);not null;index"`
-	Clients  StringArray `json:"clients" gorm:"type:longtext"`
-	Type     string      `json:"type" gorm:"type:varchar(12);not null;default:'icmp'"` // icmp tcp http
-	Target   string      `json:"target" gorm:"type:varchar(255);not null"`
-	Interval int         `json:"interval" gorm:"type:int;not null;default:60"` // 间隔时间
-}

internal/database/models/theme.go

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

internal/database/records/records_test.go

@@ -1,130 +0,0 @@
-package records
-
-import (
-	"encoding/csv"
-	"os"
-	"strconv"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"gorm.io/driver/sqlite"
-	"gorm.io/gorm"
-
-	"github.com/komari-monitor/komari/internal/database/models"
-)
-
-var uuid = "7901508c-304f-49aa-b84f-957c33ae6f8a"
-
-var _ = func() bool {
-	// 确保 Test 环境中使用 sqlite 内存数据库
-	return true
-}()
-
-// TestCompactRecord tests the database compaction logic by inserting 4h30m of data (one record per minute),
-// then running migrateOldRecords and verifying the aggregation and cleanup.
-func TestCompactRecord(t *testing.T) {
-	const totalMinutes = 12*60 + 30
-	now := time.Now()
-	threshold := now.Add(-4 * time.Hour)
-
-	// 使用 sqlite 内存数据库并迁移表结构
-	db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
-	assert.NoError(t, err)
-	assert.NoError(t, db.AutoMigrate(&models.Record{}))
-	assert.NoError(t, db.Table("records_long_term").AutoMigrate(&models.Record{}))
-
-	expectedGroups := make(map[time.Time]struct{})
-	expectedRemain := 0
-
-	// 插入数据
-	for i := 0; i < totalMinutes; i++ {
-		recTime := now.Add(-time.Duration(i) * time.Minute)
-		rec := models.Record{Client: uuid, Time: models.FromTime(recTime), Cpu: float32(i), Gpu: float32(i), Load: float32(i), Temp: float32(i), Ram: int64(i)}
-		err := db.Create(&rec).Error
-		assert.NoError(t, err)
-
-		if recTime.Before(threshold) {
-			slot := recTime.Truncate(time.Hour)
-			expectedGroups[slot] = struct{}{}
-		} else {
-			expectedRemain++
-		}
-	}
-
-	// 导出原始数据到 CSV
-	os.MkdirAll("../../data", 0755)
-	var origRecs []models.Record
-	db.Order("time desc").Find(&origRecs)
-	fOrig, err := os.Create("../../data/original.csv")
-	assert.NoError(t, err)
-	defer fOrig.Close()
-	wOrig := csv.NewWriter(fOrig)
-	defer wOrig.Flush()
-	wOrig.Write([]string{"Client", "Time", "Cpu", "Gpu", "Load", "Temp", "Ram"})
-	for _, r := range origRecs {
-		wOrig.Write([]string{
-			r.Client,
-			r.Time.ToTime().Format(time.RFC3339),
-			strconv.FormatFloat(float64(r.Cpu), 'f', -1, 32),
-			strconv.FormatFloat(float64(r.Gpu), 'f', -1, 32),
-			strconv.FormatFloat(float64(r.Load), 'f', -1, 32),
-			strconv.FormatFloat(float64(r.Temp), 'f', -1, 32),
-			strconv.FormatInt(r.Ram, 10),
-		})
-	}
-
-	// 运行压缩（迁移）逻辑
-	err = migrateOldRecords(db)
-	assert.NoError(t, err)
-
-	// 验证 long-term 表中的聚合记录数
-	var longCount int64
-	assert.NoError(t, db.Table("records_long_term").Count(&longCount).Error)
-	assert.Equal(t, int64(len(expectedGroups)), longCount)
-
-	// 验证原始表中剩余记录数
-	var remainCount int64
-	assert.NoError(t, db.Table("records").Count(&remainCount).Error)
-	assert.Equal(t, int64(expectedRemain), remainCount+1)
-
-	// 导出压缩后的数据到 CSV
-	var compRecs []models.Record
-	db.Table("records_long_term").Order("time desc").Find(&compRecs)
-	fComp, err := os.Create("../../data/compressed.csv")
-	assert.NoError(t, err)
-	defer fComp.Close()
-	wComp := csv.NewWriter(fComp)
-	defer wComp.Flush()
-	wComp.Write([]string{"Client", "Time", "Cpu", "Gpu", "Load", "Temp", "Ram"})
-	for _, r := range compRecs {
-		wComp.Write([]string{
-			r.Client,
-			r.Time.ToTime().Format(time.RFC3339),
-			strconv.FormatFloat(float64(r.Cpu), 'f', -1, 32),
-			strconv.FormatFloat(float64(r.Gpu), 'f', -1, 32),
-			strconv.FormatFloat(float64(r.Load), 'f', -1, 32),
-			strconv.FormatFloat(float64(r.Temp), 'f', -1, 32),
-			strconv.FormatInt(r.Ram, 10),
-		})
-	}
-
-	db.Table("records").Order("time desc").Find(&compRecs)
-	fComp, err = os.Create("../../data/compressed_records.csv")
-	assert.NoError(t, err)
-	defer fComp.Close()
-	wComp = csv.NewWriter(fComp)
-	defer wComp.Flush()
-	wComp.Write([]string{"Client", "Time", "Cpu", "Gpu", "Load", "Temp", "Ram"})
-	for _, r := range compRecs {
-		wComp.Write([]string{
-			r.Client,
-			r.Time.ToTime().Format(time.RFC3339),
-			strconv.FormatFloat(float64(r.Cpu), 'f', -1, 32),
-			strconv.FormatFloat(float64(r.Gpu), 'f', -1, 32),
-			strconv.FormatFloat(float64(r.Load), 'f', -1, 32),
-			strconv.FormatFloat(float64(r.Temp), 'f', -1, 32),
-			strconv.FormatInt(r.Ram, 10),
-		})
-	}
-}

internal/database/tasks/ping.go

@@ -1,106 +0,0 @@
-package tasks
-
-import (
-	"time"
-
-	"github.com/komari-monitor/komari/internal/database/models"
-	"github.com/komari-monitor/komari/internal/dbcore"
-	"github.com/komari-monitor/komari/internal/pingSchedule"
-	"gorm.io/gorm"
-)
-
-func AddPingTask(clients []string, name string, target, task_type string, interval int) (uint, error) {
-	db := dbcore.GetDBInstance()
-	task := models.PingTask{
-		Clients:  clients,
-		Name:     name,
-		Type:     task_type,
-		Target:   target,
-		Interval: interval,
-	}
-	if err := db.Create(&task).Error; err != nil {
-		return 0, err
-	}
-	ReloadPingSchedule()
-	return task.Id, nil
-}
-
-func DeletePingTask(id []uint) error {
-	db := dbcore.GetDBInstance()
-	result := db.Where("id IN ?", id).Delete(&models.PingTask{})
-	if result.RowsAffected == 0 {
-		return gorm.ErrRecordNotFound
-	}
-	ReloadPingSchedule()
-	return result.Error
-}
-
-func EditPingTask(tasks []*models.PingTask) error {
-	db := dbcore.GetDBInstance()
-	for _, task := range tasks {
-		result := db.Model(&models.PingTask{}).Where("id = ?", task.Id).Updates(task)
-		if result.RowsAffected == 0 {
-			return gorm.ErrRecordNotFound
-		}
-	}
-	ReloadPingSchedule()
-	return nil
-}
-
-func GetAllPingTasks() ([]models.PingTask, error) {
-	db := dbcore.GetDBInstance()
-	var tasks []models.PingTask
-	if err := db.Find(&tasks).Error; err != nil {
-		return nil, err
-	}
-	return tasks, nil
-}
-
-func SavePingRecord(record models.PingRecord) error {
-	db := dbcore.GetDBInstance()
-	return db.Create(&record).Error
-}
-
-func DeletePingRecordsBefore(time time.Time) error {
-	db := dbcore.GetDBInstance()
-	err := db.Where("time < ?", time).Delete(&models.PingRecord{}).Error
-	return err
-}
-
-func DeletePingRecords(id []uint) error {
-	db := dbcore.GetDBInstance()
-	result := db.Where("task_id IN ?", id).Delete(&models.PingRecord{})
-	if result.RowsAffected == 0 {
-		return gorm.ErrRecordNotFound
-	}
-	return result.Error
-}
-
-func DeleteAllPingRecords() error {
-	db := dbcore.GetDBInstance()
-	result := db.Exec("DELETE FROM ping_records")
-	if result.RowsAffected == 0 {
-		return gorm.ErrRecordNotFound
-	}
-	return result.Error
-}
-
-func ReloadPingSchedule() error {
-	return pingSchedule.ReloadPingSchedule()
-}
-
-func GetPingRecords(uuid string, taskId int, start, end time.Time) ([]models.PingRecord, error) {
-	db := dbcore.GetDBInstance()
-	var records []models.PingRecord
-	dbQuery := db.Model(&models.PingRecord{})
-	if uuid != "" {
-		dbQuery = dbQuery.Where("client = ?", uuid)
-	}
-	if taskId >= 0 {
-		dbQuery = dbQuery.Where("task_id = ?", uint(taskId))
-	}
-	if err := dbQuery.Where("time >= ? AND time <= ?", start, end).Order("time DESC").Find(&records).Error; err != nil {
-		return nil, err
-	}
-	return records, nil
-}

internal/dbcore/boot.go

@@ -1,90 +0,0 @@
-package dbcore
-
-import (
-	"errors"
-	"fmt"
-	"log"
-	"sync"
-
-	"github.com/komari-monitor/komari/internal/conf"
-	logu "github.com/komari-monitor/komari/internal/log"
-	"gorm.io/driver/mysql"
-	"gorm.io/driver/sqlite"
-	"gorm.io/gorm"
-)
-
-var (
-	dbBootOnce sync.Once
-	dbBootErr  error
-)
-
-// Boot initializes the global DB instance based on the provided config.
-//
-// It is safe to call multiple times; the first call wins.
-func BootWithConfig(cfg *conf.Config) error {
-	if cfg == nil {
-		return errors.New("dbcore: config is nil")
-	}
-
-	dbBootOnce.Do(func() {
-		var err error
-
-		logConfig := &gorm.Config{
-			Logger:                                   logu.NewGormLogger(),
-			DisableForeignKeyConstraintWhenMigrating: true,
-		}
-
-		switch cfg.Database.DatabaseType {
-		case "sqlite", "":
-			instance, err = gorm.Open(sqlite.Open(cfg.Database.DatabaseFile), logConfig)
-			if err != nil {
-				dbBootErr = fmt.Errorf("failed to connect to SQLite3 database: %w", err)
-				return
-			}
-			log.Printf("Using SQLite database file: %s", cfg.Database.DatabaseFile)
-			instance.Exec("PRAGMA wal = ON;")
-			if err := instance.Exec("PRAGMA journal_mode = WAL;").Error; err != nil {
-				log.Printf("Failed to enable WAL mode for SQLite: %v", err)
-			}
-			instance.Exec("PRAGMA wal_checkpoint(TRUNCATE);")
-		case "mysql":
-			dsn := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8mb4&collation=utf8mb4_unicode_ci&parseTime=True&loc=Local",
-				cfg.Database.DatabaseUser,
-				cfg.Database.DatabasePass,
-				cfg.Database.DatabaseHost,
-				cfg.Database.DatabasePort,
-				cfg.Database.DatabaseName)
-			instance, err = gorm.Open(mysql.Open(dsn), logConfig)
-			if err != nil {
-				dbBootErr = fmt.Errorf("failed to connect to MySQL database: %w", err)
-				return
-			}
-			log.Printf("Using MySQL database: %s@%s:%s/%s", cfg.Database.DatabaseUser, cfg.Database.DatabaseHost, cfg.Database.DatabasePort, cfg.Database.DatabaseName)
-			instance.Exec("SET NAMES utf8mb4 COLLATE utf8mb4_unicode_ci")
-		default:
-			dbBootErr = fmt.Errorf("unsupported database type: %s", cfg.Database.DatabaseType)
-			return
-		}
-
-		if needsMigration(instance) {
-			log.Println("Version changed, running database migration...")
-			if err := runMigrations(instance); err != nil {
-				dbBootErr = fmt.Errorf("failed to run migrations: %w", err)
-				return
-			}
-			updateSchemaVersion(instance)
-			log.Println("Database migration completed")
-		} else {
-			log.Println("Version unchanged, skipping migration")
-		}
-	})
-
-	return dbBootErr
-}
-
-// Boot initializes the global DB instance based on current conf.Conf.
-//
-// It is safe to call multiple times; the first call wins.
-func Boot() error {
-	return BootWithConfig(conf.Conf)
-}

internal/dbcore/dbcore.go

@@ -1,115 +0,0 @@
-package dbcore
-
-import (
-	"fmt"
-	"log"
-
-	"github.com/komari-monitor/komari/internal/conf"
-	"github.com/komari-monitor/komari/internal/database/models"
-	"gorm.io/gorm"
-)
-
-var (
-	instance *gorm.DB
-)
-
-type SchemaVersion struct {
-	ID      uint   `gorm:"primaryKey"`
-	Version string `gorm:"type:varchar(50);not null"`
-}
-
-func GetDBInstance() *gorm.DB {
-	return instance
-}
-
-// needsMigration 检查是否需要运行数据库迁移（版本号不一致时需要）
-func needsMigration(db *gorm.DB) bool {
-	// 先确保 schema_versions 表存在
-	if err := db.AutoMigrate(&SchemaVersion{}); err != nil {
-		log.Printf("Failed to create schema_versions table: %v", err)
-		return true
-	}
-
-	var sv SchemaVersion
-	if err := db.First(&sv).Error; err != nil {
-		// 没有记录，首次运行
-		return true
-	}
-
-	// 版本不一致则需要迁移
-	return sv.Version != conf.Version
-}
-
-// updateSchemaVersion 更新版本记录
-func updateSchemaVersion(db *gorm.DB) {
-	var sv SchemaVersion
-	if err := db.First(&sv).Error; err != nil {
-		db.Create(&SchemaVersion{Version: conf.Version})
-	} else {
-		db.Model(&sv).Update("version", conf.Version)
-	}
-}
-
-// setMySQLTableCharset 设置 MySQL 表的字符集为 utf8mb4
-func setMySQLTableCharset(db *gorm.DB, tableName string) {
-	if conf.Conf.Database.DatabaseType == "mysql" {
-		db.Exec(fmt.Sprintf("ALTER TABLE `%s` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci", tableName))
-	}
-}
-
-// runMigrations 执行所有数据库迁移
-func runMigrations(db *gorm.DB) error {
-	// 定义所有需要迁移的模型
-	allModels := []interface{}{
-		&models.User{},
-		&models.Client{},
-		&models.Record{},
-		&models.GPURecord{},
-		&models.Log{},
-		&models.Clipboard{},
-		&models.LoadNotification{},
-		&models.OfflineNotification{},
-		&models.PingRecord{},
-		&models.PingTask{},
-		&models.OidcProvider{},
-		&models.MessageSenderProvider{},
-		&models.ThemeConfiguration{},
-		&models.Session{},
-		&models.Task{},
-		&models.TaskResult{},
-	}
-
-	// 执行 AutoMigrate
-	err := db.AutoMigrate(allModels...)
-	if err != nil {
-		return fmt.Errorf("failed to create tables: %w", err)
-	}
-
-	// 为 MySQL 设置表字符集
-	if conf.Conf.Database.DatabaseType == "mysql" {
-		tableNames := []string{
-			"users", "clients", "records", "gpu_records", "logs", "clipboards",
-			"load_notifications", "offline_notifications", "ping_records", "ping_tasks",
-			"oidc_providers", "message_sender_providers", "theme_configurations",
-			"sessions", "tasks", "task_results", "schema_versions",
-		}
-		for _, tableName := range tableNames {
-			setMySQLTableCharset(db, tableName)
-		}
-	}
-
-	// 创建长期记录表
-	if err := db.Table("records_long_term").AutoMigrate(&models.Record{}); err != nil {
-		log.Printf("Failed to create records_long_term table: %v", err)
-	} else {
-		setMySQLTableCharset(db, "records_long_term")
-	}
-
-	if err := db.Table("gpu_records_long_term").AutoMigrate(&models.GPURecord{}); err != nil {
-		log.Printf("Failed to create gpu_records_long_term table: %v", err)
-	} else {
-		setMySQLTableCharset(db, "gpu_records_long_term")
-	}
-
-	return nil
-}

internal/dbcore/init.go

@@ -1,7 +0,0 @@
-package dbcore
-
-import "github.com/komari-monitor/komari/internal/app"
-
-func init() {
-	app.RegisterModuleFactory(NewDBModule().Name(), NewDBModule)
-}

internal/dbcore/module.go

@@ -1,77 +0,0 @@
-package dbcore
-
-import (
-	"github.com/gookit/event"
-	"github.com/komari-monitor/komari/internal/app"
-	"github.com/komari-monitor/komari/internal/conf"
-	"github.com/komari-monitor/komari/internal/eventType"
-	"gorm.io/gorm"
-)
-
-type dbModule struct{}
-
-var _ app.Module = (*dbModule)(nil)
-
-// NewDBModule provides the "db" module for the lifecycle app.
-//
-// It initializes the legacy global DB instance and returns it for DI.
-func NewDBModule() app.Module { return &dbModule{} }
-
-func (m *dbModule) Name() string      { return "db" }
-func (m *dbModule) Depends() []string { return []string{"config"} }
-
-func (m *dbModule) Provide(r app.Registry) error {
-	return r.Provide(func(cfg *conf.Config) (*gorm.DB, error) {
-		if err := BootWithConfig(cfg); err != nil {
-			return nil, err
-		}
-		return GetDBInstance(), nil
-	})
-}
-
-func (m *dbModule) Hooks() app.Hooks {
-	return app.Hooks{
-		Init: func(_ *gorm.DB) error { return nil },
-		Start: func() {
-			// Move legacy event registrations out of init() to avoid implicit side-effects.
-			event.On(eventType.SchedulerEvery5Minutes, event.ListenerFunc(func(e event.Event) error {
-				db := GetDBInstance()
-				if db == nil {
-					return nil
-				}
-				if conf.Conf.Database.DatabaseType == "sqlite" || conf.Conf.Database.DatabaseType == "" {
-					db.Exec("PRAGMA wal_checkpoint(TRUNCATE);")
-				}
-				return nil
-			}))
-
-			event.On(eventType.SchedulerEveryDay, event.ListenerFunc(func(e event.Event) error {
-				db := GetDBInstance()
-				if db == nil {
-					return nil
-				}
-				if conf.Conf.Database.DatabaseType == "sqlite" || conf.Conf.Database.DatabaseType == "" {
-					db.Exec("VACUUM;")
-				}
-				return nil
-			}))
-		},
-		Stop: func() error {
-			db := GetDBInstance()
-			if db == nil {
-				return nil
-			}
-			sqlDB, err := db.DB()
-			if err != nil {
-				return err
-			}
-			return sqlDB.Close()
-		},
-	}
-}
-
-func init() {
-	// Ensure "config" can be auto-materialized even if callers only import dbcore.
-	app.RegisterModuleFactory("config", conf.NewConfigModule)
-	app.RegisterModuleFactory("db", NewDBModule)
-}

internal/eventType/events.go

@@ -1,55 +0,0 @@
-package eventType
-
-const (
-	ClientWebsocketConnected    = "client.websocket.connected"    // 客户端通过 websocket 连接
-	ClientWebsocketDisconnected = "client.websocket.disconnected" // 客户端断开 websocket 连接
-	ClientMessageReceived       = "client.message.received"       // 收到客户端消息
-	ClientCreated               = "client.created"                // 新客户端创建
-	ClientUpdated               = "client.updated"                // 客户端信息更新
-	ClientDeleted               = "client.deleted"                // 客户端删除
-	ClientRenewed               = "client.renewed"                // 客户端续期
-
-	UserUpdateUsername = "user.update.username" // 用户更改用户名
-	UserUpdatePassword = "user.update.password" // 用户更改密码
-	UserLogin          = "user.login.succeeded" // 用户登录
-	UserLogout         = "user.logout"          // 用户登出
-	UserOidcBound      = "user.oidc.bound"      // 用户绑定 OIDC
-	UserOidcUnbound    = "user.oidc.unbound"    // 用户解绑 OIDC
-	UserTwoFaAdded     = "user.2fa.added"       // 用户添加 2FA
-	UserTwoFaRemoved   = "user.2fa.removed"     // 用户移除 2FA
-	UserSessionRevoked = "user.session.revoked" // 用户会话撤销
-
-	LoginFailed = "user.login.failed" // 用户登录失败
-
-	ConfigUpdated = "config.updated" // 配置更改。当服务器第一次启动载入配置时也会触发此事件（由 ServerInitializeDone 事件联动），其中 old 全部为go类型零值， new 为载入的配置内容，若在配置载入前读取Conf，返回的将是零值配置。当出现错误时，配置修改将会被撤回。
-
-	ProcessStart = "process.start" // 进程启动，如果在此事件的监听器中返回错误，进程将退出。注意：此时数据库、配置进行初始化，不应该在此事件的监听器中执行需要数据库或配置的操作，即使需要进行操作数据库和配置，请将优先级设置为event.Max以下
-	ProcessExit  = "process.exit"  // 进程停止
-
-	ServerInitializeStart = "server.routers.start"     // 服务器路由初始化开始，如果在此事件的监听器中返回错误，进程将退出
-	ServerInitializeDone  = "server.routers.done"      // 服务器路由初始化完成
-	ServerListenGrpcStart = "server.listen.grpc.start" // 服务器开始监听 gRPC
-	ServerListenGrpcStop  = "server.listen.grpc.stop"  // 服务器停止监听 gRPC
-
-	TaskCreated = "task.created" // 任务创建
-	TaskUpdated = "task.updated" // 任务更新
-
-	HttpRequestReceived = "http.request.received" // 收到 HTTP 请求
-
-	SchedulerDatabase       = "scheduler.database"       // 数据库定时任务
-	SchedulerEveryMinute    = "scheduler.everyminute"    // 每分钟定时触发
-	SchedulerEvery5Minutes  = "scheduler.every5minutes"  // 每五分钟定时触发
-	SchedulerEvery30Minutes = "scheduler.every30minutes" // 每三十分钟定时触发
-	SchedulerEveryHour      = "scheduler.everyhour"      // 每小时定时触发
-	SchedulerEveryDay       = "scheduler.everyday"       // 每天定时触发，服务器启动的当天不会触发此事件
-
-	NotificationSent   = "notification.sent"   // 通知发送
-	NotificationFailed = "notification.failed" // 通知发送失败
-
-	TerminalEstablished = "terminal.established" // 终端连接建立
-	TerminalClosed      = "terminal.closed"      // 终端连接关闭
-
-	GeoIpUpdateStart  = "geoip.update.start"  // GeoIP 数据库更新开始
-	GeoIpUpdateDone   = "geoip.update.done"   // GeoIP 数据库更新完成
-	GeoIpUpdateFailed = "geoip.update.failed" // GeoIP 数据库更新失败
-)