Restore: перевод бэкапов на восстановленный сервер

Раньше восстановленная копия получала конфиг и таймер агента со старым токеном
(через категории etc и units), и бэкапы шли с двух серверов одновременно.

- конфиг и юниты агента больше не бэкапятся
- в конце restore спрашивает, сделать ли сервер основным: сервер бэкапов
  выпускает новый токен (POST /api/v1/restore/takeover), restore ставит
  агента; токен старого сервера отозван — его агент получает отказ
- --takeover / --no-takeover; без них — вопрос (с --yes — да)
- уведомление «Сервер восстановлен» в ntfy/Telegram

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

.gitattributes

@@ -0,0 +1,2 @@
+* text=auto eol=lf
+*.sh text eol=lf

README.md

@@ -99,7 +99,14 @@ sudo systemctl reload caddy
 sudo -u backup-master BM_DATA=/var/lib/backup-master backupctl admin-passwd новый_логин
 ```
 
-**Обновление сервера:** снова выполните блок «бинарники», затем `sudo systemctl restart backup-master`. Агенты обновляются командой `curl -fsSL https://backup.ВАШ-ДОМЕН/agent.sh | sudo bash` без `--token`, конфиг при этом сохраняется.
+**Обновление.** Достаточно обновить сервер: снова выполните блок «бинарники», затем `sudo systemctl restart backup-master`. Агенты подтянутся сами при следующем бэкапе:
+
+- **каталог** агент каждый раз берёт с сервера — встроенный каталог сервера плюс переопределения клиента. Новые категории начинают работать без обновления агента;
+- **бинарник** — перед бэкапом агент сравнивает свою версию с версией сервера. Если серверная новее, он скачивает свой бинарник с того же сервера, сверяет sha256, проверяет, что новая версия запускается, подменяет файл и перезапускается. Если что-то не так, бэкап выполняет текущая версия, а в карточке клиента появляется предупреждение.
+
+Отставшие агенты подсвечены в списке клиентов. Автообновление можно выключить в карточке клиента — тогда агент обновляется вручную командой `curl -fsSL https://backup.ВАШ-ДОМЕН/agent.sh | sudo bash` без `--token`, конфиг при этом сохраняется. Разовый бэкап без обновления: `backupctl backup --no-update`.
+
+Сервер dev-сборки обновлений не раздаёт, откатов на более старую версию не бывает.
 
 ### Уведомления
 
@@ -151,18 +158,27 @@ curl -fsSL https://backup.example.com/restore.sh | sudo bash -s -- --token bm_..
 
 1. Показывается сводка бэкапа и запрашивается подтверждение.
 2. Базовая подготовка системы (`internal/restore/provision.sh`): пользователь с sudo, hostname, fail2ban, UFW, blocklist, SSH hardening. Docker, Caddy и Telegraf ставятся **тех же версий apt-пакетов**, если такие версии ещё есть в репозитории. Спрашиваются только логин и пароль пользователя.
-3. Распаковка: файлы ложатся на свои места, docker-тома — прямо в тома.
+3. Системные параметры старого сервера: часовой пояс (от него зависит время cron-заданий), swap-файл того же размера, вручную поставленные пакеты (`apt-mark showmanual`), если они есть в репозиториях.
-4. Категории восстанавливаются по порядку:
+4. Распаковка: файлы ложатся на свои места, docker-тома — прямо в тома.
+5. Категории восстанавливаются по порядку:
    - 3x-ui, Nebula и sing-box ставятся той версии, что была на старом сервере. Если скачать не получилось, используется копия бинарника из бэкапа;
    - база x-ui кладётся на место;
    - compose-проекты: образы закрепляются по digest (`compose.restore.yml`), базы поднимаются, в них заливаются дампы, затем запускается весь проект;
-   - systemd-сервисы включаются и запускаются так, как было на старом сервере.
+   - systemd-сервисы включаются и запускаются так, как было на старом сервере;
-5. В конце выводятся итог и список того, что осталось сделать: DNS, lighthouse, перезагрузка.
+   - sshd проверяется (`sshd -t`) и перезапускается со старым конфигом и ключами хоста;
+   - свои systemd-юниты включаются и запускаются как на старом сервере.
+6. Restore спрашивает, сделать ли новый сервер **основным для бэкапов**:
+   - **да** (по умолчанию) — сервер бэкапов выпускает клиенту новый токен, на новый сервер ставится агент. Токен старого сервера отзывается: если тот ещё жив, его агент получает отказ, и бэкапы шлёт только новый;
+   - **нет** (`--no-takeover`) — пробное восстановление: агент не ставится, основным остаётся старый сервер.
+
+   Конфиг и юниты самого агента в бэкап не попадают, поэтому восстановленная копия не начнёт слать бэкапы со старым токеном.
+7. В конце выводятся итог и список того, что осталось сделать: DNS, lighthouse, перезагрузка. Перезагрузка нужна в том числе для того, чтобы все сервисы перечитали восстановленные конфиги.
 
 Флаги:
 - `--backup ID` — конкретный бэкап;
 - `--skip-heavy` — без MinIO Stoat;
 - `--skip-provision` — повторный прогон без базовой подготовки;
+- `--takeover` / `--no-takeover` — сделать сервер основным для бэкапов или нет, не спрашивая;
 - `--user NAME`, `--yes`, `--keep-staging`.
 
 ## Что бэкапится
@@ -171,17 +187,32 @@ curl -fsSL https://backup.example.com/restore.sh | sudo bash -s -- --token bm_..
 
 | Категория | Что входит |
 |---|---|
-| system | правила UFW, все crontab (`/var/spool/cron/crontabs`), `ban-blacklist`, `/etc/sysctl.d` |
+| system | весь `/etc/ufw` и `/etc/default/ufw`, все crontab (`/var/spool/cron/crontabs`) и свои файлы `/etc/cron.d`, `/etc/sysctl.conf`, `/etc/sysctl.d`, `/etc/hosts`, `ban.sh` |
-| xui | `/etc/x-ui` (снимок базы через `VACUUM INTO`, без логина в панель), `/root/cert`, версия 3x-ui |
+| ssh | `sshd_config`, `sshd_config.d`, ключи хоста, `authorized_keys` root и пользователей |
+| certs | `/etc/letsencrypt`, `/root/.acme.sh` |
+| xui | `/etc/x-ui` (снимок базы через `VACUUM INTO`, без логина в панель), `/root/cert`, свои geo-файлы `/usr/local/x-ui/bin/*.dat` (ipcheck, discord и т.п., кроме штатных), сертификаты по путям из базы (панель, подписка, инбаунды), версия 3x-ui |
+| fail2ban | `jail.local`, `jail.d/` (в т.ч. `3x-ipl.local`), IP-лимит 3x-ui (`filter.d`/`action.d/3x-ipl.conf`), свои `*.local`; при восстановлении создаются логи `3xipl.log` |
 | nebula | `/etc/nebula`, юнит, версия |
-| caddy | `/etc/caddy`, `/var/www`, сертификаты |
+| caddy | `/etc/caddy`, `/var/www`, сертификаты; бинарник — если Caddy собран с плагинами |
-| telegraf | `/etc/telegraf`, sudoers |
+| telegraf | `/etc/telegraf`, sudoers, `/etc/default/telegraf` |
+| docker | `/etc/docker/daemon.json`, логины в registry (`/root/.docker/config.json`) |
 | sing-box-warp | `/opt/sing-box-warp`, `/etc/sing-box-warp`, юнит, sysctl, версия sing-box-extended |
 | scripts | `/var/scripts`, `update-geosite.sh` |
 | pnvpanel | `/opt/PnvPanel` целиком, кроме `pgdata`; `pg_dump`; том `ticket_uploads` |
 | stoat | `/opt/stoat`, кроме `data/db` и `data/rabbit`; `mongodump`; `data/minio` идёт отдельной heavy-частью раз в неделю |
 | stoat-mbot | `/opt/stoat-mbot` целиком, восстанавливается после stoat |
+| etc | страховка: изменённые конфиги любых пакетов (`dpkg` conffiles) и свои файлы в `/etc`, кроме привязанного к железу и облаку (сеть, диски, cloud-init, apt, загрузчик) |
 | psiphon | отключён |
+| units | свои systemd-юниты (не из пакетов) с состоянием enabled/active и drop-in переопределения `*.service.d` |
+
+Кроме файлов, в манифест записываются часовой пояс, swap и список вручную поставленных пакетов.
+
+Агент ищет то, что могло не попасть в бэкап, и показывает это в карточке клиента как предупреждения:
+- скрипты из crontab и программы из юнитов, которые не покрыты ни одной категорией;
+- каталоги в `/opt` и программы в `/usr/local/bin` и `/usr/local/sbin` без категории;
+- контейнеры, запущенные через `docker run`, а не через compose.
+
+Ненужное убирается глобальным `exclude` в конфиге клиента.
 
 Compose-проекты, которых нет в каталоге, находятся автоматически (`docker compose ls`). Они бэкапятся с настройками по умолчанию и помечаются в морде как «авто». Базы распознаются по образу (postgres, mongo, mysql, mariadb) и дампятся без остановки.
 

cmd/backupctl/main.go

