mcp-medic 1.0.0

package/dist/checks/sample-call-simulation.js

@@ -0,0 +1,239 @@
+function generatePlaceholderForType(propDef) {
+    // 1. If enum is specified
+    if (Array.isArray(propDef.enum)) {
+        if (propDef.enum.length === 0) {
+            throw new Error('required enum array is empty');
+        }
+        return { value: propDef.enum[0] };
+    }
+    // 2. If default is specified
+    if (propDef.default !== undefined) {
+        return { value: propDef.default };
+    }
+    // 3. Match by type
+    const rawType = propDef.type;
+    const targetType = Array.isArray(rawType) ? rawType[0] : rawType;
+    if (targetType === 'string') {
+        if (typeof propDef.minLength === 'number' && propDef.minLength > 0) {
+            return { value: 'a'.repeat(propDef.minLength) };
+        }
+        return { value: '' };
+    }
+    if (targetType === 'number' || targetType === 'integer') {
+        if (typeof propDef.minimum === 'number' && propDef.minimum > 0) {
+            return { value: propDef.minimum };
+        }
+        return { value: 0 };
+    }
+    if (targetType === 'boolean') {
+        return { value: false };
+    }
+    if (targetType === 'array') {
+        return { value: [] };
+    }
+    if (targetType === 'object') {
+        return { value: {} };
+    }
+    if (targetType === 'null') {
+        return { value: null };
+    }
+    // Fallback if type is missing or complex
+    return {
+        value: '',
+        caveat: `unknown or missing type "${String(rawType)}", defaulted to empty string`,
+    };
+}
+function validateSyntheticPayload(payload, schema) {
+    const errors = [];
+    const caveats = [];
+    const required = Array.isArray(schema.required) ? schema.required : [];
+    const properties = schema.properties && typeof schema.properties === 'object' && !Array.isArray(schema.properties)
+        ? schema.properties
+        : {};
+    // Verify all required fields are present
+    for (const req of required) {
+        if (typeof req === 'string' && !(req in payload)) {
+            errors.push(`Missing required field "${req}" in synthetic payload.`);
+        }
+    }
+    // Validate properties
+    for (const [key, val] of Object.entries(payload)) {
+        const propDef = properties[key];
+        if (!propDef || typeof propDef !== 'object' || Array.isArray(propDef)) {
+            continue;
+        }
+        const propObj = propDef;
+        // Enum validation
+        if (Array.isArray(propObj.enum)) {
+            if (propObj.enum.length === 0) {
+                errors.push(`Field "${key}" specifies an empty enum array.`);
+            }
+            else if (!propObj.enum.includes(val)) {
+                errors.push(`Field "${key}" value ${JSON.stringify(val)} is not in enum [${propObj.enum.map((e) => JSON.stringify(e)).join(', ')}].`);
+            }
+        }
+        // Number constraints check
+        if (typeof val === 'number') {
+            if (typeof propObj.minimum === 'number' && typeof propObj.maximum === 'number') {
+                if (propObj.minimum > propObj.maximum) {
+                    errors.push(`Field "${key}" has contradictory bounds: minimum (${propObj.minimum}) > maximum (${propObj.maximum}).`);
+                }
+            }
+            if (typeof propObj.minimum === 'number' && val < propObj.minimum) {
+                errors.push(`Field "${key}" value ${val} is less than minimum ${propObj.minimum}.`);
+            }
+            if (typeof propObj.maximum === 'number' && val > propObj.maximum) {
+                errors.push(`Field "${key}" value ${val} is greater than maximum ${propObj.maximum}.`);
+            }
+        }
+        // String constraints check
+        if (typeof val === 'string') {
+            if (typeof propObj.minLength === 'number' && typeof propObj.maxLength === 'number') {
+                if (propObj.minLength > propObj.maxLength) {
+                    errors.push(`Field "${key}" has contradictory bounds: minLength (${propObj.minLength}) > maxLength (${propObj.maxLength}).`);
+                }
+            }
+        }
+    }
+    if (schema.$ref || schema.oneOf || schema.anyOf || schema.allOf) {
+        caveats.push('Schema uses complex combinators or references ($ref/oneOf/anyOf/allOf).');
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        caveats,
+    };
+}
+export const sampleCallSimulationCheck = {
+    id: 'schema.sample-call-simulation',
+    description: 'Generates and validates a minimal synthetic argument object against the tool inputSchema.',
+    run(connection) {
+        const results = [];
+        try {
+            if (!connection.tools || !Array.isArray(connection.tools)) {
+                return results;
+            }
+            for (const tool of connection.tools) {
+                const schema = tool.inputSchema;
+                if (!schema || typeof schema !== 'object' || Array.isArray(schema)) {
+                    results.push({
+                        checkId: 'schema.sample-call-simulation',
+                        severity: 'error',
+                        message: `Cannot simulate sample call for tool "${tool.name}": inputSchema is not a valid object.`,
+                        serverName: connection.server.name,
+                        toolName: tool.name,
+                    });
+                    continue;
+                }
+                const schemaObj = schema;
+                const required = Array.isArray(schemaObj.required) ? schemaObj.required : [];
+                const properties = schemaObj.properties &&
+                    typeof schemaObj.properties === 'object' &&
+                    !Array.isArray(schemaObj.properties)
+                    ? schemaObj.properties
+                    : {};
+                const syntheticArgs = {};
+                const generationCaveats = [];
+                let generationFailed = false;
+                for (const reqField of required) {
+                    if (typeof reqField !== 'string')
+                        continue;
+                    if (!(reqField in properties)) {
+                        results.push({
+                            checkId: 'schema.sample-call-simulation',
+                            severity: 'error',
+                            message: `Sample call generation failed for tool "${tool.name}": required field "${reqField}" has no property definition.`,
+                            serverName: connection.server.name,
+                            toolName: tool.name,
+                            details: { missingRequiredProperty: reqField },
+                            suggestedFix: {
+                                description: `Define property "${reqField}" under inputSchema.properties with a valid type.`,
+                            },
+                        });
+                        generationFailed = true;
+                        break;
+                    }
+                    const propDef = properties[reqField];
+                    if (!propDef || typeof propDef !== 'object' || Array.isArray(propDef)) {
+                        results.push({
+                            checkId: 'schema.sample-call-simulation',
+                            severity: 'error',
+                            message: `Sample call generation failed for tool "${tool.name}": property definition for "${reqField}" is not an object.`,
+                            serverName: connection.server.name,
+                            toolName: tool.name,
+                            suggestedFix: {
+                                description: `Update property definition for "${reqField}" to be a valid object with a "type" field.`,
+                            },
+                        });
+                        generationFailed = true;
+                        break;
+                    }
+                    try {
+                        const { value, caveat } = generatePlaceholderForType(propDef);
+                        syntheticArgs[reqField] = value;
+                        if (caveat)
+                            generationCaveats.push(caveat);
+                    }
+                    catch (genErr) {
+                        results.push({
+                            checkId: 'schema.sample-call-simulation',
+                            severity: 'error',
+                            message: `Sample call generation failed for tool "${tool.name}" on required field "${reqField}": ${genErr instanceof Error ? genErr.message : String(genErr)}`,
+                            serverName: connection.server.name,
+                            toolName: tool.name,
+                            suggestedFix: {
+                                description: `Provide valid enum options or valid bounds for required property "${reqField}".`,
+                            },
+                        });
+                        generationFailed = true;
+                        break;
+                    }
+                }
+                if (generationFailed) {
+                    continue;
+                }
+                // Validate the generated payload against the schema
+                const outcome = validateSyntheticPayload(syntheticArgs, schemaObj);
+                if (!outcome.valid) {
+                    results.push({
+                        checkId: 'schema.sample-call-simulation',
+                        severity: 'error',
+                        message: `Sample call simulation validation failed for tool "${tool.name}": ${outcome.errors.join('; ')}`,
+                        serverName: connection.server.name,
+                        toolName: tool.name,
+                        details: {
+                            syntheticArgs,
+                            errors: outcome.errors,
+                        },
+                        suggestedFix: {
+                            description: 'Fix conflicting property constraints (e.g. minimum <= maximum, non-empty enums).',
+                        },
+                    });
+                }
+                else if (generationCaveats.length > 0 || outcome.caveats.length > 0) {
+                    const allCaveats = [...generationCaveats, ...outcome.caveats];
+                    results.push({
+                        checkId: 'schema.sample-call-simulation',
+                        severity: 'warning',
+                        message: `Sample call simulation succeeded with caveats for tool "${tool.name}": ${allCaveats.join('; ')}`,
+                        serverName: connection.server.name,
+                        toolName: tool.name,
+                        details: {
+                            syntheticArgs,
+                            caveats: allCaveats,
+                        },
+                    });
+                }
+            }
+        }
+        catch (err) {
+            results.push({
+                checkId: 'schema.sample-call-simulation',
+                severity: 'error',
+                message: `check failed internally: ${err instanceof Error ? err.message : String(err)}`,
+                serverName: connection.server.name,
+            });
+        }
+        return results;
+    },
+};

