dsh-webui-oauth 0.7.4 → 0.7.5

package/CHANGELOG.md

@@ -2,6 +2,45 @@
 
 本文件记录每个版本的**用户可见**变更。破坏性变更与升级动作单独标注。
 
+## 0.7.5
+
+设置页交互修正：登录回调改成全局悬浮窗、远程信任可一键开关、保存改为右下角悬浮按钮 + 二次验证。
+
+### 修复：登录回调中转
+
+- **输入框缺失**：旧实现把中转窗渲染在设置页组件内部，受容器布局影响显示不全；
+  现在改为在客户端插件 `apply()` 里挂**全局**悬浮组件（原生 DOM，不依赖 slot），
+  输入框、按钮、提示都完整可见。
+- **不再放在设置页**：右下角常驻「DeepSeek 登录回调」悬浮按钮，任何页面都能打开；
+  设置页只保留说明文字。
+
+### 新增：远程访问信任开关（不再只靠改 YAML）
+
+- 设置 → 身份认证 → 远程访问，新增「开启 / 关闭远程访问信任」按钮；
+- 新增 `POST /dsh-webui-oauth/remote-trust`（要求会话）：写入插件配置
+  `dsh-webui-oauth.json` 的 `remoteTrust`，并**动态**安装/移除 index tap；
+- 配置合并写入，不会覆盖 OIDC 段；
+- `webServer.tapIndex` 不可用时返回 `tap-index-unavailable`，不假装成功；
+- 仍兼容 settings 的 `remote-web-ui.trustRemoteHost`（手工配置优先级的兜底）。
+
+### 新增：设置保存改为悬浮按钮 + 二次验证
+
+- 账号卡片里的「保存账号密码」按钮已移除；
+- 插件设置子页右下角常驻「保存设置」悬浮按钮；
+- 点击后弹窗验证身份，再真正保存：
+  - **当前密码**；或
+  - **SSO 验证**：`GET /dsh-webui-oauth/oidc/reauth` 走一次 IdP 授权，
+    回调签发**一次性、2 分钟**的复验令牌（不新建会话），客户端存在
+    sessionStorage 并在保存时提交；
+- `configure` / `disable` / `oidc/unbind` 均接受 `reauthToken` 替代密码；
+- 令牌一次性、不可重放；密码路径保持不变。
+
+### 测试
+
+- `test/oidc-bind.test.mjs` 新增 9 项：SSO 复验全链路（发起 → 回调令牌 →
+  无密码保存 → 令牌不可重放）、远程信任端点（未登录 401 / 类型校验 / tapIndex 缺失降级）；
+- 全量 22 个测试文件、599 项断言通过。
+
 ## 0.7.4
 
 修正 0.7.3 对官方 DeepSeek 登录的处理：`/oauth/callback` **不再公开**，改为

package/README.en.md

@@ -112,13 +112,16 @@ Authentication is enforced in four layers, all implemented by **wrapping the web
 - **Remote-access trust (0.7.3, optional built-in equivalent of `dsh-remote-trust`)**: when the page is
   reached through a domain reverse proxy, the client treats it as non-loopback and Settings → Models
   reports `settings are unavailable in this browser`. Enable:
+  **Since 0.7.5 you can simply click "开启远程访问信任" on the settings page**; editing YAML is no longer
+  required (and is still supported):
   ```yaml
   remote-web-ui:
     trustRemoteHost: true
   ```
   It injects `__DSH_TRANSPORT__.ownsHost = true` into index.html through the official
   `webServer.tapIndex`; the injection is idempotent, so installing `dsh-remote-trust` as well does not
-  duplicate it. If `tapIndex` is unavailable it only logs a warning and everything else keeps working
+  duplicate it. The settings toggle writes `remoteTrust` into `dsh-webui-oauth.json` and applies
+  dynamically (refresh the page for the injected index to take effect). If `tapIndex` is unavailable it only logs a warning and everything else keeps working
   (version compatibility).
   **Security boundary**: the declaration marks the page as a "trusted local" surface and also opens
   other client-side features gated on `isLoopback`; enable it only when the page is already protected
@@ -426,9 +429,10 @@ wired into `npm test`).
     `http://127.0.0.1:<local port>`;
   - after authorization the browser is redirected to that loopback callback — usually unreachable from
     a remote machine, but the full URL stays in the address bar;
-  - Settings → Authentication → Remote access → "Open callback relay window", paste the URL; the plugin
-    **replays it internally** to the account platform's registered `/oauth/callback` handler (state and
-    PKCE are still validated by the platform) to finish the token exchange;
+  - click the always-on "DeepSeek 登录回调" floating button at the bottom-right of any page and paste
+    the URL; the plugin **replays it internally** to the account platform's registered
+    `/oauth/callback` handler (state and PKCE are still validated by the platform) to finish the
+    token exchange;
   - the relay endpoint requires the plugin session and accepts only the local port's
     `/oauth/callback` with exactly one `code`/`state` (SSRF / open-redirect protection);
   - on `http://127.0.0.1:3080` the official login already completes directly; no relay needed.

package/README.md

@@ -121,11 +121,12 @@ DSH WebUI 身份认证插件（持久化插件）。在「设置 → 身份认
 
 
 - **远程访问信任（0.7.3，原 `dsh-remote-trust` 的可选内置）**：经域名反代访问时，客户端会把页面判为"非 loopback"，设置 → 模型会报 `settings are unavailable in this browser`。开启下面这一项即可（等价于安装 `dsh-remote-trust`，但不需要额外插件）：
+  **0.7.5 起也可以直接在设置页点「开启远程访问信任」**，无需改 YAML；手工配置仍然兼容：
   ```yaml
   remote-web-ui:
     trustRemoteHost: true
   ```
