@railgun52/dsh-mcp-servers 0.1.0

package/src/client/index.ts

@@ -0,0 +1,38 @@
+import type { Context as ClientContext } from '@deepseek-ai/cordis'
+import type {} from '@deepseek-ai/dsh-client-ui-settings/client'
+import type {} from '@deepseek-ai/dsh-client-locale/client'
+import type {} from '@deepseek-ai/dsh-client-ui-renderer/client'
+import type {} from '@deepseek-ai/dsh-client-ui-slots'
+import { McpSection } from './McpSection.tsx'
+import type { McpSectionInjected } from './McpSection.tsx'
+import { en, zh, type McpKey } from './locales.ts'
+
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+  interface LocaleNamespaceMap {
+    'settings.mcp': McpKey
+  }
+}
+const NS = 'settings.mcp'
+const NAMESPACE = 'mcp-servers'
+
+interface McpServersConfig {
+  servers: unknown[]
+}
+
+export const inject = ['slots', 'locale', 'configForms']
+
+export function apply(ctx: ClientContext): void {
+  ctx.effect(() => ctx.locale.register(NS, { zh, en }), 'ui-settings-mcp: copy dictionaries')
+  const form = ctx.configForms.get<McpServersConfig>(NAMESPACE)
+  const t = ctx.locale.bind(NS) as McpSectionInjected['t']
+  const load = (): unknown[] => form.getSnapshot().value?.servers ?? []
+  const save = async (servers: unknown[]): Promise<void> => { await form.set('servers', servers) }
+  ctx.effect(() => ctx.configForms.whileServed([NAMESPACE], () => ctx.slots.inject('settings.section', () => ctx.slots.register({
+    name: 'settings.section',
+    id: 'mcp',
+    order: 25,
+    label: () => t('nav'),
+    locale: NS,
+    inject: (): McpSectionInjected => ({ load, save, t }),
+  }, McpSection))), 'ui-settings-mcp: page')
+}

package/src/client/locales.ts

@@ -0,0 +1,35 @@
+export const en = {
+  nav: 'MCP Servers',
+  title: 'MCP Configuration',
+  intro: 'Manage your MCP servers by editing the JSON configuration below.',
+  add: 'Add server',
+  edit: 'Edit MCP config',
+  remove: 'Delete',
+  deleteConfirm: 'Delete {server}?',
+  deleteDescription: 'This will remove the MCP server configuration.',
+  save: 'Save',
+  cancel: 'Cancel',
+  close: 'Close',
+  noServers: 'No MCP servers configured. Click "Add server" to get started.',
+  loadFailed: 'Failed to load MCP configuration.',
+  saveFailed: 'Failed to save MCP configuration.',
+  saved: 'Configuration saved.',
+}
+export type McpKey = keyof typeof en
+export const zh: { [Key in keyof typeof en]: string } = {
+  nav: 'MCP 服务器',
+  title: 'MCP 配置',
+  intro: '通过编辑下方的 JSON 配置来管理 MCP 服务器。',
+  add: '添加服务器',
+  edit: '编辑 MCP 配置',
+  remove: '删除',
+  deleteConfirm: '删除 {server}？',
+  deleteDescription: '这将移除 MCP 服务器配置。',
+  save: '保存',
+  cancel: '取消',
+  close: '关闭',
+  noServers: '还没有配置 MCP 服务器，点击"添加服务器"开始配置。',
+  loadFailed: '加载 MCP 配置失败。',
+  saveFailed: '保存 MCP 配置失败。',
+  saved: '配置已保存。',
+}

package/src/css-modules.d.ts

@@ -0,0 +1,4 @@
+declare module '*.module.css' {
+  const classes: Record<string, string>
+  export default classes
+}

package/src/index.ts

