/**
 * Reverse proxy from the orchestrator to a running per-user DSH.
 *
 * Two entry points:
 * - subpath `/u/:slug/dsh/*` (authenticated, legacy), and
 * - per-user subdomain `<username>.<baseDomain>` (HTTP + WebSocket). The DSH's
 *   absolute-path SPA requires the subdomain form: its `/assets/*` and `/api/*`
 *   resolve against the host root, which only works when each DSH owns a host.
 * @module dshs/supervisor/proxy
 */

import type { FastifyInstance, FastifyReply, FastifyRequest } from 'fastify'
import { readFileSync } from 'node:fs'
import { dirname, join } from 'node:path'
import { fileURLToPath } from 'node:url'
import { Agent, request as httpRequest, type IncomingHttpHeaders, type IncomingMessage } from 'node:http'
import { connect } from 'node:net'
import { hashSessionToken, parseCookie } from '../web/auth.js'
import { requireAuth } from '../web/middleware/authn.js'
import type { Endpoint } from './spawner.js'

// Keep-alive pool for per-user DSH upstreams. Replaced (not just destroyed) on a
// connection error, because a Pod rebuild changes its IP and any pooled socket
// to the old IP would keep failing (docs/k8s.md §5.4).
let upstreamAgent = new Agent({ keepAlive: true, maxSockets: 32 })

// Headers the DSH's browser-trust fence must NOT see from the browser, so the
// proxied request looks like a clean loopback client (its Host is overridden to
// loopback; a mismatched Origin would otherwise 403).
const STRIP_HEADERS = new Set([
  'origin',
  'referer',
  'sec-fetch-site',
  'sec-fetch-mode',
  'sec-fetch-dest',
  'sec-fetch-user',
  'x-forwarded-for',
  'x-forwarded-host',
  'x-forwarded-proto',
])


/**
 * 档案 50：注入到**实例 HTML**里的「会话过期自愈」脚本。
 *
 * 为什么需要它：实例被空闲回收后**重建**（新端口 + 新 launch token），而**已打开的页面**
 * 仍带着旧 `dsh-auth-*` cookie → 之后任何 `/api/*` XHR 都会被新实例判 **401**，
 * dsh 前端只显示 `transport failure … HTTP 401`，用户只能手动刷新。
 * 导航路径的 401 已在上面处理（302 到当前实例新 token），但 **XHR 无法靠 302 自愈**，
 * 所以给页面这段脚本：发现 `/api/*` 返回 401 就显示覆盖层并 reload ——
 * reload 会走"导航 401 → 302 新 token"这条**已经工作**的链路，从而自动恢复。
 * 仅改写响应内容，不落盘、不改官方文件（R2）；README/技能已留档。
 */
// 注入到实例子域页面的自愈脚本（档案 50 + 档案 59 增强）。
// ① 401 自愈：实例被回收重建后 launch token 轮换，页面内 /api/* 会拿到 401 → 亮覆盖层并整页 reload。
// ② 慢请求提示（档案 59）：服务端在实例未就绪时 hold 住请求最长 20 秒等拉起，
//    期间浏览器端原本毫无反馈（点了重连也看不出在等什么）→ 挂起 ≥3 秒即显示「实例正在启动」。
// ③ 回到页面自检 + 就地恢复（档案 77）：判据从「进程在不在跑」改为「页面还能不能连上实例」，
//    并把恢复过程做成**看得见**的（顶部轻提示 → 覆盖层），恢复后原地跳回而不是离开到门户域。
// 保持多行形式便于维护；注入时整段塞进 <script>，故内容不得含反引号 / ${。
// 档案 81 · R1-①：从**独立文件**加载（原先是 TS 模板字面量 —— 里面的 \n 会在模板求值时先被转义，
// 曾把整段脚本写崩成 SyntaxError，而校验跳过了"求值"这一步，形同虚设）。
// 独立文件是纯 JS：可 node --check 直接校验，不再有转义陷阱。
/** 档案 81 · R1-①：注入脚本从 `assets/inject/` 读取（纯 JS，可 node --check；无模板转义陷阱）。
 *  找不到文件 = **启动即失败**（fail-fast）：宁可平台起不来，也不要把"没有注入"的页面静默发给用户。 */
