magic-agent 2.3.9 → 2.4.3

package/CLIENT-CONTRACT.md

@@ -432,6 +432,12 @@ notice     {text:"团队模式：追加 N 个补充任务（a1、a2），继续
 | 令牌下限 | 24 字符；弱令牌**拒绝启动**（自动生成的默认令牌是 32 位十六进制，够用） |
 | 无令牌访问 | `401` —— 不因为是内网就放行 |
 | 不带 `--lan` | 局域网地址**连不上**（默认就是安全的） |
+| 地址的挑选与顺序 | 虚拟网卡（容器 / 虚拟交换机 / 隧道）的地址**不报**；公网段地址在还有私有地址时也不报；剩下的按「出站主地址（默认路由那张网卡）→ 其余」排。**第一个 = 手机最可能连上的那个** —— 移动端只认 `[0]` |
+
+⚠️ **地址顺序是契约的一部分（2026-10-23 修正）**：以前直接按网卡枚举顺序返回，
+而企业 VPN 虚拟网卡常常排在真实网卡前面 —— 移动端自动补的「公司远程」环境
+就被种成了一个手机路由不到的地址，表现为「启动成功但手机连不上」。
+现在第一个地址保证是手机能连的那个。`/desk/health.lanUrls` 用同一份顺序。
 
 扫码配对在 v1 就是「扫这段 URL」（URL 自带令牌）。带 TTL 的配对码交换属于 L2（跨网）的活，
 需要服务端与令牌存储，**未做**。

package/client-ui-mobile/index.html

@@ -1600,7 +1600,13 @@ button.setrow{font-family:inherit}
     list.forEach(function (c) { if (c && c.id === id) hit = c; });
     /* 用户主动删掉种出来的默认环境：记一笔，下次启动别再自动加回来。 */
     if (hit && hit.seed) { try { localStorage.setItem('magic.remote.seedoff.v1', '1'); } catch (e) {} }
-    if (hit && !keepQueue) dropEnvQueue(hit);
+    /* 同一台桌面可能有多条入口（公司本地 / 公司远程）共享一个 eid：
+       只有删掉最后一条时才清队列，否则删一个别名会把另一个还在用的队列带走。 */
+    var sharedEid = false;
+    if (hit && hit.eid) {
+      sharedEid = list.some(function (c) { return c && c.id !== id && c.eid && c.eid === hit.eid; });
+    }
+    if (hit && !keepQueue && !sharedEid) dropEnvQueue(hit);
     saveConns(list.filter(function (c) { return c.id !== id; }));
   }
   /* 清掉某条环境名下的排队行（eid 桶与老 host 桶都清）。 */
@@ -1671,6 +1677,44 @@ button.setrow{font-family:inherit}
     for (var j = 0; j < l2.length; j++) if (l2[j].id === rec.id) l2[j].seed = true;
     saveConns(l2);
   }
+  /* 当前连接所属环境的 eid（临时记录会先补号）。
+     用途：同一台桌面的「公司本地 / 公司远程」两条入口要共享一个环境身份 ——
+     它们是同一个 magic-client、同一份队列与设置，不能因为地址不同就算两台。 */
+  function activeEnvEid() {
+    var c = activeConn();
+    if (!c) return '';
+    c = ensureEnvId(c) || c;
+    return c.eid || '';
+  }
+  /* 把一条环境记录并入 toEid：队列行与配置槽一起迁过去（幂等）。 */
+  function mergeEnvId(rec, toEid) {
+    if (!rec || !toEid || rec.eid === toEid) return false;
+    var from = rec.eid ? eidKey(rec.eid) : envHashOf(rec);
+    rec.eid = toEid;
+    migrateEnvData(from, eidKey(toEid));
+    return true;
+  }
+  /* 服务端报了实例 id（/desk/health.instanceId）：把当前环境钉到 `srv:<id>`。
+     同一台桌面的本地 / 局域网 / 公网入口会拿到同一个 id —— 于是不同 URL 也是同一个环境：
+     队列、任务模式、引擎/空间选择都共用一份。老服务端没有该字段 → 什么也不做。 */
+  function adoptServerEid(sid) {
+    sid = String(sid || '').trim();
+    if (!sid) return false;
+    var want = 'srv:' + sid;
+    var cur = activeConn();
+    if (!cur || !cur.id) return false;
+    var list = loadConns(), changed = false;
+    for (var i = 0; i < list.length; i++) {
+      if (!list[i] || list[i].id !== cur.id) continue;
+      if (list[i].eid === want) break;
+      if (list[i].eid) mergeEnvId(list[i], want);
+      else list[i].eid = want;
+      changed = true;
+      break;
+    }
+    if (changed) saveConns(list);
+    return changed;
+  }
   function seedCurrentConn() {
     var url = connUrlNow();
     if (!url || !TOKEN) return;
@@ -1704,6 +1748,10 @@ button.setrow{font-family:inherit}
     var url = String(urls[0] || '').replace(/\/+$/, '');
     if (!url) return;
     if (url === String(connUrlNow()).replace(/\/+$/, '')) return;
+    /* 这些远程入口是**当前这台桌面**自己上报的（/desk/health），
+       与当前连接是同一个 magic-client —— 新记录必须沿用当前环境的 eid，
+       否则「公司本地 / 公司远程」会被当成两台，队列与设置各存一份。 */
+    var homeEid = activeEnvEid();
     var list = loadConns();
     /* 隧道换域名（cloudflared 每次重启都换）：把上一枚**默认命名**的种子远程记录换到新地址。
        用户改过名字的不动 —— 那条是他自己配的环境。 */
@@ -1722,18 +1770,23 @@ button.setrow{font-family:inherit}
       var c = list[i];
       if (!c) continue;
       if (c.url === url && String(c.token || '') === String(TOKEN)) {
-        if (c.seed && c.name === SEED_LOCAL) { c.name = SEED_NAME; saveConns(list); }
+        var changed = false;
+        if (c.seed && c.name === SEED_LOCAL) { c.name = SEED_NAME; changed = true; }
+        /* 老数据 / 先远程后本地：把这条并到当前桌面的 eid 上。 */
+        if (homeEid && mergeEnvId(c, homeEid)) changed = true;
+        if (changed) saveConns(list);
         return;
       }
       if (c.seed && c.url === url) {
         c.token = TOKEN;
         c.id = connIdOf({ url: url, token: TOKEN });
         c.at = Date.now();
+        if (homeEid) mergeEnvId(c, homeEid);
         saveConns(list);
         return;
       }
     }
