@feiyang666/dsh-mobile-remote 1.8.1 → 1.9.0

package/lib/index.js

@@ -43,11 +43,13 @@ 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,
-  collectTrustedAuthorities, writeManagedPatch,
+  patchFilePath, isManagedPatchEnabled, profileName, isLoopbackHost,
+  migrateLegacyPatch,
 } from './patch.js'
 
 /** 插件名（loader 诊断用）。 */
@@ -247,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()
   // 累计去重设备数 + 累计心跳数（进程生命周期内的统计，供设置页展示更丰富的数据）。
@@ -266,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')
 
@@ -279,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)) }),
@@ -290,7 +300,7 @@ 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() }),
@@ -323,8 +333,12 @@ export function apply(ctx) {
           try {
             await new Promise((r) => setTimeout(r, 30))
             const p = port || 3080
-            const tokenUrl = withAuthUrl(ctx, `http://127.0.0.1:${p}/`)
-            const same = tokenUrl === `http://127.0.0.1:${p}/`
+            // 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。
@@ -410,6 +424,50 @@ export function apply(ctx) {
         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') {
@@ -428,6 +486,14 @@ export function apply(ctx) {
       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) {
@@ -445,7 +511,9 @@ export function apply(ctx) {
       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
@@ -488,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 / 是否回环），供设置页展示。 */
@@ -518,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()
@@ -546,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'),
   }
 }
@@ -559,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'),
@@ -589,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') {
@@ -757,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,
@@ -770,7 +860,7 @@ function handleAuthStatus() {
       service: {
         name: 'DeepSeek Harness',
         hostname: hostname(),
-        version: detectDshVersion() || '',
+        version: detectDshVersion(ctx) || '',
         host: String(req.headers.host || ''),
       },
     })
@@ -960,27 +1050,39 @@ async function queryServerStatus(base, bindCode) {
 }
 
 /**
- * 开启 / 关闭远程控制：把受管区域整体重写进 profile 的 cordis.patch.yml。
- * 必须同时写两块，缺一不可：
- *   1) webserver.host = '0.0.0.0'  → 手机能连上（官方 CLI 拒绝 --host 0.0.0.0，
- *      只有 patch 层能覆盖）。
- *   2) connection.trustedHosts = ['192.168.x.x:port', ...] → 手机的 /api 请求
- *      能通过 dsh 的 Host/Origin 信任围栏，否则页面能打开但功能全 403。
+ * 开启局域网访问：在每块局域网网卡上旁挂一个听众，转发到宿主的回环监听。
+ *
+ * 为什么不再写 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 {boolean} enabled
+ * @param {ReturnType<typeof createLanProxy>} proxy
  */
-function setPatchEnabled(ctx, enabled) {
-  const port = ctx.webServer.port || 3080
-  // 局域网各网卡地址都要放行（手机与主机可能不在同一网段时命中的是不同网卡）。
-  const authorities = collectTrustedAuthorities({ lanAddresses: getLanAddresses(), port })
-  return writeManagedPatch(ctx, { enabled, port, authorities })
+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
+}
+
+/**
+ * 关闭局域网访问：释放旁挂听众，本机监听自始至终未受影响。
+ * @param {ReturnType<typeof createLanProxy>} proxy
+ */
+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）
@@ -1038,15 +1140,24 @@ function handleStatus(ctx, devices, external, tracker, dshCache) {
       lanAddresses: lan,
       lanInterfaces: getLanInterfaces(),
       remoteEnabled,
+      // 本机监听地址（新版永远是回环：局域网访问由旁挂听众转发，不再改绑定）
+      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),
+      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,
@@ -1097,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) })
@@ -1818,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;
+}
 `
 
 /* ------------------------------------------------------------------ */
@@ -2236,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) {}
 })();
 `