magic-agent 1.0.2 → 1.0.46

package/internal/client/browse.go

@@ -0,0 +1,456 @@
+package client
+
+import (
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"net/http/cookiejar"
+	"net/url"
+	"regexp"
+	"strings"
+	"time"
+)
+
+/* 内置浏览器的**服务端中转**。
+ *
+ * ── 为什么需要它 ──
+ * 移动端的内置浏览器是一个 <iframe>。iframe 里的站点是**客户端的 WebView 自己去拉的**，
+ * 也就是说走的是**手机的网络**；桌面端只把界面发给了手机，并不参与抓取。要让浏览走桌面端
+ * 的网络（例如桌面能上、手机不能上的站点，或内网服务），只能由桌面端**代取**再回给手机。
+ *
+ * ── 形状 ──
+ *   手机 iframe → GET /b/<scheme>/<host><path>?magicToken=…
+ *   桌面端      → 按 <scheme>://<host><path> 抓取
+ *              → HTML 就地改写（把页面里的链接/资源地址都指回本中转）
+ *              → 回给手机
+ *
+ * 用**路径前缀**承载目标地址（而不是 ?url= 全量编码）：浏览器解析相对地址时会自动保留
+ * 前缀，配上注入的 <base> 就能让同站链接继续走中转。令牌只放在**首帧**的查询串里，
+ * 首帧响应下发 cookie，后续子资源请求靠 cookie 过鉴权（否则每个 URL 都得带令牌）。
+ *
+ * ── 刻意不做的事 ──
+ *   - 不转发上游的 Set-Cookie：上游会话存桌面端的 cookie jar，别去污染手机对本服务的 cookie。
+ *   - 不把 X-Frame-Options / CSP 透传：本来就是为了让原本禁止内嵌的站点能显示，
+ *     这两个头一透传就等于白做。
+ *   - 不改 <script> 内部的字符串：在 JS 里替换 URL 会砸掉脚本。代价是页内 JS 拼出来的
+ *     地址（fetch/XHR/动态跳转）不走中转 —— 这是本方案的已知边界。
+ */
+
+const (
+	// browsePrefix 中转路径前缀。
+	browsePrefix = "/b/"
+	// browseCookie 首帧下发、供子资源请求复用的鉴权 cookie。
+	browseCookie = "magic_browse"
+	// browseMaxBytes HTML 改写单页size上限；超了直接报错（不静默截断成坏页面）。
+	browseMaxBytes = 12 << 20
+	// browseUA 伪装成 Android Chrome —— 直接拿 Go 默认 UA 会被不少移动站点降级甚至拒绝。
+	// 大陆出口下它会让 Google 跳到 www.google.cn/m（404），可用 --browse-ua 换成桌面 UA。
+	browseUA = "Mozilla/5.0 (Linux; Android 13) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36"
+	// browseUADesktop 桌面 Chrome：站点给桌面版页面；也让 Google 走香港跳转而不是 CN 移动跳转。
+	browseUADesktop = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+)
+
+var (
+	browseBaseRe   = regexp.MustCompile(`(?is)<base\b[^>]*>`)
+	browseCSPRe    = regexp.MustCompile(`(?is)<meta[^>]+http-equiv\s*=\s*["']?Content-Security-Policy["']?[^>]*>`)
+	browseScriptRe = regexp.MustCompile(`(?is)<script\b[^>]*>.*?</script>`)
+	browseAttrRe   = regexp.MustCompile(`(?is)\b(href|src|poster|action|data)\s*=\s*("([^"]*)"|'([^']*)')`)
+	browseSrcsetRe = regexp.MustCompile(`(?is)\bsrcset\s*=\s*("([^"]*)"|'([^']*)')`)
+	browseCSSURLRe = regexp.MustCompile(`(?is)url\(\s*['"]?([^'")]+)['"]?\s*\)`)
+	browseImportRe = regexp.MustCompile(`(?is)@import\s+("([^"]*)"|'([^']*)')`)
+)
+
+/* googleHostMap：把会踩到「中国大陆移动跳转」的 Google 入口换到香港域名。
+ *
+ * 背景：大陆出口 + 移动 UA 时，google.com 会 302 到 http://www.google.cn/m，
+ * 而该路径本身就是 Google 的 404（实测）。同一个 UA/IP 下 www.google.com.hk 是 200，
+ * 而且给的是**移动版**页面 —— 所以我们只在入口把主机名换掉，其余一律不动。
+ *
+ * 只映射**搜索首页/搜索**这几个主机：accounts./mail./drive. 等不能动，换了会直接坏。
+ */
+var googleHostMap = map[string]string{
+	"google.com":     "www.google.com.hk",
+	"www.google.com": "www.google.com.hk",
+	"google.cn":      "www.google.com.hk",
+	"www.google.cn":  "www.google.com.hk",
+}
+
+func remapBrowseHost(u *url.URL) *url.URL {
+	// /sorry/... 是 Google 的「异常流量」人机验证页，只存在于 www.google.com。
+	// 把它也换成 .hk 会变成 404，用户连验证都做不了 —— 必须放行。
+	if strings.HasPrefix(strings.ToLower(u.Path), "/sorry") {
+		return u
+	}
+	to, ok := googleHostMap[strings.ToLower(u.Hostname())]
+	if !ok {
+		return u
+	}
+	if p := u.Port(); p != "" {
+		u.Host = net.JoinHostPort(to, p)
+	} else {
+		u.Host = to
+	}
+	return u
+}
+
+// browseUserAgent 决定中转用哪个 UA：显式配置优先，其次识别 mobile/desktop 关键字。
+func (s *Service) browseUserAgent() string {
+	ua := strings.TrimSpace(s.opts.BrowseUA)
+	switch strings.ToLower(ua) {
+	case "":
+		return browseUA
+	case "mobile":
+		return browseUA
+	case "desktop", "pc":
+		return browseUADesktop
+	default:
+		return ua
+	}
+}
+
+// handleBrowse 中转入口。
+func (s *Service) handleBrowse(w http.ResponseWriter, r *http.Request) {
+	target, ok := browseTarget(r)
+	if !ok {
+		writeErr(w, http.StatusBadRequest, "用法：/b/<http|https>/<host>/<path>")
+		return
+	}
+	target = remapBrowseHost(target)
+
+	// 鉴权：查询令牌（首帧）或 cookie（子资源）。
+	if want := strings.TrimSpace(s.opts.Token); want != "" {
+		got := strings.TrimSpace(r.URL.Query().Get("magicToken"))
+		if got == "" {
+			if c, err := r.Cookie(browseCookie); err == nil {
+				got = c.Value
+			}
+		}
+		if got != want {
+			writeErr(w, http.StatusUnauthorized, "缺少或错误的访问令牌（?magicToken= 或 cookie）")
+			return
+		}
+		if r.URL.Query().Get("magicToken") != "" {
+			http.SetCookie(w, &http.Cookie{
+				Name: browseCookie, Value: want, Path: "/",
+				HttpOnly: true, SameSite: http.SameSiteLaxMode,
+			})
+		}
+	}
+
+	// 中转自身的访问前缀，例如 http://127.0.0.1:52118。用**请求的 Host** 而不是写死：
+	// 手机可能经局域网 IP、回环或隧道访问，取请求自带的 Host 才与它的入口一致。
+	// 改写出的地址一律带这个前缀（绝对地址），原因见 browseURL 的注释。
+	//
+	// 协议要认隧道给的头：cloudflared 等反代在本地这一段是 http（r.TLS 为空），
+	// 但**对外是 https**。若照 r.TLS 判成 http，改写出的子资源就是 http，
+	// 而页面是 https —— 浏览器按「混合内容」全部拦掉（图片/样式/脚本全裂）。
+	scheme := "http"
+	if r.TLS != nil {
+		scheme = "https"
+	}
+	if p := strings.TrimSpace(r.Header.Get("X-Forwarded-Proto")); p != "" {
+		scheme = p
+	}
+	proxyBase := scheme + "://" + r.Host
+
+	outReq, err := http.NewRequestWithContext(r.Context(), r.Method, target.String(), r.Body)
+	if err != nil {
+		writeErr(w, http.StatusBadGateway, "构造请求失败："+err.Error())
+		return
+	}
+	// 头：优先**原样转发客户端真实的浏览器指纹**（UA + Client Hints + Sec-Fetch）。
+	// 为什么要这样：上游的风控（Google 的「异常流量」就是它）会看指纹是否自洽。
+	// 只塞一个伪装 UA、却不给配套的 Sec-CH-UA 等头，等于自己举牌说「我是脚本」——
+	// 表现就是被跳转到 /sorry/index 人机验证。手机上的 WebView 本来就是真浏览器，
+	// 把它的头原样带过去最省事也最稳。客户端没给 UA 时才退回内置伪装。
+	ua := strings.TrimSpace(r.Header.Get("User-Agent"))
+	if ua == "" {
+		ua = s.browseUserAgent()
+	}
+	outReq.Header.Set("User-Agent", ua)
+	// 刻意不带 Accept-Encoding：留给 Go 的 transport 自动协商 gzip 并透明解压，
+	// 这样拿到的 body 一定是可改写的明文。
+	for _, h := range []string{
+		"Accept", "Accept-Language", "Content-Type",
+		"Sec-CH-UA", "Sec-CH-UA-Mobile", "Sec-CH-UA-Platform", "Sec-CH-UA-Full-Version-List",
+		"Sec-Fetch-Dest", "Sec-Fetch-Mode", "Sec-Fetch-Site", "Sec-Fetch-User",
+		"Upgrade-Insecure-Requests",
+	} {
+		if v := r.Header.Get(h); v != "" {
+			outReq.Header.Set(h, v)
+		}
+	}
+
+	resp, err := s.browseClient().Do(outReq)
+	if err != nil {
+		writeErr(w, http.StatusBadGateway, "桌面端抓取失败："+err.Error())
+		return
+	}
+	defer resp.Body.Close()
+
+	// 重定向：把 Location 也改成中转地址，否则浏览器一跳出前缀就离开中转了。
+	if loc := resp.Header.Get("Location"); loc != "" && resp.StatusCode >= 300 && resp.StatusCode < 400 {
+		if abs, perr := target.Parse(loc); perr == nil {
+			w.Header().Set("Location", browseURL(abs, proxyBase))
+		} else {
+			w.Header().Set("Location", loc)
+		}
+		w.WriteHeader(resp.StatusCode)
+		return
+	}
+
+	ctype := strings.ToLower(resp.Header.Get("Content-Type"))
+	if strings.Contains(ctype, "text/html") {
+		body, rerr := readCapped(resp.Body)
+		if rerr != nil {
+			writeErr(w, http.StatusBadGateway, rerr.Error())
+			return
+		}
+		w.Header().Set("Content-Type", "text/html; charset=utf-8")
+		w.Header().Set("Cache-Control", "no-store")
+		w.WriteHeader(resp.StatusCode)
+		_, _ = w.Write(rewriteBrowseHTML(body, target, proxyBase))
+		return
+	}
+	// CSS 也要改写：样式表里 background-image / @import 引用的图不经过 HTML，
+	// 不改写就会按 CSS 文件所在位置解析到错误地址（图全裂）。
+	if strings.Contains(ctype, "text/css") {
+		body, rerr := readCapped(resp.Body)
+		if rerr != nil {
+			writeErr(w, http.StatusBadGateway, rerr.Error())
+			return
+		}
+		w.Header().Set("Content-Type", "text/css; charset=utf-8")
+		w.WriteHeader(resp.StatusCode)
+		_, _ = w.Write([]byte(rewriteCSS(string(body), target, proxyBase)))
+		return
+	}
+
+	// 非 HTML：原样透传。上游响应头我们从头到尾没拷贝，所以 X-Frame-Options / CSP
+	// 自然不存在 —— 这正是「原本禁止内嵌的站点现在能显示」的原因。
+	if ct := resp.Header.Get("Content-Type"); ct != "" {
+		w.Header().Set("Content-Type", ct)
+	}
+	w.WriteHeader(resp.StatusCode)
+	_, _ = io.Copy(w, resp.Body)
+}
+
+// readCapped 读响应体，超过上限直接报错（不静默截断成坏页面）。
+func readCapped(r io.Reader) ([]byte, error) {
+	b, err := io.ReadAll(io.LimitReader(r, browseMaxBytes+1))
+	if err != nil {
+		return nil, fmt.Errorf("读取响应失败：%w", err)
+	}
+	if len(b) > browseMaxBytes {
+		return nil, fmt.Errorf("响应过大（超过 %dMB），未做中转", browseMaxBytes>>20)
+	}
+	return b, nil
+}
+
+// browseClient 惰性建中转用 HTTP 客户端：带 cookie jar（按上游 host 存会话），
+// 且**不自动跟随重定向**（我们要自己改写 Location）。
+func (s *Service) browseClient() *http.Client {
+	s.browseOnce.Do(func() {
+		jar, _ := cookiejar.New(nil)
+		s.browseHTTP = &http.Client{
+			Timeout: 30 * time.Second,
+			Jar:     jar,
+			CheckRedirect: func(req *http.Request, via []*http.Request) error {
+				return http.ErrUseLastResponse
+			},
+		}
+	})
+	return s.browseHTTP
+}
+
+// browseTarget 从请求路径拆出目标 URL：/b/<scheme>/<host>/<path>?<query>。
+// 纯手写拆分，不用正则（路径里允许出现任意字符）。
+func browseTarget(r *http.Request) (*url.URL, bool) {
+	rest := strings.TrimPrefix(r.URL.EscapedPath(), browsePrefix)
+	i := strings.IndexByte(rest, '/')
+	if i < 0 {
+		return nil, false
+	}
+	scheme := rest[:i]
+	rest = rest[i+1:]
+	host, path := rest, "/"
+	if j := strings.IndexByte(rest, '/'); j >= 0 {
+		host, path = rest[:j], rest[j:]
+	}
+	if (scheme != "http" && scheme != "https") || host == "" {
+		return nil, false
+	}
+	raw := scheme + "://" + host + path
+	if q := stripMagicToken(r.URL.RawQuery); q != "" {
+		raw += "?" + q
+	}
+	u, err := url.Parse(raw)
+	if err != nil {
+		return nil, false
+	}
+	return u, true
+}
+
+// stripMagicToken 去掉中转自己的令牌参数，避免把它连同目标地址一起发给上游站点。
+func stripMagicToken(q string) string {
+	if q == "" {
+		return ""
+	}
+	parts := strings.Split(q, "&")
+	out := parts[:0]
+	for _, p := range parts {
+		if p == "" || strings.HasPrefix(p, "magicToken=") {
+			continue
+		}
+		out = append(out, p)
+	}
+	return strings.Join(out, "&")
+}
+
+// browseURL 把目标地址映射成中转地址。非 http(s) 原样返回。
+//
+// 产出的是**绝对地址**（带 proxyBase 前缀），而不是 /b/... 这样的根相对地址。
+// 原因：根相对地址按「所在文档 / 样式表的源」解析，而页面里常有**直连加载**的外站样式表
+// 或脚本（由 JS 动态插入，我们改写不到）。它们消费到 url(/b/...) 时会解析回自己的源
+// （实测：被解析成 ms.bdstatic.com/b/...，图片全裂）。绝对地址在任何上下文都指向中转。
+func browseURL(abs *url.URL, proxyBase string) string {
+	if abs == nil || (abs.Scheme != "http" && abs.Scheme != "https") {
+		if abs == nil {
+			return ""
+		}
+		return abs.String()
+	}
+	p := abs.EscapedPath()
+	if p == "" {
+		p = "/"
+	}
+	out := proxyBase + browsePrefix + abs.Scheme + "/" + abs.Host + p
+	if abs.RawQuery != "" {
+		out += "?" + abs.RawQuery
+	}
+	return out
+}
+
+// rewriteRef 把一个页面里的引用地址解析成绝对地址后再映射到中转。
+// data:/javascript:/mailto: 等非网络协议与纯锚点一律不动，避免把页面改坏。
+func rewriteRef(raw string, page *url.URL, proxyBase string) string {
+	t := strings.TrimSpace(raw)
+	if t == "" {
+		return raw
+	}
+	low := strings.ToLower(t)
+	for _, p := range []string{"data:", "javascript:", "mailto:", "tel:", "blob:", "about:", "#"} {
+		if strings.HasPrefix(low, p) {
+			return raw
+		}
+	}
+	ref, err := url.Parse(t)
+	if err != nil {
+		return raw
+	}
+	abs := page.ResolveReference(ref)
+	if abs.Scheme != "http" && abs.Scheme != "https" {
+		return raw
+	}
+	return browseURL(abs, proxyBase)
+}
+
+// rewriteBrowseHTML 就地改写 HTML：剥掉会妨碍内嵌的头、把所有 URL 指回中转、注入 <base>。
+//
+// 分片处理：<script> 段原样保留（在 JS 里替换 URL 会砸脚本），其余段做属性 / srcset / CSS url() 改写。
+func rewriteBrowseHTML(body []byte, page *url.URL, proxyBase string) []byte {
+	html := string(body)
+	html = browseBaseRe.ReplaceAllString(html, "")
+	html = browseCSPRe.ReplaceAllString(html, "")
+
+	var b strings.Builder
+	last := 0
+	for _, loc := range browseScriptRe.FindAllStringIndex(html, -1) {
+		b.WriteString(rewriteChunk(html[last:loc[0]], page, proxyBase))
+		b.WriteString(html[loc[0]:loc[1]])
+		last = loc[1]
+	}
+	b.WriteString(rewriteChunk(html[last:], page, proxyBase))
+	out := b.String()
+
+	// 注入 <base>：给**没被改写**的相对地址一个基准，指向本中转的页面地址。
+	// 改写过的地址现在是绝对的、不依赖 base（早先用根相对地址 + 指向原站的 base，
+	// 会被解析回原站导致图片全裂，已修）。
+	base := `<base href="` + htmlEscapeAttr(browseURL(page, proxyBase)) + `">`
+	if i := strings.Index(strings.ToLower(out), "<head"); i >= 0 {
+		if j := strings.IndexByte(out[i:], '>'); j >= 0 {
+			k := i + j + 1
+			return []byte(out[:k] + base + out[k:])
+		}
+	}
+	return []byte(base + out)
+}
+
+func rewriteChunk(chunk string, page *url.URL, proxyBase string) string {
+	chunk = browseAttrRe.ReplaceAllStringFunc(chunk, func(m string) string {
+		sub := browseAttrRe.FindStringSubmatch(m)
+		name := sub[1]
+		// sub[3]/sub[4] 分别是双/单引号内的值；用原始匹配里的引号字符判定取哪个，
+		// 因为「空值」与「另一种引号」在子匹配里都可能表现为空串。
+		eq := strings.IndexByte(m, '=')
+		rest := strings.TrimLeft(m[eq+1:], " \t")
+		q := byte('"')
+		val := sub[3]
+		if len(rest) > 0 && rest[0] == '\'' {
+			q = '\''
+			val = sub[4]
+		}
+		return name + "=" + string(q) + rewriteRef(val, page, proxyBase) + string(q)
+	})
+	chunk = browseSrcsetRe.ReplaceAllStringFunc(chunk, func(m string) string {
+		sub := browseSrcsetRe.FindStringSubmatch(m)
+		val := sub[2]
+		q := `"`
+		if sub[2] == "" {
+			val = sub[3]
+			q = `'`
+		}
+		return "srcset=" + q + rewriteSrcset(val, page, proxyBase) + q
+	})
+	return rewriteCSS(chunk, page, proxyBase)
+}
+
+// rewriteCSS 改写样式里的资源引用：url(...) 与 @import "..."。
+func rewriteCSS(css string, page *url.URL, proxyBase string) string {
+	css = browseCSSURLRe.ReplaceAllStringFunc(css, func(m string) string {
+		sub := browseCSSURLRe.FindStringSubmatch(m)
+		// 统一重建成不带引号的形式：Go 的 RE2 不支持反向引用，没法配对首尾引号。
+		return "url(" + rewriteRef(sub[1], page, proxyBase) + ")"
+	})
+	css = browseImportRe.ReplaceAllStringFunc(css, func(m string) string {
+		sub := browseImportRe.FindStringSubmatch(m)
+		q := sub[1][:1]
+		val := sub[2]
+		if q == "'" {
+			val = sub[3]
+		}
+		return "@import " + q + rewriteRef(val, page, proxyBase) + q
+	})
+	return css
+}
+
+// rewriteSrcset 处理 srcset：逗号分隔，每段「URL [descriptor]」，只改 URL 那一段。
+func rewriteSrcset(val string, page *url.URL, proxyBase string) string {
+	items := strings.Split(val, ",")
+	for i, it := range items {
+		fields := strings.Fields(strings.TrimSpace(it))
+		if len(fields) == 0 {
+			continue
+		}
+		fields[0] = rewriteRef(fields[0], page, proxyBase)
+		items[i] = strings.Join(fields, " ")
+	}
+	return strings.Join(items, ", ")
+}
+
+// htmlEscapeAttr 只做属性值所需的最小转义。
+func htmlEscapeAttr(s string) string {
+	r := strings.NewReplacer("&", "&amp;", `"`, "&quot;", "<", "&lt;", ">", "&gt;")
+	return r.Replace(s)
+}

