dsh-webui-oauth 0.6.9 → 0.7.1

package/CHANGELOG.md

@@ -2,6 +2,87 @@
 
 本文件记录每个版本的**用户可见**变更。破坏性变更与升级动作单独标注。
 
+## 0.7.1
+
+兼容 dsh **0.2.2-rc.1**：`webServer.fallback` 从函数改成了 `{ resource }`。
+
+### 修复：访问 `/` 返回 500 空响应（nginx 日志 `500 0`）
+
+- **现象**：升级到 dsh 0.2.2-rc.1 后，访问 `/` 在完成核心 token 交换后返回
+  `500`，body 为空；nginx 访问日志表现为 `500 0`。
+- **原因**：0.2.2-rc.1 起 `webServer.fallback` 不再一定是函数——
+  `dsh-host-frontend-static` 注册的是 `{ resource }`（Fetch 风格
+  `resource(request, peer) -> Response`）。插件仍按 `await fallback(req, res)`
+  调用，抛 `TypeError: fallback is not a function`，被外层 `catch` 兜成
+  `500` + 空 body。
+- **修复**：新增 `serveFallback()` 统一分派三种形状：
+  1. 函数（旧核心）；
+  2. `{ resource }` + `webServer.serveResource`（0.2.2-rc.1+）；
+  3. `{ handler }`（部分中间版本）。
+  没有 fallback 时返回 `false`，由调用方 404——不再把"形状不匹配"误报成 500。
+
+### 安全：资源型 fallback 也必须上闸门
+
+此前 `wrapExistingFallback` 只处理 `typeof === 'function'`，遇到 `{ resource }`
+直接跳过，等于把兜底入口留给匿名请求。现在：
+
+- `resource(request, peer)` 会被包装：从 Fetch Request 的 `cookie` 头取会话，
+  未登录返回 `401 Response`，已登录原样放行；
+- `registerFallback` 注册时的三种形状都会在注册那一刻上闸门；
+- `undo` 会把 `resource` / `handler` 原样还原。
+
+### 测试
+
+- 新增 `test/fallback-shape.test.mjs`（19 项）：三种形状分派、无 fallback /
+  未知形状 / 缺 `serveResource` 均不抛异常、资源型 fallback 的匿名拒绝与
+  登录放行、`undo` 还原。
+- 全量 18 个测试文件、488 项断言通过。
+
+## 0.7.0
+
+新增**「仅允许 SSO」**开关；同时修复一个会把 OIDC 绑定悄悄弄丢的老问题。
+
+### 新增：仅允许 SSO（设置 → 身份认证 → OIDC）
+
+勾选后：
+
+- **未登录访问 WebUI** 一律 `302` 到 SSO 入口（`/dsh-webui-oauth/oidc/login`），
+  不再显示密码表单；跳转自动带上浏览器侧 origin，兼容 `trustBrowserOrigin` 部署。
+- **密码登录接口被禁用**：`POST /dsh-webui-oauth/login` 返回 `403`
+  `{"ok":false,"error":"sso-only"}`，并记一条 `login_failure` 审计
+  （detail 标明"已启用仅允许 SSO"）。
+- 登录页本身也做了兜底：即使页面被缓存/手动回退，也只显示 SSO 按钮。
+
+**防锁死校验**（服务端强制，不只是前端）：
+
+| 条件 | 结果 |
+|---|---|
+| 未启用 OIDC | 拒绝保存 |
+| Issuer / Client ID / Client Secret 不全 | 拒绝保存 |
+| 尚未绑定 OIDC 身份 | 拒绝保存（`oidc-sso-only-unbound`） |
+| 已启用「仅允许 SSO」时解绑 | 拒绝（`sso-only-active`），要求先关开关 |
+
+运行时生效值还要求"OIDC 已启用 **且** 已绑定"：若绑定因任何原因消失（手工改文件、
+旧数据），自动退回密码登录，不会把唯一入口切成必然失败的跳转。
+
+**被锁在门外怎么恢复**：编辑数据目录的 `dsh-webui-oauth.json`，把
+`"ssoOnly": true` 改为 `false`。后台定时器每 60 秒重读一次配置，无需重启；
+也可以直接重启。
+
+### 修复：保存设置会把 OIDC 绑定弄丢
+
+`configure` 重建凭据对象时只写了 `{ v, username, hash, ttl }`，把 `boundSub`
+一并丢掉——等于"每次保存设置都静默解绑"。这个问题在启用「仅允许 SSO」时会
+直接导致开关失效（保存后绑定没了 → 自动退回密码登录）。现在原样保留 `boundSub`，
+并加回归断言锁住。
+
+### 测试
+
+- `test/oidc-bind.test.mjs` 新增 17 项：未绑定拒绝启用、已绑定可启用、
+  `boundSub` 不丢、status 回显、登录页 302 + base、密码登录 403、
+  禁止解绑、关闭后全部恢复。
+- 全量 17 个测试文件、469 项断言通过。
+
 ## 0.6.9
 
 会话体验补齐：**已登录访问登录页直接回首页**；**会话失效时页面跳登录、接口返回 401 并由前端跳登录**。

package/README.en.md

@@ -118,6 +118,21 @@ Authentication is enforced in four layers, all implemented by **wrapping the web
     Only absolute paths starting with `/` and free of whitespace/control characters are accepted; anything undeclared is denied. Changes take effect on the next scan (≤10s) without a restart. **The built-in allowlist contains only the five paths required for login / the OIDC round trip** — do not add business endpoints unless they verify a signature or state themselves.
   - **Host-rewriting reverse proxies**: when the proxy rewrites `Host` to a loopback address (`127.0.0.1:3080`, `::1`, `localhost`, `0.0.0.0`) and sends nothing else, the plugin **cannot** recover the browser-side address from the request, so it treats the address as proxy-rewritten and uses the configured `publicBaseUrl` directly (the legacy "declare the public address in settings.yaml" advice was ineffective in that shape, because `publicBaseUrl` was only trusted on an exact Host match). If the proxy can send the original host, `X-Forwarded-Host` (or RFC 7239 `Forwarded: host=`) is preferred over the request Host for building the redirect.
 - **Optional OIDC SSO (0.4.0; identity binding required since 0.6.0)**: standards-based authorization-code + PKCE with a **confidential client (client_secret required)**, security-benchmarked against Logto. **Configuring OIDC does not mean anyone can log in**: you must first bind one IdP identity. Until then OIDC login is refused outright and the login page hides the SSO button (see the next bullet). Once bound, the login page shows an "SSO single sign-on" button; after IdP authentication the plugin creates a local session keyed by the IdP `sub` (reusing the session TTL and persistence).
