dsh-vscode-mode 0.17.0 → 0.18.0

package/src/mcpDiscover.ts

@@ -0,0 +1,38 @@
+/** Scoped capability discovery; never accepts commands, paths or caller identity. @author ddj 2026年10月20号 */
+import type { McpRuntime } from './mcpRuntime.js'
+
+/** @public @author ddj 2026年10月20号 @param runtime Authorized runtime. @param ctx Host registration context. @returns Global discovery cleanup; normal capability filters remain authoritative. */
+export function installDiscover(runtime: McpRuntime, ctx: any): () => void {
+  const tools = ctx.get('tools')
+  /** @author ddj 2026年10月20号 @param args Validated operation. @param execution Registry-owned caller identity. @returns Safe capability catalogue or real connected schemas. */
+  const execute = async (args: any, execution: any): Promise<unknown> => {
+    const agent = execution.agent
+    if (!agent || !runtime.agents.has(agent)) throw new Error('会话未激活，不能使用项目 MCP 发现入口')
+    if (!args || typeof args !== 'object' || Array.isArray(args) || Object.keys(args).some((key) => !['action', 'serverName'].includes(key))) throw new Error('发现入口仅接受 action 和 serverName')
+    if (!['list', 'connect'].includes(args.action)) throw new Error('action 必须为 list 或 connect')
+    if (args.action === 'list') return runtime.catalogue(agent)
+    if (typeof args.serverName !== 'string') throw new Error('请指定已配置的 serverName')
+    return runtime.connect(agent, args.serverName, execution.signal)
+  }
+  /** @author ddj 2026年10月20号 @param _args Unused. @param result Safe canonical JSON. @returns Native content without bypassing output validation. */
+  const render = (_args: unknown, result: unknown): any[] => [{ type: 'text', text: JSON.stringify(result) }]
+  const removeTool = tools.register({
+    name: 'discover_project_mcp', description: 'List this workspace’s configured project MCP services without starting them, or connect one to discover its real tools. After connecting, call discovered tools in the NEXT request/program; never guess schemas. Global/preset MCPs are not included.',
+    parameters: { type: 'object', properties: { action: { type: 'string', enum: ['list', 'connect'] }, serverName: { type: 'string' } }, required: ['action'], additionalProperties: false },
+    output: { schema: {}, render }, execute,
+  })
+  return removeTool
+}
+
+/** @public @author ddj 2026年10月20号 @param runtime Active owners. @param agent Scoped catalogue owner. @returns Scoped instruction cleanup; does not register a tool override. */
+export function discoverPrompt(runtime: McpRuntime, agent: any): () => void {
+  const prompt = agent.ctx.get('systemPrompt')
+  /** @author ddj 2026年10月20号 @returns Current enabled names only; no credential-bearing configuration. */
+  const text = (): string => {
+    const names = runtime.catalogue(agent).map((server) => server.serverName)
+    if (!names.length) return ''
+    return 'Project MCP capabilities (may not be started): ' + JSON.stringify(names) + '. Use discover_project_mcp action=list, then action=connect with serverName when needed. Only use returned real tool schemas. Native tools appear on the next model request; PTC must finish the current program and start a new program to refresh its SDK. Do not eval or bypass tool approval.'
+  }
+  const removePrompt = prompt.section({ name: 'vscode-mode:project-mcp', order: 3090, text, interpolate: false })
+  return removePrompt
+}

package/src/mcpPool.ts

