@dsh-plus/access-gate 0.1.4 → 0.2.1

package/src/index.ts

@@ -1,12 +1,20 @@
 /**
  * dsh 插件：访问围栏（access-gate）。
  *
- * 为 dsh web 的全部 HTTP/WebSocket 流量提供访问安全校验与访问控制：
- * - 本机直连（loopback 且无 x-forwarded-for）永久放行——管理通道，防锁死；
- * - 远程流量按 tailscale serve 注入的 x-forwarded-for 还原真实客户端 IP，
- *   命中白名单（精确 IP / CIDR，v4+v6）即放行；
- * - 或持有效 token（登录页换取 HttpOnly cookie）放行；
- * - 其余：浏览器导航返回登录页，API / WS 一律 403 / 拒绝升级。
+ * 与官方 browser-auth 合并后的全量访问围栏：
+ * - 访问凭据唯一化为官方 dsh-auth-* cookie（`?token=` 启动令牌交换签发，
+ *   30 天、按 authority 分别持有）——凭据校验委托 connection.requestRejection()，
+ *   本插件不再持有自有 token/cookie；
+ * - 本机直连（loopback 且无 x-forwarded-for）gate 层永久放行——管理通道；
+ * - allowedIps 为可选附加 IP 围栏（XFF 还原，精确 IP / CIDR，v4+v6）；
+ * - 未认证的浏览器导航 → token 输入页（粘贴启动令牌走官方交换，**PWA 内
+ *   同路径可用**——恢复官方 start_url 无法携带 token 导致的 PWA 死结）；
+ *   未认证的 API / WS / 静态资产 → 403 / 拒绝升级；
+ * - 豁免：自有端点（/dsh-plus/gate/*）、PWA 安装资产、官方令牌交换请求。
+ *
+ * 自有端点：GET /dsh-plus/gate/status（卡片诊断）、GET /dsh-plus/gate/launch-url
+ * （仅本机直连，返回当前进程认证链接——令牌跨 authority 有效，支持 host/scheme
+ * 参数生成远程变体）。
  *
  * 配置：settings 命名空间 dsh-plus-access-gate（webui 配置卡片同一份，
  * 热生效）；enabled=false 时完全旁路（等价插件缺席）。
@@ -14,8 +22,12 @@
  * 隔离止损，绝不静默 fail-open）。
  * @module @dsh-plus/access-gate
  */
+
+import type { IncomingMessage } from 'node:http'
 import { type Context, Service } from '@deepseek-ai/cordis'
-import { installSettingsSection } from '@deepseek-ai/dsh-settings'
+// HostConnectionHandle 的 Context 声明合并（connection 服务类型来源）。
+import type {} from '@deepseek-ai/dsh-client-connection'
+import type {} from '@deepseek-ai/dsh-settings'
 
 import { type AccessGateConfig, Config, SETTINGS_NS } from './config.ts'
 import { type GateWebServer, installGateInterceptor } from './interceptor.ts'
@@ -23,7 +35,7 @@ import { registerGateRoutes } from './routes.ts'
 
 export const name = 'dsh-plus-access-gate'
 
-export const inject = ['webServer'] as const
+export const inject = ['webServer', 'connection'] as const
 
 export { Config }
 
