mcp-medic 1.2.5 → 1.2.7

package/dist/cli.d.ts

@@ -13,6 +13,7 @@ export interface ParsedArgs {
     updateSnapshotPath?: string;
     json: boolean;
     timeoutMs?: number;
+    jobs?: number;
     showFixes: boolean;
     verbose: boolean;
     failOn: 'error' | 'warning';

package/dist/cli.js

@@ -113,6 +113,14 @@ export function parseArgs(argv) {
             }
             args.protocolVersion = val;
         }
+        else if (arg === '--jobs') {
+            const value = argv[++i];
+            const parsed = value ? Number(value) : NaN;
+            if (!Number.isSafeInteger(parsed) || parsed < 1) {
+                throw new Error(`--jobs requires a positive safe integer, got: ${value ?? '(none)'}`);
+            }
+            args.jobs = parsed;
+        }
         else {
             positional.push(arg);
         }
@@ -213,6 +221,7 @@ OPTIONS
   --timeout <ms>        Per-server handshake timeout in milliseconds (default: 5000)
   --protocol-version <v> MCP protocolVersion to request: "auto" (default, latest supported)
                         or an explicit version, e.g. ${SUPPORTED_PROTOCOL_VERSIONS[SUPPORTED_PROTOCOL_VERSIONS.length - 1]}
+  --jobs <n>            Maximum config files processed at once in check-all (default: 1)
   --help, -h            Show help
   --version, -V         Print the installed mcp-medic version
 
@@ -568,6 +577,7 @@ export async function main(argv = process.argv.slice(2), deps = {}) {
         const fleetReport = await runFleetChecks(glob, {
             checks,
             timeoutMs: args.timeoutMs,
+            jobs: args.jobs,
             verbose: args.verbose,
             protocolVersion: args.protocolVersion,
         });

package/dist/fleet.d.ts

@@ -37,6 +37,7 @@ export declare function findConfigFiles(globOrPattern: string, rootDir?: string)
  */
 export declare function runFleetChecks(globPattern: string, options?: RunOptions & {
     cwd?: string;
+    jobs?: number;
 }): Promise<FleetReport>;
 /**
  * Compares two MCP configurations to identify server and attribute drift.

package/dist/fleet.js

@@ -1,23 +1,46 @@
-import { readdirSync, statSync, readFileSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
+import { readdirSync, lstatSync, readFileSync, existsSync } from 'node:fs';
+import { resolve, join } from 'node:path';
 import { loadConfig } from './config-loader.js';
 import { runChecks } from './orchestrator.js';
 import { allChecks } from './checks/index.js';
 import { redactRecord } from './redact.js';
-function findFilesMatching(dir, pattern, results = []) {
+async function mapWithConcurrency(items, concurrency, worker) {
+    const results = new Array(items.length);
+    let nextIndex = 0;
+    const workerCount = Math.min(concurrency, items.length);
+    await Promise.all(Array.from({ length: workerCount }, async () => {
+        while (true) {
+            const index = nextIndex++;
+            if (index >= items.length)
+                return;
+            results[index] = await worker(items[index]);
+        }
+    }));
+    return results;
+}
+function findFilesMatching(dir, rootDir, pattern, results = []) {
     if (!existsSync(dir))
         return results;
-    const entries = readdirSync(dir);
+    let entries;
+    try {
+        entries = readdirSync(dir).sort();
+    }
+    catch {
+        return results;
+    }
     for (const entry of entries) {
         if (entry === 'node_modules' || entry === '.git' || entry === 'dist')
             continue;
         const fullPath = join(dir, entry);
         try {
-            const stat = statSync(fullPath);
+            const stat = lstatSync(fullPath);
             if (stat.isDirectory()) {
-                findFilesMatching(fullPath, pattern, results);
+                findFilesMatching(fullPath, rootDir, pattern, results);
             }
-            else if (stat.isFile() && pattern.test(fullPath)) {
+            else if (stat.isFile()) {
+                const relativePath = fullPath.slice(rootDir.length + 1).split('\\').join('/');
+                if (!pattern.test(relativePath))
+                    continue;
                 results.push(fullPath);
             }
         }
@@ -31,13 +54,31 @@ function findFilesMatching(dir, pattern, 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);
+    const root = resolve(rootDir);
+    const glob = globOrPattern.split('\\').join('/').replace(/^\.\//, '');
+    let regexSource = '^';
+    for (let i = 0; i < glob.length; i += 1) {
+        const char = glob[i];
+        if (char === '*' && glob[i + 1] === '*') {
+            i += 1;
+            if (glob[i + 1] === '/') {
+                // A leading or interior **/ can match zero or more path segments.
+                regexSource += '(?:.*/)?';
+                i += 1;
+            }
+            else {
+                regexSource += '.*';
+            }
+        }
+        else if (char === '*') {
+            regexSource += '[^/]*';
+        }
+        else {
+            regexSource += char.replace(/[|\\{}()[\]^$+?.]/g, '\\$&');
+        }
+    }
+    const regex = new RegExp(`${regexSource}$`);
+    return findFilesMatching(root, root, regex).sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
 }
 /**
  * Runs validation checks across all matching configuration files.
@@ -45,38 +86,36 @@ export function findConfigFiles(globOrPattern, rootDir = process.cwd()) {
 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) {
+    const jobs = options.jobs ?? 1;
+    if (!Number.isSafeInteger(jobs) || jobs < 1) {
+        throw new TypeError(`jobs must be a positive safe integer, got: ${jobs}`);
+    }
+    const processed = await mapWithConcurrency(filePaths, jobs, async (filePath) => {
         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;
+                return {
+                    fileResult: { filePath, error: `Config validation failed: ${errors.join(', ')}` },
+                    errorCount: errors.length,
+                };
             }
             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;
+            return { fileResult: { filePath, report }, errorCount: report.summary.errors };
         }
         catch (err) {
-            fileResults.push({
-                filePath,
-                error: `Could not process file: ${err instanceof Error ? err.message : String(err)}`,
-            });
-            totalErrors += 1;
+            return {
+                fileResult: { filePath, error: `Could not process file: ${err instanceof Error ? err.message : String(err)}` },
+                errorCount: 1,
+            };
         }
-    }
+    });
+    const fileResults = processed.map((item) => item.fileResult);
+    const totalServers = fileResults.reduce((sum, result) => sum + (result.report?.summary.servers ?? 0), 0);
+    const totalErrors = processed.reduce((sum, item) => sum + item.errorCount, 0);
+    const totalWarnings = fileResults.reduce((sum, result) => sum + (result.report?.summary.warnings ?? 0), 0);
     return {
         totalFiles: filePaths.length,
         successfulFiles: fileResults.filter((f) => !f.error).length,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-medic",
-  "version": "1.2.5",
+  "version": "1.2.7",
   "description": "Diagnose broken MCP (Model Context Protocol) server configs before they break your agent silently.",
   "type": "module",
   "main": "dist/index.js",