function loadInject(file: string): string {
  // ⚠️ 本项目是 ESM（package.json "type": "module"）—— **没有 __dirname**；
  // 用 import.meta.url 定位（2026-09-13 实测：写成 __dirname 会让整个平台起不来）
  const p = join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'assets', 'inject', file)
  try {
    return readFileSync(p, 'utf8')
  } catch (err) {
    throw new Error(`[inject] 读取注入脚本失败: ${p}（档案 81 R1：assets/inject 必须随包部署）: ${String(err)}`)
  }
}
const SESSION_RECOVERY_JS = loadInject('recovery.js')

/**
 * 档案 56：注入到实例页面的「实例助手」——右下角两个入口：
 *   ① 我的文件：浏览自己的工作区并**下载**任意文件（走平台 `/api/desktop/tree` + `/api/fs/download`，
 *      不暴露宿主绝对路径；此前用户拿到的只是 `/var/lib/...` 路径，浏览器打不开）；
 *   ② 能力：展示平台生成的实例能力清单（与 `bundled-skills/platform-capabilities` 同源）。
 * 另外：读取 `/api/dsh/session-permission`，若**老会话仍处于 workspace-write**（沙箱后端不可用 →
 * bash 会被 fail-closed 拒绝）则顶部给一条可操作的提示（含切换办法）。
 * 纯前端注入，不改官方包、不落盘（R2）；失败静默，绝不影响实例本身。
 */
// 档案 81 · R1-①：从**独立文件**加载（原先是 TS 模板字面量 —— 里面的 \n 会在模板求值时先被转义，
// 曾把整段脚本写崩成 SyntaxError，而校验跳过了"求值"这一步，形同虚设）。
// 独立文件是纯 JS：可 node --check 直接校验，不再有转义陷阱。
const SESSION_ASSIST_JS = loadInject('assist.js')

/** 非 HTML / 已压缩 / 无正文的状态直接透传，避免破坏二进制或已编码内容。 */
function injectRecovery(html: string): string {
  const tag =
    '<script>' + SESSION_RECOVERY_JS + '</script>' + '<script>' + SESSION_ASSIST_JS + '</script>'
  return html.includes('</body>') ? html.replace('</body>', tag + '</body>') : html + tag
}

function buildUpstreamHeaders(headers: IncomingHttpHeaders, port: number): Record<string, string | string[]> {
  const out: Record<string, string | string[]> = {}
  for (const [key, value] of Object.entries(headers)) {
    if (value === undefined || STRIP_HEADERS.has(key.toLowerCase())) continue
    out[key] = value as string | string[]
  }
  // Keep Host loopback: DSH's /api trust fence requires the Host to be loopback
  // or a `--trusted-host` authority — a real domain would 403 every /api call.
  // DSH's absolute URLs are rewritten to the real origin in proxyHttp below.
  out.host = `127.0.0.1:${port}`
  return out
}

/** 档案 51：从 freshAuthUrl 的 `?token=` 中取出当前实例的 launch token。 */
function tokenFromAuthUrl(url: string | undefined): string | undefined {
  if (url === undefined) return undefined
  const m = /[?&]token=([^&]+)/.exec(url)
  return m === null || m[1] === undefined ? undefined : decodeURIComponent(m[1])
}

/**
 * 档案 51：向**当前**实例要一份有效的浏览器凭证 cookie。
 *
 * 实例每次 (重)启动都会换 launch token **和** `dsh-auth-<随机后缀>` 的 cookie 名。
 * 已打开的页面还带着旧名字的 cookie → 新实例一律判 401。这里 GET `/?token=<当前>`
 * （实例回 303 + Set-Cookie），把 set-cookie 原样取出，供代理重放请求与回写浏览器。
 */
