@lincyaw/dsh 0.0.0-stage → 0.2.0-rc.0

package/src/client/brand.tsx

@@ -0,0 +1,97 @@
+import { PmButton, WorkbenchProvider } from '@lincyaw/workbench'
+import type { Workbench } from '@lincyaw/workbench'
+import { useEffect } from 'react'
+import { Modal } from '@deepseek-ai/dsh-client-ui-primitives'
+import { BRAND_SLOTS, ONBOARDING } from './contract.ts'
+import { BRAND_COPY, BRAND_LANGUAGES, useClientMessages } from './messages.ts'
+import { rememberOpenSection } from './settings-opener.ts'
+
+export function Logo({ size = 24, className }: { size?: number, className?: string }) {
+  return (
+    <svg className={className ? `pmw-logo ${className}` : 'pmw-logo'} width={size} height={size} viewBox="0 0 32 32" role="img" aria-label="Presmium">
+      <rect width="32" height="32" rx="7" fill="#0F5F5C" />
+      <path d="M11 8h7.5a6.5 6.5 0 0 1 0 13H15v4h-4zM15 12v5h3.5a2.5 2.5 0 0 0 0-5z" fill="#F7F5F0" fillRule="evenodd" />
+    </svg>
+  )
+}
+
+const WELCOMED = 'presmium.workbench.welcomed'
+
+function welcomed(): boolean {
+  try {
+    return localStorage.getItem(WELCOMED) === '1'
+  } catch {
+    return false
+  }
+}
+
+function Welcome({ workbench, complete, openSection }: { workbench: Workbench, complete?: () => void, openSection?: (id: string) => void }) {
+  const t = useClientMessages(workbench)
+  const read = welcomed()
+  useEffect(() => rememberOpenSection(openSection), [openSection])
+  useEffect(() => {
+    if (read) complete?.()
+  }, [read, complete])
+  if (read) return null
+  const done = () => {
+    try {
+      localStorage.setItem(WELCOMED, '1')
+    } catch {
+    }
+    complete?.()
+  }
+  return (
+    <WorkbenchProvider workbench={workbench}>
+      <Modal open title={t.welcomeTitle} onClose={done} headless>
+        <div className="pmw-welcome__card pm-ui" data-pmw-welcome="">
+          <Logo size={40} />
+          <h2 id="pmw-welcome-title" className="pmw-welcome__title">{t.welcomeTitle}</h2>
+          <p>{t.welcome}</p>
+          <div className="pmw-welcome__actions">
+            <PmButton
+              onClick={() => {
+                done()
+                openSection?.('models')
+              }}
+            >
+              {t.models}
+            </PmButton>
+            <PmButton variant="primary" onClick={done}>{t.start}</PmButton>
+          </div>
+        </div>
+      </Modal>
+    </WorkbenchProvider>
+  )
+}
+
+function PassOver({ complete, openSection }: { complete?: () => void, openSection?: (id: string) => void }) {
+  useEffect(() => {
+    rememberOpenSection(openSection)
+    complete?.()
+  }, [complete, openSection])
+  return null
+}
+
+/** Puts Presmium's mark, name, first-use notice and languages in DeepSeek Harness's slots, in every layout. */
+export function registerBrand(ctx: DshClientContext, workbench: Workbench): void {
+  const [mark, name, hero] = BRAND_SLOTS
+  ctx.effect(() => ctx.slots.inject(mark, () => ctx.slots.register({ name: mark }, ({ size }: { size?: number }) => <Logo size={size ?? 24} />)), 'presmium: sidebar brand mark')
+  ctx.effect(() => ctx.slots.inject(name, () => ctx.slots.register({ name }, () => <span className="pmw-brand-name">Presmium</span>)), 'presmium: sidebar brand name')
+  ctx.effect(() => ctx.slots.inject(hero, () => ctx.slots.register({ name: hero }, ({ size, className }: { size?: number, className?: string }) => <Logo size={size ?? 34} className={className} />)), 'presmium: conversation brand mark')
+  const [welcome, signIn] = ONBOARDING.steps
+  ctx.effect(() => ctx.slots.inject(ONBOARDING.slot, () => ctx.slots.register({ name: ONBOARDING.slot, id: welcome, priority: -1, order: -100 }, props => <Welcome workbench={workbench} {...props} />)), 'presmium: first-use notice')
+  ctx.effect(() => ctx.slots.inject(ONBOARDING.slot, () => ctx.slots.register({ name: ONBOARDING.slot, id: signIn, priority: -1, order: 0 }, PassOver)), 'presmium: no DeepSeek sign-in step')
+  // Harness's own `English` and `中文` carry its developer copy in the AI panel ("Describe what you want to build…"),
+  // and a language's dictionary cannot be registered twice; a choice of either becomes the same language with Presmium's
+  // copy. Only changes are followed: the page's first, provisional language may still give way to the stored one.
+  for (const language of BRAND_LANGUAGES) {
+    ctx.effect(() => ctx.locale.addLanguage({ id: language.id, label: language.label, fallback: language.fallback }), `presmium: language ${language.id}`)
+    for (const [ns, dict] of Object.entries(BRAND_COPY[language.id])) ctx.effect(() => ctx.locale.register(ns, language.id, dict), `presmium: ${ns} copy ${language.id}`)
+  }
+  ctx.effect(() => ctx.locale.subscribe(() => {
+    const active = ctx.locale.getLocale().active
+    const language = BRAND_LANGUAGES.find(candidate => candidate.fallback === active)
+    // The language may still be unregistered while its definition loads or after it is unloaded.
+    if (language && ctx.locale.getLocale().locales.some(locale => locale.id === language.id)) void ctx.locale.setLocale(language.id)
+  }), 'presmium: Harness\'s languages with Presmium\'s copy')
+}

