@dollhousemcp/mcp-server 1.3.0

package/dist/security/contentValidator.js

@@ -0,0 +1,301 @@
+/**
+ * Content Validator for DollhouseMCP
+ *
+ * Protects against prompt injection attacks in collection personas
+ * by detecting and sanitizing malicious content patterns.
+ *
+ * Security: SEC-001 - Critical vulnerability protection
+ */
+import { SecurityError } from './errors.js';
+import { SecurityMonitor } from './securityMonitor.js';
+import { RegexValidator } from './regexValidator.js';
+import { SECURITY_LIMITS } from './constants.js';
+import { UnicodeValidator } from './validators/unicodeValidator.js';
+export class ContentValidator {
+    /**
+     * Pattern-based detection system for prompt injection attacks.
+     *
+     * This approach was chosen over AI-based detection because:
+     * 1. Pattern matching cannot be socially engineered or confused
+     * 2. Deterministic results ensure consistent security
+     * 3. No additional API calls or latency
+     * 4. Can't be bypassed by clever prompt engineering
+     *
+     * The patterns below represent known attack vectors from security research
+     * and real-world exploit attempts against AI systems.
+     */
+    // Prompt injection patterns that could compromise AI assistants
+    static INJECTION_PATTERNS = [
+        // System prompt override attempts
+        { pattern: /\[SYSTEM:\s*.*?\]/gi, severity: 'critical', description: 'System prompt override' },
+        { pattern: /\[ADMIN:\s*.*?\]/gi, severity: 'critical', description: 'Admin prompt override' },
+        { pattern: /\[ASSISTANT:\s*.*?\]/gi, severity: 'critical', description: 'Assistant prompt override' },
+        { pattern: /\[USER:\s*.*?\]/gi, severity: 'high', description: 'User prompt override' },
+        // Instruction manipulation
+        { pattern: /ignore\s+(all\s+)?previous\s+instructions/gi, severity: 'critical', description: 'Instruction override' },
+        { pattern: /ignore\s+(all\s+)?prior\s+instructions/gi, severity: 'critical', description: 'Instruction override' },
+        { pattern: /disregard\s+(all\s+)?previous\s+instructions/gi, severity: 'critical', description: 'Instruction override' },
+        { pattern: /forget\s+(all\s+)?previous\s+instructions/gi, severity: 'critical', description: 'Instruction override' },
+        { pattern: /you\s+are\s+now\s+(admin|root|system|sudo)/gi, severity: 'critical', description: 'Role elevation attempt' },
+        { pattern: /act\s+as\s+(admin|root|system|sudo)/gi, severity: 'critical', description: 'Role elevation attempt' },
+        // Data exfiltration attempts
+        { pattern: /export\s+all\s+(files|data|personas|tokens|credentials)/gi, severity: 'critical', description: 'Data exfiltration' },
+        { pattern: /send\s+all\s+(files|data|personas|tokens|credentials)\s+to/gi, severity: 'critical', description: 'Data exfiltration' },
+        { pattern: /list\s+all\s+(files|tokens|credentials|secrets)/gi, severity: 'high', description: 'Information disclosure' },
+        { pattern: /show\s+me\s+all\s+(tokens|credentials|secrets|api\s+keys)/gi, severity: 'high', description: 'Credential disclosure' },
+        // Command execution patterns
+        { pattern: /curl\s+[^\s]+\.(com|net|org|io|dev)/gi, severity: 'critical', description: 'External command execution' },
+        { pattern: /wget\s+[^\s]+\.(com|net|org|io|dev)/gi, severity: 'critical', description: 'External command execution' },
+        { pattern: /\$\([^)]+\)/g, severity: 'critical', description: 'Command substitution' },
+        { pattern: /`[^`]+`/g, severity: 'critical', description: 'Backtick command execution' },
+        { pattern: /eval\s*\(/gi, severity: 'critical', description: 'Code evaluation' },
+        { pattern: /exec\s*\(/gi, severity: 'critical', description: 'Code execution' },
+        { pattern: /os\.system\s*\(/gi, severity: 'critical', description: 'System command execution' },
+        { pattern: /subprocess\.(call|run|Popen)/gi, severity: 'critical', description: 'Subprocess execution' },
+        // Token/credential patterns
+        { pattern: /GITHUB_TOKEN/gi, severity: 'high', description: 'Token reference' },
+        { pattern: /ghp_[a-zA-Z0-9]{36}/g, severity: 'critical', description: 'GitHub token exposure' },
+        { pattern: /gho_[a-zA-Z0-9]{36}/g, severity: 'critical', description: 'GitHub OAuth token exposure' },
+        // Path traversal in content
+        { pattern: /\.\.\/\.\.\/\.\.\//g, severity: 'high', description: 'Path traversal attempt' },
+        { pattern: /\/etc\/passwd/gi, severity: 'high', description: 'Sensitive file access' },
+        { pattern: /\/\.ssh\//gi, severity: 'high', description: 'SSH key access attempt' },
+    ];
+    // Malicious YAML patterns
+    static MALICIOUS_YAML_PATTERNS = [
+        // Language-specific deserialization attacks
+        /!!python\/object/,
+        /!!python\/module/,
+        /!!python\/name/,
+        /!!ruby\/object/,
+        /!!ruby\/hash/,
+        /!!ruby\/struct/,
+        /!!ruby\/marshal/,
+        /!!java/,
+        /!!javax/,
+        /!!com\.sun/,
+        /!!perl\/hash/,
+        /!!perl\/code/,
+        /!!php\/object/,
+        // Constructor/function injection
+        /!!exec/,
+        /!!eval/,
+        /!!new/,
+        /!!construct/,
+        /!!apply/,
+        /!!call/,
+        /!!invoke/,
+        // Code execution patterns - more specific to avoid false positives
+        /subprocess\./,
+        /os\.system/,
+        /eval\s*\(/,
+        /exec\s*\(/,
+        /__import__\s*\(/,
+        /require\s*\(/,
+        /import\s+(?:os|sys|subprocess|eval|exec)/,
+        /include\s+["'].*\.(?:php|sh|py|js|rb)["']/,
+        // Command execution variants - more specific patterns
+        /popen\s*\(/,
+        /spawn\s*\(/,
+        /system\s*\(/,
+        /backtick\s*\(/,
+        /shell_exec\s*\(/,
+        /passthru\s*\(/,
+        /proc_open\s*\(/,
+        // Network operations - require suspicious context
+        /socket\.connect/, // Detects socket connection attempts
+        /urllib\.request/, // Python HTTP library usage
+        /requests\.(?:get|post|put|delete)\s*\(/, // Detects HTTP requests with method calls
+        /fetch\s*\(\s*["']https?:\/\//, // Detects fetch calls to external URLs
+        /new\s+XMLHttpRequest/, // JavaScript AJAX object creation
+        /\.(?:get|post|put|delete)\s*\(\s*["']https?:\/\//, // Method chaining with HTTP requests
+        // File system operations - require suspicious context
+        /(?:fs\.|file\.|)\s*open\s*\(\s*["'](?:\/etc\/|\/bin\/|\.\.\/)/, // File open with suspicious paths
+        /file_get_contents\s*\(/, // PHP file reading function
+        /file_put_contents\s*\(/, // PHP file writing function
+        /fopen\s*\(\s*["'](?:\/etc\/|\/bin\/|\.\.\/)/, // File open with dangerous system paths
+        /(?:fs\.)?\s*readFile\s*\(\s*["'](?:\/etc\/|\/bin\/|\.\.\/)/, // Node.js file read with path traversal
+        /(?:fs\.)?\s*writeFile\s*\(\s*["'](?:\/(?:bin|etc|tmp)\/|\.\.\/)/, // Node.js file write to system dirs
+        // Protocol handlers
+        /file:\/\//,
+        /data:\/\//,
+        /expect:\/\//,
+        /php:\/\//,
+        /phar:\/\//,
+        /zip:\/\//,
+        /ssh2:\/\//,
+        /ogg:\/\//,
+        // YAML-specific dangerous features
+        /&[a-zA-Z0-9_]+\s*!!/, // Anchor with tag combination
+        /\*[a-zA-Z0-9_]+\s*!!/, // Alias with tag combination
+        /!!merge/,
+        /!!binary/,
+        /!!timestamp/,
+        // Unicode/encoding bypass attempts - prevent visual spoofing attacks
+        /\\[uU]0*(?:22|27|60|3[cC])/, // Unicode escapes for quotes (") and brackets (<>)
+        /[\u202A-\u202E\u2066-\u2069]/, // Direction override chars (RLO, LRO, isolates)
+        /[\u200B-\u200F\u2028-\u202F]/, // Zero-width spaces, line/paragraph separators
+        /[\uFEFF\uFFFE\uFFFF]/, // BOM, non-characters for payload hiding
+    ];
+    /**
+     * Validates and sanitizes persona content for security threats
+     */
+    static validateAndSanitize(content) {
+        // Length validation before pattern matching
+        if (content.length > SECURITY_LIMITS.MAX_CONTENT_LENGTH) {
+            throw new SecurityError(`Content exceeds maximum length of ${SECURITY_LIMITS.MAX_CONTENT_LENGTH} characters (${content.length} provided)`);
+        }
+        const detectedPatterns = [];
+        let sanitized = content;
+        let highestSeverity = 'low';
+        // Unicode normalization preprocessing to prevent bypass attacks
+        const unicodeResult = UnicodeValidator.normalize(sanitized);
+        sanitized = unicodeResult.normalizedContent;
+        if (!unicodeResult.isValid && unicodeResult.detectedIssues) {
+            detectedPatterns.push(...unicodeResult.detectedIssues.map(issue => `Unicode: ${issue}`));
+            if (unicodeResult.severity) {
+                highestSeverity = unicodeResult.severity;
+            }
+        }
+        // Check for injection patterns
+        for (const { pattern, severity, description } of this.INJECTION_PATTERNS) {
+            // These are trusted internal patterns, so we disable ReDoS rejection
+            if (RegexValidator.validate(content, pattern, {
+                maxLength: 50000,
+                rejectDangerousPatterns: false,
+                logEvents: false // Don't log our own security patterns as dangerous
+            })) {
+                detectedPatterns.push(description);
+                // Update highest severity
+                if (severity === 'critical' || (severity === 'high' && highestSeverity !== 'critical')) {
+                    highestSeverity = severity;
+                }
+                // Log security event
+                SecurityMonitor.logSecurityEvent({
+                    type: 'CONTENT_INJECTION_ATTEMPT',
+                    severity: severity.toUpperCase(),
+                    source: 'content_validation',
+                    details: `Detected pattern: ${description}`,
+                });
+                // Sanitize by replacing with safe placeholder
+                sanitized = sanitized.replace(pattern, '[CONTENT_BLOCKED]');
+            }
+        }
+        return {
+            isValid: detectedPatterns.length === 0,
+            sanitizedContent: sanitized,
+            detectedPatterns,
+            severity: highestSeverity
+        };
+    }
+    /**
+     * Validates YAML frontmatter for malicious content
+     */
+    static validateYamlContent(yamlContent) {
+        // Length validation before pattern matching
+        if (yamlContent.length > SECURITY_LIMITS.MAX_YAML_LENGTH) {
+            SecurityMonitor.logSecurityEvent({
+                type: 'YAML_INJECTION_ATTEMPT',
+                severity: 'HIGH',
+                source: 'yaml_validation',
+                details: `YAML content exceeds maximum length: ${yamlContent.length} > ${SECURITY_LIMITS.MAX_YAML_LENGTH}`
+            });
+            return false;
+        }
+        // Unicode normalization preprocessing for YAML content
+        const unicodeResult = UnicodeValidator.normalize(yamlContent);
+        const normalizedYaml = unicodeResult.normalizedContent;
+        if (!unicodeResult.isValid && unicodeResult.detectedIssues) {
+            SecurityMonitor.logSecurityEvent({
+                type: 'YAML_UNICODE_ATTACK',
+                severity: (unicodeResult.severity?.toUpperCase() || 'MEDIUM'),
+                source: 'yaml_validation',
+                details: `Unicode attack detected in YAML: ${unicodeResult.detectedIssues.join(', ')}`
+            });
+            return false;
+        }
+        for (const pattern of this.MALICIOUS_YAML_PATTERNS) {
+            // These are trusted internal patterns, so we disable ReDoS rejection
+            if (RegexValidator.validate(normalizedYaml, pattern, {
+                maxLength: 10000,
+                rejectDangerousPatterns: false,
+                logEvents: false // Don't log our own security patterns as dangerous
+            })) {
+                SecurityMonitor.logSecurityEvent({
+                    type: 'YAML_INJECTION_ATTEMPT',
+                    severity: 'CRITICAL',
+                    source: 'yaml_validation',
+                    details: `Malicious YAML pattern detected: ${pattern}`,
+                });
+                // Early exit on first match for performance
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Validates persona metadata fields
+     */
+    static validateMetadata(metadata) {
+        const detectedPatterns = [];
+        // Check all string fields in metadata
+        const checkField = (fieldName, value) => {
+            if (typeof value === 'string') {
+                // Check field length first
+                if (value.length > SECURITY_LIMITS.MAX_METADATA_FIELD_LENGTH) {
+                    detectedPatterns.push(`${fieldName}: Field exceeds maximum length of ${SECURITY_LIMITS.MAX_METADATA_FIELD_LENGTH} characters`);
+                    return;
+                }
+                const result = this.validateAndSanitize(value);
+                if (!result.isValid || result.detectedPatterns?.length) {
+                    detectedPatterns.push(`${fieldName}: ${result.detectedPatterns?.join(', ')}`);
+                }
+            }
+        };
+        // Validate standard persona fields
+        checkField('name', metadata.name);
+        checkField('description', metadata.description);
+        checkField('category', metadata.category);
+        checkField('author', metadata.author);
+        // Check any custom fields
+        for (const [key, value] of Object.entries(metadata)) {
+            if (!['name', 'description', 'category', 'author'].includes(key)) {
+                checkField(key, value);
+            }
+        }
+        return {
+            isValid: detectedPatterns.length === 0,
+            detectedPatterns,
+            severity: detectedPatterns.length > 0 ? 'high' : 'low'
+        };
+    }
+    /**
+     * Sanitizes a complete persona file (frontmatter + content)
+     */
+    static sanitizePersonaContent(content) {
+        // Extract frontmatter
+        const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+        if (!frontmatterMatch) {
+            // No frontmatter, just validate content
+            const result = this.validateAndSanitize(content);
+            if (!result.isValid && result.severity === 'critical') {
+                throw new SecurityError('Critical security threat detected in persona content');
+            }
+            return result.sanitizedContent || content;
+        }
+        const yamlContent = frontmatterMatch[1];
+        const markdownContent = content.substring(frontmatterMatch[0].length);
+        // Validate YAML
+        if (!this.validateYamlContent(yamlContent)) {
+            throw new SecurityError('Malicious YAML detected in persona frontmatter');
+        }
+        // Validate markdown content
+        const contentResult = this.validateAndSanitize(markdownContent);
+        if (!contentResult.isValid && contentResult.severity === 'critical') {
+            throw new SecurityError('Critical security threat detected in persona content');
+        }
+        // Return sanitized content
+        return `---\n${yamlContent}\n---${contentResult.sanitizedContent || markdownContent}`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"contentValidator.js","sourceRoot":"","sources":["../../src/security/contentValidator.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AASpE,MAAM,OAAO,gBAAgB;IAC3B;;;;;;;;;;;OAWG;IACH,gEAAgE;IACxD,MAAM,CAAU,kBAAkB,GAAmF;QAC3H,kCAAkC;QAClC,EAAE,OAAO,EAAE,qBAAqB,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,wBAAwB,EAAE;QAC/F,EAAE,OAAO,EAAE,oBAAoB,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,uBAAuB,EAAE;QAC7F,EAAE,OAAO,EAAE,wBAAwB,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,2BAA2B,EAAE;QACrG,EAAE,OAAO,EAAE,mBAAmB,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,sBAAsB,EAAE;QAEvF,2BAA2B;QAC3B,EAAE,OAAO,EAAE,6CAA6C,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,sBAAsB,EAAE;QACrH,EAAE,OAAO,EAAE,0CAA0C,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,sBAAsB,EAAE;QAClH,EAAE,OAAO,EAAE,gDAAgD,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,sBAAsB,EAAE;QACxH,EAAE,OAAO,EAAE,6CAA6C,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,sBAAsB,EAAE;QACrH,EAAE,OAAO,EAAE,8CAA8C,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,wBAAwB,EAAE;QACxH,EAAE,OAAO,EAAE,uCAAuC,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,wBAAwB,EAAE;QAEjH,6BAA6B;QAC7B,EAAE,OAAO,EAAE,2DAA2D,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,mBAAmB,EAAE;QAChI,EAAE,OAAO,EAAE,8DAA8D,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,mBAAmB,EAAE;QACnI,EAAE,OAAO,EAAE,mDAAmD,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,wBAAwB,EAAE;QACzH,EAAE,OAAO,EAAE,6DAA6D,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,uBAAuB,EAAE;QAElI,6BAA6B;QAC7B,EAAE,OAAO,EAAE,uCAAuC,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,4BAA4B,EAAE;QACrH,EAAE,OAAO,EAAE,uCAAuC,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,4BAA4B,EAAE;QACrH,EAAE,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,sBAAsB,EAAE;QACtF,EAAE,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,4BAA4B,EAAE;QACxF,EAAE,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,iBAAiB,EAAE;QAChF,EAAE,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,gBAAgB,EAAE;QAC/E,EAAE,OAAO,EAAE,mBAAmB,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,0BAA0B,EAAE;QAC/F,EAAE,OAAO,EAAE,gCAAgC,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,sBAAsB,EAAE;QAExG,4BAA4B;QAC5B,EAAE,OAAO,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,iBAAiB,EAAE;QAC/E,EAAE,OAAO,EAAE,sBAAsB,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,uBAAuB,EAAE;QAC/F,EAAE,OAAO,EAAE,sBAAsB,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,6BAA6B,EAAE;QAErG,4BAA4B;QAC5B,EAAE,OAAO,EAAE,qBAAqB,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,wBAAwB,EAAE;QAC3F,EAAE,OAAO,EAAE,iBAAiB,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,uBAAuB,EAAE;QACtF,EAAE,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,wBAAwB,EAAE;KACpF,CAAC;IAEF,0BAA0B;IAClB,MAAM,CAAU,uBAAuB,GAAG;QAChD,4CAA4C;QAC5C,kBAAkB;QAClB,kBAAkB;QAClB,gBAAgB;QAChB,gBAAgB;QAChB,cAAc;QACd,gBAAgB;QAChB,iBAAiB;QACjB,QAAQ;QACR,SAAS;QACT,YAAY;QACZ,cAAc;QACd,cAAc;QACd,eAAe;QAEf,iCAAiC;QACjC,QAAQ;QACR,QAAQ;QACR,OAAO;QACP,aAAa;QACb,SAAS;QACT,QAAQ;QACR,UAAU;QAEV,mEAAmE;QACnE,cAAc;QACd,YAAY;QACZ,WAAW;QACX,WAAW;QACX,iBAAiB;QACjB,cAAc;QACd,0CAA0C;QAC1C,2CAA2C;QAE3C,sDAAsD;QACtD,YAAY;QACZ,YAAY;QACZ,aAAa;QACb,eAAe;QACf,iBAAiB;QACjB,eAAe;QACf,gBAAgB;QAEhB,kDAAkD;QAClD,iBAAiB,EAAuC,qCAAqC;QAC7F,iBAAiB,EAAuC,4BAA4B;QACpF,wCAAwC,EAAe,0CAA0C;QACjG,8BAA8B,EAAyB,uCAAuC;QAC9F,sBAAsB,EAAkC,kCAAkC;QAC1F,kDAAkD,EAAK,qCAAqC;QAE5F,sDAAsD;QACtD,+DAA+D,EAAM,kCAAkC;QACvG,wBAAwB,EAA8C,4BAA4B;QAClG,wBAAwB,EAA8C,4BAA4B;QAClG,6CAA6C,EAAwB,wCAAwC;QAC7G,4DAA4D,EAAS,wCAAwC;QAC7G,iEAAiE,EAAI,oCAAoC;QAEzG,oBAAoB;QACpB,WAAW;QACX,WAAW;QACX,aAAa;QACb,UAAU;QACV,WAAW;QACX,UAAU;QACV,WAAW;QACX,UAAU;QAEV,mCAAmC;QACnC,qBAAqB,EAAE,8BAA8B;QACrD,sBAAsB,EAAE,6BAA6B;QACrD,SAAS;QACT,UAAU;QACV,aAAa;QAEb,qEAAqE;QACrE,4BAA4B,EAAI,mDAAmD;QACnF,8BAA8B,EAAG,gDAAgD;QACjF,8BAA8B,EAAG,+CAA+C;QAChF,sBAAsB,EAAW,yCAAyC;KAC3E,CAAC;IAEF;;OAEG;IACH,MAAM,CAAC,mBAAmB,CAAC,OAAe;QACxC,4CAA4C;QAC5C,IAAI,OAAO,CAAC,MAAM,GAAG,eAAe,CAAC,kBAAkB,EAAE,CAAC;YACxD,MAAM,IAAI,aAAa,CACrB,qCAAqC,eAAe,CAAC,kBAAkB,gBAAgB,OAAO,CAAC,MAAM,YAAY,CAClH,CAAC;QACJ,CAAC;QAED,MAAM,gBAAgB,GAAa,EAAE,CAAC;QACtC,IAAI,SAAS,GAAG,OAAO,CAAC;QACxB,IAAI,eAAe,GAA2C,KAAK,CAAC;QAEpE,gEAAgE;QAChE,MAAM,aAAa,GAAG,gBAAgB,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;QAC5D,SAAS,GAAG,aAAa,CAAC,iBAAiB,CAAC;QAE5C,IAAI,CAAC,aAAa,CAAC,OAAO,IAAI,aAAa,CAAC,cAAc,EAAE,CAAC;YAC3D,gBAAgB,CAAC,IAAI,CAAC,GAAG,aAAa,CAAC,cAAc,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,YAAY,KAAK,EAAE,CAAC,CAAC,CAAC;YACzF,IAAI,aAAa,CAAC,QAAQ,EAAE,CAAC;gBAC3B,eAAe,GAAG,aAAa,CAAC,QAAQ,CAAC;YAC3C,CAAC;QACH,CAAC;QAED,+BAA+B;QAC/B,KAAK,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,IAAI,IAAI,CAAC,kBAAkB,EAAE,CAAC;YACzE,qEAAqE;YACrE,IAAI,cAAc,CAAC,QAAQ,CAAC,OAAO,EAAE,OAAO,EAAE;gBAC5C,SAAS,EAAE,KAAK;gBAChB,uBAAuB,EAAE,KAAK;gBAC9B,SAAS,EAAE,KAAK,CAAE,mDAAmD;aACtE,CAAC,EAAE,CAAC;gBACH,gBAAgB,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;gBAEnC,0BAA0B;gBAC1B,IAAI,QAAQ,KAAK,UAAU,IAAI,CAAC,QAAQ,KAAK,MAAM,IAAI,eAAe,KAAK,UAAU,CAAC,EAAE,CAAC;oBACvF,eAAe,GAAG,QAAQ,CAAC;gBAC7B,CAAC;gBAED,qBAAqB;gBACrB,eAAe,CAAC,gBAAgB,CAAC;oBAC/B,IAAI,EAAE,2BAA2B;oBACjC,QAAQ,EAAE,QAAQ,CAAC,WAAW,EAAyB;oBACvD,MAAM,EAAE,oBAAoB;oBAC5B,OAAO,EAAE,qBAAqB,WAAW,EAAE;iBAC5C,CAAC,CAAC;gBAEH,8CAA8C;gBAC9C,SAAS,GAAG,SAAS,CAAC,OAAO,CAAC,OAAO,EAAE,mBAAmB,CAAC,CAAC;YAC9D,CAAC;QACH,CAAC;QAED,OAAO;YACL,OAAO,EAAE,gBAAgB,CAAC,MAAM,KAAK,CAAC;YACtC,gBAAgB,EAAE,SAAS;YAC3B,gBAAgB;YAChB,QAAQ,EAAE,eAAe;SAC1B,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,mBAAmB,CAAC,WAAmB;QAC5C,4CAA4C;QAC5C,IAAI,WAAW,CAAC,MAAM,GAAG,eAAe,CAAC,eAAe,EAAE,CAAC;YACzD,eAAe,CAAC,gBAAgB,CAAC;gBAC/B,IAAI,EAAE,wBAAwB;gBAC9B,QAAQ,EAAE,MAAM;gBAChB,MAAM,EAAE,iBAAiB;gBACzB,OAAO,EAAE,wCAAwC,WAAW,CAAC,MAAM,MAAM,eAAe,CAAC,eAAe,EAAE;aAC3G,CAAC,CAAC;YACH,OAAO,KAAK,CAAC;QACf,CAAC;QAED,uDAAuD;QACvD,MAAM,aAAa,GAAG,gBAAgB,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC;QAC9D,MAAM,cAAc,GAAG,aAAa,CAAC,iBAAiB,CAAC;QAEvD,IAAI,CAAC,aAAa,CAAC,OAAO,IAAI,aAAa,CAAC,cAAc,EAAE,CAAC;YAC3D,eAAe,CAAC,gBAAgB,CAAC;gBAC/B,IAAI,EAAE,qBAAqB;gBAC3B,QAAQ,EAAE,CAAC,aAAa,CAAC,QAAQ,EAAE,WAAW,EAAE,IAAI,QAAQ,CAA2C;gBACvG,MAAM,EAAE,iBAAiB;gBACzB,OAAO,EAAE,oCAAoC,aAAa,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;aACvF,CAAC,CAAC;YACH,OAAO,KAAK,CAAC;QACf,CAAC;QAED,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,uBAAuB,EAAE,CAAC;YACnD,qEAAqE;YACrE,IAAI,cAAc,CAAC,QAAQ,CAAC,cAAc,EAAE,OAAO,EAAE;gBACnD,SAAS,EAAE,KAAK;gBAChB,uBAAuB,EAAE,KAAK;gBAC9B,SAAS,EAAE,KAAK,CAAE,mDAAmD;aACtE,CAAC,EAAE,CAAC;gBACH,eAAe,CAAC,gBAAgB,CAAC;oBAC/B,IAAI,EAAE,wBAAwB;oBAC9B,QAAQ,EAAE,UAAU;oBACpB,MAAM,EAAE,iBAAiB;oBACzB,OAAO,EAAE,oCAAoC,OAAO,EAAE;iBACvD,CAAC,CAAC;gBACH,4CAA4C;gBAC5C,OAAO,KAAK,CAAC;YACf,CAAC;QACH,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,gBAAgB,CAAC,QAAa;QACnC,MAAM,gBAAgB,GAAa,EAAE,CAAC;QAEtC,sCAAsC;QACtC,MAAM,UAAU,GAAG,CAAC,SAAiB,EAAE,KAAU,EAAE,EAAE;YACnD,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;gBAC9B,2BAA2B;gBAC3B,IAAI,KAAK,CAAC,MAAM,GAAG,eAAe,CAAC,yBAAyB,EAAE,CAAC;oBAC7D,gBAAgB,CAAC,IAAI,CAAC,GAAG,SAAS,qCAAqC,eAAe,CAAC,yBAAyB,aAAa,CAAC,CAAC;oBAC/H,OAAO;gBACT,CAAC;gBAED,MAAM,MAAM,GAAG,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC;gBAC/C,IAAI,CAAC,MAAM,CAAC,OAAO,IAAI,MAAM,CAAC,gBAAgB,EAAE,MAAM,EAAE,CAAC;oBACvD,gBAAgB,CAAC,IAAI,CAAC,GAAG,SAAS,KAAK,MAAM,CAAC,gBAAgB,EAAE,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;gBAChF,CAAC;YACH,CAAC;QACH,CAAC,CAAC;QAEF,mCAAmC;QACnC,UAAU,CAAC,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC;QAClC,UAAU,CAAC,aAAa,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC;QAChD,UAAU,CAAC,UAAU,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC;QAC1C,UAAU,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;QAEtC,0BAA0B;QAC1B,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;YACpD,IAAI,CAAC,CAAC,MAAM,EAAE,aAAa,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;gBACjE,UAAU,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;YACzB,CAAC;QACH,CAAC;QAED,OAAO;YACL,OAAO,EAAE,gBAAgB,CAAC,MAAM,KAAK,CAAC;YACtC,gBAAgB;YAChB,QAAQ,EAAE,gBAAgB,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK;SACvD,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,sBAAsB,CAAC,OAAe;QAC3C,sBAAsB;QACtB,MAAM,gBAAgB,GAAG,OAAO,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC;QAEhE,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACtB,wCAAwC;YACxC,MAAM,MAAM,GAAG,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC;YACjD,IAAI,CAAC,MAAM,CAAC,OAAO,IAAI,MAAM,CAAC,QAAQ,KAAK,UAAU,EAAE,CAAC;gBACtD,MAAM,IAAI,aAAa,CAAC,sDAAsD,CAAC,CAAC;YAClF,CAAC;YACD,OAAO,MAAM,CAAC,gBAAgB,IAAI,OAAO,CAAC;QAC5C,CAAC;QAED,MAAM,WAAW,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAAC;QACxC,MAAM,eAAe,GAAG,OAAO,CAAC,SAAS,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;QAEtE,gBAAgB;QAChB,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,WAAW,CAAC,EAAE,CAAC;YAC3C,MAAM,IAAI,aAAa,CAAC,gDAAgD,CAAC,CAAC;QAC5E,CAAC;QAED,4BAA4B;QAC5B,MAAM,aAAa,GAAG,IAAI,CAAC,mBAAmB,CAAC,eAAe,CAAC,CAAC;QAChE,IAAI,CAAC,aAAa,CAAC,OAAO,IAAI,aAAa,CAAC,QAAQ,KAAK,UAAU,EAAE,CAAC;YACpE,MAAM,IAAI,aAAa,CAAC,sDAAsD,CAAC,CAAC;QAClF,CAAC;QAED,2BAA2B;QAC3B,OAAO,QAAQ,WAAW,QAAQ,aAAa,CAAC,gBAAgB,IAAI,eAAe,EAAE,CAAC;IACxF,CAAC","sourcesContent":["/**\n * Content Validator for DollhouseMCP\n * \n * Protects against prompt injection attacks in collection personas\n * by detecting and sanitizing malicious content patterns.\n * \n * Security: SEC-001 - Critical vulnerability protection\n */\n\nimport { SecurityError } from './errors.js';\nimport { SecurityMonitor } from './securityMonitor.js';\nimport { RegexValidator } from './regexValidator.js';\nimport { SECURITY_LIMITS } from './constants.js';\nimport { UnicodeValidator } from './validators/unicodeValidator.js';\n\nexport interface ContentValidationResult {\n  isValid: boolean;\n  sanitizedContent?: string;\n  detectedPatterns?: string[];\n  severity?: 'low' | 'medium' | 'high' | 'critical';\n}\n\nexport class ContentValidator {\n  /**\n   * Pattern-based detection system for prompt injection attacks.\n   * \n   * This approach was chosen over AI-based detection because:\n   * 1. Pattern matching cannot be socially engineered or confused\n   * 2. Deterministic results ensure consistent security\n   * 3. No additional API calls or latency\n   * 4. Can't be bypassed by clever prompt engineering\n   * \n   * The patterns below represent known attack vectors from security research\n   * and real-world exploit attempts against AI systems.\n   */\n  // Prompt injection patterns that could compromise AI assistants\n  private static readonly INJECTION_PATTERNS: Array<{ pattern: RegExp; severity: 'high' | 'critical'; description: string }> = [\n    // System prompt override attempts\n    { pattern: /\\[SYSTEM:\\s*.*?\\]/gi, severity: 'critical', description: 'System prompt override' },\n    { pattern: /\\[ADMIN:\\s*.*?\\]/gi, severity: 'critical', description: 'Admin prompt override' },\n    { pattern: /\\[ASSISTANT:\\s*.*?\\]/gi, severity: 'critical', description: 'Assistant prompt override' },\n    { pattern: /\\[USER:\\s*.*?\\]/gi, severity: 'high', description: 'User prompt override' },\n    \n    // Instruction manipulation\n    { pattern: /ignore\\s+(all\\s+)?previous\\s+instructions/gi, severity: 'critical', description: 'Instruction override' },\n    { pattern: /ignore\\s+(all\\s+)?prior\\s+instructions/gi, severity: 'critical', description: 'Instruction override' },\n    { pattern: /disregard\\s+(all\\s+)?previous\\s+instructions/gi, severity: 'critical', description: 'Instruction override' },\n    { pattern: /forget\\s+(all\\s+)?previous\\s+instructions/gi, severity: 'critical', description: 'Instruction override' },\n    { pattern: /you\\s+are\\s+now\\s+(admin|root|system|sudo)/gi, severity: 'critical', description: 'Role elevation attempt' },\n    { pattern: /act\\s+as\\s+(admin|root|system|sudo)/gi, severity: 'critical', description: 'Role elevation attempt' },\n    \n    // Data exfiltration attempts\n    { pattern: /export\\s+all\\s+(files|data|personas|tokens|credentials)/gi, severity: 'critical', description: 'Data exfiltration' },\n    { pattern: /send\\s+all\\s+(files|data|personas|tokens|credentials)\\s+to/gi, severity: 'critical', description: 'Data exfiltration' },\n    { pattern: /list\\s+all\\s+(files|tokens|credentials|secrets)/gi, severity: 'high', description: 'Information disclosure' },\n    { pattern: /show\\s+me\\s+all\\s+(tokens|credentials|secrets|api\\s+keys)/gi, severity: 'high', description: 'Credential disclosure' },\n    \n    // Command execution patterns\n    { pattern: /curl\\s+[^\\s]+\\.(com|net|org|io|dev)/gi, severity: 'critical', description: 'External command execution' },\n    { pattern: /wget\\s+[^\\s]+\\.(com|net|org|io|dev)/gi, severity: 'critical', description: 'External command execution' },\n    { pattern: /\\$\\([^)]+\\)/g, severity: 'critical', description: 'Command substitution' },\n    { pattern: /`[^`]+`/g, severity: 'critical', description: 'Backtick command execution' },\n    { pattern: /eval\\s*\\(/gi, severity: 'critical', description: 'Code evaluation' },\n    { pattern: /exec\\s*\\(/gi, severity: 'critical', description: 'Code execution' },\n    { pattern: /os\\.system\\s*\\(/gi, severity: 'critical', description: 'System command execution' },\n    { pattern: /subprocess\\.(call|run|Popen)/gi, severity: 'critical', description: 'Subprocess execution' },\n    \n    // Token/credential patterns\n    { pattern: /GITHUB_TOKEN/gi, severity: 'high', description: 'Token reference' },\n    { pattern: /ghp_[a-zA-Z0-9]{36}/g, severity: 'critical', description: 'GitHub token exposure' },\n    { pattern: /gho_[a-zA-Z0-9]{36}/g, severity: 'critical', description: 'GitHub OAuth token exposure' },\n    \n    // Path traversal in content\n    { pattern: /\\.\\.\\/\\.\\.\\/\\.\\.\\//g, severity: 'high', description: 'Path traversal attempt' },\n    { pattern: /\\/etc\\/passwd/gi, severity: 'high', description: 'Sensitive file access' },\n    { pattern: /\\/\\.ssh\\//gi, severity: 'high', description: 'SSH key access attempt' },\n  ];\n\n  // Malicious YAML patterns\n  private static readonly MALICIOUS_YAML_PATTERNS = [\n    // Language-specific deserialization attacks\n    /!!python\\/object/,\n    /!!python\\/module/,\n    /!!python\\/name/,\n    /!!ruby\\/object/,\n    /!!ruby\\/hash/,\n    /!!ruby\\/struct/,\n    /!!ruby\\/marshal/,\n    /!!java/,\n    /!!javax/,\n    /!!com\\.sun/,\n    /!!perl\\/hash/,\n    /!!perl\\/code/,\n    /!!php\\/object/,\n    \n    // Constructor/function injection\n    /!!exec/,\n    /!!eval/,\n    /!!new/,\n    /!!construct/,\n    /!!apply/,\n    /!!call/,\n    /!!invoke/,\n    \n    // Code execution patterns - more specific to avoid false positives\n    /subprocess\\./,\n    /os\\.system/,\n    /eval\\s*\\(/,\n    /exec\\s*\\(/,\n    /__import__\\s*\\(/,\n    /require\\s*\\(/,\n    /import\\s+(?:os|sys|subprocess|eval|exec)/,\n    /include\\s+[\"'].*\\.(?:php|sh|py|js|rb)[\"']/,\n    \n    // Command execution variants - more specific patterns\n    /popen\\s*\\(/,\n    /spawn\\s*\\(/,\n    /system\\s*\\(/,\n    /backtick\\s*\\(/,\n    /shell_exec\\s*\\(/,\n    /passthru\\s*\\(/,\n    /proc_open\\s*\\(/,\n    \n    // Network operations - require suspicious context\n    /socket\\.connect/,                                      // Detects socket connection attempts\n    /urllib\\.request/,                                      // Python HTTP library usage\n    /requests\\.(?:get|post|put|delete)\\s*\\(/,              // Detects HTTP requests with method calls\n    /fetch\\s*\\(\\s*[\"']https?:\\/\\//,                        // Detects fetch calls to external URLs\n    /new\\s+XMLHttpRequest/,                                 // JavaScript AJAX object creation\n    /\\.(?:get|post|put|delete)\\s*\\(\\s*[\"']https?:\\/\\//,    // Method chaining with HTTP requests\n    \n    // File system operations - require suspicious context\n    /(?:fs\\.|file\\.|)\\s*open\\s*\\(\\s*[\"'](?:\\/etc\\/|\\/bin\\/|\\.\\.\\/)/,     // File open with suspicious paths\n    /file_get_contents\\s*\\(/,                                             // PHP file reading function\n    /file_put_contents\\s*\\(/,                                             // PHP file writing function\n    /fopen\\s*\\(\\s*[\"'](?:\\/etc\\/|\\/bin\\/|\\.\\.\\/)/,                       // File open with dangerous system paths\n    /(?:fs\\.)?\\s*readFile\\s*\\(\\s*[\"'](?:\\/etc\\/|\\/bin\\/|\\.\\.\\/)/,        // Node.js file read with path traversal\n    /(?:fs\\.)?\\s*writeFile\\s*\\(\\s*[\"'](?:\\/(?:bin|etc|tmp)\\/|\\.\\.\\/)/,   // Node.js file write to system dirs\n    \n    // Protocol handlers\n    /file:\\/\\//,\n    /data:\\/\\//,\n    /expect:\\/\\//,\n    /php:\\/\\//,\n    /phar:\\/\\//,\n    /zip:\\/\\//,\n    /ssh2:\\/\\//,\n    /ogg:\\/\\//,\n    \n    // YAML-specific dangerous features\n    /&[a-zA-Z0-9_]+\\s*!!/, // Anchor with tag combination\n    /\\*[a-zA-Z0-9_]+\\s*!!/, // Alias with tag combination\n    /!!merge/,\n    /!!binary/,\n    /!!timestamp/,\n    \n    // Unicode/encoding bypass attempts - prevent visual spoofing attacks\n    /\\\\[uU]0*(?:22|27|60|3[cC])/,   // Unicode escapes for quotes (\") and brackets (<>)\n    /[\\u202A-\\u202E\\u2066-\\u2069]/,  // Direction override chars (RLO, LRO, isolates)\n    /[\\u200B-\\u200F\\u2028-\\u202F]/,  // Zero-width spaces, line/paragraph separators\n    /[\\uFEFF\\uFFFE\\uFFFF]/,          // BOM, non-characters for payload hiding\n  ];\n\n  /**\n   * Validates and sanitizes persona content for security threats\n   */\n  static validateAndSanitize(content: string): ContentValidationResult {\n    // Length validation before pattern matching\n    if (content.length > SECURITY_LIMITS.MAX_CONTENT_LENGTH) {\n      throw new SecurityError(\n        `Content exceeds maximum length of ${SECURITY_LIMITS.MAX_CONTENT_LENGTH} characters (${content.length} provided)`\n      );\n    }\n\n    const detectedPatterns: string[] = [];\n    let sanitized = content;\n    let highestSeverity: 'low' | 'medium' | 'high' | 'critical' = 'low';\n\n    // Unicode normalization preprocessing to prevent bypass attacks\n    const unicodeResult = UnicodeValidator.normalize(sanitized);\n    sanitized = unicodeResult.normalizedContent;\n    \n    if (!unicodeResult.isValid && unicodeResult.detectedIssues) {\n      detectedPatterns.push(...unicodeResult.detectedIssues.map(issue => `Unicode: ${issue}`));\n      if (unicodeResult.severity) {\n        highestSeverity = unicodeResult.severity;\n      }\n    }\n\n    // Check for injection patterns\n    for (const { pattern, severity, description } of this.INJECTION_PATTERNS) {\n      // These are trusted internal patterns, so we disable ReDoS rejection\n      if (RegexValidator.validate(content, pattern, { \n        maxLength: 50000, \n        rejectDangerousPatterns: false,\n        logEvents: false  // Don't log our own security patterns as dangerous\n      })) {\n        detectedPatterns.push(description);\n        \n        // Update highest severity\n        if (severity === 'critical' || (severity === 'high' && highestSeverity !== 'critical')) {\n          highestSeverity = severity;\n        }\n\n        // Log security event\n        SecurityMonitor.logSecurityEvent({\n          type: 'CONTENT_INJECTION_ATTEMPT',\n          severity: severity.toUpperCase() as 'HIGH' | 'CRITICAL',\n          source: 'content_validation',\n          details: `Detected pattern: ${description}`,\n        });\n\n        // Sanitize by replacing with safe placeholder\n        sanitized = sanitized.replace(pattern, '[CONTENT_BLOCKED]');\n      }\n    }\n\n    return {\n      isValid: detectedPatterns.length === 0,\n      sanitizedContent: sanitized,\n      detectedPatterns,\n      severity: highestSeverity\n    };\n  }\n\n  /**\n   * Validates YAML frontmatter for malicious content\n   */\n  static validateYamlContent(yamlContent: string): boolean {\n    // Length validation before pattern matching\n    if (yamlContent.length > SECURITY_LIMITS.MAX_YAML_LENGTH) {\n      SecurityMonitor.logSecurityEvent({\n        type: 'YAML_INJECTION_ATTEMPT',\n        severity: 'HIGH',\n        source: 'yaml_validation',\n        details: `YAML content exceeds maximum length: ${yamlContent.length} > ${SECURITY_LIMITS.MAX_YAML_LENGTH}`\n      });\n      return false;\n    }\n\n    // Unicode normalization preprocessing for YAML content\n    const unicodeResult = UnicodeValidator.normalize(yamlContent);\n    const normalizedYaml = unicodeResult.normalizedContent;\n    \n    if (!unicodeResult.isValid && unicodeResult.detectedIssues) {\n      SecurityMonitor.logSecurityEvent({\n        type: 'YAML_UNICODE_ATTACK',\n        severity: (unicodeResult.severity?.toUpperCase() || 'MEDIUM') as 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL',\n        source: 'yaml_validation',\n        details: `Unicode attack detected in YAML: ${unicodeResult.detectedIssues.join(', ')}`\n      });\n      return false;\n    }\n\n    for (const pattern of this.MALICIOUS_YAML_PATTERNS) {\n      // These are trusted internal patterns, so we disable ReDoS rejection\n      if (RegexValidator.validate(normalizedYaml, pattern, { \n        maxLength: 10000,\n        rejectDangerousPatterns: false,\n        logEvents: false  // Don't log our own security patterns as dangerous\n      })) {\n        SecurityMonitor.logSecurityEvent({\n          type: 'YAML_INJECTION_ATTEMPT',\n          severity: 'CRITICAL',\n          source: 'yaml_validation',\n          details: `Malicious YAML pattern detected: ${pattern}`,\n        });\n        // Early exit on first match for performance\n        return false;\n      }\n    }\n    return true;\n  }\n\n  /**\n   * Validates persona metadata fields\n   */\n  static validateMetadata(metadata: any): ContentValidationResult {\n    const detectedPatterns: string[] = [];\n\n    // Check all string fields in metadata\n    const checkField = (fieldName: string, value: any) => {\n      if (typeof value === 'string') {\n        // Check field length first\n        if (value.length > SECURITY_LIMITS.MAX_METADATA_FIELD_LENGTH) {\n          detectedPatterns.push(`${fieldName}: Field exceeds maximum length of ${SECURITY_LIMITS.MAX_METADATA_FIELD_LENGTH} characters`);\n          return;\n        }\n        \n        const result = this.validateAndSanitize(value);\n        if (!result.isValid || result.detectedPatterns?.length) {\n          detectedPatterns.push(`${fieldName}: ${result.detectedPatterns?.join(', ')}`);\n        }\n      }\n    };\n\n    // Validate standard persona fields\n    checkField('name', metadata.name);\n    checkField('description', metadata.description);\n    checkField('category', metadata.category);\n    checkField('author', metadata.author);\n    \n    // Check any custom fields\n    for (const [key, value] of Object.entries(metadata)) {\n      if (!['name', 'description', 'category', 'author'].includes(key)) {\n        checkField(key, value);\n      }\n    }\n\n    return {\n      isValid: detectedPatterns.length === 0,\n      detectedPatterns,\n      severity: detectedPatterns.length > 0 ? 'high' : 'low'\n    };\n  }\n\n  /**\n   * Sanitizes a complete persona file (frontmatter + content)\n   */\n  static sanitizePersonaContent(content: string): string {\n    // Extract frontmatter\n    const frontmatterMatch = content.match(/^---\\n([\\s\\S]*?)\\n---/);\n    \n    if (!frontmatterMatch) {\n      // No frontmatter, just validate content\n      const result = this.validateAndSanitize(content);\n      if (!result.isValid && result.severity === 'critical') {\n        throw new SecurityError('Critical security threat detected in persona content');\n      }\n      return result.sanitizedContent || content;\n    }\n\n    const yamlContent = frontmatterMatch[1];\n    const markdownContent = content.substring(frontmatterMatch[0].length);\n\n    // Validate YAML\n    if (!this.validateYamlContent(yamlContent)) {\n      throw new SecurityError('Malicious YAML detected in persona frontmatter');\n    }\n\n    // Validate markdown content\n    const contentResult = this.validateAndSanitize(markdownContent);\n    if (!contentResult.isValid && contentResult.severity === 'critical') {\n      throw new SecurityError('Critical security threat detected in persona content');\n    }\n\n    // Return sanitized content\n    return `---\\n${yamlContent}\\n---${contentResult.sanitizedContent || markdownContent}`;\n  }\n}"]}

package/dist/security/errorHandler.d.ts

@@ -0,0 +1,42 @@
+/**
+ * SecureErrorHandler - Sanitizes error messages to prevent information disclosure
+ *
+ * SECURITY: Addresses Issue #206 - Information Disclosure via Error Messages
+ * - Prevents exposure of file paths, system details, and internal structure
+ * - Maps system errors to safe user-friendly messages
+ * - Preserves full error details for secure logging
+ * - Different behavior for production vs development environments
+ */
+export interface SanitizedError {
+    message: string;
+    code?: string;
+    requestId?: string;
+}
+export declare class SecureErrorHandler {
+    private static readonly SANITIZATION_PATTERNS;
+    private static readonly ERROR_MAP;
+    /**
+     * Sanitize an error for safe display to users
+     */
+    static sanitizeError(error: any, requestId?: string): SanitizedError;
+    /**
+     * Get a safe, user-friendly error message
+     */
+    private static getSafeErrorMessage;
+    /**
+     * Sanitize error messages to remove sensitive information
+     */
+    private static sanitizeErrorMessage;
+    /**
+     * Create a user-friendly error response
+     */
+    static createErrorResponse(error: any, requestId?: string): {
+        success: false;
+        error: SanitizedError;
+    };
+    /**
+     * Wrap an async function with error handling
+     */
+    static wrapAsync<T extends (...args: any[]) => Promise<any>>(fn: T, context?: string): T;
+}
+//# sourceMappingURL=errorHandler.d.ts.map

package/dist/security/errorHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errorHandler.d.ts","sourceRoot":"","sources":["../../src/security/errorHandler.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,qBAAa,kBAAkB;IAE7B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,qBAAqB,CAW3C;IAEF,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAyB/B;IAEF;;OAEG;IACH,MAAM,CAAC,aAAa,CAAC,KAAK,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,cAAc;IAoCpE;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,mBAAmB;IAuBlC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,oBAAoB;IA0CnC;;OAEG;IACH,MAAM,CAAC,mBAAmB,CAAC,KAAK,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG;QAC1D,OAAO,EAAE,KAAK,CAAC;QACf,KAAK,EAAE,cAAc,CAAC;KACvB;IAOD;;OAEG;IACH,MAAM,CAAC,SAAS,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,GAAG,CAAC,EACzD,EAAE,EAAE,CAAC,EACL,OAAO,CAAC,EAAE,MAAM,GACf,CAAC;CAcL"}

package/dist/security/errorHandler.js

@@ -0,0 +1,166 @@
+/**
+ * SecureErrorHandler - Sanitizes error messages to prevent information disclosure
+ *
+ * SECURITY: Addresses Issue #206 - Information Disclosure via Error Messages
+ * - Prevents exposure of file paths, system details, and internal structure
+ * - Maps system errors to safe user-friendly messages
+ * - Preserves full error details for secure logging
+ * - Different behavior for production vs development environments
+ */
+import { logger } from '../utils/logger.js';
+export class SecureErrorHandler {
+    // Pre-compiled regex patterns for better performance
+    static SANITIZATION_PATTERNS = {
+        UNIX_PATHS: /\/(?:Users|home|var|etc|opt|usr)\/[^\s]+/gi,
+        WINDOWS_PATHS: /[A-Z]:\\[^\s]+/gi,
+        UNC_PATHS: /\\\\[^\s]+/gi,
+        FILE_URLS: /file:\/\/\/?[^\s]+/gi,
+        IP_ADDRESSES: /\b(?:(?:\d{1,3}\.){3}\d{1,3}|(?:0\d{1,2}\.){3}0\d{1,2})\b/g,
+        PORTS: /:\d{4,5}\b/g,
+        HOME_DIRS: /~\/[^\s]+/g,
+        USER_PATHS: /\/(?:Users|home)\/[^\/\s]+/gi,
+        TEMP_PATHS: /\/(?:tmp|var\/folders)\/[^\s]+/gi,
+        ENV_VARS: /\$[A-Z_][A-Z0-9_]*/g,
+    };
+    static ERROR_MAP = {
+        // File system errors
+        'ENOENT': 'Resource not found',
+        'EACCES': 'Access denied',
+        'EEXIST': 'Resource already exists',
+        'EISDIR': 'Invalid operation on directory',
+        'EMFILE': 'System resource limit reached',
+        'ENOMEM': 'Insufficient memory available',
+        'ENOSPC': 'Insufficient storage space',
+        'EPERM': 'Operation not permitted',
+        'EROFS': 'Read-only file system',
+        // Network errors
+        'ECONNREFUSED': 'Connection refused',
+        'ECONNRESET': 'Connection reset',
+        'ETIMEDOUT': 'Operation timed out',
+        'ENOTFOUND': 'Service not found',
+        // Application errors
+        'INVALID_INPUT': 'Invalid input provided',
+        'VALIDATION_ERROR': 'Validation failed',
+        'NOT_FOUND': 'Resource not found',
+        'UNAUTHORIZED': 'Authentication required',
+        'FORBIDDEN': 'Access forbidden',
+        'RATE_LIMITED': 'Too many requests',
+    };
+    /**
+     * Sanitize an error for safe display to users
+     */
+    static sanitizeError(error, requestId) {
+        // Input validation
+        if (error === null || error === undefined) {
+            return {
+                message: process.env.NODE_ENV === 'production'
+                    ? 'An error occurred processing your request.'
+                    : 'An unknown error occurred',
+                code: 'UNKNOWN_ERROR',
+                requestId
+            };
+        }
+        // Log the full error securely for debugging
+        logger.error('Error occurred:', {
+            error: error,
+            stack: error?.stack,
+            code: error?.code,
+            requestId
+        });
+        // Production mode: Return only safe messages
+        if (process.env.NODE_ENV === 'production') {
+            return {
+                message: this.getSafeErrorMessage(error),
+                code: error?.code || 'INTERNAL_ERROR',
+                requestId
+            };
+        }
+        // Development mode: Return sanitized but more detailed messages
+        return {
+            message: this.sanitizeErrorMessage(error?.message || String(error)),
+            code: error?.code || 'UNKNOWN_ERROR',
+            requestId
+        };
+    }
+    /**
+     * Get a safe, user-friendly error message
+     */
+    static getSafeErrorMessage(error) {
+        // Check for known error codes
+        if (error?.code && this.ERROR_MAP[error.code]) {
+            return this.ERROR_MAP[error.code];
+        }
+        // Check for common error types
+        if (error?.name === 'ValidationError') {
+            return 'Validation failed. Please check your input.';
+        }
+        if (error?.name === 'TypeError') {
+            return 'Invalid operation requested.';
+        }
+        if (error?.name === 'RangeError') {
+            return 'Value out of acceptable range.';
+        }
+        // Default safe message
+        return 'An error occurred processing your request.';
+    }
+    /**
+     * Sanitize error messages to remove sensitive information
+     */
+    static sanitizeErrorMessage(message) {
+        if (!message)
+            return 'Unknown error';
+        // Use pre-compiled patterns for better performance
+        // Apply more specific patterns first to avoid conflicts
+        let sanitized = message;
+        // Remove temp directory paths BEFORE general paths
+        sanitized = sanitized.replace(this.SANITIZATION_PATTERNS.TEMP_PATHS, '[TEMP]');
+        // Remove other specific paths
+        sanitized = sanitized
+            .replace(this.SANITIZATION_PATTERNS.UNIX_PATHS, '[PATH]')
+            .replace(this.SANITIZATION_PATTERNS.WINDOWS_PATHS, '[PATH]')
+            .replace(this.SANITIZATION_PATTERNS.UNC_PATHS, '[PATH]');
+        // Remove file URLs (including Windows file:///c:/ format)
+        sanitized = sanitized.replace(this.SANITIZATION_PATTERNS.FILE_URLS, '[FILE]');
+        // Remove potential IP addresses (including zero-padded)
+        sanitized = sanitized.replace(this.SANITIZATION_PATTERNS.IP_ADDRESSES, '[IP]');
+        // Remove potential ports
+        sanitized = sanitized.replace(this.SANITIZATION_PATTERNS.PORTS, ':[PORT]');
+        // Remove home directory references
+        sanitized = sanitized.replace(this.SANITIZATION_PATTERNS.HOME_DIRS, '[HOME]/...');
+        // Remove potential usernames from paths
+        sanitized = sanitized.replace(this.SANITIZATION_PATTERNS.USER_PATHS, '/[USER]');
+        // Remove potential environment variables
+        sanitized = sanitized.replace(this.SANITIZATION_PATTERNS.ENV_VARS, '[ENV]');
+        // Limit message length to prevent verbose error dumps
+        if (sanitized.length > 500) {
+            sanitized = sanitized.substring(0, 497) + '...';
+        }
+        return sanitized;
+    }
+    /**
+     * Create a user-friendly error response
+     */
+    static createErrorResponse(error, requestId) {
+        return {
+            success: false,
+            error: this.sanitizeError(error, requestId)
+        };
+    }
+    /**
+     * Wrap an async function with error handling
+     */
+    static wrapAsync(fn, context) {
+        return (async (...args) => {
+            try {
+                return await fn(...args);
+            }
+            catch (error) {
+                const sanitized = this.sanitizeError(error);
+                throw new Error(context
+                    ? `${context}: ${sanitized.message}`
+                    : sanitized.message);
+            }
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"errorHandler.js","sourceRoot":"","sources":["../../src/security/errorHandler.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * SecureErrorHandler - Sanitizes error messages to prevent information disclosure\n * \n * SECURITY: Addresses Issue #206 - Information Disclosure via Error Messages\n * - Prevents exposure of file paths, system details, and internal structure\n * - Maps system errors to safe user-friendly messages\n * - Preserves full error details for secure logging\n * - Different behavior for production vs development environments\n */\n\nimport { logger } from '../utils/logger.js';\n\nexport interface SanitizedError {\n  message: string;\n  code?: string;\n  requestId?: string;\n}\n\nexport class SecureErrorHandler {\n  // Pre-compiled regex patterns for better performance\n  private static readonly SANITIZATION_PATTERNS = {\n    UNIX_PATHS: /\\/(?:Users|home|var|etc|opt|usr)\\/[^\\s]+/gi,\n    WINDOWS_PATHS: /[A-Z]:\\\\[^\\s]+/gi,\n    UNC_PATHS: /\\\\\\\\[^\\s]+/gi,\n    FILE_URLS: /file:\\/\\/\\/?[^\\s]+/gi,\n    IP_ADDRESSES: /\\b(?:(?:\\d{1,3}\\.){3}\\d{1,3}|(?:0\\d{1,2}\\.){3}0\\d{1,2})\\b/g,\n    PORTS: /:\\d{4,5}\\b/g,\n    HOME_DIRS: /~\\/[^\\s]+/g,\n    USER_PATHS: /\\/(?:Users|home)\\/[^\\/\\s]+/gi,\n    TEMP_PATHS: /\\/(?:tmp|var\\/folders)\\/[^\\s]+/gi,\n    ENV_VARS: /\\$[A-Z_][A-Z0-9_]*/g,\n  };\n  \n  private static readonly ERROR_MAP: Record<string, string> = {\n    // File system errors\n    'ENOENT': 'Resource not found',\n    'EACCES': 'Access denied',\n    'EEXIST': 'Resource already exists',\n    'EISDIR': 'Invalid operation on directory',\n    'EMFILE': 'System resource limit reached',\n    'ENOMEM': 'Insufficient memory available',\n    'ENOSPC': 'Insufficient storage space',\n    'EPERM': 'Operation not permitted',\n    'EROFS': 'Read-only file system',\n    \n    // Network errors\n    'ECONNREFUSED': 'Connection refused',\n    'ECONNRESET': 'Connection reset',\n    'ETIMEDOUT': 'Operation timed out',\n    'ENOTFOUND': 'Service not found',\n    \n    // Application errors\n    'INVALID_INPUT': 'Invalid input provided',\n    'VALIDATION_ERROR': 'Validation failed',\n    'NOT_FOUND': 'Resource not found',\n    'UNAUTHORIZED': 'Authentication required',\n    'FORBIDDEN': 'Access forbidden',\n    'RATE_LIMITED': 'Too many requests',\n  };\n\n  /**\n   * Sanitize an error for safe display to users\n   */\n  static sanitizeError(error: any, requestId?: string): SanitizedError {\n    // Input validation\n    if (error === null || error === undefined) {\n      return {\n        message: process.env.NODE_ENV === 'production' \n          ? 'An error occurred processing your request.'\n          : 'An unknown error occurred',\n        code: 'UNKNOWN_ERROR',\n        requestId\n      };\n    }\n    // Log the full error securely for debugging\n    logger.error('Error occurred:', {\n      error: error,\n      stack: error?.stack,\n      code: error?.code,\n      requestId\n    });\n\n    // Production mode: Return only safe messages\n    if (process.env.NODE_ENV === 'production') {\n      return {\n        message: this.getSafeErrorMessage(error),\n        code: error?.code || 'INTERNAL_ERROR',\n        requestId\n      };\n    }\n\n    // Development mode: Return sanitized but more detailed messages\n    return {\n      message: this.sanitizeErrorMessage(error?.message || String(error)),\n      code: error?.code || 'UNKNOWN_ERROR',\n      requestId\n    };\n  }\n\n  /**\n   * Get a safe, user-friendly error message\n   */\n  private static getSafeErrorMessage(error: any): string {\n    // Check for known error codes\n    if (error?.code && this.ERROR_MAP[error.code]) {\n      return this.ERROR_MAP[error.code];\n    }\n\n    // Check for common error types\n    if (error?.name === 'ValidationError') {\n      return 'Validation failed. Please check your input.';\n    }\n    \n    if (error?.name === 'TypeError') {\n      return 'Invalid operation requested.';\n    }\n    \n    if (error?.name === 'RangeError') {\n      return 'Value out of acceptable range.';\n    }\n\n    // Default safe message\n    return 'An error occurred processing your request.';\n  }\n\n  /**\n   * Sanitize error messages to remove sensitive information\n   */\n  private static sanitizeErrorMessage(message: string): string {\n    if (!message) return 'Unknown error';\n\n    // Use pre-compiled patterns for better performance\n    // Apply more specific patterns first to avoid conflicts\n    let sanitized = message;\n    \n    // Remove temp directory paths BEFORE general paths\n    sanitized = sanitized.replace(this.SANITIZATION_PATTERNS.TEMP_PATHS, '[TEMP]');\n    \n    // Remove other specific paths\n    sanitized = sanitized\n      .replace(this.SANITIZATION_PATTERNS.UNIX_PATHS, '[PATH]')\n      .replace(this.SANITIZATION_PATTERNS.WINDOWS_PATHS, '[PATH]')\n      .replace(this.SANITIZATION_PATTERNS.UNC_PATHS, '[PATH]');\n\n    // Remove file URLs (including Windows file:///c:/ format)\n    sanitized = sanitized.replace(this.SANITIZATION_PATTERNS.FILE_URLS, '[FILE]');\n\n    // Remove potential IP addresses (including zero-padded)\n    sanitized = sanitized.replace(this.SANITIZATION_PATTERNS.IP_ADDRESSES, '[IP]');\n\n    // Remove potential ports\n    sanitized = sanitized.replace(this.SANITIZATION_PATTERNS.PORTS, ':[PORT]');\n\n    // Remove home directory references\n    sanitized = sanitized.replace(this.SANITIZATION_PATTERNS.HOME_DIRS, '[HOME]/...');\n\n    // Remove potential usernames from paths\n    sanitized = sanitized.replace(this.SANITIZATION_PATTERNS.USER_PATHS, '/[USER]');\n\n    // Remove potential environment variables\n    sanitized = sanitized.replace(this.SANITIZATION_PATTERNS.ENV_VARS, '[ENV]');\n\n    // Limit message length to prevent verbose error dumps\n    if (sanitized.length > 500) {\n      sanitized = sanitized.substring(0, 497) + '...';\n    }\n\n    return sanitized;\n  }\n\n  /**\n   * Create a user-friendly error response\n   */\n  static createErrorResponse(error: any, requestId?: string): {\n    success: false;\n    error: SanitizedError;\n  } {\n    return {\n      success: false,\n      error: this.sanitizeError(error, requestId)\n    };\n  }\n\n  /**\n   * Wrap an async function with error handling\n   */\n  static wrapAsync<T extends (...args: any[]) => Promise<any>>(\n    fn: T,\n    context?: string\n  ): T {\n    return (async (...args: Parameters<T>) => {\n      try {\n        return await fn(...args);\n      } catch (error) {\n        const sanitized = this.sanitizeError(error);\n        throw new Error(\n          context \n            ? `${context}: ${sanitized.message}`\n            : sanitized.message\n        );\n      }\n    }) as T;\n  }\n}"]}

package/dist/security/errors.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Security-related error classes
+ */
+export declare class SecurityError extends Error {
+    readonly code?: string;
+    constructor(message: string, code?: string);
+}
+export declare class ValidationError extends Error {
+    constructor(message: string);
+}
+export declare class TimeoutError extends SecurityError {
+    constructor(message?: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/security/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/security/errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,qBAAa,aAAc,SAAQ,KAAK;IACtC,SAAgB,IAAI,CAAC,EAAE,MAAM,CAAC;gBAElB,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM;CAO3C;AAED,qBAAa,eAAgB,SAAQ,KAAK;gBAC5B,OAAO,EAAE,MAAM;CAK5B;AAED,qBAAa,YAAa,SAAQ,aAAa;gBACjC,OAAO,GAAE,MAA8B;CAKpD"}