feat: restore job history from saved files on startup (#440)

## Summary

- Adds automatic job history restoration from saved JSON files on
startup
- New config options: `restore-history` (default: true) and
`restore-history-max-age` (default: 24h)
- Respects per-job `history-limit` settings

## Problem

When Ofelia restarts (container recreation, host reboot, etc.), job
history displayed in the web UI is lost because it's stored only in
memory. However, if `save-folder` is configured, execution data is
already persisted to disk as JSON files but never read back.

## Solution

On startup, if `save-folder` is configured:
1. Scan the save folder for `*.json` files
2. Parse JSON to extract job name and execution data
3. Filter by age (files older than `restore-history-max-age` are
skipped)
4. Match executions to configured jobs by name
5. Populate job's in-memory history (respecting `history-limit`)

## New Configuration

```ini
[global]
restore-history = true           # default: true (when save-folder is set)
restore-history-max-age = 24h    # default: 24h
```

## Test plan

- [x] Unit tests for restoration logic
- [x] Tests for edge cases (invalid JSON, missing jobs, max age
filtering)
- [x] Tests for config option defaults
- [x] All existing tests pass
- [x] Linter passes

Closes #439
Relates to discussion #437

Author: CybotTM

cli/daemon.go

@@ -10,6 +10,7 @@ import (
 	"time"
 
 	"github.com/netresearch/ofelia/core"
+	"github.com/netresearch/ofelia/middlewares"
 	"github.com/netresearch/ofelia/web"
 )
 
@@ -98,6 +99,9 @@ func (c *DaemonCommand) boot() (err error) {
 	// Re-apply CLI/environment options so they override Docker labels
 	c.applyOptions(config)
 	c.scheduler = config.sh
+
+	// Restore job history from saved files if configured
+	c.restoreJobHistory(config)
 	c.dockerHandler = config.dockerHandler
 	c.config = config
 
@@ -355,6 +359,18 @@ func (c *DaemonCommand) applyServerDefaults(config *Config) {
 	}
 }
 
+// restoreJobHistory restores job history from saved files if configured.
+func (c *DaemonCommand) restoreJobHistory(config *Config) {
+	if !config.Global.SaveConfig.RestoreHistoryEnabled() {
+		return
+	}
+	saveFolder := config.Global.SaveConfig.SaveFolder
+	maxAge := config.Global.SaveConfig.GetRestoreHistoryMaxAge()
+	if err := middlewares.RestoreHistory(saveFolder, maxAge, c.scheduler.Jobs, c.Logger); err != nil {
+		c.Logger.Warningf("Failed to restore job history: %v", err)
+	}
+}
+
 func waitForServerWithErrChan(ctx context.Context, addr string, errChan <-chan error) error {
 	ticker := time.NewTicker(50 * time.Millisecond)
 	defer ticker.Stop()

config/validator.go

@@ -447,6 +447,7 @@ func (cv *Validator2) isOptionalField(path string) bool {
 	optionalFields := []string{
 		"smtp-user", "smtp-password", "email-to", "email-from",
 		"slack-webhook", "slack-channel", "save-folder",
+		"restore-history", "restore-history-max-age",
 		"container", "service", "image", "user", "network",
 		"environment", "secrets", "volumes", "working_dir",
 		"log-level", // Has default value "info"

middlewares/restore.go

@@ -0,0 +1,210 @@
+package middlewares
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/netresearch/ofelia/core"
+)
+
+// savedExecution represents the JSON structure saved by the Save middleware.
+// The JSON field names match the Save middleware's output format (PascalCase).
+//
+//nolint:tagliatelle // JSON format is defined by the Save middleware, must match exactly
+type savedExecution struct {
+	Job struct {
+		Name string `json:"Name"`
+	} `json:"Job"`
+	Execution struct {
+		ID        string        `json:"ID"`
+		Date      time.Time     `json:"Date"`
+		Duration  time.Duration `json:"Duration"`
+		IsRunning bool          `json:"IsRunning"`
+		Failed    bool          `json:"Failed"`
+		Skipped   bool          `json:"Skipped"`
+	} `json:"Execution"`
+}
+
+// restoredEntry holds a parsed execution ready for restoration.
+type restoredEntry struct {
+	JobName   string
+	Execution *core.Execution
+}
+
+// RestoreHistory restores job history from saved JSON files in the save folder.
+// It populates the in-memory history of jobs that support SetLastRun.
+// Only files newer than maxAge are restored.
+func RestoreHistory(saveFolder string, maxAge time.Duration, jobs []core.Job, logger core.Logger) error {
+	if saveFolder == "" {
+		return nil
+	}
+
+	// Validate save folder - skip silently if invalid
+	if DefaultSanitizer.ValidateSaveFolder(saveFolder) != nil {
+		return nil //nolint:nilerr // Intentionally skip invalid folders
+	}
+
+	// Check if folder exists
+	info, err := os.Stat(saveFolder)
+	if os.IsNotExist(err) {
+		logger.Debugf("Save folder %q does not exist, skipping history restoration", saveFolder)
+		return nil
+	}
+	if err != nil {
+		return fmt.Errorf("stat save folder: %w", err)
+	}
+	if !info.IsDir() {
+		return nil
+	}
+
+	// Build job lookup map
+	jobsByName := make(map[string]core.Job)
+	for _, job := range jobs {
+		jobsByName[job.GetName()] = job
+	}
+
+	// Find and parse JSON files
+	cutoff := time.Now().Add(-maxAge)
+	entries, err := parseHistoryFiles(saveFolder, cutoff, logger)
+	if err != nil {
+		logger.Warningf("Error scanning save folder: %v", err)
+		return nil // Don't fail startup for restore errors
+	}
+
+	if len(entries) == 0 {
+		logger.Debugf("No history files found to restore")
+		return nil
+	}
+
+	// Group entries by job name and sort by date
+	entriesByJob := make(map[string][]*restoredEntry)
+	for _, entry := range entries {
+		entriesByJob[entry.JobName] = append(entriesByJob[entry.JobName], entry)
+	}
+
+	restoredCount := 0
+	restoredJobCount := 0
+	for jobName, jobEntries := range entriesByJob {
+		job, exists := jobsByName[jobName]
+		if !exists {
+			logger.Debugf("Skipping history for unknown job %q", jobName)
+			continue
+		}
+
+		// Sort by date ascending (oldest first) so SetLastRun works correctly
+		sort.Slice(jobEntries, func(i, j int) bool {
+			return jobEntries[i].Execution.Date.Before(jobEntries[j].Execution.Date)
+		})
+
+		// Check if job supports SetLastRun
+		setter, ok := job.(interface{ SetLastRun(*core.Execution) })
+		if !ok {
+			logger.Debugf("Job %q does not support history restoration", jobName)
+			continue
+		}
+
+		// Restore each execution
+		for _, entry := range jobEntries {
+			setter.SetLastRun(entry.Execution)
+			restoredCount++
+		}
+		restoredJobCount++
+	}
+
+	if restoredCount > 0 {
+		logger.Noticef("Restored %d history entries for %d job(s) from saved files", restoredCount, restoredJobCount)
+	}
+
+	return nil
+}
+
+// parseHistoryFiles scans the save folder for JSON files and parses them.
+func parseHistoryFiles(saveFolder string, cutoff time.Time, logger core.Logger) ([]*restoredEntry, error) {
+	var entries []*restoredEntry
+
+	// Resolve save folder to absolute path for containment check
+	absSaveFolder, err := filepath.Abs(saveFolder)
+	if err != nil {
+		return nil, fmt.Errorf("resolve save folder: %w", err)
+	}
+
+	err = filepath.Walk(saveFolder, func(path string, info os.FileInfo, walkErr error) error {
+		if walkErr != nil {
+			return nil //nolint:nilerr // Intentionally skip inaccessible files
+		}
+
+		// Only process .json files
+		if info.IsDir() || !strings.HasSuffix(info.Name(), ".json") {
+			return nil
+		}
+
+		// Skip files older than cutoff based on modification time (quick filter)
+		if info.ModTime().Before(cutoff) {
+			return nil
+		}
+
+		// Verify path is within save folder (defense in depth for G304)
+		absPath, absErr := filepath.Abs(path)
+		if absErr != nil || !strings.HasPrefix(absPath, absSaveFolder) {
+			return nil //nolint:nilerr // Intentionally skip invalid paths
+		}
+
+		// Parse the JSON file
+		entry, err := parseHistoryFile(absPath)
+		if err != nil {
+			logger.Debugf("Skipping invalid history file %q: %v", path, err)
+			return nil
+		}
+
+		// Skip if execution date is too old
+		if entry.Execution.Date.Before(cutoff) {
+			return nil
+		}
+
+		entries = append(entries, entry)
+		return nil
+	})
+	if err != nil {
+		return entries, fmt.Errorf("walk save folder: %w", err)
+	}
+	return entries, nil
+}
+
+// parseHistoryFile reads and parses a single JSON history file.
+// The path is validated by parseHistoryFiles to be within the save folder.
+func parseHistoryFile(path string) (*restoredEntry, error) {
+	data, err := os.ReadFile(path) //#nosec G304 -- path is validated to be within save folder
+	if err != nil {
+		return nil, fmt.Errorf("read file: %w", err)
+	}
+
+	var saved savedExecution
+	if err := json.Unmarshal(data, &saved); err != nil {
+		return nil, fmt.Errorf("parse json: %w", err)
+	}
+
+	// Validate required fields
+	if saved.Job.Name == "" {
+		return nil, os.ErrInvalid
+	}
+
+	// Convert to core.Execution
+	exec := &core.Execution{
+		ID:        saved.Execution.ID,
+		Date:      saved.Execution.Date,
+		Duration:  saved.Execution.Duration,
+		IsRunning: false, // Never restore as running
+		Failed:    saved.Execution.Failed,
+		Skipped:   saved.Execution.Skipped,
+	}
+
+	return &restoredEntry{
+		JobName:   saved.Job.Name,
+		Execution: exec,
+	}, nil
+}