-    seedMark(upsertConn({ url: url, token: TOKEN, name: SEED_NAME, eid: replacedEid }));
+    seedMark(upsertConn({ url: url, token: TOKEN, name: SEED_NAME, eid: homeEid || replacedEid }));
   }
 
   /* ── 设备现场（按环境隔离）──
@@ -3219,6 +3272,9 @@ button.setrow{font-family:inherit}
       CORE_FEATURES = ((a[2] && a[2].features) || []);
       /* 连接的身份（app）：连着哪台设备就记到哪条连接上，环境菜单里当类型标签用。 */
       if (a[2] && a[2].app) noteActiveMeta({ app: a[2].app });
+      /* 服务实例身份：同一台桌面的多个入口（本地 / 局域网 / 公网）归成一个环境。
+         必须排在 seedRemoteConns 之前 —— 后者新建「公司远程」时要继承当前 eid。 */
+      if (a[2] && a[2].instanceId) adoptServerEid(a[2].instanceId);
       /* 桌面绑了公网隧道时上报 publicUrl（cloudflared，不在同一 Wi-Fi 也能连），
          没有则退回局域网入口：自动补一条「公司远程」环境，用户不用手抄地址。 */
       if (a[2]) {
@@ -3249,7 +3305,12 @@ button.setrow{font-family:inherit}
     }).catch(function (e) {
       if (seq !== CONN_SEQ) return;
       if (quiet) return;   // 后台轮询失败：保留现有列表（见上面的说明）
-      historyList.innerHTML = '<div class="history__hint">读取会话失败：' + (e && e.message ? e.message : e) + '</div>';
+      /* 失败原因要带上**实际打的地址**：Photo/WebView 里 "Failed to fetch" 只说「没连上」，
+         而真正的原因通常是「这台手机到那个 IP 不通」（换了网络 / 环境里存的是别的网段）。
+         不写地址的话，用户和应用都无从判断该改哪一边。 */
+      var why = (e && e.message ? e.message : String(e));
+      var addr = BASE || location.origin || '(同源)';
+      historyList.innerHTML = '<div class="history__hint">读取会话失败：' + why + '<br>地址：' + addr + '</div>';
     });
   }
   /* ── 会话列表：**置顶 / 任务 / 空间** 三段（对齐截图）──

package/cmd/magic-client/main.go

@@ -62,6 +62,7 @@ func main() {
 		proxyAddr   = fs.String("proxy-addr", "", "SOCKS5 出口监听地址（供移动端 VPN 隧道核心使用），如 0.0.0.0:1080")
 		browseUA    = fs.String("browse-ua", "", "内置浏览器中转的 User-Agent：mobile（默认）/ desktop / 任意自定义串")
 		readyFile   = fs.String("ready-file", "", "监听成功后把 {pid,port,url,lanAddrs} 原子写到这个路径（`magic-client start` 用它拿端口，别手工传）")
+		anyOrigin   = fs.Bool("allow-any-origin", false, "对任意 Origin 回 CORS 头（默认只放行本机页面）。--lan 时自动开启；令牌仍是唯一门锁")
 	)
 	_ = fs.Parse(os.Args[2:])
 
@@ -90,6 +91,10 @@ func main() {
 		Token:      tok,
 		Lan:        *lan,
 		BrowseUA:   *browseUA,
+		/* 绑到局域网 = 「允许来自任意 IP 的页面访问」：再按 loopback 卡 CORS Origin
+		   等于把手机 / 别的设备的页面全判成跨域（用户侧就是「只能本地访问」）。
+		   显式 --allow-any-origin 也可以单独打开（绑回环但要给容器页面用）。 */
+		AllowAnyOrigin: *anyOrigin || *lan,
 	})
 	if err != nil {
 		// 契约不匹配是**要立刻停**的错误：带着不匹配的能力跑起来只会让人以为是界面 bug。

package/internal/cli/session.go

@@ -425,21 +425,12 @@ func runSessions(cmd *cobra.Command, opts *askOptions) error {
 			TitleSummarized: summarized,
 			StartedAt:       r.StartedAt.Format("2006-01-02 15:04:05"),
 			UpdatedAt:       r.UpdatedAt.Format("2006-01-02 15:04:05"),
-			HasLog:          hasSessionLog(logDir, r),
+			HasLog:          session.HasSessionLogIn(logDir, r.SessionID, r.RunID),
 		})
 	}
 	return printJSON(cmd.OutOrStdout(), rows)
 }
 
