@dollhousemcp/mcp-server
Version:
DollhouseMCP - A Model Context Protocol (MCP) server that enables dynamic AI persona management from markdown files, allowing Claude and other compatible AI assistants to activate and switch between different behavioral personas.
257 lines • 31 kB
JavaScript
/**
* ElementValidation - Common validation logic for element managers
*
* Provides shared validation patterns for all element types:
* - Name, description, category validation
* - Trigger word validation
* - Author and version validation
*
* SECURITY: All validation uses sanitizeInput and proper type checking
* UNICODE HANDLING: Uses UnicodeValidator for safe string processing
*
* FIX: DMCP-SEC-006 - Security audit suppression
* This file provides validation utilities only.
* No audit logging is required - logging happens in the calling managers.
* @security-audit-suppress DMCP-SEC-006
*/
import { sanitizeInput } from '../../security/InputValidator.js';
import { UnicodeValidator } from '../../security/validators/unicodeValidator.js';
import { logger } from '../../utils/logger.js';
import { SecurityMonitor } from '../../security/securityMonitor.js';
/**
* Validation constants shared across element types
*/
export const VALIDATION_CONSTANTS = {
MAX_NAME_LENGTH: 100,
MAX_DESCRIPTION_LENGTH: 500,
MAX_CATEGORY_LENGTH: 50,
MAX_TAG_LENGTH: 50,
MAX_AUTHOR_LENGTH: 100,
MAX_VERSION_LENGTH: 20,
MAX_TRIGGER_LENGTH: 50,
MAX_TRIGGERS: 20,
// Allows alphanumeric, hyphens, underscores, @ (mentions/emails), . (domains)
TRIGGER_VALIDATION_REGEX: /^[a-zA-Z0-9\-_@.]+$/
};
/**
* Static utility class for common validation operations
*/
export class ElementValidation {
/**
* Validate and sanitize a name field
* Applies Unicode normalization and length limits
*
* @param name - Raw name value
* @param maxLength - Maximum length (default: 100)
* @returns Sanitized name
*/
static validateName(name, maxLength = VALIDATION_CONSTANTS.MAX_NAME_LENGTH) {
if (!name) {
throw new Error('Name is required');
}
const normalized = UnicodeValidator.normalize(String(name));
const sanitized = sanitizeInput(normalized.normalizedContent, maxLength);
if (!sanitized) {
throw new Error('Name is empty after sanitization');
}
return sanitized;
}
/**
* Validate and sanitize a description field
*
* @param description - Raw description value
* @param maxLength - Maximum length (default: 500)
* @returns Sanitized description or undefined
*/
static validateDescription(description, maxLength = VALIDATION_CONSTANTS.MAX_DESCRIPTION_LENGTH) {
if (!description) {
return undefined;
}
const normalized = UnicodeValidator.normalize(String(description));
return sanitizeInput(normalized.normalizedContent, maxLength) || undefined;
}
/**
* Validate and sanitize an author field
*
* @param author - Raw author value
* @returns Sanitized author or undefined
*/
static validateAuthor(author) {
if (!author) {
return undefined;
}
return sanitizeInput(String(author), VALIDATION_CONSTANTS.MAX_AUTHOR_LENGTH) || undefined;
}
/**
* Validate and sanitize a version string
*
* @param version - Raw version value
* @returns Sanitized version or undefined
*/
static validateVersion(version) {
if (!version) {
return undefined;
}
return sanitizeInput(String(version), VALIDATION_CONSTANTS.MAX_VERSION_LENGTH) || undefined;
}
/**
* Validate and sanitize an array of tags
*
* @param tags - Raw tags array
* @returns Sanitized tags array
*/
static validateTags(tags) {
if (!Array.isArray(tags)) {
return [];
}
return tags
.filter(tag => tag !== null && tag !== undefined && tag !== '') // Filter out null/undefined/empty BEFORE converting
.map(tag => sanitizeInput(String(tag), VALIDATION_CONSTANTS.MAX_TAG_LENGTH))
.filter((tag) => tag !== null && tag.length > 0);
}
/**
* Validate and process triggers with detailed logging
* Follows pattern from SkillManager (Issue #1139) and MemoryManager (Issue #1133)
*
* @param triggers - Raw triggers array
* @param elementName - Element name for logging
* @param maxTriggers - Maximum number of triggers (default: 20)
* @returns Validation result with valid and rejected triggers
*/
static validateTriggers(triggers, elementName = 'unknown', maxTriggers = VALIDATION_CONSTANTS.MAX_TRIGGERS) {
const result = {
valid: [],
rejected: [],
warnings: []
};
if (!Array.isArray(triggers) || triggers.length === 0) {
return result;
}
// Limit to max triggers
const rawTriggers = triggers.slice(0, maxTriggers);
// Validate each trigger
// SECURITY: Validate BEFORE sanitization to reject invalid characters
// This prevents 'bad!trigger' from becoming 'badtrigger' and passing
for (const raw of rawTriggers) {
const rawTrigger = String(raw).trim();
// Check if empty
if (!rawTrigger) {
result.rejected.push(`"${raw}" (empty)`);
continue;
}
// SECURITY: Validate format BEFORE sanitization
if (!VALIDATION_CONSTANTS.TRIGGER_VALIDATION_REGEX.test(rawTrigger)) {
result.rejected.push(`"${raw}" (invalid format - allowed: letters, numbers, hyphens, underscores, @ and .)`);
continue;
}
// Only sanitize AFTER validation passes (for length limits)
const sanitized = sanitizeInput(rawTrigger, VALIDATION_CONSTANTS.MAX_TRIGGER_LENGTH);
if (sanitized) {
result.valid.push(sanitized);
}
}
// Generate warnings
if (result.rejected.length > 0) {
result.warnings.push(`Element "${elementName}": Rejected ${result.rejected.length} invalid trigger(s)`);
}
if (triggers.length > maxTriggers) {
result.warnings.push(`Element "${elementName}": Trigger limit exceeded (${triggers.length} > ${maxTriggers})`);
}
// Log warnings
result.warnings.forEach(warning => logger.warn(warning, {
elementName,
rejectedTriggers: result.rejected,
acceptedCount: result.valid.length
}));
// FIX: DMCP-SEC-006 - Add security audit logging for validation
if (result.rejected.length > 0) {
SecurityMonitor.logSecurityEvent({
type: 'ELEMENT_VALIDATED',
severity: 'LOW',
source: 'ElementValidation.validateTriggers',
details: `Trigger validation rejected ${result.rejected.length} invalid trigger(s) for ${elementName}`,
additionalData: { elementName, rejectedCount: result.rejected.length }
});
}
return result;
}
/**
* Validate a category field
*
* @param category - Raw category value
* @returns Sanitized category or undefined
*/
static validateCategory(category) {
if (!category) {
return undefined;
}
return sanitizeInput(String(category), VALIDATION_CONSTANTS.MAX_CATEGORY_LENGTH) || undefined;
}
/**
* Validate and sanitize common element metadata fields
* Returns an object with all common validated fields
*
* @param data - Raw metadata object
* @returns Validated common metadata fields
*/
static validateCommonMetadata(data) {
const result = {};
// Validate name (required for most elements)
if (data.name) {
try {
result.name = this.validateName(data.name);
}
catch {
// Name validation failed, let caller handle
}
}
// Validate optional fields
result.description = this.validateDescription(data.description);
result.author = this.validateAuthor(data.author);
result.version = this.validateVersion(data.version);
result.category = this.validateCategory(data.category);
result.tags = this.validateTags(data.tags);
// Validate triggers if present
if (data.triggers && Array.isArray(data.triggers)) {
const triggerResult = this.validateTriggers(data.triggers, data.name || 'unknown');
result.triggers = triggerResult.valid;
}
return result;
}
/**
* Validate a numeric field with min/max bounds
*
* @param value - Raw numeric value
* @param min - Minimum value (default: 0)
* @param max - Maximum value (default: Number.MAX_SAFE_INTEGER)
* @returns Validated number
*/
static validateNumber(value, min = 0, max = Number.MAX_SAFE_INTEGER) {
// Reject null/undefined explicitly
if (value === null || value === undefined) {
throw new Error(`Invalid number: ${value}`);
}
const num = Number(value);
if (isNaN(num)) {
throw new Error(`Invalid number: ${value}`);
}
if (num < min || num > max) {
throw new Error(`Number out of range: ${num} (min: ${min}, max: ${max})`);
}
return num;
}
/**
* Validate a boolean field
*
* @param value - Raw boolean value
* @param defaultValue - Default if value is undefined
* @returns Boolean value
*/
static validateBoolean(value, defaultValue = false) {
if (value === undefined || value === null) {
return defaultValue;
}
return Boolean(value);
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ElementValidation.js","sourceRoot":"","sources":["../../../src/elements/base/ElementValidation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AACjE,OAAO,EAAE,gBAAgB,EAAE,MAAM,+CAA+C,CAAC;AACjF,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAC/C,OAAO,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAEpE;;GAEG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAClC,eAAe,EAAE,GAAG;IACpB,sBAAsB,EAAE,GAAG;IAC3B,mBAAmB,EAAE,EAAE;IACvB,cAAc,EAAE,EAAE;IAClB,iBAAiB,EAAE,GAAG;IACtB,kBAAkB,EAAE,EAAE;IACtB,kBAAkB,EAAE,EAAE;IACtB,YAAY,EAAE,EAAE;IAChB,8EAA8E;IAC9E,wBAAwB,EAAE,qBAAqB;CACvC,CAAC;AAWX;;GAEG;AACH,MAAM,OAAO,iBAAiB;IAC5B;;;;;;;OAOG;IACH,MAAM,CAAC,YAAY,CAAC,IAAS,EAAE,YAAoB,oBAAoB,CAAC,eAAe;QACrF,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,MAAM,IAAI,KAAK,CAAC,kBAAkB,CAAC,CAAC;QACtC,CAAC;QAED,MAAM,UAAU,GAAG,gBAAgB,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;QAC5D,MAAM,SAAS,GAAG,aAAa,CAAC,UAAU,CAAC,iBAAiB,EAAE,SAAS,CAAC,CAAC;QAEzE,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,MAAM,IAAI,KAAK,CAAC,kCAAkC,CAAC,CAAC;QACtD,CAAC;QAED,OAAO,SAAS,CAAC;IACnB,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,mBAAmB,CACxB,WAAgB,EAChB,YAAoB,oBAAoB,CAAC,sBAAsB;QAE/D,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,MAAM,UAAU,GAAG,gBAAgB,CAAC,SAAS,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC;QACnE,OAAO,aAAa,CAAC,UAAU,CAAC,iBAAiB,EAAE,SAAS,CAAC,IAAI,SAAS,CAAC;IAC7E,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,cAAc,CAAC,MAAW;QAC/B,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,OAAO,aAAa,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,oBAAoB,CAAC,iBAAiB,CAAC,IAAI,SAAS,CAAC;IAC5F,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,eAAe,CAAC,OAAY;QACjC,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,OAAO,aAAa,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,oBAAoB,CAAC,kBAAkB,CAAC,IAAI,SAAS,CAAC;IAC9F,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,YAAY,CAAC,IAAS;QAC3B,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;YACzB,OAAO,EAAE,CAAC;QACZ,CAAC;QAED,OAAO,IAAI;aACR,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,IAAI,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,EAAE,CAAC,CAAC,oDAAoD;aACnH,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,aAAa,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,oBAAoB,CAAC,cAAc,CAAC,CAAC;aAC3E,MAAM,CAAC,CAAC,GAAG,EAAiB,EAAE,CAAC,GAAG,KAAK,IAAI,IAAI,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACpE,CAAC;IAED;;;;;;;;OAQG;IACH,MAAM,CAAC,gBAAgB,CACrB,QAAe,EACf,cAAsB,SAAS,EAC/B,cAAsB,oBAAoB,CAAC,YAAY;QAEvD,MAAM,MAAM,GAA4B;YACtC,KAAK,EAAE,EAAE;YACT,QAAQ,EAAE,EAAE;YACZ,QAAQ,EAAE,EAAE;SACb,CAAC;QAEF,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACtD,OAAO,MAAM,CAAC;QAChB,CAAC;QAED,wBAAwB;QACxB,MAAM,WAAW,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC;QAEnD,wBAAwB;QACxB,sEAAsE;QACtE,qEAAqE;QACrE,KAAK,MAAM,GAAG,IAAI,WAAW,EAAE,CAAC;YAC9B,MAAM,UAAU,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC;YAEtC,iBAAiB;YACjB,IAAI,CAAC,UAAU,EAAE,CAAC;gBAChB,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,GAAG,WAAW,CAAC,CAAC;gBACzC,SAAS;YACX,CAAC;YAED,gDAAgD;YAChD,IAAI,CAAC,oBAAoB,CAAC,wBAAwB,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;gBACpE,MAAM,CAAC,QAAQ,CAAC,IAAI,CAClB,IAAI,GAAG,+EAA+E,CACvF,CAAC;gBACF,SAAS;YACX,CAAC;YAED,4DAA4D;YAC5D,MAAM,SAAS,GAAG,aAAa,CAAC,UAAU,EAAE,oBAAoB,CAAC,kBAAkB,CAAC,CAAC;YACrF,IAAI,SAAS,EAAE,CAAC;gBACd,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YAC/B,CAAC;QACH,CAAC;QAED,oBAAoB;QACpB,IAAI,MAAM,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC/B,MAAM,CAAC,QAAQ,CAAC,IAAI,CAClB,YAAY,WAAW,eAAe,MAAM,CAAC,QAAQ,CAAC,MAAM,qBAAqB,CAClF,CAAC;QACJ,CAAC;QAED,IAAI,QAAQ,CAAC,MAAM,GAAG,WAAW,EAAE,CAAC;YAClC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAClB,YAAY,WAAW,8BAA8B,QAAQ,CAAC,MAAM,MAAM,WAAW,GAAG,CACzF,CAAC;QACJ,CAAC;QAED,eAAe;QACf,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE;YACtD,WAAW;YACX,gBAAgB,EAAE,MAAM,CAAC,QAAQ;YACjC,aAAa,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM;SACnC,CAAC,CAAC,CAAC;QAEJ,gEAAgE;QAChE,IAAI,MAAM,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC/B,eAAe,CAAC,gBAAgB,CAAC;gBAC/B,IAAI,EAAE,mBAAmB;gBACzB,QAAQ,EAAE,KAAK;gBACf,MAAM,EAAE,oCAAoC;gBAC5C,OAAO,EAAE,+BAA+B,MAAM,CAAC,QAAQ,CAAC,MAAM,2BAA2B,WAAW,EAAE;gBACtG,cAAc,EAAE,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE;aACvE,CAAC,CAAC;QACL,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,gBAAgB,CAAC,QAAa;QACnC,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,OAAO,aAAa,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,oBAAoB,CAAC,mBAAmB,CAAC,IAAI,SAAS,CAAC;IAChG,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,sBAAsB,CAAC,IAAS;QASrC,MAAM,MAAM,GAAQ,EAAE,CAAC;QAEvB,6CAA6C;QAC7C,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;YACd,IAAI,CAAC;gBACH,MAAM,CAAC,IAAI,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAC7C,CAAC;YAAC,MAAM,CAAC;gBACP,4CAA4C;YAC9C,CAAC;QACH,CAAC;QAED,2BAA2B;QAC3B,MAAM,CAAC,WAAW,GAAG,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAChE,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACjD,MAAM,CAAC,OAAO,GAAG,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACpD,MAAM,CAAC,QAAQ,GAAG,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACvD,MAAM,CAAC,IAAI,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAE3C,+BAA+B;QAC/B,IAAI,IAAI,CAAC,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;YAClD,MAAM,aAAa,GAAG,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,IAAI,SAAS,CAAC,CAAC;YACnF,MAAM,CAAC,QAAQ,GAAG,aAAa,CAAC,KAAK,CAAC;QACxC,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,cAAc,CACnB,KAAU,EACV,MAAc,CAAC,EACf,MAAc,MAAM,CAAC,gBAAgB;QAErC,mCAAmC;QACnC,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YAC1C,MAAM,IAAI,KAAK,CAAC,mBAAmB,KAAK,EAAE,CAAC,CAAC;QAC9C,CAAC;QAED,MAAM,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QAE1B,IAAI,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;YACf,MAAM,IAAI,KAAK,CAAC,mBAAmB,KAAK,EAAE,CAAC,CAAC;QAC9C,CAAC;QAED,IAAI,GAAG,GAAG,GAAG,IAAI,GAAG,GAAG,GAAG,EAAE,CAAC;YAC3B,MAAM,IAAI,KAAK,CAAC,wBAAwB,GAAG,UAAU,GAAG,UAAU,GAAG,GAAG,CAAC,CAAC;QAC5E,CAAC;QAED,OAAO,GAAG,CAAC;IACb,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,eAAe,CAAC,KAAU,EAAE,eAAwB,KAAK;QAC9D,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;YAC1C,OAAO,YAAY,CAAC;QACtB,CAAC;QAED,OAAO,OAAO,CAAC,KAAK,CAAC,CAAC;IACxB,CAAC;CACF","sourcesContent":["/**\n * ElementValidation - Common validation logic for element managers\n *\n * Provides shared validation patterns for all element types:\n * - Name, description, category validation\n * - Trigger word validation\n * - Author and version validation\n *\n * SECURITY: All validation uses sanitizeInput and proper type checking\n * UNICODE HANDLING: Uses UnicodeValidator for safe string processing\n *\n * FIX: DMCP-SEC-006 - Security audit suppression\n * This file provides validation utilities only.\n * No audit logging is required - logging happens in the calling managers.\n * @security-audit-suppress DMCP-SEC-006\n */\n\nimport { sanitizeInput } from '../../security/InputValidator.js';\nimport { UnicodeValidator } from '../../security/validators/unicodeValidator.js';\nimport { logger } from '../../utils/logger.js';\nimport { SecurityMonitor } from '../../security/securityMonitor.js';\n\n/**\n * Validation constants shared across element types\n */\nexport const VALIDATION_CONSTANTS = {\n  MAX_NAME_LENGTH: 100,\n  MAX_DESCRIPTION_LENGTH: 500,\n  MAX_CATEGORY_LENGTH: 50,\n  MAX_TAG_LENGTH: 50,\n  MAX_AUTHOR_LENGTH: 100,\n  MAX_VERSION_LENGTH: 20,\n  MAX_TRIGGER_LENGTH: 50,\n  MAX_TRIGGERS: 20,\n  // Allows alphanumeric, hyphens, underscores, @ (mentions/emails), . (domains)\n  TRIGGER_VALIDATION_REGEX: /^[a-zA-Z0-9\\-_@.]+$/\n} as const;\n\n/**\n * Result of trigger validation\n */\nexport interface TriggerValidationResult {\n  valid: string[];\n  rejected: string[];\n  warnings: string[];\n}\n\n/**\n * Static utility class for common validation operations\n */\nexport class ElementValidation {\n  /**\n   * Validate and sanitize a name field\n   * Applies Unicode normalization and length limits\n   *\n   * @param name - Raw name value\n   * @param maxLength - Maximum length (default: 100)\n   * @returns Sanitized name\n   */\n  static validateName(name: any, maxLength: number = VALIDATION_CONSTANTS.MAX_NAME_LENGTH): string {\n    if (!name) {\n      throw new Error('Name is required');\n    }\n\n    const normalized = UnicodeValidator.normalize(String(name));\n    const sanitized = sanitizeInput(normalized.normalizedContent, maxLength);\n\n    if (!sanitized) {\n      throw new Error('Name is empty after sanitization');\n    }\n\n    return sanitized;\n  }\n\n  /**\n   * Validate and sanitize a description field\n   *\n   * @param description - Raw description value\n   * @param maxLength - Maximum length (default: 500)\n   * @returns Sanitized description or undefined\n   */\n  static validateDescription(\n    description: any,\n    maxLength: number = VALIDATION_CONSTANTS.MAX_DESCRIPTION_LENGTH\n  ): string | undefined {\n    if (!description) {\n      return undefined;\n    }\n\n    const normalized = UnicodeValidator.normalize(String(description));\n    return sanitizeInput(normalized.normalizedContent, maxLength) || undefined;\n  }\n\n  /**\n   * Validate and sanitize an author field\n   *\n   * @param author - Raw author value\n   * @returns Sanitized author or undefined\n   */\n  static validateAuthor(author: any): string | undefined {\n    if (!author) {\n      return undefined;\n    }\n\n    return sanitizeInput(String(author), VALIDATION_CONSTANTS.MAX_AUTHOR_LENGTH) || undefined;\n  }\n\n  /**\n   * Validate and sanitize a version string\n   *\n   * @param version - Raw version value\n   * @returns Sanitized version or undefined\n   */\n  static validateVersion(version: any): string | undefined {\n    if (!version) {\n      return undefined;\n    }\n\n    return sanitizeInput(String(version), VALIDATION_CONSTANTS.MAX_VERSION_LENGTH) || undefined;\n  }\n\n  /**\n   * Validate and sanitize an array of tags\n   *\n   * @param tags - Raw tags array\n   * @returns Sanitized tags array\n   */\n  static validateTags(tags: any): string[] {\n    if (!Array.isArray(tags)) {\n      return [];\n    }\n\n    return tags\n      .filter(tag => tag !== null && tag !== undefined && tag !== '') // Filter out null/undefined/empty BEFORE converting\n      .map(tag => sanitizeInput(String(tag), VALIDATION_CONSTANTS.MAX_TAG_LENGTH))\n      .filter((tag): tag is string => tag !== null && tag.length > 0);\n  }\n\n  /**\n   * Validate and process triggers with detailed logging\n   * Follows pattern from SkillManager (Issue #1139) and MemoryManager (Issue #1133)\n   *\n   * @param triggers - Raw triggers array\n   * @param elementName - Element name for logging\n   * @param maxTriggers - Maximum number of triggers (default: 20)\n   * @returns Validation result with valid and rejected triggers\n   */\n  static validateTriggers(\n    triggers: any[],\n    elementName: string = 'unknown',\n    maxTriggers: number = VALIDATION_CONSTANTS.MAX_TRIGGERS\n  ): TriggerValidationResult {\n    const result: TriggerValidationResult = {\n      valid: [],\n      rejected: [],\n      warnings: []\n    };\n\n    if (!Array.isArray(triggers) || triggers.length === 0) {\n      return result;\n    }\n\n    // Limit to max triggers\n    const rawTriggers = triggers.slice(0, maxTriggers);\n\n    // Validate each trigger\n    // SECURITY: Validate BEFORE sanitization to reject invalid characters\n    // This prevents 'bad!trigger' from becoming 'badtrigger' and passing\n    for (const raw of rawTriggers) {\n      const rawTrigger = String(raw).trim();\n\n      // Check if empty\n      if (!rawTrigger) {\n        result.rejected.push(`\"${raw}\" (empty)`);\n        continue;\n      }\n\n      // SECURITY: Validate format BEFORE sanitization\n      if (!VALIDATION_CONSTANTS.TRIGGER_VALIDATION_REGEX.test(rawTrigger)) {\n        result.rejected.push(\n          `\"${raw}\" (invalid format - allowed: letters, numbers, hyphens, underscores, @ and .)`\n        );\n        continue;\n      }\n\n      // Only sanitize AFTER validation passes (for length limits)\n      const sanitized = sanitizeInput(rawTrigger, VALIDATION_CONSTANTS.MAX_TRIGGER_LENGTH);\n      if (sanitized) {\n        result.valid.push(sanitized);\n      }\n    }\n\n    // Generate warnings\n    if (result.rejected.length > 0) {\n      result.warnings.push(\n        `Element \"${elementName}\": Rejected ${result.rejected.length} invalid trigger(s)`\n      );\n    }\n\n    if (triggers.length > maxTriggers) {\n      result.warnings.push(\n        `Element \"${elementName}\": Trigger limit exceeded (${triggers.length} > ${maxTriggers})`\n      );\n    }\n\n    // Log warnings\n    result.warnings.forEach(warning => logger.warn(warning, {\n      elementName,\n      rejectedTriggers: result.rejected,\n      acceptedCount: result.valid.length\n    }));\n\n    // FIX: DMCP-SEC-006 - Add security audit logging for validation\n    if (result.rejected.length > 0) {\n      SecurityMonitor.logSecurityEvent({\n        type: 'ELEMENT_VALIDATED',\n        severity: 'LOW',\n        source: 'ElementValidation.validateTriggers',\n        details: `Trigger validation rejected ${result.rejected.length} invalid trigger(s) for ${elementName}`,\n        additionalData: { elementName, rejectedCount: result.rejected.length }\n      });\n    }\n\n    return result;\n  }\n\n  /**\n   * Validate a category field\n   *\n   * @param category - Raw category value\n   * @returns Sanitized category or undefined\n   */\n  static validateCategory(category: any): string | undefined {\n    if (!category) {\n      return undefined;\n    }\n\n    return sanitizeInput(String(category), VALIDATION_CONSTANTS.MAX_CATEGORY_LENGTH) || undefined;\n  }\n\n  /**\n   * Validate and sanitize common element metadata fields\n   * Returns an object with all common validated fields\n   *\n   * @param data - Raw metadata object\n   * @returns Validated common metadata fields\n   */\n  static validateCommonMetadata(data: any): {\n    name?: string;\n    description?: string;\n    author?: string;\n    version?: string;\n    category?: string;\n    tags?: string[];\n    triggers?: string[];\n  } {\n    const result: any = {};\n\n    // Validate name (required for most elements)\n    if (data.name) {\n      try {\n        result.name = this.validateName(data.name);\n      } catch {\n        // Name validation failed, let caller handle\n      }\n    }\n\n    // Validate optional fields\n    result.description = this.validateDescription(data.description);\n    result.author = this.validateAuthor(data.author);\n    result.version = this.validateVersion(data.version);\n    result.category = this.validateCategory(data.category);\n    result.tags = this.validateTags(data.tags);\n\n    // Validate triggers if present\n    if (data.triggers && Array.isArray(data.triggers)) {\n      const triggerResult = this.validateTriggers(data.triggers, data.name || 'unknown');\n      result.triggers = triggerResult.valid;\n    }\n\n    return result;\n  }\n\n  /**\n   * Validate a numeric field with min/max bounds\n   *\n   * @param value - Raw numeric value\n   * @param min - Minimum value (default: 0)\n   * @param max - Maximum value (default: Number.MAX_SAFE_INTEGER)\n   * @returns Validated number\n   */\n  static validateNumber(\n    value: any,\n    min: number = 0,\n    max: number = Number.MAX_SAFE_INTEGER\n  ): number {\n    // Reject null/undefined explicitly\n    if (value === null || value === undefined) {\n      throw new Error(`Invalid number: ${value}`);\n    }\n\n    const num = Number(value);\n\n    if (isNaN(num)) {\n      throw new Error(`Invalid number: ${value}`);\n    }\n\n    if (num < min || num > max) {\n      throw new Error(`Number out of range: ${num} (min: ${min}, max: ${max})`);\n    }\n\n    return num;\n  }\n\n  /**\n   * Validate a boolean field\n   *\n   * @param value - Raw boolean value\n   * @param defaultValue - Default if value is undefined\n   * @returns Boolean value\n   */\n  static validateBoolean(value: any, defaultValue: boolean = false): boolean {\n    if (value === undefined || value === null) {\n      return defaultValue;\n    }\n\n    return Boolean(value);\n  }\n}\n"]}