@@ -34,7 +34,7 @@ const usage = `backupctl %s
   backupctl plan   [--config ...]     показать, что попадёт в бэкап
 
 Новый сервер:
-  backupctl restore --server URL --token TOKEN [--backup ID] [--skip-heavy] [--skip-provision]
+  backupctl restore --server URL --token TOKEN [--backup ID] [--skip-heavy] [--skip-provision] [--takeover|--no-takeover]
 
   backupctl version
 Флаги подкоманды: backupctl <команда> -h
@@ -99,6 +99,7 @@ func runServer(ctx context.Context, args []string) error {
 	maxGB := fs.Int64("max-upload-gb", 200, "максимальный размер одной части бэкапа, ГБ")
 	_ = fs.Parse(args)
 	cfg.MaxUpload = *maxGB << 30
+	cfg.Version = version
 	if cfg.PublicURL == "" {
 		log.Printf("ВНИМАНИЕ: --public-url не задан, адрес в командах установки берётся из запроса")
 	}
@@ -176,6 +177,7 @@ func runBackup(ctx context.Context, args []string) error {
 	fs := flag.NewFlagSet("backup", flag.ExitOnError)
 	o := agentFlags(fs)
 	fs.StringVar(&o.Output, "output", "", "записать части в каталог вместо отправки на сервер (отладка)")
+	fs.BoolVar(&o.NoUpdate, "no-update", false, "не обновлять агента, даже если сервер предлагает новую версию")
 	_ = fs.Parse(args)
 	return agent.Backup(ctx, *o)
 }
@@ -199,7 +201,17 @@ func runRestore(ctx context.Context, args []string) error {
 	fs.BoolVar(&o.Yes, "yes", false, "не спрашивать подтверждение")
 	fs.StringVar(&o.StagingDir, "staging", "", "каталог для временных файлов (по умолчанию /var/tmp/backup-restore)")
 	fs.BoolVar(&o.KeepStaging, "keep-staging", false, "не удалять временные файлы (дампы) после восстановления")
+	takeover := fs.Bool("takeover", false, "сделать этот сервер основным для бэкапов, не спрашивая (токен старого отзывается)")
+	noTakeover := fs.Bool("no-takeover", false, "пробное восстановление: агента не ставить, бэкапы продолжает слать старый сервер")
 	_ = fs.Parse(args)
+	switch {
+	case *takeover && *noTakeover:
+		return errors.New("--takeover и --no-takeover вместе не указываются")
+	case *takeover:
+		o.Takeover = restore.TakeoverYes
+	case *noTakeover:
+		o.Takeover = restore.TakeoverNo
+	}
 	if o.Server == "" {
 		return errors.New("нужен --server")
 	}

internal/agent/collect.go

@@ -93,14 +93,18 @@ func Collect(ctx context.Context, cat *catalog.Config, spool string, heavyDue bo
 	c.plan.Manifest.Parts = []string{manifest.MainPart}
 	c.fillSystem()
 
-	var composeSpecs []catalog.Spec
+	var composeSpecs, unitSpecs []catalog.Spec
 	for _, s := range cat.Categories {
 		if s.Disabled {
 			continue
 		}
-		if s.Type == catalog.TypeCompose {
+		switch s.Type {
+		case catalog.TypeCompose:
 			composeSpecs = append(composeSpecs, s)
 			continue
+		case catalog.TypeUnits:
+			unitSpecs = append(unitSpecs, s) // после остальных: им нужно знать, что уже покрыто
+			continue
 		}
 		mc, err := c.collectSpec(s)
 		if err != nil {
@@ -113,7 +117,13 @@ func Collect(ctx context.Context, cat *catalog.Config, spool string, heavyDue bo
 	if err := c.collectCompose(composeSpecs); err != nil {
 		return nil, err
 	}
+	for _, s := range unitSpecs {
+		if mc := c.collectUnits(s); mc != nil {
+			c.plan.Manifest.Categories = append(c.plan.Manifest.Categories, *mc)
+		}
+	}
 	c.checkCron()
+	c.checkCoverage()
 	return c.plan, nil
 }
 
@@ -139,6 +149,11 @@ func (c *collector) fillSystem() {
 		SSHHardened: sysx.Exists("/etc/ssh/sshd_config.d/00-hardening.conf"),
 	}
 	m.SudoUsers = sysx.GroupMembers("sudo")
+	m.Timezone = sysx.Timezone(c.ctx)
+	for p, size := range sysx.SwapFiles() {
+		m.Swap = append(m.Swap, manifest.SwapFile{Path: p, Size: size})
+	}
+	m.ManualPackages = sysx.ManualPackages(c.ctx)
 }
 
 // collectSpec обрабатывает категории files/systemd/xui. nil — категория неактивна.
@@ -155,13 +170,28 @@ func (c *collector) collectSpec(s catalog.Spec) (*manifest.Category, error) {
 		RestoreAfter: s.RestoreAfter,
 	}
 	skip := archive.NewMatcher(c.cat.Exclude, s.Exclude)
-	for _, p := range s.Paths {
+	for _, p := range expandPaths(s.Paths) {
 		if !sysx.Exists(p) {
 			continue
 		}
 		mc.Paths = append(mc.Paths, p)
 		c.add(manifest.MainPart, filesItem(s.Name, p, skip))
 	}
+	extra := c.unowned(s.Unowned)
+	if s.ModifiedConffiles {
+		extra = append(extra, sysx.ModifiedConffiles(c.ctx)...)
+	}
+	if len(extra) > 0 {
+		covered := c.covered() // то, что уже взяли другие категории, не дублируем
+		for _, p := range extra {
+			ps := filepath.ToSlash(p)
+			if archive.Covers(mc.Paths, ps) || archive.Covers(covered, ps) || skip.Match(ps) {
+				continue
+			}
+			mc.Paths = append(mc.Paths, p)
+			c.add(manifest.MainPart, filesItem(s.Name, p, skip))
+		}
+	}
 
 	if s.Type == catalog.TypeXUI {
 		if err := c.snapshotXUI(mc); err != nil {
@@ -177,7 +207,11 @@ func (c *collector) collectSpec(s catalog.Spec) (*manifest.Category, error) {
 		return nil, nil
 	}
 
-	for _, b := range s.KeepBinaries {
+	keepBins := s.KeepBinaries
+	if s.KeepBinariesIf != "" && sysx.Shell(c.ctx, s.KeepBinariesIf) != nil {
+		keepBins = nil
+	}
+	for _, b := range expandPaths(keepBins) {
 		if sysx.Exists(b) {
 			mc.Binaries = append(mc.Binaries, b)
 			c.add(manifest.MainPart, binItem(s.Name, b))
@@ -186,6 +220,15 @@ func (c *collector) collectSpec(s catalog.Spec) (*manifest.Category, error) {
 	if len(s.VersionCmd) > 0 && sysx.Exists(s.VersionCmd[0]) {
 		mc.Version = c.version(s)
 	}
+	if mc.Version == "" && s.Service != "" {
+		// сервис из apt-пакета с тем же именем (caddy, telegraf, docker → docker-ce)
+		for _, pkg := range []string{s.Service, s.Service + "-ce"} {
+			if v := c.plan.Manifest.Packages[pkg]; v != "" {
+				mc.Version = v
+				break
+			}
+		}
+	}
 	if s.Service != "" && sysx.UnitLoaded(c.ctx, s.Service) {
 		en, ac := sysx.UnitState(c.ctx, s.Service)
 		mc.Service = &manifest.ServiceState{Unit: s.Service, Enabled: en, Active: ac}
@@ -236,6 +279,52 @@ func (c *collector) cmdDump(cat string, d catalog.CmdDump, mc *manifest.Category
 	return nil
 }
 
+// expandPaths раскрывает маски (*, ?, [...]) в путях категории; пути без масок — как есть.
+func expandPaths(paths []string) []string {
+	var out []string
+	for _, p := range paths {
+		if !strings.ContainsAny(p, "*?[") {
+			out = append(out, p)
+			continue
+		}
+		m, _ := filepath.Glob(p)
+		out = append(out, m...)
+	}
+	return out
+}
+
+// unowned раскрывает маски и оставляет только обычные файлы, не принадлежащие пакетам.
+func (c *collector) unowned(patterns []string) []string {
+	var files []string
+	for _, p := range expandPaths(patterns) {
+		if fi, err := os.Lstat(p); err == nil && fi.Mode().IsRegular() {
+			files = append(files, p)
+		}
+	}
+	owned := sysx.DpkgOwned(c.ctx, files)
+	var out []string
+	for _, f := range files {
+		if !owned[f] {
+			out = append(out, f)
+		}
+	}
+	return out
+}
+
+// covered — все пути, которые уже попадают в бэкап (для проверок покрытия).
+func (c *collector) covered() []string {
+	var out []string
+	for _, mc := range c.plan.Manifest.Categories {
+		for _, p := range mc.Paths {
+			out = append(out, filepath.ToSlash(p))
+		}
+		for _, p := range mc.Binaries {
+			out = append(out, filepath.ToSlash(p))
+		}
+	}
+	return out
+}
+
 func anyExists(paths []string) bool {
 	for _, p := range paths {
 		if sysx.Exists(p) {

internal/agent/collect_test.go

@@ -0,0 +1,96 @@
+package agent
+
+import (
+	"os"
+	"path/filepath"
+	"slices"
+	"testing"
+
+	"gitea.hsrv.site/mrleo1nid/backup-master/internal/archive"
+	"gitea.hsrv.site/mrleo1nid/backup-master/internal/catalog"
+)
+
+func TestExpandPaths(t *testing.T) {
+	dir := t.TempDir()
+	for _, n := range []string{"ipcheck.dat", "geoip.dat", "x.txt"} {
+		if err := os.WriteFile(filepath.Join(dir, n), nil, 0o644); err != nil {
+			t.Fatal(err)
+		}
+	}
+	got := expandPaths([]string{filepath.Join(dir, "*.dat"), "/etc/x-ui", filepath.Join(dir, "*.none")})
+	want := []string{filepath.Join(dir, "geoip.dat"), filepath.Join(dir, "ipcheck.dat"), "/etc/x-ui"}
+	if !slices.Equal(got, want) {
+		t.Fatalf("expandPaths = %v, want %v", got, want)
+	}
+}
+
+// Свои geo-файлы попадают в бэкап, штатные из релиза 3x-ui — нет.
+func TestXUIGeoExcludes(t *testing.T) {
+	cat, err := catalog.Default()
+	if err != nil {
+		t.Fatal(err)
+	}
+	s := cat.Find("xui")
+	skip := archive.NewMatcher(cat.Exclude, s.Exclude)
+	cases := map[string]bool{
+		"/usr/local/x-ui/bin/ipcheck.dat":         false,
+		"/usr/local/x-ui/bin/discord-geosite.dat": false,
+		"/usr/local/x-ui/bin/geoip.dat":           true,
+		"/usr/local/x-ui/bin/geosite_RU.dat":      true,
+		"/usr/local/x-ui/bin/geoip_IR.dat":        true,
+		"/usr/local/x-ui/bin/ipcheck.dat.bak":     true,
+		"/etc/x-ui/x-ui.db":                       true,
+	}
+	for p, want := range cases {
+		if got := skip.Match(p); got != want {
+			t.Errorf("exclude(%s) = %v, want %v", p, got, want)
+		}
+	}
+	f2b := cat.Find("fail2ban")
+	if f2b == nil || !slices.Contains(f2b.Paths, "/etc/fail2ban/jail.d") || !slices.Contains(f2b.Paths, "/etc/fail2ban/filter.d/3x-ipl.conf") {
+		t.Fatalf("категория fail2ban: %+v", f2b)
+	}
+}
+
+func TestUnitExecPaths(t *testing.T) {
+	f := filepath.Join(t.TempDir(), "x.service")
+	unit := "[Service]\nExecStartPre=-/opt/app/prepare.sh --x\nExecStart=/usr/local/bin/app run\nExecReload=/bin/kill -HUP $MAINPID\nEnvironment=A=/tmp/x\n"
+	if err := os.WriteFile(f, []byte(unit), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	got := unitExecPaths(f)
+	want := []string{"/opt/app/prepare.sh", "/usr/local/bin/app", "/bin/kill"}
+	if !slices.Equal(got, want) {
+		t.Fatalf("unitExecPaths = %v, want %v", got, want)
+	}
+}
+
+func TestEtcCategoryExcludes(t *testing.T) {
+	cat, err := catalog.Default()
+	if err != nil {
+		t.Fatal(err)
+	}
+	s := cat.Find("etc")
+	if s == nil || !s.ModifiedConffiles {
+		t.Fatal("нет категории etc")
+	}
+	skip := archive.NewMatcher(cat.Exclude, s.Exclude)
+	for p, want := range map[string]bool{
+		"/etc/netplan/50-cloud-init.yaml":        true,
+		"/etc/apt/sources.list.d/ubuntu.sources": true,
+		"/etc/systemd/system/my.service":         true,
+		"/etc/fstab":                             true,
+		"/etc/wireguard/wg0.conf":                false,
+		"/etc/nginx/sites-available/site":        false,
+		"/etc/security/limits.conf":              false,
+		"/etc/systemd/journald.conf":             false,
+		"/etc/backup-agent/agent.yaml":           true,
+	} {
+		if got := skip.Match(p); got != want {
+			t.Errorf("etc exclude(%s) = %v, want %v", p, got, want)
+		}
+	}
+	if cat.Find("units") == nil || cat.Find("ssh") == nil || cat.Find("docker") == nil {
+		t.Fatal("нет категорий units/ssh/docker")
+	}
+}

internal/agent/reexec_other.go

@@ -0,0 +1,9 @@
+//go:build !unix
+
+package agent
+
+import "errors"
+
+func reexec(string, []string, []string) error {
+	return errors.New("самообновление поддерживается только на Linux")
+}

internal/agent/reexec_unix.go

@@ -0,0 +1,10 @@
+//go:build unix
+
+package agent
+
+import "syscall"
+
+// reexec заменяет текущий процесс новым бинарником (тот же PID, systemd не замечает).
+func reexec(exe string, args, env []string) error {
+	return syscall.Exec(exe, args, env)
+}

internal/agent/run.go

@@ -11,6 +11,7 @@ import (
 	"log"
 	"os"
 	"path/filepath"
+	"runtime"
 	"strings"
 	"time"
 
@@ -27,43 +28,73 @@ type Options struct {
 	Output string
 	// ForceHeavy — включить heavy-части независимо от расписания.
 	ForceHeavy bool
+	// NoUpdate — не обновлять агента, даже если сервер предлагает.
+	NoUpdate bool
 }
 
-// prepare загружает конфиг, получает переопределения с сервера и собирает план.
+// session — подключение к серверу и его ответ для одного запуска агента.
-func prepare(ctx context.Context, opts Options, spool string) (*Plan, *api.Client, error) {
+type session struct {
+	cfg    *Config
+	client *api.Client
+	remote *api.AgentConfig
+}
+
+// connect читает конфиг и спрашивает у сервера настройки (каталог, обновление).
+func connect(ctx context.Context, opts Options) (*session, error) {
 	cfg, err := LoadConfig(opts.ConfigPath)
 	if err != nil {
-		return nil, nil, err
+		return nil, err
 	}
 	client := api.NewClient(cfg.Server, cfg.Token)
-	remote, err := client.AgentConfig(ctx)
+	remote, err := client.AgentConfig(ctx, runtime.GOARCH, opts.AgentVersion)
 	if err != nil {
-		return nil, nil, fmt.Errorf("конфиг с сервера: %w", err)
+		return nil, fmt.Errorf("конфиг с сервера: %w", err)
+	}
+	return &session{cfg: cfg, client: client, remote: remote}, nil
+}
+
+// catalogFor выбирает каталог: итоговый с сервера, а если его нет (старый сервер)
+// или он не читается этой версией агента — встроенный + переопределения клиента.
+func catalogFor(remote *api.AgentConfig) (*catalog.Config, []string, error) {
+	var warns []string
+	if strings.TrimSpace(remote.CatalogYAML) != "" {
+		cat, err := catalog.Parse([]byte(remote.CatalogYAML))
+		if err == nil {
+			err = cat.Validate()
+		}
+		if err == nil {
+			return cat, nil, nil
+		}
+		warns = append(warns, fmt.Sprintf("каталог с сервера не подошёл этой версии агента (%v) — использую встроенный", err))
 	}
 	cat, err := catalog.Default()
 	if err != nil {
-		return nil, nil, err
+		return nil, warns, err
 	}
 	if strings.TrimSpace(remote.ConfigYAML) != "" {
 		over, err := catalog.Parse([]byte(remote.ConfigYAML))
 		if err != nil {
-			return nil, nil, fmt.Errorf("конфиг клиента с сервера: %w", err)
+			return nil, warns, fmt.Errorf("конфиг клиента с сервера: %w", err)
 		}
 		cat = catalog.Merge(cat, over)
 	}
-	if err := cat.Validate(); err != nil {
+	return cat, warns, cat.Validate()
-		return nil, nil, err
+}
-	}
+
-	if spool == "" {
+// prepare собирает план бэкапа по каталогу.
-		spool = cfg.SpoolDir
+func (s *session) prepare(ctx context.Context, opts Options, spool string, warns []string) (*Plan, error) {
-	}
+	cat, catWarns, err := catalogFor(s.remote)
-	plan, err := Collect(ctx, cat, spool, remote.HeavyDue || opts.ForceHeavy)
 	if err != nil {
-		return nil, nil, err
+		return nil, err
 	}
-	plan.Manifest.Domain = remote.Domain
+	plan, err := Collect(ctx, cat, spool, s.remote.HeavyDue || opts.ForceHeavy)
+	if err != nil {
+		return nil, err
+	}
+	plan.Manifest.Domain = s.remote.Domain
 	plan.Manifest.AgentVersion = opts.AgentVersion
-	return plan, client, nil
+	plan.Manifest.Warnings = append(append(warns, catWarns...), plan.Manifest.Warnings...)
+	return plan, nil
 }
 
 func newSpool(base string) (string, error) {
@@ -73,20 +104,24 @@ func newSpool(base string) (string, error) {
 
 // PrintPlan выводит, что попадёт в бэкап. Дампы БД при этом реально выполняются (во временный каталог).
 func PrintPlan(ctx context.Context, opts Options, w io.Writer) error {
-	cfg, err := LoadConfig(opts.ConfigPath)
+	sess, err := connect(ctx, opts)
 	if err != nil {
 		return err
 	}
-	spool, err := newSpool(cfg.SpoolDir)
+	spool, err := newSpool(sess.cfg.SpoolDir)
 	if err != nil {
 		return err
 	}
 	defer os.RemoveAll(spool)
-	plan, _, err := prepare(ctx, opts, spool)
+	plan, err := sess.prepare(ctx, opts, spool, nil)
 	if err != nil {
 		return err
 	}
 	m := &plan.Manifest
+	fmt.Fprintf(w, "Агент %s, сервер %s\n", opts.AgentVersion, sess.remote.ServerVersion)
+	if u := sess.remote.Update; u != nil {
+		fmt.Fprintf(w, "Доступно обновление агента до %s — установится при следующем бэкапе\n", u.Version)
+	}
 	fmt.Fprintf(w, "Домен: %s, hostname: %s, %s (%s)\n", m.Domain, m.Hostname, m.OS.PrettyName, m.OS.Arch)
 	if len(m.Packages) > 0 {
 		fmt.Fprintf(w, "Пакеты:")
@@ -161,18 +196,32 @@ func Backup(ctx context.Context, opts Options) (err error) {
 	}
 	defer unlock()
 
-	cfg, err := LoadConfig(opts.ConfigPath)
+	sess, err := connect(ctx, opts)
 	if err != nil {
 		return err
 	}
-	spool, err := newSpool(cfg.SpoolDir)
+	// Самообновление — до сбора: при успехе процесс перезапускается новой версией
+	// (exec не возвращается), при ошибке бэкап идёт текущей версией с предупреждением.
+	var warns []string
+	if u := sess.remote.Update; u != nil && !opts.NoUpdate && os.Getenv(updatedEnv) == "" {
+		log.Printf("обновление агента %s → %s", opts.AgentVersion, u.Version)
+		if err := selfUpdate(ctx, sess.client, u, opts.AgentVersion); err != nil {
+			log.Printf("! обновление не удалось: %v", err)
+			warns = append(warns, fmt.Sprintf("обновление агента до %s не удалось: %v", u.Version, err))
+		}
+	}
+	if from := os.Getenv(updatedEnv); from != "" {
+		log.Printf("агент обновлён: %s → %s", from, opts.AgentVersion)
+	}
+	client := sess.client
+	spool, err := newSpool(sess.cfg.SpoolDir)
 	if err != nil {
 		return err
 	}
 	defer os.RemoveAll(spool)
 
 	start := time.Now()
-	plan, client, err := prepare(ctx, opts, spool)
+	plan, err := sess.prepare(ctx, opts, spool, warns)
 	if err != nil {
 		return err
 	}

internal/agent/units.go

@@ -0,0 +1,139 @@
+package agent
+
+import (
+	"bufio"
+	"os"
+	"path/filepath"
+	"slices"
+	"strings"
+
+	"gitea.hsrv.site/mrleo1nid/backup-master/internal/archive"
+	"gitea.hsrv.site/mrleo1nid/backup-master/internal/catalog"
+	"gitea.hsrv.site/mrleo1nid/backup-master/internal/manifest"
+	"gitea.hsrv.site/mrleo1nid/backup-master/internal/sysx"
+)
+
+// collectUnits собирает свои systemd-юниты (не из пакетов и не описанные другими
+// категориями) вместе с состоянием enabled/active, а также drop-in каталоги *.d —
+// переопределения пакетных юнитов (например, docker.service.d/override.conf).
+func (c *collector) collectUnits(s catalog.Spec) *manifest.Category {
+	mc := &manifest.Category{Name: s.Name, Type: catalog.TypeUnits, PostRestore: s.PostRestore, RestoreAfter: s.RestoreAfter}
+	covered := c.covered()
+	services := map[string]bool{}
+	for _, cat := range c.plan.Manifest.Categories {
+		if cat.Service != nil {
+			services[cat.Service.Unit] = true
+		}
+	}
+	skip := archive.NewMatcher(c.cat.Exclude, s.Exclude)
+
+	for _, f := range c.unowned(s.Unowned) {
+		unit := filepath.Base(f)
+		name := strings.TrimSuffix(strings.TrimSuffix(unit, ".service"), ".timer")
+		// юниты самого агента не бэкапим: на новый сервер его ставит restore с новым токеном,
+		// иначе восстановленная копия слала бы бэкапы со старым токеном параллельно старому серверу
+		if strings.HasPrefix(unit, "backup-agent.") || archive.Covers(covered, filepath.ToSlash(f)) || services[name] || services[unit] {
+			continue
+		}
+		mc.Paths = append(mc.Paths, f)
+		c.add(manifest.MainPart, filesItem(s.Name, f, skip))
+		st := manifest.ServiceState{Unit: unit}
+		if sysx.UnitLoaded(c.ctx, unit) {
+			st.Enabled, st.Active = sysx.UnitState(c.ctx, unit)
+		}
+		mc.Units = append(mc.Units, st)
+		c.checkExec(unit, f, covered)
+	}
+	for _, d := range expandPaths(s.Paths) {
+		if fi, err := os.Stat(d); err != nil || !fi.IsDir() || archive.Covers(covered, filepath.ToSlash(d)) {
+			continue
+		}
+		mc.Paths = append(mc.Paths, d)
+		c.add(manifest.MainPart, filesItem(s.Name, d, skip))
+	}
+	if len(mc.Paths) == 0 {
+		return nil
+	}
+	return mc
+}
+
+// checkExec предупреждает, если юнит запускает программу, которая не попадает в бэкап
+// и не ставится пакетом: после восстановления такой сервис не стартует.
+func (c *collector) checkExec(unit, file string, covered []string) {
+	var missing []string
+	for _, p := range unitExecPaths(file) {
+		if archive.Covers(covered, p) || archive.Covers(systemBinDirs, p) || slices.Contains(missing, p) {
+			continue
+		}
+		if !sysx.Exists(p) {
+			continue
+		}
+		if sysx.DpkgOwned(c.ctx, []string{p})[p] {
+			continue
+		}
+		missing = append(missing, p)
+	}
+	for _, p := range missing {
+		c.warn("юнит %s запускает %s, но он не попадает в бэкап — добавьте путь в категорию", unit, p)
+	}
+}
+
+// unitExecPaths извлекает пути программ из Exec*= строк unit-файла.
+func unitExecPaths(file string) []string {
+	f, err := os.Open(file)
+	if err != nil {
+		return nil
+	}
+	defer f.Close()
+	var out []string
+	sc := bufio.NewScanner(f)
+	for sc.Scan() {
+		k, v, ok := strings.Cut(strings.TrimSpace(sc.Text()), "=")
+		if !ok || !strings.HasPrefix(k, "Exec") {
+			continue
+		}
+		// префиксы systemd: -, @, :, +, !
+		v = strings.TrimLeft(strings.TrimSpace(v), "-@:+!")
+		if fields := strings.Fields(v); len(fields) > 0 && strings.HasPrefix(fields[0], "/") {
+			out = append(out, fields[0])
+		}
+	}
+	return out
+}
+
+// checkCoverage ищет типичные места, где лежит что-то своё, не попавшее в бэкап:
+// каталоги в /opt, программы в /usr/local/bin и sbin, контейнеры без compose.
+func (c *collector) checkCoverage() {
+	covered := c.covered()
+	ignore := []string{"/opt/containerd", "/usr/local/bin/backupctl"}
+	for _, s := range c.cat.Categories {
+		if s.Disabled && s.Dir != "" {
+			ignore = append(ignore, filepath.ToSlash(s.Dir)) // отключено сознательно
+		}
+	}
+	check := func(pattern, what string) {
+		matches, _ := filepath.Glob(pattern)
+		for _, p := range matches {
+			ps := filepath.ToSlash(p)
+			if archive.Covers(covered, ps) || slices.Contains(ignore, ps) || c.global.Match(ps) {
+				continue
+			}
+			c.warn("%s %s не попадает в бэкап — добавьте его в категорию или в глобальный exclude, если он не нужен", what, p)
+		}
+	}
+	check("/opt/*", "каталог")
+	check("/usr/local/bin/*", "программа")
+	check("/usr/local/sbin/*", "программа")
+
+	if sysx.HasCommand("docker") {
+		out, err := sysx.Output(c.ctx, "docker", "ps", "--format", `{{.Names}}	{{.Label "com.docker.compose.project"}}`)
+		if err == nil {
+			for _, line := range strings.Split(out, "\n") {
+				name, project, _ := strings.Cut(line, "\t")
+				if name != "" && project == "" {
+					c.warn("контейнер %s запущен без docker compose (docker run) — его настройки и данные не бэкапятся", name)
+				}
+			}
+		}
+	}
+}

internal/agent/update.go

@@ -0,0 +1,106 @@
+package agent
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"gitea.hsrv.site/mrleo1nid/backup-master/internal/api"
+)
+
+// updatedEnv выставляется перезапущенному процессу: не обновляться повторно в том же запуске.
+const updatedEnv = "BM_UPDATED_FROM"
+
+// selfUpdate скачивает новую версию агента с того же сервера, сверяет sha256,
+// подменяет бинарник (старый сохраняется для отката) и перезапускает процесс.
+// При успехе не возвращается.
+func selfUpdate(ctx context.Context, client *api.Client, u *api.AgentUpdate, current string) error {
+	// только путь на своём сервере: чужой адрес от сервера не принимаем
+	if !strings.HasPrefix(u.Path, "/dl/") || strings.Contains(u.Path, "..") || strings.Contains(u.Path, "://") {
+		return fmt.Errorf("недопустимый путь обновления %q", u.Path)
+	}
+	if len(u.SHA256) != 64 {
+		return errors.New("сервер не прислал sha256")
+	}
+	exe, err := os.Executable()
+	if err != nil {
+		return err
+	}
+	if exe, err = filepath.EvalSymlinks(exe); err != nil {
+		return err
+	}
+
+	dctx, cancel := context.WithTimeout(ctx, 5*time.Minute)
+	defer cancel()
+	body, err := client.Download(dctx, u.Path)
+	if err != nil {
+		return fmt.Errorf("скачивание: %w", err)
+	}
+	defer body.Close()
+
+	tmp := exe + ".new"
+	if err := writeVerified(tmp, body, u.SHA256); err != nil {
+		os.Remove(tmp)
+		return err
+	}
+	// новый бинарник должен запускаться и сообщать ожидаемую версию
+	if err := checkVersion(ctx, tmp, u.Version); err != nil {
+		os.Remove(tmp)
+		return err
+	}
+
+	old := exe + ".old"
+	if err := os.Rename(exe, old); err != nil {
+		os.Remove(tmp)
+		return err
+	}
+	if err := os.Rename(tmp, exe); err != nil {
+		_ = os.Rename(old, exe)
+		return err
+	}
+	env := append(os.Environ(), updatedEnv+"="+current)
+	err = reexec(exe, os.Args, env)
+	// сюда попадаем, только если exec не удался — возвращаем старую версию
+	_ = os.Rename(old, exe)
+	return fmt.Errorf("перезапуск: %w", err)
+}
+
+func writeVerified(path string, r io.Reader, want string) error {
+	f, err := os.OpenFile(path, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0o755)
+	if err != nil {
+		return err
+	}
+	h := sha256.New()
+	if _, err := io.Copy(io.MultiWriter(f, h), r); err != nil {
+		f.Close()
+		return err
+	}
+	if err := f.Close(); err != nil {
+		return err
+	}
+	if got := hex.EncodeToString(h.Sum(nil)); got != want {
+		return fmt.Errorf("sha256 не совпал: %s, ожидался %s", got, want)
+	}
+	return os.Chmod(path, 0o755)
+}
+
+func checkVersion(ctx context.Context, bin, want string) error {
+	cctx, cancel := context.WithTimeout(ctx, 30*time.Second)
+	defer cancel()
+	out, err := exec.CommandContext(cctx, bin, "version").Output()
+	if err != nil {
+		return fmt.Errorf("новый бинарник не запускается: %w", err)
+	}
+	if !strings.Contains(string(out), want) {
+		return fmt.Errorf("новый бинарник сообщает версию %q, ожидалась %s", strings.TrimSpace(string(out)), want)
+	}
+	return nil
+}

internal/agent/update_test.go

@@ -0,0 +1,55 @@
+package agent
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"gitea.hsrv.site/mrleo1nid/backup-master/internal/api"
+)
+
+func TestSelfUpdateRejectsForeignPath(t *testing.T) {
+	for _, p := range []string{"https://evil.example/x", "/dl/../etc/passwd", "/api/v1/x"} {
+		err := selfUpdate(context.Background(), api.NewClient("http://127.0.0.1:1", "t"),
+			&api.AgentUpdate{Version: "v1.0.0", Path: p, SHA256: strings.Repeat("a", 64)}, "v0.1.0")
+		if err == nil || !strings.Contains(err.Error(), "недопустимый путь") {
+			t.Errorf("%s: %v", p, err)
+		}
+	}
+}
+
+func TestWriteVerified(t *testing.T) {
+	p := filepath.Join(t.TempDir(), "bin")
+	// sha256("abc")
+	good := "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+	if err := writeVerified(p, strings.NewReader("abc"), good); err != nil {
+		t.Fatal(err)
+	}
+	if err := writeVerified(p, strings.NewReader("abd"), good); err == nil {
+		t.Fatal("подменённый бинарник принят")
+	}
+	if _, err := os.Stat(p); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestCatalogFor(t *testing.T) {
+	cat, warns, err := catalogFor(&api.AgentConfig{CatalogYAML: "categories:\n  - {name: only, type: files, paths: [/x]}\n"})
+	if err != nil || len(warns) != 0 || cat.Find("only") == nil || cat.Find("xui") != nil {
+		t.Fatalf("каталог с сервера не применён: %v %v", err, warns)
+	}
+	// каталог, который эта версия не понимает, — встроенный + переопределения и предупреждение
+	cat, warns, err = catalogFor(&api.AgentConfig{
+		CatalogYAML: "categories:\n  - {name: x, type: future-type}\n",
+		ConfigYAML:  "categories:\n  - {name: scripts, disabled: true}\n",
+	})
+	if err != nil || len(warns) != 1 || cat.Find("xui") == nil || !cat.Find("scripts").Disabled {
+		t.Fatalf("запасной каталог: %v %v", err, warns)
+	}
+	// старый сервер без catalog_yaml
+	if cat, _, err := catalogFor(&api.AgentConfig{}); err != nil || cat.Find("xui") == nil {
+		t.Fatalf("встроенный каталог: %v", err)
+	}
+}

internal/agent/xui.go

@@ -5,9 +5,12 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"regexp"
 	"strings"
 
+	"gitea.hsrv.site/mrleo1nid/backup-master/internal/archive"
 	"gitea.hsrv.site/mrleo1nid/backup-master/internal/manifest"
+	"gitea.hsrv.site/mrleo1nid/backup-master/internal/sysx"
 
 	_ "modernc.org/sqlite"
 )
@@ -32,9 +35,63 @@ func (c *collector) snapshotXUI(mc *manifest.Category) error {
 	}
 	mc.Dumps = append(mc.Dumps, manifest.Dump{Name: "x-ui.db", Kind: "sqlite", Target: xuiDB})
 	c.add(manifest.MainPart, dumpItem(mc.Name, out, "x-ui.db"))
+
+	// сертификаты панели, подписки и инбаундов могут лежать где угодно — берём пути из базы
+	for _, p := range xuiCertPaths(out) {
+		if !sysx.Exists(p) {
+			c.warn("xui: в настройках указан %s, но файла нет", p)
+			continue
+		}
+		if archive.Covers(mc.Paths, filepath.ToSlash(p)) {
+			continue
+		}
+		mc.Paths = append(mc.Paths, p)
+		c.add(manifest.MainPart, filesItem(mc.Name, p, nil))
+	}
 	return nil
 }
 
+var certFileRe = regexp.MustCompile(`"(?:certificateFile|keyFile)"\s*:\s*"([^"]+)"`)
+
+// xuiCertPaths читает из снимка базы 3x-ui пути к сертификатам и ключам.
+func xuiCertPaths(dbPath string) []string {
+	db, err := sql.Open("sqlite", "file:"+dbPath+"?mode=ro")
+	if err != nil {
+		return nil
+	}
+	defer db.Close()
+	seen := map[string]bool{}
+	var out []string
+	addPath := func(p string) {
+		p = strings.TrimSpace(p)
+		if strings.HasPrefix(p, "/") && !seen[p] {
+			seen[p] = true
+			out = append(out, p)
+		}
+	}
+	if rows, err := db.Query(`SELECT value FROM settings WHERE key IN ('webCertFile','webKeyFile','subCertFile','subKeyFile')`); err == nil {
+		for rows.Next() {
+			var v string
+			if rows.Scan(&v) == nil {
+				addPath(v)
+			}
+		}
+		rows.Close()
+	}
+	if rows, err := db.Query(`SELECT stream_settings FROM inbounds`); err == nil {
+		for rows.Next() {
+			var v string
+			if rows.Scan(&v) == nil {
+				for _, m := range certFileRe.FindAllStringSubmatch(v, -1) {
+					addPath(m[1])
+				}
+			}
+		}
+		rows.Close()
+	}
+	return out
+}
+
 func vacuumInto(src, dst string) error {
 	_ = os.Remove(dst)
 	db, err := sql.Open("sqlite", "file:"+src+"?_pragma=busy_timeout(10000)")

internal/api/api.go

@@ -9,6 +9,7 @@ import (
 	"io"
 	"net"
 	"net/http"
+	"net/url"
 	"strings"
 	"time"
 
@@ -17,8 +18,20 @@ import (
 
 type AgentConfig struct {
 	Domain     string `json:"domain"`
-	ConfigYAML string `json:"config_yaml"`
+	ConfigYAML string `json:"config_yaml"` // только переопределения клиента (для старых агентов)
 	HeavyDue   bool   `json:"heavy_due"`
+	// CatalogYAML — итоговый каталог: встроенный каталог сервера + переопределения клиента.
+	// Агент берёт его вместо своего встроенного, поэтому новые категории приходят без обновления агента.
+	CatalogYAML   string       `json:"catalog_yaml,omitempty"`
+	ServerVersion string       `json:"server_version,omitempty"`
+	Update        *AgentUpdate `json:"update,omitempty"` // есть, если агенту пора обновиться
+}
+
+// AgentUpdate — новая версия агента. Path — путь на том же сервере (/dl/...), чужие адреса агент не принимает.
+type AgentUpdate struct {
+	Version string `json:"version"`
+	Path    string `json:"path"`
+	SHA256  string `json:"sha256"`
 }
 
 type PartInfo struct {
@@ -100,9 +113,38 @@ func jsonBody(v any) io.Reader {
 	return bytes.NewReader(data)
 }
 
-func (c *Client) AgentConfig(ctx context.Context) (*AgentConfig, error) {
+// AgentConfig запрашивает настройки агента; arch и version нужны серверу, чтобы предложить обновление.
+func (c *Client) AgentConfig(ctx context.Context, arch, version string) (*AgentConfig, error) {
 	var out AgentConfig
-	return &out, c.do(ctx, http.MethodGet, "/api/v1/agent/config", nil, &out)
+	q := url.Values{}
+	if arch != "" {
+		q.Set("arch", arch)
+	}
+	if version != "" {
+		q.Set("version", version)
+	}
+	path := "/api/v1/agent/config"
+	if len(q) > 0 {
+		path += "?" + q.Encode()
+	}
+	return &out, c.do(ctx, http.MethodGet, path, nil, &out)
+}
+
+// Download открывает поток файла с этого же сервера (path вида /dl/...).
+func (c *Client) Download(ctx context.Context, path string) (io.ReadCloser, error) {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, c.Server+path, nil)
+	if err != nil {
+		return nil, err
+	}
+	resp, err := c.HTTP.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	if resp.StatusCode != http.StatusOK {
+		resp.Body.Close()
+		return nil, &Error{Status: resp.StatusCode, Msg: resp.Status}
+	}
+	return resp.Body, nil
 }
 
 func (c *Client) CreateBackup(ctx context.Context, m *manifest.Manifest) (int64, error) {
@@ -159,3 +201,10 @@ func (c *Client) DownloadPart(ctx context.Context, id int64, name string, offset
 	}
 	return resp.Body, nil
 }
+
+// Takeover делает восстановленный сервер основным и возвращает новый агентский токен.
+func (c *Client) Takeover(ctx context.Context) (string, error) {
+	var out struct{ Token string }
+	err := c.do(ctx, http.MethodPost, "/api/v1/restore/takeover", nil, &out)
+	return out.Token, err
+}

internal/catalog/catalog.go

@@ -17,6 +17,8 @@ const (
 	TypeSystemd = "systemd"
 	TypeXUI     = "xui"
 	TypeCompose = "compose"
+	// TypeUnits — свои systemd-юниты (не из пакетов) с состоянием enabled/active.
+	TypeUnits = "units"
 )
 
 type Config struct {
@@ -33,12 +35,20 @@ type Spec struct {
 	Detect   []string `yaml:"detect,omitempty"` // категория активна, если существует хоть один путь
 	Paths    []string `yaml:"paths,omitempty"`
 	Exclude  []string `yaml:"exclude,omitempty"`
+	// Unowned — маски файлов, которые берутся, только если они не принадлежат
+	// ни одному пакету (dpkg -S): свои файлы в /etc/cron.d, /etc/systemd/system и т.п.
+	Unowned []string `yaml:"unowned,omitempty"`
+	// ModifiedConffiles — добавить конфиги пакетов, изменённые относительно поставки.
+	ModifiedConffiles bool `yaml:"modified_conffiles,omitempty"`
 
 	Service      string   `yaml:"service,omitempty"`
 	VersionCmd   []string `yaml:"version_cmd,omitempty"`
 	VersionRegex string   `yaml:"version_regex,omitempty"`
 	Install      string   `yaml:"install,omitempty"`       // recipe: nebula, xui, sing-box-extended
 	KeepBinaries []string `yaml:"keep_binaries,omitempty"` // fallback-копии бинарников
+	// KeepBinariesIf — shell-условие: keep_binaries берутся, только если оно истинно
+	// (например, Caddy собран с плагинами и из apt его не вернуть).
+	KeepBinariesIf string    `yaml:"keep_binaries_if,omitempty"`
 	EnsureDirs     []string  `yaml:"ensure_dirs,omitempty"`
 	PostRestore    []string  `yaml:"post_restore,omitempty"`
 	Dumps          []CmdDump `yaml:"dumps,omitempty"`
@@ -127,7 +137,7 @@ func (c *Config) Validate() error {
 			continue
 		}
 		switch s.Type {
-		case TypeFiles, TypeSystemd, TypeXUI:
+		case TypeFiles, TypeSystemd, TypeXUI, TypeUnits:
 		case TypeCompose:
 			if s.Dir == "" && s.Project == "" {
 				return fmt.Errorf("категория %q: для compose нужен dir или project", s.Name)

internal/catalog/default.yaml

@@ -10,26 +10,79 @@ categories:
   - name: system
     type: files
     paths:
-      - /etc/ufw/user.rules
+      - /etc/ufw # правила, before/after.rules (NAT, форвардинг), /etc/ufw/sysctl.conf
-      - /etc/ufw/user6.rules
+      - /etc/default/ufw
-      - /var/spool/cron/crontabs
+      - /var/spool/cron/crontabs # crontab root (sudo crontab -e) и пользователей
-      - /etc/cron.d/ban-blacklist
       - /usr/local/sbin/ban.sh
+      - /etc/sysctl.conf # BBR, форвардинг и прочие правки ядра
       - /etc/sysctl.d
+      - /etc/hosts
+    # свои задания в /etc/cron.d (пакетные пропускаются)
+    unowned: ["/etc/cron.d/*"]
     post_restore:
       - "ufw reload || true"
       - "sysctl --system >/dev/null || true"
 
+  # SSH: ключи входа, ключи хоста (клиенты не увидят «host key changed») и конфиг sshd
+  # (порт, запрет паролей). После распаковки sshd проверяется и перезапускается.
+  - name: ssh
+    type: files
+    paths:
+      - /etc/ssh/sshd_config
+      - /etc/ssh/sshd_config.d
+      - /etc/ssh/ssh_host_*
+      - /root/.ssh/authorized_keys
+      - /home/*/.ssh/authorized_keys
+    restore_after: [system]
+    post_restore:
+      - "sshd -t && systemctl daemon-reload && (systemctl restart ssh.socket 2>/dev/null; systemctl restart ssh) || echo '!!! sshd: конфиг не прошёл проверку, оставлен старый процесс — проверьте sshd -t'"
+
+  # сертификаты, выпущенные вне Caddy: certbot и acme.sh (его использует x-ui для SSL панели)
+  - name: certs
+    type: files
+    paths: [/etc/letsencrypt, /root/.acme.sh]
+
   - name: xui
     type: xui
     detect: [/usr/local/x-ui/x-ui]
-    paths: [/etc/x-ui, /root/cert]
+    paths:
-    exclude: ["/etc/x-ui/x-ui.db*"]
+      - /etc/x-ui
+      - /root/cert
+      # свои geo-файлы (ipcheck.dat, discord-*.dat и т.п.): на них ссылается роутинг,
+      # без них Xray не стартует; штатные geo*.dat приходят с релизом 3x-ui
+      - /usr/local/x-ui/bin/*.dat
+    exclude:
+      - "/etc/x-ui/x-ui.db*"
+      - "/usr/local/x-ui/bin/geoip.dat"
+      - "/usr/local/x-ui/bin/geosite.dat"
+      - "/usr/local/x-ui/bin/geo*_IR.dat"
+      - "/usr/local/x-ui/bin/geo*_RU.dat"
+      - "*.bak"
     service: x-ui
     version_cmd: [/usr/local/x-ui/x-ui, -v]
     install: xui
     keep_binaries: [/usr/local/x-ui, /usr/bin/x-ui, /etc/systemd/system/x-ui.service]
 
+  # fail2ban: свои jail'ы (jail.local, jail.d/*.local) и IP-лимит 3x-ui (3x-ipl).
+  # Штатные filter.d/action.d ставит пакет — берём только файлы 3x-ui и свои *.local.
+  - name: fail2ban
+    type: systemd
+    detect: [/etc/fail2ban]
+    paths:
+      - /etc/fail2ban/jail.local
+      - /etc/fail2ban/jail.d
+      - /etc/fail2ban/fail2ban.local
+      - /etc/fail2ban/fail2ban.conf # 3x-ui включает в нём allowipv6
+      - /etc/fail2ban/filter.d/3x-ipl.conf
+      - /etc/fail2ban/action.d/3x-ipl.conf
+      - /etc/fail2ban/filter.d/*.local
+      - /etc/fail2ban/action.d/*.local
+    service: fail2ban
+    restore_after: [system, xui]
+    post_restore:
+      # jail 3x-ipl читает лог x-ui: без файла fail2ban не поднимет jail
+      - "if ls /etc/fail2ban/jail.d/3x-ipl* >/dev/null 2>&1; then mkdir -p /var/log/x-ui && touch /var/log/x-ui/3xipl.log /var/log/x-ui/3xipl-banned.log; fi"
+
   - name: nebula
     type: systemd
     detect: [/etc/nebula]
@@ -44,13 +97,22 @@ categories:
     detect: [/etc/caddy/Caddyfile]
     paths: [/etc/caddy, /var/www, /var/lib/caddy/.local/share/caddy]
     service: caddy
+    # Caddy с плагинами (xcaddy, caddy add-package) из apt не вернуть — тогда бэкапим бинарник
+    keep_binaries: [/usr/bin/caddy]
+    keep_binaries_if: "caddy list-modules --packages 2>/dev/null | grep -Eq 'Non-standard modules: [1-9]'"
 
   - name: telegraf
     type: systemd
     detect: [/etc/telegraf]
-    paths: [/etc/telegraf, /etc/sudoers.d/telegraf]
+    paths: [/etc/telegraf, /etc/sudoers.d/telegraf, /etc/default/telegraf]
     service: telegraf
 
+  # настройки демона docker (логи, MTU, IPv6) и логины в приватные registry
+  - name: docker
+    type: systemd
+    paths: [/etc/docker/daemon.json, /root/.docker/config.json]
+    service: docker
+
   - name: sing-box-warp
     type: systemd
     detect: [/opt/sing-box-warp]
@@ -70,6 +132,45 @@ categories:
     type: files
     paths: [/var/scripts, /usr/local/bin/update-geosite.sh]
 
+  # Страховка: всё своё в /etc, не описанное выше, — изменённые конфиги любых пакетов
+  # (dpkg conffiles: nginx, limits.conf, journald и т.п.) и файлы, не принадлежащие
+  # ни одному пакету (ключи wireguard, свои конфиги). Привязанное к железу и облаку
+  # (сеть, диски, cloud-init, зеркала apt, загрузчик) исключено — на новом VPS оно своё.
+  - name: etc
+    type: files
+    modified_conffiles: true
+    unowned: ["/etc/*/*", "/etc/*/*/*"]
+    exclude:
+      - /etc/netplan
+      - /etc/network
+      - /etc/NetworkManager
+      - /etc/systemd/network
+      - /etc/systemd/system # юниты собирает категория units
+      - /etc/cloud
+      - /etc/landscape
+      - /etc/ubuntu-advantage
+      - /etc/apt
+      - /etc/udev
+      - /etc/fstab
+      - /etc/default/grub
+      - /etc/default/grub.d
+      - /etc/initramfs-tools
+      - /etc/iscsi
+      - /etc/lvm
+      - /etc/mdadm
+      - /etc/multipath
+      - /etc/dhcp
+      - /etc/alternatives
+      - /etc/apparmor.d/cache
+      - /etc/ssl/certs
+      - /etc/ssl/private/ssl-cert-snakeoil.key
+      - /etc/sudoers.d/90-cloud-init-users
+      - /etc/machine-id
+      - /etc/hostname
+      - /etc/resolv.conf
+      # свой агент не бэкапим: на новый сервер его ставит restore с новым токеном
+      - /etc/backup-agent
+
   - name: pnvpanel
     type: compose
     dir: /opt/PnvPanel
@@ -89,3 +190,10 @@ categories:
     type: compose
     dir: /opt/psiphon
     disabled: true
+
+  # Свои systemd-юниты, не описанные выше и не из пакетов, — с состоянием enabled/active,
+  # и drop-in переопределения пакетных юнитов (*.service.d/override.conf).
+  - name: units
+    type: units
+    unowned: ["/etc/systemd/system/*.service", "/etc/systemd/system/*.timer"]
+    paths: ["/etc/systemd/system/*.service.d", "/etc/systemd/system/*.timer.d"]

internal/manifest/manifest.go

@@ -20,6 +20,10 @@ type Manifest struct {
 	Packages      map[string]string `json:"packages,omitempty"` // apt-пакет → точная версия dpkg
 	Features      Features          `json:"features"`
 	SudoUsers     []string          `json:"sudo_users,omitempty"`
+	Timezone      string            `json:"timezone,omitempty"`
+	Swap          []SwapFile        `json:"swap,omitempty"`
+	// ManualPackages — пакеты, поставленные вручную (apt-mark showmanual): restore доставит недостающие.
+	ManualPackages []string   `json:"manual_packages,omitempty"`
 	Categories     []Category `json:"categories"`
 	Parts          []string   `json:"parts"` // main + heavy-части, вошедшие в этот бэкап
 	Warnings       []string   `json:"warnings,omitempty"`
@@ -45,6 +49,7 @@ type Category struct {
 	Version      string         `json:"version,omitempty"`
 	Install      string         `json:"install,omitempty"` // recipe установки бинарника
 	Service      *ServiceState  `json:"service,omitempty"`
+	Units        []ServiceState `json:"units,omitempty"`    // тип units: свои systemd-юниты и их состояние
 	Paths        []string       `json:"paths,omitempty"`    // абсолютные пути в <cat>/files/
 	Binaries     []string       `json:"binaries,omitempty"` // абсолютные пути в <cat>/bin/ (fallback)
 	Dumps        []Dump         `json:"dumps,omitempty"`
@@ -57,6 +62,11 @@ type Category struct {
 	RestoreAfter []string       `json:"restore_after,omitempty"`
 }
 
+type SwapFile struct {
+	Path string `json:"path"`
+	Size int64  `json:"size"` // байт
+}
+
 type ServiceState struct {
 	Unit    string `json:"unit"`
 	Enabled bool   `json:"enabled"`

internal/restore/provision.sh

@@ -189,7 +189,8 @@ ok "$(iptables --version)"
 
 # ---------- 5. Fail2ban ----------
 step "5. Fail2ban"
-apt_install fail2ban python3-systemd
+# nftables: штатный banaction fail2ban в Ubuntu 24.04 — nftables, без nft jail sshd не банит
+apt_install fail2ban python3-systemd nftables
 IGNORE_IP="127.0.0.1/8 ::1 192.168.0.0/16 10.0.0.0/8"
 if [[ -n $CLIENT_IP ]]; then
   IGNORE_IP+=" $CLIENT_IP"

internal/restore/recipes.go

@@ -44,7 +44,8 @@ func installXUI(ctx context.Context, version, arch string) error {
 		v = "v" + v
 	}
 	url := fmt.Sprintf("https://github.com/MHSanaei/3x-ui/releases/download/%s/x-ui-linux-%s.tar.gz", v, arch)
-	_ = os.RemoveAll("/usr/local/x-ui")
+	// каталог не очищаем: в нём уже лежат восстановленные свои geo-файлы (ipcheck.dat и т.п.),
+	// архив релиза перезапишет только свои файлы
 	if err := fetchTarGz(ctx, url, func(name string) (string, bool) {
 		name = strings.TrimPrefix(name, "./")
 		if !strings.HasPrefix(name, "x-ui/") && name != "x-ui" {

internal/restore/restore.go

@@ -40,6 +40,7 @@ type Options struct {
 	Yes           bool // не спрашивать подтверждение
 	StagingDir    string
 	KeepStaging   bool
+	Takeover      string // TakeoverAsk / TakeoverYes / TakeoverNo
 }
 
 type restorer struct {
@@ -106,6 +107,7 @@ func Run(ctx context.Context, opts Options) error {
 			return fmt.Errorf("подготовка сервера: %w", err)
 		}
 	}
+	r.restoreSystem()
 	if err := r.prepareVolumes(); err != nil {
 		return err
 	}
@@ -155,6 +157,7 @@ func Run(ctx context.Context, opts Options) error {
 			failed = append(failed, c.Name)
 		}
 	}
+	r.takeover()
 	r.finish(failed)
 	if len(failed) > 0 {
 		return fmt.Errorf("с ошибками восстановлены категории: %s", strings.Join(failed, ", "))
@@ -192,6 +195,17 @@ func (r *restorer) summary(rm *api.RestoreManifest) {
 	info("части: %s", strings.Join(parts, ", "))
 }
 
+// confirmDefaultYes — вопрос, где пустой ответ означает «да».
+func confirmDefaultYes(q string) bool {
+	fmt.Printf("\n%s? [Y/n]: ", q)
+	line, _ := bufio.NewReader(os.Stdin).ReadString('\n')
+	switch strings.ToLower(strings.TrimSpace(line)) {
+	case "", "y", "yes", "д", "да":
+		return true
+	}
+	return false
+}
+
 func confirm(q string) bool {
 	fmt.Printf("\n%s? [y/N]: ", q)
 	line, _ := bufio.NewReader(os.Stdin).ReadString('\n')
@@ -403,6 +417,13 @@ func (r *restorer) restoreCategory(c manifest.Category) error {
 		if err := r.restoreCompose(c); err != nil {
 			return err
 		}
+	case catalog.TypeUnits:
+		_ = sysx.Run(r.ctx, "systemctl", "daemon-reload")
+		for i := range c.Units {
+			if err := r.applyService(&c.Units[i]); err != nil {
+				r.warn("%s: %v", c.Name, err)
+			}
+		}
 	}
 	if c.Name == "system" {
 		r.fixCrontabs()

internal/restore/system.go

@@ -0,0 +1,113 @@
+package restore
+
+import (
+	"fmt"
+	"os"
+	"regexp"
+	"strings"
+
+	"gitea.hsrv.site/mrleo1nid/backup-master/internal/sysx"
+)
+
+// restoreSystem повторяет системные параметры старого сервера: часовой пояс
+// (от него зависит время cron-заданий), swap-файл и вручную поставленные пакеты.
+func (r *restorer) restoreSystem() {
+	step("Системные параметры")
+	r.restoreTimezone()
+	r.restoreSwap()
+	r.restorePackages()
+}
+
+func (r *restorer) restoreTimezone() {
+	tz := r.m.Timezone
+	if tz == "" {
+		return
+	}
+	if cur := sysx.Timezone(r.ctx); cur == tz {
+		info("часовой пояс %s — как на старом сервере", tz)
+		return
+	}
+	if err := sysx.Run(r.ctx, "timedatectl", "set-timezone", tz); err != nil {
+		r.warn("часовой пояс %s не установлен: %v", tz, err)
+		return
+	}
+	info("часовой пояс: %s", tz)
+}
+
+func (r *restorer) restoreSwap() {
+	if len(r.m.Swap) == 0 {
+		return
+	}
+	if len(sysx.SwapFiles()) > 0 {
+		info("swap уже есть — не трогаю")
+		return
+	}
+	if out, _ := sysx.Output(r.ctx, "swapon", "--show", "--noheadings"); out != "" {
+		info("swap уже есть (раздел) — не трогаю")
+		return
+	}
+	for _, sw := range r.m.Swap {
+		if sysx.Exists(sw.Path) {
+			r.warn("swap: %s уже существует, но не подключён — пропускаю", sw.Path)
+			continue
+		}
+		mb := sw.Size / (1 << 20)
+		script := fmt.Sprintf(`set -e
+fallocate -l %dM %[2]q || dd if=/dev/zero of=%[2]q bs=1M count=%[1]d status=none
+chmod 600 %[2]q
+mkswap %[2]q >/dev/null
+swapon %[2]q
+grep -qF %[2]q /etc/fstab || echo %[3]q >> /etc/fstab`, mb, sw.Path, sw.Path+" none swap sw 0 0")
+		if err := sysx.Shell(r.ctx, script); err != nil {
+			r.warn("swap %s: %v", sw.Path, err)
+			continue
+		}
+		info("swap %s, %d МБ", sw.Path, mb)
+	}
+}
+
+// Пакеты ядра конкретных версий и метапакеты облачных образов ставить не нужно.
+var skipPackageRe = regexp.MustCompile(`^linux-(image|headers|modules|tools|cloud-tools|hwe)-\d|^linux-(image|headers|modules)-extra`)
+
+func (r *restorer) restorePackages() {
+	if len(r.m.ManualPackages) == 0 {
+		return
+	}
+	installed := map[string]bool{}
+	if out, err := sysx.Output(r.ctx, "dpkg-query", "-W", "-f=${Package} ${db:Status-Status}\n"); err == nil {
+		for _, line := range strings.Split(out, "\n") {
+			if name, st, ok := strings.Cut(line, " "); ok && st == "installed" {
+				installed[name] = true
+			}
+		}
+	}
+	available := map[string]bool{}
+	if out, err := sysx.Output(r.ctx, "apt-cache", "pkgnames"); err == nil {
+		for _, n := range strings.Fields(out) {
+			available[n] = true
+		}
+	}
+	var install, missing []string
+	for _, p := range r.m.ManualPackages {
+		name, _, _ := strings.Cut(p, ":") // pkg:amd64
+		if installed[name] || skipPackageRe.MatchString(name) {
+			continue
+		}
+		if available[name] {
+			install = append(install, name)
+		} else {
+			missing = append(missing, name)
+		}
+	}
+	if len(install) > 0 {
+		info("доустанавливаю пакеты со старого сервера: %s", strings.Join(install, " "))
+		_ = os.Setenv("DEBIAN_FRONTEND", "noninteractive")
+		args := append([]string{"install", "-y", "-q", "-o", "Dpkg::Options::=--force-confdef", "-o", "Dpkg::Options::=--force-confold"}, install...)
+		if err := sysx.Run(r.ctx, "apt-get", args...); err != nil {
+			r.warn("часть пакетов не установилась: %v", err)
+		}
+	}
+	if len(missing) > 0 {
+		r.warn("пакетов нет в репозиториях этого сервера (ставились из своих репозиториев или .deb): %s", strings.Join(missing, " "))
+	}
+}

internal/restore/takeover.go

@@ -0,0 +1,98 @@
+package restore
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"strings"
+
+	"gitea.hsrv.site/mrleo1nid/backup-master/internal/sysx"
+)
+
+const (
+	agentConfigPath = "/etc/backup-agent/agent.yaml"
+
+	agentService = `[Unit]
+Description=backup-master agent
+Wants=network-online.target
+After=network-online.target docker.service
+
+[Service]
+Type=oneshot
+ExecStart=/usr/local/bin/backupctl backup
+Nice=10
+IOSchedulingClass=idle
+TimeoutStartSec=6h
+`
+	agentTimer = `[Unit]
+Description=Ежедневный бэкап backup-master
+
+[Timer]
+OnCalendar=*-*-* 03:00:00
+RandomizedDelaySec=30m
+Persistent=true
+
+[Install]
+WantedBy=timers.target
+`
+)
+
+// Takeover — делать ли восстановленный сервер основным для бэкапов.
+const (
+	TakeoverAsk = ""
+	TakeoverYes = "yes"
+	TakeoverNo  = "no"
+)
+
+// takeover переводит бэкапы клиента на этот сервер: сервер бэкапов выпускает новый
+// токен (старый отзывается — агент старого сервера получит отказ) и здесь ставится агент.
+func (r *restorer) takeover() {
+	mode := r.opts.Takeover
+	if mode == TakeoverAsk {
+		mode = TakeoverNo
+		if r.opts.Yes || confirmDefaultYes("Сделать этот сервер основным для бэкапов? Агент старого сервера перестанет их присылать") {
+			mode = TakeoverYes
+		}
+	}
+	step("Бэкапы этого сервера")
+	if mode != TakeoverYes {
+		info("агент не установлен — бэкапы по-прежнему присылает старый сервер (пробное восстановление)")
+		r.todo = append(r.todo, "Чтобы этот сервер стал основным: в карточке клиента «Новый токен агента» и выполнить выданную команду здесь")
+		return
+	}
+	token, err := r.client.Takeover(r.ctx)
+	if err != nil {
+		r.warn("не удалось перевести бэкапы на этот сервер: %v — установите агента вручную (карточка клиента → «Новый токен агента»)", err)
+		return
+	}
+	if err := installAgent(r.ctx, r.opts.Server, token); err != nil {
+		r.warn("агент не установлен: %v — токен уже перевыпущен, установите агента вручную (карточка клиента → «Новый токен агента»)", err)
+		return
+	}
+	info("агент установлен, бэкапы теперь присылает этот сервер; токен старого сервера отозван")
+	r.todo = append(r.todo,
+		"Старый сервер больше не может слать бэкапы (токен отозван). При выводе из работы: sudo systemctl disable --now backup-agent.timer",
+		"Первый бэкап с нового сервера сразу: sudo systemctl start backup-agent")
+}
+
+func installAgent(ctx context.Context, server, token string) error {
+	if err := os.MkdirAll("/etc/backup-agent", 0o700); err != nil {
+		return err
+	}
+	cfg := fmt.Sprintf("server: %s\ntoken: %s\nspool_dir: /var/tmp/backup-agent\n", strings.TrimRight(server, "/"), token)
+	if err := os.WriteFile(agentConfigPath, []byte(cfg), 0o600); err != nil {
+		return err
+	}
+	for path, body := range map[string]string{
+		"/etc/systemd/system/backup-agent.service": agentService,
+		"/etc/systemd/system/backup-agent.timer":   agentTimer,
+	} {
+		if err := os.WriteFile(path, []byte(body), 0o644); err != nil {
+			return err
+		}
+	}
+	if err := sysx.Run(ctx, "systemctl", "daemon-reload"); err != nil {
+		return err
+	}
+	return sysx.Run(ctx, "systemctl", "enable", "--now", "backup-agent.timer")
+}

internal/server/api.go

@@ -15,10 +15,14 @@ import (
 	"regexp"
 	"slices"
 	"strconv"
+	"strings"
 	"time"
 
 	"gitea.hsrv.site/mrleo1nid/backup-master/internal/api"
+	"gitea.hsrv.site/mrleo1nid/backup-master/internal/catalog"
 	"gitea.hsrv.site/mrleo1nid/backup-master/internal/manifest"
+	"gitea.hsrv.site/mrleo1nid/backup-master/internal/version"
+	"gopkg.in/yaml.v3"
 )
 
 type ctxKey int
@@ -79,7 +83,50 @@ func (s *Server) apiAgentConfig(w http.ResponseWriter, r *http.Request) {
 	c := clientFrom(r)
 	due := c.HeavyEveryDays >= 0 &&
 		time.Since(time.Unix(c.LastHeavyAt, 0)) >= time.Duration(c.HeavyEveryDays)*24*time.Hour-time.Hour
-	jsonResp(w, http.StatusOK, AgentConfigResponse{Domain: c.Domain, ConfigYAML: c.ConfigYAML, HeavyDue: due})
+	resp := AgentConfigResponse{Domain: c.Domain, ConfigYAML: c.ConfigYAML, HeavyDue: due, ServerVersion: s.cfg.Version}
+
+	agentVer := r.URL.Query().Get("version")
+	if agentVer != "" && agentVer != c.AgentVersion {
+		_ = s.st.SetAgentVersion(c.ID, agentVer)
+	}
+
+	// итоговый каталог: встроенный каталог сервера + переопределения клиента
+	if cat, err := s.clientCatalog(c); err != nil {
+		log.Printf("каталог %s: %v", c.Domain, err)
+	} else {
+		resp.CatalogYAML = cat
+	}
+
+	arch := r.URL.Query().Get("arch")
+	if c.AutoUpdate && agentVer != "" && version.ShouldUpdate(s.cfg.Version, agentVer) {
+		if p, ok := s.binaryPath(arch); ok {
+			if sum, err := s.binarySHA256(p); err == nil {
+				resp.Update = &api.AgentUpdate{Version: s.cfg.Version, Path: "/dl/backupctl-linux-" + arch, SHA256: sum}
+			} else {
+				log.Printf("sha256 %s: %v", p, err)
+			}
+		}
+	}
+	jsonResp(w, http.StatusOK, resp)
+}
+
+func (s *Server) clientCatalog(c *Client) (string, error) {
+	cat, err := catalog.Default()
+	if err != nil {
+		return "", err
+	}
+	if strings.TrimSpace(c.ConfigYAML) != "" {
+		over, err := catalog.Parse([]byte(c.ConfigYAML))
+		if err != nil {
+			return "", err
+		}
+		cat = catalog.Merge(cat, over)
+	}
+	if err := cat.Validate(); err != nil {
+		return "", err
+	}
+	data, err := yaml.Marshal(cat)
+	return string(data), err
 }
 
 var partNameRe = regexp.MustCompile(`^[a-zA-Z0-9][a-zA-Z0-9._-]{0,63}$`)
@@ -393,3 +440,22 @@ func (s *Server) servePart(w http.ResponseWriter, r *http.Request, b *Backup, na
 		filepath.Base(filepath.Dir(b.Dir)), b.ID, name))
 	http.ServeContent(w, r, "", fi.ModTime(), f)
 }
+
+// apiTakeover делает восстановленный сервер основным: выпускает клиенту новый
+// агентский токен. Старый токен перестаёт работать, поэтому агент старого сервера,
+// если тот ещё жив, получает отказ и больше не шлёт бэкапы.
+func (s *Server) apiTakeover(w http.ResponseWriter, r *http.Request) {
+	c := clientFrom(r)
+	tok := newToken()
+	if err := s.st.SetClientToken(c.ID, hashToken(tok)); err != nil {
+		jsonErr(w, http.StatusInternalServerError, err.Error())
+		return
+	}
+	log.Printf("%s: бэкапы переведены на восстановленный сервер, старый токен отозван", c.Domain)
+	s.notify(notification{
+		Title: "Сервер восстановлен: " + c.Domain,
+		Msg:   "Бэкапы теперь присылает восстановленный сервер, токен старого отозван.",
+		Tags:  "white_check_mark", Link: s.clientLink(c.ID),
+	})
+	jsonResp(w, http.StatusOK, map[string]string{"token": tok})
+}

internal/server/api_test.go

@@ -27,6 +27,13 @@ func newTestServer(t *testing.T) (*Server, *httptest.Server) {
 	return s, ts
 }
 
+func newTestHTTP(t *testing.T, s *Server) string {
+	t.Helper()
+	ts := httptest.NewServer(s.Handler())
+	t.Cleanup(ts.Close)
+	return ts.URL
+}
+
 func call(t *testing.T, method, url, token string, body io.Reader) *http.Response {
 	t.Helper()
 	req, err := http.NewRequest(method, url, body)

internal/server/clients_list.go

@@ -2,6 +2,8 @@ package server
 
 import (
 	"cmp"
+
+	"gitea.hsrv.site/mrleo1nid/backup-master/internal/version"
 	"net/http"
 	"net/url"
 	"slices"
@@ -179,6 +181,9 @@ func (s *Server) webClients(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	v := buildClientsView(q, clients, sizes)
+	for i := range v.Rows {
+		v.Rows[i].Outdated = version.ShouldUpdate(s.cfg.Version, v.Rows[i].AgentVersion) && v.Rows[i].AgentVersion != ""
+	}
 	s.render(w, r, "clients", map[string]any{"V": v})
 }
 

internal/server/scripts.go

@@ -1,6 +1,9 @@
 package server
 
 import (
+	"crypto/sha256"
+	"encoding/hex"
+	"io"
 	"net/http"
 	"os"
 	"path/filepath"
@@ -8,6 +11,7 @@ import (
 	"runtime"
 	"strings"
 	"text/template"
+	"time"
 )
 
 var agentScript = template.Must(template.New("agent.sh").Parse(`#!/usr/bin/env bash
@@ -143,28 +147,72 @@ func (s *Server) serveRestoreScript(w http.ResponseWriter, r *http.Request) {
 
 var binNameRe = regexp.MustCompile(`^backupctl-linux-(amd64|arm64)$`)
 
-// serveBinary раздаёт backupctl для агентов: из --dist, а для своей архитектуры — сам себя.
+// binaryPath возвращает файл backupctl для архитектуры: из --dist, а для своей — сам себя.
-func (s *Server) serveBinary(w http.ResponseWriter, r *http.Request) {
+func (s *Server) binaryPath(arch string) (string, bool) {
-	name := r.PathValue("file")
+	name := "backupctl-linux-" + arch
-	m := binNameRe.FindStringSubmatch(name)
+	if !binNameRe.MatchString(name) {
-	if m == nil {
+		return "", false
-		http.NotFound(w, r)
-		return
 	}
 	if s.cfg.DistDir != "" {
 		p := filepath.Join(s.cfg.DistDir, name)
 		if _, err := os.Stat(p); err == nil {
+			return p, true
+		}
+	}
+	if runtime.GOOS == "linux" && runtime.GOARCH == arch {
+		if self, err := os.Executable(); err == nil && !strings.HasSuffix(self, ".test") {
+			return self, true
+		}
+	}
+	return "", false
+}
+
+type binarySum struct {
+	size    int64
+	modTime time.Time
+	sum     string
+}
+
+// binarySHA256 считает sha256 файла с кэшем по размеру и времени изменения.
+func (s *Server) binarySHA256(p string) (string, error) {
+	fi, err := os.Stat(p)
+	if err != nil {
+		return "", err
+	}
+	s.shaMu.Lock()
+	c, ok := s.shaCache[p]
+	s.shaMu.Unlock()
+	if ok && c.size == fi.Size() && c.modTime.Equal(fi.ModTime()) {
+		return c.sum, nil
+	}
+	f, err := os.Open(p)
+	if err != nil {
+		return "", err
+	}
+	defer f.Close()
+	h := sha256.New()
+	if _, err := io.Copy(h, f); err != nil {
+		return "", err
+	}
+	sum := hex.EncodeToString(h.Sum(nil))
+	s.shaMu.Lock()
+	s.shaCache[p] = binarySum{fi.Size(), fi.ModTime(), sum}
+	s.shaMu.Unlock()
+	return sum, nil
+}
+
+// serveBinary раздаёт backupctl для агентов.
+func (s *Server) serveBinary(w http.ResponseWriter, r *http.Request) {
+	m := binNameRe.FindStringSubmatch(r.PathValue("file"))
+	if m == nil {
+		http.NotFound(w, r)
+		return
+	}
+	p, ok := s.binaryPath(m[1])
+	if !ok {
+		http.Error(w, "бинарник "+m[0]+" не найден: положите его в --dist", http.StatusNotFound)
+		return
+	}
 	w.Header().Set("Content-Type", "application/octet-stream")
 	http.ServeFile(w, r, p)
-			return
-		}
-	}
-	if runtime.GOOS == "linux" && runtime.GOARCH == m[1] {
-		if self, err := os.Executable(); err == nil && !strings.HasSuffix(self, ".test") {
-			w.Header().Set("Content-Type", "application/octet-stream")
-			http.ServeFile(w, r, self)
-			return
-		}
-	}
-	http.Error(w, "бинарник "+name+" не найден: положите его в --dist", http.StatusNotFound)
 }

internal/server/server.go

@@ -25,6 +25,8 @@ type Config struct {
 	MaxUpload int64  // максимальный размер одной части, байт
 	// TrustProxy — брать IP клиента из X-Forwarded-For (за Caddy).
 	TrustProxy bool
+	// Version — версия сервера; до неё обновляются агенты с включённым автообновлением.
+	Version string
 }
 
 type Server struct {
@@ -35,6 +37,9 @@ type Server struct {
 
 	uploadMu sync.Mutex
 	uploads  map[int64]bool // бэкапы, в которые сейчас идёт загрузка
+
+	shaMu    sync.Mutex
+	shaCache map[string]binarySum // sha256 раздаваемых бинарников
 }
 
 func New(cfg Config) (*Server, error) {
@@ -54,7 +59,8 @@ func New(cfg Config) (*Server, error) {
 		st.Close()
 		return nil, err
 	}
-	return &Server{cfg: cfg, st: st, pages: pages, login: newLoginLimiter(), uploads: map[int64]bool{}}, nil
+	return &Server{cfg: cfg, st: st, pages: pages, login: newLoginLimiter(), uploads: map[int64]bool{},
+		shaCache: map[string]binarySum{}}, nil
 }
 
 func (s *Server) Close() error { return s.st.Close() }
@@ -80,6 +86,7 @@ func (s *Server) Handler() http.Handler {
 	// API восстановления
 	mux.HandleFunc("GET /api/v1/restore/manifest", s.restoreAuth(s.apiRestoreManifest))
 	mux.HandleFunc("GET /api/v1/restore/{id}/parts/{name}", s.restoreAuth(s.apiRestorePart))
+	mux.HandleFunc("POST /api/v1/restore/takeover", s.restoreAuth(s.apiTakeover))
 
 	// публичное
 	mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, r *http.Request) { w.Write([]byte("ok\n")) })

internal/server/store.go

@@ -94,7 +94,38 @@ func OpenStore(path string) (*Store, error) {
 		db.Close()
 		return nil, fmt.Errorf("миграция: %w", err)
 	}
-	return &Store{db: db}, nil
+	st := &Store{db: db}
+	// колонки, добавленные после первых релизов: у существующих баз их нет
+	for _, col := range []struct{ table, name, def string }{
+		{"clients", "auto_update", "INTEGER NOT NULL DEFAULT 1"},
+		{"clients", "agent_version", "TEXT NOT NULL DEFAULT ''"},
+	} {
+		if err := st.ensureColumn(col.table, col.name, col.def); err != nil {
+			db.Close()
+			return nil, fmt.Errorf("миграция %s.%s: %w", col.table, col.name, err)
+		}
+	}
+	return st, nil
+}
+
+func (s *Store) ensureColumn(table, name, def string) error {
+	rows, err := s.db.Query(`SELECT name FROM pragma_table_info(?)`, table)
+	if err != nil {
+		return err
+	}
+	found := false
+	for rows.Next() {
+		var n string
+		if rows.Scan(&n) == nil && n == name {
+			found = true
+		}
+	}
+	rows.Close()
+	if found {
+		return nil
+	}
+	_, err = s.db.Exec(fmt.Sprintf(`ALTER TABLE %s ADD COLUMN %s %s`, table, name, def))
+	return err
 }
 
 func (s *Store) Close() error { return s.db.Close() }
@@ -119,17 +150,20 @@ type Client struct {
 	LastErrorAt    int64
 	StaleNotified  bool
 	Disabled       bool
+	AutoUpdate     bool   // агент сам обновляется до версии сервера
+	AgentVersion   string // версия агента при последнем обращении
 }
 
 const clientCols = `id, name, domain, token_hash, config_yaml, keep_daily, keep_weekly, keep_monthly,
 	heavy_keep, heavy_every_days, stale_hours, created_at, last_backup_at, last_heavy_at, last_seen_at,
-	last_error, last_error_at, stale_notified, disabled`
+	last_error, last_error_at, stale_notified, disabled, auto_update, agent_version`
 
 func scanClient(row interface{ Scan(...any) error }) (*Client, error) {
 	var c Client
 	err := row.Scan(&c.ID, &c.Name, &c.Domain, &c.TokenHash, &c.ConfigYAML, &c.KeepDaily, &c.KeepWeekly,
 		&c.KeepMonthly, &c.HeavyKeep, &c.HeavyEveryDays, &c.StaleHours, &c.CreatedAt, &c.LastBackupAt,
-		&c.LastHeavyAt, &c.LastSeenAt, &c.LastError, &c.LastErrorAt, &c.StaleNotified, &c.Disabled)
+		&c.LastHeavyAt, &c.LastSeenAt, &c.LastError, &c.LastErrorAt, &c.StaleNotified, &c.Disabled,
+		&c.AutoUpdate, &c.AgentVersion)
 	if errors.Is(err, sql.ErrNoRows) {
 		return nil, ErrNotFound
 	}
@@ -172,9 +206,10 @@ func (s *Store) ListClients() ([]*Client, error) {
 
 func (s *Store) UpdateClientSettings(c *Client) error {
 	_, err := s.db.Exec(`UPDATE clients SET name = ?, config_yaml = ?, keep_daily = ?, keep_weekly = ?,
-		keep_monthly = ?, heavy_keep = ?, heavy_every_days = ?, stale_hours = ?, disabled = ? WHERE id = ?`,
+		keep_monthly = ?, heavy_keep = ?, heavy_every_days = ?, stale_hours = ?, disabled = ?, auto_update = ?
+		WHERE id = ?`,
 		c.Name, c.ConfigYAML, c.KeepDaily, c.KeepWeekly, c.KeepMonthly, c.HeavyKeep, c.HeavyEveryDays,
-		c.StaleHours, c.Disabled, c.ID)
+		c.StaleHours, c.Disabled, c.AutoUpdate, c.ID)
 	return err
 }
 
@@ -193,6 +228,11 @@ func (s *Store) TouchClient(id int64) error {
 	return err
 }
 
+func (s *Store) SetAgentVersion(id int64, version string) error {
+	_, err := s.db.Exec(`UPDATE clients SET agent_version = ? WHERE id = ?`, version, id)
+	return err
+}
+
 func (s *Store) MarkClientSuccess(id int64, at int64, heavy bool) error {
 	q := `UPDATE clients SET last_backup_at = ?1, last_error = '', last_error_at = 0, stale_notified = 0`
 	if heavy {

internal/server/templates/client.html

@@ -24,6 +24,7 @@
   <div><dt>Последний бэкап</dt><dd title="{{ts .Client.LastBackupAt}}">{{ago .Client.LastBackupAt}}</dd></div>
   <div><dt>Heavy-части</dt><dd title="{{ts .Client.LastHeavyAt}}">{{ago .Client.LastHeavyAt}}</dd></div>
   <div><dt>Агент на связи</dt><dd title="{{ts .Client.LastSeenAt}}">{{ago .Client.LastSeenAt}}</dd></div>
+  <div><dt>Версия агента</dt><dd>{{with .Client.AgentVersion}}{{.}}{{else}}—{{end}}{{if .AgentOutdated}} <span class="badge stale" title="Сервер {{.ServerVersion}}">{{if .Client.AutoUpdate}}обновится при следующем бэкапе{{else}}устарел, автообновление выключено{{end}}</span>{{end}}</dd></div>
   {{with .Latest}}<div><dt>Система</dt><dd>{{.Hostname}}{{with .OS.PrettyName}} · {{.}}{{end}}{{with .OS.Arch}} · {{.}}{{end}}</dd></div>{{end}}
 </dl>
 
@@ -40,7 +41,8 @@
     <td>{{.Version}}{{with .Compose}}{{with .Git}}<span class="muted small" title="{{.Remote}}">git {{printf "%.8s" .Commit}}{{if .Dirty}}*{{end}}</span>{{end}}{{end}}</td>
     <td>{{with .Service}}{{.Unit}} {{if .Active}}<span class="ok-text">active</span>{{else}}<span class="muted">inactive</span>{{end}}{{if not .Enabled}} <span class="muted">(disabled)</span>{{end}}{{end}}</td>
     <td class="small">
-      {{if .Paths}}{{join .Paths ", "}}{{end}}
+      {{if .Paths}}<span title="{{join .Paths ", "}}">{{short .Paths 8}}</span>{{end}}
+      {{range .Units}}<br>юнит {{.Unit}}{{if .Enabled}} <span class="muted">enabled</span>{{end}}{{if .Active}} <span class="ok-text">active</span>{{end}}{{end}}
       {{range .Dumps}}<br>дамп {{.Kind}}{{with .Service}} ({{.}}){{end}}{{end}}
       {{range .Volumes}}<br>том {{.Name}}{{end}}
       {{if .Heavy}}<br>heavy: {{join .Heavy ", "}}{{if .HeavySkipped}} <span class="muted">(не в этот раз)</span>{{end}}{{end}}
@@ -104,6 +106,7 @@
     <label>Heavy раз в, дней <input type="number" min="0" name="heavy_every_days" value="{{.Client.HeavyEveryDays}}"></label>
     <label>Хранить heavy, шт <input type="number" min="0" name="heavy_keep" value="{{.Client.HeavyKeep}}"></label>
   </div>
+  <label class="check"><input type="checkbox" name="auto_update" value="1" {{if .Client.AutoUpdate}}checked{{end}}> Автообновление агента до версии сервера (перед бэкапом)</label>
   <label class="check"><input type="checkbox" name="disabled" value="1" {{if .Client.Disabled}}checked{{end}}> Клиент отключён (агент получает отказ)</label>
   <label>Переопределения каталога (YAML)
     <textarea name="config_yaml" rows="12" spellcheck="false" placeholder="categories:

internal/server/templates/clients.html

@@ -31,6 +31,7 @@
     <th><a href="{{$q.SortURL "last_backup"}}" {{if eq $q.Sort "last_backup"}}class="sorted"{{end}}>Последний бэкап {{$q.SortMark "last_backup"}}</a></th>
     <th class="num"><a href="{{$q.SortURL "size"}}" {{if eq $q.Sort "size"}}class="sorted"{{end}}>Размер {{$q.SortMark "size"}}</a></th>
     <th><a href="{{$q.SortURL "last_seen"}}" {{if eq $q.Sort "last_seen"}}class="sorted"{{end}}>Агент на связи {{$q.SortMark "last_seen"}}</a></th>
+    <th>Версия</th>
   </tr></thead>
   <tbody>
   {{range $v.Rows}}
@@ -41,6 +42,7 @@
     <td title="{{ts .LastBackupAt}}">{{ago .LastBackupAt}}</td>
     <td class="num">{{if .LastSize}}{{bytes .LastSize}}{{end}}</td>
     <td title="{{ts .LastSeenAt}}">{{ago .LastSeenAt}}</td>
+    <td>{{if .Outdated}}<span class="badge stale" title="{{if .AutoUpdate}}обновится при следующем бэкапе{{else}}автообновление выключено{{end}}">{{.AgentVersion}}</span>{{else}}<span class="muted small">{{.AgentVersion}}</span>{{end}}</td>
   </tr>
   {{end}}
   </tbody>

internal/server/templates/layout.html

@@ -10,7 +10,7 @@
 {{if ne .Page "login"}}
 <header class="top">
   <div class="wrap">
-    <a class="brand" href="/">backup-master</a>
+    <a class="brand" href="/">backup-master{{with .ServerVersion}} <span class="muted small">{{.}}</span>{{end}}</a>
     <nav>
       <a href="/" {{if or (eq .Page "clients") (eq .Page "client") (eq .Page "backup")}}class="active"{{end}}>Клиенты</a>
       <a href="/settings" {{if eq .Page "settings"}}class="active"{{end}}>Настройки</a>

internal/server/update_test.go

@@ -0,0 +1,144 @@
+package server
+
+import (
+	"crypto/sha256"
+	"database/sql"
+	"encoding/hex"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"gitea.hsrv.site/mrleo1nid/backup-master/internal/catalog"
+)
+
+func TestAgentConfigCatalogAndUpdate(t *testing.T) {
+	dist := t.TempDir()
+	bin := []byte("fake-backupctl-binary")
+	if err := os.WriteFile(filepath.Join(dist, "backupctl-linux-amd64"), bin, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	s, err := New(Config{DataDir: t.TempDir(), DistDir: dist, Version: "v0.6.0"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer s.Close()
+	tok := newToken()
+	id, err := s.st.CreateClient("x", "x.example.com", hashToken(tok))
+	if err != nil {
+		t.Fatal(err)
+	}
+	c, _ := s.st.GetClient(id)
+	if !c.AutoUpdate {
+		t.Fatal("автообновление должно быть включено по умолчанию")
+	}
+	c.ConfigYAML = "categories:\n  - {name: scripts, disabled: true}\n"
+	if err := s.st.UpdateClientSettings(c); err != nil {
+		t.Fatal(err)
+	}
+
+	ts := newTestHTTP(t, s)
+	var cfg AgentConfigResponse
+	decode(t, call(t, "GET", ts+"/api/v1/agent/config?arch=amd64&version=v0.5.0", tok, nil), &cfg)
+
+	cat, err := catalog.Parse([]byte(cfg.CatalogYAML))
+	if err != nil || cat.Validate() != nil {
+		t.Fatalf("каталог не читается: %v", err)
+	}
+	if cat.Find("xui") == nil || !cat.Find("scripts").Disabled {
+		t.Fatal("в каталоге нет встроенных категорий или переопределений клиента")
+	}
+	sum := sha256.Sum256(bin)
+	if cfg.Update == nil || cfg.Update.Version != "v0.6.0" || cfg.Update.Path != "/dl/backupctl-linux-amd64" || cfg.Update.SHA256 != hex.EncodeToString(sum[:]) {
+		t.Fatalf("update: %+v", cfg.Update)
+	}
+	if c, _ := s.st.GetClient(id); c.AgentVersion != "v0.5.0" {
+		t.Fatalf("версия агента не записана: %q", c.AgentVersion)
+	}
+
+	// актуальная версия, неизвестная архитектура, выключенное автообновление — без обновления
+	for _, q := range []string{"arch=amd64&version=v0.6.0", "arch=riscv64&version=v0.5.0"} {
+		cfg = AgentConfigResponse{}
+		decode(t, call(t, "GET", ts+"/api/v1/agent/config?"+q, tok, nil), &cfg)
+		if cfg.Update != nil {
+			t.Fatalf("%s: обновление не ожидалось", q)
+		}
+	}
+	c, _ = s.st.GetClient(id)
+	c.AutoUpdate = false
+	_ = s.st.UpdateClientSettings(c)
+	cfg = AgentConfigResponse{}
+	decode(t, call(t, "GET", ts+"/api/v1/agent/config?arch=amd64&version=v0.5.0", tok, nil), &cfg)
+	if cfg.Update != nil {
+		t.Fatal("автообновление выключено, а обновление предложено")
+	}
+}
+
+// Базы первых релизов без новых колонок мигрируются при открытии.
+func TestStoreMigration(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "old.db")
+	db, err := sql.Open("sqlite", "file:"+path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = db.Exec(`CREATE TABLE clients (id INTEGER PRIMARY KEY, name TEXT NOT NULL, domain TEXT NOT NULL UNIQUE,
+		token_hash TEXT NOT NULL UNIQUE, config_yaml TEXT NOT NULL DEFAULT '', keep_daily INTEGER NOT NULL DEFAULT 7,
+		keep_weekly INTEGER NOT NULL DEFAULT 4, keep_monthly INTEGER NOT NULL DEFAULT 6, heavy_keep INTEGER NOT NULL DEFAULT 1,
+		heavy_every_days INTEGER NOT NULL DEFAULT 7, stale_hours INTEGER NOT NULL DEFAULT 26, created_at INTEGER NOT NULL,
+		last_backup_at INTEGER NOT NULL DEFAULT 0, last_heavy_at INTEGER NOT NULL DEFAULT 0, last_seen_at INTEGER NOT NULL DEFAULT 0,
+		last_error TEXT NOT NULL DEFAULT '', last_error_at INTEGER NOT NULL DEFAULT 0, stale_notified INTEGER NOT NULL DEFAULT 0,
+		disabled INTEGER NOT NULL DEFAULT 0);
+		INSERT INTO clients (name, domain, token_hash, created_at) VALUES ('a', 'a.example.com', 'h', 1);`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	db.Close()
+
+	st, err := OpenStore(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer st.Close()
+	cs, err := st.ListClients()
+	if err != nil || len(cs) != 1 || !cs[0].AutoUpdate {
+		t.Fatalf("после миграции: %v %+v", err, cs)
+	}
+	// повторное открытие не падает на уже добавленных колонках
+	st.Close()
+	if st2, err := OpenStore(path); err != nil {
+		t.Fatal(err)
+	} else {
+		st2.Close()
+	}
+}
+
+func TestTakeoverRevokesOldAgent(t *testing.T) {
+	s, ts := newTestServer(t)
+	oldTok := newToken()
+	id, err := s.st.CreateClient("x", "x.example.com", hashToken(oldTok))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if r := call(t, "GET", ts.URL+"/api/v1/agent/config", oldTok, nil); r.StatusCode != 200 {
+		t.Fatalf("старый токен до takeover: %d", r.StatusCode)
+	}
+	// агентский токен takeover не делает
+	if r := call(t, "POST", ts.URL+"/api/v1/restore/takeover", oldTok, nil); r.StatusCode != 401 {
+		t.Fatalf("takeover агентским токеном: %d", r.StatusCode)
+	}
+	rt := newToken()
+	if err := s.st.CreateRestoreToken(hashToken(rt), id, time.Hour); err != nil {
+		t.Fatal(err)
+	}
+	var out struct{ Token string }
+	decode(t, call(t, "POST", ts.URL+"/api/v1/restore/takeover", rt, nil), &out)
+	if out.Token == "" || out.Token == oldTok {
+		t.Fatalf("новый токен: %q", out.Token)
+	}
+	if r := call(t, "GET", ts.URL+"/api/v1/agent/config", oldTok, nil); r.StatusCode != 401 {
+		t.Fatalf("старый сервер после takeover всё ещё принят: %d", r.StatusCode)
+	}
+	if r := call(t, "GET", ts.URL+"/api/v1/agent/config", out.Token, nil); r.StatusCode != 200 {
+		t.Fatalf("новый токен: %d", r.StatusCode)
+	}
+}

internal/server/web.go

@@ -16,6 +16,7 @@ import (
 
 	"gitea.hsrv.site/mrleo1nid/backup-master/internal/catalog"
 	"gitea.hsrv.site/mrleo1nid/backup-master/internal/manifest"
+	"gitea.hsrv.site/mrleo1nid/backup-master/internal/version"
 )
 
 //go:embed templates/*.html
@@ -54,6 +55,13 @@ var funcs = template.FuncMap{
 	},
 	"bytes": humanBytes,
 	"join":  strings.Join,
+	// short — первые n путей и «ещё N», чтобы категория etc не растягивала таблицу
+	"short": func(paths []string, n int) string {
+		if len(paths) <= n {
+			return strings.Join(paths, ", ")
+		}
+		return strings.Join(paths[:n], ", ") + fmt.Sprintf(" и ещё %d", len(paths)-n)
+	},
 }
 
 func loadPages() (map[string]*pageTemplate, error) {
@@ -88,6 +96,7 @@ func (s *Server) render(w http.ResponseWriter, r *http.Request, page string, dat
 	data["CSRF"] = csrfFrom(r)
 	data["Page"] = page
 	data["PublicURL"] = s.cfg.PublicURL
+	data["ServerVersion"] = s.cfg.Version
 	var buf bytes.Buffer
 	if err := t.Execute(&buf, data); err != nil {
 		log.Printf("render %s: %v", page, err)
@@ -120,6 +129,7 @@ type clientRow struct {
 	*Client
 	StatusClass, StatusText string
 	LastSize                int64
+	Outdated                bool // агент старее сервера
 }
 
 func (s *Server) webClientNew(w http.ResponseWriter, r *http.Request) {
@@ -189,7 +199,8 @@ func (s *Server) renderClient(w http.ResponseWriter, r *http.Request, c *Client,
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
-	data := map[string]any{"Client": c, "Backups": backups, "Error": formErr}
+	data := map[string]any{"Client": c, "Backups": backups, "Error": formErr,
+		"AgentOutdated": c.AgentVersion != "" && version.ShouldUpdate(s.cfg.Version, c.AgentVersion)}
 	data["StatusClass"], data["StatusText"] = clientStatus(c)
 	if latest, err := s.st.LatestComplete(c.ID); err == nil {
 		var m manifest.Manifest
@@ -223,6 +234,7 @@ func (s *Server) webClientSettings(w http.ResponseWriter, r *http.Request) {
 	c.HeavyEveryDays = formInt(r, "heavy_every_days", c.HeavyEveryDays)
 	c.StaleHours = formInt(r, "stale_hours", c.StaleHours)
 	c.Disabled = r.FormValue("disabled") == "1"
+	c.AutoUpdate = r.FormValue("auto_update") == "1"
 	if strings.TrimSpace(c.ConfigYAML) != "" {
 		base, err := catalog.Default()
 		if err == nil {
@@ -279,7 +291,7 @@ func (s *Server) webClientRestoreToken(w http.ResponseWriter, r *http.Request) {
 	s.render(w, r, "token", map[string]any{
 		"Client": c,
 		"Title":  "Восстановление " + c.Domain,
-		"Note":   "Токен действует 24 часа и даёт только чтение бэкапов этого клиента. Выполните на новом сервере (Ubuntu 24.04, от root или пользователя с sudo):",
+		"Note":   "Токен действует 24 часа и даёт только чтение бэкапов этого клиента. Выполните на новом сервере (Ubuntu 24.04, от root или пользователя с sudo). В конце restore спросит, сделать ли новый сервер основным: тогда токен старого отзывается и бэкапы шлёт только новый. Для пробного восстановления добавьте --no-takeover.",
 		"Cmd":    cmd,
 	})
 }

internal/sysx/sysx.go

@@ -5,6 +5,8 @@ import (
 	"bufio"
 	"bytes"
 	"context"
+	"crypto/md5"
+	"encoding/hex"
 	"fmt"
 	"io"
 	"os"
@@ -162,3 +164,117 @@ func GroupMembers(group string) []string {
 	}
 	return nil
 }
+
+// DpkgOwned возвращает множество путей, принадлежащих какому-либо пакету (dpkg -S).
+// Без dpkg (не Debian/Ubuntu) считает все пути своими — ничего не теряется.
+func DpkgOwned(ctx context.Context, paths []string) map[string]bool {
+	owned := map[string]bool{}
+	if len(paths) == 0 || !HasCommand("dpkg") {
+		return owned
+	}
+	cmd := exec.CommandContext(ctx, "dpkg", append([]string{"-S"}, paths...)...)
+	out, _ := cmd.Output() // код возврата 1, если хоть один путь ничей, — это нормально
+	return ParseDpkgS(string(out), paths)
+}
+
+// ParseDpkgS разбирает вывод `dpkg -S`: "pkg1, pkg2: /path" или "diversion by ...".
+func ParseDpkgS(out string, paths []string) map[string]bool {
+	want := map[string]bool{}
+	for _, p := range paths {
+		want[p] = true
+	}
+	owned := map[string]bool{}
+	for _, line := range strings.Split(out, "\n") {
+		if strings.HasPrefix(line, "diversion ") {
+			continue
+		}
+		_, p, ok := strings.Cut(line, ": ")
+		if p = strings.TrimSpace(p); ok && want[p] {
+			owned[p] = true
+		}
+	}
+	return owned
+}
+
+// Timezone возвращает часовой пояс системы (Europe/Moscow) или "".
+func Timezone(ctx context.Context) string {
+	if tz, err := Output(ctx, "timedatectl", "show", "-p", "Timezone", "--value"); err == nil && tz != "" {
+		return tz
+	}
+	if link, err := os.Readlink("/etc/localtime"); err == nil {
+		if _, tz, ok := strings.Cut(link, "zoneinfo/"); ok {
+			return tz
+		}
+	}
+	return ""
+}
+
+// SwapFiles возвращает swap-файлы (не разделы) из /proc/swaps: путь и размер в байтах.
+func SwapFiles() map[string]int64 {
+	out := map[string]int64{}
+	data, err := os.ReadFile("/proc/swaps")
+	if err != nil {
+		return out
+	}
+	for _, line := range strings.Split(string(data), "\n")[1:] {
+		f := strings.Fields(line)
+		if len(f) < 3 || f[1] != "file" {
+			continue
+		}
+		var kb int64
+		fmt.Sscan(f[2], &kb)
+		out[f[0]] = kb * 1024
+	}
+	return out
+}
+
+// ManualPackages — пакеты, поставленные вручную (apt-mark showmanual).
+func ManualPackages(ctx context.Context) []string {
+	out, err := Output(ctx, "apt-mark", "showmanual")
+	if err != nil {
+		return nil
+	}
+	return strings.Fields(out)
+}
+
+// ModifiedConffiles возвращает конфиги пакетов (conffiles), изменённые относительно
+// поставки: md5 файла не совпадает с записанным dpkg.
+func ModifiedConffiles(ctx context.Context) []string {
+	out, err := Output(ctx, "dpkg-query", "-W", `-f=${Conffiles}\n`)
+	if err != nil {
+		return nil
+	}
+	return modifiedConffiles(out, fileMD5)
+}
+
+func modifiedConffiles(out string, sum func(string) string) []string {
+	var res []string
+	seen := map[string]bool{}
+	for _, line := range strings.Split(out, "\n") {
+		f := strings.Fields(line)
+		if len(f) < 2 || !strings.HasPrefix(f[0], "/") || seen[f[0]] {
+			continue
+		}
+		if len(f) > 2 && (f[2] == "obsolete" || f[2] == "remove-on-upgrade") {
+			continue
+		}
+		seen[f[0]] = true
+		if s := sum(f[0]); s != "" && s != f[1] {
+			res = append(res, f[0])
+		}
+	}
+	return res
+}
+
+func fileMD5(p string) string {
+	f, err := os.Open(p)
+	if err != nil {
+		return ""
+	}
+	defer f.Close()
+	h := md5.New()
+	if _, err := io.Copy(h, f); err != nil {
+		return ""
+	}
+	return hex.EncodeToString(h.Sum(nil))
+}

internal/sysx/sysx_test.go

@@ -0,0 +1,34 @@
+package sysx
+
+import (
+	"slices"
+	"testing"
+)
+
+func TestParseDpkgS(t *testing.T) {
+	out := "openssh-server: /etc/ssh/sshd_config\n" +
+		"diversion by foo from: /usr/bin/caddy\n" +
+		"cron, cron-daemon-common: /etc/cron.d/e2scrub_all\n"
+	paths := []string{"/etc/ssh/sshd_config", "/etc/cron.d/e2scrub_all", "/etc/cron.d/ban-blacklist"}
+	owned := ParseDpkgS(out, paths)
+	if !owned["/etc/ssh/sshd_config"] || !owned["/etc/cron.d/e2scrub_all"] || owned["/etc/cron.d/ban-blacklist"] {
+		t.Fatalf("owned = %v", owned)
+	}
+}
+
+func TestModifiedConffiles(t *testing.T) {
+	out := " /etc/ssh/sshd_config aaa\n" +
+		" /etc/fail2ban/fail2ban.conf bbb\n" +
+		" /etc/old.conf ccc obsolete\n" +
+		" /etc/missing.conf ddd\n" +
+		"\n"
+	sums := map[string]string{
+		"/etc/ssh/sshd_config":        "aaa",     // не менялся
+		"/etc/fail2ban/fail2ban.conf": "changed", // изменён
+		"/etc/old.conf":               "x",       // obsolete — пропускаем
+	}
+	got := modifiedConffiles(out, func(p string) string { return sums[p] })
+	if !slices.Equal(got, []string{"/etc/fail2ban/fail2ban.conf"}) {
+		t.Fatalf("modified = %v", got)
+	}
+}

internal/version/version.go

@@ -0,0 +1,44 @@
+// Package version сравнивает версии backupctl вида v1.2.3.
+package version
+
+import (
+	"strconv"
+	"strings"
+)
+
+// Parse разбирает "v1.2.3" или "1.2.3". ok=false для dev-сборок ("dev", "main-abc123").
+func Parse(v string) (parts [3]int, ok bool) {
+	v = strings.TrimPrefix(strings.TrimSpace(v), "v")
+	v, _, _ = strings.Cut(v, "-") // v1.2.3-rc1 → 1.2.3
+	f := strings.Split(v, ".")
+	if len(f) != 3 {
+		return parts, false
+	}
+	for i, s := range f {
+		n, err := strconv.Atoi(s)
+		if err != nil || n < 0 {
+			return parts, false
+		}
+		parts[i] = n
+	}
+	return parts, true
+}
+
+// ShouldUpdate решает, обновлять ли агента до версии сервера. Сервер dev-сборки
+// обновления не раздаёт; агент dev-сборки обновляется до релиза; откат вниз не делается.
+func ShouldUpdate(server, agent string) bool {
+	s, ok := Parse(server)
+	if !ok {
+		return false
+	}
+	a, ok := Parse(agent)
+	if !ok {
+		return true
+	}
+	for i := range s {
+		if s[i] != a[i] {
+			return s[i] > a[i]
+		}
+	}
+	return false
+}

internal/version/version_test.go

@@ -0,0 +1,25 @@
+package version
+
+import "testing"
+
+func TestShouldUpdate(t *testing.T) {
+	cases := []struct {
+		server, agent string
+		want          bool
+	}{
+		{"v0.5.0", "v0.4.0", true},
+		{"v0.5.0", "v0.5.0", false},
+		{"v0.4.0", "v0.5.0", false}, // без отката
+		{"v0.10.0", "v0.9.3", true}, // числа, а не строки
+		{"v1.0.0", "dev", true},
+		{"v1.0.0", "main-abc123", true},
+		{"dev", "v0.1.0", false}, // dev-сервер не раздаёт обновления
+		{"main-abc", "dev", false},
+		{"v0.5.1-rc1", "v0.5.0", true},
+	}
+	for _, c := range cases {
+		if got := ShouldUpdate(c.server, c.agent); got != c.want {
+			t.Errorf("ShouldUpdate(%q, %q) = %v, want %v", c.server, c.agent, got, c.want)
+		}
+	}
+}