dsh-vscode-mode 0.12.0 → 0.13.1

package/src/lsp/transport.ts

@@ -1,180 +1,137 @@
-/**
- * dsh-vscode-mode host — LSP 语言服务器进程传输层。
- * 基于 node:child_process.spawn（stdio pipe 双向流）。刻意不用 DSH ctx.subprocess
- * 抽象：LSP 需要持续写 stdin + 流式读 stdout，而该抽象 stdin 不可写、输出为一次性收集。
- * 作者 ddj 2026-08-27
- */
-import { spawn, type ChildProcess } from 'node:child_process'
+/** LSP 双向 stdio 传输；外部进程使用清理后的环境及独立进程组。 */
+import { spawn } from 'node:child_process'
+import type { ChildProcess, ChildProcessWithoutNullStreams } from 'node:child_process'
 import { createFrameParser } from './jsonrpc.js'
+import { childEnv } from '../childEnv.js'
+import { killTree, stopTree } from '../processTree.js'
 
 const STDERR_CAP = 256 << 10
-
 export interface TransportSpec {
   argv: string[]
   cwd?: string
   env?: Record<string, string>
 }
-
 export interface Transport {
-  /** 写一行帧到 stdin（自动加换行）。 */
   write(chunk: Buffer): boolean
-  /** 推送 stdout 解析出的原始消息（内部由帧解析器调用）。 */
   onMessage: ((message: unknown) => void) | null
-  /** stderr 收集缓冲（有界，供诊断）。 */
   stderr(): string
-  /** 进程退出/崩溃回调（code/signal）。 */
   onExit: ((code: number | null, signal: string | null) => void) | null
-  /** 优雅关闭后强杀（Windows 下连带进程树）。 */
   dispose(): void
-  /** 是否仍存活。 */
   readonly alive: boolean
   readonly pid: number | undefined
 }
-
 const running = new Set<ChildProcess>()
 
-/** 当前仍在运行的 LSP 子进程（供 disposeAll / 诊断）。 */
-export function liveChildren(): ReadonlySet<ChildProcess> {
-  return running
-}
+/** 当前仍归本模块管理的进程。 */
+export function liveChildren(): ReadonlySet<ChildProcess> { return running }
 
 /**
- * 启动语言服务器进程。
- * @author ddj 2026年08月27号
- * @param spec 启动参数（argv 数组，不经 shell，Windows 引号安全）
- * @param onMessage stdout 消息回调
- * @param logger 诊断日志（可选）
- * @returns 传输句柄
+ * 建立传输状态与回收路径；根进程退出也立即回收剩余进程组。
+ * @private
+ * @author ddj 2026年09月28号
+ * @param child 新建子进程
+ * @param onMessage 协议消息回调
+ * @param logger 诊断回调
+ * @returns 传输句柄与错误缓冲写入器
  */