function fetchInstanceAuthCookies(endpoint: Endpoint, token: string): Promise<string[]> {
  return new Promise((resolve) => {
    let done = false
    const finish = (v: string[]): void => {
      if (!done) {
        done = true
        resolve(v)
      }
    }
    const req = httpRequest(
      {
        host: endpoint.host,
        port: endpoint.port,
        path: '/?token=' + encodeURIComponent(token),
        method: 'GET',
        headers: { host: `127.0.0.1:${endpoint.port}`, 'user-agent': 'dsh-proxy-auth-refresh' },
      },
      (res) => {
        const sc = res.headers['set-cookie']
        res.resume()
        finish(Array.isArray(sc) ? sc : sc === undefined ? [] : [sc])
      },
    )
    req.on('error', () => finish([]))
    req.setTimeout(5000, () => {
      req.destroy()
      finish([])
    })
    req.end()
  })
}

/**
 * 档案 51：把浏览器带来的 cookie 与实例的新 cookie 合并 —— 丢掉旧的 `dsh-auth-*`
 * （新实例只认自己那份；旧名留着也没用），其余（`sid` 等代理不关心）原样保留。
 */
function mergeCookieHeader(original: string | undefined, fresh: string[]): string {
  const keep = (original ?? '')
    .split(';')
    .map((x) => x.trim())
    .filter((x) => x !== '' && !/^dsh-auth-/.test(x))
  const add = fresh
    .map((c) => (c.split(';')[0] ?? '').trim())
    .filter((x) => x !== '')
  return [...keep, ...add].join('; ')
}

/** Extract `<slug>` from `<slug>.<baseDomain>`, or null when not a match. */
export function parseSubdomain(host: string | undefined, baseDomain: string): string | null {
  if (host === undefined || baseDomain === '') return null
  const name = host.split(':')[0] ?? ''
  if (name === baseDomain) return null
  if (name.endsWith('.' + baseDomain)) {
    const slug = name.slice(0, -(baseDomain.length + 1))
    return slug !== '' ? slug.toLowerCase() : null
  }
  return null
}

/** The per-user subdomain for a username, or null when `baseDomain` is unset. */
export function subdomainForUser(baseDomain: string, username: string): string | null {
  return baseDomain === '' ? null : `${username.toLowerCase()}.${baseDomain}`
}

/** The browser-facing origin (`<scheme>://<host>`) this request reached us with,
 * used to rewrite DSH's loopback absolute URLs back to the real domain. */
function realOrigin(headers: IncomingHttpHeaders): string | undefined {
  const host = clientHost(headers)
  if (host === undefined) return undefined
  const proto = headers['x-forwarded-proto']
  const scheme = typeof proto === 'string' && proto !== '' ? proto : 'https'
  return `${scheme}://${host}`
}

/** A subdomain resolution: a tunnelable endpoint, an error to return, or null (not a subdomain). */
type SubdomainAccess = { endpoint: Endpoint; userId: string } | { error: string; code: number; userId?: string } | null

/**
 * The client-facing host, preferring `X-Forwarded-Host`. The control plane sits
 * behind an edge proxy (Tencent nginx) that hides the real Host to sidestep the
 * cloud provider's ICP check (docs/k8s-deploy.md §7.4); the real domain arrives
 * here. The subdomain auth check still validates the cookie against the slug, so
 * a spoofed forwarded host cannot reach another user's DSH.
 */
function clientHost(headers: IncomingHttpHeaders): string | undefined {
  const fwd = headers['x-forwarded-host']
  if (typeof fwd === 'string' && fwd !== '') return fwd
  if (Array.isArray(fwd) && fwd[0] !== '') return fwd[0]
  return headers.host
}

/**
 * Resolve a subdomain Host to a DSH port, authenticating the caller: the session
 * cookie must belong to a non-disabled user whose username matches the subdomain.
 */