@@ -0,0 +1,45 @@
+/**
+ * Host registration: the `mcp-servers` settings namespace and the live
+ * mcp-client bridge it feeds. Under the profile-config settings model the
+ * plugin's Config schema IS the namespace, so the owning profile entry id must
+ * equal `mcp-servers`. `servers` is volatile, so edits reload the value without
+ * remounting this plugin; the bridge re-syncs on `loader/volatile-update`.
+ */
+
+import type { Context } from '@deepseek-ai/cordis'
+import type {} from '@deepseek-ai/cordis-plugin-loader'
+import type {} from '@deepseek-ai/dsh-tools'
+import { McpServersSchema } from './mcp-servers-schema.ts'
+import type { McpServersHostConfig } from './mcp-servers-schema.ts'
+import { applyMcpBridge } from './mcp-bridge.ts'
+
+export { MCP_SERVERS_NAMESPACE, McpServersSchema } from './mcp-servers-schema.ts'
+export type { McpServerConfig, McpServersSettings } from './mcp-servers-schema.ts'
+
+/** Services required: the mcp-client instances this plugin mounts inject the tool registry. */
+export const inject = ['tools']
+
+/** Config schema; the owning profile entry's id must equal `mcp-servers`. */
+export const Config = McpServersSchema
+
+/**
+ * Keep live mcp-client instances in sync with the resolved `mcp-servers`
+ * config, so the Settings page's MCP edits take effect without a restart.
+ * @param ctx - Host context whose tool registry the mounted mcp-client instances need.
+ * @param config - resolved `mcp-servers` section; `servers` is a live volatile reference.
+ */
+export function apply(ctx: Context, config: McpServersHostConfig): void {
+  const bridge = applyMcpBridge(ctx, () => ({
+    servers: config.servers.get().map(server => ({
+      ...server,
+      args: [...server.args],
+      env: { ...server.env },
+    })),
+  }))
+  ctx.on('loader/volatile-update', () => {
+    bridge.sync()
+  })
+  ctx.effect(() => () => {
+    void bridge.dispose()
+  }, 'mcp-servers: settings bridge')
+}

package/src/invariant.ts

@@ -0,0 +1,8 @@
+import type { Context } from '@deepseek-ai/cordis'
+import type { InvariantInstaller } from '@deepseek-ai/dsh-invariants'
+const PACKAGE_NAME = '@deepseek-ai/dsh-client-ui-settings-mcp'
+export const name = 'client-ui-settings-mcp-invariant'
+export const inject = ['invariants']
+const install: InvariantInstaller = () => {}
+export const apply = (ctx: Context): Promise<() => void> =>
+  Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install))

package/src/mcp-bridge.ts