package/dist/checks/type-mismatch.d.ts

@@ -0,0 +1,2 @@
+import type { Check } from '../types.js';
+export declare const typeMismatchCheck: Check;

package/dist/checks/type-mismatch.js

@@ -0,0 +1,154 @@
+const VALID_JSON_SCHEMA_TYPES = new Set([
+    'string',
+    'number',
+    'integer',
+    'boolean',
+    'object',
+    'array',
+    'null',
+]);
+function matchesDeclaredType(value, declaredType) {
+    if (value === null) {
+        return declaredType === 'null';
+    }
+    if (Array.isArray(value)) {
+        return declaredType === 'array';
+    }
+    const jsType = typeof value;
+    if (jsType === 'string') {
+        return declaredType === 'string';
+    }
+    if (jsType === 'number') {
+        if (declaredType === 'number')
+            return true;
+        if (declaredType === 'integer')
+            return Number.isInteger(value);
+        return false;
+    }
+    if (jsType === 'boolean') {
+        return declaredType === 'boolean';
+    }
+    if (jsType === 'object') {
+        return declaredType === 'object';
+    }
+    return false;
+}
+function valueMatchesTypeDefinition(value, typeDef) {
+    if (typeof typeDef === 'string') {
+        return matchesDeclaredType(value, typeDef);
+    }
+    if (Array.isArray(typeDef)) {
+        return typeDef.some((t) => typeof t === 'string' && matchesDeclaredType(value, t));
+    }
+    return true;
+}
+export const typeMismatchCheck = {
+    id: 'schema.type-mismatch',
+    description: 'Flags properties with invalid types or enum values that do not match their declared type.',
+    run(connection) {
+        const results = [];
+        try {
+            if (!connection.tools || !Array.isArray(connection.tools)) {
+                return results;
+            }
+            for (const tool of connection.tools) {
+                const schema = tool.inputSchema;
+                if (!schema || typeof schema !== 'object' || Array.isArray(schema)) {
+                    continue;
+                }
+                const schemaObj = schema;
+                if (!schemaObj.properties ||
+                    typeof schemaObj.properties !== 'object' ||
+                    Array.isArray(schemaObj.properties)) {
+                    continue;
+                }
+                const properties = schemaObj.properties;
+                for (const [propName, propDef] of Object.entries(properties)) {
+                    if (!propDef || typeof propDef !== 'object' || Array.isArray(propDef)) {
+                        continue;
+                    }
+                    const propObj = propDef;
+                    const declaredType = propObj.type;
+                    if (declaredType !== undefined) {
+                        if (typeof declaredType === 'string') {
+                            if (!VALID_JSON_SCHEMA_TYPES.has(declaredType)) {
+                                results.push({
+                                    checkId: 'schema.type-mismatch',
+                                    severity: 'warning',
+                                    message: `Property "${propName}" in tool "${tool.name}" has invalid or unrecognized type "${declaredType}".`,
+                                    serverName: connection.server.name,
+                                    toolName: tool.name,
+                                    details: { property: propName, invalidType: declaredType },
+                                    suggestedFix: {
+                                        description: `Change type of property "${propName}" to a valid JSON Schema type (e.g. "string", "number", "integer", "boolean", "object", "array", "null").`,
+                                    },
+                                });
+                            }
+                        }
+                        else if (Array.isArray(declaredType)) {
+                            for (const item of declaredType) {
+                                if (typeof item !== 'string' || !VALID_JSON_SCHEMA_TYPES.has(item)) {
+                                    results.push({
+                                        checkId: 'schema.type-mismatch',
+                                        severity: 'warning',
+                                        message: `Property "${propName}" in tool "${tool.name}" has invalid type union entry "${String(item)}".`,
+                                        serverName: connection.server.name,
+                                        toolName: tool.name,
+                                        details: { property: propName, invalidTypeEntry: item },
+                                        suggestedFix: {
+                                            description: `Remove or correct invalid type entry "${String(item)}" in union type for property "${propName}".`,
+                                        },
+                                    });
+                                }
+                            }
+                        }
+                        else {
+                            results.push({
+                                checkId: 'schema.type-mismatch',
+                                severity: 'warning',
+                                message: `Property "${propName}" in tool "${tool.name}" has invalid type descriptor of type ${typeof declaredType}.`,
+                                serverName: connection.server.name,
+                                toolName: tool.name,
+                                details: { property: propName, typeDescriptor: declaredType },
+                                suggestedFix: {
+                                    description: `Specify property "${propName}" type as a string (e.g. "string") or array of strings.`,
+                                },
+                            });
+                        }
+                    }
+                    // Check enum values against declared type
+                    if (Array.isArray(propObj.enum) && declaredType !== undefined) {
+                        for (const enumVal of propObj.enum) {
+                            if (!valueMatchesTypeDefinition(enumVal, declaredType)) {
+                                results.push({
+                                    checkId: 'schema.type-mismatch',
+                                    severity: 'warning',
+                                    message: `Enum value ${JSON.stringify(enumVal)} for property "${propName}" in tool "${tool.name}" does not match declared type "${JSON.stringify(declaredType)}".`,
+                                    serverName: connection.server.name,
+                                    toolName: tool.name,
+                                    details: {
+                                        property: propName,
+                                        enumValue: enumVal,
+                                        declaredType,
+                                    },
+                                    suggestedFix: {
+                                        description: `Ensure all enum entries for property "${propName}" conform to declared type "${JSON.stringify(declaredType)}".`,
+                                    },
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch (err) {
+            results.push({
+                checkId: 'schema.type-mismatch',
+                severity: 'error',
+                message: `check failed internally: ${err instanceof Error ? err.message : String(err)}`,
+                serverName: connection.server.name,
+            });
+        }
+        return results;
+    },
+};

package/dist/cli.d.ts

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+export interface ParsedArgs {
+    command: 'check' | 'watch' | 'check-all' | 'diff' | 'help';
+    configPath?: string;
+    configPathB?: string;
+    globPattern?: string;
+    registryServer?: string;
+    policyPath?: string;
+    exportJunit?: string;
+    exportJson?: string;
+    snapshotPath?: string;
+    updateSnapshotPath?: string;
+    json: boolean;
+    timeoutMs?: number;
+    showFixes: boolean;
+    verbose: boolean;
+    failOn: 'error' | 'warning';
+}
+export declare function parseArgs(argv: string[]): ParsedArgs;
+export declare function main(argv?: string[]): Promise<number>;