fix(auth): token 刷新改为无密码会话探针，密码登录仅作兜底

DeepSeek 的 token 是按设备绑定的长期会话凭证，不存在 access/refresh
两段式机制，也没有可换新的端点；原来的「刷新」实际是每 6h（以及每次
鉴权类失败）提交一次明文密码并过一次数美风控。

- 新增 Client.RefreshSessionToken：GET /api/v0/users/current 回填会话 token
- Resolver 刷新链改为探针优先，只有服务端明确拒绝会话才回退密码登录；
探针无法判定时，定时路径保留现有 token，失败恢复路径仍兜底登录
- 失效判定收窄到 401/403 与 code/biz_code 40001-40003（实测失效响应是
HTTP 200 + code=40003，只按状态码会漏判）
- 未注入探针时保持历史行为，测试与自定义装配不受影响
- 文档：research 文档补落地细节与线上实测，security 报告与 API.md 同步配置语义

API.en.md

@@ -766,6 +766,7 @@ Reads runtime settings and status, including:
 - `success`
 - `admin` (`has_password_hash`, `jwt_expire_hours`, `jwt_valid_after_unix`, `default_password_warning`)
 - `runtime` (`account_max_inflight`, `account_max_queue`, `global_max_inflight`, `token_refresh_interval_hours`)
+- `runtime.token_refresh_interval_hours` is a session health-check interval: on expiry the gateway performs a password-free check (`GET /api/v0/users/current`) and only falls back to a password login when the server explicitly rejects the session
 - `config_snapshot`: raw config values (`admin` / `runtime` / `responses` / `embeddings` / `auto_delete` / `current_input_file` / `thinking_injection` / `model_aliases`) before env overrides
 - `responses` / `embeddings`
 - `auto_delete` (`mode`: `none` / `single` / `all`; legacy `sessions=true` is still treated as `all`)

API.md

@@ -772,6 +772,7 @@ data: {"type":"message_stop"}
 - `success`
 - `admin`（`has_password_hash`、`jwt_expire_hours`、`jwt_valid_after_unix`、`default_password_warning`）
 - `runtime`（`account_max_inflight`、`account_max_queue`、`global_max_inflight`、`token_refresh_interval_hours`）
+- `runtime.token_refresh_interval_hours` 的语义是「会话体检间隔」：到期只做一次无密码复核（`GET /api/v0/users/current`），只有服务端明确拒绝会话时才回退到密码登录
 - `config_snapshot`：原始配置快照（`admin` / `runtime` / `responses` / `embeddings` / `auto_delete` / `current_input_file` / `thinking_injection` / `model_aliases`），用于区分环境变量覆盖前的配置
 - `responses` / `embeddings`
 - `auto_delete`（`mode`：`none` / `single` / `all`；旧配置 `sessions=true` 仍按 `all` 处理）

docs/token-refresh-research.md

@@ -4,16 +4,17 @@
 > DeepSeek 官方客户端是否存在真正的 token 刷新（refresh / rotate）通道。
 > 研究时间：2026-10-17
 > 证据来源：`chat.deepseek.com (1)/`（Web 端完整抓包）、根目录若干 `.har`、`deepseek.apk`（Android 2.2.2 / 2.3.3）
-> 状态：**调研结论已明确；未做任何线上实测**（见 §7）
+> 状态：**调研结论已明确**；阶段 1 已落地（§9），并有单账号线上实测（§9.5）
 
 ---
 
 ## 一、结论摘要（TL;DR）
 
-1. **现有实现的「刷新 token」确实是「重新登录」。** `Resolver.RefreshToken()`
+1. **改动前的「刷新 token」等于「重新登录」。** `Resolver.RefreshToken()`
    清空本地 token 后走 `loginAndPersist()` → `Client.Login()` →
    `POST /api/v0/users/login`，也就是**每次都把邮箱/手机号 + 明文密码重新提交一次**。
    定时刷新（默认 6h）也一样走这条路径。
+   （已改：现在是「无密码探针优先，明确失效才登录」，见 §9。）
 
 2. **DeepSeek 没有「access_token + refresh_token」那套机制。** 我们在
    - Web 端 JS bundle（`main.7d19d7e901.js`）
@@ -43,6 +44,9 @@
 
 ## 二、现状：刷新 == 重新登录（代码事实）
 
