dsh-sidenote 0.3.2 → 0.3.4

package/src/client/sidechat/native.ts

@@ -0,0 +1,192 @@
+/**
+ * better-sidebar >= 0.19 / DSH 0.1.5 bridge.
+ *
+ * From 0.19 on, better-sidebar no longer owns the right column: it hands it to
+ * DSH's native right sidebar (`dsh-client-ui-sidebar-right`) and routes tab
+ * lifecycle calls to that surface (`openTab`/`activateTab`/`updateTab`).
+ * Sidechat tabs opened that way never enter the legacy layout store
+ * (splits/bottomSplits/floats) that `collectSideTabs` walks, so the minted tab
+ * id cannot be recovered from the snapshot — after `openTab` there is no
+ * `updateTab` target until the panel mounts and publishes itself. Drafts must
+ * therefore ride the `openTab` seed.meta (which the native surface honors) or
+ * wait for the panel's registration.
+ *
+ * This module keeps that missing link: a registry of live side-chat panels
+ * (their native tab id, their draft sink, their current meta) plus a lazy
+ * root-context holder. The root context is the plugin's own fiber — unlike the
+ * slot-provided context a panel receives, its inject list contains
+ * `workspaces`, so host calls made from it keep working on 0.1.5.
+ *
+ * Authority: dsh-better-sidebar `src/client/service.ts` (>= 0.19 surface
+ * routing) and `@deepseek-ai/dsh-api-session-controller` (remote session face).
+ */
+import type { Context } from '../host/contracts.ts'
+
+/** better-sidebar version that moved the right column to DSH's native sidebar. */
+const NATIVE_SIDEBAR_MINOR = 19
+
+let root: Context | undefined
+
+/** Remember the plugin root context at activation (see module docstring). */
+export function setRootContext(ctx: Context): void {
+  root = ctx
+}
+
+/** Plugin root context; falls back to the caller's context (legacy behaviour). */
+export function rootContext(fallback: Context): Context {
+  return root ?? fallback
+}
+
+/**
+ * True when the host keeps sidebar tabs outside the legacy layout store
+ * (better-sidebar >= 0.19). Version parse is best-effort: an unparsable
+ * version reports false, which keeps the pre-0.19 behaviour.
+ */
+export function nativeSidebarHost(ctx: Context): boolean {
+  try {
+    const [major = 0, minor = 0] = ctx.betterSidebar.version.split('.').map(part => Number.parseInt(part, 10))
+    return major > 0 || minor >= NATIVE_SIDEBAR_MINOR
+  } catch {
+    return false
+  }
+}
+
+interface LiveSideChat {
+  readonly tabId: string
+  readonly sessionId: string
+  /** Write text into the panel composer (draft delivery). */
+  seedDraft(text: string): void
+  /** Current tab meta, read at call time (the panel re-renders on meta change). */
+  readMeta(): unknown
+  /** Current tab title（聚焦列表/编号数据源的读取面）。 */
+  readTitle(): string
+}
+
+/** Native tab id → live panel. Native layouts are memory-only, so is this. */
+const liveSideChats = new Map<string, LiveSideChat>()
+
+/**
+ * tabId → 首次注册序号（打开序的近似）。tab.id 跨重挂载稳定，重注册不改写
+ * ——遍历 Map 的插入序会随重挂漂移，「最近打开」只能锚在首次序号上。
+ */
+const birthOrder = new Map<string, number>()
+let birthSeq = 0
+
+/**
+ * Publish a mounted panel so programmatic entry points can focus it and seed
+ * its draft. Returns the disposer for the panel's effect cleanup.
+ */
+export function registerLiveSideChat(
+  sessionId: string,
+  tabId: string,
+  seedDraft: (text: string) => void,
+  readMeta: () => unknown,
+  readTitle: () => string,
+): () => void {
+  const entry: LiveSideChat = { tabId, sessionId, seedDraft, readMeta, readTitle }
+  liveSideChats.set(tabId, entry)
+  if (!birthOrder.has(tabId)) birthOrder.set(tabId, ++birthSeq)
+  // 挂载即回放在 openTab→注册窗口内暂存的草稿（seedDraft 内有相位门）。
+  const opening = openings.get(sessionId)
+  if (opening !== undefined) {
+    openings.delete(sessionId)
+    for (const draft of opening.drafts) seedDraft(draft)
+  }
+  return () => {
+    if (liveSideChats.get(tabId) === entry) liveSideChats.delete(tabId)
+  }
+}
+
+// ── openTab→面板挂载窗口的 in-flight 标记 ────────────────────────────────────
+// native tab 铸造后对布局快照与 registry 同时不可见，直到面板挂载登记；窗口内
+// 的重复触发必须落进标记（草稿暂存、注册时回放），而不是再开一个 tab
+// （双开 = 双 fork 出孤儿会话）。legacy 宿主无此窗口（openTab 同步落快照）。
+
+/** 标记失效应力：openTab 被静默拒绝/面板未挂载时，超时后允许重试。 */
+const OPENING_TTL_MS = 10_000
+
+interface OpeningMark {
+  readonly at: number
+  /** 窗口内到达的待投递草稿（面板注册时经 seedDraft 回放）。 */
+  readonly drafts: string[]
+}
+
+const openings = new Map<string, OpeningMark>()
+
+/** 标记一次已发起、面板尚未注册的 native 打开（create/reopen 铸造后调用）。 */
+export function markSideChatOpening(sessionId: string): void {
+  openings.set(sessionId, { at: Date.now(), drafts: [] })
+}
+
+/** 进行中的打开；TTL 外视为 openTab 被拒/面板未挂载，清除并返回 undefined。 */
+export function sideChatOpening(sessionId: string): OpeningMark | undefined {
+  const mark = openings.get(sessionId)
+  if (mark === undefined) return undefined
+  if (Date.now() - mark.at > OPENING_TTL_MS) {
+    openings.delete(sessionId)
+    return undefined
+  }
+  return mark
+}
+
+/** Live panel for a native tab id (undefined for legacy layout tabs). */
+export function liveSideChat(tabId: string): LiveSideChat | undefined {
+  return liveSideChats.get(tabId)
+}
+
+/** 一个会话的全部存活面板（按打开序升序；native 下枚举 side tab 的唯一数据源）。 */
+export function liveSideChatsOf(sessionId: string): LiveSideChat[] {
+  return [...liveSideChats.values()]
+    .filter(entry => entry.sessionId === sessionId)
+    .sort((a, b) => (birthOrder.get(a.tabId) ?? 0) - (birthOrder.get(b.tabId) ?? 0))
+}
+
+/**
+ * Most recently OPENED live panel of a session — the open-or-focus target
+ * when the legacy snapshot cannot see the tab (mirrors "last opened wins").
+ * 排序锚在首次注册序号上：面板重挂载不翻序（见 birthOrder）。
+ */
+export function lastLiveSideChat(sessionId: string): LiveSideChat | undefined {
+  const all = liveSideChatsOf(sessionId)
+  return all[all.length - 1]
+}
+
+/** 插件卸载/重载时清场（apply 的 ctx.effect disposer 调用）。 */
+export function clearNativeRuntime(): void {
+  root = undefined
+  liveSideChats.clear()
+  openings.clear()
+  birthOrder.clear()
+}
+
+/** Native tab shell for reads that go through the layout snapshot (`readTab`). */
+export function nativeTabShell(tabId: string, type: string): { id: string; type: string; title: string; meta: unknown } | undefined {
+  const entry = liveSideChats.get(tabId)
+  if (entry === undefined) return undefined
+  return { id: entry.tabId, type, title: '', meta: entry.readMeta() }
+}
+
+/**
+ * 聚焦一个 native tab：better-sidebar >= 0.19 的 `surface.activate` 是空操作
+ * （只返回记录存在性——authority: dsh-better-sidebar src/client/native/surface.ts），
+ * 真实聚焦面是 dsh 0.1.5 的 `ISidebarRight.focus`（authority:
+ * dsh-client-ui-sidebar-right lib/types/client/service.d.ts `focus(tabId)`）。
+ * focus 只标记活动 tab/pane，不展开折叠的栏——聚焦的语义包含「让用户看见」，
+ * 故折叠时补 toggleExpanded（authority: 同文件 `isExpanded/toggleExpanded`）。
+ * @returns true = 已通过 focus 聚焦；false = 面缺席（调用方回退 activateTab）。
+ */
+export function focusNativeTab(ctx: Context, tabId: string): boolean {
+  try {
+    const face = ctx.get('sidebarRight') as {
+      focus?: (id: string) => void
+      isExpanded?: () => boolean
+      toggleExpanded?: () => void
+    } | undefined
+    if (typeof face?.focus !== 'function') return false
+    face.focus(tabId)
+    if (face.isExpanded?.() === false) face.toggleExpanded?.()
+    return true
+  } catch {
+    return false
+  }
+}

