Merge branch 'feature/config-presets' into develop

docker/acc-server/entrypoint.sh

@@ -1,78 +1,26 @@
 #!/bin/bash
 set -e
 
+# Use a display number derived from the server port to avoid conflicts
+# between containers (each server gets its own unique display).
 DISPLAY_NUM=$((SERVER_PORT % 1000 + 100))
 export DISPLAY=:${DISPLAY_NUM}
 
+# Clean up any stale X lock from a previous container run.
 rm -f /tmp/.X${DISPLAY_NUM}-lock /tmp/.X11-unix/X${DISPLAY_NUM} 2>/dev/null || true
 
 Xvfb ${DISPLAY} -screen 0 1024x768x16 -nolisten tcp &
 XVFB_PID=$!
 
-TCPDUMP_PID=""
-
 cleanup() {
     echo "Stopping ACC server..."
-    [ -n "${TCPDUMP_PID}" ] && kill "${TCPDUMP_PID}" 2>/dev/null || true
-    kill "${XVFB_PID}" 2>/dev/null || true
+    kill $XVFB_PID 2>/dev/null || true
 }
-trap cleanup SIGTERM SIGINT EXIT
-
-# Initialize Wine prefix (no-op if already done)
-wineboot -u 2>/dev/null
+trap cleanup SIGTERM SIGINT
 
 mkdir -p /acc/game/log
 
-# ─── Debug mode ───────────────────────────────────────────────────────────────
-# Set DEBUG_MODE=1 on the container to enable extra diagnostics:
-#
-#   docker run -e DEBUG_MODE=1 ...
-#   or in docker-compose:
-#     environment:
-#       DEBUG_MODE: "1"
-#
-# Produces:
-#   /acc/game/log/tcpdump_<port>.pcap  — raw packet capture (open in Wireshark)
-#   /acc/game/log/wine_debug.log       — Wine debug output
-#   Stderr: Wine version, WINEDEBUG channel, prefix state
-#
-# You can also override which Wine debug channels are enabled:
-#   WINEDEBUG_CHANNELS="+loaddll,+seh,+relay"  (relay is very verbose)
-# ─────────────────────────────────────────────────────────────────────────────
-if [ "${DEBUG_MODE:-0}" = "1" ]; then
-    echo "[debug] Debug mode enabled for port ${SERVER_PORT}"
-    echo "[debug] Wine: $(wine --version 2>/dev/null || echo unknown)"
-    echo "[debug] WINEPREFIX: ${WINEPREFIX}"
+echo "Starting ACC server on port ${SERVER_PORT}..."
 
-    # Configure Wine debug channels (default: loader + exception + module info)
-    export WINEDEBUG="${WINEDEBUG_CHANNELS:-+loaddll,+module,+seh,+ntdll}"
-    echo "[debug] WINEDEBUG=${WINEDEBUG}"
-
-    # Start packet capture on the server port — captures both TCP and UDP.
-    # The pcap file records every byte Kunos sends/receives so you can inspect
-    # the 2-byte "pakSizeMax" packet and anything that follows.
-    #
-    # NOTE: requires CAP_NET_RAW capability on the container:
-    #   docker-compose: cap_add: [NET_RAW]
-    #   docker run: --cap-add=NET_RAW
-    # Without it tcpdump will be skipped (no crash, just no capture).
-    CAPTURE_FILE="/acc/game/log/tcpdump_${SERVER_PORT}.pcap"
-    echo "[debug] Starting packet capture → ${CAPTURE_FILE}"
-    echo "[debug] (requires cap_add: [NET_RAW] in docker-compose — will exit silently if missing)"
-    tcpdump -i any -nn -s 0 -w "${CAPTURE_FILE}" \
-        "port ${SERVER_PORT}" 2>/acc/game/log/tcpdump.err &
-    TCPDUMP_PID=$!
-
-    # Redirect Wine debug output to a log file (Wine writes to stderr).
-    WINE_LOG="/acc/game/log/wine_debug.log"
-    echo "[debug] Wine debug log → ${WINE_LOG}"
-    echo "Starting ACC server on port ${SERVER_PORT} (DEBUG)..."
-    cd /acc/game
-    exec wine /acc/game/accServer.exe 2>"${WINE_LOG}"
-else
-    # Production: suppress all Wine debug output.
-    export WINEDEBUG=-all
-    echo "Starting ACC server on port ${SERVER_PORT}..."
-    cd /acc/game
-    exec wine /acc/game/accServer.exe
-fi
+cd /acc/game
+exec wine /acc/game/accServer.exe

local/api/api.go

@@ -34,7 +34,10 @@ func Init(di *dig.Container, app *fiber.App) {
 		WebSocket:    groups.Group("/ws"),
 		Leaderboard:  serverIdGroup.Group("/leaderboard"),
 		Steam:        groups.Group("/steam"),
+		ActivityLog:  serverIdGroup.Group("/activity-log"),
+		Groups:       groups,
 		Log:          serverIdGroup.Group("/log"),
+		Presets:      groups.Group("/presets"),
 	}
 
 	accessKeyMiddleware := middleware.NewAccessKeyMiddleware()

local/controller/activity_log.go

@@ -0,0 +1,48 @@
+package controller
+
+import (
+	"acc-server-manager/local/middleware"
+	"acc-server-manager/local/model"
+	"acc-server-manager/local/service"
+	"acc-server-manager/local/utl/common"
+	"acc-server-manager/local/utl/error_handler"
+
+	"github.com/gofiber/fiber/v2"
+)
+
+type ActivityLogController struct {
+	service      *service.ActivityLogService
+	errorHandler *error_handler.ControllerErrorHandler
+}
+
+func NewActivityLogController(as *service.ActivityLogService, routeGroups *common.RouteGroups, auth *middleware.AuthMiddleware) *ActivityLogController {
+	ac := &ActivityLogController{
+		service:      as,
+		errorHandler: error_handler.NewControllerErrorHandler(),
+	}
+
+	// Global activity log: GET /activity-log (admin use)
+	routeGroups.Groups.Group("/activity-log").Use(auth.Authenticate).Get("/", ac.GetAllLogs)
+
+	return ac
+}
+
+// GetAllLogs returns activity logs across all servers (admin).
+//
+//	@Summary		Return all activity logs
+//	@Tags			ActivityLog
+//	@Success		200	{array}	model.ActivityLog
+//	@Router			/activity-log [get]
+func (ac *ActivityLogController) GetAllLogs(c *fiber.Ctx) error {
+	var filter model.ActivityLogFilter
+	if err := common.ParseQueryFilter(c, &filter); err != nil {
+		return ac.errorHandler.HandleValidationError(c, err, "query_filter")
+	}
+
+	result, err := ac.service.GetAll(c.UserContext(), &filter)
+	if err != nil {
+		return ac.errorHandler.HandleServiceError(c, err)
+	}
+
+	return c.JSON(result)
+}

local/controller/config_preset.go

