magic-agent 2.4.2 → 2.6.0

package/internal/client/lan.go

@@ -8,9 +8,9 @@ import (
 
 /* 局域网接入（P4 的第一级：让手机能连上）。
  *
- * 默认只绑 127.0.0.1 是刻意的：本地端口对同机所有进程可见，开了鉴权才敢往外露。
- * 手机要连就得绑到局域网，而这一开，**令牌就成了唯一的门锁** —— 所以这里的两条
- * 守卫是配套的：`--lan` 必须给足强度的令牌，短令牌直接拒绝启动。
+ * 默认就绑局域网（0.0.0.0:9100，手机开箱可连）：这一开，**令牌就是唯一的门锁** ——
+ * 所以这里的两条守卫是配套的：局域网模式必须给足强度的令牌，短令牌直接拒绝启动；
+ * 只想本机访问用 `--local` 绑回 127.0.0.1。
  *
  * 三级接入里这一级是 L1（局域网）；L2 的跨网中继需要服务端，不在本文件范围。
  */
@@ -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/quotas_merge_test.go

@@ -0,0 +1,107 @@
+package client
+
+// quotas_merge_test.go - --quotas 现查结果合并进缓存的引擎清单（额度不跟着缓存冻住）。
+
+import (
+	"encoding/json"
+	"testing"
+)
+
+func TestMergeQuotaJSONOverridesStaleValues(t *testing.T) {
+	engines := []byte(`[
+		{"engine":"llm","ok":true,"credit_suffix":"%",
+		 "model_quota":{"MiniMax-M3.1-Flash":{"interval_left":"98","weekly_left":"53"},
+		                "minimax-peter":{"interval_left":"98","weekly_left":"53"}}},
+		{"engine":"codebuddy","ok":true,"credit_left":"5800.1","checkin_today":false,"checkin_credit":"100"},
+		{"engine":"trae","ok":true}
+	]`)
+	quotas := []byte(`[
+		{"engine":"llm","credit_suffix":"%",
+		 "model_quota":{"MiniMax-M3.1-Flash":{"interval_left":"98","weekly_left":"53"},
+		                "minimax-peter":{"interval_left":"1","weekly_left":"0"}}},
+		{"engine":"codebuddy","credit_left":"5910.77","checkin_today":true,"checkin_credit":"100"}
+	]`)
+
+	out := mergeQuotaJSON(engines, quotas)
+	var rows []map[string]any
+	if err := json.Unmarshal(out, &rows); err != nil {
+		t.Fatalf("合并结果不是合法 JSON: %v\n%s", err, out)
+	}
+	if len(rows) != 3 {
+		t.Fatalf("引擎行数变了: %d", len(rows))
+	}
+
+	byEngine := map[string]map[string]any{}
+	for _, r := range rows {
+		byEngine[r["engine"].(string)] = r
+	}
+	if got := byEngine["codebuddy"]["credit_left"]; got != "5910.77" {
+		t.Errorf("credit_left 未刷新: %v", got)
+	}
+	if got := byEngine["codebuddy"]["checkin_today"]; got != true {
+		t.Errorf("checkin_today 未刷新: %v", got)
+	}
+	quota := byEngine["llm"]["model_quota"].(map[string]any)
+	peter := quota["minimax-peter"].(map[string]any)
+	if peter["interval_left"] != "1" || peter["weekly_left"] != "0" {
+		t.Errorf("minimax-peter 额度未按新 key 刷新: %v", peter)
+	}
+	if _, ok := byEngine["trae"]["credit_left"]; ok {
+		t.Errorf("没有额度的引擎不该被塞字段: %v", byEngine["trae"])
+	}
+}
+
+func TestMergeQuotaJSONKeepsOldOnEmpty(t *testing.T) {
+	engines := []byte(`[{"engine":"codebuddy","ok":true,"credit_left":"5800.1"}]`)
+	// 现查失败（字段缺失 / 空串）时保留缓存里的旧值，不能把数字抹掉。
+	quotas := []byte(`[{"engine":"codebuddy","credit_left":""}]`)
+
+	out := mergeQuotaJSON(engines, quotas)
+	var rows []map[string]any
+	if err := json.Unmarshal(out, &rows); err != nil {
+		t.Fatal(err)
+	}
+	if got := rows[0]["credit_left"]; got != "5800.1" {
+		t.Fatalf("空结果覆盖了旧值: %v", got)
+	}
+}
+
+func TestMergeQuotaJSONBadInputFallsBack(t *testing.T) {
+	engines := []byte(`[{"engine":"llm","ok":true}]`)
+	if out := mergeQuotaJSON(engines, []byte("not json")); string(out) != string(engines) {
+		t.Fatalf("额度输出非法时应原样返回，实际 %s", out)
+	}
+}
+
+// 登录态也要现查：缓存里是「已登录」，但用户刚登出时下一次打开就该隐藏。
+func TestMergeQuotaJSONLoggedIn(t *testing.T) {
+	engines := []byte(`[
+		{"engine":"codebuddy","ok":true,"logged_in":true,"account":"旧昵称"},
+		{"engine":"codebuddy-ai","ok":true,"logged_in":true}
+	]`)
+	quotas := []byte(`[
+		{"engine":"codebuddy","logged_in":true,"account":"Darren"},
+		{"engine":"codebuddy-ai","logged_in":false}
+	]`)
+
+	out := mergeQuotaJSON(engines, quotas)
+	var rows []map[string]any
+	if err := json.Unmarshal(out, &rows); err != nil {
+		t.Fatal(err)
+	}
+	got := map[string]any{}
+	acct := map[string]any{}
+	for _, r := range rows {
+		got[r["engine"].(string)] = r["logged_in"]
+		acct[r["engine"].(string)] = r["account"]
+	}
+	if got["codebuddy"] != true {
+		t.Errorf("codebuddy logged_in = %v, want true", got["codebuddy"])
+	}
+	if got["codebuddy-ai"] != false {
+		t.Errorf("codebuddy-ai 登出后应合并为 false，实际 %v", got["codebuddy-ai"])
+	}
+	if acct["codebuddy"] != "Darren" {
+		t.Errorf("账号昵称未刷新: %v", acct["codebuddy"])
+	}
+}