+- **SSO only (0.7.0)**: under Settings → Authentication → OIDC, tick "仅允许 SSO":
+  - unauthenticated visits are `302`-redirected to the SSO entry (carrying the browser-side
+    origin) instead of showing the password form;
+  - `POST /dsh-webui-oauth/login` is disabled and answers
+    `403 {"ok":false,"error":"sso-only"}`;
+  - **an OIDC identity must already be bound**, otherwise saving is refused
+    (`oidc-sso-only-unbound`) — the only entrance is never swapped for a path that cannot work;
+  - **unbinding is refused** while the switch is on (`sso-only-active`), so the operator must
+    turn it off first;
+  - at runtime it also requires "OIDC enabled **and** bound"; if the binding disappears the
+    plugin automatically falls back to password login.
+
+  **Locked out?** Edit `dsh-webui-oauth.json` in the data directory and set
+  `"ssoOnly": false`. The background timer re-reads the config every 60 seconds, so no
+  restart is required (a restart also works).
 - **OIDC identity binding / unbinding (0.6.0)**: binding = log in with the local account, then click "绑定 OIDC 身份" under **Settings → Authentication → OIDC identity binding** and complete one IdP authorization; the verified `sub` is stored in the credentials file (`boundSub`), and **only that identity** can then log in via SSO. Unbinding = click "解除绑定" (current password required); once cleared, SSO login immediately reverts to "refuse everything". The settings page only ever shows a masked sub (e.g. `su*****ce`). A credentials file without `boundSub` counts as unbound, so upgrading never opens access. The **redirect_uri base is set by `oidc.redirectBase`**; by default the browser is trusted (it trusts the front-end `location.origin` — under a host-rewriting reverse proxy the browser's public address is correct), ****constrained by the unifed switch above****; when disabled only the configured `redirectBase` is used; if neither is available it fails closed with an error. id_token signatures support **RSA (RS256/384/512, PS256/384/512), EC (ES256/384/512) and EdDSA (Ed25519)**, with iss/aud/exp/iat/nbf/nonce and JWKS(kid) validation (see "Signature algorithm support" below). Logout is the simple variant: it clears the local session only.
 - **Scheme-adaptive post-login redirect (0.3.3, fixes #6 / #7)**: after a successful login the plugin sends the browser to the core's token-bearing root URL. Its **authority now comes from the request Host** (no longer hardcoded to `127.0.0.1`) and its **scheme follows the protocol the request actually used**, resolved in this order: ① the operator's explicit `remote-web-ui.publicBaseUrl` (**trusted only when its host/port matches the incoming Host** — otherwise a LAN direct hit would be redirected to the public address and lose the freshly issued session cookie to a cross-origin hop); ② the standard proxies headers `X-Forwarded-Proto` (leftmost value) or RFC 7239 `Forwarded: proto=`; ③ a TLS-terminating socket (`socket.encrypted`); ④ fallback `http`. It deliberately does **not** guess "non-IP hostname ⇒ https", which would turn plain-http intranet access (`http://nas.local:3080`) into a dead https link. The login page adds a one-way client-side fallback: an https page receiving a **same-origin** `http://` redirect upgrades it to `https://` (never downgrades, never rewrites another origin).
 
@@ -386,6 +401,7 @@ wired into `npm test`).
 
 ## Known limits
 
+- **Fallback shape on dsh 0.2.2-rc.1**: since that version `webServer.fallback` may be `{ resource }` (that is how `dsh-host-frontend-static` registers it) instead of a function. The plugin now handles function / `{ resource }` / `{ handler }`; a resource fallback is gated as well. If `/` returns an empty `500` after upgrading (nginx logs `500 0`), make sure the plugin is ≥ 0.7.1.
 - **Inherent runtime-wrapping window**: between a route-object replacement (service hot-reload) and the next rescan (≤10s) there is an unprotected window; the fail-closed check on enabling covers the "initially exposed" case, so this window only affects hot-reload during runtime.
 - **WebSocket and `trustedHosts`**: in reverse-proxy / LAN deployments (non-loopback Host), WS downlinks need the public hostname added to `client-connection.trustedHosts` in the DSH config (see "Architecture").
 - **Proxy on a different host**: if the reverse proxy is not on the same machine as DSH (non-loopback peer), the proxy headers are not trusted and rate limiting aggregates per proxy IP (degrades to a global bucket).

package/README.md

@@ -137,6 +137,16 @@ DSH WebUI 身份认证插件（持久化插件）。在「设置 → 身份认
   **已知取舍**：本机浏览器直连 `http://127.0.0.1:3080` 也落进第 2 行，于是开关开着也会跳 `publicBaseUrl`。要同时支持本机直连，只能让反代下发 `X-Forwarded-Host`（走第 1 行）。
 - **登录后跳转的协议自适应（0.3.3，修 #6 / #7）**：插件登录成功后要把浏览器引导到核心的带 token 根地址，其 **authority 取自本次请求的 Host**（不再写死 `127.0.0.1`），**scheme 按请求实际协议解析**，优先级：① 操作者显式声明 `remote-web-ui.publicBaseUrl`（**仅当其 host/port 与本次请求 Host 一致时**采信——否则局域网直连会被重定向到公网地址、跨源丢掉刚下发的会话 Cookie）；② 标准代理头 `X-Forwarded-Proto`（取最左值）或 RFC 7239 `Forwarded: proto=`；③ socket 自身是 TLS（插件直接终结 TLS）；④ 兜底 `http`。**刻意不做「非 IP 域名即 https」的猜测**——那会把纯 http 的内网域名访问（`http://nas.local:3080`）打成 https 死链。前端登录页另有一层单向兜底：页面在 https 下收到**同源** `http://` 跳转时自动升级为 `https://`（反向不降级、异源不改写）。
 - **可选 OIDC 单点登录（0.4.0；0.6.0 起需绑定身份）**：标准 OIDC 授权码 + PKCE（机密客户端，须 `client_secret`），以 Logto 为安全基准。**配置 OIDC ≠ 谁都能登录**：必须先绑定一个 IdP 身份，绑定前 OIDC 登录一律拒绝、登录页也不显示 SSO 按钮（见下条）。绑定后登录页出现「SSO 单点登录」按钮，认证通过后以 IdP 的 `sub` 建立本地会话（沿用会话有效期与持久化）。
+- **仅允许 SSO（0.7.0）**：设置 → 身份认证 → OIDC 勾选「仅允许 SSO」后：
+  - 未登录访问 WebUI 一律 `302` 到 SSO 入口（带浏览器侧 origin），不再显示密码表单；
+  - `POST /dsh-webui-oauth/login` 被禁用，返回 `403 {"ok":false,"error":"sso-only"}`；
+  - **启用前必须已绑定 OIDC 身份**，否则拒绝保存（`oidc-sso-only-unbound`）——
+    避免把唯一入口换成一条走不通的路；
+  - 启用期间**禁止解绑**（`sso-only-active`），要求先关开关，防止锁死；
+  - 运行时还要求「OIDC 已启用且已绑定」，绑定若意外消失会自动退回密码登录。
+
+  **被锁在门外**：编辑数据目录的 `dsh-webui-oauth.json`，把 `"ssoOnly": true` 改为
+  `false`；后台每 60 秒重读一次配置，无需重启（重启也可）。
 - **OIDC 身份绑定 / 解绑（0.6.0）**：绑定 = 本地账号登录后在**设置 → 身份认证 → OIDC 身份绑定**点「绑定 OIDC 身份」，走一次 IdP 授权，校验通过的 `sub` 存入凭据文件（`boundSub`）；**此后只有该身份能通过 SSO 登录**。解绑 = 点「解除绑定」（需当前密码），清空后 SSO 登录立即恢复为「一律拒绝」。设置页只显示掩码后的 sub（如 `su*****ce`）。旧凭据文件无 `boundSub` 字段时视为未绑定（升级不会放开访问）。**redirect_uri 的 base 由 `oidc.redirectBase` 决定；默认交由浏览器处理（采信前端 `location.origin`，反代重写 Host 时浏览器看到的公网地址即正确），受上面统一开关约束；关闭时仅用配置的 `redirectBase`；两者都不可用则 fail-closed 报错。** id_token 签名支持 **RSA（RS256/384/512、PS256/384/512）、EC（ES256/384/512）、EdDSA（Ed25519）**，配合 iss/aud/exp/iat/nbf/nonce 与 JWKS(kid) 校验（见下节「签名算法支持」）。登出为简单版：仅清本地会话。
 
 会话为**服务端会话，持久化到磁盘**（`sessions.jsonl`，重启 DSH 不掉线，到期自动失效），由 `HttpOnly; SameSite=Lax` Cookie（`dsh_wua_session`）携带，JS 无法读取；修改密码会**吊销所有其他会话**。
@@ -401,6 +411,7 @@ IdP 侧日志确认完整往返：`discovery → jwks → authorize(issued code)
 
 ## 已知边界
 
+- **dsh 0.2.2-rc.1 的 fallback 形状**：该版本起 `webServer.fallback` 可能是 `{ resource }`（`dsh-host-frontend-static` 就是这样注册的），而不再是函数。插件已兼容函数 / `{ resource }` / `{ handler }` 三种形状；资源型 fallback 同样会被闸门包装。若升级后 `/` 返回 `500` 且 body 为空（nginx 日志 `500 0`），请确认插件版本 ≥ 0.7.1。
 - **运行时包装的固有窗口**：路由对象被替换（服务热重载）到下一次重扫之间（≤10s）存在未保护窗口；启用认证时的 fail-closed 已挡住「初始裸奔」，此窗口仅影响运行中的热重载场景。
 - **WS 与 trustedHosts**：反代/局域网（非回环 Host）下，WS 下行需在 dsh 配置 `client-connection.trustedHosts` 中加入对外域名（见「架构」节）。
 - **反代不同机**：若反代与 DSH 不在同一台机器（对端非回环），代理头不被信任，限流将按代理 IP 聚合（退化为全局桶）。

package/index.js

@@ -919,7 +919,7 @@ const LOGIN_PAGE = `<!DOCTYPE html>
       <label for="t">初始化令牌（见 dsh 启动日志）</label>
       <input id="t" type="password" autocomplete="off" spellcheck="false">
     </div>
-    <label for="u">用户名</label>
+    <label for="u" id="ul">用户名</label>
     <input id="u" type="text" autocomplete="username" autofocus spellcheck="false">
     <label for="p" id="pl">密码</label>
     <input id="p" type="password" autocomplete="current-password">
@@ -939,8 +939,10 @@ const LOGIN_PAGE = `<!DOCTYPE html>
 <script>
 var MODE = "__MODE__";
 var OIDC_ENABLED = "__OIDC_ENABLED__";
+var SSO_ONLY = "__SSO_ONLY__";
 var sub = document.getElementById('sub'), pl = document.getElementById('pl'), pc = document.getElementById('pc'), e = document.getElementById('e'),
   u = document.getElementById('u'), p = document.getElementById('p'), p2 = document.getElementById('p2'), b = document.getElementById('b'),
+  ul = document.getElementById('ul'),
   f = document.getElementById('f'), t = document.getElementById('t'), tokenrow = document.getElementById('tokenrow'),
   ssorow = document.getElementById('ssorow'), sso = document.getElementById('sso');
 function show(msg) { e.textContent = msg; e.style.display = 'block'; }
@@ -950,6 +952,8 @@ if (MODE === 'setup') {
   pl.textContent = '密码（至少 8 位，含大小写、数字、特殊符号）';
   pc.style.display = 'block';
   b.textContent = '创建账号';
+} else if (SSO_ONLY === 'true') {
+  sub.textContent = '此部署已启用「仅允许 SSO」，请使用 SSO 单点登录。';
 } else {
   sub.textContent = '此界面已启用身份认证，请登录后继续使用。';
 }
@@ -958,6 +962,19 @@ if (MODE === 'setup') {
 if (OIDC_ENABLED === 'true' && MODE === 'login') {
   ssorow.style.display = 'block';
 }
+// 仅允许 SSO：把密码表单整体收起，只留 SSO 按钮。
+// 正常情况下服务端在 GET 阶段就 302 到 SSO 了，这里是兜底（例如配置刚改、
+// 页面被缓存，或用户手动回退到本页）。
+if (SSO_ONLY === 'true' && MODE === 'login') {
+  ul.style.display = 'none';
+  u.style.display = 'none';
+  pl.style.display = 'none';
+  p.style.display = 'none';
+  b.style.display = 'none';
+  tokenrow.style.display = 'none';
+  pc.style.display = 'none';
+  ssorow.style.display = 'block';
+}
 if (sso) {
   sso.addEventListener('click', function () {
     var base = location.origin || '';
@@ -1137,6 +1154,41 @@ function wantsHtml(req) {
   }
 }
 
+/**
+ * 把请求交给 webServer 的 fallback。
+ *
+ * 0.2.2-rc.1 起 fallback 不再一定是函数：dsh-host-frontend-static 注册的是
+ * `{ resource }`（Fetch 风格的 `resource(request, peer) -> Response`）。
+ * 旧代码直接 `await fallback(req, res)` 会抛 TypeError（fallback is not a function），
+ * 被外层 catch 兜成 `500` + 空 body——nginx 访问日志里就是 `500 0`。
+ *
+ * 这里统一三种形状：
+ *   1. 函数（旧核心 / 第三方 handler）；
+ *   2. `{ resource }` + webServer.serveResource（0.2.2-rc.1+）；
+ *   3. `{ handler }`（部分中间版本）。
+ *
+ * @returns {Promise<boolean>} 是否已由 fallback 处理；false 表示没有 fallback，
+ *   调用方应自行返回 404（不要把"没有 fallback"误报成 500）。
+ */
+export async function serveFallback(ctx, req, res) {
+  const ws = ctx && ctx.webServer
+  if (!ws) return false
+  const fallback = ws.fallback
+  if (typeof fallback === 'function') {
+    await fallback(req, res)
+    return true
+  }
+  if (fallback && typeof fallback.resource === 'function' && typeof ws.serveResource === 'function') {
+    await ws.serveResource(req, res, new URL(req.url || '/', 'http://x'), fallback.resource)
+    return true
+  }
+  if (fallback && typeof fallback.handler === 'function') {
+    await fallback.handler(req, res)
+    return true
+  }
+  return false
+}
+
 function rejectUpgrade401(socket) {
   try {
     socket.write('HTTP/1.1 401 Unauthorized\r\nConnection: close\r\nContent-Length: 13\r\n\r\nunauthorized\n')
@@ -1204,7 +1256,18 @@ function detectOriginalPlugin(ctx) {
  * 检查读取。
  * @returns {{ ok: () => boolean, problems: () => string[], undo: () => void }}
  */
-function installRouteGate(ctx, checkRequest, log) {
+function installRouteGate(ctx, checkRequest, log, options) {
+  // 未登录时把浏览器送到哪里：默认密码登录页；「仅允许 SSO」时由调用方
+  // 传入的 loginLocation(req) 改送 SSO 入口（并带上浏览器侧 origin）。
+  const loginLocation = (req) => {
+    try {
+      if (options && typeof options.loginLocation === 'function') {
+        const target = options.loginLocation(req)
+        if (typeof target === 'string' && target) return target
+      }
+    } catch (e) { /* 回退到默认登录页 */ }
+    return LOGIN_PATH
+  }
   const ws = ctx.webServer
   const problems = new Set()
   const undos = []
@@ -1242,7 +1305,7 @@ function installRouteGate(ctx, checkRequest, log) {
         // 不区分会导致两种坏体验：页面变成裸文本，或 fetch 跟随 302 拿到 HTML
         // 后 JSON 解析失败。
         if ((req.method === 'GET' || req.method === 'HEAD') && wantsHtml(req)) {
-          res.writeHead(302, { location: '/dsh-webui-oauth/login', 'cache-control': 'no-store' })
+          res.writeHead(302, { location: loginLocation(req), 'cache-control': 'no-store' })
           res.end()
           return
         }
@@ -1345,7 +1408,12 @@ function installRouteGate(ctx, checkRequest, log) {
   // ---------------- fallback 也要包 ----------------
   // fallback 是"未被任何具名路由认领"的兜底处理器。它同样可能被第三方插件占据，
   // 若不管，攻击者只要找到一个不存在的路径就可能落到未鉴权的 fallback 上。
-  const wrappedFallbacks = new WeakSet()
+  //
+  // 0.2.2-rc.1 起 fallback 还可能是 { resource }（Fetch 风格）：既不能当函数调用
+  // （TypeError），也不能放任它绕过闸门。两种形状分别包装。
+  const wrappedFallbacks = new WeakSet()   // 原始 handler 函数
+  const wrappedResources = new WeakSet()   // 原始 resource 函数
+
   const gateFallback = (handler) => {
     if (typeof handler !== 'function' || wrappedFallbacks.has(handler)) return handler
     const original = handler
@@ -1357,23 +1425,71 @@ function installRouteGate(ctx, checkRequest, log) {
       }
       return original(req, res)
     }
-    wrappedFallbacks.add(gated)
+    wrappedFallbacks.add(original)
     fallbackWrapped = true
     log('wrapped fallback handler')
     return gated
   }
 
-  // 已经就位的 fallback：直接替换属性（保留原函数以便 undo）。
+  const gateResource = (resource) => {
+    if (typeof resource !== 'function' || wrappedResources.has(resource)) return resource
+    const original = resource
+    const gated = async (request, peer) => {
+      // resource 收到的是 Fetch Request；checkRequest 只依赖 cookie 头。
+      const cookie = request && request.headers && typeof request.headers.get === 'function'
+        ? (request.headers.get('cookie') || '')
+        : ''
+      const headers = { cookie }
+      if (!checkRequest({ method: request && request.method, url: request && request.url, headers })) {
+        return new Response('unauthorized', {
+          status: 401,
+          headers: { 'content-type': 'text/plain; charset=utf-8' },
+        })
+      }
+      return original(request, peer)
+    }
+    wrappedResources.add(original)
+    fallbackWrapped = true
+    log('wrapped fallback resource')
+    return gated
+  }
+
+  // 已经就位的 fallback：按形状替换（保留原值以便 undo）。
   const wrapExistingFallback = () => {
     const current = ws.fallback
-    if (typeof current !== 'function') return
-    if (wrappedFallbacks.has(current)) return
-    if (current.__dshWuaGated === true) return
-    const gated = gateFallback(current)
-    if (gated === current) return
-    gated.__dshWuaGated = true
-    ws.fallback = gated
-    undos.push(() => { if (ws.fallback === gated) ws.fallback = current })
+    if (typeof current === 'function') {
+      if (wrappedFallbacks.has(current)) return
+      if (current.__dshWuaGated === true) return
+      const gated = gateFallback(current)
+      if (gated === current) return
+      gated.__dshWuaGated = true
+      ws.fallback = gated
+      undos.push(() => { if (ws.fallback === gated) ws.fallback = current })
+      return
+    }
+    if (current && typeof current === 'object') {
+      if (typeof current.resource === 'function') {
+        if (wrappedResources.has(current.resource)) { fallbackWrapped = true; return }
+        if (current.resource.__dshWuaGated === true) return
+        const original = current.resource
+        const gated = gateResource(original)
+        if (gated === original) return
+        gated.__dshWuaGated = true
+        current.resource = gated
+        undos.push(() => { if (current.resource === gated) current.resource = original })
+        return
+      }
+      if (typeof current.handler === 'function') {
+        if (wrappedFallbacks.has(current.handler)) { fallbackWrapped = true; return }
+        if (current.handler.__dshWuaGated === true) return
+        const original = current.handler
+        const gated = gateFallback(original)
+        if (gated === original) return
+        gated.__dshWuaGated = true
+        current.handler = gated
+        undos.push(() => { if (current.handler === gated) current.handler = original })
+      }
+    }
   }
 
   // ---------------- 注册时即拦截（消除重扫窗口） ----------------
@@ -1404,8 +1520,28 @@ function installRouteGate(ctx, checkRequest, log) {
   // registerFallback 走的是属性赋值而非 Map，单独接管。
   if (typeof ws.registerFallback === 'function') {
     const originalRegisterFallback = ws.registerFallback
-    ws.registerFallback = function patchedRegisterFallback (handler) {
-      return originalRegisterFallback.call(this, gateFallback(handler))
+    ws.registerFallback = function patchedRegisterFallback (fallback) {
+      // 三种形状都要上闸门：函数 / { resource } / { handler }。
+      try {
+        if (typeof fallback === 'function') {
+          fallback = gateFallback(fallback)
+        } else if (fallback && typeof fallback === 'object') {
+          if (typeof fallback.resource === 'function' && !wrappedResources.has(fallback.resource)) {
+            const gated = gateResource(fallback.resource)
+            if (gated !== fallback.resource) {
+              gated.__dshWuaGated = true
+              fallback.resource = gated
+            }
+          } else if (typeof fallback.handler === 'function' && !wrappedFallbacks.has(fallback.handler)) {
+            const gated = gateFallback(fallback.handler)
+            if (gated !== fallback.handler) {
+              gated.__dshWuaGated = true
+              fallback.handler = gated
+            }
+          }
+        }
+      } catch (e) { /* 包装失败不阻断注册，靠重扫兜底 */ }
+      return originalRegisterFallback.call(this, fallback)
     }
     undos.push(() => { ws.registerFallback = originalRegisterFallback })
   }
@@ -1746,6 +1882,9 @@ function postLoginRedirect(ctx, req) {
 //   - 审计只记录 sanitizeSub() 过滤后的 subject，杜绝注入。
 
 const OIDC_CALLBACK_PATH = '/dsh-webui-oauth/oidc/callback'
+// 登录入口。ssoOnly 开启时改走 SSO 入口——两者都是公开白名单路径。
+const LOGIN_PATH = '/dsh-webui-oauth/login'
+const SSO_LOGIN_PATH = '/dsh-webui-oauth/oidc/login'
 // 授权请求状态（state / nonce / PKCE verifier）的存活时间。三次握手应在分钟内
 // 完成，10 分钟足够覆盖用户在 IdP 侧慢慢登录的情形，又限制了被滥用的窗口。
 const OIDC_STATE_TTL_MS = 10 * 60 * 1000
@@ -2298,9 +2437,68 @@ export async function apply(ctx) {
     sessions.deleteAllExcept(keepToken)
   }
 
+  // ---------------- 「仅允许 SSO」 ----------------
+  //
+  // 生效条件（三者缺一不可）：
+  //   1) oidc.ssoOnly === true（部署者显式勾选）；
+  //   2) OIDC 已启用且 issuer/clientId/clientSecret 齐全；
+  //   3) 已绑定某个 IdP 身份。
+  //
+  // 第 3 条是**防锁死**的关键：配置为 ssoOnly 但绑定被移除（例如手工改了文件、
+  // 或旧版本留下的状态）时自动退回密码登录，绝不把唯一入口切成一个必然失败
+  // 的 SSO 跳转。
+  //
+  // 运行时值缓存起来：不在每个请求里读配置文件（那是同步/异步文件 IO），
+  // 由 apply、configure、unbind 以及后台定时器刷新。
+  let ssoOnlyActiveFlag = false
+
+  async function computeSsoOnly(creds) {
+    try {
+      const c = creds || await readCredentials(ctx)
+      const o = await oidcOf(c)
+      return !!(o && o.ssoOnly === true && o.enabled === true &&
+        typeof o.issuer === 'string' && typeof o.clientId === 'string' &&
+        typeof o.clientSecret === 'string' && isOidcBound(c))
+    } catch (e) {
+      return false
+    }
+  }
+  async function refreshSsoOnly(creds) {
+    ssoOnlyActiveFlag = await computeSsoOnly(creds)
+    return ssoOnlyActiveFlag
+  }
+
+  /** 本次请求的浏览器侧 origin（用于 SSO 入口的 base 参数）。 */
+  function requestOriginOf(req) {
+    try {
+      const headerHost = (req && req.headers && typeof req.headers.host === 'string' && req.headers.host.trim())
+        ? req.headers.host.trim()
+        : ''
+      const browserHost = proxyHost(req) || headerHost
+      if (!browserHost) return ''
+      const scheme = resolveRedirectScheme(ctx, req, browserHost)
+      return scheme + '://' + browserHost
+    } catch (e) {
+      return ''
+    }
+  }
+
+  /**
+   * 未登录时把浏览器送到哪个入口。
+   * ssoOnly 生效 → SSO 入口，并带上浏览器侧 origin（否则 trustBrowserOrigin
+   * 模式下服务端拿不到 base，会以 oidc-base-unresolvable 失败）。
+   */
+  function loginLocation(req) {
+    if (!ssoOnlyActiveFlag) return LOGIN_PATH
+    const origin = requestOriginOf(req)
+    return SSO_LOGIN_PATH + (origin ? '?base=' + encodeURIComponent(origin) : '')
+  }
+
   // H2: 安装运行时路由闸门
-  const gate = installRouteGate(ctx, checkRequest, (m) => ctx.logger.info('[dsh-webui-oauth] ' + m))
+  const gate = installRouteGate(ctx, checkRequest, (m) => ctx.logger.info('[dsh-webui-oauth] ' + m), { loginLocation })
   ctx.effect(() => gate.undo, 'dsh-webui-oauth: route gate')
+  // 启动时算一次（异步，不阻塞注册；默认 false 是安全的——最坏只是先显示密码页）
+  refreshSsoOnly().catch(() => {})
   if (!gate.ok()) {
     ctx.logger.error('[dsh-webui-oauth] ROUTE GATE INCOMPLETE — ' + gate.problems().join('; ')
       + '. /api and/or WebSocket may be unprotected; the gate will still wrap them if they register later.')
@@ -2332,6 +2530,8 @@ export async function apply(ctx) {
     try {
       const creds = await readCredentials(ctx)
       enabledFlag = isEnabled(creds)
+      // 配置可能被手工修改（含 ssoOnly / 绑定状态），定期重算生效值。
+      await refreshSsoOnly(creds)
     } catch (e) { /* keep last state */ }
   }, 60000)
   ctx.effect(() => () => clearInterval(bgTimer), 'dsh-webui-oauth: background timer')
@@ -2401,9 +2601,17 @@ export async function apply(ctx) {
             res.end()
             return
           }
+          // 「仅允许 SSO」：密码表单没有意义，直接送去 SSO 入口。
+          // 放在会话判断之后：已登录仍然优先回首页。
+          if (enabledFlag && ssoOnlyActiveFlag) {
+            res.writeHead(302, { location: loginLocation(req), 'cache-control': 'no-store' })
+            res.end()
+            return
+          }
           const oidcOn = await oidcEnabled(credsNow)
           const page = LOGIN_PAGE
             .replace('__MODE__', enabledFlag ? 'login' : 'setup')
+            .replace('__SSO_ONLY__', ssoOnlyActiveFlag ? 'true' : 'false')
             // SSO 按钮的显示条件 = 已配置 OIDC **且**已绑定身份。
             // 只判配置会让未绑定的部署显示一个点了必然被拒的按钮（oidc-not-bound），
             // 用户会以为坏了。绑定是访问前提，按钮就该跟着绑定状态走。
@@ -2428,6 +2636,22 @@ export async function apply(ctx) {
             sendJson(res, 200, { ok: false, error: 'not-configured' })
             return
           }
+          // 「仅允许 SSO」：密码登录接口一并关闭，避免绕过策略。
+          // 返回 403 + JSON（前端仍按 JSON 解析），并给出可读原因。
+          if (ssoOnlyActiveFlag) {
+            await auditLog(ctx, 'login_failure', {
+              username: String(body.username || '').trim() || null,
+              ip: requestMeta(req).ip,
+              ua: requestMeta(req).ua,
+              detail: '已启用「仅允许 SSO」，密码登录被拒绝',
+            })
+            sendJson(res, 403, {
+              ok: false,
+              error: 'sso-only',
+              hint: '此部署已启用「仅允许 SSO」，请使用 SSO 单点登录。',
+            })
+            return
+          }
           const username = String(body.username || '').trim()
           const password = String(body.password || '')
           const creds = await readCredentials(ctx)
@@ -2596,13 +2820,18 @@ export async function apply(ctx) {
                 boundSubHint: isOidcBound(creds) ? maskSubForDisplay(boundSubOf(creds)) : null,
                 // prompt 是可选参数，回传当前值供设置页回显（缺省为空 = 不发送）。
                 prompt: typeof oidcCfg.prompt === 'string' ? oidcCfg.prompt : '',
+                // 「仅允许 SSO」：ssoOnly 是配置值，ssoOnlyActive 是**实际生效值**
+                // （还要求 OIDC 已启用且已绑定）。两者分开回显，便于排查
+                // "勾了但没生效"——通常是绑定被解除或 OIDC 参数不全。
+                ssoOnly: oidcCfg.ssoOnly === true,
+                ssoOnlyActive: ssoOnlyActiveFlag,
                 // 提供给 IdP 登记用的确切回调地址。原生 OIDC 要求 redirect_uri 精确匹配，
                 // 部署者必须把它抄进 IdP 的允许列表，因此这里直接算好给他。
                 // 不能只给路径：IdP 侧需要完整的 scheme + host + port。
                 redirectUri: resolveOidcRedirectUri(ctx, oidcCfg),
                 callbackPath: OIDC_CALLBACK_PATH,
               }
-            : { enabled: false, bound: isOidcBound(creds), boundSubHint: isOidcBound(creds) ? maskSubForDisplay(boundSubOf(creds)) : null, redirectUri: null, callbackPath: OIDC_CALLBACK_PATH },
+            : { enabled: false, bound: isOidcBound(creds), boundSubHint: isOidcBound(creds) ? maskSubForDisplay(boundSubOf(creds)) : null, redirectUri: null, callbackPath: OIDC_CALLBACK_PATH, ssoOnly: false, ssoOnlyActive: false },
         })
       } catch (e) {
         sendJson(res, 500, { error: e && e.message ? e.message : String(e) })
@@ -2718,6 +2947,39 @@ export async function apply(ctx) {
             sendJson(res, 200, { ok: false, error: 'oidc-invalid', reason: 'clientSecret 须为字符串' })
             return
           }
+          // ssoOnly：「仅允许 SSO」。类型校验 + 防锁死校验。
+          // 勾选它等于关掉唯一的备用入口（密码登录），因此必须确认 SSO 这条路
+          // 真的能走通：OIDC 启用、参数齐全、且已经绑定了一个 IdP 身份。
+          // 否则用户会在下一次打开页面时被送进一个必然失败的 SSO 跳转。
+          if (oidcIn.ssoOnly !== undefined && typeof oidcIn.ssoOnly !== 'boolean') {
+            await auditLog(ctx, 'configure_failure', { username, ip: meta.ip, ua: meta.ua, detail: 'OIDC 配置：ssoOnly 须为 boolean' })
+            sendJson(res, 200, { ok: false, error: 'oidc-invalid', reason: 'ssoOnly 须为 boolean' })
+            return
+          }
+          if (oidcIn.ssoOnly === true) {
+            if (oidcIn.enabled === false) {
+              await auditLog(ctx, 'configure_failure', { username, ip: meta.ip, ua: meta.ua, detail: 'OIDC 配置：未启用 OIDC 时不能仅允许 SSO' })
+              sendJson(res, 200, { ok: false, error: 'oidc-sso-only-invalid', reason: '未启用 OIDC 时不能勾选「仅允许 SSO」' })
+              return
+            }
+            const prev = (await readOidcConfig(ctx, creds)).oidc
+            const prevSecret = (prev && typeof prev.clientSecret === 'string') ? prev.clientSecret : ''
+            const effectiveSecret = (typeof oidcIn.clientSecret === 'string' && oidcIn.clientSecret) ? oidcIn.clientSecret : prevSecret
+            if (!String(oidcIn.issuer || '').trim() || !String(oidcIn.clientId || '').trim() || !String(effectiveSecret || '').trim()) {
+              await auditLog(ctx, 'configure_failure', { username, ip: meta.ip, ua: meta.ua, detail: 'OIDC 配置：仅允许 SSO 需先补全 OIDC 参数' })
+              sendJson(res, 200, { ok: false, error: 'oidc-sso-only-invalid', reason: '勾选「仅允许 SSO」前需先填写完整的 Issuer / Client ID / Client Secret' })
+              return
+            }
+            if (!isOidcBound(creds)) {
+              await auditLog(ctx, 'configure_failure', { username, ip: meta.ip, ua: meta.ua, detail: 'OIDC 配置：仅允许 SSO 需先绑定身份' })
+              sendJson(res, 200, {
+                ok: false,
+                error: 'oidc-sso-only-unbound',
+                reason: '勾选「仅允许 SSO」前需要先在下方绑定 OIDC 身份，否则会把自己锁在门外',
+              })
+              return
+            }
+          }
           // 首次配置（尚无旧 secret）时必须提供：否则会存下一个没有 secret 的配置，
           // oidcEnabled() 判定为未启用，用户会看到莫名其妙的 oidc-not-configured。
           if (oidcIn.enabled === true && !String(oidcIn.clientSecret || '').trim()) {
@@ -2747,21 +3009,31 @@ export async function apply(ctx) {
             // prompt 默认不发（留空即 undefined）。仅在部署者显式填写时才带给 IdP，
             // 因为不少 IdP 会因不认识的 prompt 值直接拒绝授权。
             prompt: typeof oidcIn.prompt === 'string' && oidcIn.prompt.trim() ? oidcIn.prompt.trim() : undefined,
+            // 仅允许 SSO：显式存布尔值，便于设置页回显与运维手改。
+            ssoOnly: oidcIn.ssoOnly === true,
           }
         } else if (oidcIn && oidcIn.enabled === false) {
           oidcOut = { enabled: false }
         }
+        // 这里曾经只重建 { v, username, hash, ttl }，把 boundSub 一并丢掉——
+        // 结果是"每次保存设置都会静默解绑 OIDC"。绑定关系属于账号的一部分，
+        // 改密码/改 TTL 时没有理由动它，必须原样带过去。
+        const keptBoundSub = typeof creds.boundSub === 'string' && creds.boundSub ? creds.boundSub : null
         let credsOut
         if (keepPassword && typeof creds.hash === 'string') {
           credsOut = { v: 3, username, hash: creds.hash, ttl }
         } else {
           credsOut = { v: 3, username, hash: await hashPassword(password), ttl }
         }
+        if (keptBoundSub) credsOut.boundSub = keptBoundSub
         // 凭据文件只保留账号字段（OIDC 走独立文件）；写入时自然剥掉历史遗留的 oidc 段，
         // 完成旧布局 → 新布局迁移，不让旧 secret 继续躺在凭据文件里。
         await writeCredentials(ctx, credsOut)
         // OIDC 仅当本次请求涉及它时才写，避免"只改密码"把 OIDC 配置意外清掉。
         if (oidcOut) await writeOidcConfig(ctx, oidcOut)
+        // 配置可能改变了 ssoOnly / 绑定状态，立即重算生效值，
+        // 不必等后台定时器（否则用户保存后要最多 60 秒才看到效果）。
+        await refreshSsoOnly(credsOut)
         enabledFlag = true
         if (wasEnabled) {
           const keepToken = cookieOf(req, COOKIE_NAME)
@@ -2996,10 +3268,27 @@ export async function apply(ctx) {
           sendJson(res, 200, { ok: true, bound: false, alreadyUnbound: true })
           return
         }
+        // 仅允许 SSO 时禁止解绑：绑定是唯一入口，解绑等于把所有人锁在门外
+        // （此时密码登录已被禁用，且解绑后连 SSO 也会因未绑定而拒绝）。
+        // 要求先关闭开关，是有意的两步操作——不做静默降级，避免安全策略被
+        // 一个顺手点击悄悄改掉。
+        {
+          const cfg = await oidcOf(creds)
+          if (cfg && cfg.ssoOnly === true) {
+            await auditLog(ctx, 'oidc_unbind_failure', { username: creds.username, ip: meta.ip, ua: meta.ua, detail: '仅允许 SSO 生效时禁止解绑' })
+            sendJson(res, 200, {
+              ok: false,
+              error: 'sso-only-active',
+              hint: '请先在设置中关闭「仅允许 SSO」，再解除绑定。',
+            })
+            return
+          }
+        }
         // 只删 boundSub，其余字段原样保留。
         const next = { ...creds }
         delete next.boundSub
         await writeCredentials(ctx, next)
+        await refreshSsoOnly(next)
         await auditLog(ctx, 'oidc_unbind_success', { username: creds.username, ip: meta.ip, ua: meta.ua })
         sendJson(res, 200, { ok: true, bound: false })
       } catch (e) {
@@ -3218,16 +3507,14 @@ export async function apply(ctx) {
               return
             }
           }
-          const fallback = ctx.webServer.fallback
-          if (fallback !== undefined) {
-            await fallback(req, res)
-            return
-          }
+          // fallback 可能是函数，也可能是 { resource }（0.2.2-rc.1+）。
+          // 交给 serveFallback 统一分派，避免 TypeError → 500 空响应。
+          if (await serveFallback(ctx, req, res)) return
           res.writeHead(404)
           res.end()
           return
         }
-        res.writeHead(302, { location: '/dsh-webui-oauth/login' })
+        res.writeHead(302, { location: loginLocation(req) })
         res.end()
       } catch (e) {
         ctx.logger.warn('[dsh-webui-oauth] intercept error: ' + (e && e.message ? e.message : String(e)))

package/lib/client.js

@@ -129,6 +129,9 @@ window.__ModuleLoader__.load({
 				const [oidcScope, setOidcScope] = react.useState('openid profile email');
 				const [oidcRedirectBase, setOidcRedirectBase] = react.useState('');
 				const [oidcTrustBrowser, setOidcTrustBrowser] = react.useState(true);
+				// 「仅允许 SSO」：勾选后未登录访问会自动跳转 SSO，并禁用密码登录接口。
+				// 服务端还要求已绑定身份（否则会返回 oidc-sso-only-unbound）。
+				const [oidcSsoOnly, setOidcSsoOnly] = react.useState(false);
 				// prompt（可选）。默认留空 = 不发送该参数——不少 IdP 会对不认识的
 				// prompt 值直接回 unsupported prompt value requested，导致授权发不出去。
 				const [oidcPrompt, setOidcPrompt] = react.useState('');
@@ -165,6 +168,7 @@ window.__ModuleLoader__.load({
 							setOidcEnabled(!!(o && o.enabled));
 							setOidcIssuer((o && o.issuer) || '');
 							setOidcTrustBrowser(!o || o.trustBrowserOrigin !== false);
+							setOidcSsoOnly(!!(o && o.ssoOnly));
 							setOidcClientId((o && o.clientId) || '');
 							if (o && o.scope) setOidcScope(o.scope);
 							if (o && o.redirectBase) setOidcRedirectBase(o.redirectBase);
@@ -258,6 +262,8 @@ window.__ModuleLoader__.load({
 					trustBrowserOrigin: oidcTrustBrowser,
 					// 留空即不发送 prompt（服务端会存成 undefined）
 					prompt: oidcPrompt.trim(),
+					// OIDC 关闭时不能「仅允许 SSO」，否则等于关掉所有登录入口
+					ssoOnly: oidcEnabled ? oidcSsoOnly : false,
 				};
 				api('/dsh-webui-oauth/configure', { username: name, password, current, ttl: Number(ttl), oidc: oidcPayload }).then((r) => {
 						setBusy(false);
@@ -281,6 +287,8 @@ window.__ModuleLoader__.load({
 							setMsg({ kind: 'err', text: '用户名需为 3-32 位字母、数字、下划线或连字符' });
 						} else if (r && r.error === 'legacy-hash') {
 							setMsg({ kind: 'err', text: '当前凭据为旧版哈希（0.2.0 起仅支持 scrypt），必须填写新密码才能保存' });
+						} else if (r && (r.error === 'oidc-sso-only-unbound' || r.error === 'oidc-sso-only-invalid')) {
+							setMsg({ kind: 'err', text: (r && r.reason) || '无法启用「仅允许 SSO」' });
 						} else if (r && typeof r.error === 'string') {
 							// 服务端 500/未知错误：展示真实信息便于排查
 							setMsg({ kind: 'err', text: '保存失败：' + r.error });
@@ -348,6 +356,8 @@ window.__ModuleLoader__.load({
 							}).catch(() => {});
 						} else if (r && r.error === 'current-invalid') {
 							setBindMsg({ kind: 'err', text: '当前密码不正确' });
+						} else if (r && r.error === 'sso-only-active') {
+							setBindMsg({ kind: 'err', text: (r && r.hint) || '请先关闭「仅允许 SSO」再解绑' });
 						} else {
 							setBindMsg({ kind: 'err', text: '解绑失败：' + ((r && r.error) || '未知错误') });
 						}
@@ -476,6 +486,19 @@ window.__ModuleLoader__.load({
 							' 启用（登录页显示「SSO 单点登录」按钮）'),
 					),
 					oidcEnabled ? react.createElement('div', { className: 'wua-section' },
+						react.createElement('div', { className: 'wua-row' },
+							react.createElement('label', { className: 'wua-label' },
+								react.createElement('input', {
+									type: 'checkbox',
+									checked: oidcSsoOnly,
+									onChange: (e) => setOidcSsoOnly(e.target.checked),
+								}),
+								' 仅允许 SSO（未登录时自动跳转到 SSO，并禁用密码登录）'),
+							react.createElement('p', { className: 'wua-hint', style: { borderTop: 'none', paddingTop: 0 } },
+								oidcBound
+									? '启用后密码登录接口会被拒绝，未登录访问一律跳转 SSO。请确认 IdP 可用，否则将无法登录；如被锁在门外，可手工把 dsh-webui-oauth.json 里的 ssoOnly 改回 false。'
+									: '尚未绑定 OIDC 身份，无法启用：请先在下方完成「绑定 OIDC 身份」。'),
+						),
 						react.createElement('div', { className: 'wua-row' },
 							react.createElement('label', { className: 'wua-label' }, 'Issuer（IdP 地址，须为 https）'),
 							react.createElement('input', { className: 'wua-input', type: 'text', value: oidcIssuer, spellCheck: false, onChange: (e) => setOidcIssuer(e.target.value) }),

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "dsh-webui-oauth",
-  "version": "0.6.9",
+  "version": "0.7.1",
   "type": "module",
   "main": "index.js",
   "scripts": {
-    "test": "node test/redirect-scheme.test.mjs && node test/proxy-host.test.mjs && node test/trusted-origin.test.mjs && node test/oidc.test.mjs && node test/oidc-state-ttl.test.mjs && node test/set-cookie-multi.test.mjs && node test/oidc-integration.test.mjs && node test/oidc-config-store.test.mjs && node test/adopt-data-dir.test.mjs && node test/oidc-ec.test.mjs && node test/jwks-refresh.test.mjs && node test/oidc-bind.test.mjs && node test/client-bundle-id.test.mjs && node test/client-prefill.test.mjs && node test/displace-original.test.mjs && node test/oidc-redirect-matrix.test.mjs && node test/gate-default-deny.test.mjs"
+    "test": "node test/redirect-scheme.test.mjs && node test/proxy-host.test.mjs && node test/trusted-origin.test.mjs && node test/oidc.test.mjs && node test/oidc-state-ttl.test.mjs && node test/set-cookie-multi.test.mjs && node test/oidc-integration.test.mjs && node test/oidc-config-store.test.mjs && node test/adopt-data-dir.test.mjs && node test/oidc-ec.test.mjs && node test/jwks-refresh.test.mjs && node test/oidc-bind.test.mjs && node test/client-bundle-id.test.mjs && node test/client-prefill.test.mjs && node test/displace-original.test.mjs && node test/oidc-redirect-matrix.test.mjs && node test/gate-default-deny.test.mjs && node test/fallback-shape.test.mjs"
   },
   "exports": {
     ".": "./index.js",