优化，bug处理

internal/service/reader/browser_panel.go

@@ -94,6 +94,10 @@ type pendingBrowser struct {
 	sourceURL string
 	userID    string
 	request   rule.BrowserTask
+	// cookies 是发起这次页面的会话 Cookie 累积区：页面在面板里发出的
+	// 请求（接口代理 / 资源代理）会把 Set-Cookie 写回它，用户点「完成」后
+	// 书源会话就能读到登录凭证。
+	cookies browserCookieTarget
 	// html 已就绪的页面源码（data: 直接解码；http 抓取后资源地址已改写）。
 	html     string
 	finalURL string
@@ -113,21 +117,56 @@ type browserHost struct {
 	sourceURL string
 	sourceID  string
 	userID    string
+	// state / capture 是这次会话的 Cookie 累积区与 enabledCookieJar 开关。
+	// 面板承载的页面自己发起的请求（ProxyBrowserXHR / 资源代理）会把
+	// 响应 Set-Cookie 写进 state，从而让「页面里登录成功 = 书源会话拿到凭证」。
+	state   *sourceState
+	capture bool
 }
 
 func (h *browserHost) AwaitBrowser(ctx context.Context, req rule.BrowserTask) (rule.BrowserResult, error) {
-	return h.svc.awaitBrowser(ctx, h.sourceURL, h.sourceID, h.userID, req)
+	return h.svc.awaitBrowser(ctx, h.sourceURL, h.sourceID, h.userID, h.cookieTarget(), req)
 }
 
 func (h *browserHost) OpenBrowser(ctx context.Context, req rule.BrowserTask) error {
-	return h.svc.openBrowser(ctx, h.sourceURL, h.sourceID, h.userID, req)
+	return h.svc.openBrowser(ctx, h.sourceURL, h.sourceID, h.userID, h.cookieTarget(), req)
+}
+
+// cookieTarget 打包会话状态与开关；capture 为假时返回携带 nil state 的目标。
+func (h *browserHost) cookieTarget() browserCookieTarget {
+	if !h.capture {
+		return browserCookieTarget{}
+	}
+	return browserCookieTarget{state: h.state}
+}
+
+// browserCookieTarget 面板链路要回写 Cookie 的目标会话。
+type browserCookieTarget struct {
+	state *sourceState
+}
+
+// captureFrom 把这次请求（含重定向各跳）下发的 Set-Cookie 写回会话。
+// ctx 上挂了 sink 时以它为准（逐跳收集，见 cookies.go），最后再补最终响应。
+// 归属域一律 Cookie 的 Domain 优先、否则该跳地址。
+func (t browserCookieTarget) captureFrom(ctx context.Context, resp *http.Response) {
+	if t.state == nil || resp == nil {
+		return
+	}
+	sink := cookieSinkFrom(ctx)
+	if sink == nil {
+		sink = &cookieSink{}
+	}
+	if resp.Request != nil {
+		sink.add(resp.Request.URL, resp)
+	}
+	sink.apply(t.state)
 }
 
 // ─── 服务层入口 ────────────────────────────────────────────────────────────
 
 // awaitBrowser 登记待办并阻塞等待用户回传页面内容。
-func (s *ReaderService) awaitBrowser(ctx context.Context, sourceURL, sourceID, userID string, req rule.BrowserTask) (rule.BrowserResult, error) {
-	entry, err := s.registerBrowser(ctx, sourceURL, sourceID, userID, req, browserModeWait)
+func (s *ReaderService) awaitBrowser(ctx context.Context, sourceURL, sourceID, userID string, cookies browserCookieTarget, req rule.BrowserTask) (rule.BrowserResult, error) {
+	entry, err := s.registerBrowser(ctx, sourceURL, sourceID, userID, cookies, req, browserModeWait)
 	if err != nil {
 		return rule.BrowserResult{}, err
 	}
@@ -151,16 +190,16 @@ func (s *ReaderService) awaitBrowser(ctx context.Context, sourceURL, sourceID, u
 }
 
 // openBrowser 登记待办但不等待（页面展示给用户即可）。
-func (s *ReaderService) openBrowser(ctx context.Context, sourceURL, sourceID, userID string, req rule.BrowserTask) error {
-	_, err := s.registerBrowser(ctx, sourceURL, sourceID, userID, req, browserModeOpen)
+func (s *ReaderService) openBrowser(ctx context.Context, sourceURL, sourceID, userID string, cookies browserCookieTarget, req rule.BrowserTask) error {
+	_, err := s.registerBrowser(ctx, sourceURL, sourceID, userID, cookies, req, browserModeOpen)
 	return err
 }
 
 // registerBrowser 准备页面内容并登记待办。
-func (s *ReaderService) registerBrowser(ctx context.Context, sourceURL, sourceID, userID string, req rule.BrowserTask, mode string) (*pendingBrowser, error) {
+func (s *ReaderService) registerBrowser(ctx context.Context, sourceURL, sourceID, userID string, cookies browserCookieTarget, req rule.BrowserTask, mode string) (*pendingBrowser, error) {
 	// 先分配 ID：页面里的资源代理地址需要用它签名。
 	id := newBrowserID()
-	html, finalURL, err := s.prepareBrowserPage(ctx, sourceURL, id, req)
+	html, finalURL, err := s.prepareBrowserPage(ctx, sourceURL, id, cookies, req)
 	if err != nil {
 		return nil, err
 	}
@@ -173,6 +212,7 @@ func (s *ReaderService) registerBrowser(ctx context.Context, sourceURL, sourceID
 		sourceURL: sourceURL,
 		userID:    userID,
 		request:   req,
+		cookies:   cookies,
 		html:      html,
 		finalURL:  finalURL,
 		mode:      mode,
@@ -319,7 +359,7 @@ func jsStringEscape(s string) string {
 //     退化成书源站点地址——书源自己的 BaseUrl() 也指向它）；
 //   - Cookie：页面常用 document.cookie 判断登录态，而真实 Cookie 在服务端，
 //     不预置的话「用户后台」会以为未登录并把浏览器导到 /login。
-func (s *ReaderService) prepareBrowserPage(ctx context.Context, sourceURL, id string, req rule.BrowserTask) (string, string, error) {
+func (s *ReaderService) prepareBrowserPage(ctx context.Context, sourceURL, id string, cookies browserCookieTarget, req rule.BrowserTask) (string, string, error) {
 	// 1) 书源自带 HTML（显式 html 参数或 data: URL）
 	if html := strings.TrimSpace(req.HTML); html != "" {
 		return injectBrowserBridge(html, sourceURL, s.browserCookieHeader(ctx, sourceURL, sourceURL)), req.URL, nil
@@ -331,7 +371,7 @@ func (s *ReaderService) prepareBrowserPage(ctx context.Context, sourceURL, id st
 	if !strings.HasPrefix(req.URL, "http://") && !strings.HasPrefix(req.URL, "https://") {
 		return "", "", fmt.Errorf("无法承载该地址: %s", truncateForLog(req.URL, 120))
 	}
-	body, finalURL, contentType, err := s.fetchBrowserPage(ctx, sourceURL, req.URL)
+	body, finalURL, contentType, err := s.fetchBrowserPage(ctx, sourceURL, cookies, req.URL)
 	if err != nil {
 		return "", "", fmt.Errorf("打开页面失败: %w", err)
 	}
@@ -355,8 +395,8 @@ func (s *ReaderService) browserCookieHeader(ctx context.Context, sourceURL, targ
 }
 
 // fetchBrowserPage 服务端抓取页面（附带书源 Cookie / 登录请求头 / 书源请求头）。
-func (s *ReaderService) fetchBrowserPage(ctx context.Context, sourceURL, target string) (string, string, string, error) {
-	contentType, _, data, finalURL, err := s.requestBrowserResource(ctx, sourceURL, target)
+func (s *ReaderService) fetchBrowserPage(ctx context.Context, sourceURL string, cookies browserCookieTarget, target string) (string, string, string, error) {
+	contentType, _, data, finalURL, err := s.requestBrowserResource(ctx, sourceURL, cookies, target)
 	if err != nil {
 		return "", "", "", err
 	}
@@ -364,16 +404,25 @@ func (s *ReaderService) fetchBrowserPage(ctx context.Context, sourceURL, target
 }
 
 // FetchBrowserAsset 代理拉取页面资源（带书源 Cookie/请求头），供 iframe 内引用。
-// 返回 (contentType, status, body, error)。
-func (s *ReaderService) FetchBrowserAsset(ctx context.Context, sourceURL, target string) (string, int, []byte, error) {
-	contentType, status, data, _, err := s.requestBrowserResource(ctx, sourceURL, target)
+// 返回 (contentType, status, body, error)。按待办 ID 找会话，顺带把响应
+// Set-Cookie 写回（页面可能靠资源响应续期会话）。
+func (s *ReaderService) FetchBrowserAsset(ctx context.Context, id, target string) (string, int, []byte, error) {
+	entry := s.lookupBrowser(id)
+	if entry == nil {
+		return "", 0, nil, errors.New("页面已过期，请重新打开")
+	}
+	contentType, status, data, _, err := s.requestBrowserResource(ctx, entry.sourceURL, entry.cookies, target)
 	return contentType, status, data, err
 }
 
 // requestBrowserResource 带书源凭据请求一个外部地址。
-func (s *ReaderService) requestBrowserResource(ctx context.Context, sourceURL, target string) (string, int, []byte, string, error) {
+func (s *ReaderService) requestBrowserResource(ctx context.Context, sourceURL string, cookies browserCookieTarget, target string) (string, int, []byte, string, error) {
 	reqCtx, cancel := context.WithTimeout(ctx, browserFetchTimeout)
 	defer cancel()
+	// 挂上 sink，让重定向各跳的 Set-Cookie 也能被收集。
+	if cookies.state != nil {
+		reqCtx = withCookieSink(reqCtx, &cookieSink{})
+	}
 
 	state := s.newSourceState(reqCtx, sourceURL)
 	httpReq, err := http.NewRequestWithContext(reqCtx, http.MethodGet, target, nil)
@@ -419,6 +468,8 @@ func (s *ReaderService) requestBrowserResource(ctx context.Context, sourceURL, t
 	if resp.Request != nil && resp.Request.URL != nil {
 		finalURL = resp.Request.URL.String()
 	}
+	// 页面/资源响应下发的 Set-Cookie 也写回会话（含跳转各跳）。
+	cookies.captureFrom(reqCtx, resp)
 	contentType := resp.Header.Get("Content-Type")
 	if contentType == "" {
 		contentType = "application/octet-stream"
@@ -456,6 +507,11 @@ func (s *ReaderService) ProxyBrowserXHR(ctx context.Context, id, method, target
 	}
 	reqCtx, cancel := context.WithTimeout(ctx, browserFetchTimeout)
 	defer cancel()
+	// 挂上 sink：页面自己发起的请求（如扫码登录的轮询/取票跳转）下发的
+	// Set-Cookie 要能落到书源会话里，否则「面板里登录成功」书源却始终未登录。
+	if entry.cookies.state != nil {
+		reqCtx = withCookieSink(reqCtx, &cookieSink{})
+	}
 
 	httpReq, err := http.NewRequestWithContext(reqCtx, strings.ToUpper(method), target, strings.NewReader(body))
 	if err != nil {
@@ -506,6 +562,8 @@ func (s *ReaderService) ProxyBrowserXHR(ctx context.Context, id, method, target
 		return nil, err
 	}
 	data = helper.DecompressBody(resp, data)
+	// 页面请求同样把 Set-Cookie 写回书源会话（含跳转各跳）。
+	entry.cookies.captureFrom(reqCtx, resp)
 	contentType := resp.Header.Get("Content-Type")
 	if contentType == "" {
 		contentType = "text/plain"

internal/service/reader/browser_panel_test.go

@@ -201,7 +201,7 @@ func TestBrowserPanelInjectsSourceCookies(t *testing.T) {
 	st.flush()
 
 	// 直接驱动服务层：等价于书源调用 startBrowser 打开用户后台
-	if err := svc.openBrowser(ctx, srv.URL, sourceID, readerTestUserID, rule.BrowserTask{
+	if err := svc.openBrowser(ctx, srv.URL, sourceID, readerTestUserID, browserCookieTarget{}, rule.BrowserTask{
 		URL: srv.URL + "/user", Title: "用户后台",
 	}); err != nil {
 		t.Fatalf("打开用户后台失败: %v", err)
@@ -266,7 +266,7 @@ func TestBrowserPanelInjectsSourceCookies(t *testing.T) {
 	if gotSourceURL != srv.URL {
 		t.Fatalf("资源关联的书源 = %q", gotSourceURL)
 	}
-	contentType, status, data, err := svc.FetchBrowserAsset(ctx, gotSourceURL, target)
+	contentType, status, data, err := svc.FetchBrowserAsset(ctx, page.ID, target)
 	if err != nil {
 		t.Fatalf("拉取资源失败: %v", err)
 	}
@@ -313,7 +313,7 @@ func TestBrowserPanelXHRProxy(t *testing.T) {
 	st.SetCookie(srv.URL, "qttoken=SESSION_abcdef123456")
 	st.flush()
 
-	if err := svc.openBrowser(ctx, srv.URL, sourceID, readerTestUserID, rule.BrowserTask{
+	if err := svc.openBrowser(ctx, srv.URL, sourceID, readerTestUserID, browserCookieTarget{}, rule.BrowserTask{
 		URL: srv.URL + "/user", Title: "用户后台",
 	}); err != nil {
 		t.Fatalf("打开用户后台失败: %v", err)
@@ -403,7 +403,7 @@ func TestBrowserPanelOpenPageDroppedAfterResolve(t *testing.T) {
 	sourceID := prepareLoginSource(t, svc, browserPanelSourceJSON(t, "https://panel.example.com"))
 
 	// 等价于书源的 renderVersionPage()：java.startBrowser(data:..., '光遇书源更新')
-	if err := svc.openBrowser(ctx, "https://panel.example.com", sourceID, readerTestUserID,
+	if err := svc.openBrowser(ctx, "https://panel.example.com", sourceID, readerTestUserID, browserCookieTarget{},
 		rule.BrowserTask{URL: "data:text/html,<html><body>更新</body></html>", Title: "光遇书源更新"}); err != nil {
 		t.Fatalf("登记 open 页面失败: %v", err)
 	}
@@ -421,7 +421,7 @@ func TestBrowserPanelOpenPageDroppedAfterResolve(t *testing.T) {
 	}
 
 	// 再点别的按钮：待办表里只应剩新页面，且序号更大
-	if err := svc.openBrowser(ctx, "https://panel.example.com", sourceID, readerTestUserID,
+	if err := svc.openBrowser(ctx, "https://panel.example.com", sourceID, readerTestUserID, browserCookieTarget{},
 		rule.BrowserTask{URL: "data:text/html,<html><body>设置</body></html>", Title: "光遇书源设置"}); err != nil {
 		t.Fatalf("登记新页面失败: %v", err)
 	}

internal/service/reader/comment.go

@@ -451,6 +451,8 @@ func (s *ReaderService) OpenContentComment(ctx context.Context, userID, bookID,
 		title = "段评"
 	}
 	entry, err := s.registerBrowser(ctx, book.Origin, sourceID, userID,
+		// 段评是「只展示」的页面，没有登录会话可回写 Cookie。
+		browserCookieTarget{},
 		rule.BrowserTask{URL: target, Title: title}, browserModeOpen)
 	if err != nil {
 		return nil, err

internal/service/reader/cookie_capture_test.go

@@ -0,0 +1,181 @@
+package reader
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"sync"
+	"testing"
+
+	"github.com/truewhile/MeBox/internal/service/reader/rule"
+)
+
+// 本文件：响应 Set-Cookie 回写会话的回归测试（cookies.go）。
+//
+// 背景：扫码登录类书源把凭证放在**跳转链中间那一跳**的 Set-Cookie 里
+// （B站 的 crossDomain 票据地址就是如此），并且签到站点会声明业务域的
+// Domain（Domain=.bilibili.com）。之前的实现只看最终响应、按请求地址归档，
+// 于是凭证永远进不了会话，表现为「面板显示已授权，书源却始终未登录」。
+
+// cookieCaptureServer 构造跳转链：/redeem 下发声明了 Domain 的凭证并 302，
+// /done 只回 200。这样「中间那一跳的 Set-Cookie」与「最终响应的 Set-Cookie」
+// 能被分开断言。
+func cookieCaptureServer(t *testing.T) *httptest.Server {
+	t.Helper()
+	mux := http.NewServeMux()
+	mux.HandleFunc("/redeem", func(w http.ResponseWriter, r *http.Request) {
+		http.SetCookie(w, &http.Cookie{
+			Name: "SESSDATA", Value: "cred-abc", Domain: ".example.com", Path: "/",
+		})
+		http.Redirect(w, r, "/done", http.StatusFound)
+	})
+	mux.HandleFunc("/done", func(w http.ResponseWriter, r *http.Request) {
+		http.SetCookie(w, &http.Cookie{Name: "biz", Value: "1", Path: "/"})
+		_, _ = w.Write([]byte(`{"ok":true}`))
+	})
+	mux.HandleFunc("/plain", func(w http.ResponseWriter, r *http.Request) {
+		_, _ = w.Write([]byte(`<html><body>面板</body></html>`))
+	})
+	srv := httptest.NewServer(mux)
+	t.Cleanup(srv.Close)
+	return srv
+}
+
+// TestExecuteCapturesRedirectHopCookies 主链路：跳转中间那一跳的 Set-Cookie
+// 必须被收下，且按 Cookie 自己的 Domain 归档（而不是按请求地址）。
+func TestExecuteCapturesRedirectHopCookies(t *testing.T) {
+	srv := cookieCaptureServer(t)
+	svc, _ := newLoginTestService(t)
+	ctx := t.Context()
+	state := svc.newSourceState(ctx, srv.URL)
+
+	req := &rule.Request{Method: "GET", URL: srv.URL + "/redeem", Headers: map[string]string{}}
+	if _, _, _, err := svc.executeWithState(ctx, req, state, true); err != nil {
+		t.Fatalf("请求失败: %v", err)
+	}
+
+	// 凭证声明的是 .example.com，就应该落在 example.com 这个域桶里。
+	if got := state.GetCookie("https://example.com/"); !strings.Contains(got, "SESSDATA=cred-abc") {
+		t.Fatalf("跳转中间那一跳的凭证没有按 Domain 归档: %q", got)
+	}
+	// 最终响应的 Cookie 按该跳地址归档。
+	if got := state.GetCookie(srv.URL); !strings.Contains(got, "biz=1") {
+		t.Fatalf("最终响应的 Cookie 没有被收下: %q", got)
+	}
+}
+
+// TestExecuteSkipsCookieCaptureWhenJarDisabled enabledCookieJar=false 时
+// 主链路不应自动累积 Cookie。
+func TestExecuteSkipsCookieCaptureWhenJarDisabled(t *testing.T) {
+	srv := cookieCaptureServer(t)
+	svc, _ := newLoginTestService(t)
+	ctx := t.Context()
+	state := svc.newSourceState(ctx, srv.URL)
+
+	req := &rule.Request{Method: "GET", URL: srv.URL + "/redeem", Headers: map[string]string{}}
+	if _, _, _, err := svc.executeWithState(ctx, req, state, false); err != nil {
+		t.Fatalf("请求失败: %v", err)
+	}
+	if got := state.GetCookie("https://example.com/"); got != "" {
+		t.Fatalf("关掉 CookieJar 后不应自动累积: %q", got)
+	}
+	if got := state.GetCookie(srv.URL); got != "" {
+		t.Fatalf("关掉 CookieJar 后不应自动累积: %q", got)
+	}
+}
+
+// TestProxyBrowserXHRCapturesCookies 面板链路：页面自己发起的请求（经
+// ProxyBrowserXHR 转发）拿到的 Set-Cookie 也要写回书源会话并能落库。
+// 这正是「页面里登录成功、书源却始终未登录」的那个缺口。
+func TestProxyBrowserXHRCapturesCookies(t *testing.T) {
+	srv := cookieCaptureServer(t)
+	svc, _ := newLoginTestService(t)
+	ctx := t.Context()
+	const sourceURL = "https://api.example.com"
+	const sourceID = "panel-source-1"
+	state := svc.newSourceState(ctx, sourceURL)
+
+	// 承载页面本身不下发凭证（/plain），确保断言只针对代理请求。
+	if err := svc.openBrowser(ctx, sourceURL, sourceID, readerTestUserID,
+		browserCookieTarget{state: state},
+		rule.BrowserTask{URL: srv.URL + "/plain", Title: "面板"}); err != nil {
+		t.Fatalf("登记页面失败: %v", err)
+	}
+	pages := svc.PendingBrowserPages(readerTestUserID, sourceID)
+	if len(pages) != 1 {
+		t.Fatalf("应登记 1 个待办页面，实际 %d", len(pages))
+	}
+
+	// 页面请求票据地址：302 时下发凭证，最终响应只带回 JSON。
+	if _, err := svc.ProxyBrowserXHR(ctx, pages[0].ID, http.MethodGet, srv.URL+"/redeem", nil, ""); err != nil {
+		t.Fatalf("代理请求失败: %v", err)
+	}
+	if got := state.GetCookie("https://example.com/"); !strings.Contains(got, "SESSDATA=cred-abc") {
+		t.Fatalf("面板请求的凭证没有写回会话: %q", got)
+	}
+
+	// 登录态必须能持久化：重新读一条会话也应看到这份 Cookie。
+	state.flush()
+	reloaded := svc.newSourceState(ctx, sourceURL)
+	if got := reloaded.GetCookie("https://example.com/"); !strings.Contains(got, "SESSDATA=cred-abc") {
+		t.Fatalf("面板拿到的凭证没有落库: %q", got)
+	}
+}
+
+// TestProxyBrowserXHRWithoutSessionSkipsCapture 没有会话可回写时（如段评面板）
+// 代理请求照常工作，只是不做 Cookie 累积。
+func TestProxyBrowserXHRWithoutSessionSkipsCapture(t *testing.T) {
+	srv := cookieCaptureServer(t)
+	svc, _ := newLoginTestService(t)
+	ctx := t.Context()
+	const sourceID = "panel-source-2"
+
+	if err := svc.openBrowser(ctx, srv.URL, sourceID, readerTestUserID,
+		browserCookieTarget{},
+		rule.BrowserTask{URL: srv.URL + "/plain", Title: "面板"}); err != nil {
+		t.Fatalf("登记页面失败: %v", err)
+	}
+	pages := svc.PendingBrowserPages(readerTestUserID, sourceID)
+	if len(pages) != 1 {
+		t.Fatalf("应登记 1 个待办页面，实际 %d", len(pages))
+	}
+	res, err := svc.ProxyBrowserXHR(ctx, pages[0].ID, http.MethodGet, srv.URL+"/done", nil, "")
+	if err != nil {
+		t.Fatalf("代理请求应照常成功: %v", err)
+	}
+	if res.Status != http.StatusOK {
+		t.Fatalf("代理状态 = %d", res.Status)
+	}
+}
+
+// TestBrowserHostCookieTargetRespectsJarFlag 面板链路同样受 enabledCookieJar 控制。
+func TestBrowserHostCookieTargetRespectsJarFlag(t *testing.T) {
+	st := &sourceState{cookies: map[string]string{}}
+	if got := (&browserHost{state: st, capture: false}).cookieTarget(); got.state != nil {
+		t.Fatal("enabledCookieJar=false 时不应把会话交给面板回写 Cookie")
+	}
+	if got := (&browserHost{state: st, capture: true}).cookieTarget(); got.state != st {
+		t.Fatal("开启时应把会话交给面板回写 Cookie")
+	}
+}
+
+// TestSourceStateCookieConcurrency 面板里的资源/接口代理是并发回写 Cookie 的，
+// 必须与书源 JS 的读取安全共存（-race 下能抓到缺锁）。
+func TestSourceStateCookieConcurrency(t *testing.T) {
+	st := &sourceState{cookies: map[string]string{}}
+	var wg sync.WaitGroup
+	for i := 0; i < 16; i++ {
+		wg.Add(1)
+		go func(n int) {
+			defer wg.Done()
+			url := "https://example.com/"
+			st.SetCookie(url, "k=1")
+			_ = st.GetCookie(url)
+			_ = st.snapshotCookies()
+		}(i)
+	}
+	wg.Wait()
+	if got := st.GetCookie("https://example.com/"); !strings.Contains(got, "k=1") {
+		t.Fatalf("并发写入后应能读到 Cookie: %q", got)
+	}
+}

internal/service/reader/cookies.go

@@ -0,0 +1,148 @@
+package reader
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"net/url"
+	"strings"
+	"sync"
+)
+
+// 本文件：把响应下发的 Set-Cookie 收进书源会话。
+//
+// 之前只有 executeWithState 收 Set-Cookie，而且只看**最终**响应、按请求地址归档。
+// 对「靠跳转链下发凭证」的登录源（典型是扫码登录：票据地址一跳 302 带
+// Set-Cookie，再跳到业务域名）这三个做法都会漏：
+//
+//  1. 凭证在中间某一跳的 Set-Cookie 里，只看最终响应拿不到；
+//  2. 签发站点（如 passport.biligame.com）声明的 Domain 可能是业务域
+//     （Domain=.bilibili.com），按请求地址归档会存进错误的域桶，
+//     之后 api.bilibili.com 的请求取不到这份 Cookie；
+//  3. 浏览器面板里的页面自己发起的请求走 ProxyBrowserXHR，完全不落库，
+//     页面在面板里「登录成功」但书源会话始终是空的。
+//
+// 因此统一成：一个 cookieSink 收集一次请求（含各跳）的 Set-Cookie，
+// 再按「Cookie 自身的 Domain 优先、否则该跳请求地址」写入会话。
+
+// capturedCookie 一条待写入会话的 Cookie 及其归属地址。
+type capturedCookie struct {
+	// url 归属地址：Cookie 声明了 Domain 时用 Domain（去掉前导点），
+	// 否则用下发它的那一跳的请求地址。
+	url    string
+	cookie string
+}
+
+// cookieSink 收集一次请求（含重定向各跳）下发的 Set-Cookie。
+// 并发安全：面板里的多个资源/接口请求会同时走这里。
+type cookieSink struct {
+	mu    sync.Mutex
+	items []capturedCookie
+}
+
+// add 收集一份响应里的 Set-Cookie。reqURL 是产生该响应（或跳转前那一跳）的地址。
+func (s *cookieSink) add(reqURL *url.URL, resp *http.Response) {
+	if s == nil || resp == nil {
+		return
+	}
+	items := make([]capturedCookie, 0, len(resp.Cookies()))
+	for _, ck := range resp.Cookies() {
+		if ck == nil || ck.Name == "" {
+			continue
+		}
+		target := ""
+		if d := strings.TrimSpace(ck.Domain); d != "" {
+			target = strings.TrimPrefix(d, ".")
+		} else if reqURL != nil {
+			target = reqURL.String()
+		}
+		if target == "" {
+			continue
+		}
+		items = append(items, capturedCookie{url: target, cookie: ck.Name + "=" + ck.Value})
+	}
+	if len(items) == 0 {
+		return
+	}
+	s.mu.Lock()
+	s.items = append(s.items, items...)
+	s.mu.Unlock()
+}
+
+// drain 取出并清空已收集的 Cookie。
+func (s *cookieSink) drain() []capturedCookie {
+	if s == nil {
+		return nil
+	}
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	out := s.items
+	s.items = nil
+	return out
+}
+
+// apply 把收集到的 Cookie 写入会话并清空（会话为 nil 时直接丢弃）。
+func (s *cookieSink) apply(state *sourceState) {
+	if s == nil {
+		return
+	}
+	items := s.drain()
+	if state == nil || len(items) == 0 {
+		return
+	}
+	for _, it := range items {
+		state.SetCookie(it.url, it.cookie)
+	}
+}
+
+// ─── 请求级挂载：sink 放进 context，由 CheckRedirect 逐跳收集 ──────────────
+
+type cookieSinkKey struct{}
+
+// withCookieSink 在请求 context 上挂一个 sink；sink 为 nil 时原样返回。
+func withCookieSink(ctx context.Context, sink *cookieSink) context.Context {
+	if sink == nil {
+		return ctx
+	}
+	return context.WithValue(ctx, cookieSinkKey{}, sink)
+}
+
+// cookieSinkFrom 取出请求 context 上的 sink（没有则 nil）。
+func cookieSinkFrom(ctx context.Context) *cookieSink {
+	if ctx == nil {
+		return nil
+	}
+	sink, _ := ctx.Value(cookieSinkKey{}).(*cookieSink)
+	return sink
+}
+
+// captureRedirectCookies 作为 http.Client.CheckRedirect：
+// 每发生一次跳转，就把「上一跳响应」里的 Set-Cookie 收进 context 上的 sink。
+//
+// 没有挂 sink 时是纯透传；跳转次数上限与 net/http 的默认实现保持一致
+// （10 次），所以装上它不改变既有链路的行为。
+func captureRedirectCookies(req *http.Request, via []*http.Request) error {
+	if req != nil {
+		if sink := cookieSinkFrom(req.Context()); sink != nil && req.Response != nil {
+			// via 的最后一跳才是产生 req.Response 的那个请求。
+			prev := req
+			if n := len(via); n > 0 {
+				prev = via[n-1]
+			}
+			sink.add(prev.URL, req.Response)
+		}
+	}
+	if len(via) >= 10 {
+		return errors.New("stopped after 10 redirects")
+	}
+	return nil
+}
+
+// enableCookieCapture 给 reader 的 HTTP 客户端装上「逐跳收集 Set-Cookie」。
+// NewReaderService 调用一次即可：没有挂 sink 的请求完全不受影响。
+func enableCookieCapture(c *http.Client) {
+	if c == nil {
+		return
+	}
+	c.CheckRedirect = captureRedirectCookies
+}

internal/service/reader/reader.go

@@ -63,11 +63,14 @@ type ReaderService struct {
 
 // NewReaderService 创建服务。
 func NewReaderService(cfg *config.Config, log *zap.Logger, repos *repository.Container) *ReaderService {
+	client := helper.NewSiteHTTPClient(30, true)
+	// 逐跳收集 Set-Cookie：登录源常把凭证放在跳转链中间那一跳（见 cookies.go）。
+	enableCookieCapture(client)
 	return &ReaderService{
 		cfg:     cfg,
 		log:     log,
 		repo:    repos.Reader,
-		http:    helper.NewSiteHTTPClient(30, true),
+		http:    client,
 		crypto:  helper.NewSecretCipher(firstNonEmpty(cfg.Secrets.EncryptionKey, cfg.Secrets.JWTSecret)),
 		limiter: newSourceRateLimiter(),
 	}
@@ -319,12 +322,13 @@ func (s *ReaderService) executeWithState(ctx context.Context, req *rule.Request,
 		}
 	}
 	// 请求构造抽成闭包：重试时必须重建请求（body 读取器只能消费一次）。
-	buildRequest := func() (*http.Request, error) {
+	// reqCtx 每次尝试单独传入，好让 Set-Cookie 只从「最终那次尝试」收集。
+	buildRequest := func(reqCtx context.Context) (*http.Request, error) {
 		var bodyReader io.Reader
 		if req.Body != "" {
 			bodyReader = strings.NewReader(req.Body)
 		}
-		httpReq, err := http.NewRequestWithContext(ctx, req.Method, target, bodyReader)
+		httpReq, err := http.NewRequestWithContext(reqCtx, req.Method, target, bodyReader)
 		if err != nil {
 			return nil, err
 		}
@@ -361,9 +365,18 @@ func (s *ReaderService) executeWithState(ctx context.Context, req *rule.Request,
 	var (
 		resp *http.Response
 		data []byte
+		// sink 收集这次请求（含重定向各跳）下发的 Set-Cookie，
+		// 只在需要回写会话且书源允许自动累积时才挂。
+		sink *cookieSink
 	)
 	for attempt := 1; ; attempt++ {
-		httpReq, err := buildRequest()
+		sink = nil
+		reqCtx := ctx
+		if state != nil && captureCookies {
+			sink = &cookieSink{}
+			reqCtx = withCookieSink(ctx, sink)
+		}
+		httpReq, err := buildRequest(reqCtx)
 		if err != nil {
 			return "", "", 0, err
 		}
@@ -405,15 +418,12 @@ func (s *ReaderService) executeWithState(ctx context.Context, req *rule.Request,
 		body = string(data)
 	}
 	finalURL := resp.Request.URL.String()
-	// 记录 Set-Cookie（书源 JS 的 cookie.getCookie 可读取）
-	var cookieStrs []string
-	for _, ck := range resp.Cookies() {
-		cookieStrs = append(cookieStrs, ck.Name+"="+ck.Value)
-	}
-	if len(cookieStrs) > 0 && state != nil && captureCookies {
-		for _, ck := range cookieStrs {
-			state.SetCookie(finalURL, ck)
-		}
+	// 记录 Set-Cookie（书源 JS 的 cookie.getCookie 可读取）。
+	// sink 里已含重定向各跳的 Cookie，这里再把最终响应补进去，
+	// 归属域按 Cookie 自己的 Domain 优先、否则按该跳地址（见 cookies.go）。
+	if sink != nil {
+		sink.add(resp.Request.URL, resp)
+		sink.apply(state)
 	}
 	// bodyJs 二次处理
 	if req.BodyJsFn != nil {
@@ -606,6 +616,11 @@ func (sess *sourceSession) runner(key string, page int) *rule.JSRunner {
 			sourceURL: sess.srcURL(),
 			sourceID:  sess.srcID(),
 			userID:    sess.userID,
+			// state 交出去，让面板里页面自己发起的请求也能把 Set-Cookie
+			// 写回这次会话（见 browser_panel.go / cookies.go）。
+			state: sess.state,
+			// capture 对应 enabledCookieJar：关掉时面板同样不自动累积 Cookie。
+			capture: sess.captureCookies(),
 		}
 	}
 	return rule.NewJSRunner(rule.JSConfig{

internal/service/reader/state.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"strings"
+	"sync"
 
 	"github.com/truewhile/MeBox/internal/model"
 	"github.com/truewhile/MeBox/internal/service/reader/rule"
@@ -23,8 +24,12 @@ type sourceState struct {
 	variable    string
 	loginInfo   string
 	loginHeader string
-	cookies     map[string]string // domain → "k=v; k=v"
-	loaded      bool
+	// cookies / cookieMu：domain → "k=v; k=v"。
+	// cookieMu 保护这张表：浏览器面板里的多个资源/接口代理请求会并发回写
+	// Cookie（见 browser_panel.go），而书源 JS 同时在读，不加锁会 data race。
+	cookies  map[string]string
+	cookieMu sync.Mutex
+	loaded   bool
 
 	toasts   []string
 	browsers []rule.BrowserRequest
@@ -119,6 +124,13 @@ func (st *sourceState) SetLoginHeader(v string) {
 func (st *sourceState) GetCookie(rawURL string) string { return st.GetCookieKey(rawURL, "") }
 
 func (st *sourceState) GetCookieKey(rawURL, key string) string {
+	st.cookieMu.Lock()
+	defer st.cookieMu.Unlock()
+	return st.getCookieKeyLocked(rawURL, key)
+}
+
+// getCookieKeyLocked 的调用方需持有 cookieMu。
+func (st *sourceState) getCookieKeyLocked(rawURL, key string) string {
 	domain := rule.CookieDomain(rawURL)
 	if domain == "" {
 		return ""
@@ -138,6 +150,8 @@ func (st *sourceState) SetCookie(rawURL, cookie string) {
 	if domain == "" || strings.TrimSpace(cookie) == "" {
 		return
 	}
+	st.cookieMu.Lock()
+	defer st.cookieMu.Unlock()
 	merged := rule.MergeCookie(st.cookies[domain], cookie)
 	if merged == st.cookies[domain] {
 		return
@@ -151,6 +165,8 @@ func (st *sourceState) RemoveCookie(rawURL string) {
 	if domain == "" {
 		return
 	}
+	st.cookieMu.Lock()
+	defer st.cookieMu.Unlock()
 	if _, ok := st.cookies[domain]; !ok {
 		return
 	}
@@ -197,12 +213,14 @@ func (st *sourceState) flush() {
 	if !st.dirty || st.svc == nil || st.svc.repo == nil || st.sourceURL == "" {
 		return
 	}
+	st.cookieMu.Lock()
 	cookiesJSON := ""
 	if len(st.cookies) > 0 {
 		if b, err := json.Marshal(st.cookies); err == nil {
 			cookiesJSON = string(b)
 		}
 	}
+	st.cookieMu.Unlock()
 	rec := &model.ReaderSourceState{
 		SourceURL:   st.sourceURL,
 		Variable:    st.variable,
@@ -221,6 +239,8 @@ func (st *sourceState) flush() {
 
 // snapshotCookies 返回 Cookie 副本（domain → cookie 串）。
 func (st *sourceState) snapshotCookies() map[string]string {
+	st.cookieMu.Lock()
+	defer st.cookieMu.Unlock()
 	out := make(map[string]string, len(st.cookies))
 	for d, c := range st.cookies {
 		out[d] = c
@@ -230,6 +250,8 @@ func (st *sourceState) snapshotCookies() map[string]string {
 
 // clearCookies 清空全部 Cookie 并标记待落库（对应 legado removeAllCookies）。
 func (st *sourceState) clearCookies() {
+	st.cookieMu.Lock()
+	defer st.cookieMu.Unlock()
 	if len(st.cookies) == 0 {
 		return
 	}