dsh-ptc-plus 0.4.8 → 0.5.0

package/src/client.js

@@ -1,16 +1,20 @@
 import { createClientRpc } from './client-rpc.js'
 import { RPC_CONTRACTS } from '../internal/rpc-contract.js'
-import { SETTINGS_NAMESPACE } from '../internal/config-spec.js'
+import { CONFIG_DEFAULTS, SETTINGS_NAMESPACE } from '../internal/config-spec.js'
 import { createPtcToolView } from './client-tool-view.js'
 import { createPtcSettingsView } from './client-settings-view.js'
+import { createCapabilityCommandCard, createCapabilityRefreshView, createSessionCapabilityControlsView } from './client-capabilities-view.js'
+import { capabilityProfileConfiguration } from '../internal/runtime-config.js'
 import { createReplView } from './client-repl-view.js'
 import { createAuthoringView } from './client-authoring-view.js'
+import { bindingToggleConversationDefinition } from './client-binding-toggle.js'
 import { createIndicatorView } from './client-indicator-view.js'
 import { createTypeScriptEditor } from './client-code-editor.js'
 import { createBindingConsole } from './client-console.js'
 import {
   createMenuChildrenEvidence,
   hostIconComponents,
+  isHostComponent,
   isHostIconComponent,
   isIdleSessionComposer,
   publishSettingsCard,
@@ -28,23 +32,84 @@ import { installStyles } from './client-styles.js'
 import { featureEnabled, registerGated } from './client-feature-gates.js'
 import { createCatalogOwner } from './client-catalog.js'
 import { createUserBindingsWorkbench } from './client-workbench.js'
-import { createBindingCommandAvailability, createReplObserver } from './client-transport.js'
+import { createBindingCommandAvailability, createCommandAccess, createReplObserver } from './client-transport.js'
+import { createActionButton, resolvePrimitives } from './client-primitives.js'
 
-window.__ModuleLoader__.load({
-  // Replaced by the bundle entry with the package name from package.json.
-  id: __PTC_PLUS_CLIENT_MODULE_ID__,
-  factory: (require) => {
+/** Settings snapshot used until the installed generation serves a transport. */
+const UNAVAILABLE_PREFERENCE = Object.freeze({
+  status: 'unavailable',
+  writable: false,
+  value: CONFIG_DEFAULTS,
+})
+
+/**
+ * Resolve the settings preference scope of the running generation without
+ * depending on that generation publishing a particular transport name: the
+ * current one serves `configForms` and the preceding one served
+ * `settingsScope`. The plugin exposes the shipped Config defaults until a
+ * transport appears, prefers the current one, and retains live alternatives.
+ * A renamed or omitted transport degrades the settings surface instead of
+ * suspending apply() before any contribution is registered.
+ */
+function createPreferenceScope(ctx) {
+  const listeners = new Set()
+  const registrations = new Map()
+  let bound
+  const notify = () => { for (const listener of [...listeners]) listener() }
+  const sync = () => {
+    const next = registrations.get('configForms') ?? registrations.get('settingsScope')
+    if (bound === next) return
+    bound = next
+    notify()
+  }
+  const adopt = (name, scope) => {
+    if (scope === undefined || scope === null) return undefined
+    const registration = { scope }
+    const unsubscribe = typeof scope.subscribe === 'function' ? scope.subscribe(() => {
+      if (bound === registration) notify()
+    }) : undefined
+    registrations.set(name, registration)
+    sync()
+    return () => {
+      unsubscribe?.()
+      if (registrations.get(name) !== registration) return
+      registrations.delete(name)
+      sync()
+    }
+  }
+  ctx.inject(['configForms'], scope => adopt('configForms', scope.configForms.get(SETTINGS_NAMESPACE)))
+  ctx.inject(['settingsScope'], scope => adopt('settingsScope', scope.settingsScope.bind({ namespace: SETTINGS_NAMESPACE })))
+  return Object.freeze({
+    getSnapshot: () => bound?.scope.getSnapshot() ?? UNAVAILABLE_PREFERENCE,
+    subscribe(listener) {
+      listeners.add(listener)
+      return () => listeners.delete(listener)
+    },
+    set: (key, value) => bound?.scope.set(key, value),
+    mutate: patch => bound?.scope.mutate(patch),
+  })
+}
+
+export function createClientPlugin(require) {
     const React = require('react')
-    const primitives = require('@deepseek-ai/dsh-client-ui-primitives')
+    const { createPortal } = require('react-dom')
+    let primitives
+    try {
+      primitives = require('@deepseek-ai/dsh-client-ui-primitives') ?? {}
+    } catch {
+      primitives = {}
+    }
     const {
       Button,
       CodeBlock,
       DisclosureRow,
       Menu,
+      MenuFallback,
       Modal,
+      Select,
       Toast,
       Tooltip,
-    } = primitives
+    } = resolvePrimitives(primitives, React, createPortal)
     const {
       check: IconCheckOutline14,
       chevron: IconChevronDownOutline14,
@@ -59,66 +124,27 @@ window.__ModuleLoader__.load({
       play: IconPlayOutline16,
       stop: IconStopFill16,
     } = hostIconComponents(primitives)
-    const module = { exports: {} }
     const h = React.createElement
     const TypeScriptEditor = createTypeScriptEditor(React)
 
     function IconButton({ icon: Icon, label, ...props }) {
       const button = h('button', { ...props, type: 'button', className: 'ptcPlusIconButton',
         'aria-label': label, title: label }, isHostIconComponent(Icon) ? h(Icon, { size: 16 }) : label)
-      return typeof Tooltip === 'function' ? h(Tooltip, { label, delayMs: 400 }, button) : button
+      return isHostComponent(Tooltip) ? h(Tooltip, { label, delayMs: 400 }, button) : button
     }
 
-    function ActionButton({ className = '', 'data-kind': kind, ...props }) {
-      return typeof Button === 'function'
-        ? h(Button, {
-          ...props, size: 'sm', variant: kind === 'primary' ? 'primary' : kind === 'ghost' ? 'ghost' : 'outline',
-          className: className.split(' ').filter(name => name !== 'ptcPlusButton').join(' '),
-        })
-        : h('button', { ...props, className, 'data-kind': kind })
-    }
+    const ActionButton = createActionButton(React, Button)
 
     const BindingConsole = createBindingConsole(React, { TypeScriptEditor, IconButton, ActionButton,
       icons: { play: IconPlayOutline16, stop: IconStopFill16, reset: IconRefreshOutline16, clear: IconTrashOutline16 } })
     const { PTCPlusToolRow } = createPtcToolView(React, {
-      CodeBlock, DisclosureRow,
+      CodeBlock, DisclosureRow, createPortal,
       icons: { chevron: IconChevronDownOutline14, check: IconCheckOutline14, inspect: IconInspectOutline12 },
     })
 
-    /**
-     * Resolve the settings transport of the running generation. The current
-     * release publishes `configForms`; the preceding one published
-     * `settingsScope`. Both are optional child injections so the client entry
-     * does not stay pending on the name the installed generation does not use.
-     */
-    function settingsPreferenceScope(ctx) {
-      return new Promise((resolve, reject) => {
-        let settled = false
-        let configFormsWatcher
-        let settingsScopeWatcher
-        const take = (name, scope) => {
-          if (settled) return
-          settled = true
-          if (name !== 'configForms' && typeof configFormsWatcher === 'function') configFormsWatcher()
-          if (name !== 'settingsScope' && typeof settingsScopeWatcher === 'function') settingsScopeWatcher()
-          resolve(name === 'configForms'
-            ? scope.configForms.get(SETTINGS_NAMESPACE)
-            : scope.settingsScope.bind({ namespace: SETTINGS_NAMESPACE }))
-        }
-        try {
-          configFormsWatcher = ctx.inject(['configForms'], scope => take('configForms', scope))
-          if (!settled) {
-            settingsScopeWatcher = ctx.inject(['settingsScope'], scope => take('settingsScope', scope))
-          }
-        } catch (error) {
-          reject(error)
-        }
-      })
-    }
-
     async function apply(ctx) {
       const rpc = await createClientRpc(ctx)
-      const preferenceScope = await settingsPreferenceScope(ctx)
+      const preferenceScope = createPreferenceScope(ctx)
       ctx.effect(() => ctx.locale.register(LOCALE_NS, SETTINGS_COPY), 'ptc-plus: settings dictionaries')
       ctx.effect(installStyles, 'ptc-plus: client styles')
 
@@ -141,7 +167,7 @@ window.__ModuleLoader__.load({
       const catalogOwner = createCatalogOwner({ callUserBindings })
       ctx.effect(() => () => catalogOwner.dispose(), 'ptc-plus: binding catalog sources')
       const { useWorkbenchController, UserBindingsWorkbench, BindingsDialog } = createUserBindingsWorkbench(React, {
-        TypeScriptEditor, BindingConsole, IconButton, ActionButton, CodeBlock, Modal,
+        TypeScriptEditor, BindingConsole, IconButton, ActionButton, CodeBlock, Modal, Select,
         catalogOwner,
         icons: {
           refresh: IconRefreshOutline16, plus: IconPlusOutline16, check: IconCheckOutline14,
@@ -150,12 +176,43 @@ window.__ModuleLoader__.load({
         },
       })
       const { observeRepl } = createReplObserver({ rpc, ctx })
+      const capabilityCommands = createCommandAccess(ctx, 'capabilities')
+      const CapabilityCommandCard = createCapabilityCommandCard(React)
+      const CapabilityRefreshButton = createCapabilityRefreshView(React, capabilityCommands)
+      const SessionCapabilityControls = createSessionCapabilityControlsView(React, {
+        commands: capabilityCommands, Modal, Select,
+        async inspectSessionCatalog(sessionId, signal) {
+          const result = await rpc.call(RPC_CONTRACTS.capabilities, 'session-catalog', { sessionId }, signal)
+          if (result?.ok !== true) throw new Error(result?.error?.message ?? 'Session capability catalog unavailable')
+          return result.value
+        },
+      })
       const { PTCPlusSettingsCard, PTCPlusSettingsDialog } = createPtcSettingsView(React, {
-        ActionButton, BindingsDialog, Modal, useWorkbenchController,
-        icons: { chevron: IconChevronDownOutline14 },
+        ActionButton, BindingsDialog, Modal, Select, useWorkbenchController, CapabilityRefreshButton,
+        async inspectCapabilityTargets(signal) {
+          const result = await rpc.call(RPC_CONTRACTS.capabilities, 'targets', {}, signal)
+          if (result?.ok !== true) throw new Error(result?.error?.message ?? 'Capability refresh targets unavailable')
+          return result.value
+        },
+        async inspectCapabilityPlans(signal) {
+          const result = await rpc.call(RPC_CONTRACTS.capabilities, 'inspect', {}, signal)
+          if (result?.ok !== true) throw new Error(result?.error?.message ?? 'Capability plans unavailable')
+          return result.value
+        },
+        async inspectCapabilityCatalog(signal) {
+          const result = await rpc.call(RPC_CONTRACTS.capabilities, 'catalog', {}, signal)
+          if (result?.ok !== true) throw new Error(result?.error?.message ?? 'Capability catalog unavailable')
+          return result.value
+        },
+        async inspectCapabilityAllocation(payload, signal) {
+          const result = await rpc.call(RPC_CONTRACTS.capabilities, 'allocation', payload, signal)
+          if (result?.ok !== true) throw new Error(result?.error?.message ?? 'Capability allocation unavailable')
+          return result.value
+        },
+        icons: { search: IconSearchOutline16, chevron: IconChevronDownOutline14 },
       })
-      const { ReplComposer, ReplConsole, ReplMemoryCard, replPopoverIsOpen, placeReplPopover } = createReplView(React, {
-        CodeBlock, featureEnabled, normalizeReplMemorySnapshot, unavailableReplMemorySnapshot,
+      const { ReplComposer, ReplConsole, ReplMemoryCard, replPopoverIsOpen, placeReplPopover, useObservedReplMemory } = createReplView(React, {
+        CodeBlock, Select, featureEnabled, normalizeReplMemorySnapshot, unavailableReplMemorySnapshot,
         useSessionPreset, sessionUsesPtcPreset, useWorkbenchController, UserBindingsWorkbench,
         icons: { search: IconSearchOutline16, chevron: IconChevronDownOutline14 },
       })
@@ -178,6 +235,15 @@ window.__ModuleLoader__.load({
           && (key !== 'bindingUpdates' || after.value.legacyBindingSettings !== true)
           ? 'status.applied' : 'status.conflict'
       }
+      const updateCapabilityConfiguration = async configuration => {
+        const before = preferenceScope.getSnapshot()
+        if (before.status !== 'ready' || before.writable !== true || !featureEnabled(before, 'plugin')) throw new Error('Capability settings are not writable')
+        const validated = capabilityProfileConfiguration(configuration)
+        await preferenceScope.mutate(Object.entries(validated).map(([key, value]) => ({ op: 'set', path: [key], value })))
+        const after = preferenceScope.getSnapshot()
+        if (after.status !== 'ready' || Object.entries(validated).some(([key, value]) => after.value?.[key] !== value)) throw new Error('Capability configuration was not applied')
+        return 'status.applied'
+      }
       // One gated-registration shape for every settings-driven contribution.
       const settingsGate = (feature, register) => ({
         subscribe: listener => preferenceScope.subscribe(listener),
@@ -191,20 +257,25 @@ window.__ModuleLoader__.load({
       const settingsCard = publishSettingsCard(ctx, {
         bundleName: __PTC_PLUS_CLIENT_MODULE_ID__,
         locale: LOCALE_NS,
-        injectProps: () => ({ ...settingsProps(), updateSetting }),
+        injectProps: () => ({ ...settingsProps(), updateSetting, updateCapabilityConfiguration }),
         component: PTCPlusSettingsCard,
       })
 
+      function ConfiguredToolRow(props) {
+        const snapshot = React.useSyncExternalStore(preferenceScope.subscribe, preferenceScope.getSnapshot)
+        return h(PTCPlusToolRow, { ...props, hoverEnabled: featureEnabled(snapshot, 'toolHover') })
+      }
+
       ctx.slots.inject('tool.call.toolview', () => registerGated(ctx, settingsGate('toolView', () => {
         // Two rows share one eligibility decision; roll both back if either fails.
         const disposers = []
         try {
           disposers.push(ctx.slots.register({
             name: 'tool.call.toolview', key: 'run_code', locale: LOCALE_NS,
-          }, PTCPlusToolRow))
+          }, ConfiguredToolRow))
           disposers.push(ctx.slots.register({
             name: 'tool.call.toolview', key: 'edit_run_code', locale: LOCALE_NS,
-          }, PTCPlusToolRow))
+          }, ConfiguredToolRow))
         } catch (error) {
           disposers.reverse().forEach(dispose => dispose())
           throw error
@@ -255,9 +326,9 @@ window.__ModuleLoader__.load({
       // One probe answer serves every session's composer entry for this Client.
       const menuChildren = createMenuChildrenEvidence()
       const { BindingAuthorButton, BindingReviewDock, BindingCommandCard } = createAuthoringView(React, {
-        ActionButton, IconButton, Menu, Toast, Tooltip, CodeBlock, BindingsDialog, PTCPlusSettingsDialog,
+        ActionButton, IconButton, Menu, MenuFallback, Toast, Tooltip, CodeBlock, Modal, createPortal, BindingsDialog, PTCPlusSettingsDialog,
         useWorkbenchController, useBindingReview, catalogOwner, callUserBindings, subscribeReset,
-        settingsCardSeat: settingsCard.seat, updateSetting, menuChildren,
+        settingsCardSeat: settingsCard.seat, updateSetting, updateCapabilityConfiguration, menuChildren, SessionCapabilityControls,
         icons: {
           sparkle: IconSparkle16, chevron: IconChevronDownOutline14,
           close: IconCloseOutline16, check: IconCheckOutline14,
@@ -268,6 +339,7 @@ window.__ModuleLoader__.load({
         normalizeReplMemorySnapshot, unavailableReplMemorySnapshot,
         ReplMemoryCard, replPopoverIsOpen, placeReplPopover,
         catalogOwner, subscribeReset,
+        useObservedReplMemory, observeRepl,
       })
 
       ctx.slots.inject('conversation.session.header.actions', () => registerGated(ctx, settingsGate('plugin', () => ctx.slots.register({
@@ -278,9 +350,18 @@ window.__ModuleLoader__.load({
         name: 'conversation.chat.commandview', key: 'binding', locale: LOCALE_NS,
         inject: settingsProps,
       }, props => h(BindingCommandCard, { ...props, key: props.node.commandId })))))
+      ctx.slots.inject('conversation.chat.commandview', () => registerGated(ctx, settingsGate('plugin', () => ctx.slots.register({
+        name: 'conversation.chat.commandview', key: 'capabilities', locale: LOCALE_NS,
+      }, props => h(CapabilityCommandCard, props)))))
+      ctx.inject(['uiConversation'], scope => scope.effect(() => scope.uiConversation.events.register(bindingToggleConversationDefinition),
+        'ptc-plus binding configuration receipts'))
+      ctx.slots.inject('conversation.chat.node', () => ctx.effect(() => ctx.slots.register({
+        name: 'conversation.chat.node', key: 'ptc-plus-binding-toggle', locale: LOCALE_NS,
+      }, ({ node, t }) => h('p', { className: 'ptcPlusCapabilityReceipt', role: 'status' },
+        t(node.data.enabled ? 'bindings.toggleEnabled' : 'bindings.toggleDisabled', { name: node.data.name }))), 'ptc-plus binding configuration receipt renderer'))
       ctx.slots.inject('conversation.input.dock', () => ctx.slots.inject('conversation.input.left', () =>
         registerGated(ctx, settingsGate('bindings', () => ctx.slots.register({
-          name: 'conversation.input.dock', id: 'ptc-plus-binding-review', order: 30, locale: LOCALE_NS,
+          name: 'conversation.input.dock', id: 'ptc-plus-binding-review', order: -30, locale: LOCALE_NS,
         }, props => typeof props.useProjection === 'function' && props.sessionId !== undefined
           ? h(BindingReviewDock, { ...props, key: props.sessionId }) : null)))))
       const availability = createBindingCommandAvailability(ctx)
@@ -300,21 +381,20 @@ window.__ModuleLoader__.load({
             return () => { unsubscribePreset(); unsubscribeSettings() }
           },
           isEnabled: () => sessionUsesPtcPreset(preset)
-            && featureEnabled(preferenceScope.getSnapshot(), 'bindings'),
+            && featureEnabled(preferenceScope.getSnapshot(), 'plugin'),
           register: () => ctx.slots.register({
             name: 'conversation.input.left', id: 'ptc-plus-binding-author', order: 20, locale: LOCALE_NS,
             inject: sessionId => ({
-              hooks: { ptcSettings: preferenceScope, bindingCommand: availability.source(sessionId) },
+              hooks: { ptcSettings: preferenceScope, bindingCommand: availability.source(sessionId),
+                capabilityCommand: capabilityCommands.source(sessionId) },
             }),
           }, props => props.sessionId === undefined ? null : h(BindingAuthorButton, { ...props, key: props.sessionId })),
         }))
       })
     }
 
-    module.exports = {
+    return {
       apply,
       inject: ['slots', 'locale', 'connection', 'remote'],
     }
-    return module.exports
-  },
-})
+}