-// hasSessionLog 这条记录有没有可回放的事件日志。
-//
-// 日志文件名可能是 **session_id**（终名），也可能是 **run_id** —— 引擎还没吐 id 时
-// core 先按 run_id 落盘（见 sessionlog.go 的 setRunID / renameTo），所以两个名字都试一次；
-// 决议逻辑（含 run_id → session_id 的翻译）在 session.HasSessionLog 里，读接口共用同一份。
-func hasSessionLog(dir string, rec session.Record) bool {
-	return session.HasSessionLog(dir, rec.SessionID) || session.HasSessionLog(dir, rec.RunID)
-}
-
 // runSessionLog 读一段会话的**事件历史**：`--session-log <id> [--after <seq>]`。
 //
 // 为什么这条命令必须存在：会话的「查询」原先只有 HTTP 插件能做（`/desk/session/{id}/messages`），

package/internal/client/instance.go

@@ -0,0 +1,59 @@
+package client
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+)
+
+/*
+	服务实例的稳定身份（2026-10-23）。
+
+为什么需要：同一台桌面可能有多条入口（公司本地 127.0.0.1、局域网 IP、cloudflared
+公网域名），它们在客户端看来是不同 URL。移动端要用「这是不是同一台桌面」来决定
+队列与设置要不要共用一份 —— 只看地址会把同一台机器拆成好几个环境。
+
+id 落在 profile 的 DataDir 下（`instance-id`），第一次生成后不再变：
+
+	· 改端口 / 换隧道域名 / 手机换 Wi-Fi 都不影响；
+	· 只删 `instance-id` 才会换身份（等同于「这是一台新桌面」）。
+
+/desk/health 把它报给客户端（`instanceId`，只增字段）。老客户端忽略；
+新客户端据此把同一台桌面的多个入口并成一个环境身份。
+*/
+type instanceIDCache struct {
+	once sync.Once
+	id   string
+}
+
+func (s *Service) instanceID() string {
+	s.inst.once.Do(func() {
+		dir := s.opts.Profile.DataDir()
+		if strings.TrimSpace(dir) == "" {
+			return
+		}
+		path := filepath.Join(dir, "instance-id")
+		if b, err := os.ReadFile(path); err == nil {
+			if v := strings.TrimSpace(string(b)); len(v) >= 8 {
+				s.inst.id = v
+				return
+			}
+		}
+		var buf [8]byte
+		if _, err := rand.Read(buf[:]); err != nil {
+			return
+		}
+		id := hex.EncodeToString(buf[:])
+		if err := os.MkdirAll(dir, 0o700); err != nil {
+			return
+		}
+		if err := os.WriteFile(path, []byte(id+"\n"), 0o600); err != nil {
+			return
+		}
+		s.inst.id = id
+	})
+	return s.inst.id
+}

package/internal/client/lan.go

@@ -33,17 +33,142 @@ func ValidateLanToken(token string) error {
 	return nil
 }
 