package/internal/client/browse_test.go

@@ -0,0 +1,199 @@
+package client
+
+import (
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"strings"
+	"testing"
+)
+
+func mustURL(t *testing.T, s string) *url.URL {
+	t.Helper()
+	u, err := url.Parse(s)
+	if err != nil {
+		t.Fatalf("解析 %q 失败：%v", s, err)
+	}
+	return u
+}
+
+// testProxyBase 测试用的中转前缀（绝对地址形式）。
+const testProxyBase = "http://p"
+
+func TestRemapBrowseHost(t *testing.T) {
+	cases := []struct{ in, want string }{
+		{"https://google.com/", "https://www.google.com.hk/"},
+		{"https://www.google.com/search?q=a", "https://www.google.com.hk/search?q=a"},
+		{"https://www.google.com/", "https://www.google.com.hk/"},
+		// 其它 Google 主机不能动（换了会直接坏）
+		{"https://accounts.google.com/", "https://accounts.google.com/"},
+		{"https://mail.google.com/", "https://mail.google.com/"},
+		// 已经是 hk 的保持
+		{"https://www.google.com.hk/", "https://www.google.com.hk/"},
+		// /sorry 是人机验证页，只存在于 www.google.com，不能被换成 .hk
+		{"https://www.google.com/sorry/index?continue=x", "https://www.google.com/sorry/index?continue=x"},
+	}
+	for _, c := range cases {
+		if got := remapBrowseHost(mustURL(t, c.in)).String(); got != c.want {
+			t.Errorf("remap(%q) = %q，期望 %q", c.in, got, c.want)
+		}
+	}
+}
+
+func TestBrowseURL(t *testing.T) {
+	cases := []struct {
+		in, want string
+	}{
+		{"https://example.com/", "http://p/b/https/example.com/"},
+		{"https://example.com/a/b?x=1", "http://p/b/https/example.com/a/b?x=1"},
+		{"http://192.168.1.5:8080/x", "http://p/b/http/192.168.1.5:8080/x"},
+		{"mailto:a@b.c", "mailto:a@b.c"},
+	}
+	for _, c := range cases {
+		if got := browseURL(mustURL(t, c.in), testProxyBase); got != c.want {
+			t.Errorf("browseURL(%q) = %q，期望 %q", c.in, got, c.want)
+		}
+	}
+}
+
+func TestStripMagicToken(t *testing.T) {
+	cases := []struct{ in, want string }{
+		{"magicToken=t&x=1", "x=1"},
+		{"x=1&magicToken=t", "x=1"},
+		{"x=1", "x=1"},
+		{"", ""},
+		{"magicToken=t", ""},
+	}
+	for _, c := range cases {
+		if got := stripMagicToken(c.in); got != c.want {
+			t.Errorf("stripMagicToken(%q) = %q，期望 %q", c.in, got, c.want)
+		}
+	}
+}
+
+func TestRewriteBrowseHTML(t *testing.T) {
+	page := mustURL(t, "https://example.com/a/b")
+	in := `<html><head><base href="https://example.com/"><title>T</title></head>` +
+		`<body>` +
+		`<a href="/x">root-rel</a>` +
+		`<img src="pic.png">` +
+		`<a href="https://other.com/p">abs</a>` +
+		`<a href="#top">anchor</a>` +
+		`<a href="mailto:a@b.c">mail</a>` +
+		`<link rel="stylesheet" href="/s.css">` +
+		`<div style="background:url('/bg.png')"></div>` +
+		`<img srcset="/1.png 1x, /2.png 2x">` +
+		`<script>var s="/y";</script>` +
+		`</body></html>`
+	out := string(rewriteBrowseHTML([]byte(in), page, testProxyBase))
+
+	wants := []string{
+		`href="http://p/b/https/example.com/x"`,
+		`src="http://p/b/https/example.com/a/pic.png"`,
+		`href="http://p/b/https/other.com/p"`,
+		`href="http://p/b/https/example.com/s.css"`,
+		`url(http://p/b/https/example.com/bg.png)`,
+		`srcset="http://p/b/https/example.com/1.png 1x, http://p/b/https/example.com/2.png 2x"`,
+		`<base href="http://p/b/https/example.com/a/b">`,
+	}
+	for _, w := range wants {
+		if !strings.Contains(out, w) {
+			t.Errorf("改写结果缺少 %q\n实际：%s", w, out)
+		}
+	}
+
+	// 不该动的：锚点、mailto、脚本内字符串、以及原来的 base 标签（应被剥掉）。
+	notWants := []string{
+		`href="http://p/b/https/example.com/#top"`,
+		`/b/https/a@b.c`,
+		`/b/https/example.com/y`, // 脚本里的 "/y" 不应被改
+		`<base href="https://example.com/">`,
+	}
+	for _, nw := range notWants {
+		if strings.Contains(out, nw) {
+			t.Errorf("改写结果不该包含 %q\n实际：%s", nw, out)
+		}
+	}
+	if !strings.Contains(out, `href="#top"`) {
+		t.Errorf("锚点应保持原样，实际：%s", out)
+	}
+	if !strings.Contains(out, `var s="/y";`) {
+		t.Errorf("脚本内容应保持原样，实际：%s", out)
+	}
+	if !strings.Contains(out, `href="mailto:a@b.c"`) {
+		t.Errorf("mailto 应保持原样，实际：%s", out)
+	}
+}
+
+// TestRewriteCSS 样式表里的资源引用也要改写（否则 background-image 全裂）。
+func TestRewriteCSS(t *testing.T) {
+	page := mustURL(t, "https://example.com/css/style.css")
+	in := `.a{background:url('/img/a.png')} .b{background:url(../img/b.png)}` +
+		`@import "sub.css"; @import url('/other.css');`
+	out := rewriteCSS(in, page, testProxyBase)
+	wants := []string{
+		`url(http://p/b/https/example.com/img/a.png)`,
+		`url(http://p/b/https/example.com/img/b.png)`,
+		`@import "http://p/b/https/example.com/css/sub.css"`,
+		`url(http://p/b/https/example.com/other.css)`,
+	}
+	for _, w := range wants {
+		if !strings.Contains(out, w) {
+			t.Errorf("CSS 改写缺少 %q\n实际：%s", w, out)
+		}
+	}
+}
+
+// TestHandleBrowseE2E 端到端：起一个「拒绝内嵌」的上游站点，经中转取回，
+// 断言 (1) X-Frame-Options 被剥掉、(2) 页内链接被改写到本中转。
+func TestHandleBrowseE2E(t *testing.T) {
+	upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "text/html; charset=utf-8")
+		w.Header().Set("X-Frame-Options", "DENY") // 上游明确拒绝被内嵌
+		w.Header().Set("Content-Security-Policy", "frame-ancestors 'none'")
+		_, _ = io.WriteString(w, `<html><head></head><body><a href="/next">next</a></body></html>`)
+	}))
+	defer upstream.Close()
+
+	up, err := url.Parse(upstream.URL)
+	if err != nil {
+		t.Fatal(err)
+	}
+	s := &Service{} // Token 为空 → 跳过鉴权，专注验证中转与改写
+	proxy := httptest.NewServer(http.HandlerFunc(s.handleBrowse))
+	defer proxy.Close()
+
+	resp, err := http.Get(proxy.URL + browsePrefix + "http/" + up.Host + "/")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer resp.Body.Close()
+	body, _ := io.ReadAll(resp.Body)
+
+	if resp.Header.Get("X-Frame-Options") != "" {
+		t.Error("X-Frame-Options 应被剥掉（否则站点无法内嵌）")
+	}
+	if resp.Header.Get("Content-Security-Policy") != "" {
+		t.Error("CSP 应被剥掉")
+	}
+	if !strings.Contains(string(body), browsePrefix+"http/"+up.Host+"/next") {
+		t.Errorf("页内链接应被改写到本中转，实际：%s", body)
+	}
+}
+
+// TestHandleBrowseAuth 令牌校验：给了令牌就必须带对，否则 401。
+func TestHandleBrowseAuth(t *testing.T) {
+	s := &Service{opts: Options{Token: "sekret"}}
+	proxy := httptest.NewServer(http.HandlerFunc(s.handleBrowse))
+	defer proxy.Close()
+
+	resp, err := http.Get(proxy.URL + browsePrefix + "https/example.com/")
+	if err != nil {
+		t.Fatal(err)
+	}
+	resp.Body.Close()
+	if resp.StatusCode != http.StatusUnauthorized {
+		t.Errorf("缺令牌应 401，实际 %d", resp.StatusCode)
+	}
+}