+> 本节记录的是**改动前**的代码事实（行号同当时版本）。
+> 改动后的实现见 §9：`RefreshToken()` 现在先走无密码探针，密码登录只是兜底。
+
 ### 2.1 调用链
 
 ```
@@ -91,6 +95,9 @@ Client.Login(ctx, acc)                              internal/deepseek/client/cli
 
 也就是说：**只要服务跑满 6 小时，每个托管账号就必然重新登录一次**，哪怕 token 完全没坏。
 
+> 已修复：本节描述的是调研时的实现。现在到期只做一次无密码探针复核，
+> 只有服务端明确拒绝会话才回退到密码登录，见 §9。
+
 ### 2.4 `MarkTokenInvalid` 也是清空
 
 `internal/auth/request.go:214` 把 token 清空落盘，下一次 `ensureManagedToken` 会再登录一次。
@@ -224,8 +231,8 @@ Android 端不是这样。APK 里有显式的模型类（`classes.dex` 字符串
 | 观察 | 结论 |
 |------|------|
 | 形如 `<44 字符随机段><20 字符随机段>`（含 `+` `/`，共 64 字符） | 64 字符 base64，**不是 JWT**（无 `.` 分段，无 `exp` 可解析） |
-| 同一账号 + 同一 `device_id` 反复登录 | **返回同一个 token** |
-| `users/current` 响应 | 回显**同一个 token** |
+| 同一账号 + 同一 `device_id` 反复登录 | **返回同一个 token** · ⚠️ 该行已被 §9.5 的线上实测推翻 |
+| `users/current` 响应 | 回显**同一个 token**（线上实测仍成立） |
 | 不同平台 / 不同 `device_id` | token 不同（`os=web` 与 `os=android` 互不相同） |
 
 所以 DeepSeek 是「**服务端长期会话 token，按设备绑定**」模型，
@@ -233,7 +240,7 @@ Android 端不是这样。APK 里有显式的模型类（`classes.dex` 字符串
 
 - 没有「token 快过期了所以必须刷新」这回事 → **定时 6h 强制重登在语义上没有必要**；
 - 真正需要处理的只有两类事件：
-  1. **token 被服务端吊销/轮换** → `users/current` 可能回填到新值，或直接 401；
+  1. **token 被服务端吊销/轮换** → `users/current` 可能回填到新值，或直接报鉴权失败；
   2. **会话彻底死了** → 才需要密码登录。
 
 ---
@@ -248,7 +255,7 @@ Android 端不是这样。APK 里有显式的模型类（`classes.dex` 字符串
 
 ### 5.2 分阶段实现
 
-**阶段 1（低风险，收益最大）：新增 `GET /api/v0/users/current` 回填**
+**阶段 1（低风险，收益最大）：新增 `GET /api/v0/users/current` 回填 —— ✅ 已实现（见 §9）**
 
 - 在 `dsprotocol` 增加 `DeepSeekCurrentUserURL = ".../api/v0/users/current"`。
 - `Client` 新增 `RefreshSessionToken(ctx, a) (string, error)`：
@@ -289,9 +296,9 @@ users/current 回填  →  check_device rotate  →  密码登录  →  切换
 
 ## 六、与现有文档的关系
 
-- `security_best_practices_report.md:171` 建议「定期刷新 token（已有
-  `TokenRefreshIntervalHours` 配置）」。本文确认该配置**当前语义是定期重新登录**，
-  修完阶段 1 之后才是真正的「刷新」。
+- `security_best_practices_report.md:171` 曾建议「定期刷新 token（已有
+  `TokenRefreshIntervalHours` 配置）」。本文确认该配置**旧语义是定期重新登录**；
+  该条目已随 §9 的改动同步为「定期做无密码探针复核」。
 - `docs/web-endpoint-upgrade.md` 记录的是登录协议的数美风控细节，与本文互补：
   那条链路越少走越好，正是本文的动机。
 
@@ -372,3 +379,84 @@ java -Xms64m -Xmx1100m -XX:MaxMetaspaceSize=320m -XX:ReservedCodeCacheSize=96m `
 > 全量反编译约需 1.5–2GB 堆 + 3GB 提交内存。内存不足时 jadx 会报
 > `Native memory allocation (mmap) failed`，此时要么加页面文件，要么只做 §8.2 的
 > 定点 DEX 解析（本次结论主要靠后者得到）。