@@ -0,0 +1,246 @@
+package controller
+
+import (
+	"acc-server-manager/local/middleware"
+	"acc-server-manager/local/model"
+	"acc-server-manager/local/service"
+	"acc-server-manager/local/utl/common"
+	"acc-server-manager/local/utl/error_handler"
+	"acc-server-manager/local/utl/logging"
+
+	"github.com/gofiber/fiber/v2"
+	"github.com/google/uuid"
+)
+
+type ConfigPresetController struct {
+	service      *service.ConfigPresetService
+	apiService   *service.ServiceControlService
+	errorHandler *error_handler.ControllerErrorHandler
+}
+
+// NewConfigPresetController initializes ConfigPresetController.
+func NewConfigPresetController(s *service.ConfigPresetService, apiService *service.ServiceControlService, routeGroups *common.RouteGroups, auth *middleware.AuthMiddleware) *ConfigPresetController {
+	c := &ConfigPresetController{
+		service:      s,
+		apiService:   apiService,
+		errorHandler: error_handler.NewControllerErrorHandler(),
+	}
+
+	presetRoutes := routeGroups.Presets
+	presetRoutes.Use(auth.Authenticate)
+	presetRoutes.Get("/", auth.HasPermission(model.PresetView), c.ListPresets)
+	presetRoutes.Post("/", auth.HasPermission(model.PresetCreate), c.CreatePreset)
+	presetRoutes.Get("/:presetId", auth.HasPermission(model.PresetView), c.GetPreset)
+	presetRoutes.Put("/:presetId", auth.HasPermission(model.PresetUpdate), c.UpdatePreset)
+	presetRoutes.Delete("/:presetId", auth.HasPermission(model.PresetDelete), c.DeletePreset)
+
+	configRoutes := routeGroups.Config
+	configRoutes.Post("/presets/:presetId/apply", auth.HasPermission(model.ConfigUpdate), c.ApplyPreset)
+
+	return c
+}
+
+// ListPresets returns all config presets.
+//
+//	@Summary		List config presets
+//	@Description	Get a list of all saved configuration presets
+//	@Tags			Config Presets
+//	@Accept			json
+//	@Produce		json
+//	@Param			name query string false "Filter by preset name (partial match)"
+//	@Success		200	{array} model.ConfigPreset "List of presets"
+//	@Failure		401	{object} error_handler.ErrorResponse "Unauthorized"
+//	@Failure		403	{object} error_handler.ErrorResponse "Insufficient permissions"
+//	@Failure		500	{object} error_handler.ErrorResponse "Internal server error"
+//	@Security		BearerAuth
+//	@Router			/presets [get]
+func (c *ConfigPresetController) ListPresets(ctx *fiber.Ctx) error {
+	var filter model.ConfigPresetFilter
+	if err := common.ParseQueryFilter(ctx, &filter); err != nil {
+		return c.errorHandler.HandleParsingError(ctx, err)
+	}
+
+	presets, err := c.service.ListPresets(ctx.UserContext(), &filter)
+	if err != nil {
+		return c.errorHandler.HandleServiceError(ctx, err)
+	}
+	return ctx.JSON(presets)
+}
+
+// GetPreset returns a single config preset by ID.
+//
+//	@Summary		Get config preset
+//	@Description	Retrieve a single configuration preset by ID
+//	@Tags			Config Presets
+//	@Accept			json
+//	@Produce		json
+//	@Param			presetId path string true "Preset ID (UUID format)"
+//	@Success		200	{object} model.ConfigPreset "Preset"
+//	@Failure		400	{object} error_handler.ErrorResponse "Invalid preset ID"
+//	@Failure		401	{object} error_handler.ErrorResponse "Unauthorized"
+//	@Failure		403	{object} error_handler.ErrorResponse "Insufficient permissions"
+//	@Failure		404	{object} error_handler.ErrorResponse "Preset not found"
+//	@Failure		500	{object} error_handler.ErrorResponse "Internal server error"
+//	@Security		BearerAuth
+//	@Router			/presets/{presetId} [get]
+func (c *ConfigPresetController) GetPreset(ctx *fiber.Ctx) error {
+	id, err := uuid.Parse(ctx.Params("presetId"))
+	if err != nil {
+		return c.errorHandler.HandleUUIDError(ctx, "preset ID")
+	}
+
+	preset, err := c.service.GetPreset(ctx.UserContext(), id)
+	if err != nil {
+		return c.errorHandler.HandleServiceError(ctx, err)
+	}
+	return ctx.JSON(preset)
+}
+
+// CreatePreset creates a new config preset.
+//
+//	@Summary		Create config preset
+//	@Description	Save a new configuration preset with one or more ACC config sections
+//	@Tags			Config Presets
+//	@Accept			json
+//	@Produce		json
+//	@Param			content body model.ConfigPresetCreateRequest true "Preset data"
+//	@Success		201	{object} model.ConfigPreset "Created preset"
+//	@Failure		400	{object} error_handler.ErrorResponse "Invalid request"
+//	@Failure		401	{object} error_handler.ErrorResponse "Unauthorized"
+//	@Failure		403	{object} error_handler.ErrorResponse "Insufficient permissions"
+//	@Failure		500	{object} error_handler.ErrorResponse "Internal server error"
+//	@Security		BearerAuth
+//	@Router			/presets [post]
+func (c *ConfigPresetController) CreatePreset(ctx *fiber.Ctx) error {
+	var req model.ConfigPresetCreateRequest
+	if err := ctx.BodyParser(&req); err != nil {
+		return c.errorHandler.HandleParsingError(ctx, err)
+	}
+
+	actorID, _ := ctx.Locals("userID").(string)
+	actorUsername, _ := ctx.Locals("actorUsername").(string)
+	if actorUsername == "" {
+		actorUsername = "system"
+	}
+
+	preset, err := c.service.CreatePreset(ctx.UserContext(), &req, actorID, actorUsername)
+	if err != nil {
+		return c.errorHandler.HandleServiceError(ctx, err)
+	}
+	return ctx.Status(fiber.StatusCreated).JSON(preset)
+}
+
+// UpdatePreset updates an existing config preset.
+//
+//	@Summary		Update config preset
+//	@Description	Update name, description, or any config sections of an existing preset
+//	@Tags			Config Presets
+//	@Accept			json
+//	@Produce		json
+//	@Param			presetId path string true "Preset ID (UUID format)"
+//	@Param			content body model.ConfigPresetUpdateRequest true "Fields to update (omit to keep existing)"
+//	@Success		200	{object} model.ConfigPreset "Updated preset"
+//	@Failure		400	{object} error_handler.ErrorResponse "Invalid request or preset ID"
+//	@Failure		401	{object} error_handler.ErrorResponse "Unauthorized"
+//	@Failure		403	{object} error_handler.ErrorResponse "Insufficient permissions"
+//	@Failure		404	{object} error_handler.ErrorResponse "Preset not found"
+//	@Failure		500	{object} error_handler.ErrorResponse "Internal server error"
+//	@Security		BearerAuth
+//	@Router			/presets/{presetId} [put]
+func (c *ConfigPresetController) UpdatePreset(ctx *fiber.Ctx) error {
+	id, err := uuid.Parse(ctx.Params("presetId"))
+	if err != nil {
+		return c.errorHandler.HandleUUIDError(ctx, "preset ID")
+	}
+
+	var req model.ConfigPresetUpdateRequest
+	if err := ctx.BodyParser(&req); err != nil {
+		return c.errorHandler.HandleParsingError(ctx, err)
+	}
+
+	preset, err := c.service.UpdatePreset(ctx.UserContext(), id, &req)
+	if err != nil {
+		return c.errorHandler.HandleServiceError(ctx, err)
+	}
+	return ctx.JSON(preset)
+}
+
+// DeletePreset deletes a config preset.
+//
+//	@Summary		Delete config preset
+//	@Description	Permanently delete a configuration preset
+//	@Tags			Config Presets
+//	@Accept			json
+//	@Produce		json
+//	@Param			presetId path string true "Preset ID (UUID format)"
+//	@Success		204	"No Content"
+//	@Failure		400	{object} error_handler.ErrorResponse "Invalid preset ID"
+//	@Failure		401	{object} error_handler.ErrorResponse "Unauthorized"
+//	@Failure		403	{object} error_handler.ErrorResponse "Insufficient permissions"
+//	@Failure		500	{object} error_handler.ErrorResponse "Internal server error"
+//	@Security		BearerAuth
+//	@Router			/presets/{presetId} [delete]
+func (c *ConfigPresetController) DeletePreset(ctx *fiber.Ctx) error {
+	id, err := uuid.Parse(ctx.Params("presetId"))
+	if err != nil {
+		return c.errorHandler.HandleUUIDError(ctx, "preset ID")
+	}
+
+	if err := c.service.DeletePreset(ctx.UserContext(), id); err != nil {
+		return c.errorHandler.HandleServiceError(ctx, err)
+	}
+	return ctx.SendStatus(fiber.StatusNoContent)
+}
+
+// ApplyPreset applies a saved preset to a server's config files.
+//
+//	@Summary		Apply config preset to server
+//	@Description	Apply a saved configuration preset to an ACC server, writing only the sections stored in the preset
+//	@Tags			Server Configuration
+//	@Accept			json
+//	@Produce		json
+//	@Param			id path string true "Server ID (UUID format)"
+//	@Param			presetId path string true "Preset ID (UUID format)"
+//	@Param			restart query bool false "Restart the server after applying the preset"
+//	@Success		200	{array} model.Config "List of updated config audit records"
+//	@Failure		400	{object} error_handler.ErrorResponse "Invalid server or preset ID"
+//	@Failure		401	{object} error_handler.ErrorResponse "Unauthorized"
+//	@Failure		403	{object} error_handler.ErrorResponse "Insufficient permissions"
+//	@Failure		404	{object} error_handler.ErrorResponse "Server or preset not found"
+//	@Failure		500	{object} error_handler.ErrorResponse "Internal server error"
+//	@Security		BearerAuth
+//	@Router			/server/{id}/config/presets/{presetId}/apply [post]
+func (c *ConfigPresetController) ApplyPreset(ctx *fiber.Ctx) error {
+	restart := ctx.QueryBool("restart")
+	serverID := ctx.Params("id")
+
+	if _, err := uuid.Parse(serverID); err != nil {
+		return c.errorHandler.HandleUUIDError(ctx, "server ID")
+	}
+
+	ctx.Locals("serverId", serverID)
+
+	presetID, err := uuid.Parse(ctx.Params("presetId"))
+	if err != nil {
+		return c.errorHandler.HandleUUIDError(ctx, "preset ID")
+	}
+
+	actorID, _ := ctx.Locals("userID").(string)
+	actorUsername, _ := ctx.Locals("actorUsername").(string)
+	if actorUsername == "" {
+		actorUsername = "system"
+	}
+
+	configs, err := c.service.ApplyPreset(ctx.UserContext(), serverID, presetID, actorID, actorUsername)
+	if err != nil {
+		return c.errorHandler.HandleServiceError(ctx, err)
+	}
+
+	if restart {
+		if _, err := c.apiService.ServiceControlRestartServer(ctx); err != nil {
+			logging.ErrorWithContext("PRESET_APPLY_RESTART", "Failed to restart server after preset apply: %v", err)
+		}
+	}
+
+	return ctx.JSON(configs)
+}

