dsh-plugin-capabilities 0.1.0

package/src/http.ts

@@ -0,0 +1,42 @@
+/** HTTP helpers: JSON body reading, same-origin check, JSON responses. */
+
+import type { IncomingMessage, ServerResponse } from 'node:http'
+
+/** Read and JSON-parse a request body, bounded to 1 MiB (skill bodies live here). */
+export async function readJsonBody(request: IncomingMessage): Promise<unknown> {
+  const chunks: Buffer[] = []
+  let received = 0
+  for await (const chunk of request) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)
+    received += buffer.length
+    if (received > 1024 * 1024) throw new Error('request body too large')
+    chunks.push(buffer)
+  }
+  return JSON.parse(Buffer.concat(chunks).toString('utf8'))
+}
+
+/**
+ * True when the request is a same-origin POST a browser page could have made.
+ * CSRF fence (the loopback server already trusts its local peer for reads).
+ */
+export function sameOrigin(request: IncomingMessage): boolean {
+  const origin = request.headers.origin
+  const host = request.headers.host
+  if (origin === undefined || host === undefined) return false
+  try {
+    const parsed = new URL(origin)
+    return (parsed.protocol === 'http:' || parsed.protocol === 'https:') && parsed.host === host
+  } catch {
+    return false
+  }
+}
+
+/** Write a JSON response. */
+export function sendJson(response: ServerResponse, status: number, body: unknown): void {
+  const payload = JSON.stringify(body)
+  response.writeHead(status, {
+    'content-type': 'application/json; charset=utf-8',
+    'cache-control': 'no-store',
+  })
+  response.end(payload)
+}

package/src/index.ts

@@ -0,0 +1,56 @@
+/** dsh-plugin-capabilities host entry: mount the manager's HTTP routes once
+ * the profile composes both the web server and the skill registry, and mount
+ * a host-plane filesystem skill provider so the Settings page sees a live
+ * catalog (the web composition deliberately leaves the host row to presets). */
+
+import type { Context } from '@deepseek-ai/cordis'
+import { agentSkillRoots } from './agents.ts'
+import { argvProfile, profileDir } from './profile.ts'
+import { mountCapabilitiesRoutes } from './routes.ts'
+import type { CapabilitiesHost } from './types.ts'
+
+export const name = 'dsh-plugin-capabilities'
+
+/** Optional cordis.yml configuration; profile defaults to the booted one. */
+export interface Config {
+  /** Profile whose patch layer holds the MCP rows; defaults to argv or `web`. */
+  profile?: string
+}
+
+export const inject = ['webServer', 'skills']
+
+/** The provider plugin's structural shape (name/apply export). */
+interface FilesystemSkillPlugin {
+  name: string
+  apply(context: Context, config?: unknown): void
+}
+
+export function apply(ctx: Context, config?: Config): void {
+  const profile = config?.profile ?? argvProfile() ?? 'web'
+  ctx.inject(['webServer', 'skills'], (hostCtx: Context) => {
+    // The web bundle disables the host-plane `skill-filesystem` row on
+    // purpose (presets own per-session discovery). The Settings manager
+    // mounts its own host-plane provider as a CHILD of this plugin: it dies
+    // with us, registers into the registry's global layer, and preset layers
+    // keep their semantics (nearest layer still wins duplicate names). Other
+    // agents' skill roots (~/.claude/skills, ~/.codex/skills) join as custom
+    // dirs — zero-copy, live-synced both ways. A failed load only means an
+    // empty catalog — the routes keep serving.
+    void (async () => {
+      try {
+        const mod = (await import('@deepseek-ai/dsh-skill-filesystem')) as unknown as
+          (FilesystemSkillPlugin & { default?: FilesystemSkillPlugin })
+        const plugin = mod.default ?? mod
+        const roots = agentSkillRoots()
+        hostCtx.plugin(plugin, roots.length > 0 ? { customSkillDirs: roots } : {})
+      } catch {
+        // Unresolvable provider: skills list stays empty; MCP tab unaffected.
+      }
+    })()
+
+    ctx.effect(
+      () => mountCapabilitiesRoutes(hostCtx as unknown as CapabilitiesHost, { profileDirPath: profileDir(profile) }),
+      'dsh-plugin-capabilities: http routes',
+    )
+  })
+}

