dsh-plugin-capabilities 0.3.7 → 0.3.9

package/src/client/locales.ts

@@ -68,9 +68,20 @@ export const zh = {
   confirmRemoveRoot: '确认移除该仓库？',
   removeRootWarn: '将取消扫描该仓库并删除下载到 DSH_HOME 的副本（本地目录本身不受影响）。',
   mcpTitle: 'MCP 服务器',
-  mcpIntro: '管理 profile 中的 MCP 服务器行（@deepseek-ai/dsh-mcp-client）。新增、修改或删除后需要重启 dsh 才生效。',
+  mcpIntro: '管理 MCP 服务器行（@deepseek-ai/dsh-mcp-client）。服务器可放在 profile 层（仅本 profile）或全局层（DSH_HOME/cordis.patch.yml，对本机所有 profile 生效）；新增、修改或删除后需要重启 dsh 才生效。',
   addServer: '添加服务器',
   editServer: '编辑服务器',
+  scopeLabel: '生效范围',
+  scopeGlobal: '全局',
+  scopeProfile: '当前 profile',
+  scopeHint: '全局：写入 DSH_HOME/cordis.patch.yml，对本机所有 profile 生效；当前 profile：只影响本 profile。',
+  shadowedByGlobal: '全局层存在同名 id，此行不生效',
+  globalLayerError: '全局配置（DSH_HOME/cordis.patch.yml）读取失败，全局服务器暂未显示：',
+  checkLabel: '检查',
+  checkRunning: '检查中…',
+  checkOk: '检查通过',
+  checkFail: '检查未通过',
+  copyToOther: '复制到另一层',
   serverName: '服务器名（工具名前缀）',
   transport: '传输方式',
   transportStdio: 'stdio（本地命令）',
@@ -84,10 +95,10 @@ export const zh = {
   enabled: '启用中',
   toggle: '停用/启用',
   confirmRemove: '确认移除该服务器？',
-  removeWarn: '将从 profile 配置中移除这一行，重启 dsh 后其工具不再出现。',
+  removeWarn: '将从配置中移除这一行，重启 dsh 后其工具不再出现。',
   emptyMcp: '还没有配置 MCP 服务器',
   importServers: '从其他 Agent 导入',
-  importIntro: '扫描 Claude Code（~/.claude.json）与 Codex（~/.codex/config.toml）的 MCP 服务器配置，勾选后导入为本 profile 的服务器行。',
+  importIntro: '扫描 Claude Code（~/.claude.json）、Codex（~/.codex/config.toml）、Cursor（~/.cursor/mcp.json）与 Gemini CLI（~/.gemini/settings.json）的 MCP 服务器配置，勾选后导入到所选范围。',
   importEmpty: '没有发现可导入的 MCP 服务器',
   importSelectAll: '全选',
   importExisting: '已存在',
@@ -113,7 +124,7 @@ export const zh = {
   marketSkills: '技能市场',
   marketMcp: 'MCP 市场',
   marketSkillsIntro: '安装技能仓库（GitHub 下载解包，实时进入扫描目录）；已安装的仓库可在「技能」页管理。',
-  marketMcpIntro: '添加 MCP 服务器行（与「MCP」页同一存储，添加后需重启生效）；需要密钥的服务在安装后于列表中补填环境变量。',
+  marketMcpIntro: '添加 MCP 服务器行（上方可选写入当前 profile 还是全局层，添加后需重启生效）；需要密钥的服务在安装后于列表中补填环境变量。',
   marketEmpty: '市场列表为空或不可用',
   marketOffline: '在线索引不可达，当前展示包内快照（可能与最新列表有差异）。',
   marketSkillCount: '{n} 个技能',
@@ -201,9 +212,20 @@ export const en = {
   confirmRemoveRoot: 'Remove this repository?',
   removeRootWarn: 'Stops scanning the repository and deletes the copy downloaded into DSH_HOME (a local folder itself is untouched).',
   mcpTitle: 'MCP servers',
-  mcpIntro: 'Manage the MCP server rows (@deepseek-ai/dsh-mcp-client) in this profile. Additions, edits, and removals take effect after a dsh restart.',
+  mcpIntro: 'Manage MCP server rows (@deepseek-ai/dsh-mcp-client). A server lives either in this profile or in the global layer (DSH_HOME/cordis.patch.yml, applied to every profile on this machine); additions, edits, and removals take effect after a dsh restart.',
   addServer: 'Add server',
   editServer: 'Edit server',
+  scopeLabel: 'Scope',
+  scopeGlobal: 'Global',
+  scopeProfile: 'This profile',
+  scopeHint: 'Global writes DSH_HOME/cordis.patch.yml and applies to every profile on this machine; this profile writes the current profile only.',
+  shadowedByGlobal: 'a global row with the same id wins — this row has no effect',
+  globalLayerError: 'Failed to read the global layer (DSH_HOME/cordis.patch.yml); global servers are hidden:',
+  checkLabel: 'Check',
+  checkRunning: 'Checking…',
+  checkOk: 'OK',
+  checkFail: 'Failed',
+  copyToOther: 'Copy to other layer',
   serverName: 'Server name (tool name prefix)',
   transport: 'Transport',
   transportStdio: 'stdio (local command)',
@@ -217,10 +239,10 @@ export const en = {
   enabled: 'Enabled',
   toggle: 'Enable/disable',
   confirmRemove: 'Remove this server?',
-  removeWarn: 'Removes the row from the profile configuration; its tools disappear after the next dsh restart.',
+  removeWarn: 'Removes the row from its configuration; its tools disappear after the next dsh restart.',
   emptyMcp: 'No MCP servers configured yet',
   importServers: 'Import from other agents',
-  importIntro: 'Scans Claude Code (~/.claude.json) and Codex (~/.codex/config.toml) MCP server configs; selected entries become server rows in this profile.',
+  importIntro: 'Scans the MCP server configs of Claude Code (~/.claude.json), Codex (~/.codex/config.toml), Cursor (~/.cursor/mcp.json), and Gemini CLI (~/.gemini/settings.json); selected entries land in the scope picked below.',
   importEmpty: 'No importable MCP servers found',
   importSelectAll: 'Select all',
   importExisting: 'already here',
@@ -246,7 +268,7 @@ export const en = {
   marketSkills: 'Skills market',
   marketMcp: 'MCP market',
   marketSkillsIntro: 'Installs skill repositories (GitHub download, live catalog); manage installed ones on the Skills tab.',
-  marketMcpIntro: 'Adds MCP server rows (same storage as the MCP tab; restart to apply). Servers needing keys get their environment filled in on the row after install.',
+  marketMcpIntro: 'Adds MCP server rows (pick the target layer — this profile or global — above; restart to apply). Servers needing keys get their environment filled in on the row after install.',
   marketEmpty: 'Market list is empty or unavailable',
   marketOffline: 'Online index unreachable — showing the bundled snapshot, which may lag behind.',
   marketSkillCount: '{n} skills',

package/src/index.ts

@@ -11,7 +11,7 @@ import { existsSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { agentSkillRoots } from './agents.ts'
-import { argvProfile, profileDir } from './profile.ts'
+import { argvProfile, dshHomeDir, profileDir } from './profile.ts'
 import { mountCapabilitiesRoutes } from './routes.ts'
 import { loadState } from './state.ts'
 import type { CapabilitiesHost } from './types.ts'
@@ -102,6 +102,7 @@ export function apply(ctx: Context, config?: Config): void {
       ctx.effect(
         () => mountCapabilitiesRoutes(hostCtx as unknown as CapabilitiesHost, {
           profileDirPath: profileDir(profile),
+          dshHomePath: dshHomeDir(),
           remountProvider,
         }),
         'dsh-plugin-capabilities: http routes',

package/src/mcp.test.ts

@@ -2,11 +2,15 @@ import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'nod
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { afterAll, describe, expect, it } from 'vitest'
-import { listMcp, removeMcp, setMcpDisabled, upsertMcp, validateMcpInput, type McpInput } from './mcp.ts'
+import { checkMcpRow, listMcp, listMcpScoped, mcpRowToInput, mcpScopeDir, removeMcp, resolveCommandOnPath, setMcpDisabled, upsertMcp, validateMcpInput, type McpInput } from './mcp.ts'
 
 const root = mkdtempSync(join(tmpdir(), 'dsh-caps-mcp-'))
 const profile = join(root, 'profiles', 'web')
-afterAll(() => rmSync(root, { recursive: true, force: true }))
+const home = join(root, 'home')
+afterAll(() => {
+  rmSync(root, { recursive: true, force: true })
+  rmSync('dsh-caps-path-bin', { recursive: true, force: true })
+})
 
 const patch = () => join(profile, 'cordis.patch.yml')
 
@@ -149,3 +153,132 @@ describe('corrupt patch file', () => {
     expect(readFileSync(join(brokenDir, 'cordis.patch.yml'), 'utf8')).toBe(before)
   })
 })
+
+describe('global patch layer (GitHub issue #2)', () => {
+  const cleanHome = (): void => rmSync(join(home, 'cordis.patch.yml'), { force: true })
+
+  it('merges both layers, global first, and flags shadowed profile rows', () => {
+    cleanHome()
+    mkdirSync(home, { recursive: true })
+    writeFileSync(join(home, 'cordis.patch.yml'), [
+      '- insert:',
+      '    - id: mcp-shared-tools',
+      "      name: '@deepseek-ai/dsh-mcp-client'",
+      '      config:',
+      '        serverName: shared-tools',
+      '        transport: stdio',
+      '        command: node',
+      '        args:',
+      '          - global.js',
+      '',
+    ].join('\n'), 'utf8')
+
+    upsertMcp(profile, { ...stdio, serverName: 'github' })
+    // Same id as the global row: the home layer composes after the profile
+    // layer, so this profile row never takes effect.
+    upsertMcp(profile, { ...stdio, serverName: 'shared', id: 'mcp-shared-tools' })
+
+    const { servers, globalError } = listMcpScoped(profile, home)
+    expect(globalError).toBeUndefined()
+    expect(servers.map(row => `${row.scope}/${row.id}`)).toEqual(['global/mcp-shared-tools', 'profile/mcp-github', 'profile/mcp-shared-tools'])
+    expect(servers[0]).toMatchObject({ serverName: 'shared-tools', args: ['global.js'] })
+    expect(servers[2].shadowed).toBe(true)
+    expect(servers[1].shadowed).toBeUndefined()
+
+    cleanHome()
+    expect(listMcpScoped(profile, home).servers.every(row => row.scope === 'profile')).toBe(true)
+  })
+
+  it('degrades a broken global file to globalError and still lists profile rows', () => {
+    mkdirSync(home, { recursive: true })
+    writeFileSync(join(home, 'cordis.patch.yml'), 'foo: 1\n  bar: 2\n', 'utf8')
+    const { servers, globalError } = listMcpScoped(profile, home)
+    expect(globalError).toMatch(/cordis\.patch\.yml/)
+    expect(globalError).toMatch(/line 1/)
+    expect(servers.length).toBeGreaterThan(0)
+    expect(servers.every(row => row.scope === 'profile')).toBe(true)
+    cleanHome()
+  })
+
+  it('writes, toggles, and removes through the global scope dir', () => {
+    cleanHome()
+    const globalDir = mcpScopeDir('global', profile, home)
+    expect(globalDir).toBe(home)
+
+    const id = upsertMcp(globalDir, { ...stdio, serverName: 'shared-tools' })
+    expect(id).toBe('mcp-shared-tools')
+    // The global layer file (not the profile's) received the row.
+    expect(readFileSync(join(home, 'cordis.patch.yml'), 'utf8')).toContain('shared-tools')
+
+    expect(setMcpDisabled(globalDir, id, true)).toBe(true)
+    expect(listMcp(home)[0].disabled).toBe(true)
+    expect(removeMcp(globalDir, id)).toBe(true)
+    expect(listMcp(home)).toHaveLength(0)
+    expect(listMcp(profile).some(row => row.serverName === 'shared-tools')).toBe(false)
+  })
+})
+
+describe('mcpRowToInput', () => {
+  it('rebuilds a create request carrying identity fields but not the id', () => {
+    const rows = listMcp(profile)
+    const source = rows[0]
+    const input = mcpRowToInput(source)
+    expect(input.id).toBe('')
+    expect(input.serverName).toBe(source.serverName)
+    expect(input.transport).toBe(source.transport)
+    expect(input.command).toBe(source.command)
+    expect(input.args).toEqual(source.args)
+    expect(input.env).toEqual(source.env)
+    expect(validateMcpInput(input)).toBeNull()
+  })
+})
+
+describe('command resolution + connectivity check', () => {
+  it('resolves bare commands across PATH entries, honoring Windows extensions and quotes', () => {
+    const bin = join(root, 'bin')
+    mkdirSync(bin, { recursive: true })
+    writeFileSync(join(bin, 'tool.cmd'), '@echo off\r\n')
+    writeFileSync(join(bin, 'plain'), '#!/bin/sh\n')
+
+    expect(resolveCommandOnPath('tool', `"${bin}"`, 'win32')).toBe(true)
+    expect(resolveCommandOnPath('tool', bin, 'win32')).toBe(true)
+    expect(resolveCommandOnPath('tool', bin, 'linux')).toBe(false)
+    expect(resolveCommandOnPath('plain', bin, 'win32')).toBe(true)
+    expect(resolveCommandOnPath('missing-thing', bin, 'win32')).toBe(false)
+    expect(resolveCommandOnPath('missing-thing', `${bin};`, 'win32')).toBe(false)
+    expect(resolveCommandOnPath(join(bin, 'tool.cmd'), '', 'win32')).toBe(true)
+    expect(resolveCommandOnPath(join(bin, 'nope'), '', 'win32')).toBe(false)
+
+    // The POSIX branch splits on ':'; a Windows temp path carries a drive
+    // letter, so exercise it through a colon-free relative entry instead.
+    mkdirSync('dsh-caps-path-bin', { recursive: true })
+    writeFileSync(join('dsh-caps-path-bin', 'plain'), '#!/bin/sh\n')
+    expect(resolveCommandOnPath('plain', 'dsh-caps-path-bin:/elsewhere', 'linux')).toBe(true)
+    expect(resolveCommandOnPath('tool', 'dsh-caps-path-bin:/elsewhere', 'linux')).toBe(false)
+  })
+
+  it('checks stdio rows against PATH without spawning anything', async () => {
+    const base = { id: 'mcp-x', serverName: 'x', disabled: false, scope: 'profile' as const }
+    const missing = await checkMcpRow({ ...base, transport: 'stdio', command: 'definitely-not-a-real-cmd-xyz' }, { pathEnv: '' })
+    expect(missing.ok).toBe(false)
+    expect(missing.detail).toContain('not found on PATH')
+
+    const bin = join(root, 'bin')
+    const found = await checkMcpRow({ ...base, transport: 'stdio', command: 'tool' }, { pathEnv: bin, platform: 'win32' })
+    expect(found.ok).toBe(true)
+
+    const empty = await checkMcpRow({ ...base, transport: 'stdio' }, {})
+    expect(empty.ok).toBe(false)
+  })
+
+  it('checks http rows with a bounded GET; refusal reads as unreachable', async () => {
+    const base = { id: 'mcp-y', serverName: 'y', disabled: false, scope: 'profile' as const }
+    // Port 1 has no listener: the connect fails fast (ECONNREFUSED), which is
+    // exactly the signal the check exists to surface.
+    const refused = await checkMcpRow({ ...base, transport: 'streamable-http', url: 'http://127.0.0.1:1/mcp' }, { timeoutMs: 1500 })
+    expect(refused.ok).toBe(false)
+
+    const broken = await checkMcpRow({ ...base, transport: 'streamable-http' }, {})
+    expect(broken.ok).toBe(false)
+  }, 10_000)
+})

package/src/mcp.ts

@@ -10,6 +10,12 @@
  * list. Managed rows therefore always sit inside one insert entry, and any
  * legacy bare rows (written before this contract was understood) are
  * absorbed into it on the next write.
+ *
+ * Rows live in one of two patch layers: the profile's own
+ * `cordis.patch.yml`, or the machine-wide `$DSH_HOME/cordis.patch.yml`
+ * (dsh composes it over every profile, after the profile layer — a home row
+ * with the same id wins). The primitives below address one layer via the
+ * directory holding its `cordis.patch.yml`; `listMcpScoped` merges both.
  */
 
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
@@ -24,6 +30,9 @@ export const SERVER_NAME_RE = /^[A-Za-z0-9_-]{1,32}$/
 /** Transport choices the client supports. */
 export type McpTransport = 'stdio' | 'streamable-http'
 
+/** Which patch layer a row lives in. */
+export type McpScope = 'global' | 'profile'
+
 /** One managed row, as shown to the browser. */
 export interface McpRow {
   id: string
@@ -38,6 +47,20 @@ export interface McpRow {
   headers?: Record<string, string>
 }
 
+/** One row tagged with its layer. */
+export interface McpRowView extends McpRow {
+  scope: McpScope
+  /** Profile rows only: a global row with the same id composes after this one and wins. */
+  shadowed?: boolean
+}
+
+/** Merged listing across both patch layers. */
+export interface McpListResult {
+  servers: McpRowView[]
+  /** The home layer exists but could not be read; its rows are not shown. */
+  globalError?: string
+}
+
 /** Write request for one server row (id empty = create). */
 export type McpInput = Omit<McpRow, 'disabled'> & { disabled?: boolean }
 
@@ -58,9 +81,9 @@ function assertPatchParses(path: string, doc: Document): void {
   )
 }
 
-/** Load the profile patch as a YAML document; `[]` for a missing file. */
-function loadPatch(profileDirPath: string): Document {
-  const path = join(profileDirPath, 'cordis.patch.yml')
+/** Load one layer's patch (`<dirPath>/cordis.patch.yml`) as a YAML document; `[]` for a missing file. */
+function loadPatch(dirPath: string): Document {
+  const path = join(dirPath, 'cordis.patch.yml')
   const text = existsSync(path) ? readFileSync(path, 'utf8') : '[]'
   const doc = parseDocument(text)
   assertPatchParses(path, doc)
@@ -71,9 +94,9 @@ function loadPatch(profileDirPath: string): Document {
   return doc
 }
 
-function savePatch(profileDirPath: string, doc: Document): void {
-  mkdirSync(profileDirPath, { recursive: true })
-  writeFileSync(join(profileDirPath, 'cordis.patch.yml'), String(doc), 'utf8')
+function savePatch(dirPath: string, doc: Document): void {
+  mkdirSync(dirPath, { recursive: true })
+  writeFileSync(join(dirPath, 'cordis.patch.yml'), String(doc), 'utf8')
 }
 
 /** Wrap a plain value into a YAML node (yaml v2 exposes no standalone createNode). */
@@ -183,12 +206,49 @@ function takenIds(doc: Document): Set<string> {
   return taken
 }
 
-/** Read every mcp-client row in the profile layer. */
-export function listMcp(profileDirPath: string): McpRow[] {
-  const doc = loadPatch(profileDirPath)
+/** Read every mcp-client row in one patch layer (`<dirPath>/cordis.patch.yml`). */
+export function listMcp(dirPath: string): McpRow[] {
+  const doc = loadPatch(dirPath)
   return mcpRowItems(doc).map(({ node }) => rowToMcp(doc, node))
 }
 
+/**
+ * Merge both patch layers for the browser: global rows first (dsh composes
+ * them after the profile layer, so they win), profile rows tagged `shadowed`
+ * when a global row claims the same id. A broken home layer must not take
+ * the whole page down — its read failure degrades to `globalError` and the
+ * profile layer still lists (the assertPatchParses message names the file
+ * and the parser location, which is what the banner shows).
+ */
+export function listMcpScoped(profileDirPath: string, dshHomePath: string): McpListResult {
+  let globalRows: McpRow[] = []
+  let globalError: string | undefined
+  if (existsSync(join(dshHomePath, 'cordis.patch.yml'))) {
+    try {
+      globalRows = listMcp(dshHomePath)
+    } catch (error) {
+      globalError = error instanceof Error ? error.message : String(error)
+    }
+  }
+  const globalIds = new Set(globalRows.map(row => row.id).filter(id => id !== ''))
+  return {
+    servers: [
+      ...globalRows.map((row): McpRowView => ({ ...row, scope: 'global' })),
+      ...listMcp(profileDirPath).map((row): McpRowView => ({
+        ...row,
+        scope: 'profile',
+        ...(globalIds.has(row.id) ? { shadowed: true } : {}),
+      })),
+    ],
+    ...(globalError !== undefined ? { globalError } : {}),
+  }
+}
+
+/** Resolve a write target: the layer's directory holding its cordis.patch.yml. */
+export function mcpScopeDir(scope: McpScope, profileDirPath: string, dshHomePath: string): string {
+  return scope === 'global' ? dshHomePath : profileDirPath
+}
+
 /** Validate one write request; returns the rejection reason or null. */
 export function validateMcpInput(input: McpInput): string | null {
   if (!SERVER_NAME_RE.test(input.serverName)) return 'serverName must be 1-32 chars of A-Z a-z 0-9 _ -'
@@ -204,9 +264,9 @@ export function validateMcpInput(input: McpInput): string | null {
 }
 
 /** Add or replace one server row. Returns the (possibly deduplicated) id. */
-export function upsertMcp(profileDirPath: string, input: McpInput): string {
+export function upsertMcp(dirPath: string, input: McpInput): string {
   const inputId = input.id ?? ''
-  const doc = loadPatch(profileDirPath)
+  const doc = loadPatch(dirPath)
   const list = managedInsert(doc)
 
   const existing = inputId !== ''
@@ -248,25 +308,25 @@ export function upsertMcp(profileDirPath: string, input: McpInput): string {
     rowSeq(doc).items.splice(rowSeq(doc).items.indexOf(existing.node), 1, node)
   }
 
-  savePatch(profileDirPath, doc)
+  savePatch(dirPath, doc)
   return id
 }
 
 /** Flip one row's disabled flag (absent = enabled). Returns false when missing. */
-export function setMcpDisabled(profileDirPath: string, id: string, disabled: boolean): boolean {
-  const doc = loadPatch(profileDirPath)
+export function setMcpDisabled(dirPath: string, id: string, disabled: boolean): boolean {
+  const doc = loadPatch(dirPath)
   managedInsert(doc)
   const hit = mcpRowItems(doc).find(({ node }) => String(node.get('id') ?? '') === id)
   if (hit === undefined) return false
   if (disabled) hit.node.set('disabled', true)
   else hit.node.delete('disabled')
-  savePatch(profileDirPath, doc)
+  savePatch(dirPath, doc)
   return true
 }
 
 /** Remove one server row. Returns false when missing. */
-export function removeMcp(profileDirPath: string, id: string): boolean {
-  const doc = loadPatch(profileDirPath)
+export function removeMcp(dirPath: string, id: string): boolean {
+  const doc = loadPatch(dirPath)
   managedInsert(doc)
   const hit = mcpRowItems(doc).find(({ node }) => String(node.get('id') ?? '') === id)
   if (hit === undefined || hit.list === undefined) return false
@@ -280,6 +340,84 @@ export function removeMcp(profileDirPath: string, id: string): boolean {
     seq.items.splice(seq.items.indexOf(owner), 1)
   }
 
-  savePatch(profileDirPath, doc)
+  savePatch(dirPath, doc)
   return true
 }
+
+/** Rebuild a create request from an existing row (id emptied; identity fields
+ *  carried over) — used to copy a row into the other patch layer. */
+export function mcpRowToInput(row: McpRow): McpInput {
+  return {
+    id: '',
+    serverName: row.serverName,
+    transport: row.transport,
+    disabled: row.disabled,
+    ...(row.transport === 'stdio'
+      ? {
+          command: row.command,
+          ...(row.args !== undefined ? { args: row.args } : {}),
+          ...(row.env !== undefined ? { env: row.env } : {}),
+          ...(row.cwd !== undefined ? { cwd: row.cwd } : {}),
+        }
+      : {
+          url: row.url,
+          ...(row.headers !== undefined ? { headers: row.headers } : {}),
+        }),
+  }
+}
+
+/**
+ * Whether a stdio command would resolve at spawn time: a bare name is looked
+ * up in the PATH entries (with the Windows executable extensions), anything
+ * with a path separator must exist as given. Pure filesystem reads — no
+ * process is spawned, so no console-window or side-effect concerns.
+ */
+export function resolveCommandOnPath(command: string, pathEnv: string, platform: string = process.platform): boolean {
+  if (command.includes('/') || command.includes('\\')) return existsSync(command)
+  const exts = platform === 'win32' ? ['', '.com', '.exe', '.bat', '.cmd'] : ['']
+  const separator = platform === 'win32' ? ';' : ':'
+  for (const rawDir of pathEnv.split(separator)) {
+    const dir = rawDir.trim().replace(/^"|"$/g, '')
+    if (dir === '') continue
+    for (const ext of exts) {
+      if (existsSync(join(dir, command + ext))) return true
+    }
+  }
+  return false
+}
+
+/** Outcome of a connectivity check, as the browser renders it. */
+export interface McpCheckResult {
+  ok: boolean
+  /** Short technical detail for the hint line ("HTTP 200", "not found on PATH"). */
+  detail?: string
+}
+
+/**
+ * Probe one server row without starting it: stdio rows are validated against
+ * the PATH (a spawn would leave console windows and side effects behind),
+ * streamable-http rows get a short GET — any HTTP status proves reachability,
+ * since MCP endpoints legitimately answer 405 to plain GETs.
+ */
+export async function checkMcpRow(row: McpRow, options: { timeoutMs?: number; pathEnv?: string; platform?: string } = {}): Promise<McpCheckResult> {
+  const pathEnv = options.pathEnv ?? process.env.PATH ?? ''
+  if (row.transport === 'stdio') {
+    const command = row.command ?? ''
+    if (command === '') return { ok: false, detail: 'row has no command' }
+    return resolveCommandOnPath(command, pathEnv, options.platform)
+      ? { ok: true, detail: command }
+      : { ok: false, detail: `${command} not found on PATH` }
+  }
+  if (row.url === undefined || !/^https?:\/\//.test(row.url)) return { ok: false, detail: 'row has no http url' }
+  try {
+    const response = await fetch(row.url, {
+      headers: { accept: 'application/json, text/event-stream' },
+      signal: AbortSignal.timeout(options.timeoutMs ?? 5000),
+    })
+    return { ok: true, detail: `HTTP ${response.status}` }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    const cause = (error as { cause?: { code?: unknown } }).cause?.code
+    return { ok: false, detail: cause !== undefined ? String(cause) : message }
+  }
+}

package/src/profile.ts

@@ -10,8 +10,12 @@ export function argvProfile(argv: readonly string[] = process.argv): string | un
   return undefined
 }
 
+/** The dsh home directory itself: `$DSH_HOME`, default `~/.dsh`. */
+export function dshHomeDir(dshHome: string | undefined = process.env.DSH_HOME): string {
+  return dshHome ?? join(homedir(), '.dsh')
+}
+
 /** Directory of a profile under DSH_HOME (default `~/.dsh`). */
 export function profileDir(profile: string, dshHome: string | undefined = process.env.DSH_HOME): string {
-  const home = dshHome ?? join(homedir(), '.dsh')
-  return join(home, 'profiles', profile)
+  return join(dshHomeDir(dshHome), 'profiles', profile)
 }