package/src/client/contract.ts

@@ -0,0 +1,82 @@
+// What the client part assumes of DeepSeek Harness's client: the IDs it registers and looks for, the children of the
+// root slot, the members of ctx.layout, the brand and first-use slots, the shell's module table and the plugin group
+// of the plugins page. The build (build/client.mjs) and the upgrade gate (e2e/workbench.spec.ts) read these too.
+export const CLIENT_ID = '@lincyaw/dsh'
+
+export const ROOT_CHILDREN = {
+  'sidebar': { kind: 'single', scope: 'root' },
+  'main': { kind: 'keyed', scope: 'root' },
+  'rightbar': { kind: 'single', scope: 'root' },
+  'shell.bottom': { kind: 'single', scope: 'root' },
+  'shell.overlay': { kind: 'list', scope: 'root' },
+  'shell.leading': { kind: 'single', scope: 'root' },
+} as const
+
+export const LAYOUT_MEMBERS = ['panelInfo', 'selectPanel', 'beginNavigation', 'toggleSidebar', 'openRightbar', 'closeRightbar'] as const
+
+export const BRAND_SLOTS = ['sidebar.brand.mark', 'sidebar.brand.name', 'conversation.hero.brand.mark'] as const
+export const ONBOARDING = { slot: 'settings.onboarding', steps: ['welcome-notice', 'deepseek-official'] } as const
+
+/**
+ * Where the AI assistant explains a missing model and a failed turn: the composer's takeover chain, and the chat's
+ * `turn-error` node (its shipped cell is replaced, so every failed turn reads in the author's terms).
+ */
+export const ASSISTANT_SLOTS = ['conversation.composer', { name: 'conversation.chat.node', key: 'turn-error' }] as const
+
+/** Where the kitten sits beside the conversation: an added entry (its own id) among the session header's actions. */
+export const MASCOT_SLOT = { name: 'conversation.session.header.actions', id: 'presmium-mascot' } as const
+
+/** Where the author turns the kitten on or off: an added row (its own id) in Settings → General. */
+export const MASCOT_SETTING = { name: 'settings.general.item', id: 'presmium-mascot' } as const
+
+/**
+ * Settings → Models, and when the model catalog is read again: on the Host's events that change what can be routed,
+ * whenever the window regains focus, and on a slow poll while no model is usable (Settings is a modal over this page,
+ * so saving a key there does not refocus the window).
+ */
+export const MODEL_SETTINGS = {
+  section: 'models',
+  events: ['credentials/reference-updated', 'settings/document-updated', 'llm/adapters-updated'],
+  pollMs: 3000,
+} as const
+
+export const SHELL_MODULES = [
+  'react',
+  'react/jsx-runtime',
+  'react-dom',
+  'react-dom/client',
+  '@deepseek-ai/cordis',
+  'zod',
+  '@tanstack/react-virtual',
+  '@deepseek-ai/dsh-client-store',
+  '@deepseek-ai/dsh-client-ui-slots',
+  '@deepseek-ai/dsh-client-ui-primitives',
+  '@deepseek-ai/dsh-client-ui-dockkit',
+] as const
+
+/**
+ * Harness's technical rows in Settings → General, by cell id, that stay out of an author's Settings while the coding
+ * view is off: the default permission mode and the display of the AI's work (work details and when they collapse, send
+ * behaviour while busy, performance and usage).
+ */
+export const TECHNICAL_SETTINGS = { slot: 'settings.general.item', ids: ['permission', 'transcript-view', 'composer-enter', 'performance-usage'] } as const
+
+/**
+ * The author's defaults for Harness's display preferences, by settings namespace (docs/studio.md 7.2):
+ * the coding view (trajectory, code diffs, every agent preset and the technical rows above) off, and the AI's work as
+ * compact, collapsed summaries without token statistics.
+ */
+export const AUTHOR_DEFAULTS: Record<string, Record<string, unknown>> = {
+  'ui-settings': { enabled: false },
+  'ui-chat': { transcriptView: 'compact', performanceUsage: 'compact' },
+}
+
+export const EXPERIMENTAL_GROUP = '[data-plugin-group="extensions"]'
+
+export const UI_LAYOUT = '@deepseek-ai/dsh-client-ui-layout'
+export const UI_SIDEBAR = '@deepseek-ai/dsh-client-ui-sidebar'
+
+/** Whether DeepSeek Harness's boot graph has the plugin `id` (a running host keeps its roster until it restarts). */
+export function isBootEntryLoaded(id: string): boolean {
+  return window.__DSH_BOOT__?.entries.some(entry => entry.id === id) ?? false
+}