async function resolveSubdomainAccess(
  app: FastifyInstance,
  host: string | undefined,
  cookieHeader: string | undefined,
): Promise<SubdomainAccess> {
  const slug = parseSubdomain(host, app.config.baseDomain)
  if (slug === null) return null
  const target = await app.db.findUserBySlug(slug)
  if (target === undefined) return { error: 'unknown_user', code: 404 }
  const token = parseCookie(cookieHeader, 'sid')
  const session = token === undefined ? undefined : await app.db.findSessionWithUser(hashSessionToken(token))
  if (session === undefined || session.expiresAt <= Date.now() || session.user.role === 'disabled') {
    return { error: 'unauthorized', code: 401 }
  }
  if (session.user.username.toLowerCase() !== slug) {
    return { error: 'forbidden', code: 403 }
  }
  const endpoint = await app.supervisor.endpointFor(session.user.id)
  if (endpoint === undefined) return { error: 'not_running', code: 404, userId: session.user.id }
  // userId 一并返回：实例侧 401（launch token 过期）时用它取当前实例的新 token（档案 24）。
  // Real user traffic to their own DSH counts as activity (idle-reap signal).
  app.supervisor.touch(session.user.id)
  return { endpoint, userId: session.user.id }
}

function proxyHttp(
  request: FastifyRequest,
  reply: FastifyReply,
  endpoint: Endpoint,
  targetPath: string,
  rewritePrefix?: string,
  rewriteLoopbackLocation = false,
  useKeepAlive = false,
  /**
   * 实例侧 401 时的恢复入口（档案 24）：浏览器导航遇到 dsh 的 "authentication required"
   * （launch token 过期 —— 实例重启/回收后刷新旧标签页）时调用，返回应 302 到的地址。
   * 返回 undefined 则回落到 '/'。
   */
  freshAuthUrl?: () => Promise<string | undefined>,
): void {
  reply.hijack()
  // 档案 51：为「401 透明重放」准备请求体。
  // 只在 content-length 已知且不大时才缓冲（普通 /api JSON-RPC 请求都很小）；
  // 未知长度（chunked 上传）不缓冲 → 该请求退回旧行为（401 透传），不做重放。
  const MAX_REPLAY_BODY = 8 * 1024 * 1024
  const reqMethod = (request.raw.method ?? 'GET').toUpperCase()
  const mayHaveBody = reqMethod !== 'GET' && reqMethod !== 'HEAD'
  const clNum =
    typeof request.headers['content-length'] === 'string' ? Number(request.headers['content-length']) : NaN
  const bufferable = mayHaveBody && Number.isFinite(clNum) && clNum <= MAX_REPLAY_BODY
  let bodyBuf: Buffer | undefined
  // ★ 事后修正 1（2026-09-11）：重放闸门**不能**用 bufferable —— 它含 mayHaveBody，
  // 会让 GET/HEAD（含 dsh 的 SSE 会话流）永远无法重放。GET 没有请求体，反而最该能重放。
  const canReplay = mayHaveBody ? false : true
  let authRetryUsed = false
  let replayCookies: string[] = []

  const attempt = (connRetry: boolean, authCookie?: string): void => {
    // 档案 50 修正（实测定位）：**HTML 导航请求必须向上游要 identity**。
    // 原因：dsh 实例对带 Accept-Encoding 的请求会 **gzip 压缩 HTML**（浏览器就带），
    // 于是响应带 content-encoding → 我下面的注入逻辑**主动跳过** → 浏览器拿到的页面
    // **没有自愈脚本** → C 方案对真实用户无效（而 curl 不带 Accept-Encoding，故此前验证
    // 是假阳性）。改法：只要**客户端接受 HTML**，就覆盖转发的 accept-encoding 为 identity，
    // 让上游回未压缩 HTML → 注入成功。体积影响可忽略（HTML ~24KB），且边缘 nginx 若开 gzip
    // 仍会对浏览器压缩，用户侧无感知。静态资源/SSE 的压缩行为不受影响。
    const upHeaders = buildUpstreamHeaders(request.headers, endpoint.port)
    if (String(request.headers.accept ?? '').includes('text/html')) {
      upHeaders['accept-encoding'] = 'identity'
    }
    // 档案 51：重放时用**当前实例的新 cookie** 覆盖浏览器带来的旧 cookie。
    if (authCookie !== undefined) upHeaders.cookie = authCookie
    if (bodyBuf !== undefined) {
      // 请求体已缓冲 → 显式带上长度并去掉可能存在的 chunked 头，保证重放一致。
      delete upHeaders['transfer-encoding']
      upHeaders['content-length'] = String(bodyBuf.length)
    }
    const upstream = httpRequest(
      {
        host: endpoint.host,
        port: endpoint.port,
        path: targetPath,
        method: request.method,
        // Keep-alive only where it is required (k8s Headless Service DNS
        // re-resolution on retry — docs/k8s.md §5.4). Local mode uses a fresh
        // connection per request: the loopback connect cost is negligible and
        // this avoids the half-open keep-alive pool that hung the proxy after
        // child-instance restarts (2026-09-09 outage: pooled sockets to a
        // since-recycled instance port never errored, so requests hung).
        agent: useKeepAlive && !connRetry ? upstreamAgent : false,
        // Host header stays loopback for the DSH trust fence; the TCP target host
        // is endpoint.host above. k8s mode overrides the header port separately.
        headers: upHeaders,
      },
      (upRes: IncomingMessage) => {
        const headers = { ...upRes.headers }
        const isNav =
          request.raw.method === 'GET' && String(request.headers.accept ?? '').includes('text/html')
        // 档案 51：**非导航**请求的实例侧 401 = 页面拿着旧实例的 dsh-auth cookie。
        // 透明重放：取当前实例新 cookie → 覆盖 cookie 头重发同一请求 → 新 cookie 回写浏览器。
        // 只重放一次（authRetryUsed），避免与实例互相刷 401 造成死循环。
        const replayReady = mayHaveBody ? bodyBuf !== undefined : canReplay
        if (upRes.statusCode === 401 && !isNav && !authRetryUsed && freshAuthUrl !== undefined && replayReady) {
          authRetryUsed = true
          upRes.resume()
          void (async () => {
            let cookieHeader: string | undefined
            try {
              const url = await freshAuthUrl()
              const tk = tokenFromAuthUrl(url)
              if (tk !== undefined) {
                const fresh = await fetchInstanceAuthCookies(endpoint, tk)
                if (fresh.length > 0) {
                  replayCookies = fresh
                  cookieHeader = mergeCookieHeader(request.headers.cookie, fresh)
                }
              }
            } catch {
              /* 取不到 → 回落到原样 401 */
            }
            if (cookieHeader === undefined) {
              reply.raw.writeHead(401, headers)
              reply.raw.end('unauthorized')
              return
            }
            process.stderr.write(
              `[proxy-auth-replay] ${request.raw.method ?? 'GET'} ${targetPath}（旧 cookie → 实例新 cookie，重放）\n`,
            )
            attempt(false, cookieHeader)
          })()
          return
        }
        // 重放成功后把新 cookie 交给浏览器：之后（含 SSE 自动重连）不再需要重放。
        if (authCookie !== undefined && replayCookies.length > 0) {
          const prev = headers['set-cookie']
          headers['set-cookie'] = [
            ...(Array.isArray(prev) ? prev : prev === undefined ? [] : [prev]),
            ...replayCookies,
          ]
        }
        const location = upRes.headers.location
        if (
          rewritePrefix !== undefined &&
          typeof location === 'string' &&
          location.startsWith('/') &&
          !location.startsWith('//') &&
          !location.startsWith(rewritePrefix)
        ) {
          headers.location = rewritePrefix + location
        }
        // ── 2026-09-12（平台缓存治理）：让「改了 client bundle 却看不到变化」不再发生 ──
        //
        // 背景（档案 67 v0.2.6 实测，排查成本极高）：
        //   dsh 的客户端模块 URL 形如 `/plugins/??<pkg>/client.js,…&rev=<内容 sha1>`，
        //   `rev` 由 **dsh 官方**按内容计算（`dsh-client-modules`），**平台不得改（R2）**。
        //   平台更新 bundle 后，若 `rev` 未变 → 浏览器认为手上那份缓存仍有效 → **不重新请求**
        //   ⇒ 服务端已是新版、用户却一直看到旧 UI（本次：SQL 层/磁盘/服务端三处都验过是新的）。
        //
        // 处置：对实例的**模块/静态资源路径**统一加 `Cache-Control: no-cache` ——
        //   **允许缓存，但每次必须回源校验**（配合上游 ETag/Last-Modified 走 304，开销极小）。
        //   ⇒ bundle 一变，浏览器下一次请求就拿到新的，**用户无需清缓存/换无痕**。
        //
        // ⚠️ 勿删：这是 UI 改动能否被验收的前置机制（`06-工作台UI规范 §6.5`）。
        if (targetPath.startsWith('/plugins/') || targetPath.startsWith('/assets/')) {
          headers['cache-control'] = 'no-cache'
        }
        // local mode only: DSH builds absolute URLs from the loopback Host we
        // forward; rewrite any 127.0.0.1 Location to the real origin so the
        // browser doesn't jump to the user's own machine. k8s mode keeps its
        // verified behavior (no rewrite).
        if (
          rewriteLoopbackLocation &&
          typeof location === 'string' &&
          realOrigin(request.headers) !== undefined
        ) {
          headers.location = location.replace(/^https?:\/\/127\.0\.0\.1(:\d+)?/, realOrigin(request.headers)!)
        }
        // 2026-09-11（档案 24）：实例侧 401 = launch token 过期。浏览器导航时不要停在
        // dsh 的 "dsh web authentication required; reopen the URL printed by dsh web." 死端页，
        // 而是用当前实例的新 token 302 回同一地址（拿不到则回门户）。
        if (
          upRes.statusCode === 401 &&
          request.raw.method === 'GET' &&
          String(request.headers.accept ?? '').includes('text/html') &&
          freshAuthUrl !== undefined
        ) {
          upRes.resume()
          void freshAuthUrl()
            .then((url) => {
              reply.raw.writeHead(302, { location: url ?? '/' })
              reply.raw.end()
            })
            .catch(() => {
              reply.raw.writeHead(302, { location: '/' })
              reply.raw.end()
            })
          return
        }
        // 档案 50：HTML 响应缓冲后注入「会话过期自愈」脚本（其余一切原样 pipe，零影响）。
        const ctype = String(upRes.headers['content-type'] ?? '')
        const enc = upRes.headers['content-encoding']
        const status = upRes.statusCode ?? 502
        const canInject =
          ctype.includes('text/html') && enc === undefined && status !== 204 && status !== 304
        if (!canInject) {
          if (ctype.includes('text/html') && enc !== undefined) {
            process.stderr.write(`[inject-recovery] skip: content-encoding=${String(enc)}\n`)
          }
          reply.raw.writeHead(status, headers)
          upRes.pipe(reply.raw)
          return
        }
        const chunks: Buffer[] = []
        upRes.on('data', (c: Buffer) => chunks.push(c))
        upRes.on('end', () => {
          const out = injectRecovery(Buffer.concat(chunks).toString('utf8'))
          delete headers['content-length']
          delete headers['transfer-encoding']
          headers['content-length'] = String(Buffer.byteLength(out))
          reply.raw.writeHead(status, headers)
          reply.raw.end(out)
        })
        upRes.on('error', () => reply.raw.destroy())
      },
    )
    upstream.on('error', () => {
      if (connRetry) {
        reply.raw.destroy()
        return
      }
      // A stale keep-alive socket or a Pod that just restarted: drop the pool,
      // replace it with a fresh one, and retry once on a fresh connection.
      upstreamAgent.destroy()
      upstreamAgent = new Agent({ keepAlive: true, maxSockets: 32 })
      request.raw.unpipe(upstream)
      attempt(true)
    })
    if (bodyBuf !== undefined) upstream.end(bodyBuf)
    else request.raw.pipe(upstream)
  }
  if (!bufferable) {
    attempt(false)
    return
  }
  const pre: Buffer[] = []
  request.raw.on('data', (c: Buffer) => pre.push(c))
  request.raw.on('end', () => {
    bodyBuf = Buffer.concat(pre)
    attempt(false)
  })
  request.raw.on('error', () => reply.raw.destroy())
}