-export function spawnServer(spec: TransportSpec, onMessage: (message: unknown) => void, logger?: (line: string) => void): Transport {
-  const { argv, cwd, env } = spec
-  const child = spawn(argv[0], argv.slice(1), {
-    cwd,
-    env: { ...process.env, ...env },
-    stdio: ['pipe', 'pipe', 'pipe'],
-    windowsHide: true,
-  })
-  running.add(child)
-  let stderrBuf = Buffer.alloc(0)
+function makeTransport(child: ChildProcessWithoutNullStreams, onMessage: (message: unknown) => void, logger?: (line: string) => void) {
   let alive = true
-  const parser = createFrameParser()
-
-  child.stderr.on('data', (chunk: Buffer) => {
-    if (stderrBuf.length < STDERR_CAP) {
-      stderrBuf = Buffer.concat([stderrBuf, chunk], Math.min(stderrBuf.length + chunk.length, STDERR_CAP))
-    }
-    logger?.(chunk.toString('utf8'))
-  })
-
-  let exited = false
-  const emitExit = (code: number | null, signal: string | null): void => {
-    if (exited) return
-    exited = true
-    alive = false
-    running.delete(child)
-    transport.onExit?.(code, signal)
-  }
-  child.on('error', (error) => {
-    logger?.('spawn error: ' + String(error))
-    emitExit(null, null)
-  })
-  child.on('exit', (code, signal) => emitExit(code, signal))
-  child.on('close', (code, signal) => emitExit(code, signal))
-
+  let disposed = false
+  let stderrBuf = Buffer.alloc(0)
+  let finish: (() => void) | undefined
   const transport: Transport = {
+    /** @public @author ddj 2026年09月28号 @param chunk 协议帧 @returns 是否可写 */
     write(chunk: Buffer): boolean {
       if (!alive || !child.stdin.writable) return false
       child.stdin.write(chunk)
       return true
     },
     onMessage,
-    stderr(): string {
-      return stderrBuf.toString('utf8')
-    },
+    /** @public @author ddj 2026年09月28号 @returns 有界错误缓冲 */
+    stderr(): string { return stderrBuf.toString('utf8') },
     onExit: null,
+    /** @public @author ddj 2026年09月28号 @description 停止整个进程树，根退出不取消回收。 */
     dispose(): void {
-      if (!alive) return
-      // 先 SIGTERM 让服务器有机会清理，1.5s 后强杀进程树
-      child.kill()
-      const timer = setTimeout(() => {
-        if (!alive) return
-        alive = false
-        running.delete(child)
-        try {
-          if (process.platform === 'win32') {
-            spawn('taskkill', ['/PID', String(child.pid), '/T', '/F'], { windowsHide: true, stdio: 'ignore' })
-          } else {
-            child.kill('SIGKILL')
-          }
-        } catch (error) {
-          logger?.('force kill error: ' + String(error))
-        }
-      }, 1500)
-      timer.unref?.()
-    },
-    get alive() {
-      return alive
-    },
-    get pid() {
-      return child.pid
+      if (disposed) return
+      disposed = true
+      finish = stopTree(child, logger)
     },
+    get alive() { return alive },
+    get pid() { return child.pid },
+  }
+  /** @private @author ddj 2026年09月28号 @param code 退出码 @param signal 退出信号 */
+  const emitExit = (code: number | null, signal: string | null): void => {
+    if (!alive) return
+    alive = false
+    disposed = true
+    if (finish) finish()
+    else killTree(child, logger)
+    running.delete(child)
+    transport.onExit?.(code, signal)
   }
-  // stdout 帧解析 → onMessage（LSP 响应/通知；onMessage 由 client 接管后动态生效）
+  child.on('error', (error) => { logger?.('spawn error: ' + String(error)); emitExit(null, null) })
+  child.on('exit', emitExit)
+  child.on('close', emitExit)
+  child.stderr.on('data', (chunk: Buffer) => {
+    if (stderrBuf.length < STDERR_CAP) stderrBuf = Buffer.concat([stderrBuf, chunk], Math.min(stderrBuf.length + chunk.length, STDERR_CAP))
+    logger?.(chunk.toString('utf8'))
+  })
+  return transport
+}
+
+/**
+ * 启动语言服务器并接入协议流，显式 env 在父环境清理后覆盖。
+ * @public
+ * @author ddj 2026年09月28号
+ * @param spec 启动参数，不经 shell
+ * @param onMessage stdout 协议消息回调
+ * @param logger 诊断日志
+ * @returns 传输句柄
+ * @throws spawn 的同步参数错误
+ */
+export function spawnServer(spec: TransportSpec, onMessage: (message: unknown) => void, logger?: (line: string) => void): Transport {
+  const child = spawn(spec.argv[0], spec.argv.slice(1), {
+    cwd: spec.cwd,
+    env: childEnv(spec.env),
+    stdio: ['pipe', 'pipe', 'pipe'],
+    windowsHide: true,
+    detached: process.platform !== 'win32',
+  })
+  running.add(child)
+  const transport = makeTransport(child, onMessage, logger)
+  const parser = createFrameParser()
   child.stdout.on('data', (chunk: Buffer) => {
     for (const message of parser.push(chunk)) transport.onMessage?.(message)
   })
+  // 写入管道在退出竞态中可能异步 EPIPE，必须监听以免宿主未处理异常。
+  child.stdin.on('error', (error) => logger?.('stdin error: ' + String(error)))
   return transport
 }
 
-/** 强杀全部运行中的 LSP 子进程（插件卸载/退出用）。 */
-export function disposeAllServers(): void {
-  for (const child of running) {
-    try {
-      if (process.platform === 'win32' && child.pid) {
-        spawn('taskkill', ['/PID', String(child.pid), '/T', '/F'], { windowsHide: true, stdio: 'ignore' })
-      } else {
-        child.kill('SIGKILL')
-      }
-    } catch (error) {
-      /* 忽略单个清理失败 */
-    }
-  }
+/**
+ * 回收本模块所有进程树。
+ * @public
+ * @author ddj 2026年09月28号
+ * @param sync 宿主 exit 钩子使用同步 taskkill
+ */
+export function disposeAllServers(sync = false): void {
+  for (const child of running) killTree(child, undefined, sync)
   running.clear()
 }
 
-/** 进程退出回收是否已注册（防重复挂监听）。 */
 let exitHooked = false
-
 /**
- * 宿主进程退出时回收 LSP 子进程（幂等）。
- *
- * 为什么需要：插件的 ctx.effect 清理只在卸载/重载时触发，宿主进程退出不触发，
- * 于是 emmylua_ls / dotnet 等服务器会成为跨重启的孤儿常驻（实测孤儿启动时间早于宿主，
- * 长期占用内存与工作区文件句柄）。
- *
- * ⚠️ 只回收、不退出：宿主自身已注册 SIGINT/SIGTERM 处理（DSH profile-boot 走
- * shutdown.interrupt → 优雅关闭 + 状态落盘），这里若调 process.exit 会打断该流程。
- * 因此仅在信号到达时顺带回收子进程，退出时机与退出码仍由宿主决定。
- *
- * ⚠️ 信号监听只在宿主已有监听时才挂：Node 的默认信号语义（终止进程）会被首个监听器
- * 取代，若本插件是唯一监听者，挂上去反而让 Ctrl+C 不再退出宿主。无既有监听即跳过，
- * 交由 'exit' 事件兜底。
- *
- * exit 事件下只能同步执行，Windows 的 child.kill 不走进程树，故复用
- * disposeAllServers 的 taskkill /T /F 强杀路径；best-effort，失败不阻塞退出。
- * @author ddj 2026年09月11号
+ * 注册宿主退出回收；不夺取宿主原有信号退出语义。
+ * @public
+ * @author ddj 2026年09月28号
+ * @description exit 用同步回收；仅在宿主已有信号监听时追加收尾。
  */
 export function hookExitReclaim(): void {
   if (exitHooked) return
   exitHooked = true
-  const reclaim = (): void => {
-    try {
-      disposeAllServers()
-    } catch (error) { /* 退出路径静默 */ }
-  }
-  process.on('exit', reclaim)
+  process.on('exit', () => disposeAllServers(true))
   for (const signal of ['SIGINT', 'SIGTERM'] as const) {
     if (process.listenerCount(signal) === 0) continue
-    process.on(signal, reclaim)
+    process.on(signal, () => disposeAllServers())
   }
 }

package/src/mcp.ts

@@ -12,6 +12,7 @@ import {
 } from './compat.js'
 import type { MpcConfig, MpcServer, MpcTool } from './shared/mcp.js'
 import type { Ctx } from './store.js'
+import { checkMcpName } from './mcpProject.js'
 
 export { LEGACY_PROJECT_PREFIX, MCP_PACKAGE, PROJECT_ENTRY_PREFIX, isProjectEntryId }
 
@@ -31,10 +32,17 @@ export function publicConfig(config: Record<string, unknown>): MpcConfig {
   return out as unknown as MpcConfig
 }
 
-/** 从工具注册表读取服务器命名空间下的工具摘要。 */
-export function toolsOf(ctx: Ctx, serverName: string): MpcTool[] {
+/**
+ * Read tool summaries from the caller's exact visible scope.
+ * @public @author ddj 2026年09月28号
+ * @param ctx Host tools service.
+ * @param serverName Server namespace.
+ * @param agent Optional agent scope; omitted for global entries.
+ * @returns Scoped tool summaries, allowing resource-only servers to have zero tools.
+ */
+export function toolsOf(ctx: Ctx, serverName: string, agent?: any): MpcTool[] {
   const tools = ctx.get('tools')
-  const view = tools?.view?.(void 0)
+  const view = tools?.view?.(agent)
   const visible = view?.visible
   if (!(visible instanceof Map)) return []
   const prefix = `mcp__${serverName}__`
@@ -44,7 +52,37 @@ export function toolsOf(ctx: Ctx, serverName: string): MpcTool[] {
   }))
 }
 
-/** 将 loader entry 映射为设置页摘要。 */
+/**
+ * Restore unchanged masked values without inventing credentials for new keys.
+ * @public @author ddj 2026年09月28号
+ * @param next Submitted configuration, including editable unknown fields.
+ * @param previous Last persisted configuration.
+ * @returns Detached configuration with unchanged secrets restored; throws for an orphan mask.
+ */
+export function mergeSecrets(next: Record<string, unknown>, previous: Record<string, unknown>): Record<string, unknown> {
+  const merged = { ...next }
+  for (const field of ['env', 'headers']) {
+    const values = next[field]
+    if (!values || typeof values !== 'object' || Array.isArray(values)) continue
+    const old = previous[field] as Record<string, unknown> | undefined
+    const restored: Record<string, unknown> = Object.create(null)
+    for (const [key, value] of Object.entries(values)) {
+      if (value !== '••••••') { restored[key] = value; continue }
+      if (!old || !Object.hasOwn(old, key)) throw new Error('脱敏凭据没有原值，请重新填写：' + key)
+      restored[key] = old[key]
+    }
+    merged[field] = restored
+  }
+  return merged
+}
+
+/**
+ * Summarize a global entry without treating plugin activation as a successful handshake.
+ * @public @author ddj 2026年09月28号
+ * @param ctx Host services.
+ * @param entry Global loader entry.
+ * @returns Masked status and globally visible tools.
+ */
 export function serverOf(ctx: Ctx, entry: any): MpcServer {
   const config = (entry.options?.config ?? {}) as Record<string, unknown>
   const serverName = typeof config.serverName === 'string' ? config.serverName : entry.options?.id ?? 'unknown'
@@ -53,10 +91,12 @@ export function serverOf(ctx: Ctx, entry: any): MpcServer {
   return {
     id: String(entry.id ?? entry.options?.id ?? serverName),
     serverName,
-    enabled: entry.disabled !== true,
+    enabled: entry.disabled !== true && entry.options?.disabled !== true,
     transport: config.transport === 'streamable-http' ? 'streamable-http' : 'stdio',
     config: publicConfig(config),
-    status: state === 2 ? 'connected' : state === 1 ? 'connecting' : 'error',
+    status: entry.disabled === true || entry.options?.disabled === true ? 'disabled'
+      : state === 2 ? 'unverified' : state === 1 || state === 0 ? 'connecting' : state === 3 ? 'error' : 'configured',
+    instanceCount: entry.fiber ? 1 : 0,
     toolCount: tools.length,
     tools,
     error: state === 3 ? 'MCP 插件未正常运行' : undefined,
@@ -75,17 +115,26 @@ export function listMcp(ctx: Ctx): { servers: MpcServer[] } {
   return { servers: entriesOf(ctx).filter((entry) => !isProjectEntryId(String(entry.id ?? entry.options?.id ?? ''))).map((entry) => serverOf(ctx, entry)) }
 }
 
-/** 保存 MCP 服务配置并触发 loader 热更新。 */
+/**
+ * Save a global loader entry while preserving advanced options and unchanged secrets.
+ * @public @author ddj 2026年09月28号
+ * @param ctx Host loader context.
+ * @param config Submitted global configuration.
+ * @returns Masked server status; project name collisions reject before writing.
+ */
 export async function saveMcp(ctx: Ctx, config: MpcConfig): Promise<MpcServer> {
   validateConfig(config)
+  await checkMcpName(ctx, config.serverName)
   const loader = ctx.get('loader')
   if (!loader) throw new Error('缺少 loader 服务')
   const existing = entriesOf(ctx).find((entry) => !isProjectEntryId(String(entry.id ?? entry.options?.id ?? '')) && entry.options?.config?.serverName === config.serverName)
+  const previous = existing?.options?.config ?? {}
+  const next = mergeSecrets({ ...previous, ...config }, previous)
   if (existing) {
-    await loader.update(existing.id, { config: { ...config } })
+    await loader.update(existing.id, { config: next })
     return serverOf(ctx, loader.resolve(existing.id))
   }
-  const id = await loader.create({ name: MCP_PACKAGE, config: { ...config } })
+  const id = await loader.create({ name: MCP_PACKAGE, config: next })
   return serverOf(ctx, loader.resolve(id))
 }