package/src/client/document-context.ts

@@ -0,0 +1,39 @@
+import { selectedDocument } from '@lincyaw/workbench'
+import type { Workbench } from '@lincyaw/workbench'
+
+/** The agent session the main view shows. */
+export function mainViewAgentSession<T extends { retainedBy: { mainView?: number } }>(byId: Record<string, T>): T | undefined {
+  return Object.values(byId).find(session => (session.retainedBy.mainView ?? 0) > 0)
+}
+
+/** Tells the bundle which document the agent session works on (`null`: none, the workspace root). */
+export function postDocumentContext(agentSessionId: string, document: string | null, signal?: AbortSignal): Promise<Response> {
+  // Relative to the page: Studio may be served below a path (`--public-url`).
+  return fetch('api/presmium/context', {
+    method: 'POST', headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ session: agentSessionId, document }), ...signal ? { signal } : {},
+  })
+}
+
+/** Keeps the main view's agent session on the document selected in the workbench, in every layout. */
+export function syncDocumentContext(ctx: DshClientContext, workbench: Workbench): void {
+  ctx.inject(['sessions'], inner => inner.effect(() => {
+    let previous: string | undefined
+    let pending: AbortController | undefined
+    const sync = () => {
+      const session = mainViewAgentSession(inner.sessions.list.getSnapshot().byId)
+      if (!session) return
+      const document = selectedDocument(workbench.state)
+      const key = JSON.stringify([session.id, document])
+      if (key === previous) return
+      previous = key
+      pending?.abort()
+      pending = new AbortController()
+      void postDocumentContext(session.id, document, pending.signal).catch(() => {})
+    }
+    const offSession = inner.sessions.list.subscribe(sync)
+    const offDocument = workbench.subscribe(sync)
+    sync()
+    return () => { offSession(); offDocument(); pending?.abort() }
+  }, 'presmium: selected document context (all layouts)'))
+}

package/src/client/dsh.d.ts