package/src/client/sidechat/open.ts

@@ -16,10 +16,16 @@ import {
   sideTabTitle,
 } from './model.ts'
 import { readInputDraft, resolveSessionInput } from './composer.ts'
+import { focusNativeTab, lastLiveSideChat, liveSideChatsOf, markSideChatOpening, nativeSidebarHost, nativeTabShell, sideChatOpening } from './native.ts'
 
-/** 从最新快照读一个 Tab（meta 合并写入前的读取面；布局即注册表）。 */
+/**
+ * 从最新快照读一个 Tab（meta 合并写入前的读取面；布局即注册表）。
+ * better-sidebar >= 0.19: the open tab lives in the native right sidebar, not
+ * in the layout snapshot — fall back to the live-panel registry.
+ */
 export function readTab(ctx: Context, tabId: string): SidebarTab | undefined {
-  return collectTabs(ctx.betterSidebar.getSnapshot().state).find(tab => tab.id === tabId)
+  const tab = collectTabs(ctx.betterSidebar.getSnapshot().state).find(candidate => candidate.id === tabId)
+  return tab ?? nativeTabShell(tabId, SIDE_TAB_TYPE)
 }
 
 /**
@@ -33,6 +39,17 @@ export function openOrFocusSideChat(ctx: Context, sessionId: string, draftText?:
     if (snapshot.sessionId !== sessionId || snapshot.state === undefined) return false
     const existing = collectSideTabs(snapshot.state)
 
+    // Native right sidebar (better-sidebar >= 0.19): the tab is invisible to the
+    // layout snapshot, so focus the live panel and hand it the draft directly.
+    const live = lastLiveSideChat(sessionId)
+    if (live !== undefined) {
+      if (draftText !== undefined && draftText !== '') live.seedDraft(draftText)
+      // native 宿主的 activateTab 是空操作（surface.activate 只查记录存在性），
+      // 聚焦走 ISidebarRight.focus 探测；面缺席（legacy）回退 activateTab。
+      if (!focusNativeTab(ctx, live.tabId)) ctx.betterSidebar.activateTab(live.tabId, { sessionId })
+      return true
+    }
+
     if (existing.length > 0) {
       const target = existing[existing.length - 1]!
       if (draftText !== undefined && draftText !== '') {
@@ -50,6 +67,15 @@ export function openOrFocusSideChat(ctx: Context, sessionId: string, draftText?:
       return true
     }
 
+    // openTab→面板挂载窗口（native 特有）：tab 已铸但对快照与 registry 均不可见，
+    // 重复触发落进 in-flight 标记（草稿暂存、注册时回放）而非再开一个
+    // （双开 = 双 fork 出孤儿会话）。legacy 无此窗口（openTab 同步落快照）。
+    const opening = sideChatOpening(sessionId)
+    if (opening !== undefined) {
+      if (draftText !== undefined && draftText !== '') opening.drafts.push(draftText)
+      return true
+    }
+
     return createSideChat(ctx, sessionId, draftText)
   } catch (error) {
     console.warn('[dsh-sidenote] 打开侧边聊天失败:', error)
@@ -66,12 +92,26 @@ export function createSideChat(ctx: Context, sessionId: string, draftText?: stri
   try {
     const snapshot = ctx.betterSidebar.getSnapshot()
     if (snapshot.sessionId !== sessionId || snapshot.state === undefined) return false
+    // openTab 的已知静默失败面先排除（类型在设置里被禁用 = 宿主 warn 后 return，
+    // 不抛错）——否则 native 分支的乐观返回会把失败报成成功。
+    if (!ctx.betterSidebar.isTabEnabled(SIDE_TAB_TYPE)) return false
     // 新建：openTab 走 createTab 铸造（seed.meta 会被忽略），所以先记下既有
     // id 集，openTab 同步落状态后找出新 Tab，再把 pendingDraft 写进它的 meta。
     const before = new Set(collectTabs(snapshot.state).map(tab => tab.id))
-    ctx.betterSidebar.openTab({ type: SIDE_TAB_TYPE }, { sessionId })
+    // Native tabs (better-sidebar >= 0.19) take meta from the seed: the minted id
+    // only becomes known once the panel mounts and publishes itself.
+    const seed = draftText !== undefined && draftText !== ''
+      ? { type: SIDE_TAB_TYPE, meta: { pendingDraft: draftText } }
+      : { type: SIDE_TAB_TYPE }
+    ctx.betterSidebar.openTab(seed, { sessionId })
     const created = collectSideTabs(ctx.betterSidebar.getSnapshot().state).find(tab => !before.has(tab.id))
-    if (created === undefined) return false
+    if (created === undefined) {
+      if (!nativeSidebarHost(ctx)) return false
+      // native：tab 不进快照属预期——openTab 不抛错即视为成功；标记 in-flight
+      // 窗口供并发触发去重（窗口语意见 native.ts）。
+      markSideChatOpening(sessionId)
+      return true
+    }
     if (draftText !== undefined && draftText !== '') {
       ctx.betterSidebar.updateTab(created.id, { meta: { pendingDraft: draftText } })
     }
@@ -93,6 +133,9 @@ export function sideChatTargetTitle(ctx: Context, sessionId: string): string | u
     if (snapshot.sessionId !== sessionId || snapshot.state === undefined) return undefined
     const existing = collectSideTabs(snapshot.state)
     if (existing.length > 0) return existing[existing.length - 1]!.title
+    // native：布局快照看不到 tab，改读 live registry（最近打开者）。
+    const live = lastLiveSideChat(sessionId)
+    if (live !== undefined) return live.readTitle()
     return sideTabTitle([])
   } catch {
     return undefined
@@ -109,13 +152,26 @@ export function reopenSideChat(ctx: Context, sessionId: string, childId: string,
   try {
     const snapshot = ctx.betterSidebar.getSnapshot()
     if (snapshot.sessionId !== sessionId || snapshot.state === undefined) return false
+    if (!ctx.betterSidebar.isTabEnabled(SIDE_TAB_TYPE)) return false
+    // native 下同 kind 每 pane 单实例（dsh sidebar-right held 规则）：有存活
+    // 实例时 openTab 必折叠为聚焦既有 tab 且 seed.meta 被丢弃——拒绝（弹层
+    // 侧此时本就不列重开项，这里是双保险）。
+    if (nativeSidebarHost(ctx) && liveSideChatsOf(sessionId).length > 0) return false
     const before = new Set(collectTabs(snapshot.state).map(tab => tab.id))
-    ctx.betterSidebar.openTab({ type: SIDE_TAB_TYPE }, { sessionId })
+    // native（>= 0.19）：seed.meta 携带恢复信息（native 面采纳 seed.meta；
+    // 面板挂载即走绑定恢复路径）。legacy 的 createTab 铸造忽略 seed.meta，
+    // 落快照后补写。
+    const meta = { childId, parentSessionId: sessionId }
+    ctx.betterSidebar.openTab({ type: SIDE_TAB_TYPE, ...(title !== undefined ? { title } : {}), meta }, { sessionId })
     const created = collectSideTabs(ctx.betterSidebar.getSnapshot().state).find(tab => !before.has(tab.id))
-    if (created === undefined) return false
+    if (created === undefined) {
+      if (!nativeSidebarHost(ctx)) return false
+      markSideChatOpening(sessionId)
+      return true
+    }
     ctx.betterSidebar.updateTab(created.id, {
       ...(title !== undefined ? { title } : {}),
-      meta: { childId, parentSessionId: sessionId },
+      meta,
     })
     return true
   } catch (error) {

package/src/client/sidechat/slash.ts

@@ -2,7 +2,9 @@
  * /side 斜杠命令（spike 落点）：经 client 侧 `ctx.commandUi.register`
  * （dsh-client-ui-commands 的 CommandContribution，ui 形态 popupSelect）
  * 注册。popupSelect 是该注册面唯一的 UI 形态 —— 菜单行被选中后弹一个
- * 选项壳，选项 = 新建 + 当前会话已并存的侧边聊天（聚焦）。
+ * 选项壳，选项 = 新建 + 当前会话已并存的侧边聊天（聚焦）+ 最近关闭（重开）。
+ * native 宿主（better-sidebar >= 0.19）受 dsh sidebar-right 的 held 规则约束
+ * （page kind 每 pane 单实例）：有存活实例时不列「新建」与「重开」。
  *
  * 服务经 ctx.get 惰性解析（commandUi 不在 inject 清单里）：服务缺失、
  * 注册抛错（如与 host 命令撞名）都降级为「只有 Tab 入口」，绝不影响面板。
@@ -12,6 +14,7 @@
  */
 import type { Context } from '../host/contracts.ts'
 import { canForkFrom, collectSideTabs } from './model.ts'