package/src/mcp.test.ts

@@ -0,0 +1,85 @@
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+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'
+
+const root = mkdtempSync(join(tmpdir(), 'dsh-caps-mcp-'))
+const profile = join(root, 'profiles', 'web')
+afterAll(() => rmSync(root, { recursive: true, force: true }))
+
+const patch = () => join(profile, 'cordis.patch.yml')
+
+const stdio: McpInput = {
+  id: '',
+  serverName: 'github',
+  transport: 'stdio',
+  command: 'npx',
+  args: ['-y', '@modelcontextprotocol/server-github'],
+  env: { GITHUB_TOKEN: 'secret' },
+}
+
+describe('validateMcpInput', () => {
+  it('enforces serverName grammar and per-transport requirements', () => {
+    expect(validateMcpInput(stdio)).toBeNull()
+    expect(validateMcpInput({ ...stdio, serverName: 'has space' })).toContain('serverName')
+    expect(validateMcpInput({ ...stdio, command: ' ' })).toContain('command')
+    expect(validateMcpInput({ id: '', serverName: 'web', transport: 'streamable-http' })).toContain('url')
+    expect(validateMcpInput({ id: '', serverName: 'web', transport: 'streamable-http', url: 'ftp://x' })).toContain('url')
+    expect(validateMcpInput({ id: 'a/b', serverName: 'web', transport: 'streamable-http', url: 'http://x' })).toContain('id')
+  })
+})
+
+describe('profile patch CRUD', () => {
+  it('creates rows in a missing file, dedupes ids, and reads them back', () => {
+    const id1 = upsertMcp(profile, stdio)
+    expect(id1).toBe('mcp-github')
+    const id2 = upsertMcp(profile, { ...stdio, env: undefined })
+    expect(id2).toBe('mcp-github-2')
+
+    const rows = listMcp(profile)
+    expect(rows).toHaveLength(2)
+    expect(rows[0]).toMatchObject({ id: 'mcp-github', serverName: 'github', transport: 'stdio', command: 'npx', disabled: false })
+    expect(rows[0].args).toEqual(['-y', '@modelcontextprotocol/server-github'])
+    expect(rows[0].env).toEqual({ GITHUB_TOKEN: 'secret' })
+  })
+
+  it('preserves foreign rows and comments across edits', () => {
+    writeFileSync(patch(), [
+      '# user comment',
+      '- id: something-else',
+      "  name: 'other-plugin'",
+      '  config:',
+      '    a: 1',
+      '',
+    ].join('\n'))
+    upsertMcp(profile, { ...stdio, serverName: 'web', transport: 'streamable-http', url: 'http://localhost:3000/mcp' })
+    const text = readFileSync(patch(), 'utf8')
+    expect(text).toContain('# user comment')
+    expect(text).toContain('something-else')
+    expect(text).toContain('streamable-http')
+    expect(listMcp(profile)).toHaveLength(1)
+    expect(listMcp(profile)[0]).toMatchObject({ transport: 'streamable-http', url: 'http://localhost:3000/mcp' })
+  })
+
+  it('updates an existing row in place when the id matches', () => {
+    upsertMcp(profile, stdio)
+    expect(listMcp(profile)).toHaveLength(2)
+    upsertMcp(profile, { ...stdio, id: 'mcp-github', command: 'pnpm' })
+    const rows = listMcp(profile)
+    expect(rows).toHaveLength(2)
+    expect(rows.find(row => row.id === 'mcp-github')?.command).toBe('pnpm')
+  })
+
+  it('toggles disabled and removes rows', () => {
+    expect(setMcpDisabled(profile, 'mcp-github', true)).toBe(true)
+    expect(listMcp(profile).find(row => row.id === 'mcp-github')?.disabled).toBe(true)
+    expect(setMcpDisabled(profile, 'mcp-github', false)).toBe(true)
+    expect(listMcp(profile).find(row => row.id === 'mcp-github')?.disabled).toBe(false)
+    expect(setMcpDisabled(profile, 'no-such', true)).toBe(false)
+
+    expect(removeMcp(profile, 'mcp-github')).toBe(true)
+    expect(listMcp(profile).find(row => row.id === 'mcp-github')).toBeUndefined()
+    expect(removeMcp(profile, 'mcp-github')).toBe(false)
+  })
+})

