@linxin666/dsh-client-ui-task-board 0.4.4 → 0.4.6

package/src/client/index.ts

@@ -35,6 +35,14 @@ import { HttpTaskBoardHostTransport } from './host-api.ts'
 import { reportDailyHeartbeat } from './telemetry.ts'
 import { installPluginCard } from './plugin-card-seat.ts'
 import { createServedEntryForm } from './settings-entry-form.ts'
+import { TaskBoardClientService } from './service.ts'
+import {
+  TASK_BOARD_SERVICE_NAME,
+  type TaskBoardCardDecorationProps,
+  type TaskBoardDetailSectionProps,
+  type TaskBoardHostFace,
+  type TaskBoardSettingsSectionProps,
+} from '../core/extension.ts'
 
 /** Locale namespace this plugin owns. */
 const NS = 'task-board'
@@ -95,6 +103,13 @@ declare module '@deepseek-ai/dsh-client-ui-slots' {
      * package can register without depending on the sibling UI package.
      */
     'web-ui.plugin.item': { kind: 'list'; scope: 'root'; owner: SettingsPluginItemOwnerProps }
+
+    /** Provider task-detail section; the board declares and renders it. */
+    'task-board.detail.section': { kind: 'list'; scope: 'root'; owner: TaskBoardDetailSectionProps }
+    /** Provider settings section; the board declares and renders it. */
+    'task-board.settings.section': { kind: 'list'; scope: 'root'; owner: TaskBoardSettingsSectionProps }
+    /** Provider card decoration; the board declares and renders it. */
+    'task-board.card.decoration': { kind: 'list'; scope: 'root'; owner: TaskBoardCardDecorationProps }
   }
 }
 
