dsh-armory 1.9.4 → 2.0.0

package/lib/mcp-import-sources.js

@@ -527,6 +527,127 @@ function parseFailure(error, text) {
   return 0
 }
 
+// ---------------------------------------------------------------------------
+// VS Code `${input:...}`：逐条降级，不整份拒绝
+// ---------------------------------------------------------------------------
+
+/**
+ * VS Code 的 `${input:名称}`：值由人在**导入时**填写，DSH 读配置的时候无从知道。
+ * 它是 VS Code 专属写法，出现在别的客户端配置里也代表同一件事。
+ */
+const VSCODE_INPUT = /\$\{input:([^}]*)\}/g
+
+/** 一个字符串里出现的 input 名，按出现顺序去重。 */
+function vscodeInputNames(value) {
+  if (typeof value !== 'string' || !value.includes('${input:')) return []
+  const names = []
+  for (const match of value.matchAll(VSCODE_INPUT)) {
+    const name = match[1].trim()
+    if (name && !names.includes(name)) names.push(name)
+  }
+  return names
+}
+
+/** 报错/提示里统一用 `${input:x}` 原样回显名字（名字本身不是密钥）。 */
+const showInputs = (names) => names.map((name) => `\${input:${name}}`).join('、')
+
+/** 条目会走哪条传输：只用于把不支持项说清楚，不参与归一化判定。 */
+function guessTransport(raw) {
+  if (typeof raw.type === 'string' && raw.type.trim()) return raw.type.trim()
+  if (typeof raw.transport === 'string' && raw.transport.trim()) return raw.transport.trim()
+  if (typeof raw.command === 'string' && raw.command.trim()) return 'stdio'
+  const url = raw.url ?? raw.serverUrl ?? raw.server_url
+  return typeof url === 'string' && url.trim() ? 'streamable-http' : 'unknown'
+}
+
+/**
+ * 把一条 VS Code 条目里的 `${input:...}` 按位置分三类处理：
+ *
+ * - **url / command / cwd**：地址或可执行文件本身就是交互值，剔掉就没得导了，
+ *   所以整条标记为不支持、不进 `entries`。
+ * - **env / headers 的某一项**：先剔掉那一项，剩下的照常导入——少一个环境变量
+ *   会变成一个看得见的启动/鉴权失败，比整条消失更容易被用户理解和补救。
+ * - **args 的某一个元素**：同上，剔掉那个参数。
+ *
+ * 返回 `blocked` 非空表示整条不可用；否则 `raw` 是剔干净后的副本。
+ */
+function splitVscodeInputs(name, raw) {
+  // 顺序固定成 url → command → cwd → args → env → headers：前面出现就整条判死，
+  // 后面即使也用到 input 也一并记进 names，方便用户一次看全。
+  const hard = []
+  for (const field of ['url', 'serverUrl', 'server_url', 'command', 'cwd']) {
+    for (const found of vscodeInputNames(raw[field])) if (!hard.includes(found)) hard.push(found)
+  }
+  if (hard.length) {
+    for (const field of ['args', 'env', 'headers']) {
+      for (const value of field === 'args' && Array.isArray(raw.args) ? raw.args : Object.values(isObject(raw[field]) ? raw[field] : {})) {
+        for (const found of vscodeInputNames(value)) if (!hard.includes(found)) hard.push(found)
+      }
+    }
+    return { blocked: hard, raw: null, warnings: [] }
+  }
+  const warnings = []
+  const soft = []
+  const clean = { ...raw }
+  const args = stripFromArgs(name, raw.args, soft, warnings)
+  if (args === undefined) delete clean.args
+  else clean.args = args
+  for (const field of ['env', 'headers']) {
+    // 不是对象就原样留给下游报错：这里静默删掉会把"env 写错了"变成"没有 env"。
+    if (!isObject(raw[field])) continue
+    const table = stripFromMap(name, field, raw[field], soft, warnings)
+    // 整个字段被剔空时删掉它，别让下游把 `env: {}` 当成"用户写了空表"。
+    if (table === undefined) delete clean[field]
+    else setOwn(clean, field, table)
+  }
+  return { blocked: [], raw: clean, warnings, names: soft }
+}
+
+/**
+ * args 里带 `${input:...}` 的元素剔除。剔除后可能剩一个空数组——那就把字段删掉，
+ * 别让下游把 `args: []` 当成"用户显式写了空参数表"。
+ */
+function stripFromArgs(name, args, soft, warnings) {
+  // `args` 写成单个字符串时下游会原样当成一个参数：它带 input 就同样不可用。
+  if (typeof args === 'string') {
+    const found = vscodeInputNames(args)
+    if (!found.length) return args
+    for (const inputName of found) if (!soft.includes(inputName)) soft.push(inputName)
+    warnings.push(`${name}.args 里的 ${showInputs(found)} 需要交互取值，已跳过这个参数`)
+    return undefined
+  }
+  if (!Array.isArray(args)) return args
+  const kept = []
+  for (const item of args) {
+    const found = vscodeInputNames(item)
+    if (!found.length) {
+      kept.push(item)
+      continue
+    }
+    for (const inputName of found) if (!soft.includes(inputName)) soft.push(inputName)
+    warnings.push(`${name}.args 里的 ${showInputs(found)} 需要交互取值，已跳过这个参数`)
+  }
+  return kept.length || args.length === 0 ? kept : undefined
+}
+
+/** env / headers 里值带 `${input:...}` 的项剔除。整表剔空时删掉字段。 */
+function stripFromMap(name, field, table, soft, warnings) {
+  if (!isObject(table)) return undefined
+  const kept = {}
+  let dropped = 0
+  for (const [key, value] of Object.entries(table)) {
+    const found = vscodeInputNames(value)
+    if (!found.length) {
+      setOwn(kept, key, value)
+      continue
+    }
+    dropped += 1
+    for (const inputName of found) if (!soft.includes(inputName)) soft.push(inputName)
+    warnings.push(`${name}.${field}.${key} 需要交互取值（${showInputs(found)}），已跳过`)
+  }
+  return dropped && !Object.keys(kept).length ? undefined : kept
+}
+
 /**
  * 按来源解析文本并归一化成 DSH spec。逐条目容错：一条不支持不影响其余条目。
  * 返回的 `spec` 是 Host 侧内部值（含 `!!js` 表达式与字面密钥），**不得**直接发给浏览器。
@@ -541,33 +662,50 @@ export function normalizeSourceText(source, text, format = 'json') {
     parsed = parseSourceText(format, content)
   } catch (error) {
     const line = parseFailure(error, content)
-    return { entries: [], warnings: [], error: `不是合法 ${PARSE_LABEL[format] || format}${line ? `（第 ${line} 行附近）` : ''}` }
+    return { entries: [], warnings: [], unsupportedEntries: [], error: `不是合法 ${PARSE_LABEL[format] || format}${line ? `（第 ${line} 行附近）` : ''}` }
   }
-  if (!isObject(parsed)) return { entries: [], warnings: [], error: '配置根节点必须是对象' }
-  // VS Code 的 ${input:...} 需要交互取值，normalizeMcpImport 会整份拒绝；
-  // 在取段落之前就给出同样的判断，避免一条输入变量吞掉整份文件。
+  if (!isObject(parsed)) return { entries: [], warnings: [], unsupportedEntries: [], error: '配置根节点必须是对象' }
+  // OPT-17：VS Code 的 `${input:...}` 原本在这里整份拒绝，结果是一条交互变量吞掉
+  // 文件里其余 19 条能用的服务。改成逐条降级：位置可剔的（env/headers/args）剔掉后
+  // 照常导入并在 warnings 里说清楚，位置不可剔的（url/command/cwd）只把那一条记进
+  // unsupportedEntries，`error` 只留给"整份文件读不懂"。
   const warnings = []
-  if (Array.isArray(parsed.inputs) && parsed.inputs.length > 0) {
-    return { entries: [], warnings, error: 'VS Code inputs 需要交互式取值，DSH 当前不支持安全转换' }
-  }
+  const unsupportedEntries = []
+  // 声明了 `inputs` 只说明这份文件"可能"用到交互变量，不再是拒绝理由；真正的判定
+  // 落在每个条目上——没被引用的 inputs 声明不该影响任何导入，也不该冒出一条噪音提示。
   const selected = source.select(parsed, warnings)
-  if (selected === null) return { entries: [], warnings, error: '没有找到该客户端使用的 MCP 段落' }
+  if (selected === null) return { entries: [], warnings, unsupportedEntries, error: '没有找到该客户端使用的 MCP 段落' }
   const entries = []
   for (const item of selected) {
     const carried = item.warnings || []
     if (item.error) {
-      entries.push({ name: item.name, spec: null, error: item.error, warnings: carried })
+      entries.push({ name: item.name, spec: null, error: item.error, warnings: carried, unsupported: null })
+      continue
+    }
+    const split = splitVscodeInputs(item.name, item.raw)
+    const merged = [...carried, ...split.warnings]
+    // url / command / cwd 本身是交互值：这条没法安全转换。不进 `entries`（下游只认
+    // 可导入的 spec），改在 `unsupportedEntries` 里留一份可展示信息，别让它凭空消失。
+    if (split.blocked.length) {
+      unsupportedEntries.push({
+        name: item.name,
+        transport: guessTransport(item.raw),
+        reason: `地址/命令里用到 ${showInputs(split.blocked)}，需要交互取值，DSH 无法安全转换`,
+        names: split.blocked,
+      })
       continue
     }
     try {
-      const normalized = normalizeMcpImport({ mcpServers: { [item.name]: item.raw } })
-      entries.push({ name: item.name, spec: normalized.servers[0], error: null, warnings: [...carried, ...normalized.warnings] })
+      const normalized = normalizeMcpImport({ mcpServers: { [item.name]: split.raw } })
+      entries.push({ name: item.name, spec: normalized.servers[0], error: null, warnings: [...merged, ...normalized.warnings], unsupported: null })
     } catch (error) {
-      entries.push({ name: item.name, spec: null, error: String(error?.message ?? error), warnings: carried })
+      entries.push({ name: item.name, spec: null, error: String(error?.message ?? error), warnings: merged, unsupported: null })
     }
   }
-  if (!entries.length) return { entries, warnings, error: '这条配置里没有 MCP' }
-  return { entries, warnings, error: '' }
+  // 全部条目都不可用时 `error` 仍然是 null：上层要能说"3 条不支持 / 0 条可导入"，
+  // 而不是一句"失败"。只有真的一条 MCP 都没找到才落到下面的文案。
+  if (!entries.length && !unsupportedEntries.length) return { entries, warnings, unsupportedEntries, error: '这条配置里没有 MCP' }
+  return { entries, warnings, unsupportedEntries, error: '' }
 }
 
 export function hashSourceText(text) {
@@ -640,6 +778,7 @@ async function inspectImportLocation(source, location, ctx, readText) {
     error: '',
     contentHash: '',
     entries: [],
+    unsupportedEntries: [],
     warnings: [],
   }
   const picked = await pickCandidate(location, readText)
@@ -655,6 +794,7 @@ async function inspectImportLocation(source, location, ctx, readText) {
   row.contentHash = hashSourceText(picked.text)
   const normalized = normalizeSourceText(source, picked.text, picked.candidate.format)
   row.entries = normalized.entries
+  row.unsupportedEntries = normalized.unsupportedEntries
   row.warnings = normalized.warnings
   row.error = normalized.error
   return row