package/internal/client/cors_test.go

@@ -134,3 +134,38 @@ func join(v []string) string {
 	}
 	return out
 }
+
+// originSource（2026-10-11）：移动容器（capacitor/ionic）= 移动端；其余 = 桌面端。
+// 这条决定会话列表上的设备标志，所以两种容器 scheme 都要认。
+// requestSource（2026-10-11）：客户端自报优先，没自报才退回按 Origin 猜。
+// 移动端加载 /m/ 与桌面同源，Origin 一样，所以自报是唯一可靠来源。
+func TestRequestSource(t *testing.T) {
+	cases := []struct{ client, origin, want string }{
+		{"mobile", "https://localhost", "mobile"},
+		{"pc", "capacitor://localhost", "pc"},
+		{"", "capacitor://localhost", "mobile"},
+		{"", "https://localhost", "pc"},
+		{"  MOBILE  ", "", "mobile"},
+		{"unknown", "capacitor://localhost", "mobile"},
+	}
+	for _, c := range cases {
+		if got := requestSource(c.client, c.origin); got != c.want {
+			t.Errorf("requestSource(%q,%q) = %q want %q", c.client, c.origin, got, c.want)
+		}
+	}
+}
+
+func TestOriginSource(t *testing.T) {
+	cases := map[string]string{
+		"capacitor://localhost": "mobile",
+		"ionic://localhost":     "mobile",
+		"https://localhost":     "pc",
+		"http://127.0.0.1:8791": "pc",
+		"":                      "pc",
+	}
+	for in, want := range cases {
+		if got := originSource(in); got != want {
+			t.Errorf("originSource(%q) = %q want %q", in, got, want)
+		}
+	}
+}