From 001f89f62c76d16dae8d30135144cf0d1b2228f8 Mon Sep 17 00:00:00 2001 From: gnanam1990 Date: Thu, 2 Apr 2026 14:55:04 +0530 Subject: [PATCH 1/3] feat: add MCP doctor diagnostics service Add the diagnostics core and report model for MCP health, scope, and config analysis. This creates the structured report used by both text and JSON doctor output. Co-Authored-By: Claude --- src/services/mcp/doctor.test.ts | 540 +++++++++++++++++++++++++ src/services/mcp/doctor.ts | 695 ++++++++++++++++++++++++++++++++ 2 files changed, 1235 insertions(+) create mode 100644 src/services/mcp/doctor.test.ts create mode 100644 src/services/mcp/doctor.ts diff --git a/src/services/mcp/doctor.test.ts b/src/services/mcp/doctor.test.ts new file mode 100644 index 00000000..83b74d3f --- /dev/null +++ b/src/services/mcp/doctor.test.ts @@ -0,0 +1,540 @@ +import assert from 'node:assert/strict' +import test from 'node:test' + +import type { ValidationError } from '../../utils/settings/validation.js' + +import { + buildEmptyDoctorReport, + doctorAllServers, + doctorServer, + findingsFromValidationErrors, + type McpDoctorDependencies, +} from './doctor.js' + +function stdioConfig(scope: 'local' | 'project' | 'user' | 'enterprise', command: string) { + return { + type: 'stdio' as const, + command, + args: [], + scope, + } +} + +function makeDependencies(overrides: Partial = {}): McpDoctorDependencies { + return { + getAllMcpConfigs: async () => ({ servers: {}, errors: [] }), + getMcpConfigsByScope: () => ({ servers: {}, errors: [] }), + getProjectMcpServerStatus: () => 'approved', + isMcpServerDisabled: () => false, + describeMcpConfigFilePath: scope => `scope://${scope}`, + clearServerCache: async () => {}, + connectToServer: async (name, config) => ({ + name, + type: 'connected', + capabilities: {}, + config, + cleanup: async () => {}, + }), + ...overrides, + } +} + +test('buildEmptyDoctorReport returns zeroed summary', () => { + const report = buildEmptyDoctorReport({ + configOnly: true, + scopeFilter: 'project', + targetName: 'filesystem', + }) + + assert.equal(report.targetName, 'filesystem') + assert.equal(report.scopeFilter, 'project') + assert.equal(report.configOnly, true) + assert.deepEqual(report.summary, { + totalReports: 0, + healthy: 0, + warnings: 0, + blocking: 0, + }) + assert.deepEqual(report.findings, []) + assert.deepEqual(report.servers, []) +}) + +test('findingsFromValidationErrors maps missing env warnings into doctor findings', () => { + const validationErrors: ValidationError[] = [ + { + file: '.mcp.json', + path: 'mcpServers.filesystem', + message: 'Missing environment variables: API_KEY, API_URL', + suggestion: 'Set the following environment variables: API_KEY, API_URL', + mcpErrorMetadata: { + scope: 'project', + serverName: 'filesystem', + severity: 'warning', + }, + }, + ] + + const findings = findingsFromValidationErrors(validationErrors) + + assert.equal(findings.length, 1) + assert.deepEqual(findings[0], { + blocking: false, + code: 'config.missing_env_vars', + message: 'Missing environment variables: API_KEY, API_URL', + remediation: 'Set the following environment variables: API_KEY, API_URL', + scope: 'project', + serverName: 'filesystem', + severity: 'warn', + sourcePath: '.mcp.json', + }) +}) + +test('findingsFromValidationErrors maps Windows npx warnings into doctor findings', () => { + const validationErrors: ValidationError[] = [ + { + file: '.mcp.json', + path: 'mcpServers.node-tools', + message: "Windows requires 'cmd /c' wrapper to execute npx", + suggestion: + 'Change command to "cmd" with args ["/c", "npx", ...]. See: https://code.claude.com/docs/en/mcp#configure-mcp-servers', + mcpErrorMetadata: { + scope: 'project', + serverName: 'node-tools', + severity: 'warning', + }, + }, + ] + + const findings = findingsFromValidationErrors(validationErrors) + + assert.equal(findings.length, 1) + assert.equal(findings[0]?.code, 'config.windows_npx_wrapper_required') + assert.equal(findings[0]?.serverName, 'node-tools') + assert.equal(findings[0]?.severity, 'warn') + assert.equal(findings[0]?.blocking, false) +}) + +test('findingsFromValidationErrors maps fatal parse errors into blocking findings', () => { + const validationErrors: ValidationError[] = [ + { + file: 'C:/repo/.mcp.json', + path: '', + message: 'MCP config is not a valid JSON', + suggestion: 'Fix the JSON syntax errors in the file', + mcpErrorMetadata: { + scope: 'project', + severity: 'fatal', + }, + }, + ] + + const findings = findingsFromValidationErrors(validationErrors) + + assert.equal(findings.length, 1) + assert.equal(findings[0]?.code, 'config.invalid_json') + assert.equal(findings[0]?.severity, 'error') + assert.equal(findings[0]?.blocking, true) +}) + +test('doctorAllServers reports global validation findings once without duplicating them into every server', async () => { + const localConfig = stdioConfig('local', 'node-local') + const deps = makeDependencies({ + getAllMcpConfigs: async () => ({ + servers: { filesystem: localConfig }, + errors: [], + }), + getMcpConfigsByScope: scope => + scope === 'project' + ? { + servers: {}, + errors: [ + { + file: '.mcp.json', + path: '', + message: 'MCP config is not a valid JSON', + suggestion: 'Fix the JSON syntax errors in the file', + mcpErrorMetadata: { + scope: 'project', + severity: 'fatal', + }, + }, + ], + } + : scope === 'local' + ? { servers: { filesystem: localConfig }, errors: [] } + : { servers: {}, errors: [] }, + }) + + const report = await doctorAllServers({ configOnly: true }, deps) + + assert.equal(report.summary.totalReports, 1) + assert.equal(report.summary.blocking, 1) + assert.equal(report.findings.length, 1) + assert.equal(report.findings[0]?.code, 'config.invalid_json') + assert.deepEqual(report.servers[0]?.findings, []) +}) + +test('doctorServer explains same-name shadowing across scopes', async () => { + const localConfig = stdioConfig('local', 'node-local') + const userConfig = stdioConfig('user', 'node-user') + const deps = makeDependencies({ + getAllMcpConfigs: async () => ({ + servers: { + filesystem: localConfig, + }, + errors: [], + }), + getMcpConfigsByScope: scope => { + switch (scope) { + case 'local': + return { servers: { filesystem: localConfig }, errors: [] } + case 'user': + return { servers: { filesystem: userConfig }, errors: [] } + default: + return { servers: {}, errors: [] } + } + }, + }) + + const report = await doctorServer('filesystem', { configOnly: true }, deps) + assert.equal(report.servers.length, 1) + assert.equal(report.servers[0]?.definitions.length, 2) + assert.equal(report.servers[0]?.definitions.find(def => def.sourceType === 'local')?.runtimeActive, true) + assert.equal(report.servers[0]?.definitions.find(def => def.sourceType === 'user')?.runtimeActive, false) + assert.deepEqual( + report.servers[0]?.findings.map(finding => finding.code).sort(), + ['duplicate.same_name_multiple_scopes', 'scope.shadowed'], + ) +}) + +test('doctorServer reports project servers pending approval', async () => { + const projectConfig = stdioConfig('project', 'node-project') + const deps = makeDependencies({ + getMcpConfigsByScope: scope => + scope === 'project' + ? { servers: { sentry: projectConfig }, errors: [] } + : { servers: {}, errors: [] }, + getProjectMcpServerStatus: name => (name === 'sentry' ? 'pending' : 'approved'), + }) + + const report = await doctorServer('sentry', { configOnly: true }, deps) + assert.equal(report.servers.length, 1) + assert.equal(report.servers[0]?.definitions[0]?.pendingApproval, true) + assert.equal(report.servers[0]?.definitions[0]?.runtimeActive, false) + assert.equal(report.servers[0]?.definitions[0]?.runtimeVisible, false) + assert.equal( + report.servers[0]?.findings.some(finding => finding.code === 'state.pending_project_approval'), + true, + ) +}) + +test('doctorServer does not treat disabled servers as runtime-active or live-check targets', async () => { + let connectCalls = 0 + const localConfig = stdioConfig('local', 'node-local') + const deps = makeDependencies({ + getAllMcpConfigs: async () => ({ + servers: { github: localConfig }, + errors: [], + }), + getMcpConfigsByScope: scope => + scope === 'local' + ? { servers: { github: localConfig }, errors: [] } + : { servers: {}, errors: [] }, + isMcpServerDisabled: name => name === 'github', + connectToServer: async (name, config) => { + connectCalls += 1 + return { + name, + type: 'failed', + config, + error: 'should not connect', + } + }, + }) + + const report = await doctorServer('github', { configOnly: false }, deps) + + assert.equal(connectCalls, 0) + assert.equal(report.summary.blocking, 0) + assert.equal(report.summary.warnings, 1) + assert.equal(report.servers[0]?.definitions[0]?.disabled, true) + assert.equal(report.servers[0]?.definitions[0]?.runtimeActive, false) + assert.equal(report.servers[0]?.definitions[0]?.runtimeVisible, false) + assert.equal(report.servers[0]?.liveCheck.result, 'disabled') + assert.equal( + report.servers[0]?.findings.some(finding => finding.code === 'state.disabled' && finding.severity === 'warn'), + true, + ) +}) + +test('doctorAllServers skips live checks in config-only mode', async () => { + let connectCalls = 0 + const localConfig = stdioConfig('local', 'node-local') + const deps = makeDependencies({ + getAllMcpConfigs: async () => ({ + servers: { linear: localConfig }, + errors: [], + }), + getMcpConfigsByScope: scope => + scope === 'local' + ? { servers: { linear: localConfig }, errors: [] } + : { servers: {}, errors: [] }, + connectToServer: async (name, config) => { + connectCalls += 1 + return { + name, + type: 'connected', + capabilities: {}, + config, + cleanup: async () => {}, + } + }, + }) + + const report = await doctorAllServers({ configOnly: true }, deps) + assert.equal(connectCalls, 0) + assert.equal(report.servers[0]?.liveCheck.attempted, false) + assert.equal(report.servers[0]?.liveCheck.result, 'skipped') +}) + +test('doctorAllServers honors scopeFilter when collecting names', async () => { + const pluginConfig = { + type: 'http' as const, + url: 'https://example.test/mcp', + scope: 'dynamic' as const, + pluginSource: 'plugin:github@official', + } + const deps = makeDependencies({ + getAllMcpConfigs: async () => ({ + servers: { 'plugin:github:github': pluginConfig }, + errors: [], + }), + }) + + const report = await doctorAllServers({ configOnly: true, scopeFilter: 'user' }, deps) + + assert.equal(report.summary.totalReports, 0) + assert.deepEqual(report.servers, []) +}) + +test('doctorAllServers honors scopeFilter when collecting validation errors', async () => { + const userConfig = stdioConfig('user', 'node-user') + const deps = makeDependencies({ + getAllMcpConfigs: async () => ({ + servers: { filesystem: userConfig }, + errors: [], + }), + getMcpConfigsByScope: scope => { + switch (scope) { + case 'project': + return { + servers: {}, + errors: [ + { + file: '.mcp.json', + path: '', + message: 'MCP config is not a valid JSON', + suggestion: 'Fix the JSON syntax errors in the file', + mcpErrorMetadata: { + scope: 'project', + severity: 'fatal', + }, + }, + ], + } + case 'user': + return { servers: { filesystem: userConfig }, errors: [] } + default: + return { servers: {}, errors: [] } + } + }, + }) + + const report = await doctorAllServers({ configOnly: true, scopeFilter: 'user' }, deps) + + assert.equal(report.summary.totalReports, 1) + assert.equal(report.summary.blocking, 0) + assert.deepEqual(report.findings, []) + assert.deepEqual(report.servers[0]?.findings, []) +}) + +test('doctorAllServers includes observed runtime definitions for plugin-only servers', async () => { + const pluginConfig = { + type: 'http' as const, + url: 'https://example.test/mcp', + scope: 'dynamic' as const, + pluginSource: 'plugin:github@official', + } + const deps = makeDependencies({ + getAllMcpConfigs: async () => ({ + servers: { 'plugin:github:github': pluginConfig }, + errors: [], + }), + }) + + const report = await doctorAllServers({ configOnly: true }, deps) + + assert.equal(report.summary.totalReports, 1) + assert.equal(report.servers[0]?.definitions.length, 1) + assert.equal(report.servers[0]?.definitions[0]?.sourceType, 'plugin') + assert.equal(report.servers[0]?.definitions[0]?.runtimeActive, true) +}) + +test('doctorAllServers reports disabled plugin servers as disabled, not not-found', async () => { + const pluginConfig = { + type: 'http' as const, + url: 'https://example.test/mcp', + scope: 'dynamic' as const, + pluginSource: 'plugin:github@official', + } + const deps = makeDependencies({ + getAllMcpConfigs: async () => ({ + servers: { 'plugin:github:github': pluginConfig }, + errors: [], + }), + isMcpServerDisabled: name => name === 'plugin:github:github', + }) + + const report = await doctorAllServers({ configOnly: true }, deps) + + assert.equal(report.summary.totalReports, 1) + assert.equal(report.summary.warnings, 1) + assert.equal(report.summary.blocking, 0) + assert.equal(report.servers[0]?.definitions.length, 1) + assert.equal(report.servers[0]?.definitions[0]?.sourceType, 'plugin') + assert.equal(report.servers[0]?.definitions[0]?.disabled, true) + assert.equal(report.servers[0]?.definitions[0]?.runtimeActive, false) + assert.equal( + report.servers[0]?.findings.some(finding => finding.code === 'state.disabled' && !finding.blocking), + true, + ) + assert.equal( + report.servers[0]?.findings.some(finding => finding.code === 'state.not_found'), + false, + ) +}) + +test('doctorServer converts failed live checks into blocking findings', async () => { + const localConfig = stdioConfig('local', 'node-local') + const deps = makeDependencies({ + getAllMcpConfigs: async () => ({ + servers: { github: localConfig }, + errors: [], + }), + getMcpConfigsByScope: scope => + scope === 'local' + ? { servers: { github: localConfig }, errors: [] } + : { servers: {}, errors: [] }, + connectToServer: async (name, config) => ({ + name, + type: 'failed', + config, + error: 'command not found: node-local', + }), + }) + + const report = await doctorServer('github', { configOnly: false }, deps) + + assert.equal(report.summary.blocking, 1) + assert.equal(report.servers[0]?.liveCheck.result, 'failed') + assert.equal( + report.servers[0]?.findings.some( + finding => finding.code === 'stdio.command_not_found' && finding.blocking, + ), + true, + ) +}) + +test('doctorServer converts needs-auth live checks into warning findings', async () => { + const localConfig = stdioConfig('local', 'node-local') + const deps = makeDependencies({ + getAllMcpConfigs: async () => ({ + servers: { sentry: localConfig }, + errors: [], + }), + getMcpConfigsByScope: scope => + scope === 'local' + ? { servers: { sentry: localConfig }, errors: [] } + : { servers: {}, errors: [] }, + connectToServer: async (name, config) => ({ + name, + type: 'needs-auth', + config, + }), + }) + + const report = await doctorServer('sentry', { configOnly: false }, deps) + + assert.equal(report.summary.warnings, 1) + assert.equal(report.summary.blocking, 0) + assert.equal( + report.servers[0]?.findings.some(finding => finding.code === 'auth.needs_auth' && finding.severity === 'warn'), + true, + ) +}) + +test('doctorServer includes observed runtime definition for plugin-only targets', async () => { + const pluginConfig = { + type: 'http' as const, + url: 'https://example.test/mcp', + scope: 'dynamic' as const, + pluginSource: 'plugin:github@official', + } + const deps = makeDependencies({ + getAllMcpConfigs: async () => ({ + servers: { 'plugin:github:github': pluginConfig }, + errors: [], + }), + }) + + const report = await doctorServer('plugin:github:github', { configOnly: true }, deps) + + assert.equal(report.summary.totalReports, 1) + assert.equal(report.servers[0]?.definitions.length, 1) + assert.equal(report.servers[0]?.definitions[0]?.sourceType, 'plugin') + assert.equal(report.servers[0]?.definitions[0]?.runtimeActive, true) +}) + +test('doctorServer with scopeFilter does not leak runtime definition from another scope when target is absent', async () => { + let connectCalls = 0 + const localConfig = stdioConfig('local', 'node-local') + const deps = makeDependencies({ + getAllMcpConfigs: async () => ({ + servers: { github: localConfig }, + errors: [], + }), + getMcpConfigsByScope: scope => + scope === 'local' + ? { servers: { github: localConfig }, errors: [] } + : { servers: {}, errors: [] }, + connectToServer: async (name, config) => { + connectCalls += 1 + return { + name, + type: 'connected', + capabilities: {}, + config, + cleanup: async () => {}, + } + }, + }) + + const report = await doctorServer('github', { configOnly: false, scopeFilter: 'user' }, deps) + + assert.equal(connectCalls, 0) + assert.equal(report.summary.totalReports, 1) + assert.equal(report.summary.blocking, 1) + assert.deepEqual(report.servers[0]?.definitions, []) + assert.equal(report.servers[0]?.liveCheck.result, 'skipped') + assert.equal( + report.servers[0]?.findings.some(finding => finding.code === 'state.not_found' && finding.blocking), + true, + ) +}) + +test('doctorServer reports blocking not-found state when no definition exists', async () => { + const report = await doctorServer('missing-server', { configOnly: true }, makeDependencies()) + + assert.equal(report.summary.blocking, 1) + assert.equal(report.servers[0]?.findings.some(finding => finding.code === 'state.not_found' && finding.blocking), true) +}) diff --git a/src/services/mcp/doctor.ts b/src/services/mcp/doctor.ts new file mode 100644 index 00000000..6cdd15e5 --- /dev/null +++ b/src/services/mcp/doctor.ts @@ -0,0 +1,695 @@ +import type { ValidationError } from '../../utils/settings/validation.js' +import { clearServerCache, connectToServer } from './client.js' +import { + getAllMcpConfigs, + getMcpConfigsByScope, + isMcpServerDisabled, +} from './config.js' +import type { + ConfigScope, + ScopedMcpServerConfig, +} from './types.js' +import { describeMcpConfigFilePath, getProjectMcpServerStatus } from './utils.js' + +export type McpDoctorSeverity = 'info' | 'warn' | 'error' +export type McpDoctorScopeFilter = 'local' | 'project' | 'user' | 'enterprise' + +export type McpDoctorFinding = { + blocking: boolean + code: string + message: string + remediation?: string + scope?: string + serverName?: string + severity: McpDoctorSeverity + sourcePath?: string +} + +export type McpDoctorLiveCheck = { + attempted: boolean + durationMs?: number + error?: string + result?: 'connected' | 'needs-auth' | 'failed' | 'pending' | 'disabled' | 'skipped' +} + +export type McpDoctorDefinition = { + name: string + sourceType: + | 'local' + | 'project' + | 'user' + | 'enterprise' + | 'managed' + | 'plugin' + | 'claudeai' + | 'dynamic' + | 'internal' + sourcePath?: string + transport?: string + runtimeVisible: boolean + runtimeActive: boolean + pendingApproval?: boolean + disabled?: boolean +} + +export type McpDoctorServerReport = { + serverName: string + requestedByUser: boolean + definitions: McpDoctorDefinition[] + liveCheck: McpDoctorLiveCheck + findings: McpDoctorFinding[] +} + +export type McpDoctorDependencies = { + getAllMcpConfigs: typeof getAllMcpConfigs + getMcpConfigsByScope: typeof getMcpConfigsByScope + getProjectMcpServerStatus: typeof getProjectMcpServerStatus + isMcpServerDisabled: typeof isMcpServerDisabled + describeMcpConfigFilePath: typeof describeMcpConfigFilePath + connectToServer: typeof connectToServer + clearServerCache: typeof clearServerCache +} + +export type McpDoctorReport = { + generatedAt: string + targetName?: string + scopeFilter?: McpDoctorScopeFilter + configOnly: boolean + summary: { + totalReports: number + healthy: number + warnings: number + blocking: number + } + findings: McpDoctorFinding[] + servers: McpDoctorServerReport[] +} + +const DEFAULT_DEPENDENCIES: McpDoctorDependencies = { + getAllMcpConfigs, + getMcpConfigsByScope, + getProjectMcpServerStatus, + isMcpServerDisabled, + describeMcpConfigFilePath, + connectToServer, + clearServerCache, +} + +export function buildEmptyDoctorReport(options: { + configOnly: boolean + scopeFilter?: McpDoctorScopeFilter + targetName?: string +}): McpDoctorReport { + return { + generatedAt: new Date().toISOString(), + targetName: options.targetName, + scopeFilter: options.scopeFilter, + configOnly: options.configOnly, + summary: { + totalReports: 0, + healthy: 0, + warnings: 0, + blocking: 0, + }, + findings: [], + servers: [], + } +} + +function getFindingCode(error: ValidationError): string { + if (error.message === 'MCP config is not a valid JSON') { + return 'config.invalid_json' + } + if (error.message.startsWith('Missing environment variables:')) { + return 'config.missing_env_vars' + } + if (error.message.includes("Windows requires 'cmd /c' wrapper to execute npx")) { + return 'config.windows_npx_wrapper_required' + } + if (error.message === 'Does not adhere to MCP server configuration schema') { + return 'config.invalid_schema' + } + return 'config.validation_error' +} + +function getSeverity(error: ValidationError): McpDoctorSeverity { + const severity = error.mcpErrorMetadata?.severity + if (severity === 'fatal') { + return 'error' + } + if (severity === 'warning') { + return 'warn' + } + return 'warn' +} + +export function findingsFromValidationErrors( + validationErrors: ValidationError[], +): McpDoctorFinding[] { + return validationErrors.map(error => { + const severity = getSeverity(error) + return { + blocking: severity === 'error', + code: getFindingCode(error), + message: error.message, + remediation: error.suggestion, + scope: error.mcpErrorMetadata?.scope, + serverName: error.mcpErrorMetadata?.serverName, + severity, + sourcePath: error.file, + } + }) +} + +function splitValidationFindings(validationFindings: McpDoctorFinding[]): { + globalFindings: McpDoctorFinding[] + serverFindingsByName: Map +} { + const globalFindings: McpDoctorFinding[] = [] + const serverFindingsByName = new Map() + + for (const finding of validationFindings) { + if (!finding.serverName) { + globalFindings.push(finding) + continue + } + + const findings = serverFindingsByName.get(finding.serverName) ?? [] + findings.push(finding) + serverFindingsByName.set(finding.serverName, findings) + } + + return { + globalFindings, + serverFindingsByName, + } +} + +function getSourceType(config: ScopedMcpServerConfig): McpDoctorDefinition['sourceType'] { + if (config.scope === 'claudeai') { + return 'claudeai' + } + if (config.scope === 'dynamic') { + return config.pluginSource ? 'plugin' : 'dynamic' + } + if (config.scope === 'managed') { + return 'managed' + } + return config.scope +} + +function getTransport(config: ScopedMcpServerConfig): string { + return config.type ?? 'stdio' +} + +function getConfigSignature(config: ScopedMcpServerConfig): string { + switch (config.type) { + case 'sse': + case 'http': + case 'ws': + case 'claudeai-proxy': + return `${config.scope}:${config.type}:${config.url}` + case 'sdk': + return `${config.scope}:${config.type}:${config.name}` + default: + return `${config.scope}:${config.type ?? 'stdio'}:${config.command}:${JSON.stringify(config.args ?? [])}` + } +} + +function isSameDefinition( + config: ScopedMcpServerConfig, + activeConfig: ScopedMcpServerConfig | undefined, +): boolean { + if (!activeConfig) { + return false + } + return getSourceType(config) === getSourceType(activeConfig) && getConfigSignature(config) === getConfigSignature(activeConfig) +} + +function buildScopeDefinitions( + name: string, + scope: ConfigScope, + servers: Record, + activeConfig: ScopedMcpServerConfig | undefined, + deps: McpDoctorDependencies, +): McpDoctorDefinition[] { + const config = servers[name] + if (!config) { + return [] + } + + const pendingApproval = + scope === 'project' ? deps.getProjectMcpServerStatus(name) === 'pending' : false + const disabled = deps.isMcpServerDisabled(name) + const runtimeActive = !disabled && isSameDefinition(config, activeConfig) + + return [ + { + name, + sourceType: getSourceType(config), + sourcePath: deps.describeMcpConfigFilePath(scope), + transport: getTransport(config), + runtimeVisible: runtimeActive, + runtimeActive, + pendingApproval, + disabled, + }, + ] +} + +function shouldIncludeScope( + scope: ConfigScope, + scopeFilter: McpDoctorScopeFilter | undefined, +): boolean { + if (!scopeFilter) { + return scope === 'enterprise' || scope === 'local' || scope === 'project' || scope === 'user' + } + return scope === scopeFilter +} + +function getValidationErrorsForSelectedScopes( + scopeResults: { + enterprise: ReturnType + local: ReturnType + project: ReturnType + user: ReturnType + }, + scopeFilter: McpDoctorScopeFilter | undefined, +): ValidationError[] { + return [ + ...(shouldIncludeScope('enterprise', scopeFilter) ? scopeResults.enterprise.errors : []), + ...(shouldIncludeScope('local', scopeFilter) ? scopeResults.local.errors : []), + ...(shouldIncludeScope('project', scopeFilter) ? scopeResults.project.errors : []), + ...(shouldIncludeScope('user', scopeFilter) ? scopeResults.user.errors : []), + ] +} + +function buildObservedDefinition( + name: string, + activeConfig: ScopedMcpServerConfig, + options?: { + disabled?: boolean + runtimeActive?: boolean + runtimeVisible?: boolean + }, +): McpDoctorDefinition { + return { + name, + sourceType: getSourceType(activeConfig), + sourcePath: + getSourceType(activeConfig) === 'plugin' + ? `plugin:${activeConfig.pluginSource ?? 'unknown'}` + : getSourceType(activeConfig) === 'claudeai' + ? 'claude.ai' + : activeConfig.scope, + transport: getTransport(activeConfig), + runtimeVisible: options?.runtimeVisible ?? true, + runtimeActive: options?.runtimeActive ?? true, + disabled: options?.disabled ?? false, + } +} + +function hasDefinitionForRuntimeSource( + definitions: McpDoctorDefinition[], + runtimeConfig: ScopedMcpServerConfig, + deps: McpDoctorDependencies, +): boolean { + const runtimeSourceType = getSourceType(runtimeConfig) + const runtimeSourcePath = + runtimeSourceType === 'plugin' + ? `plugin:${runtimeConfig.pluginSource ?? 'unknown'}` + : runtimeSourceType === 'claudeai' + ? 'claude.ai' + : deps.describeMcpConfigFilePath(runtimeConfig.scope) + + return definitions.some( + definition => + definition.sourceType === runtimeSourceType && + definition.sourcePath === runtimeSourcePath && + definition.transport === getTransport(runtimeConfig), + ) +} + +function buildShadowingFindings(definitions: McpDoctorDefinition[]): McpDoctorFinding[] { + const userEditable = definitions.filter(definition => + definition.sourceType === 'local' || + definition.sourceType === 'project' || + definition.sourceType === 'user' || + definition.sourceType === 'enterprise', + ) + + if (userEditable.length <= 1) { + return [] + } + + const active = userEditable.find(definition => definition.runtimeActive) ?? userEditable[0] + return [ + { + blocking: false, + code: 'duplicate.same_name_multiple_scopes', + message: `Server is defined in multiple config scopes; active source is ${active.sourceType}`, + remediation: 'Remove or rename one of the duplicate definitions to avoid confusion.', + serverName: active.name, + severity: 'warn', + }, + { + blocking: false, + code: 'scope.shadowed', + message: `${active.name} has shadowed definitions in lower-precedence config scopes.`, + remediation: 'Inspect the other definitions and remove the ones you no longer want to keep.', + serverName: active.name, + severity: 'warn', + }, + ] +} + +function buildStateFindings(definitions: McpDoctorDefinition[]): McpDoctorFinding[] { + const findings: McpDoctorFinding[] = [] + + for (const definition of definitions) { + if (definition.pendingApproval) { + findings.push({ + blocking: false, + code: 'state.pending_project_approval', + message: `${definition.name} is declared in project config but pending project approval.`, + remediation: 'Approve the server in the project MCP approval flow before expecting it to become active.', + scope: 'project', + serverName: definition.name, + severity: 'warn', + sourcePath: definition.sourcePath, + }) + } + + if (definition.disabled) { + findings.push({ + blocking: false, + code: 'state.disabled', + message: `${definition.name} is currently disabled.`, + remediation: 'Re-enable the server before expecting it to be available at runtime.', + serverName: definition.name, + severity: 'warn', + sourcePath: definition.sourcePath, + }) + } + } + + return findings +} + +function summarizeReport(report: McpDoctorReport): McpDoctorReport { + const allFindings = [...report.findings, ...report.servers.flatMap(server => server.findings)] + const blocking = allFindings.filter(finding => finding.blocking).length + const warnings = allFindings.filter(finding => finding.severity === 'warn').length + const healthy = report.servers.filter( + server => + server.liveCheck.result === 'connected' && + server.findings.every(finding => !finding.blocking && finding.severity !== 'warn'), + ).length + + return { + ...report, + summary: { + totalReports: report.servers.length, + healthy, + warnings, + blocking, + }, + } +} + +async function getLiveCheck( + name: string, + activeConfig: ScopedMcpServerConfig | undefined, + configOnly: boolean, + definitions: McpDoctorDefinition[], + deps: McpDoctorDependencies, +): Promise { + if (configOnly) { + return { attempted: false, result: 'skipped' } + } + + if (!activeConfig) { + if (definitions.some(definition => definition.pendingApproval)) { + return { attempted: false, result: 'pending' } + } + if (definitions.some(definition => definition.disabled)) { + return { attempted: false, result: 'disabled' } + } + return { attempted: false, result: 'skipped' } + } + + const startedAt = Date.now() + const connection = await deps.connectToServer(name, activeConfig) + const durationMs = Date.now() - startedAt + + try { + switch (connection.type) { + case 'connected': + return { attempted: true, result: 'connected', durationMs } + case 'needs-auth': + return { attempted: true, result: 'needs-auth', durationMs } + case 'disabled': + return { attempted: true, result: 'disabled', durationMs } + case 'pending': + return { attempted: true, result: 'pending', durationMs } + case 'failed': + return { + attempted: true, + result: 'failed', + durationMs, + error: connection.error, + } + } + } finally { + await deps.clearServerCache(name, activeConfig).catch(() => { + // Best-effort cleanup for diagnostic connections. + }) + } +} + +function buildLiveFindings( + name: string, + definitions: McpDoctorDefinition[], + liveCheck: McpDoctorLiveCheck, +): McpDoctorFinding[] { + const activeDefinition = definitions.find(definition => definition.runtimeActive) + + if (liveCheck.result === 'needs-auth') { + return [ + { + blocking: false, + code: 'auth.needs_auth', + message: `${name} requires authentication before it can be used.`, + remediation: 'Authenticate the server and then rerun the doctor command.', + serverName: name, + severity: 'warn', + sourcePath: activeDefinition?.sourcePath, + }, + ] + } + + if (liveCheck.result === 'failed') { + const commandNotFound = + activeDefinition?.transport === 'stdio' && + typeof liveCheck.error === 'string' && + liveCheck.error.toLowerCase().includes('not found') + + return [ + { + blocking: true, + code: commandNotFound ? 'stdio.command_not_found' : 'health.failed', + message: liveCheck.error + ? `${name} failed its live health check: ${liveCheck.error}` + : `${name} failed its live health check.`, + remediation: commandNotFound + ? 'Verify the configured executable exists on PATH or use a full executable path.' + : 'Inspect the server configuration and retry the connection once the underlying problem is fixed.', + serverName: name, + severity: 'error', + sourcePath: activeDefinition?.sourcePath, + }, + ] + } + + return [] +} + +async function buildServerReport( + name: string, + options: { + configOnly: boolean + requestedByUser: boolean + scopeFilter?: McpDoctorScopeFilter + }, + validationFindingsByName: Map, + deps: McpDoctorDependencies, +): Promise { + const scopeResults = { + enterprise: deps.getMcpConfigsByScope('enterprise'), + local: deps.getMcpConfigsByScope('local'), + project: deps.getMcpConfigsByScope('project'), + user: deps.getMcpConfigsByScope('user'), + } + const { servers: activeServers } = await deps.getAllMcpConfigs() + const serverDisabled = deps.isMcpServerDisabled(name) + const runtimeConfig = activeServers[name] ?? undefined + const activeConfig = serverDisabled ? undefined : runtimeConfig + + const definitions = [ + ...(shouldIncludeScope('enterprise', options.scopeFilter) + ? buildScopeDefinitions(name, 'enterprise', scopeResults.enterprise.servers, activeConfig, deps) + : []), + ...(shouldIncludeScope('local', options.scopeFilter) + ? buildScopeDefinitions(name, 'local', scopeResults.local.servers, activeConfig, deps) + : []), + ...(shouldIncludeScope('project', options.scopeFilter) + ? buildScopeDefinitions(name, 'project', scopeResults.project.servers, activeConfig, deps) + : []), + ...(shouldIncludeScope('user', options.scopeFilter) + ? buildScopeDefinitions(name, 'user', scopeResults.user.servers, activeConfig, deps) + : []), + ] + + const shouldAddObservedDefinition = + !!runtimeConfig && + !hasDefinitionForRuntimeSource(definitions, runtimeConfig, deps) && + ((definitions.length === 0 && !options.scopeFilter) || + (definitions.length > 0 && definitions.every(definition => !definition.runtimeActive))) + + if (runtimeConfig && shouldAddObservedDefinition) { + definitions.push( + buildObservedDefinition(name, runtimeConfig, { + disabled: serverDisabled, + runtimeActive: !serverDisabled, + runtimeVisible: !serverDisabled, + }), + ) + } + + const visibleRuntimeConfig = + definitions.some(definition => definition.runtimeActive) || shouldAddObservedDefinition + ? activeConfig + : undefined + + const findings: McpDoctorFinding[] = [ + ...(validationFindingsByName.get(name) ?? []), + ...buildShadowingFindings(definitions), + ...buildStateFindings(definitions), + ] + + if (definitions.length === 0 && !shouldAddObservedDefinition) { + findings.push({ + blocking: true, + code: 'state.not_found', + message: `${name} was not found in the selected MCP configuration sources.`, + remediation: 'Check the server name and scope, or add the MCP server before retrying.', + serverName: name, + severity: 'error', + }) + } + + const liveCheck = await getLiveCheck(name, visibleRuntimeConfig, options.configOnly, definitions, deps) + findings.push(...buildLiveFindings(name, definitions, liveCheck)) + + return { + serverName: name, + requestedByUser: options.requestedByUser, + definitions, + liveCheck, + findings, + } +} + +function getServerNames( + scopeServers: Array>, + activeServers: Record, + includeActiveServers: boolean, +): string[] { + const names = new Set(includeActiveServers ? Object.keys(activeServers) : []) + for (const servers of scopeServers) { + for (const name of Object.keys(servers)) { + names.add(name) + } + } + return [...names].sort() +} + +export async function doctorAllServers( + options: { configOnly: boolean; scopeFilter?: McpDoctorScopeFilter } = { + configOnly: false, + }, + deps: McpDoctorDependencies = DEFAULT_DEPENDENCIES, +): Promise { + const report = buildEmptyDoctorReport(options) + const scopeResults = { + enterprise: deps.getMcpConfigsByScope('enterprise'), + local: deps.getMcpConfigsByScope('local'), + project: deps.getMcpConfigsByScope('project'), + user: deps.getMcpConfigsByScope('user'), + } + const validationFindings = findingsFromValidationErrors( + getValidationErrorsForSelectedScopes(scopeResults, options.scopeFilter), + ) + const { globalFindings, serverFindingsByName } = splitValidationFindings(validationFindings) + const { servers: activeServers } = await deps.getAllMcpConfigs() + const names = getServerNames( + [ + ...(shouldIncludeScope('enterprise', options.scopeFilter) ? [scopeResults.enterprise.servers] : []), + ...(shouldIncludeScope('local', options.scopeFilter) ? [scopeResults.local.servers] : []), + ...(shouldIncludeScope('project', options.scopeFilter) ? [scopeResults.project.servers] : []), + ...(shouldIncludeScope('user', options.scopeFilter) ? [scopeResults.user.servers] : []), + ], + activeServers, + !options.scopeFilter, + ) + + const servers = await Promise.all( + names.map(name => + buildServerReport( + name, + { + configOnly: options.configOnly, + requestedByUser: false, + scopeFilter: options.scopeFilter, + }, + serverFindingsByName, + deps, + ), + ), + ) + + report.servers = servers + report.findings = globalFindings + return summarizeReport(report) +} + +export async function doctorServer( + name: string, + options: { configOnly: boolean; scopeFilter?: McpDoctorScopeFilter }, + deps: McpDoctorDependencies = DEFAULT_DEPENDENCIES, +): Promise { + const report = buildEmptyDoctorReport({ ...options, targetName: name }) + const scopeResults = { + enterprise: deps.getMcpConfigsByScope('enterprise'), + local: deps.getMcpConfigsByScope('local'), + project: deps.getMcpConfigsByScope('project'), + user: deps.getMcpConfigsByScope('user'), + } + const validationFindings = findingsFromValidationErrors( + getValidationErrorsForSelectedScopes(scopeResults, options.scopeFilter), + ) + const { globalFindings, serverFindingsByName } = splitValidationFindings(validationFindings) + const server = await buildServerReport( + name, + { + configOnly: options.configOnly, + requestedByUser: true, + scopeFilter: options.scopeFilter, + }, + serverFindingsByName, + deps, + ) + report.servers = [server] + report.findings = globalFindings + return summarizeReport(report) +} From ad1f328672ecc9046c772507e771cdc37f8050b2 Mon Sep 17 00:00:00 2001 From: gnanam1990 Date: Thu, 2 Apr 2026 14:55:05 +0530 Subject: [PATCH 2/3] feat(mcp): add doctor command Add the MCP doctor subcommand with text and JSON output, config-only mode, and scope filtering so users can diagnose MCP issues from the CLI. Co-Authored-By: Claude --- src/cli/handlers/mcp.tsx | 99 +++++++++++++++++++++++++- src/commands/mcp/doctorCommand.test.ts | 19 +++++ src/commands/mcp/doctorCommand.ts | 25 +++++++ src/main.tsx | 2 + 4 files changed, 144 insertions(+), 1 deletion(-) create mode 100644 src/commands/mcp/doctorCommand.test.ts create mode 100644 src/commands/mcp/doctorCommand.ts diff --git a/src/cli/handlers/mcp.tsx b/src/cli/handlers/mcp.tsx index e530c268..bf43d490 100644 --- a/src/cli/handlers/mcp.tsx +++ b/src/cli/handlers/mcp.tsx @@ -12,6 +12,7 @@ import { render } from '../../ink.js'; import { KeybindingSetup } from '../../keybindings/KeybindingProviderSetup.js'; import { type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, logEvent } from '../../services/analytics/index.js'; import { clearMcpClientConfig, clearServerTokensFromLocalStorage, getMcpClientConfig, readClientSecret, saveMcpClientSecret } from '../../services/mcp/auth.js'; +import { doctorAllServers, doctorServer, type McpDoctorReport, type McpDoctorScopeFilter } from '../../services/mcp/doctor.js'; import { connectToServer, getMcpServerConnectionBatchSize } from '../../services/mcp/client.js'; import { addMcpConfig, getAllMcpConfigs, getMcpConfigByName, getMcpConfigsByScope, removeMcpConfig } from '../../services/mcp/config.js'; import type { ConfigScope, ScopedMcpServerConfig } from '../../services/mcp/types.js'; @@ -23,6 +24,102 @@ import { gracefulShutdown } from '../../utils/gracefulShutdown.js'; import { safeParseJSON } from '../../utils/json.js'; import { getPlatform } from '../../utils/platform.js'; import { cliError, cliOk } from '../exit.js'; + +function formatDoctorReport(report: McpDoctorReport): string { + const lines: string[] = [] + lines.push('MCP Doctor') + lines.push('') + lines.push('Summary') + lines.push(`- ${report.summary.totalReports} server reports generated`) + lines.push(`- ${report.summary.healthy} healthy`) + lines.push(`- ${report.summary.warnings} warnings`) + lines.push(`- ${report.summary.blocking} blocking issues`) + + if (report.targetName) { + lines.push(`- target: ${report.targetName}`) + } + + for (const server of report.servers) { + lines.push('') + lines.push(server.serverName) + + const activeDefinition = server.definitions.find(definition => definition.runtimeActive) + if (activeDefinition) { + lines.push(`- Active source: ${activeDefinition.sourceType}`) + lines.push(`- Transport: ${activeDefinition.transport ?? 'unknown'}`) + } + + if (server.definitions.length > 1) { + const extraDefinitions = server.definitions + .filter(definition => !definition.runtimeActive) + .map(definition => definition.sourceType) + if (extraDefinitions.length > 0) { + lines.push(`- Additional definitions: ${extraDefinitions.join(', ')}`) + } + } + + if (server.liveCheck.result) { + const stateLikeResults = new Set(['disabled', 'pending', 'skipped']) + const label = stateLikeResults.has(server.liveCheck.result) + ? 'State' + : 'Live check' + lines.push(`- ${label}: ${server.liveCheck.result}`) + } + + if (server.liveCheck.error) { + lines.push(`- Error: ${server.liveCheck.error}`) + } + + for (const finding of server.findings) { + lines.push(`- ${finding.message}`) + if (finding.remediation) { + lines.push(`- Fix: ${finding.remediation}`) + } + } + } + + if (report.findings.length > 0) { + lines.push('') + lines.push('Global findings') + for (const finding of report.findings) { + lines.push(`- ${finding.message}`) + if (finding.remediation) { + lines.push(`- Fix: ${finding.remediation}`) + } + } + } + + return lines.join('\n') +} + +export async function mcpDoctorHandler(name: string | undefined, options: { + scope?: string; + configOnly?: boolean; + json?: boolean; +}): Promise { + try { + const scopeFilter = options.scope ? ensureConfigScope(options.scope) as McpDoctorScopeFilter : undefined + const configOnly = !!options.configOnly + const report = name + ? await doctorServer(name, { configOnly, scopeFilter }) + : await doctorAllServers({ configOnly, scopeFilter }) + + if (options.json) { + process.stdout.write(`${JSON.stringify(report, null, 2)}\n`) + } else { + process.stdout.write(`${formatDoctorReport(report)}\n`) + } + + // On Windows, exiting immediately after a single failed HTTP MCP health check + // can trip a libuv assertion while async handle shutdown is still settling. + // Let the event loop drain briefly before exiting this one-shot command. + await new Promise(resolve => setTimeout(resolve, 50)) + process.exit(report.summary.blocking > 0 ? 1 : 0) + return + } catch (error) { + cliError((error as Error).message) + } +} async function checkMcpServerHealth(name: string, server: ScopedMcpServerConfig): Promise { try { const result = await connectToServer(name, server); @@ -359,4 +456,4 @@ export async function mcpResetChoicesHandler(): Promise { })); cliOk('All project-scoped (.mcp.json) server approvals and rejections have been reset.\n' + 'You will be prompted for approval next time you start Claude Code.'); } -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["stat","pMap","cwd","React","MCPServerDesktopImportDialog","render","KeybindingSetup","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","logEvent","clearMcpClientConfig","clearServerTokensFromLocalStorage","getMcpClientConfig","readClientSecret","saveMcpClientSecret","connectToServer","getMcpServerConnectionBatchSize","addMcpConfig","getAllMcpConfigs","getMcpConfigByName","getMcpConfigsByScope","removeMcpConfig","ConfigScope","ScopedMcpServerConfig","describeMcpConfigFilePath","ensureConfigScope","getScopeLabel","AppStateProvider","getCurrentProjectConfig","getGlobalConfig","saveCurrentProjectConfig","isFsInaccessible","gracefulShutdown","safeParseJSON","getPlatform","cliError","cliOk","checkMcpServerHealth","name","server","Promise","result","type","_error","mcpServeHandler","debug","verbose","providedCwd","error","setup","undefined","startMCPServer","mcpRemoveHandler","options","scope","serverBeforeRemoval","cleanupSecureStorage","process","stdout","write","projectConfig","globalConfig","servers","projectServers","mcpJsonExists","scopes","Array","Exclude","mcpServers","push","length","stderr","forEach","Error","message","mcpListHandler","configs","Object","keys","console","log","entries","results","status","concurrency","url","args","isArray","command","join","mcpGetHandler","headers","key","value","oauth","clientId","callbackPort","parts","clientConfig","clientSecret","env","mcpAddJsonHandler","json","parsedJson","needsSecret","transportType","String","source","mcpAddFromDesktopHandler","platform","readClaudeDesktopMcpServers","unmount","exitOnCtrlC","mcpResetChoicesHandler","current","enabledMcpjsonServers","disabledMcpjsonServers","enableAllProjectMcpServers"],"sources":["mcp.tsx"],"sourcesContent":["/**\n * MCP subcommand handlers — extracted from main.tsx for lazy loading.\n * These are dynamically imported only when the corresponding `claude mcp *` command runs.\n */\n\nimport { stat } from 'fs/promises'\nimport pMap from 'p-map'\nimport { cwd } from 'process'\nimport React from 'react'\nimport { MCPServerDesktopImportDialog } from '../../components/MCPServerDesktopImportDialog.js'\nimport { render } from '../../ink.js'\nimport { KeybindingSetup } from '../../keybindings/KeybindingProviderSetup.js'\nimport {\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  logEvent,\n} from '../../services/analytics/index.js'\nimport {\n  clearMcpClientConfig,\n  clearServerTokensFromLocalStorage,\n  getMcpClientConfig,\n  readClientSecret,\n  saveMcpClientSecret,\n} from '../../services/mcp/auth.js'\nimport {\n  connectToServer,\n  getMcpServerConnectionBatchSize,\n} from '../../services/mcp/client.js'\nimport {\n  addMcpConfig,\n  getAllMcpConfigs,\n  getMcpConfigByName,\n  getMcpConfigsByScope,\n  removeMcpConfig,\n} from '../../services/mcp/config.js'\nimport type {\n  ConfigScope,\n  ScopedMcpServerConfig,\n} from '../../services/mcp/types.js'\nimport {\n  describeMcpConfigFilePath,\n  ensureConfigScope,\n  getScopeLabel,\n} from '../../services/mcp/utils.js'\nimport { AppStateProvider } from '../../state/AppState.js'\nimport {\n  getCurrentProjectConfig,\n  getGlobalConfig,\n  saveCurrentProjectConfig,\n} from '../../utils/config.js'\nimport { isFsInaccessible } from '../../utils/errors.js'\nimport { gracefulShutdown } from '../../utils/gracefulShutdown.js'\nimport { safeParseJSON } from '../../utils/json.js'\nimport { getPlatform } from '../../utils/platform.js'\nimport { cliError, cliOk } from '../exit.js'\n\nasync function checkMcpServerHealth(\n  name: string,\n  server: ScopedMcpServerConfig,\n): Promise<string> {\n  try {\n    const result = await connectToServer(name, server)\n    if (result.type === 'connected') {\n      return '✓ Connected'\n    } else if (result.type === 'needs-auth') {\n      return '! Needs authentication'\n    } else {\n      return '✗ Failed to connect'\n    }\n  } catch (_error) {\n    return '✗ Connection error'\n  }\n}\n\n// mcp serve (lines 4512–4532)\nexport async function mcpServeHandler({\n  debug,\n  verbose,\n}: {\n  debug?: boolean\n  verbose?: boolean\n}): Promise<void> {\n  const providedCwd = cwd()\n  logEvent('tengu_mcp_start', {})\n\n  try {\n    await stat(providedCwd)\n  } catch (error) {\n    if (isFsInaccessible(error)) {\n      cliError(`Error: Directory ${providedCwd} does not exist`)\n    }\n    throw error\n  }\n\n  try {\n    const { setup } = await import('../../setup.js')\n    await setup(providedCwd, 'default', false, false, undefined, false)\n    const { startMCPServer } = await import('../../entrypoints/mcp.js')\n    await startMCPServer(providedCwd, debug ?? false, verbose ?? false)\n  } catch (error) {\n    cliError(`Error: Failed to start MCP server: ${error}`)\n  }\n}\n\n// mcp remove (lines 4545–4635)\nexport async function mcpRemoveHandler(\n  name: string,\n  options: { scope?: string },\n): Promise<void> {\n  // Look up config before removing so we can clean up secure storage\n  const serverBeforeRemoval = getMcpConfigByName(name)\n\n  const cleanupSecureStorage = () => {\n    if (\n      serverBeforeRemoval &&\n      (serverBeforeRemoval.type === 'sse' ||\n        serverBeforeRemoval.type === 'http')\n    ) {\n      clearServerTokensFromLocalStorage(name, serverBeforeRemoval)\n      clearMcpClientConfig(name, serverBeforeRemoval)\n    }\n  }\n\n  try {\n    if (options.scope) {\n      const scope = ensureConfigScope(options.scope)\n      logEvent('tengu_mcp_delete', {\n        name: name as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        scope:\n          scope as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      })\n\n      await removeMcpConfig(name, scope)\n      cleanupSecureStorage()\n      process.stdout.write(`Removed MCP server ${name} from ${scope} config\\n`)\n      cliOk(`File modified: ${describeMcpConfigFilePath(scope)}`)\n    }\n\n    // If no scope specified, check where the server exists\n    const projectConfig = getCurrentProjectConfig()\n    const globalConfig = getGlobalConfig()\n\n    // Check if server exists in project scope (.mcp.json)\n    const { servers: projectServers } = getMcpConfigsByScope('project')\n    const mcpJsonExists = !!projectServers[name]\n\n    // Count how many scopes contain this server\n    const scopes: Array<Exclude<ConfigScope, 'dynamic'>> = []\n    if (projectConfig.mcpServers?.[name]) scopes.push('local')\n    if (mcpJsonExists) scopes.push('project')\n    if (globalConfig.mcpServers?.[name]) scopes.push('user')\n\n    if (scopes.length === 0) {\n      cliError(`No MCP server found with name: \"${name}\"`)\n    } else if (scopes.length === 1) {\n      // Server exists in only one scope, remove it\n      const scope = scopes[0]!\n      logEvent('tengu_mcp_delete', {\n        name: name as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        scope:\n          scope as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      })\n\n      await removeMcpConfig(name, scope)\n      cleanupSecureStorage()\n      process.stdout.write(\n        `Removed MCP server \"${name}\" from ${scope} config\\n`,\n      )\n      cliOk(`File modified: ${describeMcpConfigFilePath(scope)}`)\n    } else {\n      // Server exists in multiple scopes\n      process.stderr.write(`MCP server \"${name}\" exists in multiple scopes:\\n`)\n      scopes.forEach(scope => {\n        process.stderr.write(\n          `  - ${getScopeLabel(scope)} (${describeMcpConfigFilePath(scope)})\\n`,\n        )\n      })\n      process.stderr.write('\\nTo remove from a specific scope, use:\\n')\n      scopes.forEach(scope => {\n        process.stderr.write(`  claude mcp remove \"${name}\" -s ${scope}\\n`)\n      })\n      cliError()\n    }\n  } catch (error) {\n    cliError((error as Error).message)\n  }\n}\n\n// mcp list (lines 4641–4688)\nexport async function mcpListHandler(): Promise<void> {\n  logEvent('tengu_mcp_list', {})\n  const { servers: configs } = await getAllMcpConfigs()\n  if (Object.keys(configs).length === 0) {\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(\n      'No MCP servers configured. Use `claude mcp add` to add a server.',\n    )\n  } else {\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log('Checking MCP server health...\\n')\n\n    // Check servers concurrently\n    const entries = Object.entries(configs)\n    const results = await pMap(\n      entries,\n      async ([name, server]) => ({\n        name,\n        server,\n        status: await checkMcpServerHealth(name, server),\n      }),\n      { concurrency: getMcpServerConnectionBatchSize() },\n    )\n\n    for (const { name, server, status } of results) {\n      // Intentionally excluding sse-ide servers here since they're internal\n      if (server.type === 'sse') {\n        // biome-ignore lint/suspicious/noConsole:: intentional console output\n        console.log(`${name}: ${server.url} (SSE) - ${status}`)\n      } else if (server.type === 'http') {\n        // biome-ignore lint/suspicious/noConsole:: intentional console output\n        console.log(`${name}: ${server.url} (HTTP) - ${status}`)\n      } else if (server.type === 'claudeai-proxy') {\n        // biome-ignore lint/suspicious/noConsole:: intentional console output\n        console.log(`${name}: ${server.url} - ${status}`)\n      } else if (!server.type || server.type === 'stdio') {\n        const args = Array.isArray(server.args) ? server.args : []\n        // biome-ignore lint/suspicious/noConsole:: intentional console output\n        console.log(`${name}: ${server.command} ${args.join(' ')} - ${status}`)\n      }\n    }\n  }\n  // Use gracefulShutdown to properly clean up MCP server connections\n  // (process.exit bypasses cleanup handlers, leaving child processes orphaned)\n  await gracefulShutdown(0)\n}\n\n// mcp get (lines 4694–4786)\nexport async function mcpGetHandler(name: string): Promise<void> {\n  logEvent('tengu_mcp_get', {\n    name: name as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  })\n  const server = getMcpConfigByName(name)\n  if (!server) {\n    cliError(`No MCP server found with name: ${name}`)\n  }\n\n  // biome-ignore lint/suspicious/noConsole:: intentional console output\n  console.log(`${name}:`)\n  // biome-ignore lint/suspicious/noConsole:: intentional console output\n  console.log(`  Scope: ${getScopeLabel(server.scope)}`)\n\n  // Check server health\n  const status = await checkMcpServerHealth(name, server)\n  // biome-ignore lint/suspicious/noConsole:: intentional console output\n  console.log(`  Status: ${status}`)\n\n  // Intentionally excluding sse-ide servers here since they're internal\n  if (server.type === 'sse') {\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(`  Type: sse`)\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(`  URL: ${server.url}`)\n    if (server.headers) {\n      // biome-ignore lint/suspicious/noConsole:: intentional console output\n      console.log('  Headers:')\n      for (const [key, value] of Object.entries(server.headers)) {\n        // biome-ignore lint/suspicious/noConsole:: intentional console output\n        console.log(`    ${key}: ${value}`)\n      }\n    }\n    if (server.oauth?.clientId || server.oauth?.callbackPort) {\n      const parts: string[] = []\n      if (server.oauth.clientId) {\n        parts.push('client_id configured')\n        const clientConfig = getMcpClientConfig(name, server)\n        if (clientConfig?.clientSecret) parts.push('client_secret configured')\n      }\n      if (server.oauth.callbackPort)\n        parts.push(`callback_port ${server.oauth.callbackPort}`)\n      // biome-ignore lint/suspicious/noConsole:: intentional console output\n      console.log(`  OAuth: ${parts.join(', ')}`)\n    }\n  } else if (server.type === 'http') {\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(`  Type: http`)\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(`  URL: ${server.url}`)\n    if (server.headers) {\n      // biome-ignore lint/suspicious/noConsole:: intentional console output\n      console.log('  Headers:')\n      for (const [key, value] of Object.entries(server.headers)) {\n        // biome-ignore lint/suspicious/noConsole:: intentional console output\n        console.log(`    ${key}: ${value}`)\n      }\n    }\n    if (server.oauth?.clientId || server.oauth?.callbackPort) {\n      const parts: string[] = []\n      if (server.oauth.clientId) {\n        parts.push('client_id configured')\n        const clientConfig = getMcpClientConfig(name, server)\n        if (clientConfig?.clientSecret) parts.push('client_secret configured')\n      }\n      if (server.oauth.callbackPort)\n        parts.push(`callback_port ${server.oauth.callbackPort}`)\n      // biome-ignore lint/suspicious/noConsole:: intentional console output\n      console.log(`  OAuth: ${parts.join(', ')}`)\n    }\n  } else if (server.type === 'stdio') {\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(`  Type: stdio`)\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(`  Command: ${server.command}`)\n    const args = Array.isArray(server.args) ? server.args : []\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(`  Args: ${args.join(' ')}`)\n    if (server.env) {\n      // biome-ignore lint/suspicious/noConsole:: intentional console output\n      console.log('  Environment:')\n      for (const [key, value] of Object.entries(server.env)) {\n        // biome-ignore lint/suspicious/noConsole:: intentional console output\n        console.log(`    ${key}=${value}`)\n      }\n    }\n  }\n  // biome-ignore lint/suspicious/noConsole:: intentional console output\n  console.log(\n    `\\nTo remove this server, run: claude mcp remove \"${name}\" -s ${server.scope}`,\n  )\n  // Use gracefulShutdown to properly clean up MCP server connections\n  // (process.exit bypasses cleanup handlers, leaving child processes orphaned)\n  await gracefulShutdown(0)\n}\n\n// mcp add-json (lines 4801–4870)\nexport async function mcpAddJsonHandler(\n  name: string,\n  json: string,\n  options: { scope?: string; clientSecret?: true },\n): Promise<void> {\n  try {\n    const scope = ensureConfigScope(options.scope)\n    const parsedJson = safeParseJSON(json)\n\n    // Read secret before writing config so cancellation doesn't leave partial state\n    const needsSecret =\n      options.clientSecret &&\n      parsedJson &&\n      typeof parsedJson === 'object' &&\n      'type' in parsedJson &&\n      (parsedJson.type === 'sse' || parsedJson.type === 'http') &&\n      'url' in parsedJson &&\n      typeof parsedJson.url === 'string' &&\n      'oauth' in parsedJson &&\n      parsedJson.oauth &&\n      typeof parsedJson.oauth === 'object' &&\n      'clientId' in parsedJson.oauth\n    const clientSecret = needsSecret ? await readClientSecret() : undefined\n\n    await addMcpConfig(name, parsedJson, scope)\n\n    const transportType =\n      parsedJson && typeof parsedJson === 'object' && 'type' in parsedJson\n        ? String(parsedJson.type || 'stdio')\n        : 'stdio'\n\n    if (\n      clientSecret &&\n      parsedJson &&\n      typeof parsedJson === 'object' &&\n      'type' in parsedJson &&\n      (parsedJson.type === 'sse' || parsedJson.type === 'http') &&\n      'url' in parsedJson &&\n      typeof parsedJson.url === 'string'\n    ) {\n      saveMcpClientSecret(\n        name,\n        { type: parsedJson.type, url: parsedJson.url },\n        clientSecret,\n      )\n    }\n\n    logEvent('tengu_mcp_add', {\n      scope:\n        scope as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      source:\n        'json' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      type: transportType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n    })\n\n    cliOk(`Added ${transportType} MCP server ${name} to ${scope} config`)\n  } catch (error) {\n    cliError((error as Error).message)\n  }\n}\n\n// mcp add-from-claude-desktop (lines 4881–4927)\nexport async function mcpAddFromDesktopHandler(options: {\n  scope?: string\n}): Promise<void> {\n  try {\n    const scope = ensureConfigScope(options.scope)\n    const platform = getPlatform()\n\n    logEvent('tengu_mcp_add', {\n      scope:\n        scope as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      platform:\n        platform as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      source:\n        'desktop' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n    })\n\n    const { readClaudeDesktopMcpServers } = await import(\n      '../../utils/claudeDesktop.js'\n    )\n    const servers = await readClaudeDesktopMcpServers()\n\n    if (Object.keys(servers).length === 0) {\n      cliOk(\n        'No MCP servers found in Claude Desktop configuration or configuration file does not exist.',\n      )\n    }\n\n    const { unmount } = await render(\n      <AppStateProvider>\n        <KeybindingSetup>\n          <MCPServerDesktopImportDialog\n            servers={servers}\n            scope={scope}\n            onDone={() => {\n              unmount()\n            }}\n          />\n        </KeybindingSetup>\n      </AppStateProvider>,\n      { exitOnCtrlC: true },\n    )\n  } catch (error) {\n    cliError((error as Error).message)\n  }\n}\n\n// mcp reset-project-choices (lines 4935–4952)\nexport async function mcpResetChoicesHandler(): Promise<void> {\n  logEvent('tengu_mcp_reset_mcpjson_choices', {})\n  saveCurrentProjectConfig(current => ({\n    ...current,\n    enabledMcpjsonServers: [],\n    disabledMcpjsonServers: [],\n    enableAllProjectMcpServers: false,\n  }))\n  cliOk(\n    'All project-scoped (.mcp.json) server approvals and rejections have been reset.\\n' +\n      'You will be prompted for approval next time you start Claude Code.',\n  )\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["stat","pMap","cwd","React","MCPServerDesktopImportDialog","render","KeybindingSetup","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","logEvent","clearMcpClientConfig","clearServerTokensFromLocalStorage","getMcpClientConfig","readClientSecret","saveMcpClientSecret","connectToServer","getMcpServerConnectionBatchSize","addMcpConfig","getAllMcpConfigs","getMcpConfigByName","getMcpConfigsByScope","removeMcpConfig","ConfigScope","ScopedMcpServerConfig","describeMcpConfigFilePath","ensureConfigScope","getScopeLabel","AppStateProvider","getCurrentProjectConfig","getGlobalConfig","saveCurrentProjectConfig","isFsInaccessible","gracefulShutdown","safeParseJSON","getPlatform","cliError","cliOk","checkMcpServerHealth","name","server","Promise","result","type","_error","mcpServeHandler","debug","verbose","providedCwd","error","setup","undefined","startMCPServer","mcpRemoveHandler","options","scope","serverBeforeRemoval","cleanupSecureStorage","process","stdout","write","projectConfig","globalConfig","servers","projectServers","mcpJsonExists","scopes","Array","Exclude","mcpServers","push","length","stderr","forEach","Error","message","mcpListHandler","configs","Object","keys","console","log","entries","results","status","concurrency","url","args","isArray","command","join","mcpGetHandler","headers","key","value","oauth","clientId","callbackPort","parts","clientConfig","clientSecret","env","mcpAddJsonHandler","json","parsedJson","needsSecret","transportType","String","source","mcpAddFromDesktopHandler","platform","readClaudeDesktopMcpServers","unmount","exitOnCtrlC","mcpResetChoicesHandler","current","enabledMcpjsonServers","disabledMcpjsonServers","enableAllProjectMcpServers"],"sources":["mcp.tsx"],"sourcesContent":["/**\n * MCP subcommand handlers — extracted from main.tsx for lazy loading.\n * These are dynamically imported only when the corresponding `claude mcp *` command runs.\n */\n\nimport { stat } from 'fs/promises'\nimport pMap from 'p-map'\nimport { cwd } from 'process'\nimport React from 'react'\nimport { MCPServerDesktopImportDialog } from '../../components/MCPServerDesktopImportDialog.js'\nimport { render } from '../../ink.js'\nimport { KeybindingSetup } from '../../keybindings/KeybindingProviderSetup.js'\nimport {\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  logEvent,\n} from '../../services/analytics/index.js'\nimport {\n  clearMcpClientConfig,\n  clearServerTokensFromLocalStorage,\n  getMcpClientConfig,\n  readClientSecret,\n  saveMcpClientSecret,\n} from '../../services/mcp/auth.js'\nimport {\n  connectToServer,\n  getMcpServerConnectionBatchSize,\n} from '../../services/mcp/client.js'\nimport {\n  addMcpConfig,\n  getAllMcpConfigs,\n  getMcpConfigByName,\n  getMcpConfigsByScope,\n  removeMcpConfig,\n} from '../../services/mcp/config.js'\nimport type {\n  ConfigScope,\n  ScopedMcpServerConfig,\n} from '../../services/mcp/types.js'\nimport {\n  describeMcpConfigFilePath,\n  ensureConfigScope,\n  getScopeLabel,\n} from '../../services/mcp/utils.js'\nimport { AppStateProvider } from '../../state/AppState.js'\nimport {\n  getCurrentProjectConfig,\n  getGlobalConfig,\n  saveCurrentProjectConfig,\n} from '../../utils/config.js'\nimport { isFsInaccessible } from '../../utils/errors.js'\nimport { gracefulShutdown } from '../../utils/gracefulShutdown.js'\nimport { safeParseJSON } from '../../utils/json.js'\nimport { getPlatform } from '../../utils/platform.js'\nimport { cliError, cliOk } from '../exit.js'\n\nasync function checkMcpServerHealth(\n  name: string,\n  server: ScopedMcpServerConfig,\n): Promise<string> {\n  try {\n    const result = await connectToServer(name, server)\n    if (result.type === 'connected') {\n      return '✓ Connected'\n    } else if (result.type === 'needs-auth') {\n      return '! Needs authentication'\n    } else {\n      return '✗ Failed to connect'\n    }\n  } catch (_error) {\n    return '✗ Connection error'\n  }\n}\n\n// mcp serve (lines 4512–4532)\nexport async function mcpServeHandler({\n  debug,\n  verbose,\n}: {\n  debug?: boolean\n  verbose?: boolean\n}): Promise<void> {\n  const providedCwd = cwd()\n  logEvent('tengu_mcp_start', {})\n\n  try {\n    await stat(providedCwd)\n  } catch (error) {\n    if (isFsInaccessible(error)) {\n      cliError(`Error: Directory ${providedCwd} does not exist`)\n    }\n    throw error\n  }\n\n  try {\n    const { setup } = await import('../../setup.js')\n    await setup(providedCwd, 'default', false, false, undefined, false)\n    const { startMCPServer } = await import('../../entrypoints/mcp.js')\n    await startMCPServer(providedCwd, debug ?? false, verbose ?? false)\n  } catch (error) {\n    cliError(`Error: Failed to start MCP server: ${error}`)\n  }\n}\n\n// mcp remove (lines 4545–4635)\nexport async function mcpRemoveHandler(\n  name: string,\n  options: { scope?: string },\n): Promise<void> {\n  // Look up config before removing so we can clean up secure storage\n  const serverBeforeRemoval = getMcpConfigByName(name)\n\n  const cleanupSecureStorage = () => {\n    if (\n      serverBeforeRemoval &&\n      (serverBeforeRemoval.type === 'sse' ||\n        serverBeforeRemoval.type === 'http')\n    ) {\n      clearServerTokensFromLocalStorage(name, serverBeforeRemoval)\n      clearMcpClientConfig(name, serverBeforeRemoval)\n    }\n  }\n\n  try {\n    if (options.scope) {\n      const scope = ensureConfigScope(options.scope)\n      logEvent('tengu_mcp_delete', {\n        name: name as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        scope:\n          scope as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      })\n\n      await removeMcpConfig(name, scope)\n      cleanupSecureStorage()\n      process.stdout.write(`Removed MCP server ${name} from ${scope} config\\n`)\n      cliOk(`File modified: ${describeMcpConfigFilePath(scope)}`)\n    }\n\n    // If no scope specified, check where the server exists\n    const projectConfig = getCurrentProjectConfig()\n    const globalConfig = getGlobalConfig()\n\n    // Check if server exists in project scope (.mcp.json)\n    const { servers: projectServers } = getMcpConfigsByScope('project')\n    const mcpJsonExists = !!projectServers[name]\n\n    // Count how many scopes contain this server\n    const scopes: Array<Exclude<ConfigScope, 'dynamic'>> = []\n    if (projectConfig.mcpServers?.[name]) scopes.push('local')\n    if (mcpJsonExists) scopes.push('project')\n    if (globalConfig.mcpServers?.[name]) scopes.push('user')\n\n    if (scopes.length === 0) {\n      cliError(`No MCP server found with name: \"${name}\"`)\n    } else if (scopes.length === 1) {\n      // Server exists in only one scope, remove it\n      const scope = scopes[0]!\n      logEvent('tengu_mcp_delete', {\n        name: name as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        scope:\n          scope as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      })\n\n      await removeMcpConfig(name, scope)\n      cleanupSecureStorage()\n      process.stdout.write(\n        `Removed MCP server \"${name}\" from ${scope} config\\n`,\n      )\n      cliOk(`File modified: ${describeMcpConfigFilePath(scope)}`)\n    } else {\n      // Server exists in multiple scopes\n      process.stderr.write(`MCP server \"${name}\" exists in multiple scopes:\\n`)\n      scopes.forEach(scope => {\n        process.stderr.write(\n          `  - ${getScopeLabel(scope)} (${describeMcpConfigFilePath(scope)})\\n`,\n        )\n      })\n      process.stderr.write('\\nTo remove from a specific scope, use:\\n')\n      scopes.forEach(scope => {\n        process.stderr.write(`  claude mcp remove \"${name}\" -s ${scope}\\n`)\n      })\n      cliError()\n    }\n  } catch (error) {\n    cliError((error as Error).message)\n  }\n}\n\n// mcp list (lines 4641–4688)\nexport async function mcpListHandler(): Promise<void> {\n  logEvent('tengu_mcp_list', {})\n  const { servers: configs } = await getAllMcpConfigs()\n  if (Object.keys(configs).length === 0) {\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(\n      'No MCP servers configured. Use `claude mcp add` to add a server.',\n    )\n  } else {\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log('Checking MCP server health...\\n')\n\n    // Check servers concurrently\n    const entries = Object.entries(configs)\n    const results = await pMap(\n      entries,\n      async ([name, server]) => ({\n        name,\n        server,\n        status: await checkMcpServerHealth(name, server),\n      }),\n      { concurrency: getMcpServerConnectionBatchSize() },\n    )\n\n    for (const { name, server, status } of results) {\n      // Intentionally excluding sse-ide servers here since they're internal\n      if (server.type === 'sse') {\n        // biome-ignore lint/suspicious/noConsole:: intentional console output\n        console.log(`${name}: ${server.url} (SSE) - ${status}`)\n      } else if (server.type === 'http') {\n        // biome-ignore lint/suspicious/noConsole:: intentional console output\n        console.log(`${name}: ${server.url} (HTTP) - ${status}`)\n      } else if (server.type === 'claudeai-proxy') {\n        // biome-ignore lint/suspicious/noConsole:: intentional console output\n        console.log(`${name}: ${server.url} - ${status}`)\n      } else if (!server.type || server.type === 'stdio') {\n        const args = Array.isArray(server.args) ? server.args : []\n        // biome-ignore lint/suspicious/noConsole:: intentional console output\n        console.log(`${name}: ${server.command} ${args.join(' ')} - ${status}`)\n      }\n    }\n  }\n  // Use gracefulShutdown to properly clean up MCP server connections\n  // (process.exit bypasses cleanup handlers, leaving child processes orphaned)\n  await gracefulShutdown(0)\n}\n\n// mcp get (lines 4694–4786)\nexport async function mcpGetHandler(name: string): Promise<void> {\n  logEvent('tengu_mcp_get', {\n    name: name as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  })\n  const server = getMcpConfigByName(name)\n  if (!server) {\n    cliError(`No MCP server found with name: ${name}`)\n  }\n\n  // biome-ignore lint/suspicious/noConsole:: intentional console output\n  console.log(`${name}:`)\n  // biome-ignore lint/suspicious/noConsole:: intentional console output\n  console.log(`  Scope: ${getScopeLabel(server.scope)}`)\n\n  // Check server health\n  const status = await checkMcpServerHealth(name, server)\n  // biome-ignore lint/suspicious/noConsole:: intentional console output\n  console.log(`  Status: ${status}`)\n\n  // Intentionally excluding sse-ide servers here since they're internal\n  if (server.type === 'sse') {\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(`  Type: sse`)\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(`  URL: ${server.url}`)\n    if (server.headers) {\n      // biome-ignore lint/suspicious/noConsole:: intentional console output\n      console.log('  Headers:')\n      for (const [key, value] of Object.entries(server.headers)) {\n        // biome-ignore lint/suspicious/noConsole:: intentional console output\n        console.log(`    ${key}: ${value}`)\n      }\n    }\n    if (server.oauth?.clientId || server.oauth?.callbackPort) {\n      const parts: string[] = []\n      if (server.oauth.clientId) {\n        parts.push('client_id configured')\n        const clientConfig = getMcpClientConfig(name, server)\n        if (clientConfig?.clientSecret) parts.push('client_secret configured')\n      }\n      if (server.oauth.callbackPort)\n        parts.push(`callback_port ${server.oauth.callbackPort}`)\n      // biome-ignore lint/suspicious/noConsole:: intentional console output\n      console.log(`  OAuth: ${parts.join(', ')}`)\n    }\n  } else if (server.type === 'http') {\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(`  Type: http`)\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(`  URL: ${server.url}`)\n    if (server.headers) {\n      // biome-ignore lint/suspicious/noConsole:: intentional console output\n      console.log('  Headers:')\n      for (const [key, value] of Object.entries(server.headers)) {\n        // biome-ignore lint/suspicious/noConsole:: intentional console output\n        console.log(`    ${key}: ${value}`)\n      }\n    }\n    if (server.oauth?.clientId || server.oauth?.callbackPort) {\n      const parts: string[] = []\n      if (server.oauth.clientId) {\n        parts.push('client_id configured')\n        const clientConfig = getMcpClientConfig(name, server)\n        if (clientConfig?.clientSecret) parts.push('client_secret configured')\n      }\n      if (server.oauth.callbackPort)\n        parts.push(`callback_port ${server.oauth.callbackPort}`)\n      // biome-ignore lint/suspicious/noConsole:: intentional console output\n      console.log(`  OAuth: ${parts.join(', ')}`)\n    }\n  } else if (server.type === 'stdio') {\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(`  Type: stdio`)\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(`  Command: ${server.command}`)\n    const args = Array.isArray(server.args) ? server.args : []\n    // biome-ignore lint/suspicious/noConsole:: intentional console output\n    console.log(`  Args: ${args.join(' ')}`)\n    if (server.env) {\n      // biome-ignore lint/suspicious/noConsole:: intentional console output\n      console.log('  Environment:')\n      for (const [key, value] of Object.entries(server.env)) {\n        // biome-ignore lint/suspicious/noConsole:: intentional console output\n        console.log(`    ${key}=${value}`)\n      }\n    }\n  }\n  // biome-ignore lint/suspicious/noConsole:: intentional console output\n  console.log(\n    `\\nTo remove this server, run: claude mcp remove \"${name}\" -s ${server.scope}`,\n  )\n  // Use gracefulShutdown to properly clean up MCP server connections\n  // (process.exit bypasses cleanup handlers, leaving child processes orphaned)\n  await gracefulShutdown(0)\n}\n\n// mcp add-json (lines 4801–4870)\nexport async function mcpAddJsonHandler(\n  name: string,\n  json: string,\n  options: { scope?: string; clientSecret?: true },\n): Promise<void> {\n  try {\n    const scope = ensureConfigScope(options.scope)\n    const parsedJson = safeParseJSON(json)\n\n    // Read secret before writing config so cancellation doesn't leave partial state\n    const needsSecret =\n      options.clientSecret &&\n      parsedJson &&\n      typeof parsedJson === 'object' &&\n      'type' in parsedJson &&\n      (parsedJson.type === 'sse' || parsedJson.type === 'http') &&\n      'url' in parsedJson &&\n      typeof parsedJson.url === 'string' &&\n      'oauth' in parsedJson &&\n      parsedJson.oauth &&\n      typeof parsedJson.oauth === 'object' &&\n      'clientId' in parsedJson.oauth\n    const clientSecret = needsSecret ? await readClientSecret() : undefined\n\n    await addMcpConfig(name, parsedJson, scope)\n\n    const transportType =\n      parsedJson && typeof parsedJson === 'object' && 'type' in parsedJson\n        ? String(parsedJson.type || 'stdio')\n        : 'stdio'\n\n    if (\n      clientSecret &&\n      parsedJson &&\n      typeof parsedJson === 'object' &&\n      'type' in parsedJson &&\n      (parsedJson.type === 'sse' || parsedJson.type === 'http') &&\n      'url' in parsedJson &&\n      typeof parsedJson.url === 'string'\n    ) {\n      saveMcpClientSecret(\n        name,\n        { type: parsedJson.type, url: parsedJson.url },\n        clientSecret,\n      )\n    }\n\n    logEvent('tengu_mcp_add', {\n      scope:\n        scope as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      source:\n        'json' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      type: transportType as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n    })\n\n    cliOk(`Added ${transportType} MCP server ${name} to ${scope} config`)\n  } catch (error) {\n    cliError((error as Error).message)\n  }\n}\n\n// mcp add-from-claude-desktop (lines 4881–4927)\nexport async function mcpAddFromDesktopHandler(options: {\n  scope?: string\n}): Promise<void> {\n  try {\n    const scope = ensureConfigScope(options.scope)\n    const platform = getPlatform()\n\n    logEvent('tengu_mcp_add', {\n      scope:\n        scope as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      platform:\n        platform as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      source:\n        'desktop' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n    })\n\n    const { readClaudeDesktopMcpServers } = await import(\n      '../../utils/claudeDesktop.js'\n    )\n    const servers = await readClaudeDesktopMcpServers()\n\n    if (Object.keys(servers).length === 0) {\n      cliOk(\n        'No MCP servers found in Claude Desktop configuration or configuration file does not exist.',\n      )\n    }\n\n    const { unmount } = await render(\n      <AppStateProvider>\n        <KeybindingSetup>\n          <MCPServerDesktopImportDialog\n            servers={servers}\n            scope={scope}\n            onDone={() => {\n              unmount()\n            }}\n          />\n        </KeybindingSetup>\n      </AppStateProvider>,\n      { exitOnCtrlC: true },\n    )\n  } catch (error) {\n    cliError((error as Error).message)\n  }\n}\n\n// mcp reset-project-choices (lines 4935–4952)\nexport async function mcpResetChoicesHandler(): Promise<void> {\n  logEvent('tengu_mcp_reset_mcpjson_choices', {})\n  saveCurrentProjectConfig(current => ({\n    ...current,\n    enabledMcpjsonServers: [],\n    disabledMcpjsonServers: [],\n    enableAllProjectMcpServers: false,\n  }))\n  cliOk(\n    'All project-scoped (.mcp.json) server approvals and rejections have been reset.\\n' +\n      'You will be prompted for approval next time you start Claude Code.',\n  )\n}\n"],"mappings":"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","ignoreList":[]} diff --git a/src/commands/mcp/doctorCommand.test.ts b/src/commands/mcp/doctorCommand.test.ts new file mode 100644 index 00000000..8e4754c4 --- /dev/null +++ b/src/commands/mcp/doctorCommand.test.ts @@ -0,0 +1,19 @@ +import assert from 'node:assert/strict' +import test from 'node:test' + +import { Command } from '@commander-js/extra-typings' + +import { registerMcpDoctorCommand } from './doctorCommand.js' + +test('registerMcpDoctorCommand adds the doctor subcommand with expected options', () => { + const mcp = new Command('mcp') + + registerMcpDoctorCommand(mcp) + + const doctor = mcp.commands.find(command => command.name() === 'doctor') + assert.ok(doctor) + assert.equal(doctor?.usage(), '[options] [name]') + + const optionFlags = doctor?.options.map(option => option.long) + assert.deepEqual(optionFlags, ['--scope', '--config-only', '--json']) +}) diff --git a/src/commands/mcp/doctorCommand.ts b/src/commands/mcp/doctorCommand.ts new file mode 100644 index 00000000..75ed6a10 --- /dev/null +++ b/src/commands/mcp/doctorCommand.ts @@ -0,0 +1,25 @@ +/** + * MCP doctor CLI subcommand. + */ +import { type Command } from '@commander-js/extra-typings' + +export function registerMcpDoctorCommand(mcp: Command): void { + mcp + .command('doctor [name]') + .description( + 'Diagnose MCP configuration, precedence, disabled/pending state, and connection health. ' + + 'Note: unless --config-only is used, stdio servers may be spawned and remote servers may be contacted. ' + + 'Only use this command in directories you trust.', + ) + .option('-s, --scope ', 'Restrict config analysis to a specific scope (local, project, user, or enterprise)') + .option('--config-only', 'Skip live connection checks and only analyze configuration state') + .option('--json', 'Output the diagnostics report as JSON') + .action(async (name: string | undefined, options: { + scope?: string + configOnly?: boolean + json?: boolean + }) => { + const { mcpDoctorHandler } = await import('../../cli/handlers/mcp.js') + await mcpDoctorHandler(name, options) + }) +} diff --git a/src/main.tsx b/src/main.tsx index 07a3a3d2..9988dea7 100644 --- a/src/main.tsx +++ b/src/main.tsx @@ -139,6 +139,7 @@ import { validateUuid } from './utils/uuid.js'; // Plugin startup checks are now handled non-blockingly in REPL.tsx import { registerMcpAddCommand } from 'src/commands/mcp/addCommand.js'; +import { registerMcpDoctorCommand } from 'src/commands/mcp/doctorCommand.js'; import { registerMcpXaaIdpCommand } from 'src/commands/mcp/xaaIdpCommand.js'; import { logPermissionContextForAnts } from 'src/services/internalLogging.js'; import { fetchClaudeAIMcpConfigsIfEligible } from 'src/services/mcp/claudeai.js'; @@ -3887,6 +3888,7 @@ async function run(): Promise { // Register the mcp add subcommand (extracted for testability) registerMcpAddCommand(mcp); + registerMcpDoctorCommand(mcp); if (isXaaEnabled()) { registerMcpXaaIdpCommand(mcp); } From fb27164ddfb9d4260bda7e1bd45f7c5361927073 Mon Sep 17 00:00:00 2001 From: gnanam1990 Date: Thu, 2 Apr 2026 14:55:05 +0530 Subject: [PATCH 3/3] fix(mcp): await failed transport cleanup on Windows Wait for failed MCP transport cleanup before command exit so targeted live checks do not crash on Windows. Co-Authored-By: Claude --- src/services/mcp/client.test.ts | 48 +++++++++++++++++++++++++++++++++ src/services/mcp/client.ts | 25 +++++++++++++---- 2 files changed, 68 insertions(+), 5 deletions(-) create mode 100644 src/services/mcp/client.test.ts diff --git a/src/services/mcp/client.test.ts b/src/services/mcp/client.test.ts new file mode 100644 index 00000000..6f69ee7b --- /dev/null +++ b/src/services/mcp/client.test.ts @@ -0,0 +1,48 @@ +import assert from 'node:assert/strict' +import test from 'node:test' + +import { cleanupFailedConnection } from './client.js' + +test('cleanupFailedConnection awaits transport close before resolving', async () => { + let closed = false + let resolveClose: (() => void) | undefined + + const transport = { + close: async () => + await new Promise(resolve => { + resolveClose = () => { + closed = true + resolve() + } + }), + } + + const cleanupPromise = cleanupFailedConnection(transport) + + assert.equal(closed, false) + resolveClose?.() + await cleanupPromise + assert.equal(closed, true) +}) + +test('cleanupFailedConnection closes in-process server and transport', async () => { + let inProcessClosed = false + let transportClosed = false + + const inProcessServer = { + close: async () => { + inProcessClosed = true + }, + } + + const transport = { + close: async () => { + transportClosed = true + }, + } + + await cleanupFailedConnection(transport, inProcessServer) + + assert.equal(inProcessClosed, true) + assert.equal(transportClosed, true) +}) diff --git a/src/services/mcp/client.ts b/src/services/mcp/client.ts index b053dbb6..8857b56c 100644 --- a/src/services/mcp/client.ts +++ b/src/services/mcp/client.ts @@ -560,6 +560,22 @@ function getRemoteMcpServerConnectionBatchSize(): number { ) } +type InProcessMcpServer = { + connect(t: Transport): Promise + close(): Promise +} + +export async function cleanupFailedConnection( + transport: Pick, + inProcessServer?: Pick, +): Promise { + if (inProcessServer) { + await inProcessServer.close().catch(() => {}) + } + + await transport.close().catch(() => {}) +} + function isLocalMcpServer(config: ScopedMcpServerConfig): boolean { return !config.type || config.type === 'stdio' || config.type === 'sdk' } @@ -606,9 +622,7 @@ export const connectToServer = memoize( }, ): Promise => { const connectStartTime = Date.now() - let inProcessServer: - | { connect(t: Transport): Promise; close(): Promise } - | undefined + let inProcessServer: InProcessMcpServer | undefined try { let transport @@ -1145,9 +1159,10 @@ export const connectToServer = memoize( }) } if (inProcessServer) { - inProcessServer.close().catch(() => { }) + await cleanupFailedConnection(transport, inProcessServer) + } else { + await cleanupFailedConnection(transport) } - transport.close().catch(() => { }) if (stderrOutput) { logMCPError(name, `Server stderr: ${stderrOutput}`) }