@feiyang666/dsh-mobile-remote 1.7.1 → 1.9.0

package/lib/index.js

@@ -33,6 +33,7 @@ import {
   existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync, rmSync,
 } from 'node:fs'
 import { spawn } from 'node:child_process'
+import http from 'node:http'
 import qrcode from './qrcode.js'
 import {
   startExternal, stopExternal, externalView,
@@ -42,8 +43,14 @@ import {
 import {
   hasPassword, verifyPassword, setPassword,
   isEnabled, login, verifyToken, revokeToken, clearSessions,
+  getSetting, setSetting,
 } from './password.js'
 import { wsAvailable } from './ws-client.js'
+import { createLanProxy } from './lanproxy.js'
+import {
+  patchFilePath, isManagedPatchEnabled, profileName, isLoopbackHost,
+  migrateLegacyPatch,
+} from './patch.js'
 
 /** 插件名（loader 诊断用）。 */
 export const name = 'dsh-mobile-remote'
@@ -51,6 +58,170 @@ export const name = 'dsh-mobile-remote'
 /** 依赖 dsh-host-webserver 注入的 webServer 服务，保证 tapIndex / register 可用。 */
 export const inject = ['webServer']
 
+// ------------------------------------------------------------
+//  新版 dsh（>=0.1.2-rc.1）Web UI 浏览器会话认证适配
+//  新版 dsh 每次启动生成一次性令牌，任何浏览器访问首页都必须先带
+//  `?token=`（服务端 303 + Set-Cookie 后跳回 /），否则返回 401。手机扫码 /
+//  手动输入 LAN 地址访问的是同一个 dsh Web UI，同样受该认证保护。
+//  因此本插件在返回「手机访问地址 / 二维码 URL / 外网 URL」时，若宿主提供了
+//  官方 connection 服务（dsh-client-connection 的 BrowserAuth），就用其
+//  authenticatedUrl() 自动附加 token；老版 dsh（无 connection / 无认证）时
+//  返回原 URL，行为与旧版完全一致。
+// ------------------------------------------------------------
+/**
+ * 用宿主 connection 服务的 authenticatedUrl() 给访问 URL 附加认证 token。
+ * 老版 dsh（无 connection / 未提供该方法）时原样返回，兼容旧版与命令行裸启。
+ * @param {import('@deepseek-ai/cordis').Context} ctx
+ * @param {string} base - 形如 http://192.168.1.5:3080 的裸访问地址
+ * @returns {string} 带 token 的完整访问地址（或原地址）
+ */
+function resolveConnection(ctx) {
+  if (!ctx) return undefined
+  // 1) cordis：ctx.get(name) 默认 strict=true，只返回「provider fiber 已激活」的服务。
+  //    插件 fiber 未 inject connection 时可能取不到，故补非严格与属性两条回退。
+  if (typeof ctx.get === 'function') {
+    try {
+      const strict = ctx.get('connection')
+      if (strict) return strict
+    } catch (e) { /* 继续回退 */ }
+    try {
+      const loose = ctx.get('connection', false)
+      if (loose) return loose
+    } catch (e) { /* 继续回退 */ }
+  }
+  // 2) 少数宿主把服务直接挂在 ctx 上（ctx.connection 在未 inject 时可能抛错）。
+  try {
+    if (ctx.connection) return ctx.connection
+  } catch (e) { /* 忽略 */ }
+  return undefined
+}
+
+function withAuthUrl(ctx, base) {
+  if (!base || typeof base !== 'string') return base
+  try {
+    const conn = resolveConnection(ctx)
+    if (conn && typeof conn.authenticatedUrl === 'function') {
+      return conn.authenticatedUrl(base)
+    }
+  } catch (e) { /* 取 connection 失败则按无认证处理，返回原 URL */ }
+  return base
+}
+
+/**
+ * 把「带 token 的绝对地址」降级成 origin 相对的 `/?token=…`。
+ * 浏览器按当前协议 + authority 解析，因此 http / https / 反代路径前缀都能正确工作，
+ * 也避开了反代跨协议 301 丢 token 的问题。
+ * @param {string|null} absUrl - authenticatedUrl() 的返回值
+ * @returns {string|null} 形如 `/?token=xxx` 的相对地址；拿不到 token 时返回 null
+ */
+function relativeTokenLocation(absUrl) {
+  if (!absUrl || typeof absUrl !== 'string') return null
+  try {
+    const u = new URL(absUrl)
+    // 直接透传原始 pathname + search，不解析、不重新编码 token：
+    // token 是 base64url，经 searchParams 往返会引入 +/空格 之类的编码歧义。
+    if (!u.search || !/[?&]token=/.test(u.search)) return null
+    const path = u.pathname && u.pathname !== '' ? u.pathname : '/'
+    return `${path}${u.search}`
+  } catch (e) {
+    return null
+  }
+}
+
+
+/**
+ * 判断该请求对浏览器而言的真实协议。
+ * 外网访问通常经 nginx / frp 反代，本机看到的永远是明文 HTTP，
+ * 因此必须优先信任反代设置的 X-Forwarded-Proto，否则会生成 http:// 跳转，
+ * 被反代再 301 回 https，形成协议来回跳转。
+ * @param {import('node:http').IncomingMessage} req
+ * @returns {'http'|'https'}
+ */
+function requestScheme(req) {
+  try {
+    const xf = req.headers['x-forwarded-proto']
+    if (typeof xf === 'string' && xf.trim()) {
+      // 可能是 "https, http" 这样的列表，取最外层（第一个）。
+      const first = xf.split(',')[0].trim().toLowerCase()
+      if (first === 'https' || first === 'http') return first
+    }
+    // 直连时按 socket 是否 TLS 判断（本插件自身不终结 TLS，通常为 http）。
+    if (req.socket && req.socket.encrypted) return 'https'
+  } catch (e) { /* 忽略，回落 http */ }
+  return 'http'
+}
+
+/**
+ * 取宿主的浏览器会话认证器（connection.browserAuth）。
+ * 新版 dsh（>=0.1.2）由它完成 token → cookie 的官方握手；
+ * HostConnectionService 自身即 BrowserAuth 的委托层，字段不可见时可直接复用。
+ * @param {import('@deepseek-ai/cordis').Context} ctx
+ * @returns {object|undefined}
+ */
+function resolveBrowserAuth(ctx) {
+  const conn = resolveConnection(ctx)
+  if (!conn) return undefined
+  if (conn.browserAuth) return conn.browserAuth
+  if (typeof conn.authorizeIndex === 'function' && typeof conn.authenticatedUrl === 'function') return conn
+  return undefined
+}
+
+// ------------------------------------------------------------
+//  裸地址直达（自动登录）
+//  手机 / 远程设备直接访问裸地址（http://192.168.x.x:3080，不带 token）时，
+//  官方 dsh 会返回 401 纯文本提示。本插件接管 GET /：
+//    · 未授权  → 302 到带 token 的 URL（服务端自动完成官方 303 + Set-Cookie）
+//    · 已授权  → 返回官方 index（经内部请求取回，含全部 index taps 注入）
+//  官方 token → cookie 的握手完整保留，只是把「手动重开带 token 链接」自动化。
+//  内部拉取时需临时注销本插件的 / 路由，让请求直达官方 index owner。
+// ------------------------------------------------------------
+
+/** 简易 HTTP GET：收集 cookie、跟随 3xx 重定向（最多 4 跳），返回最终响应。 */
+function httpFollow(startUrl, maxRedirects = 4) {
+  return new Promise((resolve) => {
+    const jar = new Map()
+    let current = startUrl
+    let hops = 0
+    const step = () => {
+      if (hops++ > maxRedirects) return resolve(null)
+      let u
+      try { u = new URL(current) } catch { return resolve(null) }
+      const headers = {}
+      if (jar.size) headers.cookie = [...jar.entries()].map(([k, v]) => `${k}=${v}`).join('; ')
+      const req = http.request({
+        host: u.hostname, port: Number(u.port) || 80,
+        path: u.pathname + (u.search || ''), method: 'GET', headers, timeout: 8000,
+      }, (res) => {
+        for (const sc of res.headers['set-cookie'] || []) {
+          const kv = String(sc).split(';')[0]
+          const at = kv.indexOf('=')
+          if (at > 0) jar.set(kv.slice(0, at).trim(), kv.slice(at + 1).trim())
+        }
+        if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+          res.resume()
+          try { current = new URL(res.headers.location, current).href } catch { return resolve(null) }
+          return step()
+        }
+        const chunks = []
+        res.on('data', (c) => chunks.push(c))
+        res.on('end', () => {
+          if (res.statusCode !== 200) return resolve(null)
+          const keep = {}
+          for (const h of ['content-type', 'cache-control', 'content-security-policy', 'referrer-policy', 'x-content-type-options']) {
+            if (res.headers[h]) keep[h] = res.headers[h]
+          }
+          resolve({ status: 200, headers: keep, body: Buffer.concat(chunks) })
+        })
+        res.on('error', () => resolve(null))
+      })
+      req.on('timeout', () => { req.destroy(); resolve(null) })
+      req.on('error', () => resolve(null))
+      req.end()
+    }
+    step()
+  })
+}
+
 /** 移动端断点：与 DSH 原生 SIDEBAR_AUTO_COLLAPSE = 1024 对齐。 */
 const MOBILE_MAX_WIDTH = 1024
 
@@ -78,10 +249,18 @@ function notifyChanged() {
  * @param {import('@deepseek-ai/cordis').Context} ctx
  */
 export function apply(ctx) {
-  // 当前监听地址在服务启动时即确定。
-  const remoteEnabled = ctx.webServer.host === '0.0.0.0'
+  // 宿主端口（官方桌面端用 --port 0，由系统分配，启动后才是真实值）。
   const port = ctx.webServer.port
 
+  // 局域网旁挂听众：本机监听不动，另开一份 <LAN IP>:<port> 转发到回环。
+  // 这是 0.2.1-rc.3 之后唯一不破坏本机访问的「对局域网开放」实现方式。
+  const lan = createLanProxy({
+    log: (message, error) => {
+      try { ctx.logger?.warn?.(`[dsh-mobile-remote] ${message}${error ? `: ${String(error?.message || error)}` : ''}`) } catch { /* ignore */ }
+    },
+  })
+  const remoteEnabledNow = () => lan.status().running
+
   // 活跃设备表：deviceId -> 详细设备信息（见 handleHeartbeat）。
   const devices = new Map()
   // 累计去重设备数 + 累计心跳数（进程生命周期内的统计，供设置页展示更丰富的数据）。
@@ -97,7 +276,7 @@ export function apply(ctx) {
   const external = { proc: null, status: 'idle', url: null, domain: null, tunnelPort: null }
 
   ctx.effect(() => {
-    const dispose = ctx.webServer.tapIndex((html) => injectIntoIndex(html, remoteEnabled))
+    const dispose = ctx.webServer.tapIndex((html) => injectIntoIndex(html, remoteEnabledNow()))
     return () => dispose()
   }, 'dsh-mobile-remote: index transform')
 
@@ -110,8 +289,8 @@ export function apply(ctx) {
     const dshTimer = setInterval(refreshDsh, 60_000)
 
     const disposers = [
-      ctx.webServer.register({ kind: 'exact', path: '/__dsh_remote/status', handler: authGate(handleStatus(ctx, devices, external, tracker, dshCache)) }),
-      ctx.webServer.register({ kind: 'exact', path: '/__dsh_remote/toggle', handler: authGate(handleToggle(ctx)) }),
+      ctx.webServer.register({ kind: 'exact', path: '/__dsh_remote/status', handler: authGate(handleStatus(ctx, devices, external, tracker, dshCache, lan)) }),
+      ctx.webServer.register({ kind: 'exact', path: '/__dsh_remote/toggle', handler: authGate(handleToggle(ctx, lan)) }),
       ctx.webServer.register({ kind: 'exact', path: '/__dsh_remote/heartbeat', handler: authGate(handleHeartbeat(devices, tracker)) }),
       ctx.webServer.register({ kind: 'exact', path: '/__dsh_remote/qr', handler: authGate(handleQr()) }),
       ctx.webServer.register({ kind: 'exact', path: '/__dsh_remote/external/start', handler: authGate(handleExternalStart(ctx, external)) }),
@@ -121,30 +300,224 @@ export function apply(ctx) {
       // —— SSE 实时事件流：设备心跳 / 远程开关 / 外网隧道状态变化时推送 {"type":"changed"} ——
       ctx.webServer.register({ kind: 'exact', path: '/__dsh_remote/events', handler: authGate(handleEvents()) }),
       // —— 远程访问密码门禁相关（auth 系列不套 authGate，需放行）——
-      ctx.webServer.register({ kind: 'exact', path: '/__dsh_remote/auth-status', handler: handleAuthStatus() }),
+      ctx.webServer.register({ kind: 'exact', path: '/__dsh_remote/auth-status', handler: handleAuthStatus(ctx) }),
       ctx.webServer.register({ kind: 'exact', path: '/__dsh_remote/auth', handler: handleAuth() }),
       ctx.webServer.register({ kind: 'exact', path: '/__dsh_remote/logout', handler: handleLogout() }),
       ctx.webServer.register({ kind: 'exact', path: '/__dsh_remote/set-password', handler: handleSetPassword() }),
       // —— Service Worker：远程访问首屏缓存加速（仅 HTTPS 外网生效）——
       ctx.webServer.register({ kind: 'exact', path: '/__dsh_remote/sw.js', handler: handleServiceWorker() }),
     ]
+
+    // —— 裸地址直达（自动登录）：接管 GET / ——
+    // 未授权访问裸地址时 302 到带 token 的 URL（浏览器自动完成官方 303 + Set-Cookie），
+    // 已授权时返回官方 index。官方 token→cookie 握手完整保留。
+    let rootDisposed = false
+    let rootRouteDisposer = null
+    let rootIndexCache = null // { headers, body } 官方最终 index（含全部 index taps 注入）
+    let rootIndexJob = null
+
+    const registerRootRoute = () => {
+      if (rootDisposed || rootRouteDisposer) return
+      rootRouteDisposer = ctx.webServer.register({ kind: 'exact', path: '/', handler: rootHandler })
+    }
+
+    // 内部拉取官方 index：临时注销本插件的 / 路由，让请求直达官方 index owner
+    // （frontend-static，经完整授权检查与全部 taps），取回最终 HTML 后缓存并重新注册。
+    // 关键：必须用「带 token 的本机地址」拉取；若宿主启用浏览器会话认证而此处拿不到
+    // token，官方会回 401，则 rootIndexCache 保持 null，由调用方回退到官方 index owner。
+    const ensureRootIndex = () => {
+      if (rootIndexCache) return Promise.resolve(rootIndexCache)
+      if (!rootIndexJob) {
+        rootIndexJob = (async () => {
+          if (rootRouteDisposer) { try { rootRouteDisposer() } catch { /* ignore */ } rootRouteDisposer = null }
+          try {
+            await new Promise((r) => setTimeout(r, 30))
+            const p = port || 3080
+            // 0.2.1 起宿主只绑一块具体网卡（不再允许 0.0.0.0），回环地址可能根本没在监听，
+            // 内部取 index 必须走真实绑定地址，否则 ECONNREFUSED → 首页被回 401。
+            const bindHost = String(ctx.webServer?.host || '127.0.0.1')
+            const localBase = `http://${bindHost.includes(':') ? `[${bindHost}]` : bindHost}:${p}/`
+            const tokenUrl = withAuthUrl(ctx, localBase)
+            const same = tokenUrl === localBase
+            rootIndexCache = await httpFollow(tokenUrl)
+            // 无 token 可用且官方回 401：说明宿主强制认证但本上下文取不到 browserAuth。
+            // 绝不能把空结果当成可用 index，交由调用方走官方 index owner。
+            if (same && rootIndexCache === null) {
+              try { ctx.logger?.warn?.('[dsh-mobile-remote] 无法获取浏览器会话 token：首页自动登录不可用，已交回官方认证') } catch { /* ignore */ }
+            }
+          } catch { /* 保持 null，由调用方回退 */ }
+          registerRootRoute()
+          rootIndexJob = null
+          return rootIndexCache
+        })()
+      }
+      return rootIndexJob
+    }
+
+    async function handleRootRequest(req, res) {
+      const conn = resolveConnection(ctx)
+      const ba = resolveBrowserAuth(ctx)
+      let url
+      try { url = new URL(req.url ?? '/', 'http://x') } catch { url = new URL('/', 'http://x') }
+      if (ba) {
+        if (url.searchParams.has('token') && typeof ba.authorizeIndex === 'function') {
+          // 带 token：走官方握手（匹配 → 303 + Set-Cookie；无效 → 官方 401），浏览器自动跟随
+          const ok = ba.authorizeIndex(req, res)
+          if (!ok) return
+          // ok===true：该请求已可授权，继续 serve index
+        } else if (typeof ba.isAuthenticated === 'function' && !ba.isAuthenticated(req)) {
+          // 未授权的裸地址访问：自动登录——302 到带 token 的地址，
+          // 浏览器自动完成官方 303 + Set-Cookie 后回到裸 /，全程无感。
+          const host = req.headers.host || `127.0.0.1:${port || 3080}`
+          const scheme = requestScheme(req)
+          const target = typeof conn.authenticatedUrl === 'function'
+            ? conn.authenticatedUrl(`${scheme}://${host}/`)
+            : (typeof ba.authenticatedUrl === 'function' ? ba.authenticatedUrl(`${scheme}://${host}/`) : null)
+          // 关键：跳转地址一律降级为「相对地址」（只保留 ?token=…）。
+          // 原因是外网访问经 nginx / frp 反代时，本进程只看到明文 HTTP，
+          // 无法可靠推断浏览器侧的协议：若发出 http:// 绝对地址，反代会再
+          // 301 回 https，且 token 在这一次跨协议跳转中被丢掉，握手永远完不成
+          // （表现为外网打不开、/api 一直 401）。相对地址由浏览器按当前
+          // 协议与 authority 自行解析，http/https/反代前缀全都正确。
+          const relative = relativeTokenLocation(target)
+          if (relative) {
+            res.writeHead(302, { location: relative, 'cache-control': 'no-store' })
+            res.end()
+            return
+          }
+          // 取不到 token：不能回 302 到自身（会导致浏览器无限重定向循环），
+          // 明确回 401，交回官方语义。
+          res.writeHead(401, { 'content-type': 'text/plain; charset=utf-8', 'cache-control': 'no-store' })
+          res.end('dsh web authentication required; reopen the URL printed by dsh web.\n')
+          return
+        }
+      }
+      // 已授权 / 老版 dsh 无认证 / 取不到 browserAuth：交回官方 index owner。
+      // token 可用时 ensureRootIndex 会带回完整 index；否则保持 null，由下方回退。
+      const idx = await ensureRootIndex()
+      if (idx) {
+        res.writeHead(200, idx.headers)
+        res.end(idx.body)
+        return
+      }
+      if (ba) {
+        // 已确证存在认证器却仍拿不到 index：说明确实需要认证，明确回 401，
+        // 而不是把 503「启动中」这种误导性状态返回给手机端。
+        res.writeHead(401, { 'content-type': 'text/plain; charset=utf-8', 'cache-control': 'no-store' })
+        res.end('dsh web authentication required; reopen the URL printed by dsh web.\n')
+        return
+      }
+      res.writeHead(503, { 'content-type': 'text/plain; charset=utf-8' })
+      res.end('dsh web is starting, please try again in a moment.')
+    }
+
+    const rootHandler = (req, res) => {
+      void handleRootRequest(req, res).catch(() => {
+        try { if (!res.headersSent) { res.writeHead(500); res.end() } } catch { /* ignore */ }
+      })
+    }
+    registerRootRoute()
+
     const timer = setInterval(() => {
       const now = Date.now()
       for (const [id, info] of devices) {
         if (now - info.lastSeen > HEARTBEAT_TTL) devices.delete(id)
       }
     }, HEARTBEAT_SWEEP)
+    // —— 局域网开关的自恢复与旧配置迁移 ——
+    // 旧版本靠「patch 里写入 webserver.host」开启远程，那个块在新版会毁掉本机回环
+    // 监听（官方桌面端窗口直接白屏）。这里先把它清掉，再按配置项重建旁挂听众。
+    const migrationTimers = []
+    const restoreRemote = async () => {
+      const warn = (msg) => { try { ctx.logger?.warn?.(msg) } catch { /* ignore */ } }
+      const migrate = () => {
+        try {
+          const result = migrateLegacyPatch(ctx)
+          if (result.changed) {
+            warn('[dsh-mobile-remote] 已迁移旧版本遗留配置：不再改写 webserver 绑定（改为受管 connection.trustedHosts + 旁挂 LAN 听众）')
+          }
+        } catch (error) {
+          warn(`[dsh-mobile-remote] 旧配置迁移失败：${String(error?.message || error)}`)
+        }
+      }
+      if (isLoopbackHost(ctx.webServer.host)) {
+        // 旧绑定没生效（比如当前 profile 本来就没写过）：直接清理，不影响运行中的监听
+        migrate()
+      } else {
+        // 旧版本把 webserver 绑到了局域网 IP：现在改会触发一次重载把监听拉回回环，
+        // 必须等 HMR watcher 就绪后再写，否则这一次写入不会触发重载。
+        const timer = setTimeout(() => {
+          migrate()
+          warn('[dsh-mobile-remote] 监听已切回本机回环；局域网访问由插件的旁挂听众提供')
+        }, 4000)
+        migrationTimers.push(timer)
+      }
+      // 旧版本以「受管 patch 存在」表示开启；首次升级时迁移成持久化配置项
+      if (getSetting('remoteEnabled', null) === null) {
+        try { setSetting('remoteEnabled', isManagedPatchEnabled(ctx)) } catch { /* ignore */ }
+      }
+      if (getSetting('remoteEnabled', false) !== true) return
+      try {
+        const result = await enableRemote(ctx, lan)
+        if (!result.running) {
+          try { ctx.logger?.warn?.('[dsh-mobile-remote] 局域网监听恢复失败（端口可能已被占用），可在设置页重新开启') } catch { /* ignore */ }
+        }
+      } catch (error) {
+        try { ctx.logger?.warn?.(`[dsh-mobile-remote] 局域网监听恢复失败：${String(error?.message || error)}`) } catch { /* ignore */ }
+      }
+    }
+    void restoreRemote()
+
     // dsh 重启后自动恢复外网访问：读取持久化的绑定码 / 中转地址重新拉起 frpc，
     // 免去每次手动输入。设置 DSH_DISABLE_AUTO_RESTORE=1 可关闭该行为。
     if (process.env.DSH_DISABLE_AUTO_RESTORE !== '1') {
       const patchFile = patchFilePath(ctx)
       void autoRestoreExternal(external, patchFile, ctx.webServer.port || 3080)
     }
+
+    // ---- 端口自适应 ----
+    // frpc 代理的 localPort 必须始终等于当前真实监听端口，否则流量会打到无人监听
+    // 的端口上，表现为外网域名 502 Bad Gateway（frpc 日志：connect to local
+    // service ... refused）。端口可能因 --port 变更、被占用后回退到 0（OS 分配）、
+    // 或 profile patch 改动而变化，因此这里持续跟随，变化即重新绑定隧道。
+    let lastKnownPort = ctx.webServer.port || 0
+    const portWatcher = setInterval(() => {
+      const now = ctx.webServer.port || 0
+      if (!now || now === lastKnownPort) return
+      const from = lastKnownPort
+      lastKnownPort = now
+      // 局域网听众也要跟着端口走（否则手机地址指向一个没人监听的端口）
+      if (lan.status().running) {
+        void lan.start(getLanAddresses(), now).then((result) => {
+          if (result.running) {
+            try { ctx.logger?.info?.(`[dsh-mobile-remote] 监听端口 ${from} → ${now}，局域网听众已自适应重绑`) } catch { /* ignore */ }
+          }
+        }).catch(() => { /* 忽略 */ })
+      }
+      const persisted = loadPersistedState()
+      // 仅在隧道确实在跑、且有绑定码可复用时才自动重绑（避免无谓打中转服务器）。
+      if (external.proc && external.proc.exitCode === null && persisted && persisted.bindCode) {
+        void startExternal(external, {
+          bindCode: persisted.bindCode,
+          serverBase: persisted.serverBase || undefined,
+        }, patchFilePath(ctx), now).catch(() => { /* 状态由 startExternal 内部记录 */ })
+        try {
+          ctx.logger?.info?.(`[dsh-mobile-remote] 监听端口 ${from} → ${now}，外网隧道已自适应重绑`)
+        } catch { /* ignore */ }
+      }
+    }, 15_000)
+
     return () => {
       clearInterval(timer)
       clearInterval(dshTimer)
+      clearInterval(portWatcher)
+      for (const t of migrationTimers) clearTimeout(t)
       stopFrpc(external)
+      void lan.stop().catch(() => { /* 忽略 */ })
       for (const dispose of disposers) dispose()
+      // 裸地址直达（/ 接管）路由的清理
+      rootDisposed = true
+      if (rootRouteDisposer) { try { rootRouteDisposer() } catch { /* ignore */ } rootRouteDisposer = null }
     }
   }, 'dsh-mobile-remote: api routes')
 }
@@ -183,15 +556,19 @@ function json(res, status, body) {
   res.end(payload)
 }
 
-/** 本机局域网 IPv4 地址列表（不含回环）。 */
+/** 本机局域网 IPv4 地址列表（不含回环与 APIPA 自动私有地址）。 */
 function getLanAddresses() {
   const out = []
   for (const entries of Object.values(networkInterfaces() ?? {})) {
     for (const iface of entries ?? []) {
-      if (iface.family === 'IPv4' && !iface.internal) out.push(iface.address)
+      if (iface.family !== 'IPv4' || iface.internal) continue
+      if (String(iface.address).startsWith('169.254.')) continue
+      if (!out.includes(iface.address)) out.push(iface.address)
     }
   }
-  return out
+  // 私有网段优先，其它（如公网直连地址）排后面：设置页展示与监听顺序都更符合直觉
+  const score = (ip) => (/^192\.168\./.test(ip) ? 3 : /^10\./.test(ip) ? 2 : /^172\.(1[6-9]|2\d|3[01])\./.test(ip) ? 1 : 0)
+  return out.sort((a, b) => score(b) - score(a))
 }
 
 /** 所有 IPv4 网卡详情（含网卡名 / 掩码 / MAC / CIDR / 是否回环），供设置页展示。 */
@@ -213,8 +590,11 @@ function getLanInterfaces() {
   return out
 }
 
-/** 当前进程运行时信息（诊断用，设置页展示）。 */
-function runtimeInfo() {
+/**
+ * 当前进程运行时信息（诊断用，设置页展示）。
+ * @param {import('@deepseek-ai/cordis').Context} [ctx]
+ */
+function runtimeInfo(ctx) {
   // 采集时刻：前端可据此在两次 /status 轮询之间本地累加，让"运行时长"每秒跳动。
   const at = Date.now()
   const mem = process.memoryUsage()
@@ -241,7 +621,8 @@ function runtimeInfo() {
     rss: mem.rss,
     heapUsed: mem.heapUsed,
     heapTotal: mem.heapTotal,
-    profile: process.env.DSH_PROFILE || 'web',
+    // profile 以宿主实际加载的 profileContext 为准（官方桌面端不设 DSH_PROFILE 环境变量）
+    profile: profileName(ctx),
     dshHome: process.env.DSH_HOME || join(homedir(), '.dsh'),
   }
 }
@@ -254,13 +635,27 @@ function withTimeout(promise, ms, fallback = null) {
   ])
 }
 
-/** 多位置探测 dsh 版本号（profile 本地 / 桌面版 / 全局安装）。找不到返回 null。 */
-function detectDshVersion() {
-  const home = process.env.DSH_HOME || join(homedir(), '.dsh')
-  const profile = process.env.DSH_PROFILE || 'web'
-  const candidates = [
-    join(home, 'profiles', profile, 'node_modules', '@deepseek-ai', 'dsh', 'package.json'),
-  ]
+/**
+ * 当前运行的 profile 目录（宿主 profileContext 优先）。
+ * @param {import('@deepseek-ai/cordis').Context} [ctx]
+ * @returns {string|null}
+ */
+function profileDirOf(ctx) {
+  try {
+    const pc = typeof ctx?.get === 'function' ? ctx.get('profileContext') : ctx?.profileContext
+    if (pc && typeof pc.dir === 'string' && pc.dir) return pc.dir
+  } catch { /* 忽略 */ }
+  return null
+}
+
+/**
+ * 多位置探测 dsh 版本号（profile 本地 / 桌面版 / 全局安装）。找不到返回 null。
+ * @param {import('@deepseek-ai/cordis').Context} [ctx]
+ */
+function detectDshVersion(ctx) {
+  const candidates = []
+  const dir = profileDirOf(ctx)
+  if (dir) candidates.push(join(dir, 'node_modules', '@deepseek-ai', 'dsh', 'package.json'))
   if (process.env.APPDATA) {
     candidates.push(
       join(process.env.APPDATA, 'dsh-desktop', 'dsh-local', 'node_modules', '@deepseek-ai', 'dsh', 'package.json'),
@@ -284,7 +679,7 @@ function detectDshVersion() {
  */
 async function collectDshInfo(ctx) {
   const out = { version: null, sessions: null, workspaces: null, plugins: null, llm: null }
-  try { out.version = detectDshVersion() } catch { /* ignore */ }
+  try { out.version = detectDshVersion(ctx) } catch { /* ignore */ }
   try {
     const sp = ctx.get('sessionPersistence')
     if (sp && typeof sp.list === 'function') {
@@ -452,7 +847,7 @@ function handleEvents() {
 /** GET /__dsh_remote/auth-status：返回远程访问密码的启用状态与本次请求是否需鉴权。
  *  额外返回 service 摘要（服务名 / 本机主机名 / dsh 版本 / 当前访问域名），
  *  供密码门禁界面展示"当前是谁在提供服务"等更多信息。 */
-function handleAuthStatus() {
+function handleAuthStatus(ctx) {
   return async (req, res) => {
     json(res, 200, {
       ok: true,
@@ -465,7 +860,7 @@ function handleAuthStatus() {
       service: {
         name: 'DeepSeek Harness',
         hostname: hostname(),
-        version: detectDshVersion() || '',
+        version: detectDshVersion(ctx) || '',
         host: String(req.headers.host || ''),
       },
     })
@@ -654,81 +1049,44 @@ async function queryServerStatus(base, bindCode) {
   return data
 }
 
-/** 当前 profile 的 cordis.patch.yml 绝对路径。 */
-function patchFilePath(ctx) {
-  // DSH_HOME 环境变量优先，否则 ~/.dsh；profile 名为 DSH_PROFILE 或默认 web。
-  const home = process.env.DSH_HOME || join(homedir(), '.dsh')
-  const profile = process.env.DSH_PROFILE || 'web'
-  return join(home, 'profiles', profile, 'cordis.patch.yml')
+/**
+ * 开启局域网访问：在每块局域网网卡上旁挂一个听众，转发到宿主的回环监听。
+ *
+ * 为什么不再写 patch：
+ *   dsh 0.2.1-rc.3 起 webserver 只接受具体网卡 IP 字面量（0.0.0.0 会让启动直接失败），
+ *   而改绑局域网 IP 会让 127.0.0.1 监听消失 —— 桌面端窗口（固定连回环）立刻白屏，
+ *   官方桌面端还会因为 `--port 0` 让端口在重载后漂移。旁挂听众既不碰宿主绑定，
+ *   也不写任何配置文件：开关即时生效、无需重启、本机访问完全不受影响。
+ * @param {import('@deepseek-ai/cordis').Context} ctx
+ * @param {ReturnType<typeof createLanProxy>} proxy
+ */
+async function enableRemote(ctx, proxy) {
+  const port = ctx.webServer.port || 0
+  if (!port) throw new Error('dsh 尚未监听端口，请稍后重试')
+  const result = await proxy.start(getLanAddresses(), port)
+  if (result.running) setSetting('remoteEnabled', true)
+  return result
 }
 
 /**
- * 从 profile 的 cordis.patch.yml 中读取补丁列表（YAML 数组）。
- * 不引入 yaml 依赖：远程控制仅需对 webserver 行做增删，采用精确文本匹配。
- * @returns {{ file: string, content: string, lines: string[] }}
+ * 关闭局域网访问：释放旁挂听众，本机监听自始至终未受影响。
+ * @param {ReturnType<typeof createLanProxy>} proxy
  */
-function readPatchFile(ctx) {
-  const file = patchFilePath(ctx)
-  const content = existsSync(file) ? readFileSync(file, 'utf8') : ''
-  return { file, content, lines: content.split(/\r?\n/) }
-}
-
-/** webserver 远程控制覆盖块的行区间（含分隔注释）。不存在返回 null。 */
-function findRemoteBlock(lines) {
-  const start = lines.findIndex((l) => l.includes('# --- dsh-mobile-remote managed'))
-  if (start === -1) return null
-  const end = lines.findIndex((l, i) => i > start && l.includes('# --- end dsh-mobile-remote managed'))
-  if (end === -1) return { start, end: lines.length }
-  return { start, end: end + 1 }
-}
-
-/** 检查当前 patch 中是否已启用远程控制。 */
-function isPatchEnabled(ctx) {
-  const { lines } = readPatchFile(ctx)
-  const block = findRemoteBlock(lines)
-  if (!block) return false
-  return lines.slice(block.start, block.end).some((l) => l.includes("host: '0.0.0.0'"))
-}
-
-/** 追加 / 移除 webserver host 覆盖块。 */
-function setPatchEnabled(ctx, enabled) {
-  const { file, content, lines } = readPatchFile(ctx)
-  const block = findRemoteBlock(lines)
-  let out = lines.slice()
-  // 移除官方模板的空数组占位行 `[]`：它单独构成一个 YAML 文档，与追加的
-  // 列表块拼接会形成无 `---` 分隔符的多文档流，js-yaml 解析报
-  // "end of the stream or a document separator is expected"，导致 dsh 服务启动即崩溃。
-  out = out.filter((l) => l.trim() !== '[]')
-
-  if (block) {
-    out.splice(block.start, block.end - block.start)
-  }
-  if (enabled) {
-    const blockLines = [
-      '',
-      '# --- dsh-mobile-remote managed (auto-generated; do not edit) ---',
-      '- id: webserver',
-      '  config:',
-      "    host: '0.0.0.0'",
-      '    port: !!js ctx.webStartup.port ?? ' + (ctx.webServer.port || 3080),
-      '# --- end dsh-mobile-remote managed ---',
-      '',
-    ]
-    out = [...out, ...blockLines]
-  }
-
-  const next = out.join('\n').replace(/\n{3,}/g, '\n\n').replace(/\s*$/, '\n')
-  writeFileSync(file, next, 'utf8')
-  return { file, enabled }
+async function disableRemote(proxy) {
+  await proxy.stop()
+  setSetting('remoteEnabled', false)
 }
 
 /** GET /__dsh_remote/status */
-function handleStatus(ctx, devices, external, tracker, dshCache) {
+function handleStatus(ctx, devices, external, tracker, dshCache, proxy) {
   return async (req, res) => {
     const lan = getLanAddresses()
-    const remoteEnabled = ctx.webServer.host === '0.0.0.0'
+    const proxyState = proxy.status()
+    const remoteEnabled = proxyState.running
     // 外网 frpc 是否仍在运行
     const extRunning = !!external.proc && external.proc.exitCode === null
+    // 手机访问地址统一附加新版 dsh 的浏览器会话 token（无认证时返回原 URL）
+    const authUrl = (u) => withAuthUrl(ctx, u)
     // 已持久化的绑定信息（重启后自动恢复用，前端据此回填表单）
     const persisted = loadPersistedState()
     // 活跃设备详情列表（按最近活跃倒序）
@@ -782,13 +1140,24 @@ function handleStatus(ctx, devices, external, tracker, dshCache) {
       lanAddresses: lan,
       lanInterfaces: getLanInterfaces(),
       remoteEnabled,
-      patchEnabled: isPatchEnabled(ctx),
+      // 本机监听地址（新版永远是回环：局域网访问由旁挂听众转发，不再改绑定）
+      bindHost: ctx.webServer.host,
+      // 旁挂听众的实时状态（开启后有 running/hosts/port）
+      lan: {
+        running: proxyState.running,
+        hosts: proxyState.hosts,
+        port: proxyState.port,
+      },
+      patchEnabled: isManagedPatchEnabled(ctx),
       deviceCount: devices.size,
       devices: deviceList,
       patchFile: patchFilePath(ctx),
-      url: lan.length ? `http://${lan[0]}:${ctx.webServer.port}` : null,
+      profile: profileName(ctx),
+      url: lan.length ? authUrl(`http://${lan[0]}:${ctx.webServer.port}`) : null,
+      // 全部局域网 IP 的「手机可访问」地址（已带新版 dsh 认证 token；无认证时即裸地址）
+      lanUrls: lan.map((ip) => authUrl(`http://${ip}:${ctx.webServer.port}`)),
       // 本机运行时信息（诊断用，设置页展示更详细的数据）
-      runtime: runtimeInfo(),
+      runtime: runtimeInfo(ctx),
       uptime: Math.floor(process.uptime()),
       nodeVersion: process.version,
       totalDevicesEver: tracker.seenEver.size,
@@ -801,7 +1170,7 @@ function handleStatus(ctx, devices, external, tracker, dshCache) {
         enabled: extRunning,
         running: extRunning,
         status: external.status || 'idle',
-        url: extRunning ? external.url : null,
+        url: extRunning && external.url ? authUrl(external.url) : null,
         domain: external.domain,
         tunnelPort: external.tunnelPort,
         frpcVersion: external.frpcVersion || null,
@@ -839,26 +1208,43 @@ function handleStatus(ctx, devices, external, tracker, dshCache) {
       },
       cliHint: remoteEnabled
         ? null
-        : 'remote control is off; toggle it in settings or start dsh with --patch',
+        : 'remote control is off; toggle it in settings (no restart required)',
     })
   }
 }
 
 /** POST /__dsh_remote/toggle { enabled: boolean } */
-function handleToggle(ctx) {
+function handleToggle(ctx, proxy) {
   return async (req, res) => {
     const body = await readBody(req)
     const enabled = body.enabled === true
     try {
-      const result = setPatchEnabled(ctx, enabled)
-      notifyChanged() // 远程开关变化：通知 SSE 订阅者
+      if (enabled) {
+        const result = await enableRemote(ctx, proxy)
+        notifyChanged() // 远程开关变化：通知 SSE 订阅者
+        if (!result.running) {
+          const detail = (result.failures || [])
+            .map((f) => `${f.host || '?'} → ${f.error}`)
+            .join('; ') || '没有可用的局域网地址'
+          json(res, 500, { ok: false, enabled: false, error: `局域网监听失败：${detail}` })
+          return
+        }
+        const port = ctx.webServer.port || 0
+        json(res, 200, {
+          ok: true,
+          enabled: true,
+          lanHosts: result.hosts,
+          urls: result.hosts.map((ip) => `http://${ip}:${port}`),
+          note: 'lan listener started; dsh keeps listening on loopback (no restart, no patch)',
+        })
+        return
+      }
+      await disableRemote(proxy)
+      notifyChanged()
       json(res, 200, {
         ok: true,
-        enabled,
-        note: enabled
-          ? 'patch written; dsh HMR will re-listen on 0.0.0.0'
-          : 'patch removed; dsh HMR will re-listen on 127.0.0.1',
-        patchFile: result.file,
+        enabled: false,
+        note: 'lan listener stopped; local access was never affected',
       })
     } catch (error) {
       json(res, 500, { ok: false, error: String(error?.message || error) })
@@ -1560,6 +1946,114 @@ html[data-dsh-mobile] .dsh-usage-table {
     min-width: 320px !important;
   }
 }
+
+/* ================================================================== */
+/* 移动端侧栏：默认彻底收起，悬浮按钮唤出「抽屉」                        */
+/* ------------------------------------------------------------------ */
+/* 原生在 <1024px 时会把侧栏折成 56px 图标 rail（IconPanelLeft 按钮），    */
+/* 这在 390px 宽的手机上仍吃掉 14% 的横向空间；而原生展开是「挤压中栏」的   */
+/* 网格列（center 会被压到 ~110px），手机上基本不可用。                   */
+/* 因此这里改成：                                                       */
+/*   1) 收起的常态下把侧栏轨道压到 0px（内容区吃满整屏）；                */
+/*   2) 点悬浮按钮展开时，让侧栏脱离网格、变成覆盖式抽屉 + 半透明遮罩；    */
+/*   3) 抽屉的开合仍然驱动官方 store（点击原生 toggle 按钮），只是用 CSS    */
+/*      把「挤压」改写成「浮层」，因此原生交互、快捷键、aria 全部保留。     */
+/* 框架节点用 data-dsh-mobile-frame 标记（由 MOBILE_JS 打上），避免依赖    */
+/* harness 的哈希类名。                                                  */
+/* ================================================================== */
+
+/* 常态：侧栏轨道 0 宽，内容区独占整屏 */
+html[data-dsh-mobile] [data-dsh-mobile-frame] {
+  grid-template-columns: 0px minmax(0px, 1fr) minmax(0px, 0px) !important;
+}
+
+/* 抽屉打开：侧栏变成从左侧滑入的浮层 */
+html[data-dsh-mobile][data-dsh-nav='open'] [data-dsh-mobile-frame] > div:first-child {
+  position: fixed !important;
+  left: 0 !important;
+  top: 0 !important;
+  bottom: 0 !important;
+  width: min(86vw, 330px) !important;
+  max-width: 86vw !important;
+  z-index: 9010 !important;
+  overflow: hidden !important;
+  border-right: 1px solid var(--dsw-alias-border-l2, rgba(127, 127, 127, .22)) !important;
+  border-radius: 0 16px 16px 0 !important;
+  box-shadow: 0 18px 60px rgba(0, 0, 0, .38) !important;
+  animation: dshMobileNavIn .2s cubic-bezier(.2, .8, .3, 1);
+}
+
+/* 侧栏内部根节点：宽度铺满抽屉（原生在窄屏下用内联宽度 = rail 宽度） */
+html[data-dsh-mobile][data-dsh-nav='open'] [data-dsh-mobile-frame] > div:first-child > * {
+  width: 100% !important;
+  max-width: none !important;
+  height: 100% !important;
+}
+
+@keyframes dshMobileNavIn {
+  from { transform: translateX(-14px); opacity: .6; }
+  to   { transform: translateX(0); opacity: 1; }
+}
+
+/* 抽屉遮罩：点击任意空白处收起 */
+#dsh-mobile-nav-scrim {
+  position: fixed;
+  inset: 0;
+  z-index: 9005;
+  background: rgba(0, 0, 0, .46);
+  opacity: 0;
+  pointer-events: none;
+  transition: opacity .18s ease;
+  -webkit-tap-highlight-color: transparent;
+}
+
+html[data-dsh-mobile][data-dsh-nav='open'] #dsh-mobile-nav-scrim {
+  opacity: 1;
+  pointer-events: auto;
+}
+
+/* 抽屉打开时锁住背景滚动（只锁 body，不动框架自身布局） */
+html[data-dsh-mobile][data-dsh-nav='open'] body {
+  overflow: hidden !important;
+  overscroll-behavior: none;
+}
+
+/* 悬浮唤出按钮（收起态唯一入口；抽屉打开时淡出） */
+#dsh-mobile-nav-btn {
+  position: fixed;
+  top: calc(env(safe-area-inset-top, 0px) + 8px);
+  left: 8px;
+  width: 38px;
+  height: 38px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 0;
+  border: 1px solid var(--dsw-alias-border-l2, rgba(127, 127, 127, .26));
+  border-radius: 12px;
+  background: var(--dsw-alias-bg-l1, rgba(255, 255, 255, .86));
+  color: var(--dsw-alias-text-l1, inherit);
+  box-shadow: 0 2px 12px rgba(0, 0, 0, .18);
+  -webkit-backdrop-filter: blur(10px);
+  backdrop-filter: blur(10px);
+  z-index: 9020;
+  cursor: pointer;
+  transition: transform .15s ease, opacity .15s ease;
+}
+
+#dsh-mobile-nav-btn:active {
+  transform: scale(.94);
+}
+
+html[data-dsh-mobile][data-dsh-nav='open'] #dsh-mobile-nav-btn {
+  opacity: 0;
+  pointer-events: none;
+}
+
+/* 抽屉里没有可折叠的宿主时（极端情况）也不留白 */
+html[data-dsh-mobile]:not([data-dsh-nav='open']) [data-dsh-mobile-frame] > div:first-child {
+  overflow: hidden !important;
+}
 `
 
 /* ------------------------------------------------------------------ */
@@ -1978,6 +2472,155 @@ const MOBILE_JS = `
       });
     } catch (e) {}
   }
+
+  /* ------------------------------------------------------------------ */
+  /* 移动端侧栏：默认收起，悬浮按钮唤出覆盖式抽屉                          */
+  /* ------------------------------------------------------------------ */
+  /* 原生在窄屏把侧栏折成 56px 的 icon rail，展开又是「挤压中栏」的网格列——  */
+  /* 手机上一展开内容区只剩百来像素。这里保留官方 store 与原生 toggle 按钮，  */
+  /* 只用 CSS 把「挤压」改写成「浮层抽屉」：                              */
+  /*   · 常态：侧栏轨道 0px，内容吃满整屏（由 MOBILE_CSS 负责）；            */
+  /*   · 点悬浮按钮 → 触发原生 toggle（store 真正展开）→ 打上 data-dsh-nav    */
+  /*   · 点遮罩 / 按 Esc / 选中会话 → 触发原生 toggle 收起并去掉标记          */
+  function mrNavInit() {
+    if (!isMobile()) return;
+    if (document.getElementById('dsh-mobile-nav-btn')) return;
+
+    var html = document.documentElement;
+    var SIDEBAR_LABELS = ['打开侧边栏', 'Open sidebar', '展开侧边栏'];
+    var COLLAPSE_LABELS = ['收起侧边栏', 'Collapse sidebar'];
+
+    function findFrame() {
+      var overlay = document.querySelector('[data-shell-overlay]');
+      if (overlay && overlay.parentElement) return overlay.parentElement;
+      var root = document.getElementById('root');
+      return root ? root.firstElementChild : null;
+    }
+
+    function markFrame() {
+      var frame = findFrame();
+      if (!frame) return null;
+      if (!frame.hasAttribute('data-dsh-mobile-frame')) frame.setAttribute('data-dsh-mobile-frame', '');
+      return frame;
+    }
+
+    function sidebarCollapsed() {
+      var frame = findFrame();
+      return !!(frame && frame.hasAttribute('data-sidebar-collapsed'));
+    }
+
+    function findToggle(wanted) {
+      var buttons = document.querySelectorAll('button[aria-label]');
+      for (var i = 0; i < buttons.length; i++) {
+        var label = buttons[i].getAttribute('aria-label') || '';
+        for (var j = 0; j < wanted.length; j++) {
+          if (label === wanted[j]) return buttons[i];
+        }
+      }
+      return null;
+    }
+
+    /* 点原生 toggle：不自造状态，保证官方 store / aria / 快捷键始终一致 */
+    function clickNativeToggle(expand) {
+      var btn = findToggle(expand ? SIDEBAR_LABELS : COLLAPSE_LABELS);
+      if (!btn) {
+        // 兜底：带侧栏快捷键标注的按钮（命令 id: sidebar.left.toggle）
+        var alt = document.querySelector('button[aria-keyshortcuts]');
+        var all = document.querySelectorAll('button[aria-keyshortcuts]');
+        for (var k = 0; k < all.length; k++) {
+          var ks = (all[k].getAttribute('aria-keyshortcuts') || '').toLowerCase();
+          if (ks.indexOf('b') !== -1) { btn = all[k]; break; }
+        }
+        if (!btn) btn = alt;
+      }
+      if (!btn) return false;
+      try { btn.click(); return true } catch (e) { return false }
+    }
+
+    function openNav() {
+      markFrame();
+      if (sidebarCollapsed()) clickNativeToggle(true);
+      html.setAttribute('data-dsh-nav', 'open');
+      // 原生展开后会重新排版，下一帧再确认一次框架标记仍然有效
+      requestAnimationFrame(markFrame);
+    }
+
+    function closeNav() {
+      // 先撤标记：避免原生收起动画期间出现「挤压态」的中间画面
+      html.removeAttribute('data-dsh-nav');
+      if (!sidebarCollapsed()) clickNativeToggle(false);
+    }
+
+    var btn = document.createElement('button');
+    btn.id = 'dsh-mobile-nav-btn';
+    btn.type = 'button';
+    btn.setAttribute('aria-label', '打开侧边栏');
+    btn.innerHTML =
+      '<svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" ' +
+      'stroke-width="2" stroke-linecap="round" aria-hidden="true">' +
+      '<path d="M4 7h16M4 12h16M4 17h16"/></svg>';
+    btn.addEventListener('click', function (event) {
+      event.preventDefault();
+      event.stopPropagation();
+      if (html.getAttribute('data-dsh-nav') === 'open') closeNav();
+      else openNav();
+    });
+
+    var scrim = document.createElement('div');
+    scrim.id = 'dsh-mobile-nav-scrim';
+    scrim.setAttribute('aria-hidden', 'true');
+    scrim.addEventListener('click', function (event) {
+      event.preventDefault();
+      closeNav();
+    });
+
+    document.body.appendChild(scrim);
+    document.body.appendChild(btn);
+
+    // Esc 关闭（外接键盘 / 平板）
+    document.addEventListener('keydown', function (event) {
+      if (event.key === 'Escape' && html.getAttribute('data-dsh-nav') === 'open') closeNav();
+    });
+
+    // 抽屉里点了会话 / 工作区等可导航项就自动收起
+    document.addEventListener('click', function (event) {
+      if (html.getAttribute('data-dsh-nav') !== 'open') return;
+      var frame = findFrame();
+      var col = frame && frame.firstElementChild;
+      if (!col || !col.contains(event.target)) return;
+      if (event.target.closest && event.target.closest('button[aria-label]')) {
+        var label = event.target.closest('button[aria-label]').getAttribute('aria-label');
+        if (COLLAPSE_LABELS.indexOf(label) !== -1) { closeNav(); return }
+      }
+      var item = event.target.closest && event.target.closest('a,[role="option"],[role="treeitem"],[role="menuitem"]');
+      if (item) setTimeout(closeNav, 60);
+    }, true);
+
+    // 原生 toggle（含快捷键 Alt+B）改变了折叠态时，保持我们的标记同步
+    var frameWatch = null;
+    function watchFrame() {
+      var frame = markFrame();
+      if (!frame) return false;
+      if (frameWatch || typeof MutationObserver === 'undefined') return true;
+      frameWatch = new MutationObserver(function () {
+        var open = html.getAttribute('data-dsh-nav') === 'open';
+        var collapsed = frame.hasAttribute('data-sidebar-collapsed');
+        if (open && collapsed) html.removeAttribute('data-dsh-nav');
+      });
+      try { frameWatch.observe(frame, { attributes: true, attributeFilter: ['data-sidebar-collapsed'] }) } catch (e) {}
+      return true;
+    }
+
+    // 框架节点可能晚于本脚本出现：短暂重试 + 兜底轮询
+    var tries = 0;
+    (function tick() {
+      if (watchFrame()) return;
+      if (tries++ > 40) return;
+      setTimeout(tick, 250);
+    })();
+  }
+
+  try { mrNavInit(); } catch (e) {}
 })();
 `