@@ -0,0 +1,155 @@
+declare module '@deepseek-ai/dsh-client-ui-primitives' {
+  export const Modal: import('react').ComponentType<{
+    open: boolean
+    title: string
+    onClose(): void
+    headless: true
+    children?: import('react').ReactNode
+  }>
+}
+
+declare module '@deepseek-ai/dsh-client-store' {
+  export interface StoreInstance<S, A> {
+    actions: A
+    getSnapshot(): S
+    subscribe(listener: () => void): () => void
+  }
+  export interface StoreHandle<S, A> {
+    create(): StoreInstance<S, A>
+  }
+  type Bound<A> = { [K in keyof A]: A[K] extends (draft: any, ...args: infer P) => void ? (...args: P) => void : never }
+  export function defineStore<S, A extends Record<string, (draft: S, ...args: any[]) => void>>(spec: { init: () => S, actions: A }): StoreHandle<S, Bound<A>>
+}
+
+interface DshObservable<T> {
+  getSnapshot(): T
+  subscribe(listener: () => void): () => void
+}
+
+type DshSelectorHook<T> = <U>(select: (value: T) => U) => U
+
+interface DshConfigForm {
+  getSnapshot(): { status: 'loading' | 'ready' | 'unavailable', user: unknown, revision: number | undefined, writable: boolean }
+  subscribe(listener: () => void): () => void
+  set(field: string, value: unknown): Promise<boolean>
+}
+
+interface DshSlotOptions {
+  name: string
+  key?: string
+  id?: string
+  priority?: number
+  order?: number
+  locale?: string
+  label?: string | (() => string)
+  children?: Record<string, { kind: 'single' | 'keyed' | 'list', scope: 'root' }>
+  store?: unknown
+  inject?: unknown
+  /** A `chain` slot's election: the first non-null result in priority order renders. */
+  select?: (owner: unknown) => unknown
+}
+
+interface DshSlotEntry {
+  options: { key?: string, id?: string, label?: string | (() => string) }
+}
+
+interface DshSlots {
+  register(options: DshSlotOptions, component: (props: any) => unknown): () => void
+  inject(name: string, effect: () => unknown): void
+  entries(name: string): DshSlotEntry[]
+  subscribe(name: string, listener: () => void): () => void
+  provideRoot(options: { hooks: Record<string, DshObservable<unknown>> }): () => void
+}
+
+interface DshThemeSnapshot {
+  preference: string
+  fontSizes: { text: number, code: number, terminal: number }
+  fontFamilies: { text: string, code: string, terminal: string }
+  active: { id: string, colorScheme: 'light' | 'dark', tokens: Record<string, string> }
+}
+
+interface DshTheme {
+  getTheme(): DshThemeSnapshot
+  overrideTokens(source: string, tokens: Record<string, { light: string, dark: string }>): () => void
+}
+
+interface DshLocale {
+  getLocale(): { active: string, locales: readonly { id: string }[] }
+  subscribe(listener: () => void): () => void
+  addLanguage(language: { id: string, label: string, fallback?: string }): () => void
+  register(ns: string, locale: string | Record<string, Record<string, string>>, dict?: Record<string, string>): () => void
+  bind(ns: string): (key: string, values?: Record<string, string>) => string
+  setLocale(id: string): unknown
+}
+
+interface DshShortcutBinding { code: string, modifiers: string[] }
+
+interface DshShortcuts {
+  /** A read-only row of the shortcut reference; its keys are handled by their owner and kept from editable commands. */
+  registerFixed(command: { id: string, label: () => string, keys: readonly string[], bindings: readonly [DshShortcutBinding, ...DshShortcutBinding[]], group: 'application' | 'input' | 'menus' | 'approval' }): () => void
+  register(command: {
+    id: string
+    label: () => string
+    aliases?: string[]
+    defaults: Record<string, { code: string, modifiers: string[] }>
+    regions?: string[]
+    modals?: string[]
+    resolve: () => { status: 'handled', run: () => void }
+  }): () => void
+}
+
+interface DshSidebarRightTabs {
+  register(definition: {
+    id: string
+    kind: string
+    priority?: 'extension' | 'builtin' | 'fallback'
+    keepMounted?: boolean
+    patterns?: readonly string[]
+    canOpen?(address: string): boolean
+    title: (address?: string) => string
+    guide?: { id: string, order?: number, title: () => string, description?: () => string }[]
+  }): () => void
+}
+
+interface DshSourceTabProps {
+  useTabInfo(): { tab: {
+    contentId: string
+    visible: boolean
+    navigation: { revision: number, params?: { line?: unknown } }
+    actions: { close(): void }
+  } }
+}
+
+interface DshSessionBinding {
+  session: {
+    beginSubmission(input: { mode: 'queue', text: string, attachments: [] }): { requestId: string, abandon(): void }
+    prompt(content: { type: 'text', text: string }[], mode: 'queue', signal: AbortSignal | undefined, requestId: string): Promise<{ ok: true, value: { accepted: true } } | { ok: false, error: { code: string, message: string } }>
+  }
+}
+
+interface DshClientContext {
+  remote: { session: { modelCatalog(): Promise<{ ok: boolean, value?: { routableProviders?: readonly string[] } }> } }
+  effect(effect: () => unknown, label?: string): void
+  on(event: string, listener: (...args: any[]) => void): () => void
+  inject(names: string[], apply: (ctx: DshClientContext) => void): void
+  reflect: { provide(name: string, value: unknown): () => void }
+  slots: DshSlots
+  theme: DshTheme
+  locale: DshLocale
+  shortcuts: DshShortcuts
+  sidebarRightTabs: DshSidebarRightTabs
+  sidebarRight: { active(): { id: string, kind: string, contentId: string } | undefined, close(id: string): void, isExpanded(): boolean, toggleExpanded(): void }
+  layout: { selectPanel(id: string | null): void }
+  sessions: { list: DshObservable<{ byId: Record<string, { id: string, cwd?: string, retainedBy: { mainView?: number } }> }>, binding(id: string): DshSessionBinding | undefined }
+  uiWorkspace: { openWorkspace(id: string, beforeOpen?: (sessionId: string) => void): Promise<void>, startSession(id?: string): void }
+  workspaces: { list: DshObservable<{ items: readonly { workspaceId: string, path: string }[] }> }
+  configForms: {
+    developerTools: { enabled: DshObservable<boolean> }
+    get(entryId: string): DshConfigForm
+    whileServed(namespaces: readonly string[], register: (served: ReadonlySet<string>) => () => void): () => void
+  }
+}
+
+interface Window {
+  __DSH_BOOT__?: { entries: { id: string }[], release?: { version: string, commit?: string } }
+}