+/* ── 局域网地址的挑选 ──
+ *
+ * ⚠️ **顺序有讲究，而且这份顺序是「能不能连上」的关键**（2026-10-23 修）。
+ *
+ * 调用方全都只认**第一个**：
+ *   · `/desk/health` 的 lanUrls → 移动端自动补的「公司远程」环境取 [0]；
+ *   · `magic-client start` 打印的**第一张**二维码 → 扫出来就是这个地址。
+ *
+ * 而一台装了企业 VPN / Hyper-V 的机器上有多张网卡，枚举顺序由系统决定，
+ * 先出来的常常是**手机根本路由不到**的那张：企业 VPN 虚拟网卡（10.x / 2.x 段）
+ * 与虚拟交换机（172.16/12 段）都属于「只在本机或专用隧道里有效」的地址，
+ * 手机在同一个 Wi-Fi 下压根到不了它们。
+ *
+ * 现象就是「启动成功、地址也打印出来了，但手机就是连不上」，而且**扫码比手抄更容易撞上**
+ * —— 扫的正是打印出来的第一张码。
+ *
+ * 现在的口径（三步，详见 orderLanAddresses）：
+ *  1. 按**名字**剔掉虚拟网卡（容器 / 虚拟交换机 / 隧道 / 回环伪接口）。
+ *  2. 再剔掉**公网段**地址（只要还有私有地址）：企业 VPN 的虚拟网卡常占一段
+ *     公网地址（这里 2.0.0.1），手机在局域网里根本路由不到那一段。
+ *  3. 剩下的里，出站主地址排最前（问一次内核要源地址，不发包）—— 那张网卡
+ *     就是本机跟外界说话用的那张，手机连它最可能通。
+ *
+ * 每一步都有兜底：真实网卡没剩就退回虚拟网卡，私有地址没剩就退回公网地址 ——
+ * 不能一个地址都不报。其余地址也会列在后面，用户可以手挑 —— 不猜、不假装。
+ */
+
+// lanCandidate 一个候选局域网地址，以及它所在的网卡。
+type lanCandidate struct {
+	ip    string
+	iface net.Interface
+}
+
+// virtualIfaceHints 虚拟 / 容器网卡的**名称特征**（子串匹配，忽略大小写）。
+//
+// 为什么按名字认：这些网卡在 Windows 上叫「vEthernet (Default Switch)」
+// （Hyper-V）、「VMware Network Adapter」；在 Linux 上叫 docker0 / veth* / virbr0；
+// 在 macOS 上叫 utun*。它们承载的地址只在本机或专用隧道内有效，手机连不到。
+var virtualIfaceHints = []string{
+	"vethernet", // Hyper-V 虚拟交换机
+	"hyper-v",
+	"vmware",
+	"virtualbox",
+	"docker",
+	"veth",
+	"virbr",
+	"br-",      // Linux 网桥
+	"loopback", // Windows「Loopback Pseudo-Interface」
+	"pseudo",
+	"npcap",
+	"bluetooth", // 蓝牙 PAN
+	"utun",      // macOS 隧道
+	"tailscale",
+	"zerotier",
+}
+
+// virtualIfaceNames 虚拟网卡的**完整**名称（小写）—— 这些是短名，
+// 用子串匹配会误伤别的网卡（"tun" 之于 "Tunnel"、"wg" 之于别的东西），所以整名匹配。
+var virtualIfaceNames = map[string]bool{
+	"tun0": true, "tun1": true,
+	"tap0": true, "tap1": true,
+	"docker0":   true,
+	"wg0":       true, // WireGuard
+	"zt0":       true, // ZeroTier
+	"zt1":       true,
+	"bridge100": true, // macOS 上的 VMware
+}
+
+// isVirtualIface 网卡是不是虚拟 / 容器网卡。
+func isVirtualIface(name string) bool {
+	n := strings.ToLower(strings.TrimSpace(name))
+	if virtualIfaceNames[n] {
+		return true
+	}
+	for _, h := range virtualIfaceHints {
+		if strings.Contains(n, h) {
+			return true
+		}
+	}
+	return false
+}
+
+// isPrivateIPv4 是不是 RFC1918 私有网段（10/8、172.16/12、192.168/16）。
+//
+// 为什么用它排序：手机在同一张局域网里拿到的也是私有地址，所以私有地址是
+// 「手机连得上」的第一嫌疑。反过来，企业 VPN 的虚拟网卡常占一段**公网**地址
+// （这台机器上 Sangfor aTrust VNIC 占的是 2.0.0.1）—— 手机在局域网里
+// 根本路由不到那一段，把公网地址排前面就是第一个就撞墙。
+func isPrivateIPv4(ip string) bool {
+	p := net.ParseIP(ip)
+	if p == nil {
+		return false
+	}
+	p = p.To4()
+	if p == nil {
+		return false
+	}
+	switch {
+	case p[0] == 10:
+		return true
+	case p[0] == 172 && p[1]&0xf0 == 16:
+		return true
+	case p[0] == 192 && p[1] == 168:
+		return true
+	}
+	return false
+}
+
+// primaryOutboundIP 返回本机对外通信时实际使用的源 IP（默认路由所在网卡的那张）。
+//
+// 怎么问内核：发起一次 UDP「连接」。UDP 的 connect 只查路由表并选定源地址，
+// **一个包都不发** —— 不是在访问外网，也就不会产生任何出网流量。
+// 问不到（没有默认路由 / 离线）时返回空串，调用方退化成保持网卡枚举顺序。
+func primaryOutboundIP() string {
+	conn, err := net.Dial("udp", "8.8.8.8:80")
+	if err != nil {
+		return ""
+	}
+	defer conn.Close()
+	host, _, err := net.SplitHostPort(conn.LocalAddr().String())
+	if err != nil {
+		return ""
+	}
+	return host
+}
+
 // LanAddresses 列出本机可用于局域网访问的 IPv4 地址（形如 `192.168.1.5:50022`）。
 //
 // 过滤掉回环、链路本地（169.254.x）与非 IPv4：这三类给手机都没用。
