修复：自更新每次都被静默回滚，前端卡在「正在重启并加载新版本…」

RollbackIfStale 跑在启动早期，而清除待验证标记的 MarkHealthy 要等端口监听
成功之后才执行。于是「标记还在」这个判据永远成立 —— 新版本刚起来的那一刻
就被判定成「上次更新后没能启动」，二进制被换回旧版再重启一次。

结果是每一次自更新都悄悄回退。前端轮询 /api/version 拿到的一直是旧版本号，
永远等不到目标版本，转满 60 秒才超时。用户看到的是「更新卡住了」，
实际上是更新成功之后又被自己撤销了。

修法：待验证标记里记「带着这个标记启动过几次」。
  0 次 = 新版本头一回启动 → 放行，让它自己跑到 MarkHealthy 把标记删掉
  ≥1 次 = 上一回带着标记启动过却没撑到 MarkHealthy → 这才是真的起不来，回滚
老版本写的标记内容是 "1"，正好落在「已经启动过一次」这一档，升级上来语义正确。

顺带去掉健康信号那个 3 秒 sleep：改成自己 net.Listen，拿到 listener 就是
确凿的启动成功信号。原来靠「睡几秒应该起来了」猜，猜早了端口还没占上就
宣布健康，猜晚了这几秒内被重启一次会被误判成启动失败。

回归测试补了 4 个，覆盖首次启动放行、第二次才回滚、成功路径不留残留、
以及认得老版本的标记。把修复临时改回旧逻辑验证过：前三个会红。

受影响版本 v0.1.2 / v0.1.3 的用户没法用在线更新升上来（点了会转到超时），
需要手动替换一次二进制；换到这一版之后在线更新就正常了。

Author: gokele

VERSION

@@ -1 +1 @@
-0.1.3
+0.1.4

server/internal/updater/updater.go

