В обновлении видно изменения всех пропущенных версий

Панель показывала описание только последнего релиза. Пропустив пару
версий, человек не узнал бы, что менялось в промежутке, — теперь
запрашивается список релизов и показываются все, что новее установленной,
каждая со своим заголовком и датой. Черновики и предрелизы отбрасываются,
порядок восстанавливается по номерам версий, а не по тому, как их отдал
Gitea.

Заодно в карточке профиля появились подсказки: сколько на машине ОЗУ (не
выбирать же лимит JVM вслепую) и что означает пустое поле начальной
памяти.

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

README.md

@@ -213,6 +213,20 @@ Mod ID, который нужен серверу, лежит внутри сам
 При создании профиля можно скопировать `.ini` и настройки песочницы из
 существующего: удобно, когда нужен тот же набор правил, но чистый мир.
 
+### Память JVM
+
+`java_memory` — это `-Xmx`, верхняя граница кучи. `java_memory_min` (`-Xms`)
+по умолчанию пуст, и это осознанно: равные значения избавляют от роста кучи на
+ходу, но заставляют JVM занять весь объём сразу при старте. На машине, где
+столько свободной памяти не набирается, сервер тогда не поднимется вовсе —
+`Failed to allocate initial Java heap`. Задавайте минимум, только если памяти
+заведомо хватает.
+
+Сервер, упавший сразу после запуска три раза подряд, панель перестаёт
+поднимать автоматически: обычно так проявляется нехватка памяти или битый
+конфиг, и перезапуск делу не помогает. Пока идёт отсчёт до автоподъёма, его
+можно отменить кнопкой «Отменить перезапуск».
+
 Удаление профиля убирает его только из панели — мир и конфиги остаются на
 диске. Чтобы вернуть профиль, создайте его с тем же идентификатором.
 
@@ -327,7 +341,8 @@ profiles:                       # серверы: у каждого свой м
   - id: vanilla                 # vanilla -> vanilla.ini, Saves/Multiplayer/vanilla
     title: Ванильный мир        # как профиль подписан в панели
     admin_password: ""          # пароль админа игрового сервера
-    java_memory: 4g             # -Xmx для JVM этого профиля
+    java_memory: 4g             # -Xmx: верхняя граница кучи JVM
+    java_memory_min: ""         # -Xms: пусто — JVM берёт память по мере надобности
     extra_args: []              # доп. аргументы start-server.sh
   - id: modded
     title: Сборка с модами

internal/api/handlers_profiles.go

@@ -7,15 +7,36 @@ import (
 	"os"
 
 	"github.com/mrleo1nid/pzmanager/internal/config"
+	"github.com/mrleo1nid/pzmanager/internal/pzconfig"
 	"github.com/mrleo1nid/pzmanager/internal/pzserver"
 )
 
