dsh-mcp-plus 0.1.0

package/src/dsh-mcp-plus.ts

@@ -0,0 +1,197 @@
+// dsh-mcp-plus:增强型 MCP 客户端插件
+import type { Context } from '@deepseek-ai/cordis'
+// ContentBlock:给 AI 看的内容块类型(text/图片等)
+import type { ContentBlock } from '@deepseek-ai/dsh-llm'
+// MCP 官方 SDK
+import { Client } from '@modelcontextprotocol/sdk/client/index.js'
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js'
+// 配置形状 + 配置文件读写 + HTTP 端点(本插件的三个子模块)
+import type { ServerConfig } from './config'
+import { loadServers } from './servers-store'
+import { registerHttpRoutes, setConnectionStatus, clearConnectionStatus } from './http'
+
+// 插件名(显示在日志/诊断里)
+export const name = 'dsh-mcp-plus'
+
+// 声明依赖:
+//   tools     → 注册工具给 AI
+//   webServer → 注册 HTTP 端点(设置 UI 的读写通道)
+export const inject = ['tools', 'webServer']
+
+// ---- 命名空间:多服务器不打架的关键 ----
+
+/**
+ * 生成模型可见的公开工具名:`mcp__<serverName>__<rawName>`(官方同款格式)
+ * 例:serverName=fs, rawName=read_file → mcp__fs__read_file
+ */
+function publicToolName(serverName: string, rawName: string): string {
+  return `mcp__${serverName}__${rawName}`
+}
+
+/**
+ * 连接一台 MCP 服务器,发现工具并全部注册进 ctx.tools
+ * @returns 清理函数:断开连接
+ */
+async function connectServer(ctx: Context, cfg: ServerConfig): Promise<() => Promise<void>> {
+  const transport = new StdioClientTransport({
+    command: cfg.command,
+    args: cfg.args,
+    env: cfg.env,
+    cwd: cfg.cwd,
+  })
+  const client = new Client({ name: 'dsh-mcp-plus', version: '0.0.1' })
+
+  // 标记连接中(UI 圆点显示黄色"连接中"态)
+  setConnectionStatus(cfg.serverName, 'connecting')
+  // 连接失败时标记状态并抛错(connectAllServers 会接住,不让一台拖垮整批)
+  try {
+    await client.connect(transport)
+  } catch (err) {
+    setConnectionStatus(cfg.serverName, 'disconnected')
+    throw err
+  }
+  setConnectionStatus(cfg.serverName, 'connected')
+  console.log(`[dsh-mcp-plus] (${cfg.serverName}) 已连接,开始发现工具...`)
+
+  const { tools } = await client.listTools()
+
+  // 收集本次注册的所有工具注销函数:清理时先注销工具再关连接,
+  // 否则旧工具残留在注册表里,重连时会 "already registered"
+  const toolDisposers: Array<() => void> = []
+  for (const tool of tools) {
+    const definition = {
+      // 公开名带服务器前缀 → 不同服务器的同名工具不会撞名
+      name: publicToolName(cfg.serverName, tool.name),
+      description: tool.description ?? '',
+      parameters: tool.inputSchema as Record<string, unknown>,
+      output: {
+        schema: {
+          type: 'object',
+          properties: {
+            content: { type: 'array', items: {} },
+          },
+          required: ['content'],
+          additionalProperties: false,
+        },
+        render: (_args: unknown, value: unknown): ContentBlock[] => {
+          const result = value as { content: Array<{ type?: string; text?: string }> }
+          const text = (result.content ?? [])
+            .map(block => block.type === 'text' ? block.text ?? '' : `[${block.type}]`)
+            .join('\n')
+          return [{ type: 'text', text }]
+        },
+      },
+      // 闭包里记住原始名 rawName:AI 看到的是公开名,但转发给服务器必须用原始名
+      async execute(args: unknown) {
+        const argsObj = (typeof args === 'object' && args !== null ? args : {}) as Record<string, unknown>
+        // 转发用原始名(服务器不认识 mcp__fs__ 前缀)
+        const result = await client.callTool({ name: tool.name, arguments: argsObj })
+        if (result.isError) {
+          throw new Error(`MCP 工具 ${tool.name} 执行失败`)
+        }
+        return { content: result.content as Array<{ type: string; text?: string }> }
+      },
+    }
+
+    try {
+      // 保存注销函数!清理时用它把工具从注册表移除
+      toolDisposers.push(ctx.tools.register(definition))
+      console.log(`[dsh-mcp-plus] (${cfg.serverName}) 已注册: ${definition.name}`)
+    } catch (err) {
+      console.log(`[dsh-mcp-plus] (${cfg.serverName}) 注册失败 ${definition.name}: ${err instanceof Error ? err.message : String(err)}`)
+    }
+  }
+  console.log(`[dsh-mcp-plus] (${cfg.serverName}) 完成:共 ${tools.length} 个工具`)
+
+  return async () => {
+    setConnectionStatus(cfg.serverName, 'disconnected')
+    // 先注销工具(防止残留)再关连接;注销失败不阻断关闭
+    for (const dispose of toolDisposers) {
+      try { dispose() } catch (err) {
+        console.log(`[dsh-mcp-plus] (${cfg.serverName}) 注销工具失败(继续): ${err instanceof Error ? err.message : String(err)}`)
+      }
+    }
+    await client.close()
+  }
+}
+
+/**
+ * 读配置文件 → 连接全部服务器 → 返回总清理函数。
+ * 初次加载和 UI 保存后的重连共用这一个函数。
+ * enabled === false 的服务器跳过(已配置但不连接)。
+ * 单台失败不影响其它服务器(容错),失败仅记日志,状态表标 disconnected。
+ */
+async function connectAllServers(ctx: Context): Promise<() => Promise<void>> {
+  // 开始新一轮连接前清空状态表(避免旧 serverName 残留)
+  clearConnectionStatus()
+
+  const allServers = await loadServers()
+
+  // serverName 唯一性检查:重复名是配置错误,响亮失败
+  const seen = new Set<string>()
+  for (const server of allServers) {
+    if (seen.has(server.serverName)) {
+      throw new Error(`[dsh-mcp-plus] serverName "${server.serverName}" 重复——每台服务器必须有唯一名字`)
+    }
+    seen.add(server.serverName)
+  }
+
+  // 过滤禁用的服务器(enabled === false 跳过;缺省视为启用)
+  const active = allServers.filter(s => s.enabled !== false)
+  const skipped = allServers.length - active.length
+  if (skipped > 0) console.log(`[dsh-mcp-plus] 跳过 ${skipped} 台禁用服务器`)
+
+  // 禁用的服务器直接标 disabled(从未尝试连接)
+  for (const s of allServers) {
+    if (s.enabled === false) setConnectionStatus(s.serverName, 'disabled')
+  }
+
+  // 逐个连接;单台失败不影响其它(容错)
+  const disposers: Array<() => Promise<void>> = []
+  for (const server of active) {
+    try {
+      disposers.push(await connectServer(ctx, server))
+    } catch (err) {
+      console.log(`[dsh-mcp-plus] (${server.serverName}) 连接失败: ${err instanceof Error ? err.message : String(err)}`)
+    }
+  }
+  console.log(`[dsh-mcp-plus] 加载了 ${active.length} 台服务器(${disposers.length} 成功)`)
+
+  return async () => {
+    await Promise.all(disposers.map(dispose => dispose()))
+  }
+}
+
+export function apply(ctx: Context): void {
+  // 当前连接集的清理函数。effect 与 UI 保存后的重连共享这一个引用:
+  // 不管谁重建连接,旧连接都会先被断开,插件卸载时断开的是最新一组。
+  let currentDispose: (() => Promise<void>) | undefined
+
+  /** 读配置 → 断开旧连接 → 连接新配置(初次加载与重连共用) */
+  const connectAll = async (): Promise<void> => {
+    // 先断开旧的(如果有);错误也要继续,别让一次断开失败卡死重连
+    if (currentDispose) {
+      try { await currentDispose() } catch (err) {
+        console.log('[dsh-mcp-plus] 断开旧连接失败(继续): ' + (err instanceof Error ? err.message : String(err)))
+      }
+      currentDispose = undefined
+    }
+    // connectAllServers 只负责连接,返回清理函数存到共享引用
+    currentDispose = await connectAllServers(ctx)
+  }
+
+  // HTTP 端点:UI 的读写通道。直接注册(不挂 effect)→ 重连不卸载,端点一直可达
+  // 保存成功后调 connectAll 完成重连
+  registerHttpRoutes(ctx, connectAll)
+
+  // 初次加载:挂在 effect 上,插件卸载时自动断开当前连接(生命周期管理)
+  // 注意:此处 effect 只管 MCP 连接,端点独立存活(注册时就没挂 effect)
+  ctx.effect(() => {
+    void connectAll()
+    // effect 的清理函数:断开「最新的」那组连接
+    return async () => {
+      if (currentDispose) await currentDispose()
+      currentDispose = undefined
+    }
+  }, 'dsh-mcp-plus.servers')
+}