@@ -118,15 +133,17 @@ declare module '@deepseek-ai/cordis' {
 
 /**
  * Required services (fiber inject waiting — the runtime must be up first).
- * The generated remote faces are probed at use time instead of injected:
- * `remote.agentPresets` only registers on 0.1.2-alpha.2 hosts (the
- * api-remotes contribution), so a hard wait would pend the entry forever
- * on hosts below that cohort, which serve the same roster through the
- * connection RPC face.
+ * The generated remote namespaces are not all hard injects: `remote.session`
+ * is one, while `remote.agentPresets` is reached through a scoped inject at
+ * use time (see mountUi), because the namespace mounts with the official
+ * api-remotes assembly applied beside this entry rather than before it.
  */
 export const inject = ['slots', 'sessions', 'workspaces', 'connection', 'configForms', 'locale', 'remote', 'remote.session', 'uiWorkspace', 'layout']
 
-/** One agent-preset row the mode picker consumes (either face's wire shape). */
+/** The generated Remote namespace the mode picker reads its roster from. */
+type PresetRemote = ClientRemote['agentPresets']
+
+/** One agent-preset row the mode picker consumes. */
 interface PresetRosterRow {
   id: string
   name?: string
@@ -137,41 +154,17 @@ interface PresetRosterRow {
 }
 
 /**
- * Read the agent-preset roster through whichever face the running host
- * serves: the generated api-remotes face (`remote.agentPresets`,
- * 0.1.2-alpha.2) or the connection RPC face
- * (`connection.api.agentPresets`, hosts below that cohort). Answers
- * undefined when the host serves neither, so the caller leaves the picker
- * options untouched instead of erroring.
+ * Read the agent-preset roster through the generated api-remotes face. The
+ * caller passes the namespace resolved inside its scoped inject, so a host
+ * that serves no such namespace never reaches here; a host that serves it
+ * answers `ok: false` instead, which leaves the picker options untouched.
+ * @param remote - the `remote.agentPresets` namespace.
+ * @returns the roster, or a failed read the caller ignores.
  */
-async function readPresetRoster(
-  ctx: ClientContext,
-  remote: ClientRemote,
-): Promise<{ ok: boolean; presets: readonly PresetRosterRow[] } | undefined> {
-  // The cordis `remote` proxy throws on a property that was never injected
-  // ("cannot get property X without inject") rather than returning undefined,
-  // so the probe must guard the access — a hard read would abort mounting on
-  // hosts below the 0.1.2-alpha.2 cohort instead of degrading to the legacy
-  // connection RPC face below.
-  let remotes: ClientRemote['agentPresets'] | undefined
-  try {
-    remotes = (remote as Partial<ClientRemote>).agentPresets
-  } catch {
-    remotes = undefined
-  }
-  if (remotes !== undefined) {
-    const response = await remotes.list()
-    if (!response.ok) return { ok: false, presets: [] }
-    return { ok: true, presets: response.value.presets }
-  }
-  const connection = ctx.get('connection') as unknown as {
-    api?: { agentPresets?: { list(request: Record<string, never>): Promise<{ result: { ok: boolean; value?: { presets?: readonly PresetRosterRow[] } } }> } }
-  }
-  const legacy = connection.api?.agentPresets
-  if (legacy === undefined) return undefined
-  const response = await legacy.list({})
-  if (!response.result.ok || response.result.value === undefined) return { ok: false, presets: [] }
-  return { ok: true, presets: response.result.value.presets ?? [] }
+async function readPresetRoster(remote: PresetRemote): Promise<{ ok: boolean; presets: readonly PresetRosterRow[] }> {
+  const response = await remote.list()
+  if (!response.ok) return { ok: false, presets: [] }
+  return { ok: true, presets: response.value.presets }
 }
 
 /**
@@ -211,12 +204,26 @@ export function apply(ctx: ClientContext): void {
   // namespace, contributed to whichever plugin-card seat this host declares
   // (the family group's list seat, or the official bundle-configuration seat).
   const settingsForm = bindSettingsForm(ctx)
-  const settingsCard = new TaskBoardSettingsCardController(settingsForm)
+  // The board's browser-half extension service. It is provided before any
+  // controller exists (the UI mounts only once the settings form settles), so
+  // providers can subscribe and register visibility immediately.
+  const clientService = new TaskBoardClientService()
+  // A capture-only test context implements no service registry; the board's
+  // own surfaces still mount.
+  if (typeof (ctx as { provide?: unknown }).provide === 'function') {
+    ;(ctx.provide as unknown as (name: string, value: unknown) => void)(TASK_BOARD_SERVICE_NAME, clientService as unknown as TaskBoardHostFace)
+  }
+  ctx.effect(() => () => { clientService.detach() }, 'task-board: extension service')
+
+  const settingsCard = new TaskBoardSettingsCardController(settingsForm, request => clientService.dispatch(request))
   installPluginCard(ctx, {
     bundle: '@linxin666/dsh-client-ui-task-board',
     id: 'task-board',
     order: 110,
     locale: NS,
+    // The board's own settings card declares the provider settings seat; the
+    // provider registers into it and this card renders it.
+    children: { 'task-board.settings.section': { kind: 'list', scope: 'root' } },
     inject: () => settingsCard.inject(),
     component: TaskBoardSettingsCard,
   })
@@ -263,6 +270,9 @@ export function apply(ctx: ClientContext): void {
       },
     })
     controller.start()
+    // The extension service follows the live controller: providers observe the
+    // board mirror and dispatch through it while the board runs.
+    clientService.attach(controller)
 
     const disposers: Array<() => void> = []
 
@@ -289,10 +299,10 @@ export function apply(ctx: ClientContext): void {
       const created = await workspaces.create({ path })
       return { workspaceId: created.workspaceId }
     })
-    const pushPresetOptions = async (): Promise<void> => {
+    const pushPresetOptions = async (presetRemote: PresetRemote): Promise<void> => {
       try {
-        const roster = await readPresetRoster(ctx, remote)
-        if (roster === undefined || !roster.ok) return
+        const roster = await readPresetRoster(presetRemote)
+        if (!roster.ok) return
         controller.setExecutionOptions({
           presets: roster.presets.map(preset => ({
             id: preset.id,
@@ -308,6 +318,25 @@ export function apply(ctx: ClientContext): void {
         console.error('[dsh-task-board] agent preset roster read failed', error)
       }
     }
+    // The roster namespace mounts with the official api-remotes assembly,
+    // which the page applies beside this entry: at mount time the namespace is
+    // usually still absent, and reading it through `remote.agentPresets`
+    // before it lands throws ("cannot get property ... without inject"), so a
+    // one-shot probe leaves the mode picker with nothing but "inherit" for the
+    // page lifetime. A hard inject is no better — it would pend the whole
+    // board on a deployment that never mounts the namespace. The scoped inject
+    // runs the feed exactly when the namespace exists and re-runs it if the
+    // namespace is replaced; the reconnect read inside covers a deployment
+    // change behind the same namespace.
+    const presetRosterFeed = ctx.inject(['remote.agentPresets'], (inner) => {
+      const presetRemote = inner.get('remote.agentPresets') as PresetRemote | undefined
+      if (presetRemote === undefined) return
+      void pushPresetOptions(presetRemote)
+      // Subscribed inside the injected scope, so a namespace that goes away
+      // takes its listener with it instead of leaving one per remount.
+      return inner.on('connection/reset', () => { void pushPresetOptions(presetRemote) })
+    })
+    disposers.push(() => { void presetRosterFeed.dispose() })
     const pushModelOptions = async (): Promise<void> => {
       try {
         let models: Array<{ id: string; name?: string; provider?: string }> = []
@@ -372,12 +401,8 @@ export function apply(ctx: ClientContext): void {
         console.error('[dsh-task-board] model options read failed', error)
       }
     }
-    void pushPresetOptions()
     void pushModelOptions()
-    disposers.push(ctx.on('connection/reset', () => {
-      void pushPresetOptions()
-      void pushModelOptions()
-    }))
+    disposers.push(ctx.on('connection/reset', () => { void pushModelOptions() }))
     // Native panel surfaces: one sidebar row and one center-column page, both
     // through the official slot seats the shell itself renders. The layout's
     // panel selection is reconciled back into the controller so the board's own
@@ -400,6 +425,7 @@ export function apply(ctx: ClientContext): void {
 
     uiDisposer = () => {
       for (const dispose of disposers.splice(0)) dispose()
+      clientService.detach()
       controller.dispose()
       uiDisposer = undefined
     }
@@ -409,8 +435,13 @@ export function apply(ctx: ClientContext): void {
     const enabled = snapshot.status === 'ready'
       ? snapshot.value?.enabled ?? true
       : snapshot.status === 'unavailable'
-    if (enabled) mountUi()
-    else uiDisposer?.()
+    if (enabled) {
+      mountUi()
+      clientService.setEnabled(true)
+    } else {
+      clientService.setEnabled(false)
+      uiDisposer?.()
+    }
   }
   const unsubscribeSettings = settingsForm.subscribe(syncEnabled)
   // The mounted surfaces and the settings subscription belong to this fiber.