dsh-workspace-plus 0.6.0 → 0.7.0

package/cordis.patch.yml

@@ -25,8 +25,18 @@
 #                  poll ride in the shared browser half, which serves them
 #                  regardless and degrades silently when this row is off.
 #
+#   sessionlog     会话日志上传 (exports "./sessionlog" ->
+#                  lib/sessionlog/index.js). Node half only, and OFF by
+#                  default. DSH's own "在使用官方模型 API 时上传 Session Log"
+#                  only ever fires while the official DeepSeek adapter performs
+#                  the request; this row reproduces it and adds a
+#                  provider-independent path, so a user on a third-party model
+#                  API can still hand the session log to DeepSeek. Its settings
+#                  page rides in the shared browser half on the same terms as
+#                  the notice page.
+#
 # Turning one row off removes exactly that half from the host while the bundle
-# and the other sub-feature keep working. The 通知 settings page also carries a
+# and the other sub-features keep working. The 通知 settings page also carries a
 # runtime "启用桌面通知" switch, so notifications can be silenced without
 # touching the row at all.
 - insert:
@@ -51,3 +61,25 @@
       #     done: true               # 任务完成
       #     aborted: true            # 任务中断
       #     error: true              # 任务出错
+    - id: sessionlog
+      name: 'dsh-workspace-plus/sessionlog'
+      # config:                      # deployment defaults for the session-log
+      #   enabled: false             # sub-feature. Ships OFF on purpose: this
+      #                              # hands conversation content to a remote
+      #                              # collector, so it must be an explicit act.
+      #                              # The 会话日志 settings page can still turn
+      #                              # it on per host.
+      #   endpoint: ''               # '' = $DSH_TELEMETRY_OTLP_URL, else the
+      #                              # DeepSeek collector the base profile uses
+      #   requestField: false        # also contribute the dsh_session_log request
+      #                              # field when nothing else owns it. OFF by
+      #                              # default: DSH performs no official-endpoint
+      #                              # check before attaching that field, so on a
+      #                              # host whose deepseek-official route points at
+      #                              # a relay it would send content to that relay.
+      #                              # Skipped anyway when the shipped
+      #                              # dsh-session-log-deepseek owns the field.
+      #   includeHistory: true       # when switched on mid-run, also send the
+      #                              # sessions that are already in the log
+      #   maxRequestBytes: 4000000   # per-request ceiling for one upload
+      #   shutdownTimeoutMillis: 3000 # drain deadline when the row unloads

package/lib/client.js

@@ -71,6 +71,18 @@
  *                         click → `dsh-notice:` protocol → host route → pending
  *                         intent → THIS half → `ctx.uiWorkspace.openSession()`.
  *
+ * The 会话日志 (sessionlog) sub-feature — the plugin's own version of DSH's
+ * "在使用官方模型 API 时上传 Session Log" preference, shipped as the
+ * `dsh-workspace-plus/sessionlog` loader row and OFF by default — adds one more
+ * seat here, described in detail at its section below:
+ *
+ *   `settings.section`    the 会话日志 settings page, writing through
+ *                         `/dsh-sessionlog/api`. The host half owns the upload
+ *                         channel; this page only renders what the host reports
+ *                         and posts one switch or endpoint change at a time. When
+ *                         the sessionlog row is off the host answers 404 and the
+ *                         page explains that state instead of erroring.
+ *
  * Only the shell's frozen platform module table may be `require`d here (react,
  * react-dom, react/jsx-runtime, @deepseek-ai/cordis,
  * @deepseek-ai/dsh-client-store, @deepseek-ai/dsh-client-ui-slots,