package/src/http.ts

@@ -0,0 +1,116 @@
+// http.ts —— host 半的 HTTP 端点:让浏览器 UI 能读写服务器配置
+//
+// 注册到 DSH webServer 服务(dsh-pet 同款模式):
+//   GET  /dsh-mcp-plus/servers → 返回当前服务器列表(JSON)
+//   PUT  /dsh-mcp-plus/servers → 保存新列表 + 触发重连(响应里带回连接结果)
+//
+// 重连机制:PUT 保存后调用传入的 reload 回调——reload 由主插件提供,
+// 它会断开所有现有连接(走 effect 清理)再按新配置重新连接。
+import type { IncomingMessage, ServerResponse } from 'node:http'
+import type { Context } from '@deepseek-ai/cordis'
+import { loadServers, saveServers, SERVERS_FILE } from './servers-store'
+import { validateServers } from './config'
+
+/** 我们的路由前缀(绝对路径,无尾斜杠) */
+export const ROUTE_PREFIX = '/dsh-mcp-plus'
+
+/** 模块级连接状态表(serverName → connecting / connected / disconnected / disabled) */
+const connectionStatus = new Map<string, 'connecting' | 'connected' | 'disconnected' | 'disabled'>()
+
+/** host 半在每次 connect/disconnect 时更新这张表,UI 通过 GET 拿到 */
+export function setConnectionStatus(serverName: string, status: 'connecting' | 'connected' | 'disconnected' | 'disabled'): void {
+  connectionStatus.set(serverName, status)
+}
+
+/** 清空状态表(disconnect 所有连接时) */
+export function clearConnectionStatus(): void {
+  connectionStatus.clear()
+}
+
+/** 读请求体(UTF-8 字符串) */
+function readBody(req: IncomingMessage): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = []
+    req.on('data', chunk => chunks.push(chunk as Buffer))
+    req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')))
+    req.on('error', reject)
+  })
+}
+
+/** 发送 JSON 响应 */
+function sendJson(res: ServerResponse, status: number, body: unknown): void {
+  res.writeHead(status, { 'Content-Type': 'application/json; charset=utf-8' })
+  res.end(JSON.stringify(body))
+}
+
+/**
+ * 注册配置读写端点。直接注册到 webServer(不挂 effect → 重连不卸载,端点一直可达)。
+ * @param ctx - host 半插件上下文(需要 webServer 服务)
+ * @param reload - 保存成功后异步触发的重连函数(不等待,fire-and-forget)
+ */
+export function registerHttpRoutes(ctx: Context, reload: () => Promise<void>): void {
+  // inject = ['webServer'] 由主插件声明;这里直接从 ctx 取
+  const webServer = (ctx as unknown as { webServer?: {
+    register(route: { kind: string; path: string; handler: (req: IncomingMessage, res: ServerResponse) => Promise<void> }): () => void
+  } }).webServer
+  if (!webServer) {
+    console.log('[dsh-mcp-plus] webServer 服务不可用,HTTP 端点未注册(设置 UI 将无法保存)')
+    return
+  }
+
+  // 直接注册到 webServer(不挂在 ctx.effect 里 → 重连不卸载,端点一直可达)
+  webServer.register({
+    kind: 'prefix',
+    path: ROUTE_PREFIX,
+    handler: async (req, res) => {
+        // prefix 路由收到的是完整路径(含 ROUTE_PREFIX),去掉查询串后做全路径匹配
+        const url = (req.url ?? '/').split('?')[0]
+        const method = req.method ?? 'GET'
+        const serversPath = ROUTE_PREFIX + '/servers'
+
+        // GET /dsh-mcp-plus/servers → 读配置 + 当前连接状态
+        if (url === serversPath && method === 'GET') {
+          try {
+            const servers = await loadServers()
+            // 给每个 serverName 附带连接状态:
+            //   - enabled === false → 'disabled'(用户配置就是不连接)
+            //   - connectionStatus 有记录 → 用记录值('connected' / 'disconnected')
+            //   - 都没匹配 → 'disconnected'(刚启动/重连中,默认未连接)
+            const enriched = servers.map(s => {
+              const liveStatus = connectionStatus.get(s.serverName)
+              const status = s.enabled === false
+                ? 'disabled'
+                : (liveStatus ?? 'connecting')
+              return { ...s, status }
+            })
+            sendJson(res, 200, { servers: enriched, file: SERVERS_FILE })
+          } catch (err) {
+            sendJson(res, 500, { error: '读取配置失败: ' + (err instanceof Error ? err.message : String(err)) })
+          }
+          return
+        }
+
+        // PUT /dsh-mcp-plus/servers → 只写盘,立即响应;重连异步进行,状态经圆点展示
+        if (url === serversPath && method === 'PUT') {
+          try {
+            const body = await readBody(req)
+            // 先校验再落盘:非法配置直接 400,不写脏数据
+            const servers = validateServers(JSON.parse(body))
+            await saveServers(servers)
+            // 异步重连:不阻塞响应。所有启用台先标 connecting,
+            // connectServer 成功→connected / 失败→disconnected,UI 轮询圆点看进展
+            void reload().catch(err => {
+              console.log('[dsh-mcp-plus] 重连失败: ' + (err instanceof Error ? err.message : String(err)))
+            })
+            sendJson(res, 200, { ok: true, count: servers.length })
+          } catch (err) {
+            sendJson(res, 400, { error: '保存失败: ' + (err instanceof Error ? err.message : String(err)) })
+          }
+          return
+        }
+
+        sendJson(res, 404, { error: `未知端点: ${method} ${url}` })
+      },
+    },
+  )
+}