@@ -0,0 +1,245 @@
+/** Connection ownership, bounded cold starts and workspace leases. @author ddj 2026年10月20号 */
+import { createHash } from 'node:crypto'
+import { McpBridge } from './mcpBridge.js'
+import type { McpPolicy, McpPhase, MpcConfig } from './shared/mcp.js'
+import type { Ctx } from './store.js'
+
+export interface PoolSpec {
+  workspace: string
+  owner: object
+  config: MpcConfig
+  policy: McpPolicy
+}
+export interface PoolEntry {
+  key: string
+  spec: PoolSpec
+  refs: number
+  phase: McpPhase
+  queuedAt: number
+  phaseAt: number
+  finishedAt?: number
+  startAt?: number
+  connectedAt?: number
+  error?: string
+  retryAt?: number
+  bridge?: McpBridge
+  fiber?: any
+  ready: Promise<void>
+  close?: Promise<void>
+  idle?: ReturnType<typeof setTimeout>
+  live: boolean
+  calls: Promise<unknown>
+}
+export interface PoolLease {
+  entry: PoolEntry
+  release(): void
+}
+export type BridgeMaker = () => Promise<McpBridge>
+
+/** @private @author ddj 2026年10月20号 @param input Plain effective configuration. @returns Stable secret-bearing identity used only as digest input. */
+function stableConfig(input: unknown): string {
+  if (Array.isArray(input)) return '[' + input.map(stableConfig).join(',') + ']'
+  if (input && typeof input === 'object') {
+    const config = input as Record<string, unknown>
+    return '{' + Object.keys(config).sort().map((key) => JSON.stringify(key) + ':' + stableConfig(config[key])).join(',') + '}'
+  }
+  return JSON.stringify(input) ?? 'null'
+}
+
+/** @public @author ddj 2026年10月20号 @param task Shared work that must remain alive for other waiters. @param signal One waiter's cancellation. @returns Caller-local wait without abandoning owned pool work. */
+export function waitMcp<T>(task: Promise<T>, signal?: AbortSignal): Promise<T> {
+  if (!signal) return task
+  return new Promise<T>((resolve, reject) => {
+    /** @author ddj 2026年10月20号 Rejects only this waiter. */
+    const abort = (): void => { reject(new Error('MCP 等待已取消')) }
+    if (signal.aborted) { abort(); return }
+    signal.addEventListener('abort', abort, { once: true })
+    task.then(resolve, reject).finally(() => signal.removeEventListener('abort', abort))
+  })
+}
+
+/** The pool owns private scopes independently from any first subscriber. */
+export class McpPool {
+  readonly entries = new Map<string, PoolEntry>()
+  private readonly owners = new WeakMap<object, number>()
+  private ownerSeq = 0
+  private running = 0
+  private readonly queue: Array<() => Promise<void>> = []
+  private readonly jobs = new Set<Promise<void>>()
+  private stopped = false
+
+  /** @public @author ddj 2026年10月20号 @param ctx Host lifecycle owner. @param load Official plugin loader. @param make Private scope factory. */
+  constructor(private readonly ctx: Ctx, private readonly load: () => Promise<any>, private readonly make: BridgeMaker = () => McpBridge.create(ctx)) {}
+
+  /** @private @author ddj 2026年10月20号 @param spec Effective request. @returns Private digest; never emit configuration or secrets. */
+  private keyOf(spec: PoolSpec): string {
+    let owner = 0
+    if (spec.policy.sharing === 'agent') {
+      if (!this.owners.has(spec.owner)) this.owners.set(spec.owner, ++this.ownerSeq)
+      owner = this.owners.get(spec.owner)!
+    }
+    const workspace = process.platform === 'win32' ? spec.workspace.replace(/\\/g, '/').toLowerCase() : spec.workspace
+    return createHash('sha256').update(stableConfig([workspace, owner, spec.config, spec.policy])).digest('hex')
+  }
+
+  /** @public @author ddj 2026年10月20号 @param spec Authorized connection request. @returns Reference-counted single-flight lease. */
+  acquire(spec: PoolSpec): PoolLease {
+    if (this.stopped) throw new Error('MCP runtime is disposed')
+    const key = this.keyOf(spec)
+    let entry = this.entries.get(key)
+    if (entry?.phase === 'error' && entry.retryAt !== undefined && Date.now() >= entry.retryAt && !entry.close) {
+      this.entries.delete(key)
+      entry = undefined
+    }
+    if (entry && !entry.live) throw new Error(entry.error ?? 'MCP 旧连接仍在释放，暂不能创建替代实例')
+    if (!entry) {
+      entry = { key, spec, refs: 0, phase: 'queued', queuedAt: Date.now(), phaseAt: Date.now(), ready: Promise.resolve(), live: true, calls: Promise.resolve() }
+      this.entries.set(key, entry)
+      entry.ready = this.schedule(entry)
+      void entry.ready.catch(() => undefined)
+    }
+    if (entry.idle) clearTimeout(entry.idle)
+    entry.idle = undefined
+    entry.refs += 1
+    let released = false
+    return { entry, release: () => {
+      if (released) return
+      released = true
+      this.release(entry!)
+    } }
+  }
+
+  /** @private @author ddj 2026年10月20号 @param entry New entry. @returns Queued initialization, bounded to two concurrent starts. */
+  private schedule(entry: PoolEntry): Promise<void> {
+    return new Promise<void>((resolve, reject) => {
+      /** @author ddj 2026年10月20号 Initializes a still-owned queue item. */
+      const run = async (): Promise<void> => {
+        try { await this.start(entry); resolve() } catch (error) { reject(error) }
+      }
+      this.queue.push(run)
+      this.pump()
+    })
+  }
+
+  /** @private @author ddj 2026年10月20号 Advances FIFO work; each task holds its slot until startup or cleanup quiesces. */
+  private pump(): void {
+    while (this.running < 2 && this.queue.length) {
+      const run = this.queue.shift()!
+      this.running += 1
+      const job = run().finally(() => {
+        this.running -= 1
+        this.jobs.delete(job)
+        this.pump()
+      })
+      this.jobs.add(job)
+    }
+  }
+
+  /** @private @author ddj 2026年10月20号 @param entry Connection to initialize. @returns Initialization completion, or failure after owned cleanup. */
+  private async start(entry: PoolEntry): Promise<void> {
+    if (!entry.live || this.stopped) throw new Error('MCP 启动已取消')
+    entry.phase = 'loading'
+    entry.phaseAt = Date.now()
+    entry.startAt = entry.phaseAt
+    let timer: ReturnType<typeof setTimeout> | undefined
+    const work = this.mount(entry)
+    const deadline = new Promise<never>((_resolve, reject) => {
+      timer = setTimeout(() => reject(new Error('MCP 初始化超时')), entry.spec.policy.startupTimeoutMs)
+      timer.unref?.()
+    })
+    try {
+      await Promise.race([work, deadline])
+      if (!entry.live) throw new Error('MCP 启动已取消')
+      entry.phase = 'ready'
+      entry.finishedAt = Date.now()
+      entry.connectedAt = entry.finishedAt
+    } catch (error) {
+      entry.error = 'MCP 初始化失败或超时，请查看 Host 日志'
+      this.ctx.logger?.warn?.('MCP initialization failed: ' + String(error))
+      // Invalidation precedes disposal; neither late module load nor callbacks may publish.
+      entry.live = false
+      entry.phase = 'stopping'
+      const closing = this.closeBridge(entry)
+      await Promise.allSettled([closing, work])
+      entry.phase = 'error'
+      entry.finishedAt = Date.now()
+      entry.retryAt = Date.now() + 5000
+      // Failed generations stay invalid; acquire can replace them only after confirmed closure and cooldown.
+      throw new Error(entry.error)
+    } finally {
+      if (timer) clearTimeout(timer)
+    }
+  }
+
+  /** @private @author ddj 2026年10月20号 @param entry Owned generation. @returns Official initial sync; never publishes after invalidation. */
+  private async mount(entry: PoolEntry): Promise<void> {
+    const official = await this.load()
+    if (!entry.live || this.stopped) return
+    const bridge = await this.make()
+    if (!entry.live || this.stopped) { await bridge.dispose(); return }
+    entry.bridge = bridge
+    entry.phase = 'starting'
+    entry.phaseAt = Date.now()
+    entry.fiber = bridge.scope.ctx.plugin(official, entry.spec.config)
+    await entry.fiber
+    if (entry.fiber?.state !== undefined && entry.fiber.state !== 2) throw new Error('MCP 插件未完成激活')
+  }
+
+  /** @private @author ddj 2026年10月20号 @param entry Connection to close. @returns Shared closure barrier; rejection retains a fenced entry. */
+  private async closeBridge(entry: PoolEntry): Promise<void> {
+    if (entry.close) return entry.close
+    const close = entry.bridge?.dispose() ?? Promise.resolve()
+    entry.close = close
+    try {
+      await close
+      entry.bridge = undefined
+      entry.fiber = undefined
+      entry.close = undefined
+    } catch (error) {
+      entry.error = 'MCP 释放未确认，禁止重建，请查看 Host 日志'
+      this.ctx.logger?.warn?.('MCP cleanup failed: ' + String(error))
+      throw error
+    }
+  }
+
+  /** @private @author ddj 2026年10月20号 @param entry One lease's owner. Arms workspace-only warm retention. */
+  private release(entry: PoolEntry): void {
+    entry.refs = Math.max(0, entry.refs - 1)
+    if (entry.refs || !entry.live) return
+    if (entry.spec.policy.sharing === 'agent') { void this.retire(entry).catch(() => undefined); return }
+    entry.idle = setTimeout(() => { void this.retire(entry).catch(() => undefined) }, 60000)
+    entry.idle.unref?.()
+  }
+
+  /** @public @author ddj 2026年10月20号 @param entry Invalid generation. @returns Quiescent close; callers may await before starting a replacement. */
+  async retire(entry: PoolEntry): Promise<void> {
+    entry.live = false
+    entry.phase = 'stopping'
+    if (entry.idle) clearTimeout(entry.idle)
+    await this.closeBridge(entry)
+    await entry.ready.catch(() => undefined)
+    // A late mount checks live before assigning its bridge.
+    await entry.calls.catch(() => undefined)
+    if (this.entries.get(entry.key) === entry) this.entries.delete(entry.key)
+  }
+
+  /** @public @author ddj 2026年10月20号 @param entry Authorized connection. @param action Per-call work retaining original execution identity. @param signal Caller cancellation. @returns Serialized shared result; no direct registry bypass is introduced here. */
+  run<T>(entry: PoolEntry, action: () => Promise<T>, signal?: AbortSignal): Promise<T> {
+    /** @author ddj 2026年10月20号 Checks cancellation and generation again at actual dispatch. */
+    const invoke = async (): Promise<T> => {
+      await waitMcp(entry.ready, signal)
+      if (signal?.aborted || !entry.live || entry.phase !== 'ready') throw new Error('MCP 连接不可用或调用已取消')
+      return action()
+    }
+    const result = entry.calls.then(invoke)
+    entry.calls = result.catch(() => undefined)
+    return result
+  }
+
+  /** @public @author ddj 2026年10月20号 @returns Full disposal of entries, queue, timers and owned work. */
+  async dispose(): Promise<void> {
+    this.stopped = true
+    await Promise.all([...this.entries.values()].map((entry) => this.retire(entry)))
+    await Promise.all([...this.jobs])
+  }
+}

