@dollhousemcp/mcp-server 1.3.0

package/dist/test/src/elements/skills/Skill.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Skill element class implementing IElement interface.
+ * Represents a discrete capability for specific tasks.
+ *
+ * SECURITY FIXES IMPLEMENTED (PR #319):
+ * 1. CRITICAL: Added comprehensive input validation for all skill parameters
+ * 2. MEDIUM: Implemented Unicode normalization to prevent homograph attacks
+ * 3. MEDIUM: Added audit logging for security events via SecurityMonitor
+ * 4. MEDIUM: Implemented memory management to prevent unbounded growth
+ * 5. MEDIUM: Added XSS protection through input sanitization
+ */
+import { BaseElement } from '../BaseElement.js';
+import { IElement, IElementMetadata, ElementValidationResult } from '../../types/elements/index.js';
+export interface SkillMetadata extends IElementMetadata {
+    languages?: string[];
+    complexity?: 'beginner' | 'intermediate' | 'advanced' | 'expert';
+    domains?: string[];
+    prerequisites?: string[];
+    parameters?: SkillParameter[];
+    examples?: SkillExample[];
+    certification?: string;
+    proficiency_level?: number;
+}
+export interface SkillParameter {
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'enum';
+    description: string;
+    required?: boolean;
+    default?: any;
+    options?: string[];
+    min?: number;
+    max?: number;
+}
+export interface SkillExample {
+    title: string;
+    description: string;
+    input?: any;
+    output?: any;
+    code?: string;
+}
+export declare class Skill extends BaseElement implements IElement {
+    metadata: SkillMetadata;
+    instructions: string;
+    parameters: Map<string, any>;
+    private readonly MAX_PARAMETER_COUNT;
+    private readonly MAX_PARAMETER_SIZE;
+    constructor(metadata: Partial<SkillMetadata>, instructions?: string);
+    /**
+     * Initialize parameters with default values
+     */
+    private initializeParameters;
+    /**
+     * Set a parameter value
+     * SECURITY FIX #1: Comprehensive input validation for all skill parameters
+     * Previously: Parameters were set without validation, creating security risks
+     * Now: Full validation pipeline including sanitization, type checking, and size limits
+     */
+    setParameter(name: string, value: any): void;
+    /**
+     * Get a parameter value
+     */
+    getParameter(name: string): any;
+    /**
+     * Get all parameters as object
+     */
+    getAllParameters(): Record<string, any>;
+    /**
+     * Validate parameter value against its definition
+     */
+    private validateParameterValue;
+    /**
+     * Execute the skill with current parameters
+     */
+    execute(input?: any): Promise<any>;
+    /**
+     * Skill-specific validation
+     */
+    validate(): ElementValidationResult;
+    /**
+     * Serialize skill to JSON format
+     */
+    serialize(): string;
+    /**
+     * Deserialize skill from JSON format
+     */
+    deserialize(data: string): void;
+    /**
+     * Skill activation lifecycle
+     */
+    activate(): Promise<void>;
+    /**
+     * Clone the skill with different parameters
+     */
+    clone(newParameters?: Record<string, any>): Skill;
+    /**
+     * Skill deactivation lifecycle
+     * SECURITY FIX #4: Automatically clears parameters on deactivation
+     * to prevent memory leaks in long-running processes
+     */
+    deactivate(): Promise<void>;
+    /**
+     * Clear all parameters (for memory management)
+     * SECURITY FIX #4: Added method to clear parameters and prevent memory leaks
+     * Previously: Parameters accumulated indefinitely in long-running processes
+     * Now: Provides explicit cleanup mechanism called during deactivation
+     */
+    clearParameters(): void;
+}
+//# sourceMappingURL=Skill.d.ts.map

package/dist/test/src/elements/skills/Skill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Skill.d.ts","sourceRoot":"","sources":["../../../../../src/elements/skills/Skill.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AAQpG,MAAM,WAAW,aAAc,SAAQ,gBAAgB;IACrD,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,UAAU,CAAC,EAAE,UAAU,GAAG,cAAc,GAAG,UAAU,GAAG,QAAQ,CAAC;IACjE,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,UAAU,CAAC,EAAE,cAAc,EAAE,CAAC;IAC9B,QAAQ,CAAC,EAAE,YAAY,EAAE,CAAC;IAC1B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,CAAC;IAC/C,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,GAAG,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,GAAG,CAAC;IACZ,MAAM,CAAC,EAAE,GAAG,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,qBAAa,KAAM,SAAQ,WAAY,YAAW,QAAQ;IACzC,QAAQ,EAAE,aAAa,CAAC;IAChC,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAa;IAKhD,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAO;IAC3C,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAS;gBAEhC,QAAQ,EAAE,OAAO,CAAC,aAAa,CAAC,EAAE,YAAY,GAAE,MAAW;IA0CvE;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAU5B;;;;;OAKG;IACH,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,IAAI;IA0E5C;;OAEG;IACH,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG;IAI/B;;OAEG;IACH,gBAAgB,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAIvC;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAmB9B;;OAEG;IACG,OAAO,CAAC,KAAK,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC;IAwBxC;;OAEG;IACa,QAAQ,IAAI,uBAAuB;IAiFnD;;OAEG;IACa,SAAS,IAAI,MAAM;IAgBnC;;OAEG;IACa,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAkC/C;;OAEG;IACmB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAY/C;;OAEG;IACH,KAAK,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,KAAK;IAkBjD;;;;OAIG;IACmB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAUjD;;;;;OAKG;IACH,eAAe,IAAI,IAAI;CAIxB"}

package/dist/test/src/elements/skills/Skill.js

@@ -0,0 +1,381 @@
+/**
+ * Skill element class implementing IElement interface.
+ * Represents a discrete capability for specific tasks.
+ *
+ * SECURITY FIXES IMPLEMENTED (PR #319):
+ * 1. CRITICAL: Added comprehensive input validation for all skill parameters
+ * 2. MEDIUM: Implemented Unicode normalization to prevent homograph attacks
+ * 3. MEDIUM: Added audit logging for security events via SecurityMonitor
+ * 4. MEDIUM: Implemented memory management to prevent unbounded growth
+ * 5. MEDIUM: Added XSS protection through input sanitization
+ */
+import { BaseElement } from '../BaseElement.js';
+import { ElementType } from '../../portfolio/types.js';
+import { logger } from '../../utils/logger.js';
+import { sanitizeInput } from '../../security/InputValidator.js';
+import { UnicodeValidator } from '../../security/validators/unicodeValidator.js';
+import { SecurityMonitor } from '../../security/securityMonitor.js';
+export class Skill extends BaseElement {
+    instructions;
+    parameters = new Map();
+    // SECURITY FIX #4: Memory management constants to prevent unbounded growth
+    // Previously: No limits on parameter storage, could lead to memory exhaustion
+    // Now: Enforced limits on both count and size
+    MAX_PARAMETER_COUNT = 100;
+    MAX_PARAMETER_SIZE = 10000; // Max size per parameter value
+    constructor(metadata, instructions = '') {
+        // SECURITY FIX #2: Validate and sanitize ALL metadata fields
+        // Previously: metadata was used directly without validation
+        // Now: All string inputs are Unicode normalized and sanitized to prevent:
+        // - XSS attacks through malicious metadata
+        // - Unicode homograph attacks
+        // - Buffer overflow attempts
+        const sanitizedMetadata = {
+            ...metadata,
+            name: metadata.name ? sanitizeInput(UnicodeValidator.normalize(metadata.name).normalizedContent, 100) : undefined,
+            description: metadata.description ? sanitizeInput(UnicodeValidator.normalize(metadata.description).normalizedContent, 500) : undefined
+        };
+        super(ElementType.SKILL, sanitizedMetadata);
+        this.instructions = instructions ? sanitizeInput(UnicodeValidator.normalize(instructions).normalizedContent, 10000) : '';
+        // Ensure skill-specific metadata
+        this.metadata = {
+            ...this.metadata,
+            languages: metadata.languages || [],
+            complexity: metadata.complexity || 'beginner',
+            domains: metadata.domains || [],
+            prerequisites: metadata.prerequisites || [],
+            parameters: metadata.parameters || [],
+            examples: metadata.examples || [],
+            proficiency_level: metadata.proficiency_level || 0
+        };
+        // Validate parameter definitions
+        if (this.metadata.parameters) {
+            this.metadata.parameters = this.metadata.parameters.map(param => ({
+                ...param,
+                name: sanitizeInput(UnicodeValidator.normalize(param.name).normalizedContent, 50),
+                description: sanitizeInput(UnicodeValidator.normalize(param.description).normalizedContent, 200),
+                options: param.options?.map(opt => sanitizeInput(opt, 100))
+            }));
+        }
+        // Initialize parameter values with defaults
+        this.initializeParameters();
+    }
+    /**
+     * Initialize parameters with default values
+     */
+    initializeParameters() {
+        if (this.metadata.parameters) {
+            this.metadata.parameters.forEach(param => {
+                if (param.default !== undefined) {
+                    this.parameters.set(param.name, param.default);
+                }
+            });
+        }
+    }
+    /**
+     * Set a parameter value
+     * SECURITY FIX #1: Comprehensive input validation for all skill parameters
+     * Previously: Parameters were set without validation, creating security risks
+     * Now: Full validation pipeline including sanitization, type checking, and size limits
+     */
+    setParameter(name, value) {
+        // CRITICAL FIX: Sanitize parameter name to prevent injection attacks
+        const sanitizedName = sanitizeInput(name, 50);
+        const param = this.metadata.parameters?.find(p => p.name === sanitizedName);
+        if (!param) {
+            // SECURITY FIX #3: Log audit events for security monitoring
+            // This helps detect potential attack patterns or misconfigurations
+            SecurityMonitor.logSecurityEvent({
+                type: 'YAML_PARSING_WARNING',
+                severity: 'MEDIUM',
+                source: 'Skill.setParameter',
+                details: `Attempt to set unknown parameter: ${sanitizedName} for skill: ${this.metadata.name}`
+            });
+            throw new Error(`Parameter '${sanitizedName}' not found in skill definition`);
+        }
+        // CRITICAL FIX: Sanitize and validate the value based on type
+        let sanitizedValue = value;
+        if (param.type === 'string') {
+            // SECURITY FIX #2 & #5: Normalize Unicode and sanitize string values
+            // Previously: String values were used directly without validation
+            // Now: Full validation pipeline:
+            // 1. Unicode normalization prevents homograph attacks
+            // 2. sanitizeInput() strips dangerous HTML/JS content
+            // 3. Length limits prevent buffer overflow attacks
+            const normalized = UnicodeValidator.normalize(String(value));
+            sanitizedValue = sanitizeInput(normalized.normalizedContent, param.max || 1000);
+            // SECURITY FIX #5: Additional XSS protection
+            // Check for common XSS patterns even after sanitization
+            // This provides defense-in-depth against sophisticated attacks
+            if (sanitizedValue.includes('<script') || sanitizedValue.includes('javascript:')) {
+                // SECURITY FIX #3: Log high-severity security events
+                SecurityMonitor.logSecurityEvent({
+                    type: 'CONTENT_INJECTION_ATTEMPT',
+                    severity: 'HIGH',
+                    source: 'Skill.setParameter',
+                    details: `Potential XSS attempt in skill parameter: ${sanitizedName} for skill: ${this.metadata.name}`
+                });
+                throw new Error('Invalid characters in parameter value');
+            }
+        }
+        // Type validation
+        if (!this.validateParameterValue(param, sanitizedValue)) {
+            throw new Error(`Invalid value for parameter '${sanitizedName}': expected ${param.type}`);
+        }
+        // SECURITY FIX #4: Memory management - check parameter count
+        // Previously: No limits on parameter storage, could lead to memory exhaustion attacks
+        // Now: Enforced limits prevent attackers from consuming unlimited memory
+        if (this.parameters.size >= this.MAX_PARAMETER_COUNT && !this.parameters.has(sanitizedName)) {
+            // SECURITY FIX #3: Log rate limit violations for security monitoring
+            SecurityMonitor.logSecurityEvent({
+                type: 'RATE_LIMIT_EXCEEDED',
+                severity: 'MEDIUM',
+                source: 'Skill.setParameter',
+                details: `Parameter limit exceeded for skill: ${this.metadata.name}. Max: ${this.MAX_PARAMETER_COUNT}`
+            });
+            throw new Error(`Parameter limit exceeded. Maximum ${this.MAX_PARAMETER_COUNT} parameters allowed`);
+        }
+        // SECURITY FIX #4: Check parameter value size for strings
+        // This prevents attackers from storing massive strings that could exhaust memory
+        if (param.type === 'string' && sanitizedValue.length > this.MAX_PARAMETER_SIZE) {
+            throw new Error(`Parameter value too large. Maximum ${this.MAX_PARAMETER_SIZE} characters allowed`);
+        }
+        this.parameters.set(sanitizedName, sanitizedValue);
+        logger.debug(`Set parameter ${sanitizedName} = ${sanitizedValue} for skill ${this.metadata.name}`);
+    }
+    /**
+     * Get a parameter value
+     */
+    getParameter(name) {
+        return this.parameters.get(name);
+    }
+    /**
+     * Get all parameters as object
+     */
+    getAllParameters() {
+        return Object.fromEntries(this.parameters);
+    }
+    /**
+     * Validate parameter value against its definition
+     */
+    validateParameterValue(param, value) {
+        switch (param.type) {
+            case 'string':
+                return typeof value === 'string';
+            case 'number':
+                const num = Number(value);
+                if (isNaN(num))
+                    return false;
+                if (param.min !== undefined && num < param.min)
+                    return false;
+                if (param.max !== undefined && num > param.max)
+                    return false;
+                return true;
+            case 'boolean':
+                return typeof value === 'boolean';
+            case 'enum':
+                return param.options?.includes(String(value)) || false;
+            default:
+                return true;
+        }
+    }
+    /**
+     * Execute the skill with current parameters
+     */
+    async execute(input) {
+        logger.info(`Executing skill: ${this.metadata.name}`);
+        // Validate required parameters
+        const missingRequired = this.metadata.parameters
+            ?.filter(p => p.required && !this.parameters.has(p.name))
+            .map(p => p.name) || [];
+        if (missingRequired.length > 0) {
+            throw new Error(`Missing required parameters: ${missingRequired.join(', ')}`);
+        }
+        // Skills don't have built-in execution logic - this would be implemented
+        // by specific skill types or through a plugin system
+        logger.debug(`Skill ${this.metadata.name} executed with parameters:`, this.getAllParameters());
+        return {
+            skill: this.metadata.name,
+            parameters: this.getAllParameters(),
+            input,
+            executed_at: new Date().toISOString()
+        };
+    }
+    /**
+     * Skill-specific validation
+     */
+    validate() {
+        const result = super.validate();
+        // Initialize arrays if not present
+        if (!result.errors)
+            result.errors = [];
+        if (!result.warnings)
+            result.warnings = [];
+        // Instructions should not be empty
+        if (!this.instructions || this.instructions.trim().length === 0) {
+            result.errors.push({
+                field: 'instructions',
+                message: 'Skill instructions cannot be empty',
+                code: 'EMPTY_INSTRUCTIONS'
+            });
+        }
+        // Validate complexity level
+        const validComplexity = ['beginner', 'intermediate', 'advanced', 'expert'];
+        if (this.metadata.complexity && !validComplexity.includes(this.metadata.complexity)) {
+            result.errors.push({
+                field: 'complexity',
+                message: `Complexity must be one of: ${validComplexity.join(', ')}`,
+                code: 'INVALID_COMPLEXITY'
+            });
+        }
+        // Validate proficiency level
+        if (this.metadata.proficiency_level !== undefined) {
+            if (this.metadata.proficiency_level < 0 || this.metadata.proficiency_level > 100) {
+                result.errors.push({
+                    field: 'proficiency_level',
+                    message: 'Proficiency level must be between 0 and 100',
+                    code: 'INVALID_PROFICIENCY'
+                });
+            }
+        }
+        // Validate parameters
+        if (this.metadata.parameters) {
+            this.metadata.parameters.forEach((param, index) => {
+                if (!param.name || param.name.trim() === '') {
+                    result.errors.push({
+                        field: `parameters[${index}].name`,
+                        message: 'Parameter name is required',
+                        code: 'MISSING_PARAMETER_NAME'
+                    });
+                }
+                if (param.type === 'enum' && (!param.options || param.options.length === 0)) {
+                    result.errors.push({
+                        field: `parameters[${index}].options`,
+                        message: 'Enum parameter must have options defined',
+                        code: 'MISSING_ENUM_OPTIONS'
+                    });
+                }
+            });
+        }
+        // Warnings for best practices
+        if (!this.metadata.domains || this.metadata.domains.length === 0) {
+            result.warnings.push({
+                field: 'domains',
+                message: 'Consider adding domain categories for better organization',
+                severity: 'low'
+            });
+        }
+        if (!this.metadata.examples || this.metadata.examples.length === 0) {
+            result.warnings.push({
+                field: 'examples',
+                message: 'Adding usage examples improves skill usability',
+                severity: 'medium'
+            });
+        }
+        // Update the valid flag based on final errors
+        result.valid = (result.errors?.length || 0) === 0;
+        return result;
+    }
+    /**
+     * Serialize skill to JSON format
+     */
+    serialize() {
+        const data = {
+            id: this.id,
+            type: this.type,
+            version: this.version,
+            metadata: this.metadata,
+            instructions: this.instructions,
+            parameters: this.getAllParameters(),
+            references: this.references,
+            extensions: this.extensions,
+            ratings: this.ratings
+        };
+        return JSON.stringify(data, null, 2);
+    }
+    /**
+     * Deserialize skill from JSON format
+     */
+    deserialize(data) {
+        try {
+            const parsed = JSON.parse(data);
+            // Update metadata
+            this.metadata = { ...this.metadata, ...parsed.metadata };
+            // Update other properties
+            this.instructions = parsed.instructions || '';
+            this.references = parsed.references || [];
+            this.extensions = parsed.extensions || {};
+            this.ratings = parsed.ratings || this.ratings;
+            // Update ID and version if provided
+            if (parsed.id)
+                this.id = parsed.id;
+            if (parsed.version)
+                this.version = parsed.version;
+            // Restore parameters
+            if (parsed.parameters) {
+                this.parameters.clear();
+                Object.entries(parsed.parameters).forEach(([key, value]) => {
+                    this.parameters.set(key, value);
+                });
+            }
+            this._isDirty = true;
+            logger.debug(`Deserialized skill: ${this.metadata.name}`);
+        }
+        catch (error) {
+            logger.error(`Failed to deserialize skill: ${error}`);
+            throw new Error(`Deserialization failed: ${error}`);
+        }
+    }
+    /**
+     * Skill activation lifecycle
+     */
+    async activate() {
+        logger.info(`Activating skill: ${this.metadata.name} (${this.id})`);
+        // Validate that all required parameters are set
+        const validation = this.validate();
+        if (!validation.valid) {
+            throw new Error(`Cannot activate skill with validation errors: ${validation.errors?.map(e => e.message).join(', ')}`);
+        }
+        await super.activate?.();
+    }
+    /**
+     * Clone the skill with different parameters
+     */
+    clone(newParameters) {
+        const cloned = new Skill(this.metadata, this.instructions);
+        // Copy current parameters
+        this.parameters.forEach((value, key) => {
+            cloned.parameters.set(key, value);
+        });
+        // Override with new parameters if provided
+        if (newParameters) {
+            Object.entries(newParameters).forEach(([key, value]) => {
+                cloned.setParameter(key, value);
+            });
+        }
+        return cloned;
+    }
+    /**
+     * Skill deactivation lifecycle
+     * SECURITY FIX #4: Automatically clears parameters on deactivation
+     * to prevent memory leaks in long-running processes
+     */
+    async deactivate() {
+        logger.info(`Deactivating skill: ${this.metadata.name} (${this.id})`);
+        // SECURITY FIX #4: Clear parameters to free memory and prevent leaks
+        // This ensures skills don't retain data after deactivation
+        this.clearParameters();
+        await super.deactivate?.();
+    }
+    /**
+     * Clear all parameters (for memory management)
+     * SECURITY FIX #4: Added method to clear parameters and prevent memory leaks
+     * Previously: Parameters accumulated indefinitely in long-running processes
+     * Now: Provides explicit cleanup mechanism called during deactivation
+     */
+    clearParameters() {
+        this.parameters.clear();
+        logger.debug(`Cleared all parameters for skill: ${this.metadata.name}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Skill.js","sourceRoot":"","sources":["../../../../../src/elements/skills/Skill.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Skill element class implementing IElement interface.\n * Represents a discrete capability for specific tasks.\n * \n * SECURITY FIXES IMPLEMENTED (PR #319):\n * 1. CRITICAL: Added comprehensive input validation for all skill parameters\n * 2. MEDIUM: Implemented Unicode normalization to prevent homograph attacks\n * 3. MEDIUM: Added audit logging for security events via SecurityMonitor\n * 4. MEDIUM: Implemented memory management to prevent unbounded growth\n * 5. MEDIUM: Added XSS protection through input sanitization\n */\n\nimport { BaseElement } from '../BaseElement.js';\nimport { IElement, IElementMetadata, ElementValidationResult } from '../../types/elements/index.js';\nimport { ElementType } from '../../portfolio/types.js';\nimport { logger } from '../../utils/logger.js';\nimport { sanitizeInput, validatePath } from '../../security/InputValidator.js';\nimport { UnicodeValidator } from '../../security/validators/unicodeValidator.js';\nimport { SecurityMonitor } from '../../security/securityMonitor.js';\n\n// Extend IElementMetadata with skill-specific fields\nexport interface SkillMetadata extends IElementMetadata {\n  languages?: string[];           // Programming/spoken languages this skill works with\n  complexity?: 'beginner' | 'intermediate' | 'advanced' | 'expert';\n  domains?: string[];             // Domain categories (e.g., web-dev, data-science, writing)\n  prerequisites?: string[];       // Required knowledge or other skills\n  parameters?: SkillParameter[];  // Configurable parameters\n  examples?: SkillExample[];      // Usage examples\n  certification?: string;         // External certification or validation\n  proficiency_level?: number;     // 1-100 proficiency level\n}\n\nexport interface SkillParameter {\n  name: string;\n  type: 'string' | 'number' | 'boolean' | 'enum';\n  description: string;\n  required?: boolean;\n  default?: any;\n  options?: string[];  // For enum type\n  min?: number;        // For number type\n  max?: number;        // For number type\n}\n\nexport interface SkillExample {\n  title: string;\n  description: string;\n  input?: any;\n  output?: any;\n  code?: string;\n}\n\nexport class Skill extends BaseElement implements IElement {\n  public declare metadata: SkillMetadata;\n  public instructions: string;\n  public parameters: Map<string, any> = new Map();\n  \n  // SECURITY FIX #4: Memory management constants to prevent unbounded growth\n  // Previously: No limits on parameter storage, could lead to memory exhaustion\n  // Now: Enforced limits on both count and size\n  private readonly MAX_PARAMETER_COUNT = 100;\n  private readonly MAX_PARAMETER_SIZE = 10000; // Max size per parameter value\n\n  constructor(metadata: Partial<SkillMetadata>, instructions: string = '') {\n    // SECURITY FIX #2: Validate and sanitize ALL metadata fields\n    // Previously: metadata was used directly without validation\n    // Now: All string inputs are Unicode normalized and sanitized to prevent:\n    // - XSS attacks through malicious metadata\n    // - Unicode homograph attacks\n    // - Buffer overflow attempts\n    const sanitizedMetadata = {\n      ...metadata,\n      name: metadata.name ? sanitizeInput(UnicodeValidator.normalize(metadata.name).normalizedContent, 100) : undefined,\n      description: metadata.description ? sanitizeInput(UnicodeValidator.normalize(metadata.description).normalizedContent, 500) : undefined\n    };\n    \n    super(ElementType.SKILL, sanitizedMetadata);\n    this.instructions = instructions ? sanitizeInput(UnicodeValidator.normalize(instructions).normalizedContent, 10000) : '';\n    \n    // Ensure skill-specific metadata\n    this.metadata = {\n      ...this.metadata,\n      languages: metadata.languages || [],\n      complexity: metadata.complexity || 'beginner',\n      domains: metadata.domains || [],\n      prerequisites: metadata.prerequisites || [],\n      parameters: metadata.parameters || [],\n      examples: metadata.examples || [],\n      proficiency_level: metadata.proficiency_level || 0\n    };\n\n    // Validate parameter definitions\n    if (this.metadata.parameters) {\n      this.metadata.parameters = this.metadata.parameters.map(param => ({\n        ...param,\n        name: sanitizeInput(UnicodeValidator.normalize(param.name).normalizedContent, 50),\n        description: sanitizeInput(UnicodeValidator.normalize(param.description).normalizedContent, 200),\n        options: param.options?.map(opt => sanitizeInput(opt, 100))\n      }));\n    }\n\n    // Initialize parameter values with defaults\n    this.initializeParameters();\n  }\n\n  /**\n   * Initialize parameters with default values\n   */\n  private initializeParameters(): void {\n    if (this.metadata.parameters) {\n      this.metadata.parameters.forEach(param => {\n        if (param.default !== undefined) {\n          this.parameters.set(param.name, param.default);\n        }\n      });\n    }\n  }\n\n  /**\n   * Set a parameter value\n   * SECURITY FIX #1: Comprehensive input validation for all skill parameters\n   * Previously: Parameters were set without validation, creating security risks\n   * Now: Full validation pipeline including sanitization, type checking, and size limits\n   */\n  setParameter(name: string, value: any): void {\n    // CRITICAL FIX: Sanitize parameter name to prevent injection attacks\n    const sanitizedName = sanitizeInput(name, 50);\n    \n    const param = this.metadata.parameters?.find(p => p.name === sanitizedName);\n    if (!param) {\n      // SECURITY FIX #3: Log audit events for security monitoring\n      // This helps detect potential attack patterns or misconfigurations\n      SecurityMonitor.logSecurityEvent({\n        type: 'YAML_PARSING_WARNING',\n        severity: 'MEDIUM',\n        source: 'Skill.setParameter',\n        details: `Attempt to set unknown parameter: ${sanitizedName} for skill: ${this.metadata.name}`\n      });\n      throw new Error(`Parameter '${sanitizedName}' not found in skill definition`);\n    }\n\n    // CRITICAL FIX: Sanitize and validate the value based on type\n    let sanitizedValue = value;\n    \n    if (param.type === 'string') {\n      // SECURITY FIX #2 & #5: Normalize Unicode and sanitize string values\n      // Previously: String values were used directly without validation\n      // Now: Full validation pipeline:\n      // 1. Unicode normalization prevents homograph attacks\n      // 2. sanitizeInput() strips dangerous HTML/JS content\n      // 3. Length limits prevent buffer overflow attacks\n      const normalized = UnicodeValidator.normalize(String(value));\n      sanitizedValue = sanitizeInput(normalized.normalizedContent, param.max || 1000);\n      \n      // SECURITY FIX #5: Additional XSS protection\n      // Check for common XSS patterns even after sanitization\n      // This provides defense-in-depth against sophisticated attacks\n      if (sanitizedValue.includes('<script') || sanitizedValue.includes('javascript:')) {\n        // SECURITY FIX #3: Log high-severity security events\n        SecurityMonitor.logSecurityEvent({\n          type: 'CONTENT_INJECTION_ATTEMPT',\n          severity: 'HIGH',\n          source: 'Skill.setParameter',\n          details: `Potential XSS attempt in skill parameter: ${sanitizedName} for skill: ${this.metadata.name}`\n        });\n        throw new Error('Invalid characters in parameter value');\n      }\n    }\n\n    // Type validation\n    if (!this.validateParameterValue(param, sanitizedValue)) {\n      throw new Error(`Invalid value for parameter '${sanitizedName}': expected ${param.type}`);\n    }\n\n    // SECURITY FIX #4: Memory management - check parameter count\n    // Previously: No limits on parameter storage, could lead to memory exhaustion attacks\n    // Now: Enforced limits prevent attackers from consuming unlimited memory\n    if (this.parameters.size >= this.MAX_PARAMETER_COUNT && !this.parameters.has(sanitizedName)) {\n      // SECURITY FIX #3: Log rate limit violations for security monitoring\n      SecurityMonitor.logSecurityEvent({\n        type: 'RATE_LIMIT_EXCEEDED',\n        severity: 'MEDIUM',\n        source: 'Skill.setParameter',\n        details: `Parameter limit exceeded for skill: ${this.metadata.name}. Max: ${this.MAX_PARAMETER_COUNT}`\n      });\n      throw new Error(`Parameter limit exceeded. Maximum ${this.MAX_PARAMETER_COUNT} parameters allowed`);\n    }\n    \n    // SECURITY FIX #4: Check parameter value size for strings\n    // This prevents attackers from storing massive strings that could exhaust memory\n    if (param.type === 'string' && sanitizedValue.length > this.MAX_PARAMETER_SIZE) {\n      throw new Error(`Parameter value too large. Maximum ${this.MAX_PARAMETER_SIZE} characters allowed`);\n    }\n\n    this.parameters.set(sanitizedName, sanitizedValue);\n    logger.debug(`Set parameter ${sanitizedName} = ${sanitizedValue} for skill ${this.metadata.name}`);\n  }\n\n  /**\n   * Get a parameter value\n   */\n  getParameter(name: string): any {\n    return this.parameters.get(name);\n  }\n\n  /**\n   * Get all parameters as object\n   */\n  getAllParameters(): Record<string, any> {\n    return Object.fromEntries(this.parameters);\n  }\n\n  /**\n   * Validate parameter value against its definition\n   */\n  private validateParameterValue(param: SkillParameter, value: any): boolean {\n    switch (param.type) {\n      case 'string':\n        return typeof value === 'string';\n      case 'number':\n        const num = Number(value);\n        if (isNaN(num)) return false;\n        if (param.min !== undefined && num < param.min) return false;\n        if (param.max !== undefined && num > param.max) return false;\n        return true;\n      case 'boolean':\n        return typeof value === 'boolean';\n      case 'enum':\n        return param.options?.includes(String(value)) || false;\n      default:\n        return true;\n    }\n  }\n\n  /**\n   * Execute the skill with current parameters\n   */\n  async execute(input?: any): Promise<any> {\n    logger.info(`Executing skill: ${this.metadata.name}`);\n    \n    // Validate required parameters\n    const missingRequired = this.metadata.parameters\n      ?.filter(p => p.required && !this.parameters.has(p.name))\n      .map(p => p.name) || [];\n    \n    if (missingRequired.length > 0) {\n      throw new Error(`Missing required parameters: ${missingRequired.join(', ')}`);\n    }\n\n    // Skills don't have built-in execution logic - this would be implemented\n    // by specific skill types or through a plugin system\n    logger.debug(`Skill ${this.metadata.name} executed with parameters:`, this.getAllParameters());\n    \n    return {\n      skill: this.metadata.name,\n      parameters: this.getAllParameters(),\n      input,\n      executed_at: new Date().toISOString()\n    };\n  }\n\n  /**\n   * Skill-specific validation\n   */\n  public override validate(): ElementValidationResult {\n    const result = super.validate();\n    \n    // Initialize arrays if not present\n    if (!result.errors) result.errors = [];\n    if (!result.warnings) result.warnings = [];\n    \n    // Instructions should not be empty\n    if (!this.instructions || this.instructions.trim().length === 0) {\n      result.errors.push({\n        field: 'instructions',\n        message: 'Skill instructions cannot be empty',\n        code: 'EMPTY_INSTRUCTIONS'\n      });\n    }\n\n    // Validate complexity level\n    const validComplexity = ['beginner', 'intermediate', 'advanced', 'expert'];\n    if (this.metadata.complexity && !validComplexity.includes(this.metadata.complexity)) {\n      result.errors.push({\n        field: 'complexity',\n        message: `Complexity must be one of: ${validComplexity.join(', ')}`,\n        code: 'INVALID_COMPLEXITY'\n      });\n    }\n\n    // Validate proficiency level\n    if (this.metadata.proficiency_level !== undefined) {\n      if (this.metadata.proficiency_level < 0 || this.metadata.proficiency_level > 100) {\n        result.errors.push({\n          field: 'proficiency_level',\n          message: 'Proficiency level must be between 0 and 100',\n          code: 'INVALID_PROFICIENCY'\n        });\n      }\n    }\n\n    // Validate parameters\n    if (this.metadata.parameters) {\n      this.metadata.parameters.forEach((param, index) => {\n        if (!param.name || param.name.trim() === '') {\n          result.errors!.push({\n            field: `parameters[${index}].name`,\n            message: 'Parameter name is required',\n            code: 'MISSING_PARAMETER_NAME'\n          });\n        }\n        \n        if (param.type === 'enum' && (!param.options || param.options.length === 0)) {\n          result.errors!.push({\n            field: `parameters[${index}].options`,\n            message: 'Enum parameter must have options defined',\n            code: 'MISSING_ENUM_OPTIONS'\n          });\n        }\n      });\n    }\n\n    // Warnings for best practices\n    if (!this.metadata.domains || this.metadata.domains.length === 0) {\n      result.warnings.push({\n        field: 'domains',\n        message: 'Consider adding domain categories for better organization',\n        severity: 'low'\n      });\n    }\n\n    if (!this.metadata.examples || this.metadata.examples.length === 0) {\n      result.warnings.push({\n        field: 'examples',\n        message: 'Adding usage examples improves skill usability',\n        severity: 'medium'\n      });\n    }\n\n    // Update the valid flag based on final errors\n    result.valid = (result.errors?.length || 0) === 0;\n\n    return result;\n  }\n\n  /**\n   * Serialize skill to JSON format\n   */\n  public override serialize(): string {\n    const data = {\n      id: this.id,\n      type: this.type,\n      version: this.version,\n      metadata: this.metadata,\n      instructions: this.instructions,\n      parameters: this.getAllParameters(),\n      references: this.references,\n      extensions: this.extensions,\n      ratings: this.ratings\n    };\n\n    return JSON.stringify(data, null, 2);\n  }\n\n  /**\n   * Deserialize skill from JSON format\n   */\n  public override deserialize(data: string): void {\n    try {\n      const parsed = JSON.parse(data);\n      \n      // Update metadata\n      this.metadata = { ...this.metadata, ...parsed.metadata };\n      \n      // Update other properties\n      this.instructions = parsed.instructions || '';\n      this.references = parsed.references || [];\n      this.extensions = parsed.extensions || {};\n      this.ratings = parsed.ratings || this.ratings;\n      \n      // Update ID and version if provided\n      if (parsed.id) this.id = parsed.id;\n      if (parsed.version) this.version = parsed.version;\n      \n      // Restore parameters\n      if (parsed.parameters) {\n        this.parameters.clear();\n        Object.entries(parsed.parameters).forEach(([key, value]) => {\n          this.parameters.set(key, value);\n        });\n      }\n      \n      this._isDirty = true;\n      logger.debug(`Deserialized skill: ${this.metadata.name}`);\n      \n    } catch (error) {\n      logger.error(`Failed to deserialize skill: ${error}`);\n      throw new Error(`Deserialization failed: ${error}`);\n    }\n  }\n\n  /**\n   * Skill activation lifecycle\n   */\n  public override async activate(): Promise<void> {\n    logger.info(`Activating skill: ${this.metadata.name} (${this.id})`);\n    \n    // Validate that all required parameters are set\n    const validation = this.validate();\n    if (!validation.valid) {\n      throw new Error(`Cannot activate skill with validation errors: ${validation.errors?.map(e => e.message).join(', ')}`);\n    }\n    \n    await super.activate?.();\n  }\n\n  /**\n   * Clone the skill with different parameters\n   */\n  clone(newParameters?: Record<string, any>): Skill {\n    const cloned = new Skill(this.metadata, this.instructions);\n    \n    // Copy current parameters\n    this.parameters.forEach((value, key) => {\n      cloned.parameters.set(key, value);\n    });\n    \n    // Override with new parameters if provided\n    if (newParameters) {\n      Object.entries(newParameters).forEach(([key, value]) => {\n        cloned.setParameter(key, value);\n      });\n    }\n    \n    return cloned;\n  }\n  \n  /**\n   * Skill deactivation lifecycle\n   * SECURITY FIX #4: Automatically clears parameters on deactivation\n   * to prevent memory leaks in long-running processes\n   */\n  public override async deactivate(): Promise<void> {\n    logger.info(`Deactivating skill: ${this.metadata.name} (${this.id})`);\n    \n    // SECURITY FIX #4: Clear parameters to free memory and prevent leaks\n    // This ensures skills don't retain data after deactivation\n    this.clearParameters();\n    \n    await super.deactivate?.();\n  }\n  \n  /**\n   * Clear all parameters (for memory management)\n   * SECURITY FIX #4: Added method to clear parameters and prevent memory leaks\n   * Previously: Parameters accumulated indefinitely in long-running processes\n   * Now: Provides explicit cleanup mechanism called during deactivation\n   */\n  clearParameters(): void {\n    this.parameters.clear();\n    logger.debug(`Cleared all parameters for skill: ${this.metadata.name}`);\n  }\n}"]}