@@ -40,23 +52,34 @@ export class AccessGateService extends Service {
   constructor(ctx: Context, config: AccessGateConfig) {
     super(ctx, 'accessGate')
     this.current = () => config
-    installSettingsSection(ctx, SETTINGS_NS, Config, config, {
-      setSource: (source) => {
-        this.current = source
-      },
-      onChange: () => {},
+    // 官方 installSection 范式（0.1.2-alpha.2）：settings 提供方在时以行级 config 为
+    // base 注册用户层命名空间，缺席/ detach 时回落行级 config。
+    ctx.inject(['settings'], (settingsCtx) => {
+      settingsCtx.settings.installSection(ctx, SETTINGS_NS, Config, config, {
+        setSource: (source) => {
+          this.current = source
+        },
+        onChange: () => {},
+      })
     })
     const logger = ctx.logger('access-gate')
 
+    // 官方凭据校验委托：undefined = 已通过（含官方 Host 信任围栏）。
+    const officialAuth = (req: IncomingMessage): boolean =>
+      ctx.connection.requestRejection({ headers: req.headers }) === undefined
+
     // 自有端点（/dsh-plus/gate/*，围栏豁免路径）。
     registerGateRoutes(ctx, {
       config: () => this.current(),
+      officialAuth,
+      authenticatedUrl: (baseUrl) => ctx.connection.authenticatedUrl(baseUrl),
       onError: (message) => logger.warn(message),
     })
 
     // 结构包装：全部 HTTP/WS 流量的围栏。
     const undo = installGateInterceptor(ctx, ctx.webServer as unknown as GateWebServer, {
       config: () => this.current(),
+      officialAuth,
       onBlock: (message) => logger.info(message),
     })
     ctx.effect(() => undo, 'access-gate: interceptor')

package/src/interceptor.ts

@@ -4,7 +4,7 @@
  * 机制（dsh-host-webserver 无中间件机制，路由分发必经以下三个面）：
  * 1. `match(pathname)` —— HTTP 分发总咽喉：patch 后**请求级**围栏判定——
  *    放行则返回原 route（handler 外包一层，route 对象本体不动，webserver
- *    拿到的是浅拷贝）；拒绝则返回内联拒绝 route（导航→登录页，其余→403；
+ *    拿到的是浅拷贝）；拒绝则返回内联拒绝 route（导航→token 输入页，其余→403；
  *    连「未知路径」的探测面也一并收敛）。与路由注册时序完全无关。
  * 2. `fallback` 字段 + `registerFallback` 方法 —— SPA index/静态资源：
  *    在位包装已注册的 fallback（frontend-static 先于本插件），并 patch
@@ -12,6 +12,12 @@
  * 3. `upgrades` Map 各 route 的 handler + `registerUpgrade` 方法 —— WS 升级
  *    双路径覆盖（先/后注册的条目都被拦截）。
  *
+ * 与官方认证合并后的放行面：
+ * - 凭据校验委托官方 `connection.requestRejection()`（officialAuth 注入）；
+ * - 豁免：自有端点（/dsh-plus/gate/*）、PWA 安装资产（manifest/favicon）、
+ *   官方令牌交换（GET /?token=，校验本身由官方 authorizeIndex 完成）；
+ * - 未认证导航 → token 输入页（PWA 内同路径可用）；未认证非导航 → 403。
+ *
  * 结构守卫：安装前校验字段形状（match 为函数、upgrades 为 Map 等），
  * 不符即 fail-loud 抛错（启动失败由 lifeboat 隔离止损，绝不静默 fail-open）。
  * 恢复：所有 patch 与在位 handler 替换均登记 undo，dispose/HMR 时完全还原。
@@ -24,8 +30,8 @@ import type { Context } from '@deepseek-ai/cordis'
 
 import type { AccessGateConfig } from './config.ts'
 import { decideGate, type GateRequest } from './decision.ts'
-import { renderLoginPage } from './login-page.ts'
 import { GATE_ROUTE } from './routes.ts'
+import { renderTokenPage } from './token-page.ts'
 
 type HttpHandler = (req: IncomingMessage, res: ServerResponse) => unknown
 type UpgradeHandler = (req: IncomingMessage, socket: Duplex, head: Buffer) => unknown
@@ -43,12 +49,26 @@ export interface GateWebServer {
 
 export interface InterceptorDeps {
   config: () => AccessGateConfig
+  /** 官方 browser-auth 校验（委托 connection.requestRejection；含官方 Host 围栏）。 */
+  officialAuth: (req: IncomingMessage) => boolean
   onBlock?: (message: string) => void
 }
 
-/** 是否围栏豁免路径（自有登录/状态端点）。 */
+/** PWA 安装/图标资产：未认证也必须可达，否则浏览器无法安装 PWA。 */
+const PWA_ASSETS: ReadonlySet<string> = new Set(['/manifest.webmanifest', '/favicon.svg'])
+
+/** 是否围栏豁免路径（自有状态/管理端点 + PWA 安装资产）。 */
 export function isExemptPath(pathname: string): boolean {
-  return pathname === GATE_ROUTE || pathname.startsWith(`${GATE_ROUTE}/`)
+  return (
+    pathname === GATE_ROUTE || pathname.startsWith(`${GATE_ROUTE}/`) || PWA_ASSETS.has(pathname)
+  )
+}
+
+/** 官方令牌交换请求：GET / 且携带 token 查询参数（放行给官方 authorizeIndex 校验）。 */
+export function isTokenExchange(req: IncomingMessage): boolean {
+  if (req.method !== 'GET') return false
+  const url = new URL(req.url ?? '/', 'http://x')
+  return url.pathname === '/' && url.searchParams.has('token')
 }
 
 function toGateRequest(req: IncomingMessage): GateRequest {
@@ -77,14 +97,15 @@ function rejectUpgrade(socket: Duplex, clientIp: string, log: (m: string) => voi
 
 /** 单请求围栏判定；放行 true / 拒绝（已写响应）false。 */
 function passHttp(req: IncomingMessage, res: ServerResponse, deps: InterceptorDeps): boolean {
-  if (isExemptPath(new URL(req.url ?? '/', 'http://x').pathname)) return true
-  const decision = decideGate(toGateRequest(req), deps.config())
+  const url = new URL(req.url ?? '/', 'http://x')
+  if (isExemptPath(url.pathname) || isTokenExchange(req)) return true
+  const decision = decideGate(toGateRequest(req), deps.config(), deps.officialAuth(req))
   if (decision.verdict === 'pass') return true
   const log = deps.onBlock ?? (() => {})
-  if (decision.verdict === 'login' && !res.headersSent) {
+  if (decision.verdict === 'token-page' && !res.headersSent) {
     res.writeHead(200, { 'content-type': 'text/html; charset=utf-8', 'cache-control': 'no-store' })
-    res.end(renderLoginPage())
-    log(`login page ${req.method ?? '?'} ${req.url ?? '?'}`)
+    res.end(renderTokenPage())
+    log(`token page ${req.method ?? '?'} ${req.url ?? '?'}`)
     return false
   }
   if (!res.headersSent) {
@@ -100,7 +121,6 @@ function passHttp(req: IncomingMessage, res: ServerResponse, deps: InterceptorDe
 /** HTTP handler 包装体：先判定再派发。 */
 function gatedHttp(handler: HttpHandler, deps: InterceptorDeps): HttpHandler {
   return async (req, res) => {
-    if (isExemptPath(new URL(req.url ?? '/', 'http://x').pathname)) return handler(req, res)
     if (!passHttp(req, res, deps)) return
     return handler(req, res)
   }
@@ -109,7 +129,9 @@ function gatedHttp(handler: HttpHandler, deps: InterceptorDeps): HttpHandler {
 /** WS 升级包装体：拒绝时不进协议协商。 */
 function gatedUpgrade(handler: UpgradeHandler, deps: InterceptorDeps): UpgradeHandler {
   return (req, socket, head) => {
-    const decision = decideGate(toGateRequest(req), deps.config())
+    if (isExemptPath(new URL(req.url ?? '/', 'http://x').pathname))
+      return handler(req, socket, head)
+    const decision = decideGate(toGateRequest(req), deps.config(), deps.officialAuth(req))
     if (decision.verdict === 'pass') return handler(req, socket, head)
     rejectUpgrade(socket, decision.clientIp ?? 'unknown', deps.onBlock ?? (() => {}))
     return undefined

package/src/ns.ts

@@ -1,7 +1,8 @@
 /**
  * settings 命名空间字面量（纯常量，零依赖，浏览器半可安全引入）。
- * 服务端经 settingsNamespace() 品牌化后使用（config.ts），浏览器半将其作为
- * settings.plugin.item keyed 槽位的 key —— 同一字面量两处共用，防止漂移。
+ * 服务端直接以字面量注册（0.1.2-alpha.2 起 dsh-settings 编译期校验命名空间
+ * 语法，见 config.ts），浏览器半将其作为 settings.plugin.item keyed 槽位的
+ * key —— 同一字面量两处共用，防止漂移。
  * @module access-gate/ns
  */
 export const SETTINGS_NS = 'dsh-plus-access-gate'

package/src/routes.ts

@@ -1,14 +1,14 @@
 /**
  * 自有 HTTP 端点（/dsh-plus/gate 前缀，围栏豁免路径）：
- * - POST /dsh-plus/gate/login  — token 换 cookie（HttpOnly + SameSite=Strict）
- * - GET  /dsh-plus/gate/status — 当前客户端判定状态（登录页与卡片诊断）
+ * - GET /dsh-plus/gate/status     — 当前客户端判定状态（配置卡片诊断）
+ * - GET /dsh-plus/gate/launch-url — 当前进程认证链接（仅本机直连可用的管理通道）
  *
- * 登录失败节流：按客户端 IP 记录失败次数与冷却截止（惰性清理，无定时器）。
+ * 与官方认证合并后不再提供 login 端点：令牌校验完全由官方 authorizeIndex
+ * 完成（token 输入页纯客户端跳转 `/?token=`），无失败节流面。
  * handler 工厂与路由注册分离，测试直接驱动 handler（禁起真实服务器）。
  * @module access-gate/routes
  */
 
-import { createHash, timingSafeEqual } from 'node:crypto'
 import type { IncomingMessage, ServerResponse } from 'node:http'
 
 import type { Context } from '@deepseek-ai/cordis'
@@ -16,59 +16,26 @@ import type {} from '@deepseek-ai/dsh-host-webserver'
 
 import type { AccessGateConfig } from './config.ts'
 import { decideGate } from './decision.ts'
+import { isLoopbackAddress } from './ip.ts'
 
 export const GATE_ROUTE = '/dsh-plus/gate'
 
-/** 节流状态（纯数据结构，可注入 clock 测试）。 */
-export interface ThrottleState {
-  fails: Map<string, { count: number; until: number }>
-}
-
-export function createThrottleState(): ThrottleState {
-  return { fails: new Map() }
-}
-
 export interface RouteDeps {
   config: () => AccessGateConfig
+  /** 官方 browser-auth cookie 校验（委托 connection.requestRejection）。 */
+  officialAuth: (req: IncomingMessage) => boolean
+  /** 生成当前进程认证链接（委托 connection.authenticatedUrl）。 */
+  authenticatedUrl: (baseUrl: string) => string
   /** 客户端 IP 还原（与围栏同一规则）；缺省时从请求自身推导。 */
   resolveClientIp?: (req: IncomingMessage) => string | undefined
-  throttle?: ThrottleState
-  clock?: () => number
   onError?: (message: string) => void
 }
 
-function sendJson(
-  res: ServerResponse,
-  status: number,
-  body: unknown,
-  headers?: Record<string, string>,
-): void {
-  res.writeHead(status, { 'content-type': 'application/json; charset=utf-8', ...headers })
+function sendJson(res: ServerResponse, status: number, body: unknown): void {
+  res.writeHead(status, { 'content-type': 'application/json; charset=utf-8' })
   res.end(JSON.stringify(body))
 }
 
-function readBody(req: IncomingMessage): Promise<string> {
-  return new Promise((resolve, reject) => {
-    const chunks: Buffer[] = []
-    req.on('data', (chunk: Buffer) => chunks.push(chunk))
-    req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')))
-    req.on('error', reject)
-  })
-}
-
-/** 解析 JSON body；非对象或解析失败返回 null。 */
-async function readJson(req: IncomingMessage): Promise<Record<string, unknown> | null> {
-  if (!req.headers['content-type']?.includes('application/json')) return null
-  try {
-    const parsed: unknown = JSON.parse(await readBody(req))
-    return parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed)
-      ? (parsed as Record<string, unknown>)
-      : null
-  } catch {
-    return null
-  }
-}
-
 /** 默认客户端 IP 还原：XFF 最左优先，否则 socket 地址。 */
 function clientIpOf(req: IncomingMessage): string | undefined {
   const forwarded = req.headers['x-forwarded-for']
@@ -81,64 +48,20 @@ function clientIpOf(req: IncomingMessage): string | undefined {
   return remote.startsWith('::ffff:') ? remote.slice(7) : remote
 }
 
-/** 是否处于冷却期；冷却期满的条目惰性清除（计数中条目保留）。 */
-function throttled(state: ThrottleState, ip: string, now: number): boolean {
-  const entry = state.fails.get(ip)
-  if (entry === undefined) return false
-  if (entry.until > now) return true
-  if (entry.until > 0) state.fails.delete(ip)
-  return false
-}
-
-/** 记一次失败；达到阈值则进入冷却。 */
-function recordFailure(
-  state: ThrottleState,
-  ip: string,
-  limit: number,
-  cooldownMs: number,
-  now: number,
-): void {
-  const entry = state.fails.get(ip) ?? { count: 0, until: 0 }
-  entry.count += 1
-  if (entry.count >= limit) {
-    entry.until = now + cooldownMs
-    entry.count = 0
-  }
-  state.fails.set(ip, entry)
+/**
+ * 本机直连判定（launch-url 管理通道专用）：socket 为 loopback 且不带
+ * XFF（带 XFF 说明经代理，真实客户端在远端，不属本机管理通道）。
+ */
+function isDirectLoopback(req: IncomingMessage): boolean {
+  if (req.headers['x-forwarded-for'] !== undefined) return false
+  return isLoopbackAddress(req.socket?.remoteAddress)
 }
 
 export function createGateRoutes(
   deps: RouteDeps,
 ): (req: IncomingMessage, res: ServerResponse) => Promise<void> {
-  const throttle = deps.throttle ?? createThrottleState()
-  const clock = deps.clock ?? Date.now
   const resolveIp = deps.resolveClientIp ?? clientIpOf
 
-  const handleLogin = async (req: IncomingMessage, res: ServerResponse): Promise<void> => {
-    const config = deps.config()
-    const body = await readJson(req)
-    if (body === undefined || body === null || typeof body.token !== 'string') {
-      sendJson(res, 400, { error: 'invalid json body' })
-      return
-    }
-    const ip = resolveIp(req) ?? 'unknown'
-    const now = clock()
-    if (throttled(throttle, ip, now)) {
-      sendJson(res, 429, { error: 'too many attempts' })
-      return
-    }
-    const ok = verifyToken(body.token, config.token)
-    if (!ok) {
-      recordFailure(throttle, ip, config.loginFailLimit, config.loginCooldownMs, now)
-      sendJson(res, 403, { error: 'invalid token' })
-      return
-    }
-    throttle.fails.delete(ip)
-    const maxAge = config.cookieMaxAgeHours * 3600
-    const cookie = `dsh_gate=${body.token}; Path=/; HttpOnly; SameSite=Strict; Max-Age=${maxAge}`
-    sendJson(res, 200, { ok: true }, { 'set-cookie': cookie })
-  }
-
   const handleStatus = (req: IncomingMessage, res: ServerResponse): void => {
     const config = deps.config()
     const decision = decideGate(
@@ -149,30 +72,53 @@ export function createGateRoutes(
         remoteAddress: req.socket?.remoteAddress,
       },
       config,
+      deps.officialAuth(req),
     )
     sendJson(res, 200, {
       enabled: config.enabled,
       verdict: decision.verdict,
-      clientIp: decision.clientIp ?? null,
+      clientIp: decision.clientIp ?? resolveIp(req) ?? null,
       reason: decision.reason ?? null,
+      officialAuthed: deps.officialAuth(req),
+      ipFenceActive: config.allowedIps.length > 0,
       invalidEntries: decision.invalidEntries ?? [],
-      tokenConfigured: config.token !== '',
       allowedCount: config.allowedIps.length,
     })
   }
 
+  const handleLaunchUrl = (req: IncomingMessage, res: ServerResponse): void => {
+    if (!isDirectLoopback(req)) {
+      sendJson(res, 403, { error: 'loopback only' })
+      return
+    }
+    // 令牌本身跨 authority 有效（官方交换不校验 authority），支持按指定
+    // host/scheme 生成变体（如 tailscale 域名）；缺省取请求的 loopback host。
+    const url = new URL(req.url ?? '/', 'http://localhost')
+    const host = url.searchParams.get('host') ?? req.headers.host
+    if (typeof host !== 'string' || host === '') {
+      sendJson(res, 400, { error: 'missing host' })
+      return
+    }
+    const scheme = url.searchParams.get('scheme') ?? 'http'
+    try {
+      sendJson(res, 200, { url: deps.authenticatedUrl(`${scheme}://${host}`) })
+    } catch {
+      sendJson(res, 400, { error: 'invalid host' })
+    }
+  }
+
   return async (req, res) => {
     try {
       const sub = new URL(req.url ?? '/', 'http://localhost').pathname.slice(GATE_ROUTE.length)
       const method = req.method ?? 'GET'
-      if (sub === '/login') {
-        if (method !== 'POST') return sendJson(res, 405, { error: 'POST only' })
-        return await handleLogin(req, res)
-      }
       if (sub === '/status') {
         if (method !== 'GET') return sendJson(res, 405, { error: 'GET only' })
         return handleStatus(req, res)
       }
+      if (sub === '/launch-url') {
+        if (method !== 'GET') return sendJson(res, 405, { error: 'GET only' })
+        return handleLaunchUrl(req, res)
+      }
       sendJson(res, 404, { error: 'unknown endpoint' })
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error)
@@ -183,14 +129,6 @@ export function createGateRoutes(
   }
 }
 
-/** token 校验（sha256 + 常时比较）；空 token 通道关闭恒 false。 */
-function verifyToken(candidate: string, expected: string): boolean {
-  if (candidate === '' || expected === '') return false
-  const a = createHash('sha256').update(candidate).digest()
-  const b = createHash('sha256').update(expected).digest()
-  return timingSafeEqual(a, b)
-}
-
 /** 注册路由（webServer 缺失时由调用方保证不调用）。 */
 export function registerGateRoutes(ctx: Context, deps: RouteDeps): void {
   ctx.webServer.register({

package/src/token-page.ts

@@ -0,0 +1,88 @@
+/**
+ * token 输入页：围栏拦截未认证浏览器导航时返回的内联 HTML。
+ * 自包含（无外部静态资源依赖——静态资产同样受围栏保护）、中文、vanilla JS。
+ *
+ * 工作方式（与官方 browser-auth 合并后的唯一登录路径）：
+ * 用户粘贴当前启动令牌 → fetch `/?token=<令牌>`（同源，跟随 303）→ 官方
+ * 交换签发 dsh-auth-* HttpOnly cookie（30 天，按域名:端口分别持有）→
+ * 成功后跳回干净 `/`。PWA 内打开本页粘贴一次即可恢复（解决 PWA 无法
+ * 携带 ?token= 启动的官方限制）。
+ * 本页纯客户端跳转，无服务器端点，令牌校验完全由官方 authorizeIndex 完成。
+ * @module access-gate/token-page
+ */
+
+export function renderTokenPage(): string {
+  return `<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>登录 - DeepSeek Harness</title>
+<style>
+  :root { color-scheme: dark; }
+  body {
+    margin: 0; min-height: 100vh; display: flex; align-items: center; justify-content: center;
+    background: #16181d; color: #e6e8ec;
+    font-family: system-ui, -apple-system, "Segoe UI", Roboto, "PingFang SC", "Noto Sans CJK SC", sans-serif;
+  }
+  .card {
+    width: min(92vw, 420px); padding: 32px 28px; border-radius: 14px;
+    background: #1e2128; border: 1px solid #2e323c; box-shadow: 0 8px 32px rgba(0,0,0,.4);
+    box-sizing: border-box;
+  }
+  h1 { margin: 0 0 6px; font-size: 20px; font-weight: 600; }
+  p { margin: 0 0 14px; font-size: 13px; color: #9aa1ad; line-height: 1.7; }
+  p.tip { margin-bottom: 22px; }
+  code {
+    padding: 1px 5px; border-radius: 4px; background: #16181d; border: 1px solid #3a3f4b;
+    font-size: 12px; color: #c9d1e0; word-break: break-all;
+  }
+  input {
+    width: 100%; box-sizing: border-box; padding: 10px 12px; border-radius: 8px;
+    border: 1px solid #3a3f4b; background: #16181d; color: #e6e8ec; font-size: 15px;
+    outline: none;
+  }
+  input:focus { border-color: #5b8cff; }
+  button {
+    width: 100%; margin-top: 14px; padding: 10px 0; border: 0; border-radius: 8px;
+    background: #3d6dff; color: #fff; font-size: 15px; font-weight: 600; cursor: pointer;
+  }
+  button:disabled { opacity: .6; cursor: default; }
+  .msg { min-height: 18px; margin-top: 12px; font-size: 13px; text-align: center; }
+  .err { color: #ff7a76; }
+  .ok { color: #63d17c; }
+</style>
+</head>
+<body>
+  <form class="card" id="form">
+    <h1>需要登录</h1>
+    <p>粘贴当前<strong>启动令牌</strong>完成登录。登录后此设备免令牌 30 天（按域名:端口分别持有）。</p>
+    <p class="tip">令牌随每次 dsh web 重启更新，获取方式：服务器上执行 <code>dshctl url</code>，或查看启动日志 <code>journalctl -u dsh-web | grep "dsh web:"</code>（链接中 token= 后的部分）。PWA 内打开本页粘贴一次即可恢复。</p>
+    <input id="token" type="password" placeholder="启动令牌" autocomplete="off" autofocus>
+    <button id="btn" type="submit">登录</button>
+    <div class="msg" id="msg"></div>
+  </form>
+<script>
+  var form = document.getElementById('form');
+  var input = document.getElementById('token');
+  var btn = document.getElementById('btn');
+  var msg = document.getElementById('msg');
+  form.addEventListener('submit', function (event) {
+    event.preventDefault();
+    var token = input.value.trim();
+    if (!token) { msg.className = 'msg err'; msg.textContent = '请输入启动令牌'; return; }
+    btn.disabled = true;
+    msg.className = 'msg'; msg.textContent = '登录中…';
+    // 官方令牌交换：同源 fetch 跟随 303，交换响应的 Set-Cookie 由浏览器落罐。
+    fetch('/?token=' + encodeURIComponent(token), { redirect: 'follow' })
+      .then(function (res) {
+        if (res.ok) { msg.className = 'msg ok'; msg.textContent = '登录成功，正在进入…'; location.replace('/'); }
+        else if (res.status === 401) { msg.className = 'msg err'; msg.textContent = '令牌无效或已过期（令牌随每次重启更新）'; btn.disabled = false; }
+        else { msg.className = 'msg err'; msg.textContent = '登录失败（HTTP ' + res.status + '）'; btn.disabled = false; }
+      })
+      .catch(function () { msg.className = 'msg err'; msg.textContent = '网络错误，请重试'; btn.disabled = false; });
+  });
+</script>
+</body>
+</html>`
+}

package/src/login-page.ts

@@ -1,77 +0,0 @@
-/**
- * 登录页：围栏拦截浏览器导航请求时返回的内联 HTML。
- * 自包含（无外部静态资源依赖）、中文、vanilla JS——输入 token → 调
- * /dsh-plus/gate/login → 成功后 reload 放行。
- * @module access-gate/login-page
- */
-
-export function renderLoginPage(): string {
-  return `<!DOCTYPE html>
-<html lang="zh-CN">
-<head>
-<meta charset="utf-8">
-<meta name="viewport" content="width=device-width, initial-scale=1">
-<title>访问校验</title>
-<style>
-  :root { color-scheme: dark; }
-  body {
-    margin: 0; min-height: 100vh; display: flex; align-items: center; justify-content: center;
-    background: #16181d; color: #e6e8ec;
-    font-family: system-ui, -apple-system, "Segoe UI", Roboto, "PingFang SC", "Noto Sans CJK SC", sans-serif;
-  }
-  .card {
-    width: min(92vw, 360px); padding: 32px 28px; border-radius: 14px;
-    background: #1e2128; border: 1px solid #2e323c; box-shadow: 0 8px 32px rgba(0,0,0,.4);
-    box-sizing: border-box;
-  }
-  h1 { margin: 0 0 6px; font-size: 20px; font-weight: 600; }
-  p { margin: 0 0 22px; font-size: 13px; color: #9aa1ad; line-height: 1.6; }
-  input {
-    width: 100%; box-sizing: border-box; padding: 10px 12px; border-radius: 8px;
-    border: 1px solid #3a3f4b; background: #16181d; color: #e6e8ec; font-size: 15px;
-    outline: none;
-  }
-  input:focus { border-color: #5b8cff; }
-  button {
-    width: 100%; margin-top: 14px; padding: 10px 0; border: 0; border-radius: 8px;
-    background: #3d6dff; color: #fff; font-size: 15px; font-weight: 600; cursor: pointer;
-  }
-  button:disabled { opacity: .6; cursor: default; }
-  .msg { min-height: 18px; margin-top: 12px; font-size: 13px; text-align: center; }
-  .err { color: #ff7a76; }
-  .ok { color: #63d17c; }
-</style>
-</head>
-<body>
-  <form class="card" id="form">
-    <h1>此页面受访问控制保护</h1>
-    <p>当前网络不在放行名单内。输入访问令牌以继续；或使用名单内的设备/网络访问。</p>
-    <input id="token" type="password" placeholder="访问令牌" autocomplete="off" autofocus>
-    <button id="btn" type="submit">继续访问</button>
-    <div class="msg" id="msg"></div>
-  </form>
-<script>
-  var form = document.getElementById('form');
-  var input = document.getElementById('token');
-  var btn = document.getElementById('btn');
-  var msg = document.getElementById('msg');
-  form.addEventListener('submit', function (event) {
-    event.preventDefault();
-    var token = input.value;
-    if (!token) { msg.className = 'msg err'; msg.textContent = '请输入访问令牌'; return; }
-    btn.disabled = true;
-    msg.className = 'msg'; msg.textContent = '校验中…';
-    fetch('/dsh-plus/gate/login', {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ token: token })
-    }).then(function (res) {
-      if (res.ok) { msg.className = 'msg ok'; msg.textContent = '校验通过，正在进入…'; location.reload(); }
-      else if (res.status === 429) { msg.className = 'msg err'; msg.textContent = '失败次数过多，请稍后再试'; btn.disabled = false; }
-      else { msg.className = 'msg err'; msg.textContent = '令牌无效'; btn.disabled = false; }
-    }).catch(function () { msg.className = 'msg err'; msg.textContent = '网络错误，请重试'; btn.disabled = false; });
-  });
-</script>
-</body>
-</html>`
-}