@@ -388,8 +400,36 @@ window.__ModuleLoader__.load({
         } AUMID 发言：${toast.appId ?? '(未知)'}`
       })()
 
+      // How a click is actually delivered, as the host reports it after
+      // registering the protocol. The host prefers a compiled windowless
+      // helper and falls back to windowless PowerShell, then to plain
+      // PowerShell, so the status line names the mode instead of promising the
+      // best case. The helper restores and focuses the window itself, but only
+      // when `focusOnClick` is on — with the switch off the host registers the
+      // same helper without that step — so the sentence must not claim a
+      // foreground window in that state. A host that predates `launcher` has no
+      // value here, and then this returns '' so the sentence reads exactly as
+      // it did before.
+      const launcherNote = (() => {
+        const focus = settings.focusOnClick === true
+        if (protocol.launcher === 'helper') {
+          return focus ? '点击助手会在无窗口的情况下把 Harness 切到前台' : '由无窗口的点击助手处理，不改变窗口的前后顺序'
+        }
+        if (protocol.launcher === 'windowless-powershell') {
+          return focus
+            ? '使用无窗口 PowerShell 助手，由 Harness 负责切到前台；首次点击可能稍慢'
+            : '使用无窗口 PowerShell 助手；首次点击可能稍慢'
+        }
+        if (protocol.launcher === 'powershell') return '兼容模式：由 PowerShell 启动，可能有窗口闪烁'
+        return ''
+      })()
+
       const protocolLine = (() => {
-        if (protocol.registered === true) return `点击通知可打开对应对话（已注册 ${protocol.scheme}:）。`
+        if (protocol.registered === true) {
+          return launcherNote
+            ? `点击通知可打开对应对话（已注册 ${protocol.scheme}:，${launcherNote}）。`
+            : `点击通知可打开对应对话（已注册 ${protocol.scheme}:）。`
+        }
         if (settings.registerProtocol === false) return '已关闭协议注册：点击通知只会把 Harness 窗口切到前台。'
         return `尚未注册 ${protocol.scheme ?? 'dsh-notice'}:，点击通知只会把 Harness 窗口切到前台。`
       })()
@@ -434,7 +474,7 @@ window.__ModuleLoader__.load({
           }),
           React.createElement(NoticeSwitchRow, {
             title: '点击时把 Harness 窗口切到前台',
-            description: '关闭后只切换对话，不改变窗口的前后顺序。',
+            description: '开启后点击通知会尽量把窗口从最小化、被遮挡或收进托盘的状态恢复并切到前台；关闭则只切换对话，不改变窗口的前后顺序。',
             checked: settings.focusOnClick === true,
             disabled,
             onChange: (next) => void send({ op: 'patch', patch: { focusOnClick: next } }),
@@ -827,6 +867,357 @@ window.__ModuleLoader__.load({
       document.head.appendChild(tag)
     }
 
+    // -----------------------------------------------------------------------
+    // The 会话日志 (sessionlog) sub-feature — client side
+    //
+    // DSH's own "在使用官方模型 API 时上传 Session Log" switch lives in
+    // Settings → General and only ever fires while the official DeepSeek adapter
+    // performs the request. The `dsh-workspace-plus/sessionlog` loader row
+    // (lib/sessionlog/index.js) reproduces that behaviour and adds a
+    // provider-independent OTLP channel, so the switch means the same thing for
+    // a user on a third-party model API. It ships OFF: handing conversation
+    // content to a remote collector has to be an explicit act.
+    //
+    // This page is deliberately a *report*, not a second source of truth: the
+    // host owns enablement, the endpoint, the channel state and the counters,
+    // and answers every mutation with a fresh snapshot. A 404 means the loader
+    // row is switched off on the plugin page — a state, not a failure — and is
+    // rendered as an explanation.
+    // -----------------------------------------------------------------------
+
+    /** Settings section identity of the 会话日志 page. */
+    const SESSIONLOG_SETTINGS_SECTION_ID = 'sessionlog'
+    const SESSIONLOG_SETTINGS_SECTION_LABEL = '会话日志'
+    const SESSIONLOG_SETTINGS_SECTION_ORDER = 27
+
+    /** Host route this page talks to; must match lib/sessionlog/index.js. */
+    const SESSIONLOG_API_PATH = '/dsh-sessionlog/api'
+
+    /** Stylesheet identity for the 会话日志 settings page (one tag, rewritten on reload). */
+    const SESSIONLOG_STYLE_ID = 'dsh-workspace-plus/sessionlog.css'
+
+    /** Prefix for every class the sessionlog page injects, so it can never collide. */
+    const SESSIONLOG_CSS = `
+.dsh-sessionlog-section { display: flex; flex-direction: column; gap: 14px; }
+.dsh-sessionlog-group { display: flex; flex-direction: column; gap: 10px; }
+.dsh-sessionlog-group-title { color: var(--dsw-alias-label-secondary); font-size: 12px; font-weight: 600; letter-spacing: .04em; }
+.dsh-sessionlog-row { display: flex; align-items: flex-start; justify-content: space-between; gap: 16px; }
+.dsh-sessionlog-text { display: flex; flex-direction: column; gap: 3px; min-width: 0; }
+.dsh-sessionlog-title { color: var(--dsw-alias-label-primary); font-size: 14px; font-weight: 600; }
+.dsh-sessionlog-desc { color: var(--dsw-alias-label-secondary); font-size: 12.5px; line-height: 1.5; }
+.dsh-sessionlog-switch { position: relative; flex: none; width: 38px; height: 22px; margin-top: 2px; padding: 0; cursor: pointer; border: 1px solid var(--dsw-alias-border-l2); border-radius: 999px; background: var(--dsw-alias-bg-layer-2); transition: background .15s ease, border-color .15s ease; }
+.dsh-sessionlog-switch[aria-checked="true"] { background: var(--dsw-alias-brand-primary); border-color: var(--dsw-alias-brand-primary); }
+.dsh-sessionlog-switch:disabled { cursor: default; opacity: .5; }
+.dsh-sessionlog-knob { position: absolute; top: 2px; left: 2px; width: 16px; height: 16px; border-radius: 50%; background: var(--dsw-alias-bg-base); transition: transform .15s ease; }
+.dsh-sessionlog-switch[aria-checked="true"] .dsh-sessionlog-knob { transform: translateX(16px); }
+.dsh-sessionlog-actions { display: flex; align-items: center; gap: 8px; flex-wrap: wrap; }
+.dsh-sessionlog-button { cursor: pointer; padding: 5px 12px; font-size: 13px; border-radius: 7px; border: 1px solid var(--dsw-alias-border-l2); background: var(--dsw-alias-bg-layer-2); color: var(--dsw-alias-label-primary); }
+.dsh-sessionlog-button:hover:not(:disabled) { border-color: var(--dsw-alias-border-l1); }
+.dsh-sessionlog-button:disabled { cursor: default; opacity: .5; }
+.dsh-sessionlog-input { flex: 1 1 260px; min-width: 0; padding: 5px 9px; font-size: 12.5px; border-radius: 7px; border: 1px solid var(--dsw-alias-border-l2); background: var(--dsw-alias-bg-base); color: var(--dsw-alias-label-primary); }
+.dsh-sessionlog-status { display: flex; flex-direction: column; gap: 4px; padding: 10px 12px; border-radius: 8px; background: var(--dsw-alias-bg-layer-2); color: var(--dsw-alias-label-secondary); font-size: 12.5px; line-height: 1.6; }
+.dsh-sessionlog-mono { font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; word-break: break-all; }
+.dsh-sessionlog-error { color: var(--dsw-alias-state-error-primary); }
+.dsh-sessionlog-ok { color: var(--dsw-alias-state-success-primary); }
+`
+
+    /** Install the sessionlog stylesheet, exactly one tag per document (rewritten on reload). */
+    function ensureSessionlogStyles() {
+      if (typeof document === 'undefined') return
+      const existing = document.querySelector('style[data-plugin-css=' + JSON.stringify(SESSIONLOG_STYLE_ID) + ']')
+      if (existing !== null) {
+        existing.textContent = SESSIONLOG_CSS
+        return
+      }
+      const tag = document.createElement('style')
+      tag.dataset.plugin = 'dsh-workspace-plus'
+      tag.dataset.pluginCss = SESSIONLOG_STYLE_ID
+      tag.textContent = SESSIONLOG_CSS
+      document.head.appendChild(tag)
+    }
+
+    /**
+     * Fetch the sessionlog host's snapshot.
+     *
+     * @param signal - caller cancellation.
+     * @returns the parsed payload.
+     */
+    async function fetchSessionlogSnapshot(signal) {
+      const response = await fetch(SESSIONLOG_API_PATH, { cache: 'no-store', signal })
+      if (!response.ok) throw new Error(`host responded ${response.status}`)
+      return await response.json()
+    }
+
+    /**
+     * Post one sessionlog control operation.
+     *
+     * @param body - operation payload.
+     * @returns the parsed payload.
+     */
+    async function postSessionlogOperation(body) {
+      const response = await fetch(SESSIONLOG_API_PATH, {
+        method: 'POST',
+        cache: 'no-store',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify(body),
+      })
+      if (!response.ok && response.status >= 500) throw new Error(`host responded ${response.status}`)
+      return await response.json()
+    }
+
+    /**
+     * One labelled switch row of the 会话日志 page.
+     *
+     * @param props - `{ title, description, checked, disabled, onChange }`.
+     * @returns the row element.
+     */
+    function SessionlogSwitchRow(props) {
+      return React.createElement(
+        'div',
+        { className: 'dsh-sessionlog-row' },
+        React.createElement(
+          'div',
+          { className: 'dsh-sessionlog-text' },
+          React.createElement('div', { className: 'dsh-sessionlog-title' }, props.title),
+          props.description ? React.createElement('div', { className: 'dsh-sessionlog-desc' }, props.description) : null,
+        ),
+        React.createElement(
+          'button',
+          {
+            type: 'button',
+            role: 'switch',
+            'aria-checked': props.checked === true,
+            'aria-label': props.title,
+            disabled: props.disabled === true,
+            className: 'dsh-sessionlog-switch',
+            onClick: () => props.onChange(props.checked !== true),
+          },
+          React.createElement('span', { className: 'dsh-sessionlog-knob' }),
+        ),
+      )
+    }
+
+    /** Human label for the request-field channel's current state. */
+    function sessionlogRequestFieldLine(channel) {
+      switch (channel?.requestField) {
+        case 'active':
+          return 'dsh_session_log 请求字段：由本插件提供（官方 DeepSeek 适配器请求时随请求发出）。'
+        case 'taken':
+          return 'dsh_session_log 请求字段：已由其它插件提供（通常是内置的 dsh-session-log-deepseek），本插件自动跳过。'
+        case 'unavailable':
+          return 'dsh_session_log 请求字段：当前组合里没有 DeepSeek 扩展注册表，这一路不可用。'
+        default:
+          return 'dsh_session_log 请求字段：未启用。'
+      }
+    }
+
+    /**
+     * The 会话日志 settings page. It never predicts what the host accepted: every
+     * switch posts one key and adopts the snapshot that comes back, and a 404 —
+     * the sessionlog loader row being switched off — renders as an explanation
+     * rather than an error.
+     *
+     * `props.initial` is a test seam (the shell never passes it), matching the
+     * workspace+ page: it seeds the snapshot/status and skips the mount fetch so
+     * a test can render the ready and failure states without a live host.
+     *
+     * @param props - optional `{ initial }`.
+     * @returns the settings section element.
+     */
+    function SessionlogSettings(props) {
+      const injected = props !== null && typeof props === 'object' ? props.initial : undefined
+      const [snapshot, setSnapshot] = React.useState(injected?.snapshot ?? null)
+      const [status, setStatus] = React.useState(injected?.status ?? { kind: 'loading', message: '' })
+      const [busy, setBusy] = React.useState(injected?.busy === true)
+      const [draft, setDraft] = React.useState(String(injected?.draft ?? ''))
+
+      React.useEffect(() => {
+        if (injected !== undefined) return undefined
+        let cancelled = false
+        const controller = typeof AbortController === 'undefined' ? undefined : new AbortController()
+        ;(async () => {
+          try {
+            const payload = await fetchSessionlogSnapshot(controller?.signal)
+            if (cancelled) return
+            setSnapshot(payload)
+            setDraft(String(payload?.settings?.endpoint ?? ''))
+            setStatus({ kind: 'ready', message: '' })
+          } catch (error) {
+            if (cancelled) return
+            setStatus({ kind: 'error', message: String((error && error.message) || error) })
+          }
+        })()
+        return () => {
+          cancelled = true
+          controller?.abort()
+        }
+      }, [])
+
+      const send = React.useCallback(async (body) => {
+        setBusy(true)
+        try {
+          const payload = await postSessionlogOperation(body)
+          // A rejected operation still carries a snapshot (the host always
+          // answers with one), so the page can adopt it and show the reason.
+          if (payload !== null && typeof payload === 'object' && payload.settings !== undefined) {
+            setSnapshot(payload)
+            setDraft(String(payload.settings.endpoint ?? ''))
+          }
+          setStatus({
+            kind: payload !== null && payload.ok === true ? 'ready' : 'error',
+            message: String(payload?.message ?? ''),
+          })
+        } catch (error) {
+          setStatus({ kind: 'error', message: String((error && error.message) || error) })
+        } finally {
+          setBusy(false)
+        }
+      }, [])
+
+      if (snapshot === null) {
+        const message = status.kind === 'error' ? status.message : ''
+        if (status.kind === 'error' && message.includes('404')) {
+          return React.createElement(
+            'div',
+            { className: 'dsh-sessionlog-section' },
+            React.createElement(
+              'div',
+              { className: 'dsh-sessionlog-desc' },
+              '会话日志子功能当前未启用：在侧栏「插件」页的 dsh-workspace-plus 卡片里打开 sessionlog 这一行即可开启。',
+            ),
+          )
+        }
+        return React.createElement(
+          'div',
+          { className: 'dsh-sessionlog-section' },
+          React.createElement(
+            'div',
+            { className: 'dsh-sessionlog-desc' },
+            status.kind === 'error' ? `读取设置失败：${message}` : '正在读取设置…',
+          ),
+        )
+      }
+
+      const settings = snapshot.settings ?? {}
+      const channel = snapshot.channel ?? {}
+      const stats = snapshot.stats ?? {}
+      const on = settings.enabled === true
+      const endpointSource =
+        snapshot.endpointSource === 'settings' ? '设置页指定' : snapshot.endpointSource === 'environment' ? '环境变量' : '出厂默认'
+      const reporting = channel.reporting === true
+      const lastError = typeof stats.lastError === 'string' && stats.lastError !== '' ? stats.lastError : ''
+
+      return React.createElement(
+        'div',
+        { className: 'dsh-sessionlog-section' },
+        React.createElement(
+          'div',
+          { className: 'dsh-sessionlog-group' },
+          React.createElement(SessionlogSwitchRow, {
+            title: '上传 Session Log（帮助改进 DeepSeek 模型与产品）',
+            description:
+              '默认关闭。开启后，本机会话日志的内容会发送到 DeepSeek 的收集端点；与使用哪个模型 API 无关，因此换用第三方模型 API 时同样生效。',
+            checked: on,
+            disabled: busy,
+            onChange: (next) => void send({ op: 'patch', patch: { enabled: next } }),
+          }),
+          React.createElement(
+            'div',
+            { className: 'dsh-sessionlog-status' },
+            React.createElement('div', null, reporting ? `上报中：${stats.events ?? 0} 条事件 / ${stats.sessions ?? 0} 个会话` : on ? '已开启，等待通道就绪…' : '未开启：本机不会向 DeepSeek 发送任何会话内容。'),
+            React.createElement('div', null, channel.otlpAvailable === true ? 'OTLP 会话日志通道：可用。' : 'OTLP 会话日志通道：当前组合未挂载 otel 服务，无法上传。'),
+            React.createElement('div', null, sessionlogRequestFieldLine(channel)),
+            // The host's process-level opt-out outranks this page's switch, and
+            // saying so is the difference between "the switch is broken" and
+            // "this machine has been told not to report".
+            snapshot.killSwitch
+              ? React.createElement('div', { className: 'dsh-sessionlog-error' }, `进程级遥测开关：${String(snapshot.killSwitch)} —— 本页的开关不会覆盖它。`)
+              : null,
+            React.createElement(
+              'div',
+              { className: 'dsh-sessionlog-mono' },
+              `目标端点（${endpointSource}）：${String(snapshot.effectiveEndpoint ?? '')}`,
+            ),
+            // Redaction is unconditional, so this is a receipt rather than a control.
+            stats.redactions > 0
+              ? React.createElement(
+                  'div',
+                  { className: 'dsh-sessionlog-ok' },
+                  `已在发出前脱敏 ${String(stats.redactions)} 处凭据（token / 密钥 / Authorization）。`,
+                )
+              : null,
+            lastError ? React.createElement('div', { className: 'dsh-sessionlog-error' }, `最近一次错误：${lastError}`) : null,
+          ),
+        ),
+        React.createElement(
+          'div',
+          { className: 'dsh-sessionlog-group' },
+          React.createElement('div', { className: 'dsh-sessionlog-group-title' }, '上传范围'),
+          React.createElement(SessionlogSwitchRow, {
+            title: '同时提供 dsh_session_log 请求字段',
+            description:
+              '默认关闭。仅当官方 DeepSeek 适配器承担这次请求、且没有别的插件占用该字段时才生效；内置的 dsh-session-log-deepseek 在场时会自动跳过。注意：DSH 不检查该适配器的 baseURL 是否指向官方域名，字段会随请求发到它配置的任意端点。',
+            checked: settings.requestField === true,
+            disabled: busy || !on,
+            onChange: (next) => void send({ op: 'patch', patch: { requestField: next } }),
+          }),
+          React.createElement(SessionlogSwitchRow, {
+            title: '开启时补传已有会话历史',
+            description: '关闭后，只上传开启之后新产生的事件；已经存在的对话不会补传。',
+            checked: settings.includeHistory === true,
+            disabled: busy || !on,
+            onChange: (next) => void send({ op: 'patch', patch: { includeHistory: next } }),
+          }),
+        ),
+        React.createElement(
+          'div',
+          { className: 'dsh-sessionlog-group' },
+          React.createElement('div', { className: 'dsh-sessionlog-group-title' }, '收集端点'),
+          React.createElement(
+            'div',
+            { className: 'dsh-sessionlog-actions' },
+            React.createElement('input', {
+              type: 'text',
+              className: 'dsh-sessionlog-input',
+              spellCheck: false,
+              placeholder: '留空则使用环境变量 DSH_TELEMETRY_OTLP_URL，否则用出厂端点',
+              value: draft,
+              disabled: busy,
+              onChange: (event) => setDraft(String(event?.target?.value ?? '')),
+            }),
+            React.createElement(
+              'button',
+              {
+                type: 'button',
+                className: 'dsh-sessionlog-button',
+                disabled: busy || draft === String(settings.endpoint ?? ''),
+                onClick: () => void send({ op: 'patch', patch: { endpoint: draft } }),
+              },
+              '保存',
+            ),
+            React.createElement(
+              'button',
+              {
+                type: 'button',
+                className: 'dsh-sessionlog-button',
+                disabled: busy,
+                onClick: () => void send({ op: 'reset' }),
+              },
+              '全部恢复默认',
+            ),
+          ),
+          React.createElement(
+            'div',
+            { className: 'dsh-sessionlog-desc' },
+            '设置文件：' + String(snapshot.storePath ?? ''),
+          ),
+        ),
+        status.kind === 'error' && status.message !== ''
+          ? React.createElement('div', { className: 'dsh-sessionlog-error' }, status.message)
+          : null,
+      )
+    }
+
     ensureStyles()
 
     // The notice page's stylesheet follows the same one-tag rule; calling it in
@@ -834,6 +1225,11 @@ window.__ModuleLoader__.load({
     // `<style>` element of its own and reloads stay duplicate-free.
     ensureNoticeStyles()
 
+    // The 会话日志 page's stylesheet follows the same rule and MUST be appended
+    // last: the shell's own stylesheet checks read `head.children[0]`/`[1]` as
+    // "workspace+ then notice", so a new sheet only ever goes on the end.
+    ensureSessionlogStyles()
+
     // -----------------------------------------------------------------------
     // The workspace-directory feature
     // -----------------------------------------------------------------------
@@ -1871,11 +2267,16 @@ window.__ModuleLoader__.load({
       const bodyBlocks = (() => {
         if (state.status === 'error') {
           const unauthorized = state.message.includes('401')
+          const unavailable = state.message.includes('503')
           const unrouted = state.message.includes('404')
           /**
-           * The three failures need different advice:
+           * The four failures need different advice:
            * - 401: this document never completed the token exchange, so the
            *   connection layer has no authority to admit the request.
+           * - 503: the Host has no usable authentication service, so the route
+           *   refused the request instead of accepting an unauthenticated
+           *   change. Restarting is the ordinary fix; the route stays shut until
+           *   the connection service is mounted.
            * - 404: the request reached the Host and nothing claimed the path.
            *   The browser half hot-reloads from the served bundle, the host half
            *   does not, so a stale Host process is the ordinary cause.
@@ -1883,14 +2284,16 @@ window.__ModuleLoader__.load({
            */
           const diagnosis = unauthorized
             ? '这个页面没有带授权的会话凭据。请用 `dsh` 启动时打印的带 token 的地址重新打开 GUI（它会写入 cookie，然后跳转到干净地址）。'
-            : unrouted
-              ? '请求到达了 DSH 宿主进程，但宿主里没有注册 ' +
-                API_PATH +
-                ' 这条路由——通常意味着宿主进程还在跑旧版插件代码。浏览器半会随 bundle 热更新，宿主半不会：重启 dsh 即可。' +
-                '重启后终端会出现 [dsh-workspace-plus] host half loaded 一行；若没有，请到 设置 → 插件 查看该插件行的状态。'
-              : '这个面板通过 ' +
-                API_PATH +
-                ' 与宿主进程通信，而当前页面没有可用的 HTTP 通道（例如页面不是 dsh 提供的、或宿主进程还没起来）。'
+            : unavailable
+              ? '宿主进程没有可用的认证服务，接口按安全默认拒绝了这次请求（503）。重启 dsh 通常即可恢复；如果一直出现，说明这个宿主没有挂载 connection 认证服务，这个接口在它上面不会放行任何读写。'
+              : unrouted
+                ? '请求到达了 DSH 宿主进程，但宿主里没有注册 ' +
+                  API_PATH +
+                  ' 这条路由——通常意味着宿主进程还在跑旧版插件代码。浏览器半会随 bundle 热更新，宿主半不会：重启 dsh 即可。' +
+                  '重启后终端会出现 [dsh-workspace-plus] host half loaded 一行；若没有，请到 设置 → 插件 查看该插件行的状态。'
+                : '这个面板通过 ' +
+                  API_PATH +
+                  ' 与宿主进程通信，而当前页面没有可用的 HTTP 通道（例如页面不是 dsh 提供的、或宿主进程还没起来）。'
           return [
             noticeBlock(
               'error',
@@ -2479,6 +2882,29 @@ window.__ModuleLoader__.load({
         ),
       )
 
+      // The 会话日志 sub-feature's settings page. Same guard as the notice page:
+      // the browser half always loads with the bundle, so the page has to survive
+      // its host row being switched off (the host then answers 404 and the page
+      // renders that as a state), and a registration failure must not take the
+      // rest of this bundle down with it.
+      registerNotice(ctx, '会话日志设置页', () =>
+        ctx.effect(
+          () =>
+            ctx.slots.inject('settings.section', () =>
+              ctx.slots.register(
+                {
+                  name: 'settings.section',
+                  id: SESSIONLOG_SETTINGS_SECTION_ID,
+                  order: SESSIONLOG_SETTINGS_SECTION_ORDER,
+                  label: SESSIONLOG_SETTINGS_SECTION_LABEL,
+                },
+                SessionlogSettings,
+              ),
+            ),
+          'dsh-workspace-plus/sessionlog: settings section',
+        ),
+      )
+
       // The dialog lives in the frame-wide overlay: the same seat the shell's own
       // workspace Rename/Delete dialogs occupy.
       ctx.effect(
@@ -2622,6 +3048,17 @@ window.__ModuleLoader__.load({
     exports.NOTICE_PENDING_PATH = NOTICE_PENDING_PATH
     exports.NOTICE_POLL_INTERVAL_MS = NOTICE_POLL_INTERVAL_MS
     exports.NOTICE_POLL_RETRY_MS = NOTICE_POLL_RETRY_MS
+    exports.SESSIONLOG_SETTINGS_SECTION_ID = SESSIONLOG_SETTINGS_SECTION_ID
+    exports.SESSIONLOG_SETTINGS_SECTION_LABEL = SESSIONLOG_SETTINGS_SECTION_LABEL
+    exports.SESSIONLOG_SETTINGS_SECTION_ORDER = SESSIONLOG_SETTINGS_SECTION_ORDER
+    exports.SESSIONLOG_API_PATH = SESSIONLOG_API_PATH
+    exports.SESSIONLOG_STYLE_ID = SESSIONLOG_STYLE_ID
+    exports.ensureSessionlogStyles = ensureSessionlogStyles
+    exports.fetchSessionlogSnapshot = fetchSessionlogSnapshot
+    exports.postSessionlogOperation = postSessionlogOperation
+    exports.SessionlogSwitchRow = SessionlogSwitchRow
+    exports.SessionlogSettings = SessionlogSettings
+    exports.sessionlogRequestFieldLine = sessionlogRequestFieldLine
     exports.fetchNoticeSnapshot = fetchNoticeSnapshot
     exports.postNoticeOperation = postNoticeOperation
     exports.NoticeSwitchRow = NoticeSwitchRow

package/lib/index.js

@@ -12,7 +12,9 @@
  *      agent sees the mapping without spending a tool call
  *   3. a `workspace_dirs` Tool the agent uses to inspect or edit the mapping
  *      when the user asks in natural language
- *   4. a small JSON HTTP route the browser half uses to manage the same store
+ *   4. a small JSON HTTP route the browser half uses to manage the same store —
+ *      every request must pass the Host's `connection.admit` check, and the
+ *      route refuses (503) when that service is unavailable
  *
  * The whole point is routing by label instead of by guesswork: the injected
  * table gives absolute paths, so a similar-looking directory name elsewhere on
@@ -362,6 +364,55 @@ export function validateLabel(label) {
   return { ok: true, label: text }
 }
 
+/**
+ * Run the Host's browser trust check for one plugin request.
+ *
+ * `connection.admit(req)` is the only authority a plugin route has: the Host
+ * fence plus the GUI session cookie. This route both publishes the mapping and
+ * lets the caller rewrite it, and whatever it stores is rendered into every
+ * request's model context — so it fails closed when that authority is absent
+ * instead of falling through to "admitted":
+ *
+ * - no `connection` service mounted, or a service without `admit` — the host
+ *   composition has no auth layer (or its API drifted): refuse with 503;
+ * - `admit` throwing, rejecting, or failing to answer: the decision is
+ *   unavailable, so refuse with 503;
+ * - a rejection from `admit`: pass its 401 through, everything else is 403.
+ *
+ * The result is awaited, so a synchronous or an asynchronous `admit` is honored
+ * the same way — but only an answer that actually carries no rejection counts
+ * as an admission.
+ *
+ * The notice sub-feature deliberately grants a loopback exemption. This route
+ * does not: an unauthenticated writer could otherwise plant arbitrary text in
+ * the agent's prompt through a directory note.
+ *
+ * @param connection - the resolved `connection` service, or undefined.
+ * @param req - incoming request.
+ * @returns a promise of `{ ok: true }` or `{ ok: false, status, message }`.
+ */
+export async function checkAdmission(connection, req) {
+  const unavailable = (message) => ({ ok: false, status: 503, message })
+  if (connection === undefined || connection === null) {
+    return unavailable('host authentication service is not mounted; refusing to answer')
+  }
+  if (typeof connection.admit !== 'function') {
+    return unavailable('host authentication service has no admit(); refusing to answer')
+  }
+  let admission
+  try {
+    admission = await connection.admit(req)
+  } catch (error) {
+    return unavailable(`host authentication service failed: ${String(error?.message ?? error)}`)
+  }
+  const rejection = admission !== null && typeof admission === 'object' ? admission.rejection : undefined
+  if (rejection !== undefined) {
+    const status = rejection === 401 ? 401 : 403
+    return { ok: false, status, message: status === 401 ? 'unauthorized' : 'forbidden' }
+  }
+  return { ok: true }
+}
+
 /**
  * Apply one store operation. Every branch validates first and returns a
  * discriminated result, so both the Tool and the HTTP route share one behavior
@@ -709,11 +760,17 @@ export function apply(ctx) {
           kind: 'exact',
           path: API_PATH,
           handler: async (req, res) => {
-            const connection = ctx.get('connection')
-            const admission = connection?.admit?.(req)
-            if (admission !== undefined && 'rejection' in admission) {
-              res.writeHead(admission.rejection)
-              res.end(admission.rejection === 401 ? 'unauthorized' : 'forbidden')
+            // Fail closed. A request that cannot be admitted by the Host's
+            // connection service gets no answer at all, read or write: the
+            // mapping this route returns — and the notes it stores — become
+            // model context, so an unauthenticated caller must never reach it.
+            const admission = await checkAdmission(ctx.get('connection'), req)
+            if (!admission.ok) {
+              res.writeHead(admission.status, {
+                'content-type': 'application/json; charset=utf-8',
+                'cache-control': 'no-store',
+              })
+              res.end(JSON.stringify({ ok: false, message: admission.message }))
               return
             }
             const send = (status, payload) => {