+
+---
+
+## 九、实现落地（阶段 1���
+
+调研结论是「DeepSeek 没有可刷新的对象，只有失效后的恢复」。按这个结论落地后，
+「刷新 token」从「必发密码」变成「先免费探针、明确失效才登录」。
+
+### 9.1 改动清单
+
+| 文件 | 内容 |
+|------|------|
+| `internal/deepseek/protocol/constants.go` | 新增 `DeepSeekCurrentUserURL` |
+| `internal/deepseek/client/client_user_session.go` | 新增 `RefreshSessionToken()`：带现有 token GET `users/current`，取 `data.biz_data.token`（兼容 `biz_data.user.token`） |
+| `internal/auth/request.go` | 新增 `RefreshSessionFunc` 注入点与 `ErrSessionExpired`；`RefreshToken()` / `ensureManagedToken()` 改为「探针优先」 |
+| `internal/server/router.go` | 把 `Client.RefreshSessionToken` 注入 `Resolver.RefreshSession` |
+
+### 9.2 三种探针结果，三种处置
+
+判定刻意收窄，避免把限流、风控、临时故障误判成「必须重新登录」：
+
+| 探针结果 | 判定依据 | 定时路径（§2.3） | 失败恢复路径（§2.2） |
+|----------|----------|------------------|----------------------|
+| 会话有效，回显同一 token | `status=200`、`code=0`、`biz_code=0` 且有 token | 只更新体检时间戳，不写盘 | 直接返回成功，重试原请求 |
+| 服务端轮换了 token | 同上，但 token 与本地不同 | 落盘并采纳新 token | 落盘并采纳新 token |
+| 会话被明确拒绝 | `401`/`403` 或 `code`/`biz_code` ∈ {40001, 40002, 40003} | 清空 token → 密码登录 | 清空 token → 密码登录 |
+| 无法判定 | 网络错误、5xx、未知 biz_code、响应缺 token | **保留现有 token，不登录** | 保留 token，仍兜底密码登录（历史行为） |
+
+两个调用点策略不同的原因：
+
+- **定时路径**手里是一个还能用的 token，「一次网络抖动就提交密码」是净损失，
+  所以探测失败宁可什么都不做，等下一个请求用失败路径去处理。
+- **失败恢复路径**是请求已经吃到鉴权类错误、正在重试，宁可多登录一次也不能把
+  本来可恢复的请求判死；探针的作用是挡掉 `isTokenInvalid()` 的宽匹配误判
+  （消息里出现 `token` / `login` 就算鉴权失败）。
+
+### 9.3 行为变化
+
+| 场景 | 改动前 | 改动后 |
+|------|--------|--------|
+| 跑满 6h（默认间隔） | 每账号一次密码登录 + 数美风控 | 一次 `GET users/current`，通常不产生任何写盘 |
+| 请求被误判为鉴权失败 | 清空 token + 密码登录 | 探针确认有效即继续，不登录 |
+| token 真的被吊销 | 密码登录 | 探针 401 → 密码登录（同上，但只在真失效时发生） |
+| 探针未注入（测试/自定义装配） | — | 保持历史行为：直接密码登录 |
+
+### 9.4 本次没做的事
+
+- **阶段 2（`check_device` 的 rotate）**：抓包里始终 `null`，Android 侧证据链未闭合
+  （§7.1），收益不确定，暂不接入。
+- **阶段 3 的重试计数**：现有 `refreshed` 布尔量仍按「每个请求生命周期每级最多一次」
+  工作，未扩成枚举，等阶段 2 接入时再一并处理。
+- 保留 `token_refresh_interval_hours` 配置与默认 6h，语义变为「会话体检间隔」；
+  想彻底关掉可以设为 0（`shouldForceRefresh` 直接返回 false）。
+
+### 9.5 线上实测（2026-10-18，单账号单设备）
+
+用一个临时账号、固定 `device_id`、android 平台直接跑新代码，结果如下：
+
+| 检查项 | 实测结果 |
+|--------|----------|
+| `GET users/current` 回填 | 连续 3 次全部 `200`，返回的 token 与登录 token **完全一致** |
+| 探针耗时 | 约 150–165 ms（对比：一次密码登录要多走数美 + 登录两步） |
+| 用无效 token 打探针 | `HTTP 200` + `code=40003` + `msg="Authorization Failed (invalid token)"` |
+| 失效判定 | 被正确归类为「会话失效」而不是「无法判定」 |
+| 刷新链（有效 token） | `RefreshToken` 成功，密码登录次数 **0** |
+| 刷新链（失效 token） | 探针失败 → 清空 → 密码登录 **1** 次 → 恢复 |
+
+两个推论，都影响本文之前的判断：
+
+1. **鉴权失败不一定走 HTTP 401。** 实测是 `HTTP 200 + code=40003`。
+   所以「只按状态码判断」的探针会漏判，`sessionRejectedStatus()` 必须同时看
+   `code`/`biz_code`（这也解释了为什么不能直接复用宽匹配的 `isTokenInvalid()`：
+   那个函数还会把消息里带 `token` 字样的非鉴权错误一起算进来）。
+2. **§4.4 里「同一 device_id 反复登录返回同一个 token」这一行是错的。**
+   实测每次密码登录都会下发**新的** token，而**旧 token 继续有效**
+   （重新登录后再拿旧 token 打 `users/current` 仍 `200`）。
+   也就是说：每次重新登录都在账号上多留下一个仍然可用的长期会话凭证。
+   这比 §3 原先担心的「密码出网」更进一步——高频重登不仅暴露密码，
+   还在持续堆积可用的会话。
+
+

internal/auth/request.go