package/src/servers-store.ts

@@ -0,0 +1,44 @@
+// servers-store.ts —— 服务器配置文件的「读写」
+// 回答:配置存在哪个文件?怎么读出来?怎么写回去?
+// 路径沿用 dsh-pet 的惯例:~/.dsh/<插件名>/<文件名>
+import { dshHomePath } from '@deepseek-ai/dsh-home-paths'
+import { mkdir, readFile, writeFile } from 'node:fs/promises'
+import { dirname } from 'node:path'
+import { validateServers, type ServerConfig } from './config'
+
+/** 配置文件绝对路径:~/.dsh/dsh-mcp-plus/servers.json */
+export const SERVERS_FILE = dshHomePath('dsh-mcp-plus', 'servers.json')
+
+/**
+ * 读配置文件,返回服务器列表。
+ * - 文件不存在 → 空列表(还没配置过任何服务器,正常情况)
+ * - 文件存在但非法 → 抛错(让上层知道配置坏了,别静默吞掉)
+ */
+export async function loadServers(): Promise<ServerConfig[]> {
+  let raw: string
+  try {
+    raw = await readFile(SERVERS_FILE, 'utf8')
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+      return [] // 文件不存在 = 还没配置过
+    }
+    throw err
+  }
+  // 读出的 JSON 文本 → 解析成对象 → 校验(校验失败会抛错)
+  return validateServers(JSON.parse(raw))
+}
+
+/**
+ * 写配置文件(全量覆盖)。
+ * 自动创建目录。写入前剥离运行时字段(status 等)——它们不该被持久化,
+ * 否则下次读取会被当作配置的一部分(servers.json 里已经出现过这个污染)。
+ */
+export async function saveServers(servers: ServerConfig[]): Promise<void> {
+  await mkdir(dirname(SERVERS_FILE), { recursive: true })
+  // 只保留配置字段,丢弃 status 等运行时注入
+  const clean = servers.map(({ serverName, transport, command, args, env, cwd, enabled }) => ({
+    transport, serverName, command, args, env, cwd,
+    ...(enabled !== undefined ? { enabled } : {}),
+  }))
+  await writeFile(SERVERS_FILE, JSON.stringify({ servers: clean }, null, 2) + '\n', 'utf8')
+}