feat: complete SyncServer implementation

Full-stack Go monolith with embedded React frontend for orchestrating
rsync-over-SSH file synchronization with Wake-on-LAN support.

Features:
- JWT auth (HS256) with bcrypt password hashing
- CRUD for machines (with WoL config) and sync_pairs
- Ed25519 SSH key generation and known_hosts management
- WoL magic packet sender + TCP-connect waiter with backoff
- Sync engine: rsync subprocess, per-pair job queue, progress parsing
- Homebrew cron parser for scheduled syncs
- SSE stream for live job status (queued/waking_up/running/success/failed)
- React+TS+Vite+Tailwind SPA embedded via embed.FS
- Debian packaging with systemd unit, postinst/prerm/postrm

Tech stack:
- Go 1.22+ (CGO_ENABLED=0, pure SQLite via modernc.org/sqlite)
- chi router for HTTP API
- TypeScript + React 18 + Tailwind CSS frontend
- Cross-compiled to Linux amd64 for Proxmox LXC deployment

Tests: wol (MAC parsing, magic packet), syncengine/queue, scheduler/cron

internal/scheduler/scheduler.go

@@ -0,0 +1,95 @@
+package scheduler
+
+import (
+	"context"
+	"database/sql"
+	"log/slog"
+	"sync"
+	"time"
+
+	"github.com/syncserver/internal/config"
+	"github.com/syncserver/internal/models"
+	"github.com/syncserver/internal/syncengine"
+)
+
+type Scheduler struct {
+	db     *sql.DB
+	engine *syncengine.Engine
+	cfg    *config.Config
+	stopCh chan struct{}
+	wg     sync.WaitGroup
+}
+
+func New(database interface{ SQLDB() *sql.DB }, engine *syncengine.Engine, cfg *config.Config) *Scheduler {
+	return &Scheduler{
+		db:     database.SQLDB(),
+		engine: engine,
+		cfg:    cfg,
+		stopCh: make(chan struct{}),
+	}
+}
+
+func (s *Scheduler) Start() {
+	s.wg.Add(1)
+	go s.run()
+	slog.Info("scheduler started")
+}
+
+func (s *Scheduler) Stop() {
+	close(s.stopCh)
+	s.wg.Wait()
+	slog.Info("scheduler stopped")
+}
+
+func (s *Scheduler) run() {
+	defer s.wg.Done()
+	ticker := time.NewTicker(1 * time.Minute)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-s.stopCh:
+			return
+		case <-ticker.C:
+			s.tick()
+		}
+	}
+}
+
+func (s *Scheduler) tick() {
+	scheduleRepo := models.NewScheduleRepository(s.db)
+	now := time.Now().UTC()
+
+	schedules, err := scheduleRepo.GetEnabledDue(now)
+	if err != nil {
+		slog.Error("scheduler: failed to get due schedules", "error", err)
+		return
+	}
+
+	for _, sch := range schedules {
+		pairRepo := models.NewSyncPairRepository(s.db)
+		pair, err := pairRepo.GetByID(sch.SyncPairID)
+		if err != nil || !pair.Enabled {
+			continue
+		}
+
+		jobID, err := s.engine.CreateJob(sch.SyncPairID, "scheduled")
+		if err != nil {
+			slog.Error("scheduler: failed to create job", "schedule_id", sch.ID, "error", err)
+			continue
+		}
+
+		ctx := context.Background()
+		go func(jobID int64, pairID int64, schID int64) {
+			if err := s.engine.Run(ctx, jobID, pairID); err != nil {
+				slog.Warn("scheduler: job failed", "job_id", jobID, "error", err)
+			}
+
+			expr, _ := ParseCron(sch.CronExpr)
+			if expr != nil {
+				next := NextRun(expr, time.Now().UTC())
+				scheduleRepo.UpdateNextRun(schID, next)
+			}
+		}(jobID, sch.SyncPairID, sch.ID)
+	}
+}