-// 一台机器可能有多个（有线 + 无线 + 虚拟网卡），所以返回切片让调用方全都打印出来 ——
-// 猜错网卡比多打两行地址麻烦得多。
+// 挑选与排序的口径见上面那段注释（虚拟网卡剔除 + 默认路由那张排最前）。
 func LanAddresses(port int) []string {
 	ifaces, err := net.Interfaces()
 	if err != nil {
 		return nil
 	}
-	var out []string
+	var cands []lanCandidate
 	for _, ifc := range ifaces {
 		if ifc.Flags&net.FlagUp == 0 || ifc.Flags&net.FlagLoopback != 0 {
 			continue
@@ -61,7 +186,68 @@ func LanAddresses(port int) []string {
 			if ip4 == nil || ip4.IsLoopback() || ip4.IsLinkLocalUnicast() {
 				continue
 			}
-			out = append(out, fmt.Sprintf("%s:%d", ip4.String(), port))
+			cands = append(cands, lanCandidate{ip: ip4.String(), iface: ifc})
+		}
+	}
+	return orderLanAddresses(cands, primaryOutboundIP(), port)
+}
+
+// orderLanAddresses 把候选地址按「手机最可能连得上」排好并拼上端口。
+//
+// 三步：
+//  1. 按**名字**剔掉虚拟网卡（Hyper-V / 容器 / 隧道 / 回环伪接口）——
+//     它们的地址只在本机或专用隧道里有效，手机连不到。
+//  2. 再剔掉**公网段**地址：只要还有私有地址，公网段的就不要
+//     （企业 VPN 虚拟网卡常占一段公网地址，而它在 Windows 上报的是连接别名
+//     「本地连接」这种通用名，靠名字抓不到 —— 靠网段能抓到）。
+//  3. 剩下的里，出站主地址（默认路由所在网卡）排最前。
+//
+// 每一步都有兜底：真实网卡没剩就退回虚拟网卡，私有地址没剩就退回公网地址 ——
+// **不能一个地址都不报**。
+//
+// 拆成独立函数是为了能直接喂合成数据做单测 —— 各人机器上的网卡千差万别，
+// 靠真机跑出来的用例没法覆盖「VPN 虚拟网卡恰好排在最前」这种关键情形。
+func orderLanAddresses(cands []lanCandidate, primary string, port int) []string {
+	if len(cands) == 0 {
+		return nil
+	}
+	real := make([]lanCandidate, 0, len(cands))
+	virtual := make([]lanCandidate, 0, len(cands))
+	for _, c := range cands {
+		if isVirtualIface(c.iface.Name) {
+			virtual = append(virtual, c)
+		} else {
+			real = append(real, c)
+		}
+	}
+	pool := real
+	if len(pool) == 0 {
+		// 一张真实网卡都没有：虚拟网卡也得给 —— 不能一个地址都不报。
+		pool = virtual
+	}
+	if priv := filterByPrivate(pool); len(priv) > 0 {
+		pool = priv
+	}
+	out := make([]string, 0, len(pool))
+	for _, c := range pool {
+		if c.ip == primary {
+			out = append(out, fmt.Sprintf("%s:%d", c.ip, port))
+		}
+	}
+	for _, c := range pool {
+		if c.ip != primary {
+			out = append(out, fmt.Sprintf("%s:%d", c.ip, port))
+		}
+	}
+	return out
+}
+
+// filterByPrivate 只留私有网段（RFC1918）的候选。
+func filterByPrivate(cands []lanCandidate) []lanCandidate {
+	out := make([]lanCandidate, 0, len(cands))
+	for _, c := range cands {
+		if isPrivateIPv4(c.ip) {
+			out = append(out, c)
 		}
 	}
 	return out

package/internal/client/lan_test.go

@@ -1,6 +1,7 @@
 package client
 
 import (
+	"net"
 	"strings"
 	"testing"
 )
@@ -51,3 +52,112 @@ func TestLanAddresses(t *testing.T) {
 	// 本机可能只连着回环（离线环境），所以不要求非空，只在有结果时做上面的形状断言。
 	t.Logf("局域网地址：%v", got)
 }
+
+// TestIsVirtualIface 虚拟网卡的识别。
+//
+// 回归背景（2026-10-23）：一台装了企业 VPN + Hyper-V 的机器上，网卡枚举里
+// 排最前的是 VPN 虚拟网卡，手机拿到它就连不上 —— 详见 lan.go 那段注释。
+func TestIsVirtualIface(t *testing.T) {
+	cases := []struct {
+		name string
+		want bool
+	}{
+		{"以太网", false},
+		{"Ethernet", false},
+		{"WLAN", false},
+		{"Wi-Fi", false},
+		{"本地连接", false}, // Windows 上真实网卡也可能是中文名
+		{"vEthernet (Default Switch)", true},
+		{"Hyper-V Virtual Ethernet Adapter", true},
+		{"VMware Network Adapter VMnet8", true},
+		{"docker0", true},
+		{"veth1234", true},
+		{"virbr0", true},
+		{"br-abcdef", true},
+		{"utun3", true},
+		{"tailscale0", true},
+		{"wg0", true},
+		{"Loopback Pseudo-Interface 1", true},
+		{"  以太网  ", false}, // 前后空格不算
+	}
+	for _, tc := range cases {
+		if got := isVirtualIface(tc.name); got != tc.want {
+			t.Errorf("isVirtualIface(%q) = %v，want %v", tc.name, got, tc.want)
+		}
+	}
+}
+
+// TestIsPrivateIPv4 RFC1918 判定。
+func TestIsPrivateIPv4(t *testing.T) {
+	cases := []struct {
+		ip   string
+		want bool
+	}{
+		{"192.168.31.37", true},
+		{"10.0.0.1", true},
+		{"172.16.0.1", true},
+		{"172.31.255.254", true},
+		{"172.32.0.1", false},
+		{"172.15.0.1", false},
+		{"2.0.0.1", false}, // 企业 VPN 虚拟网卡占的公网段
+		{"8.8.8.8", false},
+		{"", false},
+	}
+	for _, tc := range cases {
+		if got := isPrivateIPv4(tc.ip); got != tc.want {
+			t.Errorf("isPrivateIPv4(%q) = %v，want %v", tc.ip, got, tc.want)
+		}
+	}
+}
+
+// TestOrderLanAddresses 排序：手机最可能连上的那个必须排第一。
+//
+// 回归背景（2026-10-23）：真实机器上枚举顺序是
+//
+//	[0] 2.0.0.1     ← Sangfor aTrust VNIC（企业 VPN 虚拟网卡）
+//	[1] 172.29.64.1 ← Hyper-V 虚拟交换机
+//	[2] 192.168.31.37 ← 以太网（手机能连的只有这个）
+//
+// 移动端只取 lanUrls[0]，于是「公司远程」环境被种成了 2.0.0.1 —— 手机永远连不上。
+func TestOrderLanAddresses(t *testing.T) {
+	cands := []lanCandidate{
+		{ip: "2.0.0.1", iface: net.Interface{Name: "本地连接"}},                           // VPN 虚拟网卡（Windows 上是中文别名）
+		{ip: "172.29.64.1", iface: net.Interface{Name: "vEthernet (Default Switch)"}}, // Hyper-V
+		{ip: "192.168.31.37", iface: net.Interface{Name: "以太网"}},
+	}
+	got := orderLanAddresses(cands, "192.168.31.37", 9100)
+	if len(got) == 0 {
+		t.Fatal("不该返回空")
+	}
+	if got[0] != "192.168.31.37:9100" {
+		t.Errorf("第一个必须是手机连得上的那个（192.168.31.37），got %v", got)
+	}
+	for _, a := range got {
+		if strings.HasPrefix(a, "2.0.0.1:") || strings.HasPrefix(a, "172.29.") {
+			t.Errorf("虚拟网卡地址不该出现在列表里：%s", a)
+		}
+	}
+}
+
+// TestOrderLanAddressesVirtualOnly 只有虚拟网卡时也得给地址 —— 不能一个都不报。
+func TestOrderLanAddressesVirtualOnly(t *testing.T) {
+	cands := []lanCandidate{
+		{ip: "172.29.64.1", iface: net.Interface{Name: "vEthernet (Default Switch)"}},
+	}
+	got := orderLanAddresses(cands, "", 9100)
+	if len(got) != 1 || got[0] != "172.29.64.1:9100" {
+		t.Errorf("没有真实网卡时应退回报虚拟网卡地址，got %v", got)
+	}
+}
+
+// TestOrderLanAddressesPrimaryFirst 出站主地址在同一档里排最前。
+func TestOrderLanAddressesPrimaryFirst(t *testing.T) {
+	cands := []lanCandidate{
+		{ip: "192.168.31.10", iface: net.Interface{Name: "以太网 2"}},
+		{ip: "192.168.31.37", iface: net.Interface{Name: "以太网"}},
+	}
+	got := orderLanAddresses(cands, "192.168.31.37", 9100)
+	if len(got) != 2 || got[0] != "192.168.31.37:9100" {
+		t.Errorf("出站主地址应排最前，got %v", got)
+	}
+}

package/internal/client/service.go

@@ -80,6 +80,14 @@ type Options struct {
 	// 为什么可配：UA 会决定站点给哪一版页面。中国大陆出口 + 移动 UA 时，Google 会跳到
 	// http://www.google.cn/m（该路径本身就是 404）；换成桌面 UA 则走香港跳转、可正常打开。
 	BrowseUA string
+	// AllowAnyOrigin 对**任意 Origin** 回 CORS 头（2026-10-23）。
+	//
+	// 默认只放行「本机页面」（见 withCORS）：APK / 桌面壳这些容器源的 Origin 各不相同，
+	// 自托管部署的入口也不止本机 —— 只放行 loopback 时，从别的设备 / 别的源打开的页面
+	// 会被浏览器判成跨域失败（用户侧就是「只能本地访问」）。
+	// 打开它 = 任意网页都能**读**响应；真正的门锁仍是令牌（没有 X-Magic-Token 一律 401）。
+	// `--lan` 时默认开启（都绑 0.0.0.0 了，再按 loopback 卡 Origin 没有意义）。
+	AllowAnyOrigin bool
 }
 
 // Service 本地服务。
@@ -98,6 +106,9 @@ type Service struct {
 	// jobs 服务端作业队列（同一 workspace 串行 + 幂等 + 持久化），见 jobs.go。
 	jobs *jobQueue
 
+	// inst 服务实例的稳定 id（见 instance.go）：同一台桌面的多个入口靠它归一。
+	inst instanceIDCache
+
 	// 内置浏览器中转用的 HTTP 客户端（惰性建、带 cookie jar，按上游 host 存会话）。
 	// 见 browse.go —— 它让 iframe 的流量走**桌面端网络**，而不是手机直连。
 	browseOnce sync.Once
@@ -309,7 +320,7 @@ func (s *Service) withCORS(next http.Handler) http.Handler {
 		if origin != "" {
 			// Origin 会随请求方变，不加 Vary 会把一个源的响应喂给另一个源。
 			w.Header().Add("Vary", "Origin")
-			if localOrigin(origin) {
+			if s.opts.AllowAnyOrigin || localOrigin(origin) {
 				w.Header().Set("Access-Control-Allow-Origin", origin)
 				/* ⚠️ 写方法必须点名（2026-10-23 用户：「删除无法删除」）。
 				   只写 GET/POST 时，容器里（源=https://localhost）的删除 / 重命名 / 置顶同步
@@ -415,6 +426,10 @@ func (s *Service) handleHealth(w http.ResponseWriter, r *http.Request) {
 		// 服务端作业队列（2026-10-23）：有它才谈得上「多客户端串行 + 幂等」。
 		// 老插件没有该字段 → 客户端退回本地排队（见 client-ui-mobile 的 fallback）。
 		"jobs": true,
+		// 服务实例的稳定 id（2026-10-23，只增字段）：同一台桌面的本地 / 局域网 / 公网
+		// 入口可能有多条 URL，客户端据此把它们归一成同一个环境（队列与设置共用）。
+		// 老插件没有该字段 → 客户端退回按连接各自算环境。
+		"instanceId": s.instanceID(),
 		// 远程移动端界面在不在（见 handleMobileUI）。
 		// 客户端的闸门页要据此决定「跳远程 /m/ 还是用包里自带的 ui.html」。
 		// 为什么不放在 features 里：features 是**core 的能力位**（s.contract.Features），

package/internal/client/service_test.go

@@ -71,11 +71,13 @@ const hostedContract = `{"contractVersion":2,"features":["feature.session.events
 
 func newTestService(t *testing.T, core string) *Service {
 	t.Helper()
-	/* 测试互不干扰：作业目录放临时目录；并发上限放大（假 core 不退出，不放大就会把
-	   同一进程里后续用例堵在队列里）。串行语义由 TestJobs* 用独立服务端覆盖。 */
+	/* 测试互不干扰：作业目录 / 实例 id 都放临时目录；并发上限放大（假 core 不退出，
+	   不放大就会把同一进程里后续用例堵在队列里）。串行语义由 TestJobs* 用独立服务端覆盖。 */
 	t.Setenv("MAGIC_CLIENT_JOBS_DIR", t.TempDir())
 	t.Setenv("MAGIC_CLIENT_MAX_RUNNING", "64")
-	svc, err := New(Options{MagicAgent: core, Profile: DefaultProfile(), Token: "tok"})
+	prof := DefaultProfile()
+	prof.Storage.Dir = t.TempDir()
+	svc, err := New(Options{MagicAgent: core, Profile: prof, Token: "tok"})
 	if err != nil {
 		t.Fatalf("New: %v", err)
 	}

package/internal/session/sessionlog.go

@@ -104,6 +104,29 @@ func HasSessionLog(dir, id string) bool {
 	return err == nil && st.Size() > 0
 }
 
+// HasSessionLogIn 判断**给定候选 id** 里有没有可回放的日志（文件在且非空）。
+//
+// 与 HasSessionLog 的区别：**不回查登记表**。调用方（列表页）手里已经有这条记录的
+// session_id / run_id，两个都试一遍就够了；而 HasSessionLog 会走
+// ResolveLogID → Find → List，那是「把全部登记记录读一遍」——
+// 逐行调用就是 O(N²) 次文件读。2026-10-23 实测：登记表 760 条时
+// `magic-agent --sessions` 卡死数分钟、CPU 打满，移动端列表永远停在「读取中…」。
+func HasSessionLogIn(dir string, ids ...string) bool {
+	if dir == "" {
+		return false
+	}
+	for _, id := range ids {
+		id = strings.TrimSpace(id)
+		if id == "" {
+			continue
+		}
+		if st, err := os.Stat(logPath(dir, id)); err == nil && st.Size() > 0 {
+			return true
+		}
+	}
+	return false
+}
+
 func fileExists(p string) bool {
 	st, err := os.Stat(p)
 	return err == nil && !st.IsDir()

package/internal/session/sessionlog_read_test.go

@@ -623,3 +623,42 @@ func writeRecordForTest(t *testing.T, dir string, rec Record) {
 		t.Fatal(err)
 	}
 }
+
+// TestHasSessionLogIn 列表页用的「按候选 id 直接查日志」：不查登记表。
+//
+// 为什么要单独一个函数（2026-10-23）：`--sessions` 原先逐行调 HasSessionLog，
+// 而它内部走 ResolveLogID → Find → List，等于**每行都把全部登记记录读一遍**。
+// 本机登记表涨到 760 条后，整条命令卡死数分钟、CPU 打满，移动端列表永远停在
+// 「读取中…」。这里钉住新函数的行为：两个 id 都认、目录为空即 false、绝不碰登记表。
+func TestHasSessionLogIn(t *testing.T) {
+	dir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(dir, "sess-a.jsonl"),
+		[]byte(`{"seq":1,"kind":"text","text":"a"}`+"\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	// 空文件不算有历史（与 HasSessionLog 同口径）。
+	if err := os.WriteFile(filepath.Join(dir, "sess-empty.jsonl"), nil, 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	if !HasSessionLogIn(dir, "sess-a") {
+		t.Error("按 session_id 应命中")
+	}
+	if !HasSessionLogIn(dir, "", "sess-a") {
+		t.Error("候选里有一个命中就算命中（空串跳过）")
+	}
+	if HasSessionLogIn(dir, "sess-empty") {
+		t.Error("空文件不算有可回放历史")
+	}
+	if HasSessionLogIn(dir, "nope", "") {
+		t.Error("都没有时应为 false")
+	}
+	if HasSessionLogIn("", "sess-a") {
+		t.Error("dir 为空应直接 false（不能去猜默认目录）")
+	}
+	// 关键：本函数**不依赖**登记表 —— 即使把 EnvDir 指到空目录也必须照常工作。
+	t.Setenv(EnvDir, t.TempDir())
+	if !HasSessionLogIn(dir, "sess-a") {
+		t.Error("HasSessionLogIn 不该依赖登记表目录")
+	}
+}

package/npm/apk/version.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.3.9",
-  "versionCode": 20309,
-  "builtAt": "2026-10-23T11:12:09.067Z"
+  "version": "2.4.2",
+  "versionCode": 20402,
+  "builtAt": "2026-10-23T12:24:54.000Z"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "magic-agent",
-  "version": "2.3.9",
+  "version": "2.4.3",
   "description": "专业的 agent CLI 代理工具 - 统一 claude / codebuddy / trae / llm / codex / openclaw 引擎",
   "license": "MIT",
   "bin": {