feat: add controller self-update mechanism (v0.16.0)

New selfupdate package: version parsing, audit state file, updater with Gitea registry V2 check, docker pull + compose rewrite + compose up flow. - API: /api/selfupdate/{status,check,update} with session+bearer auth - UI: Settings "Verzió és frissítés" card with check/install buttons + JS polling - Scheduler: periodic check (6h default) + optional daily auto-update - Notifications: success/failure on post-update startup verification - Alert: info banner when update available - docker-compose.yml: add directory bind mount for compose file access Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-02-19 17:33:40 +01:00
parent 1a58797dc8
commit c9a88afcef
14 changed files with 1074 additions and 22 deletions
@@ -13,6 +13,7 @@ import (
 	"gitea.dooplex.hu/admin/felhom-controller/internal/backup"
 	"gitea.dooplex.hu/admin/felhom-controller/internal/config"
 	"gitea.dooplex.hu/admin/felhom-controller/internal/metrics"
+	"gitea.dooplex.hu/admin/felhom-controller/internal/selfupdate"
 	"gitea.dooplex.hu/admin/felhom-controller/internal/settings"
 	"gitea.dooplex.hu/admin/felhom-controller/internal/stacks"
 	catalogsync "gitea.dooplex.hu/admin/felhom-controller/internal/sync"
@@ -29,11 +30,12 @@ type Router struct {
 	backupMgr        *backup.Manager
 	crossDriveRunner *backup.CrossDriveRunner
 	metricsStore     *metrics.MetricsStore
+	updater          *selfupdate.Updater
 	logger           *log.Logger
 }

-func NewRouter(cfg *config.Config, sett *settings.Settings, stackMgr *stacks.Manager, syncer *catalogsync.Syncer, cpuCollector *system.CPUCollector, backupMgr *backup.Manager, crossDrive *backup.CrossDriveRunner, metricsStore *metrics.MetricsStore, logger *log.Logger) *Router {
-	return &Router{cfg: cfg, sett: sett, stackMgr: stackMgr, syncer: syncer, cpuCollector: cpuCollector, backupMgr: backupMgr, crossDriveRunner: crossDrive, metricsStore: metricsStore, logger: logger}
+func NewRouter(cfg *config.Config, sett *settings.Settings, stackMgr *stacks.Manager, syncer *catalogsync.Syncer, cpuCollector *system.CPUCollector, backupMgr *backup.Manager, crossDrive *backup.CrossDriveRunner, metricsStore *metrics.MetricsStore, updater *selfupdate.Updater, logger *log.Logger) *Router {
+	return &Router{cfg: cfg, sett: sett, stackMgr: stackMgr, syncer: syncer, cpuCollector: cpuCollector, backupMgr: backupMgr, crossDriveRunner: crossDrive, metricsStore: metricsStore, updater: updater, logger: logger}
 }

 type apiResponse struct {
@@ -154,6 +156,18 @@ func (r *Router) ServeHTTP(w http.ResponseWriter, req *http.Request) {
 	case path == "/metrics/sysinfo" && req.Method == http.MethodGet:
 		r.metricsSysInfo(w, req)

+	// GET /api/selfupdate/status
+	case path == "/selfupdate/status" && req.Method == http.MethodGet:
+		r.selfupdateStatus(w, req)
+
+	// POST /api/selfupdate/check
+	case path == "/selfupdate/check" && req.Method == http.MethodPost:
+		r.selfupdateCheck(w, req)
+
+	// POST /api/selfupdate/update
+	case path == "/selfupdate/update" && req.Method == http.MethodPost:
+		r.selfupdateTrigger(w, req)
+
 	default:
 		writeJSON(w, http.StatusNotFound, apiResponse{OK: false, Error: "endpoint not found"})
 	}
@@ -779,6 +793,36 @@ func extractName(path, suffix string) string {
 	return name
 }

+func (r *Router) selfupdateStatus(w http.ResponseWriter, _ *http.Request) {
+	if r.updater == nil {
+		writeJSON(w, http.StatusOK, apiResponse{OK: true, Data: map[string]interface{}{"enabled": false}})
+		return
+	}
+	writeJSON(w, http.StatusOK, apiResponse{OK: true, Data: r.updater.GetStatus()})
+}
+
+func (r *Router) selfupdateCheck(w http.ResponseWriter, _ *http.Request) {
+	if r.updater == nil {
+		writeJSON(w, http.StatusBadRequest, apiResponse{OK: false, Error: "Self-update not configured"})
+		return
+	}
+	result := r.updater.CheckForUpdate()
+	writeJSON(w, http.StatusOK, apiResponse{OK: true, Data: result})
+}
+
+func (r *Router) selfupdateTrigger(w http.ResponseWriter, _ *http.Request) {
+	if r.updater == nil {
+		writeJSON(w, http.StatusBadRequest, apiResponse{OK: false, Error: "Self-update not configured"})
+		return
+	}
+	if err := r.updater.TriggerUpdate("manual"); err != nil {
+		writeJSON(w, http.StatusConflict, apiResponse{OK: false, Error: err.Error()})
+		return
+	}
+	r.logger.Println("[API] Manual self-update triggered")
+	writeJSON(w, http.StatusOK, apiResponse{OK: true, Message: "Frissítés elindítva"})
+}
+
 func writeJSON(w http.ResponseWriter, status int, v interface{}) {
 	w.Header().Set("Content-Type", "application/json")
 	w.WriteHeader(status)
@@ -118,6 +118,7 @@ type SelfUpdateConfig struct {
 	CheckInterval        string `yaml:"check_interval"`
 	Image                string `yaml:"image"`
 	AutoUpdate           bool   `yaml:"auto_update"`
+	AutoUpdateTime       string `yaml:"auto_update_time"`
 	HealthTimeoutSeconds int    `yaml:"health_timeout_seconds"`
 }

@@ -206,6 +207,8 @@ func applyDefaults(cfg *Config) {
 	di(&cfg.Monitoring.Thresholds.TemperatureWarnCelsius, 75)
 	d(&cfg.Hub.PushInterval, "15m")
 	d(&cfg.SelfUpdate.CheckInterval, "6h")
+	d(&cfg.SelfUpdate.Image, "gitea.dooplex.hu/admin/felhom-controller")
+	d(&cfg.SelfUpdate.AutoUpdateTime, "04:30")
 	di(&cfg.SelfUpdate.HealthTimeoutSeconds, 60)
 	d(&cfg.Logging.Level, "info")
 	di(&cfg.Logging.MaxSizeMB, 10)
@@ -242,6 +242,18 @@ func (n *Notifier) NotifyIntegrityFailed(message, details string) {
 	n.Notify("integrity_failed", "warning", message, details)
 }

+// NotifyUpdateSuccess sends a notification about a successful controller update.
+func (n *Notifier) NotifyUpdateSuccess(fromVer, toVer string) {
+	n.Notify("update_success", "info",
+		fmt.Sprintf("Controller frissítve: %s → %s", fromVer, toVer), "")
+}
+
+// NotifyUpdateFailed sends a notification about a failed controller update.
+func (n *Notifier) NotifyUpdateFailed(targetVer, errMsg string) {
+	n.Notify("update_failed", "warning",
+		fmt.Sprintf("Controller frissítés sikertelen: %s — %s", targetVer, errMsg), "")
+}
+
 // SendTest sends a test notification for verifying the notification flow.
 func (n *Notifier) SendTest() error {
 	if !n.enabled {
@@ -0,0 +1,71 @@
+package selfupdate
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"os"
+	"path/filepath"
+)
+
+const stateFileName = "update-state.json"
+
+// UpdateState tracks the last update attempt. Persisted to disk as audit log.
+type UpdateState struct {
+	Status          string `json:"status"`                   // "pending", "success", "failed"
+	PreviousVersion string `json:"previous_version"`
+	PreviousImage   string `json:"previous_image"`
+	TargetVersion   string `json:"target_version"`
+	TargetImage     string `json:"target_image"`
+	InitiatedAt     string `json:"initiated_at"`             // RFC3339
+	InitiatedBy     string `json:"initiated_by"`             // "manual" or "auto"
+	CompletedAt     string `json:"completed_at,omitempty"`
+	Error           string `json:"error,omitempty"`
+}
+
+// LoadState reads the update state file. Returns nil, nil if file doesn't exist.
+func LoadState(dataDir string) (*UpdateState, error) {
+	path := filepath.Join(dataDir, stateFileName)
+	data, err := os.ReadFile(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("reading state file: %w", err)
+	}
+
+	var state UpdateState
+	if err := json.Unmarshal(data, &state); err != nil {
+		return nil, fmt.Errorf("parsing state file: %w", err)
+	}
+	return &state, nil
+}
+
+// SaveState writes the state file atomically (write to .tmp, then rename).
+func SaveState(dataDir string, state *UpdateState) error {
+	path := filepath.Join(dataDir, stateFileName)
+	tmpPath := path + ".tmp"
+
+	data, err := json.MarshalIndent(state, "", "  ")
+	if err != nil {
+		return fmt.Errorf("marshaling state: %w", err)
+	}
+
+	if err := os.WriteFile(tmpPath, data, 0644); err != nil {
+		return fmt.Errorf("writing temp state file: %w", err)
+	}
+
+	if err := os.Rename(tmpPath, path); err != nil {
+		return fmt.Errorf("renaming state file: %w", err)
+	}
+
+	return nil
+}
+
+// ClearState removes the state file. Used for cleanup.
+func ClearState(dataDir string, logger *log.Logger) {
+	path := filepath.Join(dataDir, stateFileName)
+	if err := os.Remove(path); err != nil && !os.IsNotExist(err) {
+		logger.Printf("[WARN] Failed to clear update state file: %v", err)
+	}
+}
@@ -0,0 +1,417 @@
+package selfupdate
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"os/exec"
+	"regexp"
+	"strings"
+	"sync"
+	"time"
+
+	"gitea.dooplex.hu/admin/felhom-controller/internal/config"
+)
+
+// CheckResult holds the result of a version check.
+type CheckResult struct {
+	CurrentVersion  string `json:"current_version"`
+	LatestVersion   string `json:"latest_version"`
+	UpdateAvailable bool   `json:"update_available"`
+	Error           string `json:"error,omitempty"`
+	CheckedAt       string `json:"checked_at"`
+}
+
+// UpdateStatus is the complete status returned by the API.
+type UpdateStatus struct {
+	Running   bool         `json:"running"`
+	LastCheck *CheckResult `json:"last_check,omitempty"`
+	LastState *UpdateState `json:"last_state,omitempty"`
+}
+
+// Updater manages controller self-updates.
+type Updater struct {
+	cfg         *config.SelfUpdateConfig
+	gitCfg      *config.GitConfig
+	currentVer  string
+	dataDir     string
+	composePath string // e.g., "/opt/docker/felhom-controller/docker-compose.yml"
+	logger      *log.Logger
+
+	mu            sync.Mutex
+	latestVersion string
+	lastCheck     *CheckResult
+	updateRunning bool
+	backupRunning func() bool
+}
+
+// NewUpdater creates a new Updater instance.
+func NewUpdater(cfg *config.SelfUpdateConfig, gitCfg *config.GitConfig, currentVersion, dataDir, composePath string, logger *log.Logger) *Updater {
+	return &Updater{
+		cfg:         cfg,
+		gitCfg:      gitCfg,
+		currentVer:  currentVersion,
+		dataDir:     dataDir,
+		composePath: composePath,
+		logger:      logger,
+	}
+}
+
+// SetBackupRunningCheck sets the callback to check if a backup is in progress.
+func (u *Updater) SetBackupRunningCheck(fn func() bool) {
+	u.backupRunning = fn
+}
+
+// IsUpdateRunning returns true if an update is currently in progress.
+func (u *Updater) IsUpdateRunning() bool {
+	u.mu.Lock()
+	defer u.mu.Unlock()
+	return u.updateRunning
+}
+
+// GetStatus returns the current update status for API/UI.
+func (u *Updater) GetStatus() UpdateStatus {
+	u.mu.Lock()
+	lastCheck := u.lastCheck
+	running := u.updateRunning
+	u.mu.Unlock()
+
+	state, err := LoadState(u.dataDir)
+	if err != nil {
+		u.logger.Printf("[WARN] Failed to load update state: %v", err)
+	}
+
+	return UpdateStatus{
+		Running:   running,
+		LastCheck: lastCheck,
+		LastState: state,
+	}
+}
+
+// CheckForUpdate queries the Gitea registry for the latest version tag.
+// Caches the result. Thread-safe.
+func (u *Updater) CheckForUpdate() CheckResult {
+	result := CheckResult{
+		CurrentVersion: u.currentVer,
+		CheckedAt:      time.Now().UTC().Format(time.RFC3339),
+	}
+
+	// Dev version can't check for updates
+	currentVer, err := ParseVersion(u.currentVer)
+	if err != nil {
+		result.Error = "Dev verzió nem ellenőrizhető"
+		u.mu.Lock()
+		u.lastCheck = &result
+		u.mu.Unlock()
+		return result
+	}
+
+	// Query registry
+	latestStr, err := u.queryRegistry()
+	if err != nil {
+		result.Error = fmt.Sprintf("Registry lekérdezés sikertelen: %v", err)
+		u.logger.Printf("[WARN] Registry check failed: %v", err)
+		u.mu.Lock()
+		u.lastCheck = &result
+		u.mu.Unlock()
+		return result
+	}
+
+	result.LatestVersion = latestStr
+
+	latestVer, err := ParseVersion(latestStr)
+	if err != nil {
+		result.Error = fmt.Sprintf("Érvénytelen verzió a registry-ben: %s", latestStr)
+		u.mu.Lock()
+		u.lastCheck = &result
+		u.mu.Unlock()
+		return result
+	}
+
+	if latestVer.Compare(currentVer) > 0 {
+		result.UpdateAvailable = true
+	}
+
+	u.mu.Lock()
+	u.latestVersion = latestStr
+	u.lastCheck = &result
+	u.mu.Unlock()
+
+	return result
+}
+
+// queryRegistry queries the Gitea Docker Registry V2 API for available tags.
+// Returns the highest valid semver tag found.
+func (u *Updater) queryRegistry() (string, error) {
+	if u.gitCfg.Username == "" || u.gitCfg.Token == "" {
+		return "", fmt.Errorf("registry hitelesítő adatok hiányoznak")
+	}
+
+	// Gitea registry V2: GET /v2/<owner>/<repo>/tags/list
+	url := fmt.Sprintf("https://gitea.dooplex.hu/v2/%s/tags/list", registryImagePath(u.cfg.Image))
+
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return "", fmt.Errorf("creating request: %w", err)
+	}
+	req.SetBasicAuth(u.gitCfg.Username, u.gitCfg.Token)
+
+	client := &http.Client{Timeout: 15 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return "", fmt.Errorf("HTTP request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode == 401 {
+		return "", fmt.Errorf("authentication failed (401)")
+	}
+	if resp.StatusCode != 200 {
+		return "", fmt.Errorf("unexpected status: %d", resp.StatusCode)
+	}
+
+	var tagsResp struct {
+		Name string   `json:"name"`
+		Tags []string `json:"tags"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&tagsResp); err != nil {
+		return "", fmt.Errorf("decoding response: %w", err)
+	}
+
+	// Find highest semver tag
+	var highest *Version
+	for _, tag := range tagsResp.Tags {
+		v, err := ParseVersion(tag)
+		if err != nil {
+			continue // skip non-semver tags ("latest", "dev", etc.)
+		}
+		if highest == nil || v.Compare(*highest) > 0 {
+			highest = &v
+		}
+	}
+
+	if highest == nil {
+		return "", fmt.Errorf("no valid semver tags found")
+	}
+
+	return highest.String(), nil
+}
+
+// registryImagePath extracts the "owner/repo" from a full image reference.
+// e.g., "gitea.dooplex.hu/admin/felhom-controller" → "admin/felhom-controller"
+func registryImagePath(image string) string {
+	// Remove registry host
+	parts := strings.SplitN(image, "/", 2)
+	if len(parts) == 2 {
+		return parts[1]
+	}
+	return image
+}
+
+// imageName extracts the repo name from a full image reference.
+// e.g., "gitea.dooplex.hu/admin/felhom-controller" → "felhom-controller"
+func imageName(image string) string {
+	parts := strings.Split(image, "/")
+	return parts[len(parts)-1]
+}
+
+// TriggerUpdate starts the self-update process. Returns error immediately if
+// preconditions fail. The actual update runs in a goroutine.
+func (u *Updater) TriggerUpdate(initiatedBy string) error {
+	u.mu.Lock()
+	if u.updateRunning {
+		u.mu.Unlock()
+		return fmt.Errorf("Frissítés már folyamatban")
+	}
+
+	// Dev version check
+	if _, err := ParseVersion(u.currentVer); err != nil {
+		u.mu.Unlock()
+		return fmt.Errorf("Dev verzió nem frissíthető")
+	}
+
+	// Backup running check
+	if u.backupRunning != nil && u.backupRunning() {
+		u.mu.Unlock()
+		return fmt.Errorf("Mentés fut, próbálja később")
+	}
+
+	// Compose file accessible check
+	if _, err := os.Stat(u.composePath); err != nil {
+		u.mu.Unlock()
+		return fmt.Errorf("docker-compose.yml nem elérhető: %w", err)
+	}
+
+	u.updateRunning = true
+	u.mu.Unlock()
+
+	// Check for update (or use cached)
+	result := u.CheckForUpdate()
+	if !result.UpdateAvailable {
+		u.mu.Lock()
+		u.updateRunning = false
+		u.mu.Unlock()
+		return fmt.Errorf("Nincs elérhető frissítés")
+	}
+
+	targetVersion := result.LatestVersion
+	targetImage := fmt.Sprintf("%s:%s", u.cfg.Image, targetVersion)
+	previousImage := fmt.Sprintf("%s:%s", u.cfg.Image, u.currentVer)
+
+	u.logger.Printf("[INFO] Starting self-update: %s → %s (initiated by: %s)", u.currentVer, targetVersion, initiatedBy)
+
+	go u.performUpdate(targetVersion, targetImage, previousImage, initiatedBy)
+
+	return nil
+}
+
+// performUpdate runs the actual update steps in a goroutine.
+func (u *Updater) performUpdate(targetVersion, targetImage, previousImage, initiatedBy string) {
+	defer func() {
+		u.mu.Lock()
+		u.updateRunning = false
+		u.mu.Unlock()
+	}()
+
+	// 1. Write pending state
+	state := &UpdateState{
+		Status:          "pending",
+		PreviousVersion: u.currentVer,
+		PreviousImage:   previousImage,
+		TargetVersion:   targetVersion,
+		TargetImage:     targetImage,
+		InitiatedAt:     time.Now().UTC().Format(time.RFC3339),
+		InitiatedBy:     initiatedBy,
+	}
+	if err := SaveState(u.dataDir, state); err != nil {
+		u.logger.Printf("[ERROR] Failed to save update state: %v", err)
+		return
+	}
+
+	// 2. Docker pull
+	u.logger.Printf("[INFO] Pulling image: %s", targetImage)
+	pullOut, pullErr := runCommand("docker", "pull", targetImage)
+	if pullErr != nil {
+		state.Status = "failed"
+		state.Error = fmt.Sprintf("docker pull failed: %v — %s", pullErr, pullOut)
+		state.CompletedAt = time.Now().UTC().Format(time.RFC3339)
+		SaveState(u.dataDir, state)
+		u.logger.Printf("[ERROR] Docker pull failed: %v — %s", pullErr, pullOut)
+		return
+	}
+	u.logger.Printf("[INFO] Image pulled successfully: %s", targetImage)
+
+	// 3. Update compose file (replace image tag)
+	if err := u.updateComposeFile(targetImage); err != nil {
+		state.Status = "failed"
+		state.Error = fmt.Sprintf("compose update failed: %v", err)
+		state.CompletedAt = time.Now().UTC().Format(time.RFC3339)
+		SaveState(u.dataDir, state)
+		u.logger.Printf("[ERROR] Compose file update failed: %v", err)
+		return
+	}
+	u.logger.Printf("[INFO] Compose file updated with new image: %s", targetImage)
+
+	// 4. Docker compose up -d (this kills the current container)
+	u.logger.Printf("[INFO] Running docker compose up -d — container will restart")
+	composeDir := strings.TrimSuffix(u.composePath, "/docker-compose.yml")
+	upOut, upErr := runCommand("docker", "compose", "-f", u.composePath, "-p", "felhom-controller", "up", "-d")
+	if upErr != nil {
+		// If we get here, compose up failed but we already changed the image tag.
+		// Log the error — the state file remains "pending" for manual investigation.
+		u.logger.Printf("[ERROR] docker compose up -d failed: %v — %s (dir: %s)", upErr, upOut, composeDir)
+		return
+	}
+
+	// If we're still alive after compose up -d, log it.
+	// Normally this process should be killed when Docker replaces the container.
+	u.logger.Printf("[WARN] Still running after docker compose up -d — expected to be replaced")
+	time.Sleep(30 * time.Second)
+	u.logger.Printf("[WARN] Still alive 30s after docker compose up -d")
+}
+
+// updateComposeFile reads the compose file, replaces the image tag, and writes it back atomically.
+func (u *Updater) updateComposeFile(newImage string) error {
+	data, err := os.ReadFile(u.composePath)
+	if err != nil {
+		return fmt.Errorf("reading compose file: %w", err)
+	}
+
+	// Replace image line: "image: gitea.dooplex.hu/admin/felhom-controller:..." → new image
+	re := regexp.MustCompile(`(image:\s*)gitea\.dooplex\.hu/admin/felhom-controller:\S+`)
+	newData := re.ReplaceAll(data, []byte("${1}"+newImage))
+
+	if bytes.Equal(data, newData) {
+		return fmt.Errorf("no image line found to replace in compose file")
+	}
+
+	// Atomic write: write to .tmp, then rename
+	tmpPath := u.composePath + ".tmp"
+	if err := os.WriteFile(tmpPath, newData, 0644); err != nil {
+		return fmt.Errorf("writing temp compose file: %w", err)
+	}
+	if err := os.Rename(tmpPath, u.composePath); err != nil {
+		return fmt.Errorf("renaming compose file: %w", err)
+	}
+
+	return nil
+}
+
+// VerifyStartup checks the update state file on startup.
+// Called once from main.go before the scheduler starts.
+// Returns the state if a pending update was detected, nil otherwise.
+func (u *Updater) VerifyStartup() *UpdateState {
+	state, err := LoadState(u.dataDir)
+	if err != nil {
+		u.logger.Printf("[WARN] Failed to load update state on startup: %v — clearing", err)
+		ClearState(u.dataDir, u.logger)
+		return nil
+	}
+	if state == nil || state.Status != "pending" {
+		return nil
+	}
+
+	// Compare current version with target
+	currentVer, curErr := ParseVersion(u.currentVer)
+	targetVer, tgtErr := ParseVersion(state.TargetVersion)
+
+	if curErr != nil || tgtErr != nil {
+		state.Status = "failed"
+		state.Error = "Version parse error on startup verification"
+		state.CompletedAt = time.Now().UTC().Format(time.RFC3339)
+		SaveState(u.dataDir, state)
+		u.logger.Printf("[WARN] Post-update startup: version parse error (current=%s, target=%s)", u.currentVer, state.TargetVersion)
+		return state
+	}
+
+	if currentVer.Compare(targetVer) == 0 {
+		// Success — we're running the target version
+		state.Status = "success"
+		state.CompletedAt = time.Now().UTC().Format(time.RFC3339)
+		SaveState(u.dataDir, state)
+		u.logger.Printf("[INFO] Post-update startup: update successful (%s → %s)", state.PreviousVersion, state.TargetVersion)
+	} else {
+		// Version mismatch — update may have failed
+		state.Status = "failed"
+		state.Error = fmt.Sprintf("Version mismatch: expected %s, running %s", state.TargetVersion, u.currentVer)
+		state.CompletedAt = time.Now().UTC().Format(time.RFC3339)
+		SaveState(u.dataDir, state)
+		u.logger.Printf("[WARN] Post-update startup: version mismatch (expected %s, running %s)", state.TargetVersion, u.currentVer)
+	}
+
+	return state
+}
+
+// runCommand executes a command and returns combined stdout+stderr and error.
+func runCommand(name string, args ...string) (string, error) {
+	cmd := exec.Command(name, args...)
+	var out bytes.Buffer
+	cmd.Stdout = &out
+	cmd.Stderr = &out
+	err := cmd.Run()
+	return out.String(), err
+}
+
@@ -0,0 +1,68 @@
+package selfupdate
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// Version represents a semantic version (Major.Minor.Patch).
+type Version struct {
+	Major int
+	Minor int
+	Patch int
+	Raw   string
+}
+
+// ParseVersion parses "X.Y.Z" or "vX.Y.Z". Returns error for "dev", "latest", or invalid formats.
+func ParseVersion(s string) (Version, error) {
+	s = strings.TrimPrefix(s, "v")
+	if s == "dev" || s == "latest" || s == "" {
+		return Version{}, fmt.Errorf("invalid version: %q", s)
+	}
+	parts := strings.SplitN(s, ".", 3)
+	if len(parts) != 3 {
+		return Version{}, fmt.Errorf("invalid version format: %q (expected X.Y.Z)", s)
+	}
+	major, err := strconv.Atoi(parts[0])
+	if err != nil {
+		return Version{}, fmt.Errorf("invalid major version: %w", err)
+	}
+	minor, err := strconv.Atoi(parts[1])
+	if err != nil {
+		return Version{}, fmt.Errorf("invalid minor version: %w", err)
+	}
+	patch, err := strconv.Atoi(parts[2])
+	if err != nil {
+		return Version{}, fmt.Errorf("invalid patch version: %w", err)
+	}
+	return Version{Major: major, Minor: minor, Patch: patch, Raw: s}, nil
+}
+
+// Compare returns -1 if a < b, 0 if a == b, 1 if a > b.
+func (a Version) Compare(b Version) int {
+	if a.Major != b.Major {
+		if a.Major < b.Major {
+			return -1
+		}
+		return 1
+	}
+	if a.Minor != b.Minor {
+		if a.Minor < b.Minor {
+			return -1
+		}
+		return 1
+	}
+	if a.Patch != b.Patch {
+		if a.Patch < b.Patch {
+			return -1
+		}
+		return 1
+	}
+	return 0
+}
+
+// String returns the version as "X.Y.Z".
+func (v Version) String() string {
+	return fmt.Sprintf("%d.%d.%d", v.Major, v.Minor, v.Patch)
+}
@@ -40,7 +40,7 @@ func NewAlertManager(logger *log.Logger) *AlertManager {

 // Refresh regenerates alerts from the latest health check report and config state.
 // Called after each health check cycle (every 5 minutes).
-func (am *AlertManager) Refresh(report *monitor.HealthReport, cfg *config.Config, backupMgr *backup.Manager) {
+func (am *AlertManager) Refresh(report *monitor.HealthReport, cfg *config.Config, backupMgr *backup.Manager, updateAvailable bool, latestVersion string) {
 	var alerts []Alert

 	// From health check issues (critical)
@@ -97,6 +97,17 @@ func (am *AlertManager) Refresh(report *monitor.HealthReport, cfg *config.Config
 		})
 	}

+	// Update available
+	if updateAvailable && latestVersion != "" {
+		alerts = append(alerts, Alert{
+			ID:       "update-available",
+			Level:    "info",
+			Message:  fmt.Sprintf("Új controller verzió elérhető: %s", latestVersion),
+			Link:     "/settings",
+			LinkText: "Frissítés",
+		})
+	}
+
 	// Sort: errors first, then warnings, then info
 	sortAlerts(alerts)

@@ -906,6 +906,25 @@ func (s *Server) settingsData() map[string]interface{} {
 	data["MonitoringEnabled"] = s.cfg.Monitoring.Enabled
 	data["HealthchecksBase"] = s.cfg.Monitoring.HealthchecksBase
 	data["HubEnabled"] = s.cfg.Hub.Enabled
+
+	// Self-update status
+	data["SelfUpdateEnabled"] = s.cfg.SelfUpdate.Enabled
+	if s.updater != nil {
+		status := s.updater.GetStatus()
+		data["UpdateRunning"] = status.Running
+		if status.LastCheck != nil {
+			data["UpdateAvailable"] = status.LastCheck.UpdateAvailable
+			data["LatestVersion"] = status.LastCheck.LatestVersion
+			data["LastCheckTime"] = status.LastCheck.CheckedAt
+			data["LastCheckError"] = status.LastCheck.Error
+		}
+		if status.LastState != nil {
+			data["LastUpdateState"] = status.LastState
+		}
+		data["AutoUpdateEnabled"] = s.cfg.SelfUpdate.AutoUpdate
+		data["AutoUpdateTime"] = s.cfg.SelfUpdate.AutoUpdateTime
+	}
+
 	data["NotificationPrefs"] = s.settings.GetNotificationPrefs()

 	// Storage paths with display data
@@ -14,6 +14,7 @@ import (
 	"gitea.dooplex.hu/admin/felhom-controller/internal/config"
 	"gitea.dooplex.hu/admin/felhom-controller/internal/notify"
 	"gitea.dooplex.hu/admin/felhom-controller/internal/scheduler"
+	"gitea.dooplex.hu/admin/felhom-controller/internal/selfupdate"
 	"gitea.dooplex.hu/admin/felhom-controller/internal/settings"
 	"gitea.dooplex.hu/admin/felhom-controller/internal/stacks"
 	"gitea.dooplex.hu/admin/felhom-controller/internal/system"
@@ -29,6 +30,7 @@ type Server struct {
 	settings         *settings.Settings
 	alertManager     *AlertManager
 	notifier         *notify.Notifier
+	updater          *selfupdate.Updater
 	logger           *log.Logger
 	version          string
 	tmpl             *template.Template
@@ -49,7 +51,7 @@ type Server struct {
 	restorePlan *backup.RestorePlan
 }

-func NewServer(cfg *config.Config, stackMgr *stacks.Manager, cpuCollector *system.CPUCollector, backupMgr *backup.Manager, crossDrive *backup.CrossDriveRunner, sched *scheduler.Scheduler, sett *settings.Settings, alertMgr *AlertManager, notif *notify.Notifier, logger *log.Logger, version string) *Server {
+func NewServer(cfg *config.Config, stackMgr *stacks.Manager, cpuCollector *system.CPUCollector, backupMgr *backup.Manager, crossDrive *backup.CrossDriveRunner, sched *scheduler.Scheduler, sett *settings.Settings, alertMgr *AlertManager, notif *notify.Notifier, updater *selfupdate.Updater, logger *log.Logger, version string) *Server {
 	s := &Server{
 		cfg:              cfg,
 		stackMgr:         stackMgr,
@@ -60,6 +62,7 @@ func NewServer(cfg *config.Config, stackMgr *stacks.Manager, cpuCollector *syste
 		settings:         sett,
 		alertManager:     alertMgr,
 		notifier:         notif,
+		updater:          updater,
 		logger:           logger,
 		version:          version,
 		sessions:         make(map[string]*session),
@@ -56,13 +56,144 @@
            <span class="settings-label">Hub jelentés</span>
            <span class="settings-value">{{if .HubEnabled}}<span class="state-text-green">✅ Aktív</span>{{else}}–{{end}}</span>
        </div>
-        <div class="settings-row">
-            <span class="settings-label">Controller verzió</span>
-            <span class="settings-value mono">{{.Version}}</span>
-        </div>
    </div>
 </div>

+<!-- Section: Version & Update -->
+<div class="settings-card">
+    <h3>Verzió és frissítés</h3>
+    <div class="settings-grid">
+        <div class="settings-row">
+            <span class="settings-label">Jelenlegi verzió</span>
+            <span class="settings-value mono">{{.Version}}</span>
+        </div>
+        {{if .SelfUpdateEnabled}}
+        {{if .LatestVersion}}
+        <div class="settings-row">
+            <span class="settings-label">Legújabb verzió</span>
+            <span class="settings-value mono">
+                {{.LatestVersion}}
+                {{if .UpdateAvailable}}
+                <span class="state-text-green" style="margin-left:0.5em;">● Frissítés elérhető</span>
+                {{else}}
+                <span style="margin-left:0.5em; color:#888;">— naprakész</span>
+                {{end}}
+            </span>
+        </div>
+        {{end}}
+        {{if .LastCheckTime}}
+        <div class="settings-row">
+            <span class="settings-label">Utolsó ellenőrzés</span>
+            <span class="settings-value mono">{{.LastCheckTime}}</span>
+        </div>
+        {{end}}
+        {{if .LastCheckError}}
+        <div class="settings-row">
+            <span class="settings-label">Hiba</span>
+            <span class="settings-value state-text-red">{{.LastCheckError}}</span>
+        </div>
+        {{end}}
+        <div class="settings-row">
+            <span class="settings-label">Automatikus frissítés</span>
+            <span class="settings-value">
+                {{if .AutoUpdateEnabled}}<span class="state-text-green">✅ Aktív</span> <span class="mono">({{.AutoUpdateTime}})</span>{{else}}–{{end}}
+            </span>
+        </div>
+        {{with .LastUpdateState}}
+        <div class="settings-row">
+            <span class="settings-label">Utolsó frissítés</span>
+            <span class="settings-value">
+                {{if eq .Status "success"}}<span class="state-text-green">✅ Sikeres</span> ({{.PreviousVersion}} → {{.TargetVersion}})
+                {{else if eq .Status "failed"}}<span class="state-text-red">❌ Sikertelen</span> — {{.Error}}
+                {{else if eq .Status "pending"}}<span class="state-text-yellow">⏳ Folyamatban</span>
+                {{end}}
+            </span>
+        </div>
+        {{end}}
+        <div class="settings-row" style="padding-top: 0.5em;">
+            <span class="settings-label"></span>
+            <span class="settings-value">
+                <button class="btn btn-secondary btn-sm" id="btn-check-update" onclick="checkUpdate()">Frissítés keresése</button>
+                {{if .UpdateAvailable}}
+                <button class="btn btn-primary btn-sm" id="btn-trigger-update" onclick="triggerUpdate()" style="margin-left:0.5em;">Frissítés telepítése</button>
+                {{end}}
+                <span id="update-status-msg" style="margin-left:0.5em; display:none;"></span>
+            </span>
+        </div>
+        {{end}}
+    </div>
+</div>
+
+<script>
+function checkUpdate() {
+    var btn = document.getElementById('btn-check-update');
+    var msg = document.getElementById('update-status-msg');
+    btn.disabled = true;
+    btn.textContent = 'Ellenőrzés...';
+    msg.style.display = 'none';
+    fetch('/api/selfupdate/check', {method:'POST'})
+        .then(function(r) { return r.json(); })
+        .then(function(data) {
+            if (data.ok) {
+                location.reload();
+            } else {
+                msg.textContent = data.error || 'Hiba történt';
+                msg.style.display = 'inline';
+                btn.disabled = false;
+                btn.textContent = 'Frissítés keresése';
+            }
+        })
+        .catch(function() {
+            msg.textContent = 'Kapcsolódási hiba';
+            msg.style.display = 'inline';
+            btn.disabled = false;
+            btn.textContent = 'Frissítés keresése';
+        });
+}
+
+function triggerUpdate() {
+    if (!confirm('Biztosan frissíti a controllert?\n\nA folyamat alatt a vezérlőpult rövid időre elérhetetlenné válik.')) return;
+    var btn = document.getElementById('btn-trigger-update');
+    var checkBtn = document.getElementById('btn-check-update');
+    var msg = document.getElementById('update-status-msg');
+    btn.disabled = true;
+    btn.textContent = 'Frissítés...';
+    if (checkBtn) checkBtn.disabled = true;
+    msg.textContent = 'Frissítés folyamatban...';
+    msg.style.display = 'inline';
+    fetch('/api/selfupdate/update', {method:'POST'})
+        .then(function(r) { return r.json(); })
+        .then(function(data) {
+            if (data.ok) {
+                msg.textContent = 'Újraindulás...';
+                pollUntilBack();
+            } else {
+                msg.textContent = data.error || 'Hiba történt';
+                btn.disabled = false;
+                btn.textContent = 'Frissítés telepítése';
+                if (checkBtn) checkBtn.disabled = false;
+            }
+        })
+        .catch(function() {
+            msg.textContent = 'Kapcsolódási hiba';
+            pollUntilBack();
+        });
+}
+
+function pollUntilBack() {
+    var iv = setInterval(function() {
+        fetch('/api/health')
+            .then(function(r) {
+                if (r.ok) {
+                    clearInterval(iv);
+                    location.reload();
+                }
+            })
+            .catch(function() {});
+    }, 3000);
+}
+</script>
+
 <!-- Section: Storage Paths -->
 <div class="settings-card">
    <h3>Adattárolók</h3>