magic-agent 2.4.3 → 2.6.3

package/internal/client/coreupgrade_test.go

@@ -0,0 +1,561 @@
+package client
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"net"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+)
+
+// 2026-10-23 用户：「我的 tab 版本中除了升级 apk，也要触发 npm 升级」。
+// 这里钉住「桌面端升级」这条路：前缀探测、命令拼装、SSE 成功/失败/原地重启。
+
+func TestNpmPrefixForPackage(t *testing.T) {
+	root := t.TempDir()
+	// Homebrew 形状：<prefix>/lib/node_modules/magic-agent —— 前缀是 <prefix>，不是 lib。
+	brewPkg := filepath.Join(root, "opt", "lib", "node_modules", "magic-agent")
+	if got := npmPrefixForPackage(brewPkg); got != filepath.Join(root, "opt") {
+		t.Fatalf("npmPrefixForPackage(<prefix>/lib/node_modules/…) = %q, want %q", got, filepath.Join(root, "opt"))
+	}
+	// Windows / 普通形状：<prefix>/node_modules/magic-agent —— 前缀是 <prefix>。
+	flatPkg := filepath.Join(root, "usr", "node_modules", "magic-agent")
+	if got := npmPrefixForPackage(flatPkg); got != filepath.Join(root, "usr") {
+		t.Fatalf("npmPrefixForPackage(<prefix>/node_modules/…) = %q, want %q", got, filepath.Join(root, "usr"))
+	}
+	// 不是 npm 包（自己编译的二进制）：没有前缀可装回。
+	if got := npmPrefixForPackage(filepath.Join(root, "somewhere", "magic-agent")); got != "" {
+		t.Fatalf("非 npm 布局应返回空，got %q", got)
+	}
+	if got := npmPrefixForPackage(""); got != "" {
+		t.Fatalf("空包根应返回空，got %q", got)
+	}
+}
+
+func TestCorePackageOf(t *testing.T) {
+	root := t.TempDir()
+	pkg := filepath.Join(root, "lib", "node_modules", "magic-agent")
+	bin := filepath.Join(pkg, "npm", "dist", "darwin-arm64", "magic-agent")
+	if err := os.MkdirAll(filepath.Dir(bin), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(pkg, "package.json"), []byte(`{"name":"magic-agent"}`), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if got := corePackageOf(bin); got != pkg {
+		t.Fatalf("corePackageOf = %q, want %q", got, pkg)
+	}
+	// 别的包（不是 magic-agent）：认不出来。
+	other := filepath.Join(root, "lib", "node_modules", "other-pkg")
+	if err := os.MkdirAll(other, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(other, "package.json"), []byte(`{"name":"other-pkg"}`), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if got := corePackageOf(filepath.Join(other, "bin", "x")); got != "" {
+		t.Fatalf("别的包不该被认成 magic-agent，got %q", got)
+	}
+}
+
+func TestResolveCoreUpgradeBuildsFixedCommand(t *testing.T) {
+	// npm 必须在 PATH 上（测试机一般有；没有就跳过这条，不假装测过）。
+	npmDir := ""
+	if p, err := exec.LookPath("npm"); err == nil {
+		npmDir = filepath.Dir(p)
+	}
+	if npmDir == "" {
+		t.Skip("PATH 上没有 npm")
+	}
+	t.Setenv("PATH", npmDir+string(os.PathListSeparator)+os.Getenv("PATH")+string(os.PathListSeparator)+"/usr/bin:/bin")
+
+	dir, _ := filepath.EvalSymlinks(t.TempDir()) // macOS 的 /var → /private/var：compare 用 realpath
+	bin := filepath.Join(dir, "bin", "magic-agent")
+	if err := os.MkdirAll(filepath.Dir(bin), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(bin, []byte("#!/bin/sh\necho magic-agent 2.4.1\n"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("MAGIC_AGENT_BIN", "")
+	// findCoreBin 先看 PATH：把它指到临时目录，避开测试机上真装的那份。
+	t.Setenv("PATH", filepath.Dir(bin)+string(os.PathListSeparator)+os.Getenv("PATH"))
+
+	got := resolveCoreUpgrade("v2.4.2", bin)
+	if !got.CanUpgrade {
+		t.Fatalf("应当可以升级，Note=%q", got.Note)
+	}
+	want := "npm install magic-agent@2.4.2 --no-fund --no-audit -g --prefix " + dir
+	if got.Command() != want {
+		t.Fatalf("command = %q, want %q", got.Command(), want)
+	}
+	if got.Installed != "2.4.1" {
+		t.Fatalf("Installed = %q, want 2.4.1（盘上那份的版本，升级后拿它判断真的变了）", got.Installed)
+	}
+
+	// 没查到 registry：不升级、给出原因（而不是拿一个猜的版本去装）。
+	if q := resolveCoreUpgrade("", bin); q.CanUpgrade || q.Note == "" {
+		t.Fatalf("没有 latest 时不应升级：%+v", q)
+	}
+	// 版本号只取 x.y.z（防注入进 npm 参数）。
+	if q := resolveCoreUpgrade("2.4.2; rm -rf /", bin); strings.Contains(q.Command(), "rm") {
+		t.Fatalf("版本号没有被清理：%q", q.Command())
+	}
+}
+
+// registry 上的 latest 比本地还旧时，**不能**降级安装（npm i -g 是无条件安装）。
+func TestCoreUpgradeRefusesDowngrade(t *testing.T) {
+	s, vf := newUpgradeService(t)
+	t.Cleanup(func() {
+		if err := os.WriteFile(vf, []byte("2.4.1"), 0o644); err != nil {
+			t.Fatal(err)
+		}
+	})
+	// 本地已经是 2.4.2，registry 上只有 2.4.1。
+	if err := os.WriteFile(vf, []byte("2.4.2"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(filepath.Dir(vf), "latest.txt"), []byte(`"2.4.1"`+"\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	req, _ := http.NewRequest(http.MethodPost, "/desk/core/upgrade", nil)
+	req.Header.Set("X-Magic-Token", "test-token-0123456789abcdef")
+	rec := httptest.NewRecorder()
+	s.Handler().ServeHTTP(rec, req)
+	if rec.Code != http.StatusConflict {
+		t.Fatalf("降级应被拒（409），got %d: %s", rec.Code, rec.Body.String())
+	}
+	if !strings.Contains(rec.Body.String(), "不高于本机已装") {
+		t.Fatalf("应说清为什么不降级：%s", rec.Body.String())
+	}
+}
+
+// replacedAfterStart：盘上的二进制比本进程新 = npm 刚换上去、还没重启。
+func TestReplacedAfterStart(t *testing.T) {
+	dir := t.TempDir()
+	bin := filepath.Join(dir, "magic-agent")
+	if err := os.WriteFile(bin, []byte("#!/bin/sh\n"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	st, _ := os.Stat(bin)
+	// 二进制在「本进程启动」之后才落盘 ⇒ npm 已经装了新版、只差重启。
+	start := fileTime(st).Add(-time.Second)
+	s := &Service{}
+	s.procStartOverride = func() (time.Time, bool) { return start, true }
+	if !s.replacedAfterStart(bin) {
+		t.Fatal("本进程之后写上去的二进制应判成「已换新」（否则界面会再喊一次升级）")
+	}
+	// 二进制比本进程旧：正常情况，不当成「已换新」。
+	start = fileTime(st).Add(5 * time.Second)
+	s.procStartOverride = func() (time.Time, bool) { return start, true }
+	if s.replacedAfterStart(bin) {
+		t.Fatal("比本进程旧的二进制不该被判成「已换新」")
+	}
+	if s.replacedAfterStart(filepath.Join(dir, "不存在")) {
+		t.Fatal("不存在的路径不该判成「已换新」")
+	}
+}
+
+func TestParseSemver(t *testing.T) {
+	for in, want := range map[string]string{
+		"magic-agent v2.4.2": "2.4.2",
+		"2.4.2":              "2.4.2",
+		"v2.4.2\n":           "2.4.2",
+		`"2.4.2"`:            "2.4.2",
+		"no digits":          "",
+	} {
+		if got := parseSemver(in); got != want {
+			t.Errorf("parseSemver(%q) = %q, want %q", in, got, want)
+		}
+	}
+}
+
+func TestCmpSemver(t *testing.T) {
+	if cmpSemver("2.4.2", "2.4.1") <= 0 || cmpSemver("2.4.1", "2.4.2") >= 0 || cmpSemver("2.4.2", "2.4.2") != 0 {
+		t.Fatal("cmpSemver 比较错误")
+	}
+	if cmpSemver("2.10.0", "2.9.9") <= 0 {
+		t.Fatal("多位数字段必须按数值比较")
+	}
+}
+
+// writeVersionedCore 造一个能 `--version` 的假 core；版本号写进 version.txt，测试里可改写。
+func writeVersionedCore(t *testing.T, dir, version string) (bin, vf string) {
+	t.Helper()
+	bin = filepath.Join(dir, "magic-agent")
+	vf = filepath.Join(dir, "version.txt")
+	if err := os.WriteFile(vf, []byte(version), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	script := "#!/bin/sh\nif [ \"$1\" = \"--version\" ]; then printf 'magic-agent v'; cat " + vf + "; fi\n"
+	if err := os.WriteFile(bin, []byte(script), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	return bin, vf
+}
+
+// fakeNPM 把 npm 换成一个脚本：`view` 回 $FAKE_NPM_LATEST；`install -g` 把盘上假 core 的版本
+// 改成目标版本（模拟真 npm 换掉二进制），其余参数忽略。
+//
+// ⚠️ 用 node 写而不是 sh：真机上 `npm` 本身就是 node 脚本，没装 node 的机器上根本没有 npm
+// （resolveCoreUpgrade 会直接说「PATH 上没有 npm」，走不到这里）；而 sh 版一旦被别的测试
+// 改了 PATH、没把假 npm 排在真 npm 前面，`install` 会落到系统命令上 —— 等于在测试里
+// 真的跑了一次 `npm i -g magic-agent`（2026-10-26 实测就这样踩过一次）。node 没有同名的
+// 系统命令，落错了也只会报错退出，不会去动真包。
+func fakeNPM(t *testing.T, dir, vf string) {
+	t.Helper()
+	node, err := exec.LookPath("node")
+	if err != nil {
+		t.Skip("PATH 上没有 node：没法把 npm 替换成不会伤到真安装的假实现")
+	}
+	const js = "const fs=require('fs'),path=require('path'),a=process.argv.slice(2);\n" +
+		"const d=path.dirname(process.argv[1]);\n" +
+		// 行为覆盖：环境变量（每个子进程各读各的，测试里 t.Setenv 即可）优先，其次 npm 目录里的
+		// behavior.json（给「同一个假 npm 服务整个用例」的场景用）。
+		"try{if(process.env.FAKE_NPM_BEHAVIOR)Object.assign(process.env,JSON.parse(process.env.FAKE_NPM_BEHAVIOR));}catch(e){}\n" +
+		"try{Object.assign(process.env,JSON.parse(fs.readFileSync(path.join(d,'behavior.json'),'utf8')));}catch(e){}\n" +
+		"if(a[0]==='view'){process.stdout.write(fs.readFileSync(path.join(d,'latest.txt'),'utf8'));}\n" +
+		"else if(a[0]==='install'){const m=/^magic-agent@(.+)$/.exec(a.find(x=>/^magic-agent@/.test(x))||'');\n" +
+		"  if(process.env.FAKE_NPM_VERFILE)fs.writeFileSync(process.env.FAKE_NPM_VERFILE,m?m[1]:'bad-args');}\n"
+	// sh 垫片只做一件事：exec 到 node 并把 $0 换成 npm.js —— 假 npm 按自己所在目录找 latest.txt。
+	script := "#!/bin/sh\nexec " + node + " " + filepath.Join(dir, "npm.js") + " \"$@\"\n"
+	if err := os.WriteFile(filepath.Join(dir, "npm.js"), []byte(js), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "npm"), []byte(script), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "latest.txt"), []byte(`"2.4.2"`+"\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("FAKE_NPM_VERFILE", vf)
+}
+
+func newUpgradeService(t *testing.T) (*Service, string) {
+	t.Helper()
+	work := t.TempDir()
+	binDir := filepath.Join(work, "prefix", "bin")
+	if err := os.MkdirAll(binDir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	core, vf := writeVersionedCore(t, binDir, "2.4.1")
+	// 假 core 是测试**刚写出来**的：把「本进程启动时刻」钉在它**之后**（等它写完再钉），
+	// 它就不会被 replacedAfterStart 当成「装好了没重启」。
+	coreMtime, err := os.Stat(core)
+	if err != nil {
+		t.Fatal(err)
+	}
+	afterCore := fileTime(coreMtime).Add(time.Hour)
+	npmDir := filepath.Join(work, "npmbin")
+	_ = os.MkdirAll(npmDir, 0o755)
+	fakeNPM(t, npmDir, vf)
+	// ⚠️ 路径顺序：系统 bin 必须在最后垫底 —— npmDir 里只有假 npm，若把 /bin 之类放在
+	// 前面，测试机上（macOS）真系统里的 `install` 会先被找到，测的就不是 npm 了。
+	sysPath := "/usr/local/bin:/usr/bin:/bin"
+	t.Setenv("PATH", npmDir+string(os.PathListSeparator)+binDir+string(os.PathListSeparator)+sysPath)
+	t.Setenv("MAGIC_AGENT_BIN", "")
+
+	s := &Service{opts: Options{MagicAgent: core}, log: testLogger()}
+	// ⚠️ 基准时刻必须在这里**算一次存下来**：每次调用都现算的话，越晚算越靠后，
+	// 「二进制比本进程新」就永远不成立（曾经因此让「只差重启」那条用例悄悄测不到）。
+	s.procStartOverride = func() (time.Time, bool) { return afterCore, true }
+	s.contract = Contract{ContractVersion: RequiredContractVersion, Version: "2.4.1", Features: requiredFeatures}
+	// 「问 registry」那一问换成不联网的假体（coreStatus 与升级接口共用）。
+	s.latestFn = func(context.Context) string { return "" }
+	// 一律按「假 core」解析（Hint 固定），绝不去找本进程（`go test` 跑的就是刚编出来的
+	// magic-agent，--version 报的是真仓库的版本）。
+	s.coreTarget = func(context.Context) coreUpgradeTarget {
+		return s.resolveCoreUpgrade("2.4.2", core)
+	}
+	return s, vf
+}
+
+func TestCoreStatusReportsUpgradable(t *testing.T) {
+	s, vf := newUpgradeService(t)
+	info := s.coreStatus(t.Context())
+	if !info.Upgradable || !info.CanUpgrade || info.Latest != "2.4.2" || info.Version != "2.4.1" {
+		t.Fatalf("coreStatus = %+v", info)
+	}
+	if info.Daemon {
+		t.Fatal("测试里的进程不是 start 拉起的，不应报告为后台常驻")
+	}
+
+	// 原地重启那几秒：npm 已经把盘上那份换成 2.4.2（二进制 mtime 在本进程启动之后），
+	// 跑着的仍是 2.4.1。`--version` 跑的是**新文件**，所以「正在跑的版本」只能取契约缓存。
+	if err := os.WriteFile(vf, []byte("2.4.2"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	core := filepath.Join(filepath.Dir(vf), "magic-agent")
+	coreMtime, err := os.Stat(core)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// 进程「启动」早于这次换盘 ⇒ 盘上那份是启动之后才换上去的。
+	s.procStartOverride = func() (time.Time, bool) { return fileTime(coreMtime).Add(-time.Hour), true }
+	info = s.coreStatus(t.Context())
+	if !info.RestartOnly || info.Upgradable || info.Version != "2.4.1" || info.Installed != "2.4.2" {
+		t.Fatalf("重启待办没有报出来：%+v", info)
+	}
+	if !strings.Contains(info.Note, "重启") {
+		t.Fatalf("应提示重启后生效：%+v", info)
+	}
+}
+
+// readSSE 解析 SSE，返回 (event, data) 序列。
+func readSSE(t *testing.T, body string) [][2]string {
+	t.Helper()
+	var out [][2]string
+	for _, block := range strings.Split(body, "\n\n") {
+		var ev, data string
+		for _, ln := range strings.Split(block, "\n") {
+			if strings.HasPrefix(ln, "event: ") {
+				ev = strings.TrimPrefix(ln, "event: ")
+			} else if strings.HasPrefix(ln, "data: ") {
+				data += strings.TrimPrefix(ln, "data: ")
+			}
+		}
+		if data != "" {
+			out = append(out, [2]string{ev, data})
+		}
+	}
+	return out
+}
+
+func TestCoreUpgradeStreamsAndReallyInstalls(t *testing.T) {
+	s, vf := newUpgradeService(t)
+	orgSpawner := restartSpawner
+	t.Cleanup(func() { restartSpawner = orgSpawner })
+	restartSpawner = func(string, *log.Logger, string) {
+		t.Logf("重启助手本该在这里起身（测试里不拉真的 magic-client）")
+	}
+	rec := httptest.NewRecorder()
+	s.handleCoreUpgrade(rec, httptest.NewRequest(http.MethodPost, "/desk/core/upgrade", nil))
+	if rec.Code != http.StatusOK {
+		t.Fatalf("code = %d, body=%s", rec.Code, rec.Body.String())
+	}
+	events := readSSE(t, rec.Body.String())
+	var names []string
+	var end map[string]any
+	for _, e := range events {
+		names = append(names, e[0])
+		if e[0] == "end" {
+			_ = json.Unmarshal([]byte(e[1]), &end)
+		}
+	}
+	if len(names) < 3 || names[0] != "open" || names[1] != "step" || names[len(names)-1] != "end" {
+		t.Fatalf("事件序列 = %v（应为 open → step → … → end）", names)
+	}
+	if end == nil || end["ok"] != true {
+		t.Fatalf("end = %v，全量：%s", end, rec.Body.String())
+	}
+	// 前台 serve（没有 daemon 状态）：不重启，只说重启后生效 —— 不假称已生效。
+	if end["restarting"] != false || !strings.Contains(end["note"].(string), "重启") {
+		t.Fatalf("前台 serve 的 note 不对：%v", end)
+	}
+	// 新二进制**真的换上了**（npm 被调用、盘上版本变了）。
+	if b, _ := os.ReadFile(vf); string(b) != "2.4.2" {
+		t.Fatalf("npm install 没把盘上版本换成 2.4.2：%q", string(b))
+	}
+	// 而且装的是目标版本（2026-10-26：`-g` 曾插在 install 与包名之间，假 npm 读不到 install，
+	// 这条测试就变成永远不失败 —— 现在假 npm 按包名找参数，参数顺序怎么排都认得出）。
+	if b, _ := os.ReadFile(vf); strings.Contains(string(b), "bad-args") {
+		t.Fatalf("npm 收到的参数里没有 magic-agent@<版本>：%q", string(b))
+	}
+}
+
+func TestCoreUpgradeFailsWhenBinaryUnchanged(t *testing.T) {
+	// npm 退出 0 但什么都没装（装到别的前缀 / 源还没同步）：必须报失败，不能谎报成功。
+	//
+	// 假 npm 只让 `install` 成功、什么都不做（`view` 照旧回新版本）。开关走假 npm 自己的
+	// behavior.json，不碰 PATH 里的任何东西。
+	// ⚠️ 必须在 newUpgradeService **之前**写：假 npm 每个进程只在启动时读一次 behavior.json，
+	// Helper 之后再改文件对已经起来的假 npm 不生效（曾因此让这条用例悄悄测成「真装好了」）。
+	t.Setenv("FAKE_NPM_BEHAVIOR", `{"FAKE_NPM_VERFILE":""}`)
+	s, _ := newUpgradeService(t)
+	rec := httptest.NewRecorder()
+	s.handleCoreUpgrade(rec, httptest.NewRequest(http.MethodPost, "/desk/core/upgrade", nil))
+	if rec.Code != http.StatusOK {
+		t.Fatalf("code = %d, body=%s", rec.Code, rec.Body.String())
+	}
+	events := readSSE(t, rec.Body.String())
+	last := events[len(events)-1]
+	var end map[string]any
+	_ = json.Unmarshal([]byte(last[1]), &end)
+	if last[0] != "end" || end["ok"] != false || !strings.Contains(end["error"].(string), "版本没有变化") {
+		t.Fatalf("应报「版本没有变化」，实际：%s", rec.Body.String())
+	}
+}
+
+// TestRestartDaemonReal 端到端：真起一个后台 serve（假 core + 假 npm），升级后
+// 自动用**原来的端口与参数**重启到新二进制上 —— 前端不需要换地址也能重连。
+func TestRestartDaemonReal(t *testing.T) {
+	if testing.Short() {
+		t.Skip("-short")
+	}
+	self, err := os.Executable()
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	core, _ := writeVersionedCore(t, dir, "2.4.1")
+	/* 假 core 是**测试进程跑起来之后**才写出来的：不拨回过去，子进程会把它判成
+	   「本进程启动后盘上才换上去的」（replacedAfterStart），升级接口直接回 409「只差重启」。
+	   真实场景里 core 都是先前装好的，这里把 mtime 拨到一小时前。 */
+	past := time.Now().Add(-time.Hour)
+	if err := os.Chtimes(core, past, past); err != nil {
+		t.Fatal(err)
+	}
+	npmDir := filepath.Join(dir, "npmbin")
+	_ = os.MkdirAll(npmDir, 0o755)
+	fakeNPM(t, npmDir, filepath.Join(dir, "version.txt"))
+
+	fakeServe := filepath.Join(dir, "magic-client")
+	if err := os.Symlink(self, fakeServe); err != nil {
+		t.Skipf("无法建符号链接：%v", err)
+	}
+	statePath := filepath.Join(dir, "client.json")
+	srv := httptest.NewServer(http.NotFoundHandler())
+	port := srv.Listener.Addr().(*net.TCPAddr).Port
+	srv.Close()
+	_ = os.WriteFile(statePath+".port", []byte(strconv.Itoa(port)), 0o644)
+
+	cmd := exec.Command(fakeServe)
+	cmd.Env = append(os.Environ(),
+		"RUN_AS_SERVE=1",
+		"MAGIC_TEST_STATE="+statePath,
+		"MAGIC_AGENT_BIN="+core,
+		"PATH="+npmDir+string(os.PathListSeparator)+filepath.Dir(core)+string(os.PathListSeparator)+"/usr/bin:/bin",
+	)
+	cmd.Dir = dir
+	logFile, _ := os.Create(filepath.Join(dir, "serve.log"))
+	defer logFile.Close()
+	cmd.Stdout, cmd.Stderr = logFile, logFile
+	if err := cmd.Start(); err != nil {
+		t.Fatal(err)
+	}
+	defer func() { _ = cmd.Process.Kill() }()
+
+	// 子进程监听后会**重写** client.json.port；真实端口以它为准（父进程预挑的只是第一个尝试）。
+	portFile := statePath + ".port"
+	for i := 0; i < 100; i++ {
+		b, err := os.ReadFile(portFile)
+		if err == nil {
+			var p int
+			if _, e := fmt.Sscanf(string(b), "%d", &p); e == nil && p > 0 {
+				port = p
+				break
+			}
+		}
+		time.Sleep(50 * time.Millisecond)
+	}
+
+	base := "http://127.0.0.1:" + strconv.Itoa(port)
+	if !waitHTTP(base + "/desk/health") {
+		logFile.Sync()
+		b, _ := os.ReadFile(filepath.Join(dir, "serve.log"))
+		t.Fatalf("假 serve 没起来（日志：%s）", b)
+	}
+
+	req, _ := http.NewRequest(http.MethodPost, base+"/desk/core/upgrade", nil)
+	req.Header.Set("X-Magic-Token", "test-token-0123456789abcdef")
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+	body, _ := io.ReadAll(resp.Body)
+	resp.Body.Close()
+	events := readSSE(t, string(body))
+	if len(events) == 0 {
+		t.Fatalf("SSE 为空：%s", body)
+	}
+	var end map[string]any
+	_ = json.Unmarshal([]byte(events[len(events)-1][1]), &end)
+	if end["ok"] != true || end["restarting"] != true {
+		b, _ := os.ReadFile(filepath.Join(dir, "serve.log"))
+		t.Fatalf("升级没有触发重启：%s\nserve.log:\n%s", body, b)
+	}
+
+	// 新实例起来后，/desk/version 报的是新版本（假 serve 每次启动读一遍 core --version）。
+	deadline := time.Now().Add(10 * time.Second)
+	for time.Now().Before(deadline) {
+		if r, err := http.Get(base + "/desk/version"); err == nil {
+			b, _ := io.ReadAll(r.Body)
+			r.Body.Close()
+			if strings.Contains(string(b), "2.4.2") {
+				// 端口不能不换（手机里存的是这个地址）。
+				return
+			}
+		}
+		time.Sleep(100 * time.Millisecond)
+	}
+	t.Fatal("重启后新版本没有生效（端口应保持 " + strconv.Itoa(port) + "）")
+}
+
+func waitHTTP(u string) bool {
+	for i := 0; i < 100; i++ {
+		if r, err := http.Get(u); err == nil {
+			r.Body.Close()
+			if r.StatusCode == http.StatusOK {
+				return true
+			}
+		}
+		time.Sleep(50 * time.Millisecond)
+	}
+	return false
+}
+
+// TestNpmEnvStripsDeadLoopbackProxy 客户端里跑 npm 时不能再继承「指向死端口」的代理。
+// 现场（2026-10-27）：宿主 IDE 塞了 HTTP_PROXY=127.0.0.1:<已失效端口>，客户端里的
+// `npm view` 静默失败 → 手机看到「桌面端没有可升级版本」，而 registry 上明明有。
+func TestNpmEnvStripsDeadLoopbackProxy(t *testing.T) {
+	l, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Skipf("拿不到回环端口：%v", err)
+	}
+	addr := l.Addr().String()
+	l.Close() // 关掉 ⇒ 这个端口上没人监听
+
+	live, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Skipf("拿不到回环端口：%v", err)
+	}
+	defer live.Close()
+
+	t.Setenv("HTTP_PROXY", "http://"+addr)
+	t.Setenv("https_proxy", "http://"+addr)
+	t.Setenv("HTTPS_PROXY", "http://"+live.Addr().String())
+	t.Setenv("ALL_PROXY", "socks5://proxy.corp.example:1080") // 非回环：不许动
+
+	env := npmEnv()
+	if v, ok := envValue(env, "HTTP_PROXY"); ok {
+		t.Fatalf("死回环代理应被剔除，实际留下 %q", v)
+	}
+	if v, ok := envValue(env, "https_proxy"); ok {
+		t.Fatalf("死回环代理（小写）应被剔除，实际留下 %q", v)
+	}
+	if v, ok := envValue(env, "HTTPS_PROXY"); !ok || !strings.Contains(v, "127.0.0.1") {
+		t.Fatalf("活着的回环代理不该被剔除，实际 %q ok=%v", v, ok)
+	}
+	if v, ok := envValue(env, "ALL_PROXY"); !ok || !strings.Contains(v, "proxy.corp.example") {
+		t.Fatalf("非回环代理一律不碰，实际 %q ok=%v", v, ok)
+	}
+}
+
+func envValue(env []string, name string) (string, bool) {
+	for _, kv := range env {
+		if k, v, ok := strings.Cut(kv, "="); ok && k == name {
+			return v, true
+		}
+	}
+	return "", false
+}