-  它通过官方 `webServer.tapIndex` 往 index.html 注入 `__DSH_TRANSPORT__.ownsHost = true`；注入幂等，与 `dsh-remote-trust` 同时安装也不会重复。`tapIndex` 不存在时只记一条 warn，插件其余功能照常（版本兼容）。
+  它通过官方 `webServer.tapIndex` 往 index.html 注入 `__DSH_TRANSPORT__.ownsHost = true`；注入幂等，与 `dsh-remote-trust` 同时安装也不会重复。设置页开关写入插件配置 `dsh-webui-oauth.json` 的 `remoteTrust`，动态生效（刷新页面后 index 生效）。`tapIndex` 不存在时只记一条 warn，插件其余功能照常（版本兼容）。
   **安全边界**：该声明会把页面当作"可信本机"，同时放开其他以 `isLoopback` 为条件的本机专属客户端表面；只应在页面已由本插件保护时启用，且服务端仍需 `--trusted-host <对外域名>`（它不改变服务端信任护栏）。
 - **追加公开路径（0.6.7，默认拒绝的配套开关）**：机器调用、无法携带浏览器会话的端点（GitHub webhook、第三方 OAuth 回跳等）必须显式声明，否则会被闸门 401。同一 settings 段：
   ```yaml
@@ -422,7 +423,7 @@ IdP 侧日志确认完整往返：`discovery → jwks → authorize(issued code)
 - **DeepSeek 官方账号登录（0.2.1+，远程回调中转）**：`/oauth/callback` **不是公开路径**，仍受会话闸门保护。上游 `@deepseek-ai/dsh-deepseek-account-platform` 的 `loginOrigin()` 只接受 `http://localhost:<port>`、`http://127.0.0.1:<port>`、`http://[::1]:<port>`（显式非零端口），不支持反代域名。插件的处理方式：
   - 劫持官方登录的 `callbackOrigin`：本地回环访问保留原 origin（cookie 同 host，回调直接命中）；域名访问改写成 `http://127.0.0.1:<本机端口>`；
   - 浏览器授权后会被跳到这个回环回调地址——远程机器上通常打不开，但地址栏里有完整 URL；
-  - 设置 → 身份认证 → 远程访问 →「打开回调中转窗口」，把地址栏 URL 粘贴进去；插件在服务端**内部重放**给账号平台注册的 `/oauth/callback` handler（state + PKCE 仍由平台校验），完成换 token；
+  - 点击页面右下角常驻的「DeepSeek 登录回调」悬浮按钮，把地址栏 URL 粘贴进去；插件在服务端**内部重放**给账号平台注册的 `/oauth/callback` handler（state + PKCE 仍由平台校验），完成换 token；
   - 中转端点要求插件会话，且只接受本机端口的 `/oauth/callback` + 单个 `code`/`state`（防 SSRF / 开放重定向）；
   - 本机 `http://127.0.0.1:3080` 访问时官方登录原本就能直接走完，无需中转。
 - **DSH Desktop**：支持 `dsh-desktop-*` 标记透传（登录 / 退出后重登不再丢失标记），但**不提供**上游 0.3.6 的「宿主载体桥」。该桥只用 socket 是否回环来判定，而本部署是 nginx 同机反代——所有请求的 socket 都是 `127.0.0.1`，启用它等于"持有核心 Cookie 即可绕过插件会话 / SSO"，与「仅允许 SSO」冲突。若必须使用 DSH Desktop 的 shell 直连模式，请改用上游原版插件，并自行评估该旁路风险。

package/index.js

@@ -474,11 +474,33 @@ async function readOidcConfig(ctx, creds) {
   return { oidc: null, legacy: false }
 }
 