@@ -0,0 +1,111 @@
+/** Settings -> mcp-client bridge: live-mounts MCP servers from the settings document. */
+
+import type { Context } from '@deepseek-ai/cordis'
+import * as McpClient from '@deepseek-ai/dsh-mcp-client'
+import type { McpServerConfig } from './mcp-servers-schema.ts'
+
+type PluginFiber = ReturnType<Context['plugin']>
+
+interface LiveInstance {
+  fiber: PluginFiber
+  signature: string
+}
+
+/**
+ * Build one mcp-client config from a settings entry. The settings service
+ * deeply freezes published values, while Schemastery's config parse fills
+ * defaults into the args array and env dict, so both are cloned first.
+ * @param server - one entry of the mcp-servers settings value.
+ * @returns validated mcp-client config for that server.
+ */
+function toClientConfig(server: McpServerConfig): McpClient.Config {
+  if (server.transport === 'streamable-http') {
+    return McpClient.Config({
+      transport: 'streamable-http',
+      serverName: server.name,
+      url: server.url,
+      headers: {},
+      failOnStartupError: false,
+    })
+  }
+  return McpClient.Config({
+    transport: 'stdio',
+    serverName: server.name,
+    command: server.command,
+    args: [...server.args],
+    env: { ...server.env },
+    cwd: '',
+    failOnStartupError: false,
+  })
+}
+
+/**
+ * Mount and keep live mcp-client instances in sync with the `mcp-servers` settings
+ * namespace. Creates, rebuilds, and disposes instances by `serverName` so editing the
+ * settings page takes effect without a restart. All sync work is serialized on one
+ * promise chain so concurrent settings writes cannot race the instance map.
+ * @param ctx - Host context carrying the tool registry required by mcp-client.
+ * @param getValue - accessor for the resolved settings value (called at sync time).
+ * @returns a sync trigger (call on settings change) and a dispose that drains the chain
+ *  and tears down every live instance.
+ */
+export function applyMcpBridge(
+  ctx: Context,
+  getValue: () => { servers: McpServerConfig[] } | undefined,
+): { sync: () => void; dispose: () => Promise<void> } {
+  const instances = new Map<string, LiveInstance>()
+  let chain: Promise<void> = Promise.resolve()
+
+  const syncOnce = async (): Promise<void> => {
+    const servers = getValue()?.servers ?? []
+    const next = new Map<string, McpServerConfig>()
+    for (const server of servers) {
+      if (!server.enabled) continue
+      if (next.has(server.name)) continue
+      next.set(server.name, server)
+    }
+    for (const [name, server] of next) {
+      const signature = JSON.stringify(server)
+      const existing = instances.get(name)
+      if (existing !== undefined && existing.signature === signature) continue
+      if (existing !== undefined) {
+        await existing.fiber.dispose()
+        instances.delete(name)
+      }
+      let config: McpClient.Config
+      try {
+        config = toClientConfig(server)
+      } catch (error: unknown) {
+        ctx.logger.warn('mcp-bridge: invalid server config for "%s": %s', name, String(error))
+        continue
+      }
+      const fiber = ctx.plugin(McpClient, config)
+      instances.set(name, { fiber, signature })
+    }
+    for (const [name, { fiber }] of instances) {
+      if (!next.has(name)) {
+        await fiber.dispose()
+        instances.delete(name)
+      }
+    }
+  }
+
+  const sync = (): void => {
+    chain = chain.then(syncOnce).catch((error: unknown) => {
+      ctx.logger.warn('mcp-bridge: sync failed: %s', String(error))
+    })
+  }
+
+  const dispose = async (): Promise<void> => {
+    chain = chain.finally(async () => {
+      for (const [, { fiber }] of instances) {
+        try { await fiber.dispose() } catch { /* instance already gone */ }
+      }
+      instances.clear()
+    })
+    await chain
+  }
+
+  sync()
+  return { sync, dispose }
+}

package/src/mcp-servers-schema.ts

@@ -0,0 +1,45 @@
+/** MCP servers settings schema (host + browser shared). */
+
+import type { Volatile } from '@deepseek-ai/cordis'
+import z from '@deepseek-ai/schemastery'
+
+/** Settings namespace owned by the MCP servers settings bridge. */
+export const MCP_SERVERS_NAMESPACE = 'mcp-servers'
+
+/** One MCP server declaration as stored in the user-settings document. */
+export interface McpServerConfig {
+  name: string
+  command: string
+  args: string[]
+  env: Record<string, string>
+  transport: 'stdio' | 'streamable-http'
+  url: string
+  enabled: boolean
+}
+
+/** Durable MCP servers section shared by the Host schema and the browser scope. */
+export interface McpServersSettings {
+  servers: McpServerConfig[]
+}
+
+const McpServerSchema = z.object({
+  name: z.string().required(),
+  command: z.string(),
+  args: z.array(String).default([]),
+  env: z.dict(String).default({}),
+  transport: z.union(['stdio', 'streamable-http']).default('stdio'),
+  url: z.string().default(''),
+  enabled: z.boolean().default(true),
+})
+
+/**
+ * Durable MCP servers schema. `servers` is volatile so the profile-config
+ * settings model exposes it as a live-editable field (the plugin is not
+ * remounted on edit; the bridge re-syncs on `loader/volatile-update`).
+ */
+export const McpServersSchema = z.object({
+  servers: z.array(McpServerSchema).default([]).volatile(),
+})
+
+/** Resolved Host config; the volatile field is read through its live reference. */
+export type McpServersHostConfig = { servers: Volatile<McpServerConfig[]> }