@@ -22,6 +22,14 @@ const authCtxKey ctxKey = "auth_context"
 var (
 	ErrUnauthorized = errors.New("unauthorized: missing auth token")
 	ErrNoAccount    = errors.New("no accounts configured or all accounts are busy")
+
+	// ErrSessionExpired 表示 DeepSeek 明确拒绝了这个会话 token（401/403 或鉴权类业务码）。
+	// 只有这种情况才值得清空本地 token 并回退到密码登录。
+	ErrSessionExpired = errors.New("deepseek session rejected")
+
+	// errSessionProbeUnavailable 表示当前没有可用的无密码探针：未注入探针函数，
+	// 或本地还没有 token 可以拿去做探测。
+	errSessionProbeUnavailable = errors.New("session probe unavailable")
 )
 
 type RequestAuth struct {
@@ -37,10 +45,18 @@ type RequestAuth struct {
 
 type LoginFunc func(ctx context.Context, acc config.Account) (string, error)
 
+// RefreshSessionFunc 是不需要密码的会话回填通道：带现有 token 请求
+// GET /api/v0/users/current，返回服务端认定的当前 token。
+// 明确失效时返回包装了 ErrSessionExpired 的错误，其余错误表示无法判定。
+type RefreshSessionFunc func(ctx context.Context, acc config.Account) (string, error)
+
 type Resolver struct {
 	Store *config.Store
 	Pool  *account.Pool
 	Login LoginFunc
+	// RefreshSession 为可选的轻量续期通道；未注入时所有刷新都会回退到密码登录
+	// （与历史行为一致）。
+	RefreshSession RefreshSessionFunc
 
 	mu               sync.Mutex
 	tokenRefreshedAt map[string]time.Time
@@ -198,19 +214,81 @@ func (r *Resolver) handleBannedAccount(accountID string) {
 	}
 }
 
+// RefreshToken 由鉴权类失败触发。DeepSeek 的 token 是按设备绑定的长期会话凭证，
+// 不存在“旧 token 换新 token”的端点，所以这里先用不带密码的 users/current 探针复核：
+// 探针确认会话仍有效就直接沿用（顺带收下服务端轮换的新值），只有服务端明确拒绝会话
+// 或探针本身不可用时才回退到密码登录。这样既能挡住把非鉴权错误误判成登录失效的情况，
+// 又保留了历史行为里的恢复能力。
 func (r *Resolver) RefreshToken(ctx context.Context, a *RequestAuth) bool {
 	if !a.UseConfigToken || a.AccountID == "" {
 		return false
 	}
-	_ = r.Store.UpdateAccountToken(a.AccountID, "")
-	a.Account.Token = ""
-	if err := r.loginAndPersist(ctx, a); err != nil {
+	if err := r.refreshSessionReactive(ctx, a); err != nil {
 		config.Logger.Error("[refresh_token] failed", "account", a.AccountID, "error", err)
 		return false
 	}
 	return true
 }
 
+// refreshSessionReactive 处理“请求已经拿到鉴权类失败”的场景：探针能证明会话有效就
+// 直接返回；否则按历史行为兜底到密码登录（探针不可判定时不清空 token，登录失败还能
+// 留着下次再试）。
+func (r *Resolver) refreshSessionReactive(ctx context.Context, a *RequestAuth) error {
+	err := r.probeSessionToken(ctx, a)
+	if err == nil {
+		return nil
+	}
+	if errors.Is(err, ErrSessionExpired) {
+		// 会话确认失效：清掉落盘值，避免后续请求继续复用死 token。
+		_ = r.Store.UpdateAccountToken(a.AccountID, "")
+		a.Account.Token = ""
+		a.DeepSeekToken = ""
+	} else {
+		config.Logger.Warn("[refresh_token] session probe inconclusive, falling back to login",
+			"account", a.AccountID, "error", err)
+	}
+	return r.loginAndPersist(ctx, a)
+}
+
+// probeSessionToken 用无密码通道复核当前 token，成功时把服务端值回写内存与配置。
+func (r *Resolver) probeSessionToken(ctx context.Context, a *RequestAuth) error {
+	if r == nil || r.RefreshSession == nil {
+		return errSessionProbeUnavailable
+	}
+	if a == nil || a.AccountID == "" {
+		return errSessionProbeUnavailable
+	}
+	current := strings.TrimSpace(a.Account.Token)
+	if current == "" {
+		return errSessionProbeUnavailable
+	}
+	token, err := r.RefreshSession(ctx, a.Account)
+	if err != nil {
+		return err
+	}
+	token = strings.TrimSpace(token)
+	if token == "" {
+		return errors.New("session probe returned empty token")
+	}
+	a.Account.Token = token
+	a.DeepSeekToken = token
+	r.markTokenRefreshedNow(a.AccountID)
+	// 以配置存储中的值为准判断是否需要写盘：池里的 Account 可能是较早的快照。
+	persisted := current
+	if fresh, ok := r.Store.FindAccount(a.AccountID); ok {
+		persisted = strings.TrimSpace(fresh.Token)
+	}
+	if token == persisted {
+		// 服务端回显同一 token（抓包与线上实测观察到的主要形态）：无需写盘。
+		return nil
+	}
+	config.Logger.Info("[refresh_token] persisted session token from probe", "account", a.AccountID)
+	if err := r.Store.UpdateAccountToken(a.AccountID, token); err != nil {
+		config.Logger.Warn("[refresh_token] persist rotated token failed", "account", a.AccountID, "error", err)
+	}
+	return nil
+}
+
 func (r *Resolver) MarkTokenInvalid(a *RequestAuth) {
 	if !a.UseConfigToken || a.AccountID == "" {
 		return
@@ -302,15 +380,36 @@ func (r *Resolver) ensureManagedToken(ctx context.Context, a *RequestAuth) error
 		return r.loginAndPersist(ctx, a)
 	}
 	if r.shouldForceRefresh(a.AccountID) {
-		if err := r.loginAndPersist(ctx, a); err != nil {
+		if err := r.refreshSessionProactively(ctx, a); err != nil {
 			return err
 		}
-		return nil
 	}
 	a.DeepSeekToken = a.Account.Token
 	return nil
 }
 
+// refreshSessionProactively 是定时任务的“体检”：到期时先做一次免费探针，
+// 只有会话被明确拒绝（或根本没有探针可用）才回退到密码登录；
+// 探针结果不可判定时保留现有 token，不因为一次网络抖动就提交密码。
+func (r *Resolver) refreshSessionProactively(ctx context.Context, a *RequestAuth) error {
+	err := r.probeSessionToken(ctx, a)
+	if err == nil {
+		return nil
+	}
+	if !errors.Is(err, ErrSessionExpired) && !errors.Is(err, errSessionProbeUnavailable) {
+		config.Logger.Warn("[token_refresh] session probe inconclusive, keeping current token",
+			"account", a.AccountID, "error", err)
+		return nil
+	}
+	config.Logger.Info("[token_refresh] session probe requires login", "account", a.AccountID, "reason", err)
+	_ = r.Store.UpdateAccountToken(a.AccountID, "")
+	a.Account.Token = ""
+	a.DeepSeekToken = ""
+	return r.loginAndPersist(ctx, a)
+}
+
+// shouldForceRefresh 判断是否到了定期体检的时间点。到期并不等于要重新登录：
+// 调用方会用无密码探针复核会话，只有探针明确失败才走密码登录。
 func (r *Resolver) shouldForceRefresh(accountID string) bool {
 	if r == nil || r.Store == nil {
 		return false
@@ -330,8 +429,8 @@ func (r *Resolver) shouldForceRefresh(accountID string) bool {
 		r.tokenRefreshedAt[accountID] = now
 		return false
 	}
-	// Add jitter: ±15% random variation to avoid all accounts refreshing at the same time.
-	// For a 6h interval, this gives a range of ~5h06m to ~6h54m.
+	// Add jitter: ±10% random variation to avoid all accounts probing at the same time.
+	// For a 6h interval, this gives a range of ~5h24m to ~6h36m.
 	baseInterval := time.Duration(intervalHours) * time.Hour
 	jitterRange := baseInterval / 10 // ±10% → total range is 80%-120% of base
 	jitter := time.Duration(rand.Int63n(int64(2*jitterRange+1))) - jitterRange
@@ -348,7 +447,7 @@ func (r *Resolver) markTokenRefreshedNow(accountID string) {
 	}
 	// Add a random offset (0-30min) to spread out future refreshes across accounts.
 	// This prevents all accounts from refreshing at the same wall-clock time.
-	offset := time.Duration(rand.Int63n(int64(30*time.Minute)))
+	offset := time.Duration(rand.Int63n(int64(30 * time.Minute)))
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	r.tokenRefreshedAt[accountID] = time.Now().Add(-offset)

internal/auth/session_probe_test.go

@@ -0,0 +1,235 @@
+package auth
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"ds2api/internal/account"
+	"ds2api/internal/config"
+)
+
+func newProbeTestResolver(t *testing.T, login LoginFunc) (*Resolver, *config.Store) {
+	t.Helper()
+	t.Setenv("DS2API_CONFIG_JSON", `{
+		"keys":["managed-key"],
+		"accounts":[{"email":"acc@example.com","password":"pwd"}]
+	}`)
+	store := config.LoadStore()
+	if err := store.UpdateAccountToken("acc@example.com", "session-token"); err != nil {
+		t.Fatalf("seed token failed: %v", err)
+	}
+	return NewResolver(store, account.NewPool(store), login), store
+}
+
+func newProbeTestAuth(token string) *RequestAuth {
+	return &RequestAuth{
+		UseConfigToken: true,
+		AccountID:      "acc@example.com",
+		Account:        config.Account{Email: "acc@example.com", Password: "pwd", Token: token},
+		DeepSeekToken:  token,
+		TriedAccounts:  map[string]bool{},
+	}
+}
+
+func countingLogin(loginCount *int32, token string) LoginFunc {
+	return func(_ context.Context, _ config.Account) (string, error) {
+		atomic.AddInt32(loginCount, 1)
+		return token, nil
+	}
+}
+
+// 探针确认会话仍有效时，刷新不应提交密码。
+func TestRefreshTokenUsesProbeWithoutLogin(t *testing.T) {
+	var loginCount int32
+	r, store := newProbeTestResolver(t, countingLogin(&loginCount, "login-token"))
+	r.RefreshSession = func(_ context.Context, acc config.Account) (string, error) {
+		if acc.Token != "session-token" {
+			t.Fatalf("probe should see current token, got %q", acc.Token)
+		}
+		return "session-token", nil
+	}
+	a := newProbeTestAuth("session-token")
+
+	if !r.RefreshToken(context.Background(), a) {
+		t.Fatal("expected refresh to succeed via session probe")
+	}
+	if got := atomic.LoadInt32(&loginCount); got != 0 {
+		t.Fatalf("expected no password login, got %d", got)
+	}
+	if a.DeepSeekToken != "session-token" {
+		t.Fatalf("expected existing token to be kept, got %q", a.DeepSeekToken)
+	}
+	if token := findTestToken(t, store); token != "session-token" {
+		t.Fatalf("expected persisted token unchanged, got %q", token)
+	}
+}
+
+// 服务端主动轮换时，探针拿回的新 token 要落盘并生效。
+func TestRefreshTokenAdoptsRotatedTokenFromProbe(t *testing.T) {
+	var loginCount int32
+	r, store := newProbeTestResolver(t, countingLogin(&loginCount, "login-token"))
+	r.RefreshSession = func(_ context.Context, _ config.Account) (string, error) {
+		return "rotated-token", nil
+	}
+	a := newProbeTestAuth("session-token")
+
+	if !r.RefreshToken(context.Background(), a) {
+		t.Fatal("expected refresh to succeed via session probe")
+	}
+	if got := atomic.LoadInt32(&loginCount); got != 0 {
+		t.Fatalf("expected no password login, got %d", got)
+	}
+	if a.DeepSeekToken != "rotated-token" {
+		t.Fatalf("expected rotated token on auth, got %q", a.DeepSeekToken)
+	}
+	if token := findTestToken(t, store); token != "rotated-token" {
+		t.Fatalf("expected rotated token persisted, got %q", token)
+	}
+}
+
+// 探针明确判定会话失效时才回退到密码登录。
+func TestRefreshTokenFallsBackToLoginWhenSessionRejected(t *testing.T) {
+	var loginCount int32
+	r, store := newProbeTestResolver(t, countingLogin(&loginCount, "login-token"))
+	r.RefreshSession = func(_ context.Context, _ config.Account) (string, error) {
+		return "", fmt.Errorf("check session: %w", ErrSessionExpired)
+	}
+	a := newProbeTestAuth("session-token")
+
+	if !r.RefreshToken(context.Background(), a) {
+		t.Fatal("expected fallback login to succeed")
+	}
+	if got := atomic.LoadInt32(&loginCount); got != 1 {
+		t.Fatalf("expected exactly one login, got %d", got)
+	}
+	if a.DeepSeekToken != "login-token" {
+		t.Fatalf("expected login token, got %q", a.DeepSeekToken)
+	}
+	if token := findTestToken(t, store); token != "login-token" {
+		t.Fatalf("expected login token persisted, got %q", token)
+	}
+}
+
+// 探针无法判定时仍保留密码登录兜底，避免把可恢复的请求判死。
+func TestRefreshTokenFallsBackToLoginWhenProbeInconclusive(t *testing.T) {
+	var loginCount int32
+	r, _ := newProbeTestResolver(t, countingLogin(&loginCount, "login-token"))
+	r.RefreshSession = func(_ context.Context, _ config.Account) (string, error) {
+		return "", errors.New("dial tcp: connection refused")
+	}
+	a := newProbeTestAuth("session-token")
+
+	if !r.RefreshToken(context.Background(), a) {
+		t.Fatal("expected fallback login to succeed")
+	}
+	if got := atomic.LoadInt32(&loginCount); got != 1 {
+		t.Fatalf("expected exactly one login, got %d", got)
+	}
+	if a.DeepSeekToken != "login-token" {
+		t.Fatalf("expected login token, got %q", a.DeepSeekToken)
+	}
+}
+
+// 定时体检：探针成功即完成，不应触发登录。
+func TestScheduledRefreshUsesProbeWithoutLogin(t *testing.T) {
+	var loginCount int32
+	r, _ := newProbeTestResolver(t, countingLogin(&loginCount, "login-token"))
+	r.RefreshSession = func(_ context.Context, _ config.Account) (string, error) {
+		return "session-token", nil
+	}
+	markRefreshDue(t, r)
+	a := newProbeTestAuth("session-token")
+
+	if err := r.ensureManagedToken(context.Background(), a); err != nil {
+		t.Fatalf("ensure managed token failed: %v", err)
+	}
+	if got := atomic.LoadInt32(&loginCount); got != 0 {
+		t.Fatalf("expected no password login, got %d", got)
+	}
+	if a.DeepSeekToken != "session-token" {
+		t.Fatalf("expected token kept, got %q", a.DeepSeekToken)
+	}
+}
+
+// 定时体检：探针结果不可判定时保留 token，不能因为一次网络抖动就提交密码。
+func TestScheduledRefreshKeepsTokenWhenProbeInconclusive(t *testing.T) {
+	var loginCount int32
+	r, _ := newProbeTestResolver(t, countingLogin(&loginCount, "login-token"))
+	r.RefreshSession = func(_ context.Context, _ config.Account) (string, error) {
+		return "", errors.New("connection reset by peer")
+	}
+	markRefreshDue(t, r)
+	a := newProbeTestAuth("session-token")
+
+	if err := r.ensureManagedToken(context.Background(), a); err != nil {
+		t.Fatalf("ensure managed token failed: %v", err)
+	}
+	if got := atomic.LoadInt32(&loginCount); got != 0 {
+		t.Fatalf("expected no password login on inconclusive probe, got %d", got)
+	}
+	if a.DeepSeekToken != "session-token" {
+		t.Fatalf("expected token kept, got %q", a.DeepSeekToken)
+	}
+}
+
+// 定时体检：探针明确判定失效时回退到密码登录。
+func TestScheduledRefreshLogsInWhenSessionRejected(t *testing.T) {
+	var loginCount int32
+	r, _ := newProbeTestResolver(t, countingLogin(&loginCount, "login-token"))
+	r.RefreshSession = func(_ context.Context, _ config.Account) (string, error) {
+		return "", ErrSessionExpired
+	}
+	markRefreshDue(t, r)
+	a := newProbeTestAuth("session-token")
+
+	if err := r.ensureManagedToken(context.Background(), a); err != nil {
+		t.Fatalf("ensure managed token failed: %v", err)
+	}
+	if got := atomic.LoadInt32(&loginCount); got != 1 {
+		t.Fatalf("expected exactly one login, got %d", got)
+	}
+	if a.DeepSeekToken != "login-token" {
+		t.Fatalf("expected login token, got %q", a.DeepSeekToken)
+	}
+}
+
+// 未注入探针时保持历史行为：定时到期直接登录。
+func TestScheduledRefreshWithoutProbeFallsBackToLogin(t *testing.T) {
+	var loginCount int32
+	r, _ := newProbeTestResolver(t, countingLogin(&loginCount, "login-token"))
+	markRefreshDue(t, r)
+	a := newProbeTestAuth("session-token")
+
+	if err := r.ensureManagedToken(context.Background(), a); err != nil {
+		t.Fatalf("ensure managed token failed: %v", err)
+	}
+	if got := atomic.LoadInt32(&loginCount); got != 1 {
+		t.Fatalf("expected exactly one login, got %d", got)
+	}
+}
+
+func markRefreshDue(t *testing.T, r *Resolver) {
+	t.Helper()
+	if err := r.Store.Update(func(c *config.Config) error {
+		c.Runtime.TokenRefreshIntervalHours = 1
+		return nil
+	}); err != nil {
+		t.Fatalf("update runtime failed: %v", err)
+	}
+	r.mu.Lock()
+	r.tokenRefreshedAt["acc@example.com"] = time.Now().Add(-2 * time.Hour)
+	r.mu.Unlock()
+}
+
+func findTestToken(t *testing.T, store *config.Store) string {
+	t.Helper()
+	acc, ok := store.FindAccount("acc@example.com")
+	if !ok {
+		t.Fatal("account not found in store")
+	}
+	return acc.Token
+}

internal/deepseek/client/client_user_session.go

@@ -0,0 +1,88 @@
+package client
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+	"strings"
+
+	"ds2api/internal/auth"
+	"ds2api/internal/config"
+	dsprotocol "ds2api/internal/deepseek/protocol"
+)
+
+// DeepSeek 没有 access_token + refresh_token 的两段式机制：登录下发的 token 是
+// 按设备绑定的长期会话凭证，服务端不存在可换新的 refresh 端点。官方 Web/Android
+// 客户端续用会话的做法是 GET /api/v0/users/current，响应里的 data.biz_data.token
+// 就是当前会话 token（服务端主动轮换时会是新值），客户端拿到后直接写回本地存储，
+// 全程不需要密码。
+//
+// RefreshSessionToken 复刻这条通道，用来替代“到期就提交一次明文密码”的做法。
+// 返回的错误分两类：
+//   - auth.ErrSessionExpired：服务端明确拒绝该会话（401/403 或鉴权类 biz_code），
+//     只能靠密码重新登录恢复；
+//   - 其他错误：无法判定（网络、5xx、未知 biz_code、响应缺字段），
+//     调用方不应据此丢弃仍然可能有效的 token。
+func (c *Client) RefreshSessionToken(ctx context.Context, acc config.Account) (string, error) {
+	token := strings.TrimSpace(acc.Token)
+	if token == "" {
+		return "", errors.New("refresh session token: empty token")
+	}
+	clients := c.requestClientsForAccount(acc)
+	headers := c.authHeadersWithRangers(token, config.AndroidAccountRangersID(acc))
+	resp, status, err := c.getJSONWithStatus(ctx, clients.regular, dsprotocol.DeepSeekCurrentUserURL, headers)
+	if err != nil {
+		return "", fmt.Errorf("refresh session token: %w", err)
+	}
+	return interpretCurrentUserResponse(status, resp)
+}
+
+// interpretCurrentUserResponse 把 users/current 的响应翻译成“新 token / 会话失效 /
+// 无法判定”三种结果。判定刻意收窄：只有 HTTP 401/403 或鉴权类业务码才认定会话失效，
+// 避免把限流、风控、临时故障误判成“必须重新登录”。
+func interpretCurrentUserResponse(status int, resp map[string]any) (string, error) {
+	code, bizCode, msg, bizMsg := extractResponseStatus(resp)
+	if status == http.StatusOK && code == 0 && bizCode == 0 {
+		if token := extractCurrentUserToken(resp); token != "" {
+			return token, nil
+		}
+		return "", errors.New("refresh session token: response has no token")
+	}
+	if sessionRejectedStatus(status, code, bizCode) {
+		return "", fmt.Errorf(
+			"refresh session token: session rejected (status=%d code=%d biz_code=%d msg=%q biz_msg=%q): %w",
+			status, code, bizCode, msg, bizMsg, auth.ErrSessionExpired,
+		)
+	}
+	return "", fmt.Errorf(
+		"refresh session token: inconclusive response (status=%d code=%d biz_code=%d msg=%q biz_msg=%q)",
+		status, code, bizCode, msg, bizMsg,
+	)
+}
+
+func sessionRejectedStatus(status int, code int, bizCode int) bool {
+	if status == http.StatusUnauthorized || status == http.StatusForbidden {
+		return true
+	}
+	for _, candidate := range []int{code, bizCode} {
+		switch candidate {
+		case 40001, 40002, 40003:
+			return true
+		}
+	}
+	return false
+}
+
+// extractCurrentUserToken 兼容两种响应形状：data.biz_data.token（抓包观察到的）
+// 与 data.biz_data.user.token（登录响应同构的嵌套形状）。
+func extractCurrentUserToken(resp map[string]any) string {
+	data, _ := resp["data"].(map[string]any)
+	bizData, _ := data["biz_data"].(map[string]any)
+	if token, _ := bizData["token"].(string); strings.TrimSpace(token) != "" {
+		return strings.TrimSpace(token)
+	}
+	user, _ := bizData["user"].(map[string]any)
+	token, _ := user["token"].(string)
+	return strings.TrimSpace(token)
+}

internal/deepseek/client/client_user_session_test.go

@@ -0,0 +1,89 @@
+package client
+
+import (
+	"errors"
+	"testing"
+
+	"ds2api/internal/auth"
+)
+
+func TestInterpretCurrentUserResponseReturnsFlatToken(t *testing.T) {
+	resp := map[string]any{
+		"code": 0,
+		"data": map[string]any{
+			"biz_code": 0,
+			"biz_data": map[string]any{
+				"id":    "user-1",
+				"token": "flat-token",
+			},
+		},
+	}
+	token, err := interpretCurrentUserResponse(200, resp)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if token != "flat-token" {
+		t.Fatalf("expected flat-token, got %q", token)
+	}
+}
+
+func TestInterpretCurrentUserResponseReturnsNestedUserToken(t *testing.T) {
+	resp := map[string]any{
+		"code": 0,
+		"data": map[string]any{
+			"biz_code": 0,
+			"biz_data": map[string]any{
+				"user": map[string]any{"token": "nested-token"},
+			},
+		},
+	}
+	token, err := interpretCurrentUserResponse(200, resp)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if token != "nested-token" {
+		t.Fatalf("expected nested-token, got %q", token)
+	}
+}
+
+func TestInterpretCurrentUserResponseMarksUnauthorizedAsExpired(t *testing.T) {
+	_, err := interpretCurrentUserResponse(401, map[string]any{"code": 40001, "msg": "unauthorized"})
+	if !errors.Is(err, auth.ErrSessionExpired) {
+		t.Fatalf("expected ErrSessionExpired, got %v", err)
+	}
+}
+
+func TestInterpretCurrentUserResponseMarksAuthBizCodeAsExpired(t *testing.T) {
+	resp := map[string]any{
+		"code": 0,
+		"data": map[string]any{"biz_code": 40003, "biz_msg": "invalid permission"},
+	}
+	_, err := interpretCurrentUserResponse(200, resp)
+	if !errors.Is(err, auth.ErrSessionExpired) {
+		t.Fatalf("expected ErrSessionExpired, got %v", err)
+	}
+}
+
+// 5xx / 网络类失败不能当成“会话失效”，否则又会退回高频密码登录。
+func TestInterpretCurrentUserResponseKeepsServerErrorInconclusive(t *testing.T) {
+	_, err := interpretCurrentUserResponse(500, map[string]any{"code": 500, "msg": "internal error"})
+	if err == nil {
+		t.Fatal("expected error")
+	}
+	if errors.Is(err, auth.ErrSessionExpired) {
+		t.Fatalf("server error must not be treated as expired session: %v", err)
+	}
+}
+
+func TestInterpretCurrentUserResponseMissingTokenIsInconclusive(t *testing.T) {
+	_, err := interpretCurrentUserResponse(200, map[string]any{
+		"code": 0,
+		"data": map[string]any{"biz_code": 0, "biz_data": map[string]any{"id": "user-1"}},
+	})
+	if err == nil {
+		t.Fatal("expected error when token is missing")
+	}
+	if errors.Is(err, auth.ErrSessionExpired) {
+		t.Fatalf("missing token must not be treated as expired session: %v", err)
+	}
+}

internal/deepseek/protocol/constants.go

@@ -10,6 +10,7 @@ import (
 const (
 	DeepSeekHost                 = "chat.deepseek.com"
 	DeepSeekLoginURL             = "https://chat.deepseek.com/api/v0/users/login"
+	DeepSeekCurrentUserURL       = "https://chat.deepseek.com/api/v0/users/current"
 	DeepSeekCreateSessionURL     = "https://chat.deepseek.com/api/v0/chat_session/create"
 	DeepSeekCreatePowURL         = "https://chat.deepseek.com/api/v0/chat/create_pow_challenge"
 	DeepSeekCompletionURL        = "https://chat.deepseek.com/api/v0/chat/completion"

internal/server/router.go

@@ -54,6 +54,11 @@ func NewApp() (*App, error) {
 		return dsClient.Login(ctx, acc)
 	})
 	dsClient = dsclient.NewClient(store, resolver)
+	// 无密码续期通道：users/current 回填当前会话 token。
+	// 注入后 Resolver 的刷新链会先走这条通道，密码登录只作为兜底。
+	resolver.RefreshSession = func(ctx context.Context, acc config.Account) (string, error) {
+		return dsClient.RefreshSessionToken(ctx, acc)
+	}
 	if err := dsClient.PreloadPow(context.Background()); err != nil {
 		config.Logger.Warn("[PoW] init failed", "error", err)
 	} else {

security_best_practices_report.md

@@ -168,7 +168,7 @@
 
 **建议修复**: 不建议立即修复 —— Go 进程内存加密会显著增加复杂度且无法抵御 root 攻击者。建议：
 1. 确保 HF Space 容器以非 root 用户运行（已确认 `ds2api` 用户）。
-2. 定期刷新 token（已有 `TokenRefreshIntervalHours` 配置）。
+2. 定期复核会话有效性（`TokenRefreshIntervalHours` 到期时先走无密码的 `GET /api/v0/users/current`，只有服务端明确拒绝会话才重新登录）。
 3. 监控异常 token 使用。
 
 ### TODO-6: webui 静态文件路径穿越（已防护，建议加固）