-/** 写入 OIDC 配置（独立文件，0600 由数据目录权限兜底）。 */
-async function writeOidcConfig(ctx, oidc) {
+/**
+ * 读取插件配置文件的**全部**顶层字段（不止 oidc）。
+ * 用于在不破坏其它配置的前提下写入 remoteTrust 等新字段。
+ */
+async function readPluginConfigFile(ctx) {
+  try {
+    const raw = await ctx.fs.readText(await ctx.fs.resolve(oidcConfigPath()))
+    const parsed = raw ? JSON.parse(raw) : null
+    return parsed && typeof parsed === 'object' ? parsed : {}
+  } catch (e) {
+    return {}
+  }
+}
+
+/** 合并写入插件配置文件的顶层字段，保留未提及的键。 */
+async function writePluginConfigFile(ctx, patch) {
   ensureDataDir()
+  const current = await readPluginConfigFile(ctx)
+  const next = { ...current, ...patch }
   const target = await ctx.fs.resolve(oidcConfigPath())
-  await ctx.fs.writeText(target, JSON.stringify({ v: 1, oidc }), undefined, undefined, { mode: 'danger-full-access' })
+  await ctx.fs.writeText(target, JSON.stringify(next), undefined, undefined, { mode: 'danger-full-access' })
+  return next
+}
+
+/** 写入 OIDC 配置（独立文件，0600 由数据目录权限兜底）。保留其它顶层字段。 */
+async function writeOidcConfig(ctx, oidc) {
+  await writePluginConfigFile(ctx, { v: 1, oidc })
 }
 
 /** 从凭据对象里剥离历史遗留的 oidc 段（迁移到独立文件后不再重复保存）。 */
@@ -1104,7 +1126,9 @@ const SELF_GATED_EXACT_PATHS = new Set([
   '/dsh-webui-oauth/oidc/unbind',
   '/dsh-webui-oauth/oidc/callback',
   '/dsh-webui-oauth/oidc/logout',
+  '/dsh-webui-oauth/oidc/reauth',
   '/dsh-webui-oauth/oauth-relay',
+  '/dsh-webui-oauth/remote-trust',
 ])
 
 /**
@@ -1305,19 +1329,25 @@ export function remoteTrustEnabled(ctx) {
  *
  * @returns {boolean} 是否已安装
  */
-export function installRemoteTrust(ctx) {
-  if (!remoteTrustEnabled(ctx)) return false
+export function applyRemoteTrust(ctx, enabled) {
+  if (!enabled) return { ok: true, off: null }
   const ws = ctx && ctx.webServer
   if (!ws || typeof ws.tapIndex !== 'function') {
-    try { ctx.logger.warn('[dsh-webui-oauth] remote-web-ui.trustRemoteHost 已启用，但 webServer.tapIndex 不可用；未注入 ownsHost') } catch (e) { /* ignore */ }
-    return false
+    try { ctx.logger.warn('[dsh-webui-oauth] 远程访问信任已启用，但 webServer.tapIndex 不可用；未注入 ownsHost') } catch (e) { /* ignore */ }
+    return { ok: false, off: null }
   }
   const off = ws.tapIndex(injectRemoteTrust)
   try {
     if (typeof ctx.effect === 'function') ctx.effect(() => off, 'dsh-webui-oauth: remote trust index tap')
   } catch (e) { /* ignore */ }
   try { ctx.logger.info('[dsh-webui-oauth] remote trust index tap registered (__DSH_TRANSPORT__.ownsHost = true)') } catch (e) { /* ignore */ }
-  return true
+  return { ok: true, off }
+}
+
+/** 兼容旧调用：按 settings 配置安装一次。 */
+export function installRemoteTrust(ctx) {
+  if (!remoteTrustEnabled(ctx)) return false
+  return applyRemoteTrust(ctx, true).ok
 }
 
 /** 该请求是否是一次浏览器导航（而不是 fetch/XHR 的接口调用）。 */
@@ -2741,7 +2771,30 @@ export async function apply(ctx) {
   refreshSsoOnly().catch(() => {})
 
   // 远程访问信任（可选）：反代域名下让设置页可用。默认关闭；tapIndex 缺失时安全降级。
-  installRemoteTrust(ctx)
+  // 配置来源：插件配置 remoteTrust（设置页按钮写入），其次 settings 的
+  // remote-web-ui.trustRemoteHost（兼容手工配置）。
+  let remoteTrustOff = null
+  let remoteTrustFlag = false
+  const setRemoteTrustEnabled = (enabled) => {
+    if (!enabled) {
+      if (remoteTrustOff) { try { remoteTrustOff() } catch (e) { /* ignore */ } remoteTrustOff = null }
+      remoteTrustFlag = false
+      return true
+    }
+    if (remoteTrustOff) { remoteTrustFlag = true; return true }
+    const applied = applyRemoteTrust(ctx, true)
+    if (applied.ok) {
+      remoteTrustOff = applied.off
+      remoteTrustFlag = true
+      return true
+    }
+    remoteTrustFlag = false
+    return false
+  }
+  readPluginConfigFile(ctx).then((cfg) => {
+    const enabled = cfg.remoteTrust === true || remoteTrustEnabled(ctx)
+    setRemoteTrustEnabled(enabled)
+  }).catch(() => {})
 
   // 官方 DeepSeek 账号登录：把 callbackOrigin 桥接到回环地址（远程部署由中继端点完成）。
   installAccountLoginBridge(ctx)
@@ -2778,12 +2831,31 @@ export async function apply(ctx) {
   // 授权请求状态表（TTL + 容量上限），见 makeOidcStateStore 的说明。
   // 必须在后台定时器使用 purge 之前定义。
   const oidcStateStore = makeOidcStateStore()
+
+  // 敏感操作（保存配置 / 禁用 / 解绑）的 SSO 复验令牌：
+  // 一次性、2 分钟。密码被禁用（仅允许 SSO）时，用户仍可用 SSO 完成二次验证。
+  const reauthTokens = new Map()
+  const REAUTH_TTL_MS = 2 * 60 * 1000
+  const mintReauthToken = (username) => {
+    const token = randomBytes(16).toString('hex')
+    reauthTokens.set(token, { username, expiresAt: Date.now() + REAUTH_TTL_MS })
+    return token
+  }
+  const consumeReauthToken = (token) => {
+    if (typeof token !== 'string' || !token) return null
+    const rec = reauthTokens.get(token)
+    if (!rec) return null
+    reauthTokens.delete(token)
+    if (rec.expiresAt <= Date.now()) return null
+    return rec
+  }
   const purgeExpiredOidcStates = oidcStateStore.purge
 
   // 后台任务：过期会话清理 + enabled 状态刷新
   const bgTimer = setInterval(async () => {
     const now = Date.now()
     for (const [k, s] of sessions.live) if (s.expiresAt <= now) sessions.delete(k)
+    for (const [k, v] of reauthTokens) if (v.expiresAt <= now) reauthTokens.delete(k)
     purgeExpiredOidcStates()
     try {
       const creds = await readCredentials(ctx)
@@ -3050,8 +3122,8 @@ export async function apply(ctx) {
           username: enabled ? creds.username : null,
           ttl: ttlOf(creds),
           sessionsPersisted: sessions.ok,
-          // 远程访问信任（可选）：是否按 remote-web-ui.trustRemoteHost 注入了 ownsHost。
-          remoteTrust: remoteTrustEnabled(ctx),
+          // 远程访问信任（可选）：是否已注入 ownsHost。
+          remoteTrust: remoteTrustFlag,
           // 核心兜底席位形态（handler | resource | absent | unknown）：核心升级后
           // 如果这里变成 unknown，文档请求会 404 —— 排查时先看这个字段。
           fallback: fallbackShape(ctx.webServer),
@@ -3171,7 +3243,9 @@ export async function apply(ctx) {
           }
         }
         if (wasEnabled) {
-          const curValid = current && typeof creds.hash === 'string' && await verifyPassword(current, creds.hash)
+          // 支持 SSO 复验令牌（「仅允许 SSO」时密码登录入口不可用）
+          const reauthOk = !!consumeReauthToken(body.reauthToken)
+          const curValid = reauthOk || (current && typeof creds.hash === 'string' && await verifyPassword(current, creds.hash))
           if (!curValid) {
             await auditLog(ctx, 'configure_failure', { username, ip: meta.ip, ua: meta.ua, detail: '当前密码不正确' })
             sendJson(res, 200, { ok: false, error: 'current-invalid' })
@@ -3338,7 +3412,8 @@ export async function apply(ctx) {
           sendJson(res, 200, { ok: true })
           return
         }
-        const curValid = current && typeof creds.hash === 'string' && await verifyPassword(current, creds.hash)
+        const reauthOk = !!consumeReauthToken(body.reauthToken)
+        const curValid = reauthOk || (current && typeof creds.hash === 'string' && await verifyPassword(current, creds.hash))
         if (!curValid) {
           await auditLog(ctx, 'disable_failure', { username: creds.username, ip: meta.ip, ua: meta.ua, detail: '当前密码不正确' })
           sendJson(res, 200, { ok: false, error: 'current-invalid' })
@@ -3474,6 +3549,39 @@ export async function apply(ctx) {
     },
   }), 'dsh-webui-oauth: oidc login')
 
+  // OIDC 复验：GET /dsh-webui-oauth/oidc/reauth
+  //
+  // 用于「保存认证配置 / 禁用认证 / 解绑」前的二次验证。要求已登录会话；
+  // 走一次 IdP 授权后，回调只签发一次性复验令牌（2 分钟），不新建会话。
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-webui-oauth/oidc/reauth',
+    handler: async (req, res) => {
+      try {
+        if (req.method !== 'GET' && req.method !== 'HEAD') {
+          sendJson(res, 405, { error: '仅支持 GET' })
+          return
+        }
+        if (!checkRequest(req)) {
+          sendJson(res, 401, { error: 'unauthorized' })
+          return
+        }
+        const creds0 = await readCredentials(ctx)
+        if (!(await oidcEnabled(creds0))) {
+          sendJson(res, 200, { ok: false, error: 'oidc-not-configured' })
+          return
+        }
+        if (!isOidcBound(creds0)) {
+          sendJson(res, 200, { ok: false, error: 'oidc-not-bound' })
+          return
+        }
+        await startOidcAuthorize(ctx, req, res, 'reauth')
+      } catch (e) {
+        sendJson(res, 500, { error: e && e.message ? e.message : String(e) })
+      }
+    },
+  }), 'dsh-webui-oauth: oidc reauth')
+
   // 发起 OIDC 绑定授权：GET /dsh-webui-oauth/oidc/bind
   //
   // 必须先持有有效的本地会话（已登录）——绑定语义是"把我这个管理员账号
@@ -3521,7 +3629,8 @@ export async function apply(ctx) {
         const creds = await readCredentials(ctx)
         const meta = requestMeta(req)
         const current = String(body.current || '')
-        const curValid = current && creds && typeof creds.hash === 'string' && await verifyPassword(current, creds.hash)
+        const reauthOk = !!consumeReauthToken(body.reauthToken)
+        const curValid = reauthOk || (current && creds && typeof creds.hash === 'string' && await verifyPassword(current, creds.hash))
         if (!curValid) {
           await auditLog(ctx, 'oidc_unbind_failure', { username: creds && creds.username ? creds.username : null, ip: meta.ip, ua: meta.ua, detail: '当前密码不正确' })
           sendJson(res, 200, { ok: false, error: 'current-invalid' })
@@ -3671,6 +3780,25 @@ export async function apply(ctx) {
 
         // 用途分支：绑定 vs 登录。purpose 来自服务端 state 表（见 startOidcAuthorize），
         // 浏览器无法通过改 URL 把绑定流程降级成登录流程。
+        // SSO 复验：用于保存配置/禁用/解绑的二次验证，不新建会话。
+        if (st.purpose === 'reauth') {
+          const bound = boundSubOf(creds)
+          if (!bound) {
+            await auditLog(ctx, 'oidc_login_failure', { username: auditName, ip: meta.ip, ua: meta.ua, detail: '复验时尚未绑定身份' })
+            redirectBackToApp(ctx, req, res, 'oidcerr=not-bound', clearStateCookie)
+            return
+          }
+          if (!safeTokenEquals(String(rawSub), bound)) {
+            await auditLog(ctx, 'oidc_login_failure', { username: auditName, ip: meta.ip, ua: meta.ua, detail: '复验身份不匹配' })
+            redirectBackToApp(ctx, req, res, 'oidcerr=sub-mismatch', clearStateCookie)
+            return
+          }
+          const token = mintReauthToken(rawSub)
+          await auditLog(ctx, 'oidc_reauth_success', { username: auditName, ip: meta.ip, ua: meta.ua })
+          redirectBackToApp(ctx, req, res, 'oidcreauth=' + token, clearStateCookie)
+          return
+        }
+
         if (st.purpose === 'bind') {
           // 绑定：把本次校验通过的 sub 记进凭据文件。
           // 保留原有 username/hash/ttl，只加 boundSub —— 用 spread 以免漏字段。
@@ -3747,6 +3875,50 @@ export async function apply(ctx) {
     },
   }), 'dsh-webui-oauth: oidc logout')
 
+  // 远程访问信任开关：POST /dsh-webui-oauth/remote-trust
+  //
+  // 设置页按钮调用。写插件配置（不碰核心 settings），并动态安装/移除 index tap。
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-webui-oauth/remote-trust',
+    handler: async (req, res) => {
+      try {
+        if (req.method !== 'POST') {
+          sendJson(res, 405, { error: '仅支持 POST' })
+          return
+        }
+        if (!checkRequest(req)) {
+          sendJson(res, 401, { error: 'unauthorized' })
+          return
+        }
+        const body = await readJsonBody(req, res)
+        if (body === null) return
+        if (typeof body.enabled !== 'boolean') {
+          sendJson(res, 200, { ok: false, error: 'invalid', reason: 'enabled 须为 boolean' })
+          return
+        }
+        await writePluginConfigFile(ctx, { remoteTrust: body.enabled })
+        const applied = setRemoteTrustEnabled(body.enabled)
+        if (!applied) {
+          sendJson(res, 200, {
+            ok: false,
+            error: 'tap-index-unavailable',
+            reason: '当前核心不支持 webServer.tapIndex，无法注入 ownsHost',
+          })
+          return
+        }
+        const meta = requestMeta(req)
+        await auditLog(ctx, 'remote_trust', {
+          username: null, ip: meta.ip, ua: meta.ua,
+          detail: body.enabled ? '已开启远程访问信任' : '已关闭远程访问信任',
+        })
+        sendJson(res, 200, { ok: true, enabled: remoteTrustFlag })
+      } catch (e) {
+        sendJson(res, 500, { error: 'remote-trust-failed' })
+      }
+    },
+  }), 'dsh-webui-oauth: remote trust toggle')
+
   // 官方 DeepSeek 登录的「回调中转」：POST /dsh-webui-oauth/oauth-relay
   //
   // 远程部署下，浏览器授权后会被重定向到 http://127.0.0.1:<port>/oauth/callback

package/lib/client.js

@@ -25,6 +25,12 @@ window.__ModuleLoader__.load({
 			'.wua-float { position: fixed; right: 24px; bottom: 24px; z-index: 9999; width: min(440px, calc(100vw - 48px)); display: flex; flex-direction: column; gap: 10px; padding: 16px 18px; border: 1px solid var(--dsw-alias-border-l2, #999); border-radius: 12px; background: var(--dsw-alias-bg-layer-1, #fff); box-shadow: 0 18px 48px rgba(0, 0, 0, .22); }',
 			'.wua-float-head { display: flex; align-items: center; justify-content: space-between; gap: 10px; }',
 			'.wua-float-title { font-size: 13px; font-weight: 600; color: var(--dsw-alias-label-primary, #222); }',
+			'.wua-fab { position: fixed; right: 24px; bottom: 96px; z-index: 9998; padding: 9px 16px; font-size: 13px; cursor: pointer; color: #fff; background: var(--dsw-alias-brand-primary, #4a7cf7); border: none; border-radius: 999px; box-shadow: 0 10px 26px rgba(74, 124, 247, .35); }',
+			'.wua-fab:hover { filter: brightness(1.05); }',
+			'.wua-save-fab { position: fixed; right: 24px; bottom: 24px; z-index: 9997; padding: 10px 20px; font-size: 13px; font-weight: 600; cursor: pointer; color: #fff; background: var(--dsw-alias-brand-primary, #4a7cf7); border: none; border-radius: 999px; box-shadow: 0 12px 30px rgba(74, 124, 247, .38); }',
+			'.wua-save-fab:disabled { opacity: .55; cursor: default; }',
+			'.wua-modal-mask { position: fixed; inset: 0; z-index: 10000; display: flex; align-items: center; justify-content: center; padding: 24px; background: rgba(0, 0, 0, .45); }',
+			'.wua-modal { width: min(420px, 100%); display: flex; flex-direction: column; gap: 12px; padding: 20px 22px; border-radius: 12px; background: var(--dsw-alias-bg-layer-1, #fff); box-shadow: 0 24px 60px rgba(0, 0, 0, .35); }',
 			'.wua-intro { margin: 0; font-size: 13px; line-height: 1.6; color: var(--dsw-alias-label-secondary, #888); }',
 			'.wua-row { display: flex; flex-direction: column; gap: 5px; }',
 			'.wua-label { font-size: 12px; color: var(--dsw-alias-label-secondary, #888); }',
@@ -60,6 +66,110 @@ window.__ModuleLoader__.load({
 				if (styleEl.parentNode !== null) styleEl.parentNode.removeChild(styleEl);
 			}, 'dsh-webui-oauth: styles');
 
+			// ---------------- 全局悬浮：DeepSeek 登录回调中转 ----------------
+			// 不放在设置页里：官方登录是在「设置 → 账号」发起的，回调地址可能在任何
+			// 页面/标签页拿到。这里挂一个全局悬浮按钮，任何页面都能打开粘贴窗口。
+			(function mountRelayWidget() {
+				if (typeof document === 'undefined' || !document.body) return;
+				if (document.getElementById('dsh-wua-relay')) return;
+
+				const wrap = document.createElement('div');
+				wrap.id = 'dsh-wua-relay';
+
+				const fab = document.createElement('button');
+				fab.type = 'button';
+				fab.className = 'wua-fab';
+				fab.textContent = 'DeepSeek 登录回调';
+				fab.title = '官方 DeepSeek 登录的回调中转';
+
+				const panel = document.createElement('div');
+				panel.className = 'wua-float';
+				panel.style.display = 'none';
+
+				const head = document.createElement('div');
+				head.className = 'wua-float-head';
+				const title = document.createElement('span');
+				title.className = 'wua-float-title';
+				title.textContent = 'DeepSeek 登录回调中转';
+				const close = document.createElement('button');
+				close.type = 'button';
+				close.className = 'wua-btn ghost';
+				close.textContent = '关闭';
+				head.appendChild(title);
+				head.appendChild(close);
+
+				const hint = document.createElement('p');
+				hint.className = 'wua-hint';
+				hint.style.borderTop = 'none';
+				hint.style.paddingTop = '0';
+				hint.textContent = '把浏览器地址栏里的完整回调 URL 粘贴到这里。只接受 http://127.0.0.1 或 localhost 的本机端口地址。';
+
+				const input = document.createElement('input');
+				input.className = 'wua-input';
+				input.type = 'text';
+				input.placeholder = 'http://127.0.0.1:3080/oauth/callback?code=…&state=…';
+
+				const actions = document.createElement('div');
+				actions.className = 'wua-actions';
+				const submit = document.createElement('button');
+				submit.type = 'button';
+				submit.className = 'wua-btn';
+				submit.textContent = '完成登录';
+				actions.appendChild(submit);
+
+				const msg = document.createElement('p');
+				msg.style.display = 'none';
+
+				panel.appendChild(head);
+				panel.appendChild(hint);
+				panel.appendChild(input);
+				panel.appendChild(actions);
+				panel.appendChild(msg);
+				wrap.appendChild(fab);
+				wrap.appendChild(panel);
+				document.body.appendChild(wrap);
+
+				const show = (text, ok) => {
+					msg.textContent = text;
+					msg.className = ok ? 'wua-msg' : 'wua-err';
+					msg.style.display = 'block';
+				};
+				const setOpen = (open) => {
+					panel.style.display = open ? 'flex' : 'none';
+					fab.style.display = open ? 'none' : 'inline-flex';
+				};
+
+				fab.addEventListener('click', () => setOpen(true));
+				close.addEventListener('click', () => setOpen(false));
+				submit.addEventListener('click', () => {
+					const url = input.value.trim();
+					if (!url) { show('请粘贴完整回调地址', false); return; }
+					submit.disabled = true;
+					fetch('/dsh-webui-oauth/oauth-relay', {
+						method: 'POST',
+						headers: { 'content-type': 'application/json' },
+						body: JSON.stringify({ url }),
+					}).then((r) => {
+						if (r.status === 401) { location.href = '/dsh-webui-oauth/login'; return null; }
+						return r.json();
+					}).then((res) => {
+						submit.disabled = false;
+						if (!res) return;
+						if (res.ok) {
+							show('已收到回调，正在完成登录。请回到「设置 → 账号」查看状态。', true);
+							input.value = '';
+						} else {
+							show(res.hint || res.reason || res.error || '中转失败', false);
+						}
+					}).catch(() => {
+						submit.disabled = false;
+						show('无法连接认证服务', false);
+					});
+				});
+
+				ctx.effect(() => () => wrap.remove(), 'dsh-webui-oauth: relay widget');
+			})();
+
 			// ---------------- 会话失效：统一回登录页 ----------------
 			const LOGIN_PATH = '/dsh-webui-oauth/login';
 
@@ -156,11 +266,15 @@ window.__ModuleLoader__.load({
 				const [oidcBoundHint, setOidcBoundHint] = react.useState('');
 				const [unbindPw, setUnbindPw] = react.useState('');
 				const [bindMsg, setBindMsg] = react.useState(null);
-				// 官方 DeepSeek 登录的远程回调中转：粘贴浏览器地址栏里的回调 URL。
-				const [relayUrl, setRelayUrl] = react.useState('');
-				const [relayMsg, setRelayMsg] = react.useState(null);
-				const [relayBusy, setRelayBusy] = react.useState(false);
-				const [relayOpen, setRelayOpen] = react.useState(false);
+				// 敏感操作复验（保存配置 / 禁用 / 解绑）：密码或 SSO 一次性令牌。
+				const [saveOpen, setSaveOpen] = react.useState(false);
+				const [savePw, setSavePw] = react.useState('');
+				const [saveErr, setSaveErr] = react.useState('');
+				const [reauthToken, setReauthToken] = react.useState(null);
+				const [reauthExp, setReauthExp] = react.useState(0);
+				// 远程访问信任开关。
+				const [remoteTrustBusy, setRemoteTrustBusy] = react.useState(false);
+				const [remoteTrustMsg, setRemoteTrustMsg] = react.useState(null);
 				// 服务端算好的完整回调地址（含 scheme/host/port）。原生 OIDC 要求
 				// redirect_uri 与 IdP 登记值精确匹配，少一个字符都会被拒，所以要显示全。
 				const [oidcRedirectUri, setOidcRedirectUri] = react.useState('');
@@ -211,6 +325,19 @@ window.__ModuleLoader__.load({
 				// 读取 OIDC 回调带回来的回执。绑定/登录结束后浏览器会被 302 回应用，
 				// 结果通过 query 传递（oidcbound=1 / oidcerr=...）：因为是整页跳转，
 				// 组件重新挂载时才知道刚才发生了什么。
+				// 从 sessionStorage 恢复 SSO 复验令牌（2 分钟内有效）。
+				react.useEffect(() => {
+					try {
+						const raw = sessionStorage.getItem('dsh_wua_reauth')
+						if (!raw) return
+						const v = JSON.parse(raw)
+						if (v && typeof v.token === 'string' && v.exp > Date.now()) {
+							setReauthToken(v.token)
+							setReauthExp(v.exp)
+						}
+					} catch (e) { /* ignore */ }
+				}, []);
+
 				react.useEffect(() => {
 					let qs = ''
 					try { qs = String((location && location.search) || '') } catch (e) { qs = '' }
@@ -218,8 +345,14 @@ window.__ModuleLoader__.load({
 					const p = new URLSearchParams(qs)
 					const bound = p.get('oidcbound')
 					const err = p.get('oidcerr')
-					if (bound === null && err === null) return
-					if (bound !== null) {
+					const reauth = p.get('oidcreauth')
+					if (bound === null && err === null && reauth === null) return
+					if (reauth !== null) {
+						try { sessionStorage.setItem('dsh_wua_reauth', JSON.stringify({ token: reauth, exp: Date.now() + 120000 })) } catch (e) { /* ignore */ }
+						setReauthToken(reauth)
+						setReauthExp(Date.now() + 120000)
+						setBindMsg({ kind: 'ok', text: 'SSO 验证成功（2 分钟内有效）。请回到设置页点击「保存设置」。' })
+					} else if (bound !== null) {
 						setBindMsg({ kind: 'ok', text: 'OIDC 身份绑定成功。此后只有该身份可通过 SSO 登录。' })
 					} else {
 						const LABELS = {
@@ -247,8 +380,9 @@ window.__ModuleLoader__.load({
 					return { ok: true, text: '' };
 				}
 
-				const onSave = () => {
+				const onSave = (auth) => {
 					if (busy) return;
+					const credentials = auth || {};
 					const name = username.trim();
 					// 与服务端 usernameError 一致的用户名约束
 					if (!/^[A-Za-z0-9_-]{3,32}$/.test(name)) {
@@ -266,8 +400,8 @@ window.__ModuleLoader__.load({
 						setMsg({ kind: 'err', text: '两次输入的密码不一致' });
 						return;
 					}
-					if (enabled && !current) {
-						setMsg({ kind: 'err', text: '修改认证信息需要输入当前密码' });
+					if (enabled && !credentials.current && !credentials.reauthToken) {
+						setSaveErr('修改认证信息需要验证：请输入当前密码，或使用 SSO 验证。');
 						return;
 					}
 					setBusy(true);
@@ -285,7 +419,14 @@ window.__ModuleLoader__.load({
 					// OIDC 关闭时不能「仅允许 SSO」，否则等于关掉所有登录入口
 					ssoOnly: oidcEnabled ? oidcSsoOnly : false,
 				};
-				api('/dsh-webui-oauth/configure', { username: name, password, current, ttl: Number(ttl), oidc: oidcPayload }).then((r) => {
+				api('/dsh-webui-oauth/configure', {
+						username: name,
+						password,
+						current: credentials.current || '',
+						reauthToken: credentials.reauthToken || undefined,
+						ttl: Number(ttl),
+						oidc: oidcPayload,
+					}).then((r) => {
 						setBusy(false);
 						if (r && r.ok) {
 							if (enabled) {
@@ -296,24 +437,37 @@ window.__ModuleLoader__.load({
 							setPassword('');
 							setConfirm('');
 							setCurrent('');
+							setSaveOpen(false);
+							setSavePw('');
+							setSaveErr('');
+							setReauthToken(null);
+							setReauthExp(0);
+							try { sessionStorage.removeItem('dsh_wua_reauth') } catch (e) { /* ignore */ }
 							api('/dsh-webui-oauth/status').then((s) => {
 								if (s && !s.error) setStatus(s);
 							});
 						} else if (r && r.error === 'current-invalid') {
+							setSaveErr('当前密码不正确');
 							setMsg({ kind: 'err', text: '当前密码不正确' });
 						} else if (r && r.error === 'weak-password') {
-							setMsg({ kind: 'err', text: '密码强度不足：至少 8 位，需包含大小写字母、数字和特殊符号' });
+							const text = '密码强度不足：至少 8 位，需包含大小写字母、数字和特殊符号';
+							setMsg({ kind: 'err', text }); setSaveErr(text);
 						} else if (r && r.error === 'username-invalid') {
-							setMsg({ kind: 'err', text: '用户名需为 3-32 位字母、数字、下划线或连字符' });
+							const text = '用户名需为 3-32 位字母、数字、下划线或连字符';
+							setMsg({ kind: 'err', text }); setSaveErr(text);
 						} else if (r && r.error === 'legacy-hash') {
-							setMsg({ kind: 'err', text: '当前凭据为旧版哈希（0.2.0 起仅支持 scrypt），必须填写新密码才能保存' });
+							const text = '当前凭据为旧版哈希（0.2.0 起仅支持 scrypt），必须填写新密码才能保存';
+							setMsg({ kind: 'err', text }); setSaveErr(text);
 						} else if (r && (r.error === 'oidc-sso-only-unbound' || r.error === 'oidc-sso-only-invalid')) {
-							setMsg({ kind: 'err', text: (r && r.reason) || '无法启用「仅允许 SSO」' });
+							const text = (r && r.reason) || '无法启用「仅允许 SSO」';
+							setMsg({ kind: 'err', text }); setSaveErr(text);
 						} else if (r && typeof r.error === 'string') {
 							// 服务端 500/未知错误：展示真实信息便于排查
-							setMsg({ kind: 'err', text: '保存失败：' + r.error });
+							const text = '保存失败：' + r.error;
+							setMsg({ kind: 'err', text }); setSaveErr(text);
 						} else {
-							setMsg({ kind: 'err', text: '保存失败，请检查输入' });
+							const text = '保存失败，请检查输入';
+							setMsg({ kind: 'err', text }); setSaveErr(text);
 						}
 					}).catch(() => {
 						setBusy(false);
@@ -400,6 +554,7 @@ window.__ModuleLoader__.load({
 
 				const enabled = Boolean(status && status.enabled);
 				const remoteTrust = Boolean(status && status.remoteTrust);
+				const reauthValid = Boolean(reauthToken && Date.now() < reauthExp);
 				const intro = status === null
 					? '正在读取认证状态…'
 					: (enabled
@@ -439,28 +594,27 @@ window.__ModuleLoader__.load({
 					return d.getFullYear() + '-' + pad(d.getMonth() + 1) + '-' + pad(d.getDate()) + ' ' + pad(d.getHours()) + ':' + pad(d.getMinutes());
 				}
 
-				const onRelay = () => {
-					if (relayBusy) return;
-					const url = relayUrl.trim();
-					if (!url) {
-						setRelayMsg({ kind: 'err', text: '请粘贴浏览器地址栏里的完整回调地址（http://127.0.0.1:<端口>/oauth/callback?...）' });
-						return;
-					}
-					setRelayBusy(true);
-					setRelayMsg(null);
-					api('/dsh-webui-oauth/oauth-relay', { url }).then((r) => {
-						setRelayBusy(false);
+				const onToggleRemoteTrust = () => {
+					if (remoteTrustBusy) return;
+					const next = !remoteTrust;
+					setRemoteTrustBusy(true);
+					setRemoteTrustMsg(null);
+					api('/dsh-webui-oauth/remote-trust', { enabled: next }).then((r) => {
+						setRemoteTrustBusy(false);
 						if (r && r.ok) {
-							setRelayMsg({ kind: 'ok', text: '已收到回调，正在完成登录。请回到「设置 → 账号」查看登录状态。' });
-							setRelayUrl('');
-						} else if (r && r.error === 'no-pending') {
-							setRelayMsg({ kind: 'err', text: (r && r.hint) || '没有进行中的登录：请先在「设置 → 账号」点击 DeepSeek 登录。' });
+							setStatus((s) => (s ? { ...s, remoteTrust: !!r.enabled } : s));
+							setRemoteTrustMsg({
+								kind: 'ok',
+								text: r.enabled
+									? '已开启远程访问信任。刷新页面后生效（设置 → 模型应可正常加载）。'
+									: '已关闭远程访问信任。刷新页面后生效。',
+							});
 						} else {
-							setRelayMsg({ kind: 'err', text: (r && (r.hint || r.error)) || '回调中转失败，请重试' });
+							setRemoteTrustMsg({ kind: 'err', text: (r && (r.reason || r.error)) || '操作失败' });
 						}
 					}).catch(() => {
-						setRelayBusy(false);
-						setRelayMsg({ kind: 'err', text: '无法连接认证服务' });
+						setRemoteTrustBusy(false);
+						setRemoteTrustMsg({ kind: 'err', text: '无法连接认证服务' });
 					});
 				};
 
@@ -520,9 +674,6 @@ window.__ModuleLoader__.load({
 							react.createElement('input', { className: 'wua-input', type: 'password', value: current, onChange: (e) => setCurrent(e.target.value) }),
 						) : null,
 						msg ? react.createElement('div', { className: msg.kind === 'ok' ? 'wua-msg' : 'wua-err' }, msg.text) : null,
-						react.createElement('div', { className: 'wua-actions' },
-							react.createElement('button', { className: 'wua-btn', disabled: busy || status === null, onClick: onSave }, busy ? '保存中…' : '保存账号密码'),
-						),
 					]),
 					card('OIDC 单点登录', [
 						oidcEnabled ? badge('已启用', 'ok') : badge('未启用', 'muted'),
@@ -616,15 +767,20 @@ window.__ModuleLoader__.load({
 					], [
 						react.createElement('p', { className: 'wua-intro' },
 							remoteTrust
-								? '已通过 index.html 注入 __DSH_TRANSPORT__.ownsHost = true，反代域名下「设置 → 模型」可正常读取。'
-								: '若经域名反代访问时「设置 → 模型」报 settings are unavailable in this browser，请在 dsh settings 的 remote-web-ui 段设置 trustRemoteHost: true 并重启。'),
+								? '已通过 index.html 注入 __DSH_TRANSPORT__.ownsHost = true，反代域名下「设置 → 模型」可正常读取。刷新页面后生效。'
+								: '若经域名反代访问时「设置 → 模型」报 settings are unavailable in this browser，可开启远程访问信任。'),
+						react.createElement('div', { className: 'wua-actions' },
+							react.createElement('button', {
+								className: 'wua-btn',
+								disabled: remoteTrustBusy || status === null,
+								onClick: onToggleRemoteTrust,
+							}, remoteTrustBusy ? '处理中…' : (remoteTrust ? '关闭远程访问信任' : '开启远程访问信任')),
+						),
+						remoteTrustMsg ? react.createElement('p', { className: remoteTrustMsg.kind === 'ok' ? 'wua-msg' : 'wua-err' }, remoteTrustMsg.text) : null,
 						react.createElement('div', { className: 'wua-sep' }),
 						react.createElement('h4', { className: 'wua-card-title' }, 'DeepSeek 官方账号登录（远程回调）'),
 						react.createElement('p', { className: 'wua-hint', style: { borderTop: 'none', paddingTop: 0 } },
-							'在「设置 → 账号」点击 DeepSeek 登录后，浏览器会跳到 127.0.0.1 的回调地址（远程机器上通常打不开）。点下面的按钮打开中转窗口，把地址栏里的完整 URL 粘贴进去即可。'),
-						react.createElement('div', { className: 'wua-actions' },
-							react.createElement('button', { className: 'wua-btn', disabled: status === null, onClick: () => setRelayOpen(true) }, '打开回调中转窗口'),
-						),
+							'在「设置 → 账号」点击 DeepSeek 登录后，浏览器会跳到 127.0.0.1 的回调地址（远程机器上通常打不开）。点右下角的「DeepSeek 登录回调」悬浮按钮，把地址栏里的完整 URL 粘贴进去即可。'),
 					]),
 					card('最近登录记录', [], [
 						react.createElement('p', { className: 'wua-hint', style: { borderTop: 'none', paddingTop: 0 } },
@@ -642,16 +798,42 @@ window.__ModuleLoader__.load({
 									)),
 								)),
 					]),
-					relayOpen ? react.createElement('div', { className: 'wua-float' },
-						react.createElement('div', { className: 'wua-float-head' },
-							react.createElement('span', { className: 'wua-float-title' }, 'DeepSeek 登录回调中转'),
-							react.createElement('button', { className: 'wua-btn ghost', onClick: () => setRelayOpen(false) }, '关闭')),
-						react.createElement('p', { className: 'wua-hint', style: { borderTop: 'none', paddingTop: 0 } },
-							'把浏览器地址栏里的完整回调 URL 粘贴到这里。只接受 http://127.0.0.1 或 localhost 的本机端口地址。'),
-						react.createElement('input', { className: 'wua-input', type: 'text', value: relayUrl, spellCheck: false, placeholder: 'http://127.0.0.1:3080/oauth/callback?code=…&state=…', onChange: (e) => setRelayUrl(e.target.value) }),
-						react.createElement('div', { className: 'wua-actions' },
-							react.createElement('button', { className: 'wua-btn', disabled: relayBusy, onClick: onRelay }, relayBusy ? '提交中…' : '完成登录')),
-						relayMsg ? react.createElement('p', { className: relayMsg.kind === 'ok' ? 'wua-msg' : 'wua-err' }, relayMsg.text) : null,
+					react.createElement('button', {
+						className: 'wua-save-fab',
+						disabled: busy || status === null,
+						onClick: () => {
+							if (!enabled) { onSave({}); return; }
+							if (reauthValid) { onSave({ reauthToken }); return; }
+							setSaveErr('');
+							setSaveOpen(true);
+						},
+					}, busy ? '保存中…' : '保存设置'),
+					saveOpen ? react.createElement('div', { className: 'wua-modal-mask' },
+						react.createElement('div', { className: 'wua-modal' },
+							react.createElement('h4', { className: 'wua-card-title' }, '验证后保存'),
+							react.createElement('p', { className: 'wua-hint', style: { borderTop: 'none', paddingTop: 0 } },
+								reauthValid
+									? '已通过 SSO 验证（2 分钟内有效），可直接保存。'
+									: '修改认证配置需要验证当前身份：输入当前密码，或使用 SSO 验证。'),
+							reauthValid ? null : react.createElement('div', { className: 'wua-row' },
+								react.createElement('label', { className: 'wua-label' }, '当前密码'),
+								react.createElement('input', { className: 'wua-input', type: 'password', value: savePw, autoComplete: 'current-password', onChange: (e) => setSavePw(e.target.value) }),
+							),
+							saveErr ? react.createElement('p', { className: 'wua-err' }, saveErr) : null,
+							react.createElement('div', { className: 'wua-actions' },
+								react.createElement('button', { className: 'wua-btn', disabled: busy, onClick: () => {
+									if (reauthValid) { onSave({ reauthToken }); return; }
+									if (!savePw) { setSaveErr('请输入当前密码'); return; }
+									onSave({ current: savePw });
+								} }, busy ? '保存中…' : '验证并保存'),
+								react.createElement('button', { className: 'wua-btn ghost', disabled: busy, onClick: () => setSaveOpen(false) }, '取消'),
+							),
+							(status && status.oidc && status.oidc.enabled && status.oidc.bound)
+								? react.createElement('button', { className: 'wua-btn ghost', disabled: busy, onClick: () => {
+									location.href = '/dsh-webui-oauth/oidc/reauth?base=' + encodeURIComponent(location.origin || '');
+								} }, '使用 SSO 验证')
+								: null,
+						),
 					) : null,
 					react.createElement('p', { className: 'wua-hint' },
 						'密码规则：至少 8 位，必须包含大写字母、小写字母、数字和特殊符号（如 !@#$%^&*）。认证在 HTTP/传输层强制执行（WebUI 资源、/api 接口、WebSocket 全部要求有效会话），会话保存在服务端并由 HttpOnly Cookie 携带，修改密码会吊销其他所有会话。凭据以 scrypt 哈希保存在插件目录的 dsh-webui-auth.json（0.2.0 起仅接受 scrypt，旧版 SHA-256 凭据需删除该文件重新创建）；忘记密码时删除该文件并重启 DSH 即可重置。可选用 OIDC 单点登录：配置 issuer/clientId/clientSecret 后登录页出现 SSO 按钮，认证通过后以 IdP 的 sub 作为本地会话用户名，并沿用相同的免登录时长机制。'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-webui-oauth",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "type": "module",
   "main": "index.js",
   "scripts": {