package/src/client/fallback.tsx

@@ -0,0 +1,53 @@
+import { DocumentView, HistoryPanel, HomePanel, PreviewPanel, useWorkbench, useWorkbenchState, WorkbenchProvider } from '@lincyaw/workbench'
+import type { Workbench } from '@lincyaw/workbench'
+import { useRef } from 'react'
+import type { ComponentType } from 'react'
+import { Logo } from './brand.tsx'
+import { CLIENT_ID } from './contract.ts'
+import { CLIENT_MESSAGES } from './messages.ts'
+import { RuntimeDiagnosticsNotice, WorkbenchRuntimeBoundary } from './runtime-diagnostics.tsx'
+
+export const FALLBACK_PANEL = 'presmium'
+
+function Centre() {
+  const workbench = useWorkbench()
+  const document_ = useWorkbenchState(state => state.document)
+  const retainedDocument = useRef(false)
+  if (document_ !== undefined) retainedDocument.current = true
+  return (
+    <div className="pmw-fallback pm-ui" data-pmw-fallback="">
+      <RuntimeDiagnosticsNotice workbench={workbench} />
+      {document_ === undefined && <HomePanel />}
+      {retainedDocument.current && <div className="pmw-fallback__doc" hidden={document_ === undefined}>
+        <DocumentView active={document_ !== undefined} />
+      </div>}
+    </div>
+  )
+}
+
+/** With DeepSeek Harness's own layout: the workbench is a global panel of `main`, the document and its history are rightbar tab types. */
+export function registerFallbackLayout(ctx: DshClientContext, workbench: Workbench): void {
+  const t = () => CLIENT_MESSAGES[workbench.state.locale]
+  const provided = (Component: ComponentType, className?: string) => function PresmiumPanel() {
+    return (
+      <WorkbenchProvider workbench={workbench}>
+        <WorkbenchRuntimeBoundary workbench={workbench}>{className ? <div className={className}><Component /></div> : <Component />}</WorkbenchRuntimeBoundary>
+      </WorkbenchProvider>
+    )
+  }
+  ctx.effect(() => ctx.slots.inject('sidebar.panellist', () => ctx.slots.register({ name: 'sidebar.panellist', id: FALLBACK_PANEL, order: -10, label: () => t().product }, () => <Logo size={20} />)), 'presmium: the panel list entry')
+  ctx.effect(() => ctx.slots.register({ name: 'main', key: FALLBACK_PANEL }, provided(Centre)), 'presmium: the workbench as a global panel')
+  ctx.inject(['sidebarRightTabs'], (inner) => {
+    const History = () => <HistoryPanel onClose={() => {}} />
+    const tabs = [
+      { kind: 'presmium-preview', Panel: PreviewPanel as ComponentType, title: () => `Presmium · ${t().preview}` },
+      { kind: 'presmium-history', Panel: History, title: () => `Presmium · ${t().history}` },
+    ]
+    for (const { kind, Panel, title } of tabs) {
+      const id = `${CLIENT_ID}/${kind}`
+      const Body = provided(Panel, 'pmw-fallback__tab pm-ui')
+      inner.effect(() => inner.sidebarRightTabs.register({ id, kind, priority: 'extension', keepMounted: true, title, guide: [{ id: kind, order: 50, title }] }), `presmium: ${kind} tab type`)
+      inner.effect(() => inner.slots.inject('sidebar.right.pane.tab', () => inner.slots.register({ name: 'sidebar.right.pane.tab', key: id }, Body)), `presmium: ${kind} tab body`)
+    }
+  })
+}