@lenorin/dsh-tauri-launcher 1.0.6 → 1.0.8

package/lib/client.js

@@ -3,6 +3,16 @@
  * 在设置面板注册「桌面启动」分区：桌面端启动开关（含快速确认与乐观反馈）、
  * 添加快捷方式按钮、关闭确认弹窗、诊断信息（仅出错时显示）。
  * 与宿主通信走 /api/dsh-tauri-launcher/*（同源 fetch，仅回环）。
+ *
+ * 除设置分区外，本文件还承载两个与桌面端外壳（Tauri 主窗口）协作的功能，
+ * 仅在页面被 iframe 内嵌（桌面端）时启用：
+ * 1. 标题栏主题中继：把 DSH 主题方案与真实生效的 token 发给外壳（installThemeRelay）；
+ * 2. 会话导航栈 + 系统主题跟随（installSessionNav / installSystemThemeFollow）。
+ *
+ * 模块级结构（2026-09 阶段一拆分，见优化报告 v2）：
+ * - createSessionNavStack：应用层会话导航栈（纯逻辑，无 DOM/服务依赖，可单测）
+ * - retryLadder：服务就绪重试梯子（theme/change 事件、sessions 服务可能后于插件就绪）
+ * - installDesktopSection / installThemeRelay / installSystemThemeFollow / installSessionNav
  */
 window.__ModuleLoader__.load({
   id: '@lenorin/dsh-tauri-launcher',
@@ -114,12 +124,153 @@ body [class*='centerCol'] {
       },
     }
 
+    /**
+     * 服务就绪重试梯子：目标服务（theme/change 事件、sessions）可能在插件
+     * 之后才就绪，且 preference 等于默认值时不会发变化事件——用短重试保证
+     * 初始状态一定送达（成功或达到 maxTries 后停止）。返回清理函数。
+     */
+    function retryLadder(attempt, { immediate = false, intervalMs = 500, maxTries = 12 } = {}) {
+      let done = false
+      let tries = 0
+      const run = () => {
+        if (done) return
+        try {
+          if (attempt()) done = true
+        } catch { /* 服务未就绪，下一轮重试 */ }
+      }
+      if (immediate) run()
+      const timer = setInterval(() => {
+        tries += 1
+        if (done || tries >= maxTries) {
+          clearInterval(timer)
+          return
+        }
+        run()
+      }, intervalMs)
+      return () => clearInterval(timer)
+    }
+
+    /**
+     * 应用层会话导航栈（纯逻辑，无 DOM / DSH 服务依赖，可单测）。
+     * DSH 是 React SPA：切会话不产生浏览器历史条目，history.back() 无效，
+     * 前进/后退等价于在「最近访问会话」双栈上移动（对标浏览器语义）：
+     * - 非跳转来源的 current 变化 → 上一个会话压 backStack、清空 forwardStack；
+     * - goBack/goForward 弹栈跳转，当前会话压对向栈；栈条目 { id, address }
+     *   （address 供 catalog 子会话 openSubagent）；上限 cap、连续重复跳过；
+     * - 跳转前置 pendingJump 锁，防止自身触发的变化被当作用户切换重复压栈，
+     *   超时（jumpTimeoutMs）兜底解锁，由调用方传入 onUnlock 回调同步最新状态。
+     */
+    function createSessionNavStack({ cap = 50, jumpTimeoutMs = 1500 } = {}) {
+      let backStack = []
+      let forwardStack = []
+      let currentId = undefined
+      let currentAddress = undefined
+      let pendingJump = null
+      let jumpTimer = null
+
+      const pushStack = (stack, entry) => {
+        const top = stack[stack.length - 1]
+        if (top && top.id === entry.id && top.address === entry.address) return
+        stack.push(entry)
+        if (stack.length > cap) stack.shift()
+      }
+
+      const clearJumpTimer = () => {
+        if (jumpTimer) {
+          clearTimeout(jumpTimer)
+          jumpTimer = null
+        }
+      }
+
+      return {
+        /** 前进/后退两个方向当前是否可走（供外壳置灰按钮）。 */
+        status: () => ({ back: backStack.length > 0, forward: forwardStack.length > 0 }),
+        /** 以快照初始化当前会话（订阅前先取一次快照；跳转解锁后同步最新状态）。 */
+        init: (id, address) => {
+          currentId = id
+          currentAddress = address
+        },
+        /** 跳转锁是否生效中。 */
+        isPending: () => pendingJump !== null,
+        /**
+         * 非跳转来源的 current 变化。返回 true 表示状态对外可见变化（调用方应上报）。
+         * 规则：current 变 undefined 只清 address；同 id 只更新 address（不压栈）；
+         * 真正切换才压 backStack 并清空 forwardStack。
+         */
+        onExternalChange(snap) {
+          if (snap.id === undefined) {
+            currentAddress = undefined
+            return true
+          }
+          if (snap.id === currentId) {
+            if (snap.address !== undefined) currentAddress = snap.address
+            return false
+          }
+          if (currentId !== undefined) {
+            pushStack(backStack, { id: currentId, address: currentAddress })
+            forwardStack = []
+          }
+          currentId = snap.id
+          currentAddress = snap.address
+          return true
+        },
+        /**
+         * 跳转锁生效期间的变化。返回 true 表示跳转已被确认（命中目标）或被
+         * 用户的新切换取代（二者都应解锁并同步状态后上报）。
+         */
+        onPendingChange(snap) {
+          if (snap.id === pendingJump.id || (snap.id !== undefined && snap.id !== currentId)) {
+            clearJumpTimer()
+            pendingJump = null
+            currentId = snap.id
+            currentAddress = snap.address
+            return true
+          }
+          return false
+        },
+        /** 后退：弹出目标（当前会话压 forwardStack）。无可退时返回 null。 */
+        goBack() {
+          if (backStack.length === 0) return null
+          const target = backStack.pop()
+          if (currentId !== undefined) pushStack(forwardStack, { id: currentId, address: currentAddress })
+          return target
+        },
+        /** 前进：对称于 goBack。 */
+        goForward() {
+          if (forwardStack.length === 0) return null
+          const target = forwardStack.pop()
+          if (currentId !== undefined) pushStack(backStack, { id: currentId, address: currentAddress })
+          return target
+        },
+        /**
+         * 准备一次跳转：置 pendingJump 锁、同步 current，并启动超时兜底 timer。
+         * 超时先解锁再回调 onUnlock（调用方应读最新快照并上报）；跳转动作抛出
+         * 异常时调用 abortJump 回滚锁（timer 保留：到期仍会同步一次状态）。
+         */
+        jumpTo(entry, onUnlock) {
+          pendingJump = { id: entry.id, address: entry.address }
+          currentId = entry.id
+          currentAddress = entry.address
+          clearJumpTimer()
+          jumpTimer = setTimeout(() => {
+            pendingJump = null
+            onUnlock()
+          }, jumpTimeoutMs)
+        },
+        /** 跳转动作抛出异常时回滚锁。 */
+        abortJump: () => {
+          pendingJump = null
+        },
+        /** 释放 timer（插件卸载时）。 */
+        dispose: clearJumpTimer,
+      }
+    }
+
     exports.inject = ['slots']
 
-    exports.apply = function (ctx) {
-      const slots = ctx.get('slots')
-      if (slots === undefined) return
+    /* ---------- 设置分区「桌面启动」 ---------- */
 
+    function installDesktopSection(ctx, slots) {
       const styleEl = document.createElement('style')
       styleEl.dataset.plugin = '@lenorin/dsh-tauri-launcher'
       styleEl.textContent = CSS
@@ -269,14 +420,19 @@ body [class*='centerCol'] {
         { name: 'settings.section', id: 'desktop-launch', order: 30, label: '桌面启动' },
         () => React.createElement(DesktopSection, null),
       ))
+    }
 
-      // ---------- 标题栏主题中继 ----------
-      // 桌面端把 DSH 嵌在 iframe 里；这里读取官方主题服务解析出的浅/深方案，
-      // 并把 DSH 页面真实生效的设计 token（计算样式）发给启动器外壳，
-      // 让标题栏与 DSH 配色逐像素一致。仅当本页面被嵌入（iframe）时才有意义，
-      // 普通浏览器标签（window.parent === window）直接跳过。
-      // 注意：内置主题的快照 tokens 是空表，真实颜色在 CSS 变量里
-      // （body[data-ds-dark-theme] 切换），必须经 getComputedStyle 取。
+    /* ---------- 标题栏主题中继（DSH → 外壳） ---------- */
+
+    /**
+     * 桌面端把 DSH 嵌在 iframe 里；这里读取官方主题服务解析出的浅/深方案，
+     * 并把 DSH 页面真实生效的设计 token（计算样式）发给启动器外壳，
+     * 让标题栏与 DSH 配色逐像素一致。仅当本页面被嵌入（iframe）时才有意义，
+     * 普通浏览器标签（window.parent === window）直接跳过。
+     * 注意：内置主题的快照 tokens 是空表，真实颜色在 CSS 变量里
+     * （body[data-ds-dark-theme] 切换），必须经 getComputedStyle 取。
+     */
+    function installThemeRelay(ctx) {
       const readVar = (name) => {
         try {
           const style = getComputedStyle(document.body)
@@ -319,255 +475,220 @@ body [class*='centerCol'] {
         }
         themeSent = true
         window.parent.postMessage(payload, '*')
+        // 返回 true 供重试梯子判定“已送达”，停止后续重试（与历史 themeSent 语义一致）
+        return true
       }
 
       try {
         ctx.on('theme/change', postTheme)
       } catch { /* 事件不可用时依赖下面的重试梯子 */ }
 
-      // 主题服务可能在本插件之后才就绪，且 preference 等于默认值时不会发 theme/change：
-      // 用一个短重试梯子保证初始状态一定送达（成功或 6 秒后停止）。
-      let themeTries = 0
-      const themeTimer = setInterval(() => {
-        themeTries += 1
-        if (themeSent || themeTries >= 12) {
-          clearInterval(themeTimer)
-          return
-        }
-        postTheme()
-      }, 500)
-      ctx.effect(() => () => clearInterval(themeTimer), 'dsh-tauri-launcher: theme relay timer')
-
-      // ---------- 会话导航（应用层会话栈，等价浏览器前进/后退） ----------
-      // DSH 是 React SPA：切会话不产生浏览器历史条目，history.back() 无效。
-      // 这里维护"最近访问会话"栈：非本插件发起的 current 变化 → 上一个会话压
-      // backStack、清空 forwardStack；◀ 弹 backStack 跳转（当前压 forwardStack），
-      // ▶ 反向。跳转前设 pendingJump 锁，防止自身触发的变化被重复压栈，超时兜底解锁。
-      // sessions 服务存在就绪时序：一次性 ctx.get 可能拿到 undefined（静默失效），
-      // 故用重试梯子初始化；外壳每 3 秒 ping 一次，状态周期性回报实现自愈。
-      if (window.parent !== window) {
-        let navDispose = null
-        let navReady = false
+      // 主题服务可能在本插件之后才就绪，且 preference 等于默认值时不会发
+      // theme/change：用重试梯子保证初始状态一定送达（成功或 6 秒后停止）。
+      const disposeTimer = retryLadder(postTheme, {})
+      ctx.effect(() => disposeTimer, 'dsh-tauri-launcher: theme relay timer')
+    }
 
-        // 父窗口 origin：跨源读不到 window.parent.location，用 document.referrer 推导
-        let parentOrigin = 'http://tauri.localhost'
+    /* ---------- 桌面端系统主题跟随（外壳 → DSH） ---------- */
+
+    /**
+     * WebView2 页面里的 prefers-color-scheme 只有宿主显式设置
+     * PreferredColorScheme 才会随 Windows 变化，而 tauri/wry 未暴露该能力
+     * （wry#806），DSH 的 `system` 偏好会被冻结在启动时的取值。启动器轮询
+     * 到系统主题变化后经外壳 postMessage 转发到这里：偏好为 `system` 时把
+     * ThemeRuntime 持有的 MediaQueryList.matches（冻结值）覆盖为真实系统值
+     * 并触发重发布——偏好保持「跟随系统」不变，界面随真实系统主题切换；
+     * 用户手动选了固定主题时不干预。
+     * ⚠️ 兼容层 hack：依赖 ThemeRuntime 的 media/publish 运行时成员（无真
+     * 私有化），外壳升级若重命名则静默退化为现状（跟随失效，无副作用）。
+     */
+    function installSystemThemeFollow(ctx, parentOrigin) {
+      const applySystemTheme = (scheme) => {
         try {
-          if (document.referrer) parentOrigin = new URL(document.referrer).origin
-        } catch { /* 兜底 http://tauri.localhost */ }
-
-        // ---------- 桌面端系统主题跟随 ----------
-        // WebView2 页面里的 prefers-color-scheme 只有宿主显式设置
-        // PreferredColorScheme 才会随 Windows 变化，而 tauri/wry 未暴露该能力
-        // （wry#806），DSH 的 `system` 偏好会被冻结在启动时的取值。启动器轮询
-        // 到系统主题变化后经外壳 postMessage 转发到这里：偏好为 `system` 时把
-        // ThemeRuntime 持有的 MediaQueryList.matches（冻结值）覆盖为真实系统值
-        // 并触发重发布——偏好保持「跟随系统」不变，界面随真实系统主题切换；
-        // 用户手动选了固定主题时不干预。浏览器直开不进入本块（Chromium 原生跟随）。
-        // ⚠️ 兼容层 hack：依赖 ThemeRuntime 的 media/publish 运行时成员（无真
-        // 私有化），外壳升级若重命名则静默退化为现状（跟随失效，无副作用）。
-        const applySystemTheme = (scheme) => {
-          try {
-            const theme = ctx.get('theme')
-            if (!theme || !(theme.media instanceof MediaQueryList)) return
-            if (typeof theme.publish !== 'function') return
-            const snap = typeof theme.getTheme === 'function' ? theme.getTheme() : null
-            if (!snap || snap.preference !== 'system') return
-            if (snap.active && snap.active.colorScheme === scheme) return
-            const desc = Object.getOwnPropertyDescriptor(MediaQueryList.prototype, 'matches')
-            if (!desc || typeof desc.get !== 'function') return
-            const wantDark = scheme === 'dark'
-            Object.defineProperty(theme.media, 'matches', {
-              configurable: true,
-              get() { return wantDark }
-            })
-            theme.publish()
-          } catch { /* 主题服务异常：忽略，等待下次通知 */ }
-        }
-
-        const onSystemThemeMessage = (event) => {
-          const data = event.data || {}
-          if (event.source !== window.parent) return
-          if (event.origin !== parentOrigin) return
-          const scheme = data.__tbSystemTheme
-          if (scheme === 'light' || scheme === 'dark') applySystemTheme(scheme)
-        }
-        window.addEventListener('message', onSystemThemeMessage)
-        ctx.effect(() => () => window.removeEventListener('message', onSystemThemeMessage), 'dsh-tauri-launcher: system theme follow')
+          const theme = ctx.get('theme')
+          if (!theme || !(theme.media instanceof MediaQueryList)) return
+          if (typeof theme.publish !== 'function') return
+          const snap = typeof theme.getTheme === 'function' ? theme.getTheme() : null
+          if (!snap || snap.preference !== 'system') return
+          if (snap.active && snap.active.colorScheme === scheme) return
+          const desc = Object.getOwnPropertyDescriptor(MediaQueryList.prototype, 'matches')
+          if (!desc || typeof desc.get !== 'function') return
+          const wantDark = scheme === 'dark'
+          Object.defineProperty(theme.media, 'matches', {
+            configurable: true,
+            get() { return wantDark }
+          })
+          theme.publish()
+        } catch { /* 主题服务异常：忽略，等待下次通知 */ }
+      }
 
-        const initNav = () => {
-          const sessions = ctx.get('sessions')
-          const store = sessions && sessions.list
-          if (!store || typeof store.subscribe !== 'function') {
-            return false
-          }
+      const onSystemThemeMessage = (event) => {
+        const data = event.data || {}
+        if (event.source !== window.parent) return
+        if (event.origin !== parentOrigin) return
+        const scheme = data.__tbSystemTheme
+        if (scheme === 'light' || scheme === 'dark') applySystemTheme(scheme)
+      }
+      window.addEventListener('message', onSystemThemeMessage)
+      ctx.effect(() => () => window.removeEventListener('message', onSystemThemeMessage), 'dsh-tauri-launcher: system theme follow')
+    }
 
-          const CAP = 50
-          let backStack = []
-          let forwardStack = []
-          let currentId = undefined
-          let currentAddress = undefined
-          let pendingJump = null
-          let jumpTimer = null
-
-          const snapCurrent = () => {
-            const snap = store.getSnapshot()
-            return { id: snap.current, address: snap.currentAddress }
-          }
+    /* ---------- 会话导航（应用层会话栈，等价浏览器前进/后退） ---------- */
 
-          const sendStatus = () => {
-            if (window.parent === window) return
-            const payload = { __tbNavStatus: { back: backStack.length > 0, forward: forwardStack.length > 0 } }
-            try {
-              // 用 '*' 投递：WebView2 下对 http://tauri.localhost 虚拟主机的
-              // 精确 targetOrigin 匹配有丢弃嫌疑；外壳侧会校验 event.origin。
-              window.parent.postMessage(payload, '*')
-            } catch { /* 忽略 */ }
-          }
+    /**
+     * sessions 服务存在就绪时序：一次性 ctx.get 可能拿到 undefined（静默失效），
+     * 故用重试梯子初始化；外壳每 3 秒 ping 一次，状态周期性回报实现自愈。
+     */
+    function installSessionNav(ctx, parentOrigin) {
+      let navDispose = null
 
-          const pushStack = (stack, entry) => {
-            const top = stack[stack.length - 1]
-            if (top && top.id === entry.id && top.address === entry.address) return
-            stack.push(entry)
-            if (stack.length > CAP) stack.shift()
-          }
+      const initNav = () => {
+        const sessions = ctx.get('sessions')
+        const store = sessions && sessions.list
+        if (!store || typeof store.subscribe !== 'function') {
+          return false
+        }
 
-          const jumpTo = (entry) => {
-            pendingJump = { id: entry.id, address: entry.address }
-            currentId = entry.id
-            currentAddress = entry.address
-            clearTimeout(jumpTimer)
-            jumpTimer = setTimeout(() => {
-              pendingJump = null
-              const snap = snapCurrent()
-              currentId = snap.id
-              currentAddress = snap.address
-              sendStatus()
-            }, 1500)
-            try {
-              if (entry.address) sessions.openSubagent(entry.address)
-              else sessions.open(entry.id)
-            } catch {
-              pendingJump = null
-            }
-          }
+        const snapCurrent = () => {
+          const snap = store.getSnapshot()
+          return { id: snap.current, address: snap.currentAddress }
+        }
 
-          const goBack = () => {
-            if (backStack.length === 0) return
-            const target = backStack.pop()
-            if (currentId !== undefined) pushStack(forwardStack, { id: currentId, address: currentAddress })
-            sendStatus()
-            jumpTo(target)
-          }
+        const nav = createSessionNavStack()
 
-          const goForward = () => {
-            if (forwardStack.length === 0) return
-            const target = forwardStack.pop()
-            if (currentId !== undefined) pushStack(backStack, { id: currentId, address: currentAddress })
-            sendStatus()
-            jumpTo(target)
-          }
+        const sendStatus = () => {
+          if (window.parent === window) return
+          const payload = { __tbNavStatus: { back: nav.status().back, forward: nav.status().forward } }
+          try {
+            // 用 '*' 投递：WebView2 下对 http://tauri.localhost 虚拟主机的
+            // 精确 targetOrigin 匹配有丢弃嫌疑；外壳侧会校验 event.origin。
+            window.parent.postMessage(payload, '*')
+          } catch { /* 忽略 */ }
+        }
 
-          const onListChange = () => {
+        const jumpTo = (entry) => {
+          nav.jumpTo(entry, () => {
+            // 超时兜底解锁：读最新快照同步当前会话并上报。
             const snap = snapCurrent()
-            if (pendingJump) {
-              if (snap.id === pendingJump.id || snap.id !== undefined && snap.id !== currentId) {
-                pendingJump = null
-                clearTimeout(jumpTimer)
-                currentId = snap.id
-                currentAddress = snap.address
-                sendStatus()
-              }
-              return
-            }
-            if (snap.id === undefined) {
-              currentAddress = undefined
-              sendStatus()
-              return
-            }
-            if (snap.id === currentId) {
-              if (snap.address !== undefined) currentAddress = snap.address
-              return
-            }
-            if (currentId !== undefined) {
-              pushStack(backStack, { id: currentId, address: currentAddress })
-              forwardStack = []
-            }
-            currentId = snap.id
-            currentAddress = snap.address
+            nav.init(snap.id, snap.address)
             sendStatus()
+          })
+          try {
+            if (entry.address) sessions.openSubagent(entry.address)
+            else sessions.open(entry.id)
+          } catch {
+            nav.abortJump()
           }
+        }
 
-          const onNavMessage = (event) => {
-            const data = event.data || {}
-            if (event.source !== window.parent) return
-            if (event.origin !== parentOrigin) return
-            const dir = data.__tbNav
-            if (dir === 'back') goBack()
-            else if (dir === 'forward') goForward()
-            else if (dir === 'ping') sendStatus()
-          }
-          window.addEventListener('message', onNavMessage)
-
-          const onKeydown = (event) => {
-            if (!event.altKey || event.ctrlKey || event.shiftKey) return
-            if (event.key === 'ArrowLeft') {
-              event.preventDefault()
-              goBack()
-            } else if (event.key === 'ArrowRight') {
-              event.preventDefault()
-              goForward()
-            }
-          }
-          window.addEventListener('keydown', onKeydown, true)
-
-          // 鼠标侧键：DOM button 3 = 后退（XButton1）、4 = 前进（XButton2）
-          const onMouseup = (event) => {
-            if (event.button === 3) {
-              event.preventDefault()
-              goBack()
-            } else if (event.button === 4) {
-              event.preventDefault()
-              goForward()
-            }
-          }
-          window.addEventListener('mouseup', onMouseup, true)
+        const goBack = () => {
+          const target = nav.goBack()
+          if (!target) return
+          sendStatus()
+          jumpTo(target)
+        }
 
-          const unsubscribe = store.subscribe(onListChange)
-          const init = snapCurrent()
-          currentId = init.id
-          currentAddress = init.address
+        const goForward = () => {
+          const target = nav.goForward()
+          if (!target) return
           sendStatus()
+          jumpTo(target)
+        }
 
-          navDispose = () => {
-            if (typeof unsubscribe === 'function') unsubscribe()
-            clearTimeout(jumpTimer)
-            window.removeEventListener('message', onNavMessage)
-            window.removeEventListener('keydown', onKeydown, true)
-            window.removeEventListener('mouseup', onMouseup, true)
+        const onListChange = () => {
+          const snap = snapCurrent()
+          if (nav.isPending()) {
+            if (nav.onPendingChange(snap)) sendStatus()
+            return
           }
-          return true
+          if (nav.onExternalChange(snap)) sendStatus()
         }
 
-        // 立即尝试一次，再走重试梯子（服务可能在之后才就绪）
-        let navTries = 0
-        try {
-          navReady = initNav()
-        } catch { /* 服务未就绪，走重试 */ }
-        const navTimer = setInterval(() => {
-          navTries += 1
-          if (navReady || navTries >= 12) {
-            clearInterval(navTimer)
-            return
+        const onNavMessage = (event) => {
+          const data = event.data || {}
+          if (event.source !== window.parent) return
+          if (event.origin !== parentOrigin) return
+          const dir = data.__tbNav
+          if (dir === 'back') goBack()
+          else if (dir === 'forward') goForward()
+          else if (dir === 'ping') sendStatus()
+        }
+        window.addEventListener('message', onNavMessage)
+
+        const onKeydown = (event) => {
+          if (!event.altKey || event.ctrlKey || event.shiftKey) return
+          if (event.key === 'ArrowLeft') {
+            event.preventDefault()
+            goBack()
+          } else if (event.key === 'ArrowRight') {
+            event.preventDefault()
+            goForward()
           }
-          try {
-            navReady = initNav()
-          } catch { /* 下一轮重试 */ }
-        }, 500)
-
-        ctx.effect(() => () => {
-          clearInterval(navTimer)
-          if (navDispose) navDispose()
-        }, 'dsh-tauri-launcher: session nav')
+        }
+        window.addEventListener('keydown', onKeydown, true)
+
+        // 鼠标侧键：DOM button 3 = 后退（XButton1）、4 = 前进（XButton2）
+        const onMouseup = (event) => {
+          if (event.button === 3) {
+            event.preventDefault()
+            goBack()
+          } else if (event.button === 4) {
+            event.preventDefault()
+            goForward()
+          }
+        }
+        window.addEventListener('mouseup', onMouseup, true)
+
+        const unsubscribe = store.subscribe(onListChange)
+        const init = snapCurrent()
+        nav.init(init.id, init.address)
+        sendStatus()
+
+        navDispose = () => {
+          if (typeof unsubscribe === 'function') unsubscribe()
+          nav.dispose()
+          window.removeEventListener('message', onNavMessage)
+          window.removeEventListener('keydown', onKeydown, true)
+          window.removeEventListener('mouseup', onMouseup, true)
+        }
+        return true
+      }
+
+      // 立即尝试一次，再走重试梯子（服务可能在之后才就绪）
+      const disposeTimer = retryLadder(initNav, { immediate: true })
+
+      ctx.effect(() => () => {
+        disposeTimer()
+        if (navDispose) navDispose()
+      }, 'dsh-tauri-launcher: session nav')
+    }
+
+    /**
+     * 父窗口 origin：跨源读不到 window.parent.location，用 document.referrer
+     * 推导（兜底 http://tauri.localhost）。
+     */
+    function deriveParentOrigin() {
+      try {
+        if (document.referrer) return new URL(document.referrer).origin
+      } catch { /* 兜底 http://tauri.localhost */ }
+      return 'http://tauri.localhost'
+    }
+
+    exports.apply = function (ctx) {
+      const slots = ctx.get('slots')
+      if (slots === undefined) return
+
+      installDesktopSection(ctx, slots)
+
+      // 主题中继内部自带 window.parent 检查（浏览器直开自动不启用）。
+      installThemeRelay(ctx)
+
+      // 以下功能仅在 iframe 内嵌（桌面端）时有意义；浏览器直开时
+      // Chromium 原生跟随系统主题、且无标题栏，直接跳过。
+      if (window.parent !== window) {
+        const parentOrigin = deriveParentOrigin()
+        installSystemThemeFollow(ctx, parentOrigin)
+        installSessionNav(ctx, parentOrigin)
       }
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lenorin/dsh-tauri-launcher",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "DSH Web 插件：基于 Tauri 2 的 DeepSeek Harness 桌面启动器，自动联动桌面快捷方式，exe 路径与探测窗口可配置。",
   "type": "module",
   "main": "lib/index.js",