package/src/mcp.ts

@@ -0,0 +1,170 @@
+/**
+ * MCP server rows in the profile's own patch layer: one
+ * `@deepseek-ai/dsh-mcp-client` row per server. The YAML document API keeps
+ * foreign rows and comments intact across edits. Row changes need a dsh
+ * restart to compose — callers surface that as a pending-restart notice.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { parseDocument, Document, type YAMLMap, type YAMLSeq } from 'yaml'
+/** The plugin every managed row instantiates. */
+export const MCP_PLUGIN = '@deepseek-ai/dsh-mcp-client'
+
+/** MCP serverName grammar (dsh-mcp-client's contract). */
+export const SERVER_NAME_RE = /^[A-Za-z0-9_-]{1,32}$/
+
+/** Transport choices the client supports. */
+export type McpTransport = 'stdio' | 'streamable-http'
+
+/** One managed row, as shown to the browser. */
+export interface McpRow {
+  id: string
+  serverName: string
+  transport: McpTransport
+  disabled: boolean
+  command?: string
+  args?: string[]
+  env?: Record<string, string>
+  cwd?: string
+  url?: string
+  headers?: Record<string, string>
+}
+
+/** Write request for one server row (id empty = create). */
+export type McpInput = Omit<McpRow, 'disabled'> & { disabled?: boolean }
+
+/** Load the profile patch as a YAML document; `[]` for a missing file. */
+function loadPatch(profileDirPath: string): Document {
+  const path = join(profileDirPath, 'cordis.patch.yml')
+  const text = existsSync(path) ? readFileSync(path, 'utf8') : '[]'
+  return parseDocument(text)
+}
+
+function savePatch(profileDirPath: string, doc: Document): void {
+  mkdirSync(profileDirPath, { recursive: true })
+  writeFileSync(join(profileDirPath, 'cordis.patch.yml'), String(doc), 'utf8')
+}
+
+/** Wrap a plain value into a YAML node (yaml v2 exposes no standalone createNode). */
+function toNode<T>(value: unknown): T {
+  return new Document(value as never).contents as T
+}
+
+/** The patch row sequence; an empty file's null root becomes an empty seq. */
+function rowSeq(doc: Document): YAMLSeq<YAMLMap> {
+  if (doc.contents === null) doc.contents = toNode<YAMLSeq<YAMLMap>>([])
+  return doc.contents as YAMLSeq<YAMLMap>
+}
+
+/** Rows whose `name` is the MCP client plugin. */
+function mcpRows(doc: Document): YAMLMap[] {
+  return (rowSeq(doc).items ?? []).filter(item => item.get('name') === MCP_PLUGIN)
+}
+
+function isStringMap(value: unknown): value is Record<string, string> {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) return false
+  return Object.values(value).every(entry => typeof entry === 'string')
+}
+
+/** Read every mcp-client row in the profile layer. */
+export function listMcp(profileDirPath: string): McpRow[] {
+  const doc = loadPatch(profileDirPath)
+  return mcpRows(doc).map(item => {
+    // config is a YAMLMap node — materialize it before property access.
+    const configNode = item.get('config') as unknown
+    const plain = (typeof configNode === 'object' && configNode !== null && typeof (configNode as { toJS?: unknown }).toJS === 'function'
+      ? (configNode as { toJS(document: Document): unknown }).toJS(doc)
+      : {}) as Record<string, unknown>
+    return {
+      id: String(item.get('id') ?? ''),
+      serverName: String(plain.serverName ?? ''),
+      transport: plain.transport === 'streamable-http' ? 'streamable-http' : 'stdio',
+      disabled: item.get('disabled') === true,
+      ...(typeof plain.command === 'string' && plain.command !== '' ? { command: plain.command } : {}),
+      ...(Array.isArray(plain.args) ? { args: plain.args.map(String) } : {}),
+      ...(isStringMap(plain.env) ? { env: plain.env } : {}),
+      ...(typeof plain.cwd === 'string' && plain.cwd !== '' ? { cwd: plain.cwd } : {}),
+      ...(typeof plain.url === 'string' && plain.url !== '' ? { url: plain.url } : {}),
+      ...(isStringMap(plain.headers) ? { headers: plain.headers } : {}),
+    }
+  })
+}
+
+/** 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 _ -'
+  if (input.id.includes('/') || input.id.includes('..')) return 'invalid id'
+  if (input.transport === 'stdio') {
+    if (input.command === undefined || input.command.trim() === '') return 'stdio transport requires a command'
+  } else if (input.url === undefined || !/^https?:\/\//.test(input.url)) {
+    return 'http transport requires an http(s) url'
+  }
+  return null
+}
+
+/** Add or replace one server row. Returns the (possibly deduplicated) id. */
+export function upsertMcp(profileDirPath: string, input: McpInput): string {
+  const doc = loadPatch(profileDirPath)
+  const seq = rowSeq(doc)
+
+  const existing = input.id !== ''
+    ? mcpRows(doc).find(item => item.get('id') === input.id)
+    : undefined
+
+  let id = input.id !== '' ? input.id : `mcp-${input.serverName}`
+  if (existing === undefined) {
+    const taken = new Set(
+      (seq.items ?? []).map(item => String(item.get('id') ?? '')).filter(id => id !== ''),
+    )
+    let suffix = 2
+    while (taken.has(id)) id = `mcp-${input.serverName}-${suffix++}`
+  }
+
+  const config: Record<string, unknown> = input.transport === 'stdio'
+    ? {
+        serverName: input.serverName,
+        transport: input.transport,
+        command: input.command,
+        ...(input.args !== undefined && input.args.length > 0 ? { args: input.args } : {}),
+        ...(input.env !== undefined && Object.keys(input.env).length > 0 ? { env: input.env } : {}),
+        ...(input.cwd !== undefined && input.cwd !== '' ? { cwd: input.cwd } : {}),
+      }
+    : {
+        serverName: input.serverName,
+        transport: input.transport,
+        url: input.url,
+        ...(input.headers !== undefined && Object.keys(input.headers).length > 0 ? { headers: input.headers } : {}),
+      }
+  const row: Record<string, unknown> = { id, name: MCP_PLUGIN, config }
+  if (input.disabled === true) row.disabled = true
+
+  const node = toNode<YAMLMap>(row)
+  if (existing === undefined) seq.add(node)
+  else seq.items[seq.items.indexOf(existing)] = node
+
+  savePatch(profileDirPath, 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)
+  const item = mcpRows(doc).find(row => row.get('id') === id)
+  if (item === undefined) return false
+  if (disabled) item.set('disabled', true)
+  else item.delete('disabled')
+  savePatch(profileDirPath, doc)
+  return true
+}
+
+/** Remove one server row. Returns false when missing. */
+export function removeMcp(profileDirPath: string, id: string): boolean {
+  const doc = loadPatch(profileDirPath)
+  const item = mcpRows(doc).find(row => row.get('id') === id)
+  if (item === undefined) return false
+  const seq = rowSeq(doc)
+  seq.items.splice(seq.items.indexOf(item), 1)
+  savePatch(profileDirPath, doc)
+  return true
+}

