mcp-medic 1.0.0

package/dist/discovery.js

@@ -0,0 +1,76 @@
+import { existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { homedir, platform } from 'node:os';
+/**
+ * Auto-discovers common MCP config locations based on OS and current working directory.
+ * Returns only configs that exist on disk.
+ */
+export function discoverConfigFiles(cwd = process.cwd()) {
+    const osPlatform = platform();
+    const home = homedir();
+    const candidates = [];
+    // 1. Current working directory configs (highest precedence for local projects)
+    candidates.push({ path: resolve(cwd, '.mcp.json'), label: 'Project (.mcp.json)' }, { path: resolve(cwd, 'mcp.json'), label: 'Project (mcp.json)' }, { path: resolve(cwd, '.vscode/mcp.json'), label: 'VS Code workspace (.vscode/mcp.json)' }, { path: resolve(cwd, '.cursor/mcp.json'), label: 'Cursor workspace (.cursor/mcp.json)' });
+    // 2. Claude Desktop config path per OS
+    if (osPlatform === 'darwin') {
+        candidates.push({
+            path: join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json'),
+            label: 'Claude Desktop (macOS)',
+        });
+    }
+    else if (osPlatform === 'win32') {
+        const appData = process.env.APPDATA ?? join(home, 'AppData', 'Roaming');
+        candidates.push({
+            path: join(appData, 'Claude', 'claude_desktop_config.json'),
+            label: 'Claude Desktop (Windows)',
+        });
+    }
+    else {
+        // Linux and other POSIX
+        const configDir = process.env.XDG_CONFIG_HOME ?? join(home, '.config');
+        candidates.push({
+            path: join(configDir, 'Claude', 'claude_desktop_config.json'),
+            label: 'Claude Desktop (Linux)',
+        });
+    }
+    // 3. User-level VS Code & Cursor settings
+    if (osPlatform === 'darwin') {
+        candidates.push({
+            path: join(home, 'Library', 'Application Support', 'Code', 'User', 'settings.json'),
+            label: 'VS Code User Settings (macOS)',
+        }, {
+            path: join(home, 'Library', 'Application Support', 'Cursor', 'User', 'settings.json'),
+            label: 'Cursor User Settings (macOS)',
+        });
+    }
+    else if (osPlatform === 'win32') {
+        const appData = process.env.APPDATA ?? join(home, 'AppData', 'Roaming');
+        candidates.push({
+            path: join(appData, 'Code', 'User', 'settings.json'),
+            label: 'VS Code User Settings (Windows)',
+        }, {
+            path: join(appData, 'Cursor', 'User', 'settings.json'),
+            label: 'Cursor User Settings (Windows)',
+        });
+    }
+    else {
+        const configDir = process.env.XDG_CONFIG_HOME ?? join(home, '.config');
+        candidates.push({
+            path: join(configDir, 'Code', 'User', 'settings.json'),
+            label: 'VS Code User Settings (Linux)',
+        }, {
+            path: join(configDir, 'Cursor', 'User', 'settings.json'),
+            label: 'Cursor User Settings (Linux)',
+        });
+    }
+    // Filter to paths that actually exist
+    const existing = [];
+    const seenPaths = new Set();
+    for (const candidate of candidates) {
+        if (existsSync(candidate.path) && !seenPaths.has(candidate.path)) {
+            seenPaths.add(candidate.path);
+            existing.push(candidate);
+        }
+    }
+    return existing;
+}

package/dist/extension/index.d.ts

@@ -0,0 +1,79 @@
+import type { Severity } from '../types.js';
+export interface MinimalPosition {
+    line: number;
+    character: number;
+}
+export interface MinimalRange {
+    start: MinimalPosition;
+    end: MinimalPosition;
+}
+export interface MinimalDiagnostic {
+    range: MinimalRange;
+    message: string;
+    severity: number;
+    source: string;
+    code?: string;
+    suggestedFix?: string;
+}
+export interface MinimalTextDocument {
+    uri: {
+        toString(): string;
+        fsPath: string;
+    };
+    fileName: string;
+    getText(): string;
+    languageId: string;
+}
+export interface MinimalDiagnosticCollection {
+    set(uri: unknown, diagnostics: MinimalDiagnostic[]): void;
+    delete(uri: unknown): void;
+    clear(): void;
+    dispose(): void;
+}
+export interface MinimalVSCodeAPI {
+    DiagnosticSeverity: {
+        Error: number;
+        Warning: number;
+        Information: number;
+        Hint: number;
+    };
+    Range: new (startLine: number, startChar: number, endLine: number, endChar: number) => MinimalRange;
+    Position: new (line: number, character: number) => MinimalPosition;
+    languages: {
+        createDiagnosticCollection(name: string): MinimalDiagnosticCollection;
+        registerHoverProvider(selector: unknown, provider: {
+            provideHover(document: MinimalTextDocument, position: MinimalPosition): unknown;
+        }): {
+            dispose(): void;
+        };
+    };
+    workspace: {
+        onDidChangeTextDocument(listener: (e: {
+            document: MinimalTextDocument;
+        }) => void): {
+            dispose(): void;
+        };
+        onDidOpenTextDocument(listener: (document: MinimalTextDocument) => void): {
+            dispose(): void;
+        };
+        onDidSaveTextDocument(listener: (document: MinimalTextDocument) => void): {
+            dispose(): void;
+        };
+    };
+}
+export declare function isMCPConfigFile(fileName: string): boolean;
+export declare function mapSeverity(severity: Severity, vscode: MinimalVSCodeAPI): number;
+/**
+ * Validates a document content using mcp-doctor core and returns VS Code diagnostics.
+ */
+export declare function validateMCPDocument(document: MinimalTextDocument, vscode: MinimalVSCodeAPI): Promise<MinimalDiagnostic[]>;
+/**
+ * Activates the lightweight MCP Doctor extension.
+ */
+export declare function activateExtension(context: {
+    subscriptions: {
+        dispose(): void;
+    }[];
+}, vscode: MinimalVSCodeAPI): {
+    diagnosticCollection: MinimalDiagnosticCollection;
+};

package/dist/extension/index.js

@@ -0,0 +1,125 @@
+import { loadConfig } from '../config-loader.js';
+import { runChecks } from '../orchestrator.js';
+import { allChecks } from '../checks/index.js';
+export function isMCPConfigFile(fileName) {
+    const lower = fileName.toLowerCase();
+    return (lower.endsWith('.mcp.json') ||
+        lower.endsWith('mcp.json') ||
+        lower.endsWith('claude_desktop_config.json') ||
+        lower.includes('.vscode/mcp.json') ||
+        lower.includes('.cursor/mcp.json'));
+}
+function findLineForScope(text, serverName, toolName) {
+    const lines = text.split('\n');
+    if (toolName) {
+        const toolIndex = lines.findIndex((l) => l.includes(`"${toolName}"`));
+        if (toolIndex >= 0)
+            return toolIndex;
+    }
+    const serverIndex = lines.findIndex((l) => l.includes(`"${serverName}"`));
+    if (serverIndex >= 0)
+        return serverIndex;
+    return 0;
+}
+export function mapSeverity(severity, vscode) {
+    switch (severity) {
+        case 'error':
+            return vscode.DiagnosticSeverity.Error;
+        case 'warning':
+            return vscode.DiagnosticSeverity.Warning;
+        case 'info':
+        default:
+            return vscode.DiagnosticSeverity.Information;
+    }
+}
+/**
+ * Validates a document content using mcp-doctor core and returns VS Code diagnostics.
+ */
+export async function validateMCPDocument(document, vscode) {
+    if (!isMCPConfigFile(document.fileName)) {
+        return [];
+    }
+    const rawText = document.getText();
+    let rawJson;
+    try {
+        rawJson = JSON.parse(rawText);
+    }
+    catch (parseErr) {
+        return [
+            {
+                range: new vscode.Range(0, 0, 0, 1),
+                message: `JSON syntax error in MCP config: ${parseErr instanceof Error ? parseErr.message : String(parseErr)}`,
+                severity: vscode.DiagnosticSeverity.Error,
+                source: 'mcp-doctor',
+                code: 'config.parse-error',
+            },
+        ];
+    }
+    const { config, errors } = loadConfig(rawJson, document.fileName);
+    if (errors.length > 0 || !config) {
+        return errors.map((errMessage) => ({
+            range: new vscode.Range(0, 0, 0, 1),
+            message: errMessage,
+            severity: vscode.DiagnosticSeverity.Error,
+            source: 'mcp-doctor',
+            code: 'config.invalid-schema',
+        }));
+    }
+    const report = await runChecks(config, { checks: allChecks, timeoutMs: 3000 });
+    const diagnostics = [];
+    for (const d of report.diagnostics) {
+        const line = findLineForScope(rawText, d.serverName, d.toolName);
+        const lineContent = rawText.split('\n')[line] || '';
+        const endChar = Math.max(1, lineContent.length);
+        let message = d.message;
+        if (d.suggestedFix?.description) {
+            message += `\n\nSuggested fix: ${d.suggestedFix.description}`;
+        }
+        diagnostics.push({
+            range: new vscode.Range(line, 0, line, endChar),
+            message,
+            severity: mapSeverity(d.severity, vscode),
+            source: 'mcp-doctor',
+            code: d.checkId,
+            suggestedFix: d.suggestedFix?.description,
+        });
+    }
+    return diagnostics;
+}
+/**
+ * Activates the lightweight MCP Doctor extension.
+ */
+export function activateExtension(context, vscode) {
+    const collection = vscode.languages.createDiagnosticCollection('mcp-doctor');
+    context.subscriptions.push(collection);
+    let debounceTimer;
+    const triggerValidation = (document) => {
+        if (!isMCPConfigFile(document.fileName))
+            return;
+        if (debounceTimer)
+            clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(async () => {
+            const diagnostics = await validateMCPDocument(document, vscode);
+            collection.set(document.uri, diagnostics);
+        }, 250);
+    };
+    context.subscriptions.push(vscode.workspace.onDidOpenTextDocument((doc) => triggerValidation(doc)), vscode.workspace.onDidChangeTextDocument((e) => triggerValidation(e.document)), vscode.workspace.onDidSaveTextDocument((doc) => triggerValidation(doc)));
+    // Register hover tooltip provider showing full diagnostic message + suggested fix
+    const hoverProvider = vscode.languages.registerHoverProvider({ pattern: '**/*{mcp,claude}*.json' }, {
+        provideHover(document, position) {
+            if (!isMCPConfigFile(document.fileName))
+                return undefined;
+            const line = position.line;
+            const lines = document.getText().split('\n');
+            const currentLineText = lines[line] || '';
+            return {
+                contents: [
+                    `**mcp-doctor diagnostic** (Line ${line + 1})`,
+                    `Inspecting: \`${currentLineText.trim()}\``,
+                ],
+            };
+        },
+    });
+    context.subscriptions.push(hoverProvider);
+    return { diagnosticCollection: collection };
+}

package/dist/fleet.d.ts

@@ -0,0 +1,48 @@
+import type { MCPConfig, RunReport, RunOptions } from './types.js';
+export interface FileRunResult {
+    filePath: string;
+    report?: RunReport;
+    error?: string;
+}
+export interface FleetReport {
+    totalFiles: number;
+    successfulFiles: number;
+    failedFiles: number;
+    totalServers: number;
+    totalErrors: number;
+    totalWarnings: number;
+    fileResults: FileRunResult[];
+}
+export interface ConfigDiffEntry {
+    serverName: string;
+    kind: 'added' | 'removed' | 'modified';
+    changes?: {
+        field: string;
+        from: unknown;
+        to: unknown;
+    }[];
+}
+export interface ConfigDiffResult {
+    configAPath?: string;
+    configBPath?: string;
+    identical: boolean;
+    entries: ConfigDiffEntry[];
+}
+/**
+ * Discovers config files matching a glob or pattern.
+ */
+export declare function findConfigFiles(globOrPattern: string, rootDir?: string): string[];
+/**
+ * Runs validation checks across all matching configuration files.
+ */
+export declare function runFleetChecks(globPattern: string, options?: RunOptions & {
+    cwd?: string;
+}): Promise<FleetReport>;
+/**
+ * Compares two MCP configurations to identify server and attribute drift.
+ */
+export declare function diffConfigs(configA: MCPConfig, configB: MCPConfig): ConfigDiffResult;
+/**
+ * Filters diagnostics against a baseline snapshot, reporting only newly introduced issues.
+ */
+export declare function filterDiagnosticsByBaseline(currentReport: RunReport, baselineReport: RunReport): RunReport;

package/dist/fleet.js

@@ -0,0 +1,153 @@
+import { readdirSync, statSync, readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { loadConfig } from './config-loader.js';
+import { runChecks } from './orchestrator.js';
+import { allChecks } from './checks/index.js';
+function findFilesMatching(dir, pattern, results = []) {
+    if (!existsSync(dir))
+        return results;
+    const entries = readdirSync(dir);
+    for (const entry of entries) {
+        if (entry === 'node_modules' || entry === '.git' || entry === 'dist')
+            continue;
+        const fullPath = join(dir, entry);
+        try {
+            const stat = statSync(fullPath);
+            if (stat.isDirectory()) {
+                findFilesMatching(fullPath, pattern, results);
+            }
+            else if (stat.isFile() && pattern.test(fullPath)) {
+                results.push(fullPath);
+            }
+        }
+        catch {
+            // ignore access errors
+        }
+    }
+    return results;
+}
+/**
+ * Discovers config files matching a glob or pattern.
+ */
+export function findConfigFiles(globOrPattern, rootDir = process.cwd()) {
+    // Simple glob converter
+    const regexStr = globOrPattern
+        .replace(/\./g, '\\.')
+        .replace(/\*\*/g, '.*')
+        .replace(/\*/g, '[^/]*');
+    const regex = new RegExp(`${regexStr}$`);
+    return findFilesMatching(rootDir, regex);
+}
+/**
+ * Runs validation checks across all matching configuration files.
+ */
+export async function runFleetChecks(globPattern, options = {}) {
+    const root = options.cwd ?? process.cwd();
+    const filePaths = findConfigFiles(globPattern, root);
+    const fileResults = [];
+    let totalServers = 0;
+    let totalErrors = 0;
+    let totalWarnings = 0;
+    for (const filePath of filePaths) {
+        try {
+            const rawText = readFileSync(filePath, 'utf-8');
+            const rawJson = JSON.parse(rawText);
+            const { config, errors } = loadConfig(rawJson, filePath);
+            if (errors.length > 0 || !config) {
+                fileResults.push({
+                    filePath,
+                    error: `Config validation failed: ${errors.join(', ')}`,
+                });
+                totalErrors += errors.length;
+                continue;
+            }
+            const checks = options.checks ?? allChecks;
+            const report = await runChecks(config, { ...options, checks });
+            fileResults.push({ filePath, report });
+            totalServers += report.summary.servers;
+            totalErrors += report.summary.errors;
+            totalWarnings += report.summary.warnings;
+        }
+        catch (err) {
+            fileResults.push({
+                filePath,
+                error: `Could not process file: ${err instanceof Error ? err.message : String(err)}`,
+            });
+            totalErrors += 1;
+        }
+    }
+    return {
+        totalFiles: filePaths.length,
+        successfulFiles: fileResults.filter((f) => !f.error).length,
+        failedFiles: fileResults.filter((f) => Boolean(f.error)).length,
+        totalServers,
+        totalErrors,
+        totalWarnings,
+        fileResults,
+    };
+}
+/**
+ * Compares two MCP configurations to identify server and attribute drift.
+ */
+export function diffConfigs(configA, configB) {
+    const entries = [];
+    const mapA = new Map(configA.servers.map((s) => [s.name, s]));
+    const mapB = new Map(configB.servers.map((s) => [s.name, s]));
+    // Check servers in A
+    for (const [name, serverA] of mapA) {
+        const serverB = mapB.get(name);
+        if (!serverB) {
+            entries.push({ serverName: name, kind: 'removed' });
+        }
+        else {
+            const changes = [];
+            if (serverA.transport !== serverB.transport) {
+                changes.push({ field: 'transport', from: serverA.transport, to: serverB.transport });
+            }
+            if (serverA.command !== serverB.command) {
+                changes.push({ field: 'command', from: serverA.command, to: serverB.command });
+            }
+            if (JSON.stringify(serverA.args) !== JSON.stringify(serverB.args)) {
+                changes.push({ field: 'args', from: serverA.args, to: serverB.args });
+            }
+            if (serverA.url !== serverB.url) {
+                changes.push({ field: 'url', from: serverA.url, to: serverB.url });
+            }
+            if (JSON.stringify(serverA.env) !== JSON.stringify(serverB.env)) {
+                changes.push({ field: 'env', from: serverA.env, to: serverB.env });
+            }
+            if (changes.length > 0) {
+                entries.push({ serverName: name, kind: 'modified', changes });
+            }
+        }
+    }
+    // Check newly added servers in B
+    for (const [name] of mapB) {
+        if (!mapA.has(name)) {
+            entries.push({ serverName: name, kind: 'added' });
+        }
+    }
+    return {
+        configAPath: configA.sourcePath,
+        configBPath: configB.sourcePath,
+        identical: entries.length === 0,
+        entries,
+    };
+}
+/**
+ * Filters diagnostics against a baseline snapshot, reporting only newly introduced issues.
+ */
+export function filterDiagnosticsByBaseline(currentReport, baselineReport) {
+    const baselineKey = (d) => `${d.checkId}|${d.serverName}|${d.toolName || ''}|${d.message}`;
+    const baselineSet = new Set(baselineReport.diagnostics.map(baselineKey));
+    const newDiagnostics = currentReport.diagnostics.filter((d) => !baselineSet.has(baselineKey(d)));
+    return {
+        ...currentReport,
+        diagnostics: newDiagnostics,
+        summary: {
+            ...currentReport.summary,
+            errors: newDiagnostics.filter((d) => d.severity === 'error').length,
+            warnings: newDiagnostics.filter((d) => d.severity === 'warning').length,
+        },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+export { runChecks } from './orchestrator.js';
+export { formatReportHuman, formatReportJSON } from './report.js';
+export { loadConfig } from './config-loader.js';
+export type { ConfigLoadResult } from './config-loader.js';
+export { discoverConfigFiles } from './discovery.js';
+export type { DiscoveredConfig } from './discovery.js';
+export { watchFileDebounced } from './watch.js';
+export type { WatchOptions, WatcherHandle } from './watch.js';
+export { runCheckConformanceSuite } from './conformance.js';
+export type { ConformanceResult } from './conformance.js';
+export { resolveRegistryServer } from './registry.js';
+export type { RegistryResolveOptions } from './registry.js';
+export { isMCPConfigFile, validateMCPDocument, activateExtension } from './extension/index.js';
+export { loadPolicy, createPolicyChecks } from './policy.js';
+export type { MCPDoctorPolicy } from './policy.js';
+export { runFleetChecks, diffConfigs, filterDiagnosticsByBaseline, findConfigFiles, } from './fleet.js';
+export type { FleetReport, ConfigDiffResult, ConfigDiffEntry, FileRunResult } from './fleet.js';
+export { formatReportJUnit, formatFleetReportJUnit } from './junit.js';
+export { allChecks } from './checks/index.js';
+export * from './types.js';

package/dist/index.js

@@ -0,0 +1,13 @@
+export { runChecks } from './orchestrator.js';
+export { formatReportHuman, formatReportJSON } from './report.js';
+export { loadConfig } from './config-loader.js';
+export { discoverConfigFiles } from './discovery.js';
+export { watchFileDebounced } from './watch.js';
+export { runCheckConformanceSuite } from './conformance.js';
+export { resolveRegistryServer } from './registry.js';
+export { isMCPConfigFile, validateMCPDocument, activateExtension } from './extension/index.js';
+export { loadPolicy, createPolicyChecks } from './policy.js';
+export { runFleetChecks, diffConfigs, filterDiagnosticsByBaseline, findConfigFiles, } from './fleet.js';
+export { formatReportJUnit, formatFleetReportJUnit } from './junit.js';
+export { allChecks } from './checks/index.js';
+export * from './types.js';

package/dist/junit.d.ts

@@ -0,0 +1,10 @@
+import type { RunReport } from './types.js';
+import type { FleetReport } from './fleet.js';
+/**
+ * Formats a RunReport as a standard JUnit XML document for CI visualization.
+ */
+export declare function formatReportJUnit(report: RunReport): string;
+/**
+ * Formats a multi-file FleetReport as a JUnit XML document.
+ */
+export declare function formatFleetReportJUnit(fleetReport: FleetReport): string;

package/dist/junit.js

@@ -0,0 +1,87 @@
+function escapeXml(unsafe) {
+    return unsafe
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+/**
+ * Formats a RunReport as a standard JUnit XML document for CI visualization.
+ */
+export function formatReportJUnit(report) {
+    const lines = [];
+    const totalTests = Math.max(1, report.connections.length + report.diagnostics.length);
+    const totalErrors = report.summary.errors;
+    lines.push('<?xml version="1.0" encoding="UTF-8"?>');
+    lines.push(`<testsuites name="mcp-doctor" tests="${totalTests}" failures="${totalErrors}" errors="0">`);
+    lines.push(`  <testsuite name="${escapeXml(report.configSource || 'mcp-config')}" tests="${totalTests}" failures="${totalErrors}">`);
+    // Connection testcases
+    for (const conn of report.connections) {
+        if (conn.status === 'connected') {
+            lines.push(`    <testcase classname="${escapeXml(conn.server.name)}" name="connection.handshake" time="${((conn.latencyMs || 0) / 1000).toFixed(3)}" />`);
+        }
+        else {
+            lines.push(`    <testcase classname="${escapeXml(conn.server.name)}" name="connection.handshake">`);
+            lines.push(`      <failure message="${escapeXml(conn.error?.message || 'Connection failed')}" type="ConnectionFailure">${escapeXml(conn.error?.message || '')}</failure>`);
+            lines.push('    </testcase>');
+        }
+    }
+    // Diagnostic testcases
+    for (const d of report.diagnostics) {
+        const scope = d.toolName ? `${d.serverName}.${d.toolName}` : d.serverName;
+        if (d.severity === 'error') {
+            lines.push(`    <testcase classname="${escapeXml(scope)}" name="${escapeXml(d.checkId)}">`);
+            lines.push(`      <failure message="${escapeXml(d.message)}" type="CheckError">${escapeXml(d.message)}${d.suggestedFix ? `\nSuggested fix: ${escapeXml(d.suggestedFix.description)}` : ''}</failure>`);
+            lines.push('    </testcase>');
+        }
+        else {
+            lines.push(`    <testcase classname="${escapeXml(scope)}" name="${escapeXml(d.checkId)}">`);
+            lines.push(`      <system-out>[${d.severity}] ${escapeXml(d.message)}</system-out>`);
+            lines.push('    </testcase>');
+        }
+    }
+    lines.push('  </testsuite>');
+    lines.push('</testsuites>');
+    return lines.join('\n');
+}
+/**
+ * Formats a multi-file FleetReport as a JUnit XML document.
+ */
+export function formatFleetReportJUnit(fleetReport) {
+    const lines = [];
+    lines.push('<?xml version="1.0" encoding="UTF-8"?>');
+    lines.push(`<testsuites name="mcp-doctor-fleet" tests="${fleetReport.totalServers}" failures="${fleetReport.totalErrors}">`);
+    for (const fileResult of fleetReport.fileResults) {
+        if (fileResult.report) {
+            const rep = fileResult.report;
+            lines.push(`  <testsuite name="${escapeXml(fileResult.filePath)}" tests="${rep.summary.servers + rep.diagnostics.length}" failures="${rep.summary.errors}">`);
+            for (const conn of rep.connections) {
+                if (conn.status === 'connected') {
+                    lines.push(`    <testcase classname="${escapeXml(conn.server.name)}" name="connection.handshake" />`);
+                }
+                else {
+                    lines.push(`    <testcase classname="${escapeXml(conn.server.name)}" name="connection.handshake">`);
+                    lines.push(`      <failure message="${escapeXml(conn.error?.message || 'Connection failed')}" type="ConnectionFailure" />`);
+                    lines.push('    </testcase>');
+                }
+            }
+            for (const d of rep.diagnostics) {
+                const scope = d.toolName ? `${d.serverName}.${d.toolName}` : d.serverName;
+                if (d.severity === 'error') {
+                    lines.push(`    <testcase classname="${escapeXml(scope)}" name="${escapeXml(d.checkId)}">`);
+                    lines.push(`      <failure message="${escapeXml(d.message)}" type="CheckError">${escapeXml(d.message)}</failure>`);
+                    lines.push('    </testcase>');
+                }
+            }
+            lines.push('  </testsuite>');
+        }
+        else if (fileResult.error) {
+            lines.push(`  <testsuite name="${escapeXml(fileResult.filePath)}" tests="1" failures="1">`);
+            lines.push(`    <testcase classname="config.file" name="parse"><failure message="${escapeXml(fileResult.error)}" type="ConfigError" /></testcase>`);
+            lines.push('  </testsuite>');
+        }
+    }
+    lines.push('</testsuites>');
+    return lines.join('\n');
+}

package/dist/orchestrator.d.ts

@@ -0,0 +1,6 @@
+import type { MCPConfig, MCPConnection, RunOptions, RunReport } from './types.js';
+/** Allows the protocol layer to register its real implementation without
+ * this file needing to import it directly (keeps orchestrator decoupled
+ * from protocol internals per CONTRACT.md module boundaries). */
+export declare function registerConnectImpl(impl: (config: MCPConfig['servers'][number], timeoutMs: number, options?: RunOptions) => Promise<MCPConnection>): void;
+export declare function runChecks(config: MCPConfig, options?: RunOptions): Promise<RunReport>;