export async function registerDshProxy(app: FastifyInstance): Promise<void> {
  // Legacy authenticated subpath proxy.
  app.all('/u/:slug/dsh/*', { preHandler: requireAuth }, async (request, reply) => {
    const slug = (request.params as { slug: string }).slug
    if (request.user === null || request.user.id !== slug) {
      reply.code(403).send({ error: 'forbidden' })
      return
    }
    const endpoint = await app.supervisor.endpointFor(slug)
    if (endpoint === undefined) {
      reply.code(404).send({ error: 'not_running' })
      return
    }
    app.supervisor.touch(request.user!.id)
    const prefix = `/u/${slug}/dsh`
    const rawUrl = request.raw.url ?? '/'
    const targetPath = rawUrl.startsWith(prefix) ? rawUrl.slice(prefix.length) || '/' : rawUrl
    const pathScheme = app.config.secureCookies ? 'https' : 'http'
    proxyHttp(
      request,
      reply,
      endpoint,
      targetPath,
      prefix,
      app.config.deployMode === 'local',
      app.config.deployMode === 'k8s',
      async () => {
        const status = await app.supervisor.status(request.user!.id)
        const token = status.main?.launchToken
        return token !== undefined && token !== ''
          ? `${pathScheme}://${app.config.baseDomain}${prefix}/?token=${encodeURIComponent(token)}`
          : `${pathScheme}://${app.config.baseDomain}/`
      },
    )
  })

  // Per-user subdomain: HTTP (intercept before normal routing).
  app.addHook('onRequest', async (request, reply) => {
    const access = await resolveSubdomainAccess(app, clientHost(request.headers), request.headers.cookie)
    if (access === null) return
    if ('error' in access) {
      // 浏览器导航（GET + 期待 HTML）的 401（会话失效/退出后刷新实例子域）→ 302 回门户
      // 登录页，而不是吐 JSON {"error":"unauthorized"} 停在原地。
      if (
        access.code === 401 &&
        request.raw.method === 'GET' &&
        (request.headers.accept ?? '').includes('text/html')
      ) {
        const scheme = app.config.secureCookies ? 'https' : 'http'
        reply.redirect(`${scheme}://${app.config.baseDomain}/login.html`)
        return
      }
      // 实例未运行（后台回收/崩溃/停止/熔断后刷新会话页）→ 需要拉起。
      //
      // 2026-09-11（档案 49 · 体验修复）：**浏览器导航一律"立刻" 302 到平台自有的过渡页**，
      // 由过渡页显示加载动画并自己调 /api/dsh/enter 完成「拉起 + 等 token + 跳回」。
      // 原因：此前导航请求会在**服务端阻塞等待 launch token（最长 20 秒）**，这期间浏览器
      // 只看到白屏、没有任何反馈 → 用户以为卡死，只能手动刷新（那时实例已就绪，看似"刷新才好"）。
      // 现在导航分支**不阻塞**（0.2s 内返回 302），动画立刻出现，且**不会**在这里触发 launch
      //（拉起交给过渡页，单点、可重试）。
      if (access.code === 404 && access.error === 'not_running' && access.userId !== undefined) {
        const navScheme = app.config.secureCookies ? 'https' : 'http'
        const navHost = clientHost(request.headers) ?? app.config.baseDomain
        const isNavigation =
          request.raw.method === 'GET' && (request.headers.accept ?? '').includes('text/html')
        if (isNavigation) {
          const next = `${navScheme}://${navHost}${request.raw.url ?? '/'}`
          reply.redirect(
            `${navScheme}://${app.config.baseDomain}/wake.html?next=${encodeURIComponent(next)}`,
          )
          return
        }
        // 非导航（XHR / API）——**这是"页面已打开、再对话没反应"的主场景**。
        // 正解不是"回一个错误/动画"，而是**等实例就绪后继续转发**：请求最终成功，
        // dsh 前端自己会保持它的 loading 态 → 用户无感，不需要刷新。
        try {
          const folderAbs = app.userFs.resolvePath(access.userId, '')
          try {
            await app.supervisor.launch(access.userId, folderAbs, undefined)
          } catch {
            // 并发进场（另一请求正在拉起 → AlreadyRunningError）：等它拿到 token
            await app.supervisor.waitForLaunchTokenForUser(access.userId, 20000)
          }
        } catch {
          /* 拉起失败 → 落到下面的 503 */
        }
        const again = await resolveSubdomainAccess(app, clientHost(request.headers), request.headers.cookie)
        if (again !== null && !('error' in again)) {
          proxyHttp(
            request,
            reply,
            again.endpoint,
            request.raw.url ?? '/',
            undefined,
            app.config.deployMode === 'local',
            app.config.deployMode === 'k8s',
            async () => {
              const st = await app.supervisor.status(again.userId)
              const tk = st.main?.launchToken
              return tk !== undefined && tk !== ''
                ? `${navScheme}://${navHost}/?token=${encodeURIComponent(tk)}`
                : `${navScheme}://${app.config.baseDomain}/`
            },
          )
          return
        }
        // 真的起不来：给明确的「启动中」+ Retry-After，让前端自行退避重试。
        reply.code(503).header('retry-after', '3').send({ error: 'instance_starting' })
        return
      }
      reply.code(access.code).send({ error: access.error })
      return
    }
    const navScheme = app.config.secureCookies ? 'https' : 'http'
    const navHost = clientHost(request.headers) ?? app.config.baseDomain
    proxyHttp(
      request,
      reply,
      access.endpoint,
      request.raw.url ?? '/',
      undefined,
      app.config.deployMode === 'local',
      app.config.deployMode === 'k8s',
      async () => {
        const status = await app.supervisor.status(access.userId)
        const token = status.main?.launchToken
        return token !== undefined && token !== ''
          ? `${navScheme}://${navHost}/?token=${encodeURIComponent(token)}`
          : `${navScheme}://${app.config.baseDomain}/`
      },
    )
  })

  // Per-user subdomain: WebSocket upgrade tunnel. Auth is async (DB lookup), so
  // the raw `upgrade` callback defers to an async IIFE before deciding to tunnel.
  app.server.on('upgrade', (req, socket, head) => {
    void (async () => {
      const access = await resolveSubdomainAccess(app, clientHost(req.headers), req.headers.cookie)
      if (access === null || 'error' in access) {
        socket.destroy()
        return
      }
      const upstream = connect({ host: access.endpoint.host, port: access.endpoint.port })
      upstream.on('connect', () => {
        const lines = [`${req.method} ${req.url} HTTP/${req.httpVersion}`]
        for (let i = 0; i < req.rawHeaders.length; i += 2) {
          const name = (req.rawHeaders[i] ?? '').toLowerCase()
          if (name === 'host' || STRIP_HEADERS.has(name)) continue
          lines.push(`${req.rawHeaders[i]}: ${req.rawHeaders[i + 1]}`)
        }
        lines.push(`Host: 127.0.0.1:${access.endpoint.port}`)
        upstream.write(lines.join('\r\n') + '\r\n\r\n')
        if (head !== undefined && head.length > 0) upstream.write(head)
        socket.pipe(upstream)
        upstream.pipe(socket)
      })
      upstream.on('error', () => socket.destroy())
      socket.on('error', () => upstream.destroy())
    })()
  })
}