package/src/profile.ts

@@ -0,0 +1,17 @@
+/** Profile discovery (pure reads; same contract as dsh-plugin-install). */
+
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+/** Profile that boots this UI: `--profile <name>` on the CLI invocation. */
+export function argvProfile(argv: readonly string[] = process.argv): string | undefined {
+  const flag = argv.indexOf('--profile')
+  if (flag !== -1 && flag + 1 < argv.length && !argv[flag + 1].startsWith('-')) return argv[flag + 1]
+  return undefined
+}
+
+/** 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)
+}

package/src/routes.ts

@@ -0,0 +1,285 @@
+/** HTTP routes bridging the Settings UI to the capabilities manager. */
+
+import type { IncomingMessage, ServerResponse } from 'node:http'
+import { scanAllMcp } from './agents.ts'
+import { readJsonBody, sameOrigin, sendJson } from './http.ts'
+import { deleteSkill, validateSkillInput, writeSkill, type SkillInput } from './skills.ts'
+import { listMcp, removeMcp, setMcpDisabled, upsertMcp, validateMcpInput, type McpInput } from './mcp.ts'
+import type { CapabilitiesHost } from './types.ts'
+
+/** Only this source is writable from the Settings page (provider rank 400). */
+const EDITABLE_SOURCE = 'user-dsh'
+
+/** Register the manager's routes; returns the disposer removing them all. */
+export function mountCapabilitiesRoutes(host: CapabilitiesHost, config: { profileDirPath: string }): () => void {
+  const disposers = [
+    host.webServer.register({
+      kind: 'exact',
+      path: '/dsh-plugin-capabilities/skills',
+      handler: async (request: IncomingMessage, response: ServerResponse) => {
+        if (request.method !== 'GET') {
+          response.writeHead(405, { allow: 'GET' })
+          response.end()
+          return
+        }
+        try {
+          const skills = await host.skills.list()
+          sendJson(response, 200, {
+            skills: skills.map(skill => ({ ...skill, editable: skill.source === EDITABLE_SOURCE })),
+          })
+        } catch (error) {
+          sendJson(response, 500, { error: error instanceof Error ? error.message : String(error) })
+        }
+      },
+    }),
+
+    host.webServer.register({
+      kind: 'exact',
+      path: '/dsh-plugin-capabilities/skill',
+      handler: async (request: IncomingMessage, response: ServerResponse) => {
+        if (request.method !== 'GET') {
+          response.writeHead(405, { allow: 'GET' })
+          response.end()
+          return
+        }
+        const url = new URL(request.url ?? '/', 'http://localhost')
+        const name = url.searchParams.get('name') ?? ''
+        try {
+          const definition = await host.skills.get(name)
+          sendJson(response, 200, { name: definition.name, content: definition.content })
+        } catch (error) {
+          sendJson(response, 500, { error: error instanceof Error ? error.message : String(error) })
+        }
+      },
+    }),
+
+    host.webServer.register({
+      kind: 'exact',
+      path: '/dsh-plugin-capabilities/skill/save',
+      handler: async (request: IncomingMessage, response: ServerResponse) => {
+        if (request.method !== 'POST') {
+          response.writeHead(405, { allow: 'POST' })
+          response.end()
+          return
+        }
+        if (!sameOrigin(request)) {
+          sendJson(response, 403, { error: 'untrusted origin' })
+          return
+        }
+        try {
+          const body = (await readJsonBody(request)) as Partial<SkillInput>
+          const input: SkillInput = {
+            name: typeof body.name === 'string' ? body.name : '',
+            description: typeof body.description === 'string' ? body.description : '',
+            whenToUse: typeof body.whenToUse === 'string' ? body.whenToUse : undefined,
+            modelInvocable: body.modelInvocable !== false,
+            userInvocable: body.userInvocable !== false,
+            content: typeof body.content === 'string' ? body.content : '',
+          }
+          const invalid = validateSkillInput(input)
+          if (invalid !== null) {
+            sendJson(response, 400, { error: invalid })
+            return
+          }
+          writeSkill(input)
+          sendJson(response, 200, { ok: true, name: input.name })
+        } catch (error) {
+          sendJson(response, 500, { error: error instanceof Error ? error.message : String(error) })
+        }
+      },
+    }),
+
+    host.webServer.register({
+      kind: 'exact',
+      path: '/dsh-plugin-capabilities/skill/delete',
+      handler: async (request: IncomingMessage, response: ServerResponse) => {
+        if (request.method !== 'POST') {
+          response.writeHead(405, { allow: 'POST' })
+          response.end()
+          return
+        }
+        if (!sameOrigin(request)) {
+          sendJson(response, 403, { error: 'untrusted origin' })
+          return
+        }
+        try {
+          const body = (await readJsonBody(request)) as { name?: unknown }
+          const name = typeof body.name === 'string' ? body.name : ''
+          const removed = deleteSkill(name)
+          sendJson(response, removed ? 200 : 404, removed ? { ok: true, name } : { error: 'skill not found' })
+        } catch (error) {
+          sendJson(response, 500, { error: error instanceof Error ? error.message : String(error) })
+        }
+      },
+    }),
+
+    host.webServer.register({
+      kind: 'exact',
+      path: '/dsh-plugin-capabilities/mcp',
+      handler: async (request: IncomingMessage, response: ServerResponse) => {
+        if (request.method !== 'GET') {
+          response.writeHead(405, { allow: 'GET' })
+          response.end()
+          return
+        }
+        sendJson(response, 200, { servers: listMcp(config.profileDirPath), restartNeeded: true })
+      },
+    }),
+
+    host.webServer.register({
+      kind: 'exact',
+      path: '/dsh-plugin-capabilities/mcp/save',
+      handler: async (request: IncomingMessage, response: ServerResponse) => {
+        if (request.method !== 'POST') {
+          response.writeHead(405, { allow: 'POST' })
+          response.end()
+          return
+        }
+        if (!sameOrigin(request)) {
+          sendJson(response, 403, { error: 'untrusted origin' })
+          return
+        }
+        try {
+          const input = (await readJsonBody(request)) as McpInput
+          const invalid = validateMcpInput(input)
+          if (invalid !== null) {
+            sendJson(response, 400, { error: invalid })
+            return
+          }
+          const id = upsertMcp(config.profileDirPath, input)
+          sendJson(response, 200, { ok: true, id, restartNeeded: true })
+        } catch (error) {
+          sendJson(response, 500, { error: error instanceof Error ? error.message : String(error) })
+        }
+      },
+    }),
+
+    host.webServer.register({
+      kind: 'exact',
+      path: '/dsh-plugin-capabilities/mcp/toggle',
+      handler: async (request: IncomingMessage, response: ServerResponse) => {
+        if (request.method !== 'POST') {
+          response.writeHead(405, { allow: 'POST' })
+          response.end()
+          return
+        }
+        if (!sameOrigin(request)) {
+          sendJson(response, 403, { error: 'untrusted origin' })
+          return
+        }
+        try {
+          const body = (await readJsonBody(request)) as { id?: unknown; disabled?: unknown }
+          if (typeof body.id !== 'string' || typeof body.disabled !== 'boolean') {
+            sendJson(response, 400, { error: 'id and disabled are required' })
+            return
+          }
+          const ok = setMcpDisabled(config.profileDirPath, body.id, body.disabled)
+          sendJson(response, ok ? 200 : 404, ok ? { ok: true, restartNeeded: true } : { error: 'server row not found' })
+        } catch (error) {
+          sendJson(response, 500, { error: error instanceof Error ? error.message : String(error) })
+        }
+      },
+    }),
+
+    host.webServer.register({
+      kind: 'exact',
+      path: '/dsh-plugin-capabilities/mcp/remove',
+      handler: async (request: IncomingMessage, response: ServerResponse) => {
+        if (request.method !== 'POST') {
+          response.writeHead(405, { allow: 'POST' })
+          response.end()
+          return
+        }
+        if (!sameOrigin(request)) {
+          sendJson(response, 403, { error: 'untrusted origin' })
+          return
+        }
+        try {
+          const body = (await readJsonBody(request)) as { id?: unknown }
+          if (typeof body.id !== 'string') {
+            sendJson(response, 400, { error: 'id is required' })
+            return
+          }
+          const ok = removeMcp(config.profileDirPath, body.id)
+          sendJson(response, ok ? 200 : 404, ok ? { ok: true, restartNeeded: true } : { error: 'server row not found' })
+        } catch (error) {
+          sendJson(response, 500, { error: error instanceof Error ? error.message : String(error) })
+        }
+      },
+    }),
+    host.webServer.register({
+      kind: 'exact',
+      path: '/dsh-plugin-capabilities/import/scan',
+      handler: async (request: IncomingMessage, response: ServerResponse) => {
+        if (request.method !== 'GET') {
+          response.writeHead(405, { allow: 'GET' })
+          response.end()
+          return
+        }
+        try {
+          sendJson(response, 200, {
+            servers: scanAllMcp(),
+            // Profile serverNames, so the browser can grey out existing ones.
+            existing: listMcp(config.profileDirPath).map(row => row.serverName),
+          })
+        } catch (error) {
+          sendJson(response, 500, { error: error instanceof Error ? error.message : String(error) })
+        }
+      },
+    }),
+
+    host.webServer.register({
+      kind: 'exact',
+      path: '/dsh-plugin-capabilities/import/apply',
+      handler: async (request: IncomingMessage, response: ServerResponse) => {
+        if (request.method !== 'POST') {
+          response.writeHead(405, { allow: 'POST' })
+          response.end()
+          return
+        }
+        if (!sameOrigin(request)) {
+          sendJson(response, 403, { error: 'untrusted origin' })
+          return
+        }
+        try {
+          const body = (await readJsonBody(request)) as { items?: unknown }
+          const wanted = new Set(
+            (Array.isArray(body.items) ? body.items : [])
+              .filter((item): item is { agent: string; name: string } =>
+                typeof item === 'object' && item !== null && typeof (item as { agent?: unknown }).agent === 'string' && typeof (item as { name?: unknown }).name === 'string')
+              .map(item => `${item.agent}/${item.name}`),
+          )
+          const results: Array<{ name: string; ok: boolean; error?: string }> = []
+          for (const server of scanAllMcp()) {
+            if (!wanted.has(`${server.agent}/${server.name}`)) continue
+            const existing = listMcp(config.profileDirPath).some(row => row.serverName === server.name)
+            if (existing) {
+              results.push({ name: server.name, ok: false, error: 'already in profile' })
+              continue
+            }
+            const input: McpInput = {
+              id: '',
+              serverName: server.name,
+              transport: server.transport,
+              ...(server.transport === 'stdio'
+                ? { command: server.command, args: server.args, env: server.env }
+                : { url: server.url, headers: server.headers }),
+            }
+            const invalid = validateMcpInput(input)
+            if (invalid !== null) {
+              results.push({ name: server.name, ok: false, error: invalid })
+              continue
+            }
+            upsertMcp(config.profileDirPath, input)
+            results.push({ name: server.name, ok: true })
+          }
+          sendJson(response, 200, { ok: results.every(item => item.ok), results, restartNeeded: true })
+        } catch (error) {
+          sendJson(response, 500, { error: error instanceof Error ? error.message : String(error) })
+        }
+      },
+    }),
+  ]
+
+  return () => { for (const dispose of disposers) dispose() }
+}