local/controller/controller.go

@@ -35,6 +35,11 @@ func InitializeControllers(c *dig.Container) {
 		logging.Panic("unable to initialize config controller")
 	}
 
+	err = c.Invoke(NewConfigPresetController)
+	if err != nil {
+		logging.Panic("unable to initialize config preset controller")
+	}
+
 	err = c.Invoke(NewServerController)
 	if err != nil {
 		logging.Panic("unable to initialize server controller")
@@ -70,6 +75,11 @@ func InitializeControllers(c *dig.Container) {
 		logging.Panic("unable to initialize steam controller")
 	}
 
+	err = c.Invoke(NewActivityLogController)
+	if err != nil {
+		logging.Panic("unable to initialize activity log controller")
+	}
+
 	err = c.Invoke(NewLogController)
 	if err != nil {
 		logging.Panic("unable to initialize log controller")

local/controller/leaderboard.go

@@ -11,6 +11,7 @@ import (
 	"github.com/google/uuid"
 )
 
+
 type LeaderboardController struct {
 	service      *service.LeaderboardService
 	errorHandler *error_handler.ControllerErrorHandler
@@ -60,7 +61,14 @@ func (lc *LeaderboardController) Update(c *fiber.Ctx) error {
 		return lc.errorHandler.HandleParsingError(c, err)
 	}
 
-	data, err := lc.service.Update(c.UserContext(), serverID, &input)
+	userInfo, _ := c.Locals("userInfo").(*middleware.CachedUserInfo)
+	actorID, actorUsername := "", "system"
+	if userInfo != nil {
+		actorID = userInfo.UserID
+		actorUsername = userInfo.Username
+	}
+
+	data, err := lc.service.Update(c.UserContext(), serverID, &input, actorID, actorUsername)
 	if err != nil {
 		return lc.errorHandler.HandleServiceError(c, err)
 	}

local/controller/service_control.go

@@ -29,6 +29,7 @@ func NewServiceControlController(as *service.ServiceControlService, routeGroups
 	}
 
 	serviceRoutes := routeGroups.Server.Group("/:id/service")
+	serviceRoutes.Use(auth.Authenticate)
 	serviceRoutes.Get("/:service", ac.getStatus)
 	serviceRoutes.Post("/start", ac.startServer)
 	serviceRoutes.Post("/stop", ac.stopServer)

local/middleware/auth.go

@@ -115,6 +115,7 @@ func (m *AuthMiddleware) AuthenticateWithHandler(jwtHandler *jwt.JWTHandler, isO
 	if os.Getenv("TESTING_ENV") == "true" {
 		userInfo := CachedUserInfo{UserID: uuid.New().String(), Username: "test@example.com", RoleName: "Admin", Permissions: make(map[string]bool), CachedAt: time.Now()}
 		ctx.Locals("userID", userInfo.UserID)
+		ctx.Locals("actorUsername", userInfo.Username)
 		ctx.Locals("userInfo", userInfo)
 		ctx.Locals("authTime", time.Now())
 	} else {
@@ -127,6 +128,7 @@ func (m *AuthMiddleware) AuthenticateWithHandler(jwtHandler *jwt.JWTHandler, isO
 		}
 
 		ctx.Locals("userID", claims.UserID)
+		ctx.Locals("actorUsername", userInfo.Username)
 		ctx.Locals("userInfo", userInfo)
 		ctx.Locals("authTime", time.Now())
 	}

local/migrations/006_add_activity_log.go

@@ -0,0 +1,33 @@
+package migrations
+
+import (
+	"acc-server-manager/local/utl/logging"
+	"fmt"
+
+	"gorm.io/gorm"
+)
+
+func RunAddActivityLogMigration(db *gorm.DB) error {
+	if err := db.AutoMigrate(&MigrationRecord{}); err != nil {
+		return fmt.Errorf("failed to ensure migration_records table: %v", err)
+	}
+
+	var record MigrationRecord
+	if err := db.Where("migration_name = ?", "006_add_activity_log").First(&record).Error; err == nil {
+		logging.Info("Activity log migration already applied, skipping")
+		return nil
+	}
+
+	record = MigrationRecord{
+		MigrationName: "006_add_activity_log",
+		AppliedAt:     "datetime('now')",
+		Success:       true,
+		Notes:         "Added ActivityLog table via GORM AutoMigrate",
+	}
+	if err := db.Create(&record).Error; err != nil {
+		return fmt.Errorf("failed to record migration 006: %v", err)
+	}
+
+	logging.Info("Activity log migration recorded")
+	return nil
+}

local/migrations/007_add_config_presets.go

@@ -0,0 +1,51 @@
+package migrations
+
+import (
+	"acc-server-manager/local/utl/logging"
+	"fmt"
+	"time"
+
+	"gorm.io/gorm"
+)
+
+type ConfigPresetMigration struct {
+	ID            uint   `gorm:"primaryKey"`
+	Name          string `gorm:"not null"`
+	Description   string
+	Configuration string `gorm:"type:text"`
+	AssistRules   string `gorm:"type:text"`
+	Event         string `gorm:"type:text"`
+	EventRules    string `gorm:"type:text"`
+	Settings      string `gorm:"type:text"`
+	CreatedAt     string
+	UpdatedAt     string
+}
+
+func (ConfigPresetMigration) TableName() string {
+	return "config_presets"
+}
+
+func RunAddConfigPresetsMigration(db *gorm.DB) error {
+	if err := db.AutoMigrate(&MigrationRecord{}); err != nil {
+		return fmt.Errorf("failed to ensure migration_records table: %v", err)
+	}
+
+	var record MigrationRecord
+	if err := db.Where("migration_name = ?", "007_add_config_presets").First(&record).Error; err == nil {
+		logging.Info("Config presets migration already applied, skipping")
+		return nil
+	}
+
+	record = MigrationRecord{
+		MigrationName: "007_add_config_presets",
+		AppliedAt:     time.Now().UTC().Format(time.RFC3339),
+		Success:       true,
+		Notes:         "Added ConfigPreset table via GORM AutoMigrate",
+	}
+	if err := db.Create(&record).Error; err != nil {
+		return fmt.Errorf("failed to record migration 007: %v", err)
+	}
+
+	logging.Info("Config presets migration recorded")
+	return nil
+}

local/model/activity_log.go

@@ -0,0 +1,84 @@
+package model
+
+import (
+	"time"
+
+	"github.com/google/uuid"
+	"gorm.io/gorm"
+)
+
+type ActionType string
+
+const (
+	ActionConfigUpdate      ActionType = "config_update"
+	ActionServerStart       ActionType = "server_start"
+	ActionServerStop        ActionType = "server_stop"
+	ActionServerRestart     ActionType = "server_restart"
+	ActionLeaderboardUpdate ActionType = "leaderboard_update"
+	ActionPresetCreate      ActionType = "preset_create"
+	ActionPresetApply       ActionType = "preset_apply"
+)
+
+type ActivityLog struct {
+	ID        uuid.UUID  `json:"id"        gorm:"type:uuid;primary_key;"`
+	ServerID  *uuid.UUID `json:"serverId"  gorm:"type:uuid;index"`
+	Server    *Server    `json:"server,omitempty" gorm:"foreignKey:ServerID"`
+	UserID    string     `json:"userId"    gorm:"not null"`
+	Username  string     `json:"username"  gorm:"not null"`
+	Action    ActionType `json:"action"    gorm:"not null"`
+	Details   string     `json:"details"   gorm:"type:text"`
+	CreatedAt time.Time  `json:"createdAt"`
+}
+
+func (a *ActivityLog) BeforeCreate(tx *gorm.DB) error {
+	if a.ID == uuid.Nil {
+		a.ID = uuid.New()
+	}
+	if a.CreatedAt.IsZero() {
+		a.CreatedAt = time.Now().UTC()
+	}
+	return nil
+}
+
+type ActivityLogFilter struct {
+	BaseFilter
+	DateRangeFilter
+	UserID   string     `query:"user_id"`
+	Action   ActionType `query:"action"`
+	ServerID string     `query:"server_id"`
+}
+
+func (f *ActivityLogFilter) ApplyFilter(query *gorm.DB) *gorm.DB {
+	if f.ServerID != "" {
+		if serverUUID, err := uuid.Parse(f.ServerID); err == nil {
+			query = query.Where("server_id = ?", serverUUID)
+		}
+	}
+	if f.UserID != "" {
+		query = query.Where("user_id = ?", f.UserID)
+	}
+	if f.Action != "" {
+		query = query.Where("action = ?", f.Action)
+	}
+	timeZero := time.Time{}
+	if f.StartDate != timeZero {
+		query = query.Where("created_at >= ?", f.StartDate)
+	}
+	if f.EndDate != timeZero {
+		query = query.Where("created_at <= ?", f.EndDate)
+	}
+	return query
+}
+
+func (f *ActivityLogFilter) GetSorting() (field string, desc bool) {
+	if f.SortBy == "" {
+		return "created_at", true
+	}
+	return f.SortBy, f.SortDesc
+}
+
+type LastActivityInfo struct {
+	UpdatedAt time.Time  `json:"updatedAt"`
+	Username  string     `json:"username"`
+	Action    ActionType `json:"action"`
+}

local/model/config_preset.go

@@ -0,0 +1,48 @@
+package model
+
+import (
+	"time"
+
+	"github.com/google/uuid"
+	"gorm.io/gorm"
+)
+
+type ConfigPreset struct {
+	ID            uuid.UUID `json:"id" gorm:"type:uuid;primary_key;"`
+	Name          string    `json:"name" gorm:"not null"`
+	Description   string    `json:"description"`
+	Configuration string    `json:"configuration" gorm:"type:text"`
+	AssistRules   string    `json:"assistRules" gorm:"type:text"`
+	Event         string    `json:"event" gorm:"type:text"`
+	EventRules    string    `json:"eventRules" gorm:"type:text"`
+	Settings      string    `json:"settings" gorm:"type:text"`
+	CreatedAt     time.Time `json:"createdAt"`
+	UpdatedAt     time.Time `json:"updatedAt"`
+}
+
+func (p *ConfigPreset) BeforeCreate(tx *gorm.DB) error {
+	if p.ID == uuid.Nil {
+		p.ID = uuid.New()
+	}
+	return nil
+}
+
+type ConfigPresetCreateRequest struct {
+	Name          string                  `json:"name"`
+	Description   string                  `json:"description"`
+	Configuration *map[string]interface{} `json:"configuration"`
+	AssistRules   *map[string]interface{} `json:"assistRules"`
+	Event         *map[string]interface{} `json:"event"`
+	EventRules    *map[string]interface{} `json:"eventRules"`
+	Settings      *map[string]interface{} `json:"settings"`
+}
+
+type ConfigPresetUpdateRequest struct {
+	Name          *string                 `json:"name"`
+	Description   *string                 `json:"description"`
+	Configuration *map[string]interface{} `json:"configuration"`
+	AssistRules   *map[string]interface{} `json:"assistRules"`
+	Event         *map[string]interface{} `json:"event"`
+	EventRules    *map[string]interface{} `json:"eventRules"`
+	Settings      *map[string]interface{} `json:"settings"`
+}

local/model/filter.go

@@ -30,6 +30,18 @@ type ConfigFilter struct {
 	ChangedAt  time.Time `query:"changed_at" time_format:"2006-01-02T15:04:05Z07:00"`
 }
 
+type ConfigPresetFilter struct {
+	BaseFilter
+	Name string `query:"name"`
+}
+
+func (f *ConfigPresetFilter) ApplyFilter(query *gorm.DB) *gorm.DB {
+	if f.Name != "" {
+		query = query.Where("name LIKE ?", "%"+f.Name+"%")
+	}
+	return query
+}
+
 type ServiceControlFilter struct {
 	BaseFilter
 	ServiceControl string `query:"serviceControl"`

local/model/permissions.go

@@ -24,6 +24,11 @@ const (
 	MembershipCreate = "membership.create"
 	MembershipView   = "membership.view"
 	MembershipEdit   = "membership.edit"
+
+	PresetView   = "preset.view"
+	PresetCreate = "preset.create"
+	PresetUpdate = "preset.update"
+	PresetDelete = "preset.delete"
 )
 
 func AllPermissions() []string {
@@ -47,5 +52,9 @@ func AllPermissions() []string {
 		MembershipCreate,
 		MembershipView,
 		MembershipEdit,
+		PresetView,
+		PresetCreate,
+		PresetUpdate,
+		PresetDelete,
 	}
 }

local/model/server.go

@@ -35,18 +35,19 @@ func (s *Server) ToServerAPI() *ServerAPI {
 }
 
 type Server struct {
-	ID           uuid.UUID     `gorm:"type:uuid;primary_key;" json:"id"`
-	Name         string        `gorm:"not null" json:"name"`
-	Status       ServiceStatus `json:"status" gorm:"-"`
-	IP           string        `gorm:"not null" json:"-"`
-	Port         int           `gorm:"not null" json:"-"`
-	Path         string        `gorm:"not null" json:"path"`
-	ServiceName  string        `gorm:"not null" json:"serviceName"`
-	Platform     string        `gorm:"not null;default:'windows'" json:"platform"`
-	ContainerID  string        `gorm:"default:''" json:"-"`
-	State        *ServerState  `gorm:"-" json:"state"`
-	DateCreated  time.Time     `json:"dateCreated"`
-	FromSteamCMD bool          `gorm:"not null; default:true" json:"-"`
+	ID           uuid.UUID         `gorm:"type:uuid;primary_key;" json:"id"`
+	Name         string            `gorm:"not null" json:"name"`
+	Status       ServiceStatus     `json:"status" gorm:"-"`
+	IP           string            `gorm:"not null" json:"-"`
+	Port         int               `gorm:"not null" json:"-"`
+	Path         string            `gorm:"not null" json:"path"`
+	ServiceName  string            `gorm:"not null" json:"serviceName"`
+	Platform     string            `gorm:"not null;default:'windows'" json:"platform"`
+	ContainerID  string            `gorm:"default:''" json:"-"`
+	State        *ServerState      `gorm:"-" json:"state"`
+	LastActivity *LastActivityInfo `gorm:"-" json:"lastActivity,omitempty"`
+	DateCreated  time.Time         `json:"dateCreated"`
+	FromSteamCMD bool              `gorm:"not null; default:true" json:"-"`
 }
 
 type PlayerState struct {

local/repository/activity_log.go

@@ -0,0 +1,96 @@
+package repository
+
+import (
+	"acc-server-manager/local/model"
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/google/uuid"
+	"gorm.io/gorm"
+)
+
+type ActivityLogRepository struct {
+	*BaseRepository[model.ActivityLog, model.ActivityLogFilter]
+}
+
+func NewActivityLogRepository(db *gorm.DB) *ActivityLogRepository {
+	return &ActivityLogRepository{
+		BaseRepository: NewBaseRepository[model.ActivityLog, model.ActivityLogFilter](db, model.ActivityLog{}),
+	}
+}
+
+func (r *ActivityLogRepository) Insert(ctx context.Context, entry *model.ActivityLog) error {
+	return r.BaseRepository.Insert(ctx, entry)
+}
+
+func (r *ActivityLogRepository) GetAll(ctx context.Context, filter *model.ActivityLogFilter) (*[]model.ActivityLog, error) {
+	result := &[]model.ActivityLog{}
+	query := r.BaseRepository.db.WithContext(ctx).
+		Model(&model.ActivityLog{}).
+		Preload("Server")
+
+	query = filter.ApplyFilter(query)
+
+	offset, limit := filter.Pagination()
+	query = query.Offset(offset).Limit(limit)
+
+	field, desc := filter.GetSorting()
+	if desc {
+		query = query.Order(field + " DESC")
+	} else {
+		query = query.Order(field)
+	}
+
+	if err := query.Find(result).Error; err != nil {
+		return nil, fmt.Errorf("error getting activity logs: %w", err)
+	}
+	return result, nil
+}
+
+type lastActivityRow struct {
+	ServerID  string           `gorm:"column:server_id"`
+	CreatedAt time.Time        `gorm:"column:created_at"`
+	Username  string           `gorm:"column:username"`
+	Action    model.ActionType `gorm:"column:action"`
+}
+
+// GetLastActivityByServerIDs returns the most recent activity entry per server.
+// Uses a single GROUP BY query with MAX(created_at); SQLite selects the other
+// columns from the row that holds the max value — documented SQLite behaviour.
+func (r *ActivityLogRepository) GetLastActivityByServerIDs(ctx context.Context, serverIDs []uuid.UUID) (map[uuid.UUID]*model.LastActivityInfo, error) {
+	out := make(map[uuid.UUID]*model.LastActivityInfo)
+	if len(serverIDs) == 0 {
+		return out, nil
+	}
+
+	// Convert to string slice so the IN clause works with SQLite UUID strings.
+	ids := make([]string, len(serverIDs))
+	for i, id := range serverIDs {
+		ids[i] = id.String()
+	}
+
+	var rows []lastActivityRow
+	err := r.BaseRepository.db.WithContext(ctx).
+		Model(&model.ActivityLog{}).
+		Select("server_id, MAX(created_at) as created_at, username, action").
+		Where("server_id IN ?", ids).
+		Group("server_id").
+		Scan(&rows).Error
+	if err != nil {
+		return nil, err
+	}
+
+	for _, row := range rows {
+		serverUUID, err := uuid.Parse(row.ServerID)
+		if err != nil {
+			continue
+		}
+		out[serverUUID] = &model.LastActivityInfo{
+			UpdatedAt: row.CreatedAt,
+			Username:  row.Username,
+			Action:    row.Action,
+		}
+	}
+	return out, nil
+}

local/repository/config_preset.go

@@ -0,0 +1,17 @@
+package repository
+
+import (
+	"acc-server-manager/local/model"
+
+	"gorm.io/gorm"
+)
+
+type ConfigPresetRepository struct {
+	*BaseRepository[model.ConfigPreset, model.ConfigPresetFilter]
+}
+
+func NewConfigPresetRepository(db *gorm.DB) *ConfigPresetRepository {
+	return &ConfigPresetRepository{
+		BaseRepository: NewBaseRepository[model.ConfigPreset, model.ConfigPresetFilter](db, model.ConfigPreset{}),
+	}
+}

local/repository/repository.go

@@ -20,6 +20,8 @@ func InitializeRepositories(c *dig.Container) {
 	c.Provide(NewSteamCredentialsRepository)
 	c.Provide(NewMembershipRepository)
 	c.Provide(NewLeaderboardRepository)
+	c.Provide(NewActivityLogRepository)
+	c.Provide(NewConfigPresetRepository)
 
 	if err := c.Provide(func() *model.Steam2FAManager {
 		manager := model.NewSteam2FAManager()

local/service/activity_log.go

@@ -0,0 +1,65 @@
+package service
+
+import (
+	"acc-server-manager/local/model"
+	"acc-server-manager/local/repository"
+	"acc-server-manager/local/utl/logging"
+	"context"
+	"encoding/json"
+	"fmt"
+)
+
+type ActivityLogService struct {
+	repo *repository.ActivityLogRepository
+}
+
+func NewActivityLogService(repo *repository.ActivityLogRepository) *ActivityLogService {
+	return &ActivityLogService{repo: repo}
+}
+
+// Log persists an activity log entry. Errors are logged but not returned so
+// callers can treat this as fire-and-forget.
+func (s *ActivityLogService) Log(ctx context.Context, entry *model.ActivityLog) error {
+	if err := s.repo.Insert(ctx, entry); err != nil {
+		logging.Error("Failed to insert activity log: %v", err)
+		return err
+	}
+	return nil
+}
+
+func (s *ActivityLogService) GetAll(ctx context.Context, filter *model.ActivityLogFilter) (*[]model.ActivityLog, error) {
+	return s.repo.GetAll(ctx, filter)
+}
+
+// BuildConfigDetails produces a JSON string summarising which top-level keys
+// changed between oldJSON and newJSON.
+func BuildConfigDetails(file string, oldJSON, newJSON []byte) string {
+	var oldMap, newMap map[string]interface{}
+
+	if err := json.Unmarshal(oldJSON, &oldMap); err != nil {
+		oldMap = map[string]interface{}{}
+	}
+	if err := json.Unmarshal(newJSON, &newMap); err != nil {
+		newMap = map[string]interface{}{}
+	}
+
+	var changedKeys []string
+	for key, newVal := range newMap {
+		oldVal, exists := oldMap[key]
+		if !exists {
+			changedKeys = append(changedKeys, key)
+			continue
+		}
+		oldBytes, _ := json.Marshal(oldVal)
+		newBytes, _ := json.Marshal(newVal)
+		if string(oldBytes) != string(newBytes) {
+			changedKeys = append(changedKeys, key)
+		}
+	}
+
+	if len(changedKeys) == 0 {
+		return ""
+	}
+	keysJSON, _ := json.Marshal(changedKeys)
+	return fmt.Sprintf(`{"file":%q,"changed_keys":%s}`, file, string(keysJSON))
+}

local/service/config.go

@@ -68,14 +68,16 @@ type ConfigService struct {
 	repository       *repository.ConfigRepository
 	serverRepository *repository.ServerRepository
 	serverService    *ServerService
+	activityLog      *ActivityLogService
 	configCache      *model.ServerConfigCache
 }
 
-func NewConfigService(repository *repository.ConfigRepository, serverRepository *repository.ServerRepository) *ConfigService {
+func NewConfigService(repository *repository.ConfigRepository, serverRepository *repository.ServerRepository, activityLog *ActivityLogService) *ConfigService {
 	logging.Debug("Initializing ConfigService with 5m expiration and 1s throttle")
 	return &ConfigService{
 		repository:       repository,
 		serverRepository: serverRepository,
+		activityLog:      activityLog,
 		configCache: model.NewServerConfigCache(model.CacheConfig{
 			ExpirationTime: 5 * time.Minute,
 			ThrottleTime:   1 * time.Second,
@@ -120,6 +122,12 @@ func (as *ConfigService) UpdateAllConfigs(ctx *fiber.Ctx, req *model.Configurati
 		{SettingsJson, req.Settings},
 	}
 
+	actorID, _ := ctx.Locals("userID").(string)
+	actorUsername, _ := ctx.Locals("actorUsername").(string)
+	if actorUsername == "" {
+		actorUsername = "system"
+	}
+
 	var results []*model.Config
 	for _, entry := range entries {
 		if entry.body == nil {
@@ -129,6 +137,16 @@ func (as *ConfigService) UpdateAllConfigs(ctx *fiber.Ctx, req *model.Configurati
 		if err != nil {
 			return nil, err
 		}
+		if entry.fileName == SettingsJson {
+			if nameVal, ok := (*entry.body)["serverName"]; ok {
+				if nameStr, ok := nameVal.(string); ok && nameStr != "" && nameStr != server.Name {
+					server.Name = nameStr
+					if err := as.serverRepository.Update(ctx.UserContext(), server); err != nil {
+						logging.Error("Failed to update server name in DB: %v", err)
+					}
+				}
+			}
+		}
 		result := as.repository.UpdateConfig(ctx.UserContext(), &model.Config{
 			ServerID:   serverUUID,
 			ConfigFile: entry.fileName,
@@ -137,6 +155,20 @@ func (as *ConfigService) UpdateAllConfigs(ctx *fiber.Ctx, req *model.Configurati
 			ChangedAt:  time.Now(),
 		})
 		results = append(results, result)
+
+		if as.activityLog != nil {
+			if details := BuildConfigDetails(entry.fileName, oldDataUTF8, newData); details != "" {
+				go func(details string) {
+					_ = as.activityLog.Log(context.Background(), &model.ActivityLog{
+						ServerID: &serverUUID,
+						UserID:   actorID,
+						Username: actorUsername,
+						Action:   model.ActionConfigUpdate,
+						Details:  details,
+					})
+				}(details)
+			}
+		}
 	}
 
 	if len(results) > 0 {
@@ -152,7 +184,13 @@ func (as *ConfigService) UpdateConfig(ctx *fiber.Ctx, body *map[string]interface
 	configFile := ctx.Params("file")
 	override := ctx.QueryBool("override", false)
 
-	return as.updateConfigInternal(ctx.UserContext(), serverID, configFile, body, override)
+	actorID, _ := ctx.Locals("userID").(string)
+	actorUsername, _ := ctx.Locals("actorUsername").(string)
+	if actorUsername == "" {
+		actorUsername = "system"
+	}
+
+	return as.updateConfigInternal(ctx.UserContext(), serverID, configFile, body, override, actorID, actorUsername)
 }
 
 func (as *ConfigService) updateConfigFiles(ctx context.Context, server *model.Server, configFile string, body *map[string]interface{}, override bool) ([]byte, []byte, error) {
@@ -211,7 +249,7 @@ func (as *ConfigService) updateConfigFiles(ctx context.Context, server *model.Se
 	return oldDataUTF8, newData, nil
 }
 
-func (as *ConfigService) updateConfigInternal(ctx context.Context, serverID string, configFile string, body *map[string]interface{}, override bool) (*model.Config, error) {
+func (as *ConfigService) updateConfigInternal(ctx context.Context, serverID string, configFile string, body *map[string]interface{}, override bool, actorID, actorUsername string) (*model.Config, error) {
 	serverUUID, err := uuid.Parse(serverID)
 	if err != nil {
 		logging.Error("Invalid server ID format: %v", err)
@@ -229,9 +267,34 @@ func (as *ConfigService) updateConfigInternal(ctx context.Context, serverID stri
 		return nil, err
 	}
 
-	as.configCache.InvalidateServerCache(serverID)
+	if configFile == SettingsJson {
+		if nameVal, ok := (*body)["serverName"]; ok {
+			if nameStr, ok := nameVal.(string); ok && nameStr != "" && nameStr != server.Name {
+				server.Name = nameStr
+				if err := as.serverRepository.Update(ctx, server); err != nil {
+					logging.Error("Failed to update server name in DB: %v", err)
+				}
+			}
+		}
+	}
 
+	as.configCache.InvalidateServerCache(serverID)
 	as.serverService.StartAccServerRuntime(server)
+
+	if as.activityLog != nil {
+		if details := BuildConfigDetails(configFile, oldDataUTF8, newData); details != "" {
+			go func() {
+				_ = as.activityLog.Log(context.Background(), &model.ActivityLog{
+					ServerID: &serverUUID,
+					UserID:   actorID,
+					Username: actorUsername,
+					Action:   model.ActionConfigUpdate,
+					Details:  details,
+				})
+			}()
+		}
+	}
+
 	return as.repository.UpdateConfig(ctx, &model.Config{
 		ServerID:   serverUUID,
 		ConfigFile: configFile,
@@ -497,3 +560,17 @@ func (as *ConfigService) SaveConfiguration(server *model.Server, config *model.C
 	_, _, err = as.updateConfigFiles(context.Background(), server, ConfigurationJson, &configMap, true)
 	return err
 }
+
+// ApplySection writes a single config section to the server's config file and
+// records the change. It is used by ConfigPresetService to apply preset sections.
+func (as *ConfigService) ApplySection(ctx context.Context, serverID, configFile string, body *map[string]interface{}, actorID, actorUsername string) (*model.Config, error) {
+	return as.updateConfigInternal(ctx, serverID, configFile, body, true, actorID, actorUsername)
+}
+
+func (as *ConfigService) SetServerName(server *model.Server, name string) error {
+	configMap := map[string]interface{}{
+		"serverName": name,
+	}
+	_, _, err := as.updateConfigFiles(context.Background(), server, SettingsJson, &configMap, false)
+	return err
+}

local/service/config_preset.go

@@ -0,0 +1,210 @@
+package service
+
+import (
+	"acc-server-manager/local/model"
+	"acc-server-manager/local/repository"
+	"acc-server-manager/local/utl/logging"
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"github.com/google/uuid"
+)
+
+const (
+	presetMaxNameLen      = 100
+	presetMaxDescLen      = 500
+	presetMaxSectionBytes = 64 * 1024 // 64 KB per config section
+)
+
+type ConfigPresetService struct {
+	repository    *repository.ConfigPresetRepository
+	configService *ConfigService
+	activityLog   *ActivityLogService
+}
+
+func NewConfigPresetService(repo *repository.ConfigPresetRepository, configService *ConfigService, activityLog *ActivityLogService) *ConfigPresetService {
+	return &ConfigPresetService{
+		repository:    repo,
+		configService: configService,
+		activityLog:   activityLog,
+	}
+}
+
+func (s *ConfigPresetService) ListPresets(ctx context.Context, filter *model.ConfigPresetFilter) (*[]model.ConfigPreset, error) {
+	return s.repository.GetAll(ctx, filter)
+}
+
+func (s *ConfigPresetService) GetPreset(ctx context.Context, id uuid.UUID) (*model.ConfigPreset, error) {
+	preset, err := s.repository.GetByID(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+	if preset == nil {
+		return nil, fmt.Errorf("preset not found")
+	}
+	return preset, nil
+}
+
+func (s *ConfigPresetService) CreatePreset(ctx context.Context, req *model.ConfigPresetCreateRequest, actorID, actorUsername string) (*model.ConfigPreset, error) {
+	if req.Name == "" {
+		return nil, fmt.Errorf("preset name is required")
+	}
+	if len(req.Name) > presetMaxNameLen {
+		return nil, fmt.Errorf("preset name exceeds maximum length of %d characters", presetMaxNameLen)
+	}
+	if len(req.Description) > presetMaxDescLen {
+		return nil, fmt.Errorf("preset description exceeds maximum length of %d characters", presetMaxDescLen)
+	}
+
+	preset := &model.ConfigPreset{
+		Name:        req.Name,
+		Description: req.Description,
+	}
+
+	if err := marshalSections(req.Configuration, req.AssistRules, req.Event, req.EventRules, req.Settings, preset); err != nil {
+		return nil, err
+	}
+
+	if err := s.repository.Insert(ctx, preset); err != nil {
+		return nil, err
+	}
+
+	details := fmt.Sprintf(`{"preset_id":%q,"preset_name":%q}`, preset.ID, preset.Name)
+	go func() {
+		if logErr := s.activityLog.Log(context.Background(), &model.ActivityLog{
+			UserID:   actorID,
+			Username: actorUsername,
+			Action:   model.ActionPresetCreate,
+			Details:  details,
+		}); logErr != nil {
+			logging.Error("Failed to log preset create: %v", logErr)
+		}
+	}()
+
+	return preset, nil
+}
+
+func (s *ConfigPresetService) UpdatePreset(ctx context.Context, id uuid.UUID, req *model.ConfigPresetUpdateRequest) (*model.ConfigPreset, error) {
+	preset, err := s.GetPreset(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+
+	if req.Name != nil {
+		if len(*req.Name) == 0 {
+			return nil, fmt.Errorf("preset name cannot be empty")
+		}
+		if len(*req.Name) > presetMaxNameLen {
+			return nil, fmt.Errorf("preset name exceeds maximum length of %d characters", presetMaxNameLen)
+		}
+		preset.Name = *req.Name
+	}
+	if req.Description != nil {
+		if len(*req.Description) > presetMaxDescLen {
+			return nil, fmt.Errorf("preset description exceeds maximum length of %d characters", presetMaxDescLen)
+		}
+		preset.Description = *req.Description
+	}
+	if err := marshalSections(req.Configuration, req.AssistRules, req.Event, req.EventRules, req.Settings, preset); err != nil {
+		return nil, err
+	}
+
+	if err := s.repository.Update(ctx, preset); err != nil {
+		return nil, err
+	}
+	return preset, nil
+}
+
+func (s *ConfigPresetService) DeletePreset(ctx context.Context, id uuid.UUID) error {
+	return s.repository.Delete(ctx, id)
+}
+
+func (s *ConfigPresetService) ApplyPreset(ctx context.Context, serverID string, presetID uuid.UUID, actorID, actorUsername string) ([]*model.Config, error) {
+	preset, err := s.GetPreset(ctx, presetID)
+	if err != nil {
+		return nil, err
+	}
+
+	serverUUID, err := uuid.Parse(serverID)
+	if err != nil {
+		return nil, fmt.Errorf("invalid server ID: %v", err)
+	}
+
+	type sectionEntry struct {
+		fileName string
+		raw      string
+	}
+
+	sections := []sectionEntry{
+		{ConfigurationJson, preset.Configuration},
+		{AssistRulesJson, preset.AssistRules},
+		{EventJson, preset.Event},
+		{EventRulesJson, preset.EventRules},
+		{SettingsJson, preset.Settings},
+	}
+
+	var results []*model.Config
+	for _, section := range sections {
+		if section.raw == "" {
+			continue
+		}
+		var body map[string]interface{}
+		if err := json.Unmarshal([]byte(section.raw), &body); err != nil {
+			return nil, fmt.Errorf("failed to unmarshal preset section %s: %v", section.fileName, err)
+		}
+		result, err := s.configService.ApplySection(ctx, serverID, section.fileName, &body, actorID, actorUsername)
+		if err != nil {
+			return nil, fmt.Errorf("failed to apply preset section %s: %v", section.fileName, err)
+		}
+		if result != nil {
+			results = append(results, result)
+		}
+	}
+
+	details := fmt.Sprintf(`{"preset_id":%q,"preset_name":%q,"sections_applied":%d}`, presetID, preset.Name, len(results))
+	go func() {
+		if logErr := s.activityLog.Log(context.Background(), &model.ActivityLog{
+			ServerID: &serverUUID,
+			UserID:   actorID,
+			Username: actorUsername,
+			Action:   model.ActionPresetApply,
+			Details:  details,
+		}); logErr != nil {
+			logging.Error("Failed to log preset apply: %v", logErr)
+		}
+	}()
+
+	return results, nil
+}
+
+// marshalSections marshals each non-nil config section into the preset's JSON string fields,
+// enforcing the per-section byte size limit.
+func marshalSections(configuration, assistRules, event, eventRules, settings *map[string]interface{}, preset *model.ConfigPreset) error {
+	type entry struct {
+		src  *map[string]interface{}
+		name string
+		dest *string
+	}
+	entries := []entry{
+		{configuration, "configuration", &preset.Configuration},
+		{assistRules, "assistRules", &preset.AssistRules},
+		{event, "event", &preset.Event},
+		{eventRules, "eventRules", &preset.EventRules},
+		{settings, "settings", &preset.Settings},
+	}
+	for _, e := range entries {
+		if e.src == nil {
+			continue
+		}
+		b, err := json.Marshal(e.src)
+		if err != nil {
+			return fmt.Errorf("failed to marshal %s: %v", e.name, err)
+		}
+		if len(b) > presetMaxSectionBytes {
+			return fmt.Errorf("%s section exceeds maximum size of %d bytes", e.name, presetMaxSectionBytes)
+		}
+		*e.dest = string(b)
+	}
+	return nil
+}

local/service/docker_log_streamer.go

@@ -8,6 +8,7 @@ import (
 	"io"
 	"strconv"
 	"sync"
+	"time"
 
 	"github.com/docker/docker/api/types"
 	dockerclient "github.com/docker/docker/client"
@@ -25,14 +26,14 @@ func NewDockerLogStreamer(client *dockerclient.Client) *DockerLogStreamer {
 }
 
 func (s *DockerLogStreamer) Start(ctx context.Context, server *model.Server, handleLine func(string)) error {
-	if _, exists := s.cancels.Load(server.ID); exists {
-		return nil
-	}
+	s.Stop(server.ID)
+
 	if server.ContainerID == "" {
 		logging.Warn("DockerLogStreamer.Start: no container ID for server %s, skipping", server.ID)
 		return nil
 	}
 
+	since := time.Now().UTC().Format(time.RFC3339)
 	streamCtx, cancel := context.WithCancel(ctx)
 	s.cancels.Store(server.ID, cancel)
 
@@ -44,6 +45,7 @@ func (s *DockerLogStreamer) Start(ctx context.Context, server *model.Server, han
 			ShowStderr: true,
 			Follow:     true,
 			Timestamps: false,
+			Since:      since,
 		})
 		if err != nil {
 			logging.Error("DockerLogStreamer: failed to attach to container %s: %v", server.ContainerID[:12], err)

local/service/leaderboard.go

@@ -3,6 +3,7 @@ package service
 import (
 	"acc-server-manager/local/model"
 	"acc-server-manager/local/repository"
+	"acc-server-manager/local/utl/logging"
 	"context"
 	"fmt"
 
@@ -10,11 +11,12 @@ import (
 )
 
 type LeaderboardService struct {
-	repo *repository.LeaderboardRepository
+	repo        *repository.LeaderboardRepository
+	activityLog *ActivityLogService
 }
 
-func NewLeaderboardService(repo *repository.LeaderboardRepository) *LeaderboardService {
-	return &LeaderboardService{repo: repo}
+func NewLeaderboardService(repo *repository.LeaderboardRepository, activityLog *ActivityLogService) *LeaderboardService {
+	return &LeaderboardService{repo: repo, activityLog: activityLog}
 }
 
 // Get returns the leaderboard for a server.
@@ -23,7 +25,7 @@ func (s *LeaderboardService) Get(ctx context.Context, serverID uuid.UUID) (*mode
 }
 
 // Update replaces the leaderboard for a server.
-func (s *LeaderboardService) Update(ctx context.Context, serverID uuid.UUID, lb *model.Leaderboard) (*model.Leaderboard, error) {
+func (s *LeaderboardService) Update(ctx context.Context, serverID uuid.UUID, lb *model.Leaderboard, actorID, actorUsername string) (*model.Leaderboard, error) {
 	if lb == nil {
 		return nil, fmt.Errorf("input is required")
 	}
@@ -33,5 +35,25 @@ func (s *LeaderboardService) Update(ctx context.Context, serverID uuid.UUID, lb
 	for i := range lb.Races {
 		lb.Races[i].Position = i
 	}
-	return s.repo.FullReplace(ctx, serverID, lb)
+	result, err := s.repo.FullReplace(ctx, serverID, lb)
+	if err != nil {
+		return nil, err
+	}
+
+	driverCount := len(lb.Drivers)
+	raceCount := len(lb.Races)
+	details := fmt.Sprintf(`{"driver_count":%d,"race_count":%d}`, driverCount, raceCount)
+	go func() {
+		if logErr := s.activityLog.Log(context.Background(), &model.ActivityLog{
+			ServerID: &serverID,
+			UserID:   actorID,
+			Username: actorUsername,
+			Action:   model.ActionLeaderboardUpdate,
+			Details:  details,
+		}); logErr != nil {
+			logging.Error("Failed to log leaderboard update: %v", logErr)
+		}
+	}()
+
+	return result, nil
 }

local/service/server.go

@@ -26,12 +26,13 @@ const (
 type ServerService struct {
 	repository       *repository.ServerRepository
 	stateHistoryRepo *repository.StateHistoryRepository
+	activityLogRepo  *repository.ActivityLogRepository
 	apiService       *ServiceControlService
 	configService    *ConfigService
 	steamService     *SteamService
 	runtime          platform.ServerRuntime
 	firewall         platform.FirewallManager
-	logStreamer      platform.LogStreamer
+	logStreamer       platform.LogStreamer
 	portPool         *network.PortPoolManager
 	webSocketService *WebSocketService
 	instances        sync.Map // uuid.UUID → *tracking.AccServerInstance
@@ -71,6 +72,7 @@ func (s *ServerService) GetLastLogLines(ctx *fiber.Ctx, serverID uuid.UUID, n in
 func NewServerService(
 	repository *repository.ServerRepository,
 	stateHistoryRepo *repository.StateHistoryRepository,
+	activityLogRepo *repository.ActivityLogRepository,
 	apiService *ServiceControlService,
 	configService *ConfigService,
 	steamService *SteamService,
@@ -83,6 +85,7 @@ func NewServerService(
 	service := &ServerService{
 		repository:       repository,
 		stateHistoryRepo: stateHistoryRepo,
+		activityLogRepo:  activityLogRepo,
 		apiService:       apiService,
 		configService:    configService,
 		steamService:     steamService,
@@ -281,6 +284,16 @@ func (s *ServerService) GetAll(ctx *fiber.Ctx, filter *model.ServerFilter) (*[]m
 		return nil, err
 	}
 
+	// Collect server IDs for a single last-activity lookup.
+	serverIDs := make([]uuid.UUID, len(*servers))
+	for i, srv := range *servers {
+		serverIDs[i] = srv.ID
+	}
+	lastActivities, laErr := s.activityLogRepo.GetLastActivityByServerIDs(ctx.UserContext(), serverIDs)
+	if laErr != nil {
+		logging.Error("Failed to get last activities for server list: %v", laErr)
+	}
+
 	for i := range *servers {
 		server := &(*servers)[i]
 		status, err := s.apiService.GetCachedStatus(server.ServiceName)
@@ -297,6 +310,11 @@ func (s *ServerService) GetAll(ctx *fiber.Ctx, filter *model.ServerFilter) (*[]m
 				server.State = serverInstance.State
 			}
 		}
+		if lastActivities != nil {
+			if info, ok := lastActivities[server.ID]; ok {
+				server.LastActivity = info
+			}
+		}
 	}
 
 	return servers, nil
@@ -418,6 +436,10 @@ func (s *ServerService) createServerBackground(ctx context.Context, server *mode
 					return "", fmt.Errorf("failed to update server configuration: %v", err)
 				}
 
+				if err := s.configService.SetServerName(server, server.Name); err != nil {
+					logging.Error("Failed to set server name in config: %v", err)
+				}
+
 				return fmt.Sprintf("Server configuration generated (Port: %d)", serverPort), nil
 			},
 		},

local/service/service.go

@@ -23,6 +23,7 @@ func InitializeServices(c *dig.Container) {
 
 	logging.Debug("Registering services")
 	c.Provide(NewSteamService)
+	c.Provide(NewActivityLogService)
 	c.Provide(NewServerService)
 	c.Provide(NewStateHistoryService)
 	c.Provide(NewServiceControlService)
@@ -31,6 +32,7 @@ func InitializeServices(c *dig.Container) {
 	c.Provide(NewMembershipService)
 	c.Provide(NewWebSocketService)
 	c.Provide(NewLeaderboardService)
+	c.Provide(NewConfigPresetService)
 
 	// Always provide the PortPoolManager; in Windows mode it seeds from an
 	// empty result set and sits idle.

local/service/service_control.go

@@ -15,6 +15,7 @@ type ServiceControlService struct {
 	repository       *repository.ServiceControlRepository
 	serverRepository *repository.ServerRepository
 	serverService    *ServerService
+	activityLog      *ActivityLogService
 	statusCache      *model.ServerStatusCache
 	runtime          platform.ServerRuntime
 }
@@ -23,11 +24,13 @@ func NewServiceControlService(
 	repository *repository.ServiceControlRepository,
 	serverRepository *repository.ServerRepository,
 	runtime platform.ServerRuntime,
+	activityLog *ActivityLogService,
 ) *ServiceControlService {
 	return &ServiceControlService{
 		repository:       repository,
 		serverRepository: serverRepository,
 		runtime:          runtime,
+		activityLog:      activityLog,
 		statusCache: model.NewServerStatusCache(model.CacheConfig{
 			ExpirationTime: 30 * time.Second,
 			ThrottleTime:   5 * time.Second,
@@ -36,6 +39,28 @@ func NewServiceControlService(
 	}
 }
 
+// getServerFromCtx resolves the server from ctx locals (serverId or service name).
+func (as *ServiceControlService) getServerFromCtx(ctx *fiber.Ctx) (*model.Server, error) {
+	serviceName, ok := ctx.Locals("service").(string)
+	if !ok || serviceName == "" {
+		serverId, ok2 := ctx.Locals("serverId").(string)
+		if !ok2 || serverId == "" {
+			return nil, errors.New("service name missing")
+		}
+		return as.serverRepository.GetByID(ctx.UserContext(), serverId)
+	}
+	return as.serverRepository.GetFirstByServiceName(ctx.UserContext(), serviceName)
+}
+
+func extractActor(ctx *fiber.Ctx) (actorID, actorUsername string) {
+	actorID, _ = ctx.Locals("userID").(string)
+	actorUsername, _ = ctx.Locals("actorUsername").(string)
+	if actorUsername == "" {
+		actorUsername = "system"
+	}
+	return
+}
+
 func (as *ServiceControlService) SetServerService(serverService *ServerService) {
 	as.serverService = serverService
 }
@@ -61,10 +86,11 @@ func (as *ServiceControlService) GetStatus(ctx *fiber.Ctx) (string, error) {
 }
 
 func (as *ServiceControlService) ServiceControlStartServer(ctx *fiber.Ctx) (string, error) {
-	serviceName, err := as.GetServiceName(ctx)
+	server, err := as.getServerFromCtx(ctx)
 	if err != nil {
 		return "", err
 	}
+	serviceName := server.ServiceName
 
 	as.statusCache.UpdateStatus(serviceName, model.StatusStarting)
 
@@ -79,14 +105,29 @@ func (as *ServiceControlService) ServiceControlStartServer(ctx *fiber.Ctx) (stri
 
 	status := model.ParseServiceStatus(statusStr)
 	as.statusCache.UpdateStatus(serviceName, status)
+
+	if as.activityLog != nil {
+		actorID, actorUsername := extractActor(ctx)
+		go func() {
+			_ = as.activityLog.Log(context.Background(), &model.ActivityLog{
+				ServerID: &server.ID,
+				UserID:   actorID,
+				Username: actorUsername,
+				Action:   model.ActionServerStart,
+				Details:  `{"service":"` + serviceName + `"}`,
+			})
+		}()
+	}
+
 	return status.String(), nil
 }
 
 func (as *ServiceControlService) ServiceControlStopServer(ctx *fiber.Ctx) (string, error) {
-	serviceName, err := as.GetServiceName(ctx)
+	server, err := as.getServerFromCtx(ctx)
 	if err != nil {
 		return "", err
 	}
+	serviceName := server.ServiceName
 
 	as.statusCache.UpdateStatus(serviceName, model.StatusStopping)
 
@@ -101,14 +142,29 @@ func (as *ServiceControlService) ServiceControlStopServer(ctx *fiber.Ctx) (strin
 
 	status := model.ParseServiceStatus(statusStr)
 	as.statusCache.UpdateStatus(serviceName, status)
+
+	if as.activityLog != nil {
+		actorID, actorUsername := extractActor(ctx)
+		go func() {
+			_ = as.activityLog.Log(context.Background(), &model.ActivityLog{
+				ServerID: &server.ID,
+				UserID:   actorID,
+				Username: actorUsername,
+				Action:   model.ActionServerStop,
+				Details:  `{"service":"` + serviceName + `"}`,
+			})
+		}()
+	}
+
 	return status.String(), nil
 }
 
 func (as *ServiceControlService) ServiceControlRestartServer(ctx *fiber.Ctx) (string, error) {
-	serviceName, err := as.GetServiceName(ctx)
+	server, err := as.getServerFromCtx(ctx)
 	if err != nil {
 		return "", err
 	}
+	serviceName := server.ServiceName
 
 	as.statusCache.UpdateStatus(serviceName, model.StatusRestarting)
 
@@ -123,6 +179,20 @@ func (as *ServiceControlService) ServiceControlRestartServer(ctx *fiber.Ctx) (st
 
 	status := model.ParseServiceStatus(statusStr)
 	as.statusCache.UpdateStatus(serviceName, status)
+
+	if as.activityLog != nil {
+		actorID, actorUsername := extractActor(ctx)
+		go func() {
+			_ = as.activityLog.Log(context.Background(), &model.ActivityLog{
+				ServerID: &server.ID,
+				UserID:   actorID,
+				Username: actorUsername,
+				Action:   model.ActionServerRestart,
+				Details:  `{"service":"` + serviceName + `"}`,
+			})
+		}()
+	}
+
 	return status.String(), nil
 }
 

local/utl/common/common.go

@@ -28,7 +28,10 @@ type RouteGroups struct {
 	WebSocket    fiber.Router
 	Leaderboard  fiber.Router
 	Steam        fiber.Router
+	ActivityLog  fiber.Router
+	Groups       fiber.Router
 	Log          fiber.Router
+	Presets      fiber.Router
 }
 
 func CheckError(err error) {

local/utl/configs/configs.go

@@ -8,7 +8,7 @@ import (
 )
 
 var (
-	Version       = "0.12.3"
+	Version       = "0.13.0"
 	Prefix        = "v1"
 	Secret        string
 	SecretCode    string

local/utl/db/db.go

@@ -54,6 +54,8 @@ func Migrate(db *gorm.DB) {
 		&model.LeaderboardRace{},
 		&model.LeaderboardResult{},
 		&model.LeaderboardPointRow{},
+		&model.ActivityLog{},
+		&model.ConfigPreset{},
 	)
 
 	if err != nil {
@@ -80,6 +82,14 @@ func runMigrations(db *gorm.DB) {
 		logging.Error("Failed to run platform columns migration: %v", err)
 	}
 
+	if err := migrations.RunAddActivityLogMigration(db); err != nil {
+		logging.Error("Failed to run activity log migration: %v", err)
+	}
+
+	if err := migrations.RunAddConfigPresetsMigration(db); err != nil {
+		logging.Error("Failed to run config presets migration: %v", err)
+	}
+
 	logging.Info("Custom database migrations completed")
 }
 

tests/unit/service/config_service_test.go

@@ -20,7 +20,7 @@ func TestConfigService_GetConfiguration_ValidFile(t *testing.T) {
 
 	configRepo := repository.NewConfigRepository(helper.DB)
 	serverRepo := repository.NewServerRepository(helper.DB)
-	configService := service.NewConfigService(configRepo, serverRepo)
+	configService := service.NewConfigService(configRepo, serverRepo, nil)
 
 	config, err := configService.GetConfiguration(helper.TestData.Server)
 	tests.AssertNoError(t, err)
@@ -43,7 +43,7 @@ func TestConfigService_GetEventConfig_ValidFile(t *testing.T) {
 
 	configRepo := repository.NewConfigRepository(helper.DB)
 	serverRepo := repository.NewServerRepository(helper.DB)
-	configService := service.NewConfigService(configRepo, serverRepo)
+	configService := service.NewConfigService(configRepo, serverRepo, nil)
 
 	eventConfig, err := configService.GetEventConfig(helper.TestData.Server)
 	tests.AssertNoError(t, err)
@@ -73,7 +73,7 @@ func TestConfigService_SaveConfiguration_Success(t *testing.T) {
 
 	configRepo := repository.NewConfigRepository(helper.DB)
 	serverRepo := repository.NewServerRepository(helper.DB)
-	configService := service.NewConfigService(configRepo, serverRepo)
+	configService := service.NewConfigService(configRepo, serverRepo, nil)
 
 	newConfig := &model.Configuration{
 		UdpPort:         model.IntString(9999),
@@ -115,7 +115,7 @@ func TestConfigService_LoadConfigs_Success(t *testing.T) {
 
 	configRepo := repository.NewConfigRepository(helper.DB)
 	serverRepo := repository.NewServerRepository(helper.DB)
-	configService := service.NewConfigService(configRepo, serverRepo)
+	configService := service.NewConfigService(configRepo, serverRepo, nil)
 
 	configs, err := configService.LoadConfigs(helper.TestData.Server)
 	tests.AssertNoError(t, err)
@@ -142,7 +142,7 @@ func TestConfigService_MalformedJSON(t *testing.T) {
 
 	configRepo := repository.NewConfigRepository(helper.DB)
 	serverRepo := repository.NewServerRepository(helper.DB)
-	configService := service.NewConfigService(configRepo, serverRepo)
+	configService := service.NewConfigService(configRepo, serverRepo, nil)
 
 	config, err := configService.GetConfiguration(helper.TestData.Server)
 	if err == nil {
@@ -245,7 +245,7 @@ func TestConfigService_Caching_Configuration(t *testing.T) {
 
 	configRepo := repository.NewConfigRepository(helper.DB)
 	serverRepo := repository.NewServerRepository(helper.DB)
-	configService := service.NewConfigService(configRepo, serverRepo)
+	configService := service.NewConfigService(configRepo, serverRepo, nil)
 
 	config1, err := configService.GetConfiguration(helper.TestData.Server)
 	tests.AssertNoError(t, err)
@@ -276,7 +276,7 @@ func TestConfigService_Caching_EventConfig(t *testing.T) {
 
 	configRepo := repository.NewConfigRepository(helper.DB)
 	serverRepo := repository.NewServerRepository(helper.DB)
-	configService := service.NewConfigService(configRepo, serverRepo)
+	configService := service.NewConfigService(configRepo, serverRepo, nil)
 
 	event1, err := configService.GetEventConfig(helper.TestData.Server)
 	tests.AssertNoError(t, err)