dsh-sidenote 0.3.2 → 0.3.3

package/src/client/sidechat/native.ts

@@ -0,0 +1,168 @@
+/**
+ * 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
+}
+
+/** Native tab id → live panel. Native layouts are memory-only, so is this. */
+const liveSideChats = new Map<string, LiveSideChat>()
+
+/**
+ * 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,
+): () => void {
+  const entry: LiveSideChat = { tabId, sessionId, seedDraft, readMeta }
+  liveSideChats.set(tabId, entry)
+  // 挂载即回放在 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)
+}
+
+/**
+ * Most recently registered live panel of a session — the open-or-focus target
+ * when the legacy snapshot cannot see the tab (mirrors "last opened wins").
+ */
+export function lastLiveSideChat(sessionId: string): LiveSideChat | undefined {
+  let found: LiveSideChat | undefined
+  for (const entry of liveSideChats.values()) {
+    if (entry.sessionId === sessionId) found = entry
+  }
+  return found
+}
+
+/** 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, 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 } })
     }
@@ -109,13 +149,22 @@ 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
     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

@@ -32,7 +32,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,11 +46,17 @@ 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,