@@ -29,6 +29,7 @@ import (
 	"os"
 	"path/filepath"
 	"runtime"
+	"strconv"
 	"strings"
 	"time"
 
@@ -369,13 +370,35 @@ func RollbackIfStale(state *app.State) bool {
 	if _, err := os.Stat(backup); err != nil {
 		return false
 	}
-	if _, err := os.Stat(pending); err != nil {
+	raw, perr := os.ReadFile(pending)
+	if perr != nil {
 		// 有备份但没有"启动中"标记:说明上次是正常起来过的(只是 MarkHealthy 没删掉),
 		// 清掉备份即可,不要回滚 —— 那会把用户刚更新好的版本又换回旧的。
 		_ = os.Remove(backup)
 		return false
 	}
 
+	// 标记里记的是"带着这个标记启动过几次"。
+	//
+	// 这里必须能区分「新版本正在启动」和「新版本上次没启动起来」——
+	// 而这个函数跑在启动早期,MarkHealthy 要等端口监听成功才执行,
+	// 所以光看"标记还在"永远是真的。之前就是这么写的,后果是每次自更新
+	// 都在新版本的第一次启动时被判定为失败、静默回滚成旧版本,
+	// 用户看到的是前端一直转"正在重启并加载新版本…"直到超时。
+	//
+	// 计数 0 = 新版本头一回启动,放行,让它自己跑到 MarkHealthy 把标记删掉;
+	// 计数 ≥1 = 上一回带着标记启动过却没能撑到 MarkHealthy,这才是真的起不来。
+	if boots := parseBoots(raw); boots < 1 {
+		if err := os.WriteFile(pending, []byte(strconv.Itoa(boots+1)), 0o644); err != nil {
+			// 写不进去就不能再放行:下次启动还会读到 0,永远滚不动,
+			// 等于回滚保护彻底失效。宁可这一次多回滚一遍。
+			state.Logger.Warn("[更新] 无法更新待验证标记,按保守策略回滚: "+err.Error(), "version")
+		} else {
+			state.Logger.Info("[更新] 新版本首次启动,回滚保护已就绪(启动成功后自动解除)", "version")
+			return false
+		}
+	}
+
 	state.Logger.Error("[更新] 检测到上一次更新后未能正常启动,正在回滚到更新前的版本", "version")
 	_ = os.Remove(pending)
 	if err := os.Rename(backup, exe); err != nil {
@@ -389,9 +412,23 @@ func RollbackIfStale(state *app.State) bool {
 // pendingSuffix "更新后待验证"标记
 const pendingSuffix = ".pending"
 
-// MarkPending 替换完二进制、准备重启前写下标记
+// MarkPending 替换完二进制、准备重启前写下标记。
+// 内容是"带着这个标记启动过几次",初始 0 —— 此刻新版本还一次都没启动过。
 func MarkPending() {
 	if exe, err := selfPath(); err == nil {
-		_ = os.WriteFile(exe+pendingSuffix, []byte("1"), 0o644)
+		_ = os.WriteFile(exe+pendingSuffix, []byte("0"), 0o644)
+	}
+}
+
+// parseBoots 读启动次数。内容不认识就当 1 处理 ——
+// 老版本写的是 "1",而且"读不懂"时保守地倾向回滚比倾向放行安全。
+func parseBoots(raw []byte) int {
+	n, err := strconv.Atoi(strings.TrimSpace(string(raw)))
+	if err != nil {
+		return 1
+	}
+	if n < 0 {
+		return 0
 	}
+	return n
 }

server/internal/updater/updater_test.go

@@ -349,3 +349,88 @@ func testUpdaterState(t *testing.T) *app.State {
 	lg := logger.New(filepath.Join(dir, "t.log"), slog.New(slog.NewTextHandler(io.Discard, nil)))
 	return app.NewState(storage.Paths{DataDir: dir}, config.New(database), lg, database)
 }
+
+// 这是回归测试:自更新替换完二进制、重启进新版本,新版本的**第一次启动**
+// 绝不能被判定为"起不来"。
+//
+// 之前就是这么错的:RollbackIfStale 跑在启动早期,而清除标记的 MarkHealthy
+// 要等端口监听成功才执行 —— 于是"标记还在"永远成立,每次自更新都在新版本
+// 刚起来的那一刻被静默回滚成旧版本。用户看到的是前端一直转
+// "正在重启并加载新版本…"直到超时,以为是更新卡住了。
+func TestRollbackIfStale_新版本首次启动不回滚(t *testing.T) {
+	exe := withFakeExe(t, "新版本")
+	os.WriteFile(exe+backupSuffix, []byte("旧版本"), 0o755)
+	MarkPending() // 自更新在重启前做的事
+
+	if RollbackIfStale(testUpdaterState(t)) {
+		t.Fatal("新版本头一回启动就被回滚了 —— 这样自更新永远升不上去")
+	}
+	if got, _ := os.ReadFile(exe); string(got) != "新版本" {
+		t.Errorf("二进制不该被换掉,实际 %q", got)
+	}
+	if _, err := os.Stat(exe + pendingSuffix); err != nil {
+		t.Error("标记要留着:这一版还没跑到 MarkHealthy,万一崩了下次启动要靠它回滚")
+	}
+}
+
+// 首次启动放行之后,如果这一版真的没能跑到 MarkHealthy,
+// 下一次启动就必须回滚 —— 否则回滚保护等于没有
+func TestRollbackIfStale_第二次启动才回滚(t *testing.T) {
+	exe := withFakeExe(t, "新版本(会崩)")
+	os.WriteFile(exe+backupSuffix, []byte("旧版本(能跑)"), 0o755)
+	MarkPending()
+
+	st := testUpdaterState(t)
+	if RollbackIfStale(st) {
+		t.Fatal("第一次不该回滚")
+	}
+	// 模拟:这一版启动后崩了,没到 MarkHealthy,进程被拉起来第二次
+	if !RollbackIfStale(st) {
+		t.Fatal("第二次带着标记启动,说明上一次没撑到健康点,必须回滚")
+	}
+	if got, _ := os.ReadFile(exe); string(got) != "旧版本(能跑)" {
+		t.Errorf("回滚后应该是旧版本,实际 %q", got)
+	}
+	if _, err := os.Stat(exe + pendingSuffix); !os.IsNotExist(err) {
+		t.Error("回滚后要清掉标记,否则会反复回滚")
+	}
+}
+
+// 完整走一遍成功路径:更新 → 首次启动放行 → 跑到健康点 → 标记和备份都清掉,
+// 之后再启动多少次都不会回滚
+func TestRollback成功路径不留残留(t *testing.T) {
+	exe := withFakeExe(t, "新版本")
+	os.WriteFile(exe+backupSuffix, []byte("旧版本"), 0o755)
+	MarkPending()
+
+	st := testUpdaterState(t)
+	if RollbackIfStale(st) {
+		t.Fatal("首次启动不该回滚")
+	}
+	MarkHealthy(st) // 端口监听成功
+
+	if _, err := os.Stat(exe + pendingSuffix); !os.IsNotExist(err) {
+		t.Error("健康之后标记该没了")
+	}
+	if _, err := os.Stat(exe + backupSuffix); !os.IsNotExist(err) {
+		t.Error("健康之后备份该没了")
+	}
+	if RollbackIfStale(st) {
+		t.Fatal("已经健康过了,再启动不该回滚")
+	}
+	if got, _ := os.ReadFile(exe); string(got) != "新版本" {
+		t.Errorf("二进制该保持新版本,实际 %q", got)
+	}
+}
+
+// 老版本写的标记内容是 "1"。升级上来时如果把它当成"没启动过"而放行,
+// 一个真的起不来的版本就会永远滚不回去
+func TestRollbackIfStale_认得老版本的标记(t *testing.T) {
+	exe := withFakeExe(t, "新版本(起不来)")
+	os.WriteFile(exe+backupSuffix, []byte("旧版本"), 0o755)
+	os.WriteFile(exe+pendingSuffix, []byte("1"), 0o644) // v0.1.3 及以前的写法
+
+	if !RollbackIfStale(testUpdaterState(t)) {
+		t.Fatal("老标记应当被当作『已经启动过一次』,直接回滚")
+	}
+}

server/main.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"io/fs"
 	"log/slog"
+	"net"
 	"net/http"
 	"os"
 	"strings"
@@ -497,11 +498,16 @@ func main() {
 	// 端口真正 Listen 成功之后才标记"这一版能跑" —— 此时数据库已打开、路由已注册、
 	// 端口也占上了。太早标记等于没验证:启动就 panic、端口被占、数据库损坏,
 	// 恰恰是最需要回滚的几种情况。
-	go func() {
-		// 给 ListenAndServe 一点时间真正把端口占上;失败的话进程已经退出,这里不会执行
-		time.Sleep(3 * time.Second)
-		updater.MarkHealthy(state)
-	}()
+	//
+	// 自己 Listen 而不是用 ListenAndServe + sleep:后者只能靠"睡几秒应该起来了"猜,
+	// 猜早了端口还没占上就宣布健康,猜晚了这几秒里被重启一次就会被误判成启动失败。
+	// 拿到 listener 就是确凿的成功信号,没有窗口。
+	ln, err := net.Listen("tcp", addr)
+	if err != nil {
+		console.Error("listen", "err", err)
+		os.Exit(1)
+	}
+	updater.MarkHealthy(state)
 
 	// 自更新完成后走这里:先停止接受新请求并等在途请求收尾,再关数据库,最后换进程映像。
 	// 顺序不能反 —— 先 exec 的话,新进程会发现端口还被自己占着。
@@ -522,7 +528,7 @@ func main() {
 		}
 	}
 
-	if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+	if err := srv.Serve(ln); err != nil && err != http.ErrServerClosed {
 		console.Error("server run", "err", err)
 		os.Exit(1)
 	}