package/src/mcpProject.ts

@@ -5,7 +5,7 @@ import { PROJECT_ENTRY_PREFIX, entriesOf, mergeMcp, validateConfig, nameOverlap,
 import { isProjectEntryId } from './compat.js'
 import { clearLegacy, runtimeOf } from './mcpRuntime.js'
 import type { ProjectDef } from './mcpRuntime.js'
-import type { MpcConfig, MpcProject, MpcServer } from './shared/mcp.js'
+import { parseMcpPolicy, type McpPolicy, type MpcConfig, type MpcProject, type MpcServer } from './shared/mcp.js'
 import type { Ctx } from './store.js'
 
 const FILE_NAME = '.mcp.json'
@@ -192,19 +192,20 @@ export async function checkMcpName(ctx: Ctx, serverName: string, workspacePath?:
  * @param ctx Host services.
  * @param workspacePath Registered workspace.
  * @param refresh Optional unchanged server to reconnect.
- * @returns Completion after scoped fibers match the file, including disabled flags.
+ * @param wait Await connection synchronization for management, or only publication/scheduling for creation.
+ * @returns Configuration publication, optionally including scoped fiber synchronization.
  */
-export async function reconcileProject(ctx: Ctx, workspacePath: string, refresh?: string): Promise<void> {
+export async function reconcileProject(ctx: Ctx, workspacePath: string, refresh?: string, wait = true): Promise<void> {
   const data = await readProjectJson(ctx, workspacePath)
   const defs = new Map<string, ProjectDef>()
   for (const [name, def] of Object.entries(serversOf(data))) {
     const config = configFromDef(def, name)!
     validateConfig(config)
     await checkMcpName(ctx, name, workspacePath)
-    defs.set(name, { config, enabled: def.disabled !== true })
+    defs.set(name, { config, enabled: def.disabled !== true, policy: parseMcpPolicy(def.vscodeMode) })
   }
   await clearLegacy(ctx)
-  await runtimeOf(ctx).replace(workspacePath, defs, refresh)
+  await runtimeOf(ctx).replace(workspacePath, defs, refresh, wait)
 }
 
 /**
@@ -245,7 +246,7 @@ export async function deactivateMcp(ctx: Ctx, entryId: string): Promise<void> {
  * @param title Workspace title.
  * @returns Configuration and honest runtime status with any read error attached.
  */
-async function projectOf(ctx: Ctx, workspacePath: string, title: string): Promise<MpcProject> {
+async function projectOf(ctx: Ctx, workspacePath: string, title: string, wait = true): Promise<MpcProject> {
   let fileError: string | undefined
   let missingDir: boolean | undefined
   try {
@@ -253,7 +254,7 @@ async function projectOf(ctx: Ctx, workspacePath: string, title: string): Promis
     if (!fs) throw new Error('缺少 fs 服务')
     const info = await fs.stat(await fs.resolve(workspacePath))
     missingDir = !info || info.type !== 'directory'
-    if (!missingDir) await reconcileProject(ctx, workspacePath)
+    if (!missingDir) await reconcileProject(ctx, workspacePath, undefined, wait)
   } catch (error) {
     missingDir = isMissingFile(error) || undefined
     fileError = String(error)
@@ -271,9 +272,9 @@ async function projectOf(ctx: Ctx, workspacePath: string, title: string): Promis
  * @param ctx Host services.
  * @returns Project list; individual malformed files are reported on their project.
  */
-export async function listProjects(ctx: Ctx): Promise<{ projects: MpcProject[] }> {
+export async function listProjects(ctx: Ctx, wait = true): Promise<{ projects: MpcProject[] }> {
   const projects: MpcProject[] = []
-  for (const ws of ctx.get('workspaceRegistry')?.list?.() ?? []) projects.push(await projectOf(ctx, ws.path, ws.title ?? ''))
+  for (const ws of ctx.get('workspaceRegistry')?.list?.() ?? []) projects.push(await projectOf(ctx, ws.path, ws.title ?? '', wait))
   return { projects }
 }
 
@@ -316,18 +317,20 @@ function mergeDefinition(previous: Record<string, unknown>, config: MpcConfig):
  * @param config Submitted configuration.
  * @returns Updated project view; invalid sources or conflicts reject before writing.
  */
-export async function projectSave(ctx: Ctx, workspacePath: string, serverName: string, config: MpcConfig): Promise<MpcProject> {
-  return mcpEdit(ctx, () => saveProject(ctx, workspacePath, serverName, config))
+export async function projectSave(ctx: Ctx, workspacePath: string, serverName: string, config: MpcConfig, policy?: McpPolicy): Promise<MpcProject> {
+  if (policy !== undefined) parseMcpPolicy(policy)
+  return mcpEdit(ctx, () => saveProject(ctx, workspacePath, serverName, config, policy))
 }
 
 /** @private @author ddj 2026年10月08号 @param ctx Host services. @param workspacePath Owner. @param serverName Namespace. @param config Editable fields. @returns Persisted project status. */
-async function saveProject(ctx: Ctx, workspacePath: string, serverName: string, config: MpcConfig): Promise<MpcProject> {
+async function saveProject(ctx: Ctx, workspacePath: string, serverName: string, config: MpcConfig, policy?: McpPolicy): Promise<MpcProject> {
   const workspace = requireWorkspace(ctx, workspacePath)
   validateConfig({ ...config, serverName })
   await checkMcpName(ctx, serverName, workspacePath)
   const data = await readProjectJson(ctx, workspacePath)
   const servers = serversOf(data)
   servers[serverName] = mergeDefinition(servers[serverName] ?? {}, { ...config, serverName })
+  if (policy !== undefined) servers[serverName].vscodeMode = { ...parseMcpPolicy(policy) }
   await writeProjectJson(ctx, workspacePath, { ...data, mcpServers: servers })
   await reconcileProject(ctx, workspacePath)
   return projectOf(ctx, workspacePath, workspace.title ?? '')