vikunja-mcp-ng 0.4.0

package/dist/utils/validation.js

@@ -0,0 +1,758 @@
+"use strict";
+/**
+ * Comprehensive Input Sanitization and Security Validation Layer
+ *
+ * Provides enterprise-grade protection against:
+ * - XSS attacks (script injection, HTML injection)
+ * - SQL injection (UNION, boolean-based, time-based)
+ * - Command injection (shell command execution)
+ * - Path traversal attacks
+ * - LDAP injection
+ * - NoSQL injection
+ * - Unicode and encoding bypasses
+ * - Content Security Policy violations
+ *
+ * Integration: Works seamlessly with existing security.ts credential masking
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeString = sanitizeString;
+exports.validateField = validateField;
+exports.validateOperator = validateOperator;
+exports.validateLogicalOperator = validateLogicalOperator;
+exports.validateValue = validateValue;
+exports.validateCondition = validateCondition;
+exports.validateFilterExpression = validateFilterExpression;
+exports.safeJsonStringify = safeJsonStringify;
+exports.safeJsonParse = safeJsonParse;
+exports.validateId = validateId;
+exports.validateAndConvertId = validateAndConvertId;
+const zod_1 = require("zod");
+const errors_1 = require("../types/errors");
+/**
+ * Maximum allowed nesting depth for filter expressions (prevents DoS)
+ */
+const MAX_NESTING_DEPTH = 10;
+/**
+ * Maximum allowed number of conditions per expression (prevents DoS)
+ */
+const MAX_CONDITIONS = 50;
+/**
+ * Maximum string length for filter values (prevents storage bloat)
+ */
+const MAX_STRING_LENGTH = 1000;
+/**
+ * Zod schemas for type-safe validation
+ */
+const FieldSchema = zod_1.z.enum([
+    'done', 'priority', 'percentDone', 'dueDate', 'startDate', 'endDate',
+    'doneAt', 'project', 'assignees',
+    'labels', 'created', 'updated', 'title', 'description'
+]);
+const OperatorSchema = zod_1.z.enum([
+    '=', '!=', '>', '>=', '<', '<=', 'like', 'in', 'not in'
+]);
+const LogicalOperatorSchema = zod_1.z.enum(['&&', '||']);
+/**
+ * Server-appropriate security validation patterns
+ * Created fresh each call to avoid regex state issues
+ */
+/**
+ * Allowed characters for additional strictness (optional, can be relaxed)
+ */
+/**
+ * Validate and sanitize a string value to prevent XSS using pattern matching + HTML escaping
+ * Server-appropriate approach that avoids DOM parsing while providing comprehensive protection
+ */
+function sanitizeString(value) {
+    if (typeof value !== 'string') {
+        throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, 'Value must be a string');
+    }
+    if (value.length > MAX_STRING_LENGTH) {
+        throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, `String value exceeds maximum length of ${MAX_STRING_LENGTH}`);
+    }
+    // Step 1: Check for dangerous HTML/JavaScript patterns and REJECT them (don't sanitize)
+    // Convert to lowercase for case-insensitive pattern matching
+    const lowerValue = value.toLowerCase();
+    // Create fresh patterns each time to avoid regex state issues
+    const dangerousPatterns = [
+        // Enhanced XSS patterns - comprehensive script and injection detection
+        /<script[^>]*>/gi,
+        /<\/script>/gi,
+        /<iframe[^>]*>/gi,
+        /<\/iframe>/gi,
+        /<object[^>]*>/gi,
+        /<\/object>/gi,
+        /<embed[^>]*>/gi,
+        /<link[^>]*>/gi,
+        /<meta[^>]*>/gi,
+        /<svg[^>]*>/gi,
+        /<\/svg>/gi,
+        /<style[^>]*>/gi,
+        /<\/style>/gi,
+        /<img[^>]*on[^>]*>/gi,
+        /<div[^>]*on[^>]*>/gi,
+        /<a[^>]*on[^>]*>/gi,
+        /<body[^>]*on[^>]*>/gi,
+        /<form[^>]*on[^>]*>/gi,
+        /<input[^>]*on[^>]*>/gi,
+        /<button[^>]*on[^>]*>/gi,
+        /<select[^>]*on[^>]*>/gi,
+        /<textarea[^>]*on[^>]*>/gi,
+        // Event handlers with attributes (more specific to avoid false positives)
+        /on\w+\s*=\s*["'][^"']*["']/gi,
+        /onclick/gi,
+        /onload/gi,
+        /onerror/gi,
+        /onmouseover/gi,
+        /onmouseout/gi,
+        /onmousedown/gi,
+        /onmouseup/gi,
+        /onkeydown/gi,
+        /onkeyup/gi,
+        /onkeypress/gi,
+        /onfocus/gi,
+        /onblur/gi,
+        /onchange/gi,
+        /onsubmit/gi,
+        /onreset/gi,
+        /onselect/gi,
+        /onunload/gi,
+        /onabort/gi,
+        /oncanplay/gi,
+        /oncanplaythrough/gi,
+        /oncuechange/gi,
+        /ondurationchange/gi,
+        /onemptied/gi,
+        /onended/gi,
+        /onerror/gi,
+        /onloadeddata/gi,
+        /onloadedmetadata/gi,
+        /onloadstart/gi,
+        /onpause/gi,
+        /onplay/gi,
+        /onplaying/gi,
+        /onprogress/gi,
+        /onratechange/gi,
+        /onseeked/gi,
+        /onseeking/gi,
+        /onstalled/gi,
+        /onsuspend/gi,
+        /ontimeupdate/gi,
+        /onvolumechange/gi,
+        /onwaiting/gi,
+        // Dangerous protocols and schemes
+        /javascript:/gi,
+        /vbscript:/gi,
+        /data:text\/html/gi,
+        /data:application\/javascript/gi,
+        /data:text\/javascript/gi,
+        /data:text\/vbscript/gi,
+        /data:application\/x-javascript/gi,
+        // CSS-based attacks
+        /expression\s*\(/gi,
+        /@import/gi,
+        /url\s*\(/gi,
+        /binding\s*:/gi,
+        /behavior\s*:/gi,
+        /-moz-binding\s*:/gi,
+        /-o-link\s*:/gi,
+        /-webkit-binding\s*:/gi,
+        // SQL injection patterns (narrow: only flag time-delay/blind injection, not plain English words)
+        /(\b(WAITFOR\s+DELAY|SLEEP\s*\(|BENCHMARK\s*\(|DBMS_PIPE\.RECEIVE_MESSAGE)\b)/gi,
+        /(\b(XP_|SP_)\w+)/gi, // SQL Server extended procedures
+        // Boolean-based blind SQL injection (e.g. `' OR '1'='1`). Requires a quote immediately
+        // after OR/AND plus an `=` comparison, so it doesn't false-positive on ordinary English
+        // like "Fix bug or issue" or "Cost or budget = 500" (no quote follows OR/AND there).
+        /(\b(OR|AND)\b\s*["'][^"']*["']?\s*=\s*["']?[^"']*["']?)/gi,
+        // HTML comments (XSS vector regardless of context)
+        /<!--/gi,
+        // Command injection patterns (more specific to avoid false positives)
+        // The broad shell-metacharacter blocklist (`;&|`$(){}[]\'"*?<>~`) was removed because it
+        // rejected any string containing a bare quote or angle bracket. Generic, non-scripting
+        // HTML-like text (e.g. `<div class="x">`) is passed through unmodified: this boundary is a
+        // JSON API call, not an HTML render, so there is nothing to escape (see f2b0b93, which
+        // removed render-time HTML-escaping here for the same reason). Only constructs with actual
+        // scripting/DOM-execution vectors (script/iframe/style/svg tags, event handlers, dangerous
+        // protocols, etc.) are rejected above.
+        /(\b(wget|curl|nc|netcat|telnet|ssh|ftp|sftp)\b)/gi,
+        /(rm\s+-rf|del\s+\/s|format|fdisk|mkfs)/gi,
+        /(>\s*\/dev\/null|2>&1|\|\|)/gi,
+        /(\$\([^)]*\)|`[^`]*`)/gi, // Command substitution
+        // Path traversal patterns
+        /(\.\.[/\\])/gi,
+        /(%2e%2e[/\\])/gi,
+        /(%2e%2e%2f)/gi, // URL-encoded ../
+        /(%2e%2e%5c)/gi, // URL-encoded ..\
+        /(\/etc\/passwd|\/etc\/shadow|\/proc\/)/gi,
+        /(c:\\\\windows\\\\system32|\\\\..\\\\)/gi,
+        // LDAP injection patterns
+        /(\*\)\([&*)]*)/gi,
+        /(\*\)([^)]*\*)*)/gi,
+        /(\|\()([^)]*)(\)\|)/gi,
+        /(!\()([^)]*)(\))/gi,
+        // NoSQL injection patterns. The optional `["']?` before the colon covers both the raw
+        // `$gt:` form and the quoted-JSON-key form (`"$gt":`) produced by e.g. JSON.stringify.
+        /(\$\w+\s*["']?\s*:)/gi, // MongoDB operators like $gt, $lt, $where
+        /(\{\s*["']?\$where\s*["']?\s*:)/gi,
+        /(\{\s*["']?\$ne\s*["']?\s*:)/gi,
+        /(\{\s*["']?\$gt\s*["']?\s*:)/gi,
+        /(\{\s*["']?\$regex\s*["']?\s*:)/gi,
+        // HTML5 dangerous attributes
+        /formaction\s*=/gi,
+        /poster\s*=/gi,
+        /autofocus\s*=/gi,
+        /controls\s*=/gi,
+        /autoplay\s*=/gi,
+        /loop\s*=/gi,
+        /muted\s*=/gi,
+        // Unicode and encoding bypass attempts
+        /[\u200b-\u200f\u2060\u180e\ufeff]/g, // Zero-width and invisible characters
+        /[\uFE00-\uFE0F]/g, // Variation selectors
+        /\\u[0-9a-fA-F]{4}/g, // Unicode escapes
+        /\\x[0-9a-fA-F]{2}/g, // Hex escapes
+        // Prototype pollution patterns
+        /(__proto__|constructor|prototype)/gi,
+        // Content Security Policy violations
+        /(base64|atob|btoa|eval|Function|setTimeout|setInterval)\s*\(/gi,
+        /(document\.(write|writeln|open|close)|window\.(open|location|navigate))/gi,
+        // HTML-encoded dangerous content (prevent XSS through encoded vectors)
+        /&lt;script[^&]*&gt;/gi,
+        /&lt;\/script&gt;/gi,
+        /&lt;iframe[^&]*&gt;/gi,
+        /&lt;\/iframe&gt;/gi,
+        /&lt;object[^&]*&gt;/gi,
+        /&lt;svg[^&]*&gt;/gi,
+        /&lt;img[^&]*on[^&]*&gt;/gi,
+        /&lt;div[^&]*on[^&]*&gt;/gi,
+        /&lt;a[^&]*on[^&]*&gt;/gi,
+        /&lt;body[^&]*on[^&]*&gt;/gi,
+        /&lt;style[^&]*&gt;/gi,
+        /&lt;form[^&]*on[^&]*&gt;/gi,
+        /javascript:[^&]*/gi,
+        /on\w+[^&]*=/gi,
+        /&lt;!--.*?--&gt;/gis, // HTML-encoded comments
+    ];
+    for (const pattern of dangerousPatterns) {
+        // Reset regex lastIndex to avoid state issues with global flags
+        pattern.lastIndex = 0;
+        if (pattern.test(lowerValue)) {
+            throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, 'String contains potentially dangerous content');
+        }
+    }
+    // Step 2: Apply comprehensive sanitization for safe content
+    // First, normalize Unicode to prevent bypass attacks
+    let normalizedValue = value.normalize('NFC');
+    // Remove dangerous Unicode characters that weren't caught by pattern matching
+    normalizedValue = normalizedValue.replace(/[\u200b-\u200f\u2060\u180e\ufeff]/g, '');
+    normalizedValue = normalizedValue.replace(/[\uFE00-\uFE0F]/g, '');
+    // Apply path traversal sanitization for file system safety
+    normalizedValue = normalizedValue.replace(/\.\.[/\\]/g, '...');
+    normalizedValue = normalizedValue.replace(/%2e%2e[/\\]/gi, '...');
+    normalizedValue = normalizedValue.replace(/\/etc\/passwd/gi, 'etc/passwd');
+    normalizedValue = normalizedValue.replace(/c:\\windows\\system32/gi, 'c:/windows/system32');
+    return normalizedValue;
+}
+/**
+ * Validate a field name against Zod schema
+ */
+function validateField(field) {
+    if (typeof field !== 'string') {
+        throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, 'Field must be a string');
+    }
+    // Check for prototype pollution attempts first
+    const pollutionPatterns = ['__proto__', 'constructor', 'prototype', '__defineGetter__', '__defineSetter__', '__lookupGetter__', '__lookupSetter__'];
+    if (pollutionPatterns.includes(field)) {
+        throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, 'Invalid field name: potential prototype pollution');
+    }
+    try {
+        const result = FieldSchema.parse(field);
+        return result;
+    }
+    catch (error) {
+        if (error instanceof zod_1.z.ZodError) {
+            throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, `Invalid field: ${error.issues[0]?.message || 'Unknown validation error'}`);
+        }
+        throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, 'Invalid field: Validation failed');
+    }
+}
+/**
+ * Validate an operator against Zod schema
+ */
+function validateOperator(operator) {
+    if (typeof operator !== 'string') {
+        throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, 'Operator must be a string');
+    }
+    try {
+        const result = OperatorSchema.parse(operator);
+        return result;
+    }
+    catch (error) {
+        if (error instanceof zod_1.z.ZodError) {
+            throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, `Invalid operator: ${error.issues[0]?.message || 'Unknown validation error'}`);
+        }
+        throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, 'Invalid operator: Validation failed');
+    }
+}
+/**
+ * Validate a logical operator against Zod schema
+ */
+function validateLogicalOperator(operator) {
+    if (typeof operator !== 'string') {
+        throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, 'Logical operator must be a string');
+    }
+    try {
+        const result = LogicalOperatorSchema.parse(operator);
+        return result;
+    }
+    catch (error) {
+        if (error instanceof zod_1.z.ZodError) {
+            throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, `Invalid logical operator: ${error.issues[0]?.message || 'Unknown validation error'}`);
+        }
+        throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, 'Invalid logical operator: Validation failed');
+    }
+}
+/**
+ * Validate and normalize a value using custom logic (more comprehensive than Zod for this use case)
+ */
+function validateValue(value) {
+    // Handle null/undefined
+    if (value === null || value === undefined) {
+        throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, 'Invalid value type');
+    }
+    // Handle string values
+    if (typeof value === 'string') {
+        return value;
+    }
+    // Handle boolean values
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    // Handle number values with infinite/NaN checks
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value)) {
+            throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, 'Numeric values must be finite, not infinite or NaN');
+        }
+        return value;
+    }
+    // Handle array values
+    if (Array.isArray(value)) {
+        if (value.length > 100) {
+            throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, 'Array values cannot exceed 100 elements');
+        }
+        if (value.length === 0) {
+            return [];
+        }
+        // Check array type consistency with proper type guards
+        const firstElementType = typeof value[0];
+        if (firstElementType !== 'string' && firstElementType !== 'number') {
+            throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, 'Array elements must be all strings or all finite numbers, not mixed');
+        }
+        // Validate all elements are of the same type and valid
+        for (let i = 0; i < value.length; i++) {
+            const element = value[i];
+            const elementType = typeof element;
+            // Additional safety: reject null/undefined/object elements
+            if (element === null || element === undefined || typeof element === 'object') {
+                throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, 'Array elements must be strings, numbers, or booleans, not objects');
+            }
+            if (elementType !== firstElementType) {
+                throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, 'Array elements must be all strings or all finite numbers, not mixed');
+            }
+            if (firstElementType === 'number') {
+                // Type-safe numeric validation without casting
+                if (typeof element !== 'number' || !Number.isFinite(element)) {
+                    throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, 'Array numeric values must be finite, not infinite or NaN');
+                }
+            }
+            if (firstElementType === 'string') {
+                // Type-safe string validation with comprehensive sanitization
+                if (typeof element !== 'string') {
+                    throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, 'Array string elements must be strings');
+                }
+                // Apply comprehensive input sanitization to all string array elements
+                // This prevents injection attacks in bulk operations
+                try {
+                    value[i] = sanitizeString(element);
+                }
+                catch (sanitizationError) {
+                    throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, `Array element ${i} contains potentially dangerous content: ${sanitizationError instanceof Error ? sanitizationError.message : 'Unknown error'}`);
+                }
+            }
+        }
+        // Type-safe return without unsafe casting - we've validated the types above
+        if (firstElementType === 'string') {
+            // We've proven all elements are strings
+            return value;
+        }
+        else if (firstElementType === 'number') {
+            // We've proven all elements are finite numbers
+            return value;
+        }
+        else {
+            // This should never happen due to earlier validation
+            throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, 'Array contains unsupported element types');
+        }
+    }
+    // Reject all other types
+    throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, 'Invalid value type');
+}
+/**
+ * Schema for filter conditions
+ */
+const ConditionSchema = zod_1.z.object({
+    field: FieldSchema,
+    operator: OperatorSchema,
+    value: zod_1.z.union([
+        zod_1.z.string(),
+        zod_1.z.number(),
+        zod_1.z.boolean(),
+        zod_1.z.array(zod_1.z.string()),
+        zod_1.z.array(zod_1.z.number()),
+        zod_1.z.null()
+    ]),
+});
+/**
+ * Validate a filter condition object using Zod schema
+ */
+function validateCondition(condition) {
+    try {
+        const result = ConditionSchema.parse(condition);
+        return result;
+    }
+    catch (error) {
+        if (error instanceof zod_1.z.ZodError) {
+            throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, `Invalid condition: ${error.issues[0]?.message || 'Condition validation failed'}`);
+        }
+        throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, 'Invalid condition: Validation failed');
+    }
+}
+/**
+ * Zod schema for filter groups
+ */
+const FilterGroupSchema = zod_1.z.object({
+    operator: LogicalOperatorSchema,
+    conditions: zod_1.z.array(ConditionSchema).min(1).max(MAX_CONDITIONS)
+});
+/**
+ * Zod schema for filter expressions
+ */
+const FilterExpressionSchema = zod_1.z.object({
+    groups: zod_1.z.array(FilterGroupSchema).min(1).max(MAX_NESTING_DEPTH),
+    operator: LogicalOperatorSchema.optional()
+}).refine((expr) => {
+    // Check total conditions across all groups
+    const totalConditions = expr.groups.reduce((sum, group) => sum + group.conditions.length, 0);
+    return totalConditions <= MAX_CONDITIONS;
+}, {
+    message: `Filter expression cannot exceed ${MAX_CONDITIONS} total conditions`
+});
+/**
+ * Validate a filter expression using Zod schema with comprehensive type safety
+ */
+function validateFilterExpression(expression) {
+    try {
+        // Use Zod for comprehensive type-safe validation
+        const result = FilterExpressionSchema.parse(expression);
+        // Additional runtime checks for edge cases Zod might not catch
+        if (result.groups.length === 0) {
+            throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, 'Filter expression must have at least one group');
+        }
+        // Validate each condition individually for additional safety
+        let totalConditions = 0;
+        for (let i = 0; i < result.groups.length; i++) {
+            const group = result.groups[i];
+            // Type guard to ensure group is defined
+            if (!group) {
+                throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, `Group ${i} is undefined`);
+            }
+            // Validate operator with stricter validation
+            try {
+                validateLogicalOperator(group.operator);
+            }
+            catch (error) {
+                throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, `Group ${i} has invalid operator: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+            // Validate each condition individually
+            for (let j = 0; j < group.conditions.length; j++) {
+                const condition = group.conditions[j];
+                try {
+                    validateCondition(condition);
+                }
+                catch (error) {
+                    throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, `Group ${i}, condition ${j}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                }
+                totalConditions++;
+            }
+        }
+        // Final check for total conditions
+        if (totalConditions > MAX_CONDITIONS) {
+            throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, `Filter expression cannot exceed ${MAX_CONDITIONS} total conditions`);
+        }
+        // Type-safe return - Zod has validated the structure
+        return result;
+    }
+    catch (error) {
+        if (error instanceof zod_1.z.ZodError) {
+            // Check for specific Zod errors and provide better error messages
+            const firstIssue = error.issues[0];
+            if (firstIssue) {
+                // Handle empty groups array
+                if (firstIssue.code === 'too_small' && firstIssue.path.length > 0 && firstIssue.path[firstIssue.path.length - 1] === 'groups') {
+                    throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, 'Filter expression must have at least one group');
+                }
+                // Handle exceed maximum nesting depth or array size
+                if (firstIssue.code === 'too_big') {
+                    if (firstIssue.message.includes('Array must contain at most 10 element(s)')) {
+                        throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, 'Filter expression exceeds maximum nesting depth of 10');
+                    }
+                    if (firstIssue.message.includes('conditions') || firstIssue.message.includes('50') || firstIssue.message.includes('Array must contain at most 50')) {
+                        throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, 'Filter expression cannot exceed 50 total conditions');
+                    }
+                    // Generic too_big error for filter expressions
+                    throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, 'Filter expression exceeds maximum nesting depth of 10');
+                }
+                // Handle "Required" errors which might indicate missing required fields in deeply nested structures
+                if (firstIssue.code === 'invalid_type' && firstIssue.message === 'Required') {
+                    throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, 'Filter expression exceeds maximum nesting depth of 10');
+                }
+                // Check if any issue mentions conditions or 50
+                if (error.issues.some(issue => issue.message.includes('conditions') ||
+                    issue.message.includes('50') ||
+                    issue.message.includes('Array must contain at most 50'))) {
+                    throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, 'Filter expression cannot exceed 50 total conditions');
+                }
+            }
+            const errorDetails = error.issues.map(issue => issue.message).join('; ');
+            throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, `Invalid filter expression: ${errorDetails}`);
+        }
+        if (error instanceof errors_1.MCPError) {
+            throw error; // Re-throw MCPError as-is
+        }
+        throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, `Filter expression validation failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+/**
+ * Safely stringify JSON with comprehensive protection
+ * Prevents prototype pollution and sanitizes string values
+ */
+function safeJsonStringify(obj) {
+    try {
+        // Validate the object structure first - this will throw for invalid structures
+        const validated = validateFilterExpression(obj);
+        // Create a safe copy to prevent prototype pollution
+        const safeObj = createSafeObjectCopy(validated);
+        // Check for circular references before sanitizing
+        if (safeObj === null) {
+            throw new Error('Circular reference detected');
+        }
+        // Recursively sanitize string values in the object (but not operators)
+        const sanitizedObj = sanitizeObjectStrings(safeObj);
+        const jsonString = JSON.stringify(sanitizedObj);
+        return jsonString; // No need to sanitize the JSON string itself since we sanitized values
+    }
+    catch (error) {
+        if (error instanceof errors_1.MCPError) {
+            throw error; // Re-throw MCPError as-is
+        }
+        throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, `Failed to stringify object: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+/**
+ * Safely parse JSON with comprehensive protection
+ * Prevents prototype pollution and validates against dangerous content
+ */
+function safeJsonParse(jsonString) {
+    if (typeof jsonString !== 'string') {
+        throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, 'JSON string must be a string');
+    }
+    // Check for maximum length
+    if (jsonString.length > 50000) {
+        throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, 'JSON string exceeds maximum length');
+    }
+    // Check for prototype pollution patterns before parsing
+    if (containsPrototypePollution(jsonString)) {
+        throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, 'JSON contains potentially dangerous prototype pollution patterns');
+    }
+    try {
+        const parsed = JSON.parse(jsonString);
+        // Create a safe copy to prevent prototype pollution attacks
+        const safeObj = createSafeObjectCopy(parsed);
+        // Validate and sanitize the parsed object
+        return validateFilterExpression(safeObj);
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, `Invalid JSON: ${error.message}`);
+        }
+        if (error instanceof errors_1.MCPError) {
+            throw error; // Re-throw our validation errors
+        }
+        throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, `Failed to parse JSON: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+/**
+ * Validate ID parameters
+ */
+function validateId(id, fieldName) {
+    if (typeof id !== 'number' || !Number.isInteger(id) || id <= 0) {
+        throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, `${fieldName} must be a positive integer`);
+    }
+}
+/**
+ * Validate and convert ID from various formats
+ */
+function validateAndConvertId(id, fieldName) {
+    // Handle booleans - true converts to 1, false is rejected
+    if (typeof id === 'boolean') {
+        if (id === true) {
+            return 1;
+        }
+        throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, `${fieldName} must be a positive integer`);
+    }
+    if (typeof id === 'string') {
+        // Use Number() instead of parseInt for better conversion handling
+        // This handles hex strings like '0x42', exponential like '1e5', etc.
+        const parsed = Number(id);
+        if (!Number.isFinite(parsed) || !Number.isInteger(parsed) || parsed <= 0) {
+            throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, `${fieldName} must be a positive integer`);
+        }
+        return parsed;
+    }
+    if (typeof id === 'number') {
+        validateId(id, fieldName);
+        return id;
+    }
+    throw new errors_1.MCPError(errors_1.ErrorCode.VALIDATION_ERROR, `${fieldName} must be a number or positive integer string`);
+}
+/**
+ * Helper functions for comprehensive input sanitization
+ */
+/**
+ * Checks for prototype pollution patterns in JSON strings
+ */
+function containsPrototypePollution(jsonString) {
+    const lowerJson = jsonString.toLowerCase();
+    // Check for dangerous prototype pollution patterns
+    const pollutionPatterns = [
+        '__proto__',
+        'constructor',
+        'prototype',
+        '"__proto__":',
+        '"constructor":',
+        '"prototype":',
+        '"__proto__":',
+        '{"__proto__"',
+        'constructor.prototype',
+        '__defineGetter__',
+        '__defineSetter__',
+        '__lookupGetter__',
+        '__lookupSetter__'
+    ];
+    return pollutionPatterns.some(pattern => lowerJson.includes(pattern));
+}
+/**
+ * Creates a deep copy of an object while preventing prototype pollution
+ */
+function createSafeObjectCopy(obj, visited = new WeakSet()) {
+    // Handle null and primitive types
+    if (obj === null || typeof obj !== 'object') {
+        return obj;
+    }
+    // Prevent circular reference issues
+    if (visited.has(obj)) {
+        return null;
+    }
+    visited.add(obj);
+    // Handle arrays
+    if (Array.isArray(obj)) {
+        return obj.map(item => createSafeObjectCopy(item, visited));
+    }
+    // Handle Date objects
+    if (obj instanceof Date) {
+        return new Date(obj.getTime());
+    }
+    // Handle objects - create safe copy without prototype chain
+    const safeObj = {};
+    for (const key in obj) {
+        // Skip dangerous prototype properties
+        if (isSafeProperty(key)) {
+            try {
+                const value = obj[key];
+                safeObj[key] = createSafeObjectCopy(value, visited);
+            }
+            catch {
+                // Skip properties that cause errors during copying
+                continue;
+            }
+        }
+    }
+    return safeObj;
+}
+/**
+ * Checks if a property key is safe (not dangerous for prototype pollution)
+ */
+function isSafeProperty(key) {
+    const dangerousKeys = [
+        '__proto__',
+        'constructor',
+        'prototype',
+        '__defineGetter__',
+        '__defineSetter__',
+        '__lookupGetter__',
+        '__lookupSetter__',
+        'hasOwnProperty',
+        'isPrototypeOf',
+        'propertyIsEnumerable',
+        'toLocaleString',
+        'toString',
+        'valueOf'
+    ];
+    return !dangerousKeys.includes(key) && typeof key === 'string';
+}
+/**
+ * Recursively sanitizes all string values in an object
+ * Skips known operator values to avoid HTML entity encoding
+ */
+function sanitizeObjectStrings(obj, visited = new WeakSet(), key = null) {
+    // Handle null and primitive types
+    if (obj === null || typeof obj !== 'object') {
+        if (typeof obj === 'string') {
+            // Don't sanitize known operator values
+            const knownOperators = ['=', '!=', '>', '>=', '<', '<=', 'like', 'in', 'not in', '&&', '||'];
+            if (knownOperators.includes(obj)) {
+                return obj;
+            }
+            return sanitizeString(obj);
+        }
+        return obj;
+    }
+    // Prevent circular reference issues
+    if (visited.has(obj)) {
+        return null;
+    }
+    visited.add(obj);
+    // Handle arrays
+    if (Array.isArray(obj)) {
+        return obj.map(item => sanitizeObjectStrings(item, visited, key));
+    }
+    // Handle Date objects (don't modify)
+    if (obj instanceof Date) {
+        return obj;
+    }
+    // Handle objects
+    const sanitizedObj = {};
+    for (const key in obj) {
+        if (isSafeProperty(key)) {
+            try {
+                const value = obj[key];
+                sanitizedObj[key] = sanitizeObjectStrings(value, visited, key);
+            }
+            catch {
+                // Skip properties that cause errors during sanitization
+                continue;
+            }
+        }
+    }
+    return sanitizedObj;
+}
+//# sourceMappingURL=validation.js.map