+// validateProfileMemory проверяет границы кучи JVM здесь, а не при запуске
+// сервера: иначе про опечатку в профиле стало бы известно только из лога
+// упавшего сервера.
+func validateProfileMemory(dto profileDTO) error {
+	maxBytes, err := pzconfig.ParseMemory(dto.JavaMemory)
+	if err != nil {
+		return err
+	}
+	minBytes, err := pzconfig.ParseMemory(dto.JavaMemoryMin)
+	if err != nil {
+		return err
+	}
+	if maxBytes > 0 && minBytes > maxBytes {
+		return fmt.Errorf("начальный размер памяти (%s) больше максимального (%s)",
+			dto.JavaMemoryMin, dto.JavaMemory)
+	}
+	return nil
+}
+
 // profileDTO — профиль в том виде, в каком его показывает панель. Пароль
 // наружу не отдаётся, только признак того, что он задан.
 type profileDTO struct {
 	ID               string   `json:"id"`
 	Title            string   `json:"title"`
 	JavaMemory       string   `json:"java_memory"`
+	JavaMemoryMin    string   `json:"java_memory_min"`
 	ExtraArgs        []string `json:"extra_args"`
 	HasAdminPassword bool     `json:"has_admin_password"`
 	AdminPassword    string   `json:"admin_password,omitempty"`
@@ -33,6 +54,7 @@ func (s *Server) profileToDTO(p config.Profile) profileDTO {
 		ID:               p.ID,
 		Title:            p.Title,
 		JavaMemory:       p.JavaMemory,
+		JavaMemoryMin:    p.JavaMemoryMin,
 		ExtraArgs:        p.ExtraArgs,
 		HasAdminPassword: p.AdminPassword != "",
 		HasConfig:        fileExists(s.cfg.ServerConfigPathFor(p.ID)),
@@ -61,11 +83,16 @@ func (s *Server) handleCreateProfile(w http.ResponseWriter, r *http.Request) {
 	if !decodeJSON(w, r, &dto) {
 		return
 	}
+	if err := validateProfileMemory(dto); err != nil {
+		writeError(w, http.StatusBadRequest, err.Error())
+		return
+	}
 
 	profile := config.Profile{
 		ID:            dto.ID,
 		Title:         dto.Title,
 		JavaMemory:    dto.JavaMemory,
+		JavaMemoryMin: dto.JavaMemoryMin,
 		ExtraArgs:     dto.ExtraArgs,
 		AdminPassword: dto.AdminPassword,
 	}
@@ -133,12 +160,17 @@ func (s *Server) handleUpdateProfile(w http.ResponseWriter, r *http.Request) {
 	if !decodeJSON(w, r, &dto) {
 		return
 	}
+	if err := validateProfileMemory(dto); err != nil {
+		writeError(w, http.StatusBadRequest, err.Error())
+		return
+	}
 
 	updated := config.Profile{
-		ID:         id,
+		ID:            id,
-		Title:      dto.Title,
+		Title:         dto.Title,
-		JavaMemory: dto.JavaMemory,
+		JavaMemory:    dto.JavaMemory,
-		ExtraArgs:  dto.ExtraArgs,
+		JavaMemoryMin: dto.JavaMemoryMin,
+		ExtraArgs:     dto.ExtraArgs,
 		// Пустой пароль означает "оставить прежний": наружу мы его не отдаём,
 		// и форма присылает пустую строку, пока его не меняли.
 		AdminPassword: current.AdminPassword,

internal/api/handlers_tasks.go

@@ -236,12 +236,16 @@ func StartBackupScheduler(ctx context.Context, s *Server) {
 // При обычном старте то же самое делает супервизор.
 func (s *Server) applyJavaMemory(log func(string)) error {
 	profile := s.cfg.ActiveProfile()
-	if profile.JavaMemory == "" {
+	if profile.JavaMemory == "" && profile.JavaMemoryMin == "" {
 		return nil
 	}
-	if err := pzconfig.SetJavaMemory(s.cfg.ServerDir, profile.JavaMemory); err != nil {
+	if err := pzconfig.SetJavaMemory(s.cfg.ServerDir, profile.JavaMemory, profile.JavaMemoryMin); err != nil {
 		return err
 	}
-	log("Лимит памяти JVM выставлен: " + profile.JavaMemory)
+	if profile.JavaMemoryMin != "" {
+		log(fmt.Sprintf("Память JVM: от %s до %s", profile.JavaMemoryMin, profile.JavaMemory))
+	} else {
+		log("Лимит памяти JVM выставлен: " + profile.JavaMemory)
+	}
 	return nil
 }

internal/config/config.go

@@ -34,6 +34,11 @@ type Profile struct {
 	// запуске: файл запуска сервера общий для всех профилей.
 	JavaMemory string `yaml:"java_memory"`
 
+	// JavaMemoryMin — -Xms. Пусто (по умолчанию) означает, что JVM занимает
+	// память по мере надобности: равные -Xms и -Xmx заставляют её забрать всё
+	// сразу, и на машине с небольшой ОЗУ сервер не поднимется.
+	JavaMemoryMin string `yaml:"java_memory_min"`
+
 	// ExtraArgs — дополнительные аргументы start-server.sh.
 	ExtraArgs []string `yaml:"extra_args"`
 }

internal/pzconfig/java.go

@@ -6,24 +6,71 @@ import (
 	"os"
 	"path/filepath"
 	"regexp"
+	"strconv"
 	"strings"
 )
 
 // javaLauncherFile — файл, из которого сервер берёт аргументы JVM.
 const javaLauncherFile = "ProjectZomboid64.json"
 
-var xmxRe = regexp.MustCompile(`^-Xm[sx]`)
+var (
+	heapArgRe = regexp.MustCompile(`^-Xm[sx]`)
+	memoryRe  = regexp.MustCompile(`^([0-9]+)([kKmMgG])$`)
+)
 
-// SetJavaMemory прописывает лимит памяти JVM в ProjectZomboid64.json. Именно
+// ParseMemory переводит запись вида "4g" в байты. Возвращает 0, если строка
-// оттуда start-server.sh берёт -Xmx, поэтому менять размер памяти в аргументах
+// пустая, и ошибку, если формат непонятен.
-// запуска бесполезно.
+func ParseMemory(value string) (int64, error) {
-func SetJavaMemory(serverDir, memory string) error {
+	value = strings.TrimSpace(value)
-	memory = strings.TrimSpace(memory)
+	if value == "" {
-	if memory == "" {
+		return 0, nil
+	}
+	match := memoryRe.FindStringSubmatch(value)
+	if match == nil {
+		return 0, fmt.Errorf("объём памяти должен выглядеть как 4g или 8192m, получено %q", value)
+	}
+	amount, err := strconv.ParseInt(match[1], 10, 64)
+	if err != nil {
+		return 0, fmt.Errorf("не разобран объём памяти %q", value)
+	}
+	switch strings.ToLower(match[2]) {
+	case "k":
+		return amount * 1024, nil
+	case "m":
+		return amount * 1024 * 1024, nil
+	default:
+		return amount * 1024 * 1024 * 1024, nil
+	}
+}
+
+// SetJavaMemory прописывает границы кучи JVM в ProjectZomboid64.json. Именно
+// оттуда start-server.sh берёт -Xmx и -Xms, поэтому менять размер памяти в
+// аргументах запуска бесполезно.
+//
+// maxMemory задаёт -Xmx (верхнюю границу), minMemory — -Xms. Пустой minMemory
+// означает, что -Xms не выставляется вовсе: JVM тогда занимает память по мере
+// надобности. Равные значения удобны тем, что куча не растёт на ходу, но JVM
+// обязана занять весь объём при старте — на машине с небольшой ОЗУ сервер
+// просто не поднимется.
+func SetJavaMemory(serverDir, maxMemory, minMemory string) error {
+	maxMemory = strings.TrimSpace(maxMemory)
+	minMemory = strings.TrimSpace(minMemory)
+	if maxMemory == "" && minMemory == "" {
 		return nil
 	}
-	if !regexp.MustCompile(`^[0-9]+[kKmMgG]$`).MatchString(memory) {
+
-		return fmt.Errorf("объём памяти должен выглядеть как 4g или 8192m, получено %q", memory)
+	maxBytes, err := ParseMemory(maxMemory)
+	if err != nil {
+		return err
+	}
+	minBytes, err := ParseMemory(minMemory)
+	if err != nil {
+		return err
+	}
+	// JVM с -Xms больше -Xmx не стартует вообще, поэтому ловим это здесь, а не
+	// в логе упавшего сервера.
+	if maxBytes > 0 && minBytes > maxBytes {
+		return fmt.Errorf("начальный размер кучи (%s) больше максимального (%s)", minMemory, maxMemory)
 	}
 
 	path := filepath.Join(serverDir, javaLauncherFile)
@@ -41,14 +88,17 @@ func SetJavaMemory(serverDir, memory string) error {
 	args, _ := doc["vmArgs"].([]any)
 	updated := make([]any, 0, len(args)+2)
 	for _, a := range args {
-		if str, ok := a.(string); ok && xmxRe.MatchString(str) {
+		if str, ok := a.(string); ok && heapArgRe.MatchString(str) {
 			continue
 		}
 		updated = append(updated, a)
 	}
-	// -Xms равным -Xmx: JVM сразу забирает память и не тратит время на рост
+	if minMemory != "" {
-	// кучи в момент, когда на сервере много игроков.
+		updated = append(updated, "-Xms"+minMemory)
-	updated = append(updated, "-Xms"+memory, "-Xmx"+memory)
+	}
+	if maxMemory != "" {
+		updated = append(updated, "-Xmx"+maxMemory)
+	}
 	doc["vmArgs"] = updated
 
 	out, err := json.MarshalIndent(doc, "", "  ")

internal/pzconfig/java_test.go

@@ -0,0 +1,167 @@
+package pzconfig
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+// TestSetJavaMemoryKeepsOnlyXmx: -Xms равным -Xmx заставляет JVM занять весь
+// объём при старте, и на машине с небольшой ОЗУ сервер падает с «Failed to
+// allocate initial Java heap». Ставим только верхнюю границу.
+func TestSetJavaMemoryKeepsOnlyXmx(t *testing.T) {
+	dir := t.TempDir()
+	writeLauncher(t, dir, map[string]any{
+		"mainClass": "zombie/network/GameServer",
+		"vmArgs": []any{
+			"-Djava.awt.headless=true",
+			"-XX:+UseZGC",
+			// Значения от прошлой установки должны замениться.
+			"-Xms8g",
+			"-Xmx8g",
+		},
+	})
+
+	if err := SetJavaMemory(dir, "3g", ""); err != nil {
+		t.Fatal(err)
+	}
+
+	args := launcherArgs(t, dir)
+	var xms, xmx int
+	for _, a := range args {
+		switch {
+		case len(a) > 4 && a[:4] == "-Xms":
+			xms++
+			t.Errorf("в аргументах остался %s — JVM займёт всю память при старте", a)
+		case a == "-Xmx3g":
+			xmx++
+		}
+	}
+	if xms != 0 {
+		t.Errorf("-Xms не должен добавляться, найдено вхождений: %d", xms)
+	}
+	if xmx != 1 {
+		t.Errorf("-Xmx3g встречается %d раз, ожидалось 1: %v", xmx, args)
+	}
+
+	// Чужие аргументы должны остаться нетронутыми.
+	if !contains(args, "-XX:+UseZGC") || !contains(args, "-Djava.awt.headless=true") {
+		t.Errorf("потеряны исходные аргументы: %v", args)
+	}
+}
+
+func TestSetJavaMemoryValidates(t *testing.T) {
+	dir := t.TempDir()
+	writeLauncher(t, dir, map[string]any{"vmArgs": []any{}})
+
+	for _, bad := range []string{"4", "4gb", "много", "-4g", "4g; rm -rf /"} {
+		if err := SetJavaMemory(dir, bad, ""); err == nil {
+			t.Errorf("значение %q принято, ожидалась ошибка", bad)
+		}
+	}
+	// Пустые значения — «не трогать», это не ошибка.
+	if err := SetJavaMemory(dir, "", ""); err != nil {
+		t.Errorf("пустое значение вернуло ошибку: %v", err)
+	}
+	for _, good := range []string{"512m", "4g", "8G", "16384M"} {
+		if err := SetJavaMemory(dir, good, ""); err != nil {
+			t.Errorf("значение %q отклонено: %v", good, err)
+		}
+	}
+
+	// JVM с -Xms больше -Xmx не стартует, поэтому ловим это заранее.
+	if err := SetJavaMemory(dir, "2g", "4g"); err == nil {
+		t.Error("начальный размер больше максимального принят, ожидалась ошибка")
+	}
+	if err := SetJavaMemory(dir, "4g", "2g"); err != nil {
+		t.Errorf("корректная пара 2g/4g отклонена: %v", err)
+	}
+}
+
+func writeLauncher(t *testing.T, dir string, doc map[string]any) {
+	t.Helper()
+	raw, err := json.MarshalIndent(doc, "", "  ")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, javaLauncherFile), raw, 0o644); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func launcherArgs(t *testing.T, dir string) []string {
+	t.Helper()
+	raw, err := os.ReadFile(filepath.Join(dir, javaLauncherFile))
+	if err != nil {
+		t.Fatal(err)
+	}
+	var doc struct {
+		VMArgs []string `json:"vmArgs"`
+	}
+	if err := json.Unmarshal(raw, &doc); err != nil {
+		t.Fatal(err)
+	}
+	return doc.VMArgs
+}
+
+func contains(list []string, want string) bool {
+	for _, item := range list {
+		if item == want {
+			return true
+		}
+	}
+	return false
+}
+
+// TestSetJavaMemoryWritesXmsWhenAsked: минимальный размер кучи задаётся
+// отдельно и попадает в файл, только если его действительно указали.
+func TestSetJavaMemoryWritesXmsWhenAsked(t *testing.T) {
+	dir := t.TempDir()
+	writeLauncher(t, dir, map[string]any{"vmArgs": []any{"-XX:+UseZGC"}})
+
+	if err := SetJavaMemory(dir, "6g", "2g"); err != nil {
+		t.Fatal(err)
+	}
+	args := launcherArgs(t, dir)
+	if !contains(args, "-Xms2g") || !contains(args, "-Xmx6g") {
+		t.Fatalf("границы кучи не выставлены: %v", args)
+	}
+
+	// Убрали минимум — из файла он тоже должен уйти.
+	if err := SetJavaMemory(dir, "6g", ""); err != nil {
+		t.Fatal(err)
+	}
+	args = launcherArgs(t, dir)
+	for _, a := range args {
+		if len(a) > 4 && a[:4] == "-Xms" {
+			t.Errorf("после очистки минимума остался %s: %v", a, args)
+		}
+	}
+	if !contains(args, "-Xmx6g") {
+		t.Errorf("максимум потерян: %v", args)
+	}
+}
+
+func TestParseMemory(t *testing.T) {
+	cases := map[string]int64{
+		"":      0,
+		"512m":  512 * 1024 * 1024,
+		"4g":    4 * 1024 * 1024 * 1024,
+		"8G":    8 * 1024 * 1024 * 1024,
+		"1024k": 1024 * 1024,
+	}
+	for input, want := range cases {
+		got, err := ParseMemory(input)
+		if err != nil {
+			t.Errorf("ParseMemory(%q): %v", input, err)
+			continue
+		}
+		if got != want {
+			t.Errorf("ParseMemory(%q) = %d, ожидалось %d", input, got, want)
+		}
+	}
+	if _, err := ParseMemory("4гб"); err == nil {
+		t.Error("значение с кириллицей принято")
+	}
+}

internal/pzserver/supervisor.go

@@ -23,10 +23,13 @@ import (
 type State string
 
 const (
-	StateStopped  State = "stopped"
+	StateStopped State = "stopped"
-	StateStarting State = "starting"
+	// StateRestarting — сервер упал и ждёт автоподъёма. Отдельное состояние
-	StateRunning  State = "running"
+	// нужно, чтобы это ожидание можно было отменить кнопкой.
-	StateStopping State = "stopping"
+	StateRestarting State = "restarting"
+	StateStarting   State = "starting"
+	StateRunning    State = "running"
+	StateStopping   State = "stopping"
 )
 
 // Ошибки, на которые HTTP-слой отвечает осмысленным кодом.
@@ -42,20 +45,30 @@ const playersPollInterval = 30 * time.Second
 // restartDelay — пауза перед автоподъёмом упавшего сервера.
 const restartDelay = 10 * time.Second
 
+// Сервер, падающий сразу после старта, автоперезапуском не лечится: обычно
+// это нехватка памяти или испорченный конфиг. После нескольких таких падений
+// подряд перестаём поднимать его сам, чтобы не крутить бесконечный цикл.
+const (
+	quickCrashWindow = time.Minute
+	maxQuickCrashes  = 3
+)
+
 // Status — снимок состояния для веб-панели.
 type Status struct {
 	State State `json:"state"`
 	// Profile и ProfileTitle описывают профиль, который сейчас работает
 	// (а если сервер остановлен — который будет запущен).
-	Profile      string            `json:"profile"`
+	Profile      string   `json:"profile"`
-	ProfileTitle string            `json:"profile_title"`
+	ProfileTitle string   `json:"profile_title"`
-	Installed    bool              `json:"installed"`
+	Installed    bool     `json:"installed"`
-	PID          int               `json:"pid"`
+	PID          int      `json:"pid"`
-	UptimeSec    int64             `json:"uptime_sec"`
+	UptimeSec    int64    `json:"uptime_sec"`
-	Players      []string          `json:"players"`
+	Players      []string `json:"players"`
-	PlayersAt    int64             `json:"players_at"`
+	PlayersAt    int64    `json:"players_at"`
-	LastExit     string            `json:"last_exit"`
+	LastExit     string   `json:"last_exit"`
-	AutoRestart  bool              `json:"auto_restart"`
+	AutoRestart  bool     `json:"auto_restart"`
+	// RestartInSec — сколько секунд осталось до автоподъёма (0, если не ждём).
+	RestartInSec int64             `json:"restart_in_sec"`
 	Proc         sysinfo.ProcStats `json:"proc"`
 	Host         sysinfo.HostStats `json:"host"`
 }
@@ -89,6 +102,13 @@ type Supervisor struct {
 	captured  []string
 	autoQuery bool
 
+	// restartCancel закрывается, чтобы отменить ожидание автоперезапуска;
+	// restartAt — когда оно закончится.
+	restartCancel chan struct{}
+	restartAt     time.Time
+	// crashStreak — сколько раз подряд сервер упал сразу после запуска.
+	crashStreak int
+
 	sampler  *sysinfo.Sampler
 	stopOnce sync.Once
 	quit     chan struct{}
@@ -165,9 +185,14 @@ func (s *Supervisor) Status() Status {
 	if s.cmd != nil && s.cmd.Process != nil {
 		st.PID = s.cmd.Process.Pid
 	}
-	if !s.startedAt.IsZero() && s.state != StateStopped {
+	if !s.startedAt.IsZero() && s.state != StateStopped && s.state != StateRestarting {
 		st.UptimeSec = int64(time.Since(s.startedAt).Seconds())
 	}
+	if s.state == StateRestarting && !s.restartAt.IsZero() {
+		if left := time.Until(s.restartAt).Seconds(); left > 0 {
+			st.RestartInSec = int64(left + 0.5)
+		}
+	}
 	s.mu.Unlock()
 
 	st.Installed = s.Installed()
@@ -185,9 +210,28 @@ func (s *Supervisor) Status() Status {
 func (s *Supervisor) Start() error {
 	s.mu.Lock()
 	defer s.mu.Unlock()
+
+	// Запуск руками — знак, что причину падений устранили.
+	s.crashStreak = 0
+	// Если ждали автоподъёма, поднимаем немедленно.
+	s.cancelRestartLocked()
 	return s.startLocked()
 }
 
+// cancelRestartLocked снимает запланированный автоперезапуск. Вызывается под
+// удержанным s.mu.
+func (s *Supervisor) cancelRestartLocked() {
+	if s.restartCancel == nil {
+		return
+	}
+	close(s.restartCancel)
+	s.restartCancel = nil
+	s.restartAt = time.Time{}
+	if s.state == StateRestarting {
+		s.state = StateStopped
+	}
+}
+
 func (s *Supervisor) startLocked() error {
 	if s.state != StateStopped {
 		return ErrAlreadyRunning
@@ -204,8 +248,8 @@ func (s *Supervisor) startLocked() error {
 	profile := s.cfg.ActiveProfile()
 	// Лимит памяти живёт в файле запуска, общем для всех профилей, поэтому
 	// выставляем его на каждом старте — иначе профиль унаследует чужой -Xmx.
-	if err := pzconfig.SetJavaMemory(s.cfg.ServerDir, profile.JavaMemory); err != nil {
+	if err := pzconfig.SetJavaMemory(s.cfg.ServerDir, profile.JavaMemory, profile.JavaMemoryMin); err != nil {
-		s.AppendLog("manager", "Не удалось выставить лимит памяти JVM: "+err.Error())
+		s.AppendLog("manager", "Не удалось выставить границы памяти JVM: "+err.Error())
 	}
 
 	args := []string{"-servername", profile.ID}
@@ -322,6 +366,8 @@ func (s *Supervisor) wait(cmd *exec.Cmd, exited chan struct{}) {
 	err := cmd.Wait()
 	close(exited)
 
+	lifetime := time.Since(s.startedAt)
+
 	s.mu.Lock()
 	wasIntentional := s.intentionalStop
 	s.state = StateStopped
@@ -336,6 +382,15 @@ func (s *Supervisor) wait(cmd *exec.Cmd, exited chan struct{}) {
 		s.lastExit = "штатное завершение"
 	}
 	reason := s.lastExit
+
+	// Падение сразу после запуска — признак того, что перезапуск не поможет:
+	// не хватило памяти, испорчен конфиг, нет файлов сервера.
+	if !wasIntentional && lifetime < quickCrashWindow {
+		s.crashStreak++
+	} else {
+		s.crashStreak = 0
+	}
+	streak := s.crashStreak
 	autoRestart := s.cfg.AutoRestart && !wasIntentional
 	s.mu.Unlock()
 
@@ -343,14 +398,38 @@ func (s *Supervisor) wait(cmd *exec.Cmd, exited chan struct{}) {
 	if !autoRestart {
 		return
 	}
+	if streak >= maxQuickCrashes {
+		s.AppendLog("manager", fmt.Sprintf(
+			"Сервер падает сразу после запуска %d раза подряд — автоперезапуск остановлен. "+
+				"Посмотрите ошибку выше и запустите сервер вручную.", streak))
+		return
+	}
+
+	s.mu.Lock()
+	cancel := make(chan struct{})
+	s.restartCancel = cancel
+	s.restartAt = time.Now().Add(restartDelay)
+	s.state = StateRestarting
+	s.mu.Unlock()
+
+	s.AppendLog("manager", fmt.Sprintf("Автоперезапуск через %s (можно отменить кнопкой «Остановить»)", restartDelay))
 
-	s.AppendLog("manager", fmt.Sprintf("Автоперезапуск через %s", restartDelay))
 	select {
 	case <-time.After(restartDelay):
+	case <-cancel:
+		// Состояние уже переставил тот, кто отменил ожидание.
+		s.AppendLog("manager", "Автоперезапуск отменён")
+		return
 	case <-s.quit:
 		return
 	}
+
 	s.mu.Lock()
+	s.restartCancel = nil
+	s.restartAt = time.Time{}
+	if s.state == StateRestarting {
+		s.state = StateStopped
+	}
 	err = s.startLocked()
 	s.mu.Unlock()
 	if err != nil && !errors.Is(err, ErrAlreadyRunning) {
@@ -394,6 +473,12 @@ func (s *Supervisor) sendQuiet(command string) error {
 // мир), затем SIGTERM группе процессов и в крайнем случае SIGKILL.
 func (s *Supervisor) Stop() error {
 	s.mu.Lock()
+	// Ждём автоподъёма — «остановить» здесь значит «не поднимать».
+	if s.state == StateRestarting {
+		s.cancelRestartLocked()
+		s.mu.Unlock()
+		return nil
+	}
 	if s.state == StateStopped || s.cmd == nil {
 		s.mu.Unlock()
 		return ErrNotRunning

internal/updater/updater.go

@@ -16,6 +16,7 @@ import (
 	"fmt"
 	"net/http"
 	"os/exec"
+	"sort"
 	"strconv"
 	"strings"
 	"time"
@@ -27,6 +28,14 @@ const adminCommand = "pzmanager-admin"
 // ErrNoAdmin возвращается, когда обновление из панели недоступно.
 var ErrNoAdmin = errors.New("обновление из панели недоступно: нет pzmanager-admin или правила sudo")
 
+// ReleaseNote — одна версия в списке изменений.
+type ReleaseNote struct {
+	Version   string `json:"version"`
+	Notes     string `json:"notes"`
+	Published int64  `json:"published"`
+	URL       string `json:"url"`
+}
+
 // Info — то, что панель показывает в разделе обновления.
 type Info struct {
 	Current   string `json:"current"`
@@ -40,6 +49,10 @@ type Info struct {
 	CanApply bool `json:"can_apply"`
 	// ManualCommand — что выполнить в терминале, если сама не может.
 	ManualCommand string `json:"manual_command"`
+	// Changelog — все версии между установленной и последней, свежие первыми.
+	// Одного описания последнего релиза мало: пропустив пару версий, человек
+	// не увидит, что менялось в промежутке.
+	Changelog []ReleaseNote `json:"changelog"`
 	// Error — почему не удалось узнать последнюю версию.
 	Error string `json:"error,omitempty"`
 }
@@ -75,12 +88,14 @@ func (u *Updater) apiBase() (string, error) {
 	return fmt.Sprintf("%s://%s/api/v1/repos/%s", scheme, host, path), nil
 }
 
-// Check спрашивает у Gitea последний релиз и сравнивает его с текущей версией.
+// Check спрашивает у Gitea список релизов и оставляет те, что новее
+// установленной версии.
 func (u *Updater) Check(ctx context.Context) Info {
 	info := Info{
 		Current:       u.Version,
 		CanApply:      u.CanApply(ctx),
 		ManualCommand: u.manualCommand(),
+		Changelog:     []ReleaseNote{},
 	}
 
 	api, err := u.apiBase()
@@ -89,7 +104,10 @@ func (u *Updater) Check(ctx context.Context) Info {
 		return info
 	}
 
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, api+"/releases/latest", nil)
+	// limit с запасом: показываем изменения за все пропущенные версии, но не
+	// тянем историю репозитория целиком.
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet,
+		api+"/releases?limit=30&draft=false", nil)
 	if err != nil {
 		info.Error = err.Error()
 		return info
@@ -101,36 +119,73 @@ func (u *Updater) Check(ctx context.Context) Info {
 	}
 	defer resp.Body.Close()
 
-	if resp.StatusCode == http.StatusNotFound {
-		info.Error = "в репозитории ещё нет релизов"
-		return info
-	}
 	if resp.StatusCode != http.StatusOK {
 		info.Error = "репозиторий ответил " + resp.Status
 		return info
 	}
 
-	var release struct {
+	var releases []struct {
 		TagName     string    `json:"tag_name"`
 		Body        string    `json:"body"`
 		HTMLURL     string    `json:"html_url"`
 		PublishedAt time.Time `json:"published_at"`
+		Draft       bool      `json:"draft"`
+		Prerelease  bool      `json:"prerelease"`
 	}
-	if err := json.NewDecoder(resp.Body).Decode(&release); err != nil {
+	if err := json.NewDecoder(resp.Body).Decode(&releases); err != nil {
 		info.Error = "ответ репозитория не разобран: " + err.Error()
 		return info
 	}
 
-	info.Latest = release.TagName
+	notes := make([]ReleaseNote, 0, len(releases))
-	info.Notes = release.Body
+	for _, r := range releases {
-	info.URL = release.HTMLURL
+		if r.Draft || r.Prerelease || r.TagName == "" {
-	if !release.PublishedAt.IsZero() {
+			continue
-		info.Published = release.PublishedAt.Unix()
+		}
+		note := ReleaseNote{Version: r.TagName, Notes: r.Body, URL: r.HTMLURL}
+		if !r.PublishedAt.IsZero() {
+			note.Published = r.PublishedAt.Unix()
+		}
+		notes = append(notes, note)
 	}
-	info.Available = IsNewer(u.Version, release.TagName)
+	if len(notes) == 0 {
+		info.Error = "в репозитории ещё нет релизов"
+		return info
+	}
+
+	// Gitea отдаёт релизы свежими вперёд, но полагаться на это не станем.
+	sort.Slice(notes, func(i, j int) bool {
+		if IsNewer(notes[j].Version, notes[i].Version) {
+			return true
+		}
+		if IsNewer(notes[i].Version, notes[j].Version) {
+			return false
+		}
+		return notes[i].Published > notes[j].Published
+	})
+
+	latest := notes[0]
+	info.Latest = latest.Version
+	info.Notes = latest.Notes
+	info.URL = latest.URL
+	info.Published = latest.Published
+	info.Available = IsNewer(u.Version, latest.Version)
+	info.Changelog = NewerThan(notes, u.Version)
 	return info
 }
 
+// NewerThan оставляет из списка релизы новее указанной версии, сохраняя
+// порядок «свежие первыми».
+func NewerThan(notes []ReleaseNote, current string) []ReleaseNote {
+	out := make([]ReleaseNote, 0, len(notes))
+	for _, note := range notes {
+		if IsNewer(current, note.Version) {
+			out = append(out, note)
+		}
+	}
+	return out
+}
+
 // CanApply проверяет, что привилегированный скрипт на месте и sudo пускает к
 // нему без пароля. Проверяем вызовом: наличие файла ещё не значит, что
 // правило sudoers действует.

internal/updater/updater_test.go

@@ -57,3 +57,33 @@ func TestAPIBase(t *testing.T) {
 		}
 	}
 }
+
+func TestNewerThan(t *testing.T) {
+	notes := []ReleaseNote{
+		{Version: "v0.3.0"},
+		{Version: "v0.2.2"},
+		{Version: "v0.2.1"},
+		{Version: "v0.2.0"},
+		{Version: "v0.1.3"},
+	}
+
+	got := NewerThan(notes, "v0.2.0")
+	want := []string{"v0.3.0", "v0.2.2", "v0.2.1"}
+	if len(got) != len(want) {
+		t.Fatalf("отобрано %d версий, ожидалось %d: %v", len(got), len(want), got)
+	}
+	for i, version := range want {
+		if got[i].Version != version {
+			t.Errorf("changelog[%d] = %s, ожидалось %s", i, got[i].Version, version)
+		}
+	}
+
+	// На последней версии показывать нечего.
+	if got := NewerThan(notes, "v0.3.0"); len(got) != 0 {
+		t.Errorf("на последней версии отобрано %d записей: %v", len(got), got)
+	}
+	// Сборка из рабочей копии не знает своей версии — показываем всё.
+	if got := NewerThan(notes, "dev"); len(got) != len(notes) {
+		t.Errorf("для dev отобрано %d из %d записей", len(got), len(notes))
+	}
+}

web/static/app.js

@@ -94,6 +94,7 @@ function escapeHTML(value) {
 
 const STATE_LABELS = {
   stopped: "Остановлен",
+  restarting: "Ждёт перезапуска",
   starting: "Запускается",
   running: "Работает",
   stopping: "Останавливается",
@@ -230,8 +231,18 @@ async function refreshStatus() {
   renderTask(data.task);
 }
 
+// hostStats нужен карточкам профилей: там подсказываем, сколько памяти можно
+// отдать JVM, чтобы не выбирать объём вслепую.
+let hostStats = {};
+
 function renderStatus(status) {
-  const label = STATE_LABELS[status.state] || status.state;
+  hostStats = status.host || {};
+  let label = STATE_LABELS[status.state] || status.state;
+  // Пока идёт обратный отсчёт, показываем, сколько осталось: иначе непонятно,
+  // происходит ли вообще что-нибудь.
+  if (status.state === "restarting" && status.restart_in_sec > 0) {
+    label = `Перезапуск через ${status.restart_in_sec} с`;
+  }
   $("#status-text").textContent = label;
   $("#status-dot").className = `dot ${status.state}`;
 
@@ -274,8 +285,13 @@ function renderStatus(status) {
     : "Займёт несколько минут и около 3 ГБ на диске — прогресс виден во вкладке «Консоль».";
 
   const running = status.state !== "stopped";
-  $("#btn-start").disabled = running || !status.installed;
+  const waitingRestart = status.state === "restarting";
+
+  // В ожидании автоподъёма обе кнопки осмысленны: «Запустить» поднимает
+  // сервер сразу, «Остановить» отменяет перезапуск.
+  $("#btn-start").disabled = (running && !waitingRestart) || !status.installed;
   $("#btn-stop").disabled = !running;
+  $("#btn-stop").textContent = waitingRestart ? "Отменить перезапуск" : "Остановить";
   $("#btn-restart").disabled = !status.installed;
   $("#btn-install").disabled = running;
 
@@ -283,16 +299,19 @@ function renderStatus(status) {
   // и команда всё равно вернулась бы ошибкой.
   const consoleInput = $("#console-command");
   const consoleButton = $("#console-form").querySelector("button[type=submit]");
-  consoleInput.disabled = !running;
+  // Процесс есть только в этих двух состояниях; в ожидании перезапуска писать
-  consoleButton.disabled = !running;
+  // некуда, хотя формально сервер и не «остановлен».
-  consoleInput.placeholder = running
+  const consoleReady = status.state === "running" || status.state === "starting";
+  consoleInput.disabled = !consoleReady;
+  consoleButton.disabled = !consoleReady;
+  consoleInput.placeholder = consoleReady
     ? "Команда сервера, например: players, save, quit"
     : "Сервер остановлен — консоль принимает команды только на работающем";
 
   // Профили делят игровые порты и файл запуска, поэтому переключать их можно
   // только на остановленном сервере.
   const picker = $("#profile-select");
-  picker.disabled = running;
+  picker.disabled = running && !waitingRestart;
   picker.title = running
     ? "Остановите сервер, чтобы переключить профиль"
     : "Профиль сервера: свой мир, конфиг и моды";
@@ -331,8 +350,11 @@ async function serverAction(path, confirmText) {
 }
 
 $("#btn-start").addEventListener("click", () => serverAction("/api/server/start"));
-$("#btn-stop").addEventListener("click", () =>
+$("#btn-stop").addEventListener("click", () => {
-  serverAction("/api/server/stop", "Остановить игровой сервер? Игроки будут отключены."));
+  // Отмена перезапуска ничего не рушит, спрашивать незачем.
+  const waiting = $("#btn-stop").textContent === "Отменить перезапуск";
+  serverAction("/api/server/stop", waiting ? "" : "Остановить игровой сервер? Игроки будут отключены.");
+});
 $("#btn-restart").addEventListener("click", () =>
   serverAction("/api/server/restart", "Перезапустить сервер? Игроки будут отключены."));
 
@@ -1048,8 +1070,16 @@ function renderProfileCards() {
           <input type="text" data-field="title" value="${escapeHTML(p.title || "")}">
         </label>
         <label class="field">
-          <span>Память JVM</span>
+          <span>Память JVM, максимум</span>
           <input type="text" data-field="java_memory" value="${escapeHTML(p.java_memory || "")}">
+          <small>${escapeHTML(memoryHint())}</small>
+        </label>
+        <label class="field">
+          <span>Память JVM, начальная</span>
+          <input type="text" data-field="java_memory_min" value="${escapeHTML(p.java_memory_min || "")}"
+                 placeholder="не задана">
+          <small>Пусто — JVM берёт память по мере надобности. Если задать, она
+            займёт этот объём сразу при старте и не сможет подняться, когда его нет.</small>
         </label>
         <label class="field">
           <span>Пароль админа игры</span>
@@ -1069,6 +1099,15 @@ function renderProfileCards() {
 
 // renderCopySource предлагает копировать настройки только с тех профилей, у
 // которых конфиг уже создан игрой.
+// memoryHint подсказывает разумный потолок: JVM должна поместиться в свободную
+// память, иначе сервер не поднимется вовсе.
+function memoryHint() {
+  if (!hostStats.mem_total_bytes) return "Например 4g";
+  const total = formatBytes(hostStats.mem_total_bytes);
+  const free = formatBytes(hostStats.mem_available_bytes);
+  return `На машине ${total} ОЗУ, свободно ${free}. Оставьте запас системе.`;
+}
+
 function renderCopySource() {
   $("#new-profile-copy").innerHTML =
     `<option value="">не копировать</option>` +
@@ -1110,6 +1149,7 @@ $("#profile-cards").addEventListener("click", async (event) => {
         await put(`/api/profiles/${encodeURIComponent(id)}`, {
           title: field("title"),
           java_memory: field("java_memory"),
+          java_memory_min: field("java_memory_min"),
           admin_password: field("admin_password"),
         });
         ok("Профиль сохранён");
@@ -1262,8 +1302,13 @@ async function loadUpdateInfo() {
   }
 
   const notes = $("#update-notes");
-  notes.hidden = !(info.available && info.notes);
+  const changelog = info.changelog || [];
-  if (!notes.hidden) renderReleaseNotes(info.notes, info.url);
+  notes.hidden = !(info.available && changelog.length);
+  if (!notes.hidden) {
+    notes.querySelector("summary").textContent =
+      changelog.length > 1 ? `Что нового (версий: ${changelog.length})` : "Что нового";
+    renderChangelog(changelog);
+  }
 
   $("#btn-manager-restart").disabled = !info.can_apply;
   $("#btn-manager-restart").title = info.can_apply
@@ -1274,40 +1319,56 @@ async function loadUpdateInfo() {
 // Описание релиза приходит из Gitea разметкой Markdown, и показывать её как
 // есть неудобно: первым идёт раздел про установку, который в уже работающей
 // панели ни к чему. Берём только список изменений.
-function renderReleaseNotes(text, url) {
+function releaseItems(text) {
-  const body = $("#update-notes-body");
+  const changes = text.split(/^##\s+Изменения\s*$/m)[1];
-  body.replaceChildren();
+  return (changes ?? text)
-
-  const changesSection = text.split(/^##\s+Изменения\s*$/m)[1];
-  const items = (changesSection ?? text)
     .split("\n")
     .map((line) => line.trim())
     .filter((line) => line.startsWith("- "))
     .map((line) => line.slice(2).trim())
     .filter(Boolean);
+}
+
+// renderChangelog показывает изменения всех версий между установленной и
+// последней: пропустив несколько релизов, иначе не узнать, что было в них.
+function renderChangelog(releases) {
+  const body = $("#update-notes-body");
+  body.replaceChildren();
+
+  releases.forEach((release) => {
+    const heading = document.createElement("h4");
+    heading.className = "release-version";
+    heading.textContent = release.published
+      ? `${release.version} — ${formatDate(release.published)}`
+      : release.version;
+    body.appendChild(heading);
+
+    const items = releaseItems(release.notes || "");
+    if (items.length) {
+      const list = document.createElement("ul");
+      items.forEach((item) => {
+        const li = document.createElement("li");
+        li.textContent = item;
+        list.appendChild(li);
+      });
+      body.appendChild(list);
+      return;
+    }
 
-  if (items.length) {
-    const list = document.createElement("ul");
-    items.forEach((item) => {
-      const li = document.createElement("li");
-      li.textContent = item;
-      list.appendChild(li);
-    });
-    body.appendChild(list);
-  } else {
     // Непривычный формат описания — показываем как есть, лишь бы не потерять.
     const raw = document.createElement("pre");
-    raw.textContent = text.trim();
+    raw.textContent = (release.notes || "").trim() || "Описание не заполнено";
     body.appendChild(raw);
-  }
+  });
 
-  if (url) {
+  const newest = releases[0];
+  if (newest && newest.url) {
     const link = document.createElement("a");
-    link.href = url;
+    link.href = newest.url;
     link.target = "_blank";
     link.rel = "noopener noreferrer";
     link.className = "release-link";
-    link.textContent = "Полное описание релиза";
+    link.textContent = "Полное описание релизов";
     body.appendChild(link);
   }
 }

web/static/style.css

@@ -108,7 +108,7 @@ code {
   background: var(--muted);
 }
 .dot.running { background: var(--accent); box-shadow: 0 0 8px var(--accent); }
-.dot.starting, .dot.stopping { background: var(--warn); animation: pulse 1.2s infinite; }
+.dot.starting, .dot.stopping, .dot.restarting { background: var(--warn); animation: pulse 1.2s infinite; }
 .dot.stopped { background: #5b636f; }
 
 @keyframes pulse { 50% { opacity: .35; } }
@@ -477,6 +477,15 @@ input.input-sm, .input-sm { width: auto; padding: 6px 10px; font-size: 13px; }
   line-height: 1.5;
 }
 
+.release-version {
+  margin: 14px 0 6px;
+  font-size: 13px;
+  color: var(--accent);
+  text-transform: none;
+  letter-spacing: 0;
+}
+.release-version:first-child { margin-top: 0; }
+
 .release-notes ul { margin: 0; padding-left: 20px; }
 .release-notes li { margin-bottom: 5px; }
 .release-notes li:last-child { margin-bottom: 0; }