+import { focusNativeTab, liveSideChatsOf, nativeSidebarHost } from './native.ts'
 import { createSideChat, reopenSideChat } from './open.ts'
 import { dropClosedSideChat, listClosedSideChats } from './recentClosed.ts'
 import { t } from '../locales.ts'
@@ -32,7 +35,11 @@ interface SelectOption {
 interface CommandUiService {
   register(contribution: {
     readonly name: string
-    readonly description: string
+    // 契约在 0.1.5 从 string 改为 () => string（authority:
+    // dsh-client-ui-commands 0.1.5-rc.2 contract.d.ts `readonly description: () => string`；
+    // 0.1.1~0.1.3 为 string）。传错形状会在候选合成时炸掉整个斜杠菜单
+    // （ui-input-trigger 的 contribution.description() 对 string 抛 TypeError）。
+    readonly description: string | (() => string)
     available(session: CommandSession): boolean
     readonly ui: {
       readonly kind: 'popupSelect'
@@ -42,28 +49,52 @@ interface CommandUiService {
   }): () => void
 }
 
+/** 0.1.5 信号：`connection.api.sessions` 面在 0.1.5 被删（与模型面迁移同判据）。 */
+function isDsh015Plus(ctx: Context): boolean {
+  const legacy = (ctx as { connection?: { api?: { sessions?: unknown } } }).connection?.api?.sessions
+  return legacy === undefined || legacy === null
+}
+
 /** 单个命令名对应的完整贡献（side / 侧边 共用）。 */
 function makeContribution(ctx: Context, name: string) {
   return {
     name,
-    description: t('cmdDesc'),
+    description: isDsh015Plus(ctx) ? () => t('cmdDesc') : t('cmdDesc'),
     available: (session: CommandSession) => canForkFrom(ctx, session.sessionId),
     ui: {
       kind: 'popupSelect' as const,
       options: (session: CommandSession) => {
-        const options: SelectOption[] = [
-          { id: 'new', label: t('cmdNew'), detail: t('cmdNewDetail') },
-        ]
+        const options: SelectOption[] = []
+        const native = nativeSidebarHost(ctx)
+        const lives = native ? liveSideChatsOf(session.sessionId) : []
+        // native 下同 kind 每 pane 单实例（dsh-client-ui-sidebar-right 的 held
+        // 规则：page kind 的 contentId 恒为 sidebar://<kind>，openTab 必折叠为
+        // 聚焦既有 tab）——已有存活实例时「新建」名不副实，不列。
+        if (!native || lives.length === 0) {
+          options.push({ id: 'new', label: t('cmdNew'), detail: t('cmdNewDetail') })
+        }
         // 已并存的侧边聊天列为聚焦项（命令弹层即多实例管理入口）。
-        const snapshot = ctx.betterSidebar.getSnapshot()
-        if (snapshot.sessionId === session.sessionId && snapshot.state !== undefined) {
-          for (const tab of collectSideTabs(snapshot.state)) {
-            options.push({ id: `focus:${tab.id}`, label: t('cmdFocus', { title: tab.title }), detail: t('cmdFocusDetail') })
+        // native（>= 0.19）：tab 不进布局快照，枚举改读 live registry；
+        // legacy：读布局快照（现状）。
+        if (native) {
+          for (const live of lives) {
+            options.push({ id: `focus:${live.tabId}`, label: t('cmdFocus', { title: live.readTitle() }), detail: t('cmdFocusDetail') })
+          }
+        } else {
+          const snapshot = ctx.betterSidebar.getSnapshot()
+          if (snapshot.sessionId === session.sessionId && snapshot.state !== undefined) {
+            for (const tab of collectSideTabs(snapshot.state)) {
+              options.push({ id: `focus:${tab.id}`, label: t('cmdFocus', { title: tab.title }), detail: t('cmdFocusDetail') })
+            }
           }
         }
         // D3 后悔药：最近关闭的可重开（Cmd+Shift+T 心智）。
-        for (const entry of listClosedSideChats(session.sessionId)) {
-          options.push({ id: `reopen:${entry.childId}`, label: t('cmdReopen', { title: entry.title }), detail: t('cmdReopenDetail') })
+        // native 单实例约束下，有存活实例时 reopen 必被 held 折叠（seed.meta
+        // 丢弃且聚焦错对象）——此时不列重开项。
+        if (!(native && lives.length > 0)) {
+          for (const entry of listClosedSideChats(session.sessionId)) {
+            options.push({ id: `reopen:${entry.childId}`, label: t('cmdReopen', { title: entry.title }), detail: t('cmdReopenDetail') })
+          }
         }
         return Promise.resolve(options)
       },
@@ -75,7 +106,9 @@ function makeContribution(ctx: Context, name: string) {
           return
         }
         if (option.id.startsWith('focus:')) {
-          ctx.betterSidebar.activateTab(option.id.slice('focus:'.length), { sessionId: session.sessionId })
+          const tabId = option.id.slice('focus:'.length)
+          // native 宿主的 activateTab 是空操作——聚焦走 ISidebarRight.focus 探测。
+          if (!focusNativeTab(ctx, tabId)) ctx.betterSidebar.activateTab(tabId, { sessionId: session.sessionId })
           return
         }
         if (option.id.startsWith('reopen:')) {