@dollhousemcp/mcp-server 1.3.0

package/dist/elements/ensembles/EnsembleManager.d.ts

@@ -0,0 +1,85 @@
+/**
+ * EnsembleManager - Implementation of IElementManager for Ensemble elements
+ * Handles CRUD operations and lifecycle management for ensembles
+ *
+ * SECURITY MEASURES (Following PersonaElementManager patterns):
+ * 1. CRITICAL: Uses FileLockManager for atomic file operations to prevent race conditions
+ * 2. HIGH: SecureYamlParser for YAML content validation to prevent injection attacks
+ * 3. MEDIUM: All user inputs validated and sanitized
+ * 4. MEDIUM: Audit logging for all security operations
+ * 5. Path validation to prevent directory traversal
+ */
+import { IElementManager } from '../../types/elements/index.js';
+import { ElementValidationResult } from '../../types/elements/IElement.js';
+import { Ensemble } from './Ensemble.js';
+import { ElementType } from '../../portfolio/types.js';
+export declare class EnsembleManager implements IElementManager<Ensemble> {
+    private baseDir;
+    constructor(baseDir: string);
+    /**
+     * Load an ensemble from file
+     * SECURITY FIX: Uses FileLockManager.atomicReadFile() to prevent race conditions
+     */
+    load(filePath: string): Promise<Ensemble>;
+    /**
+     * Save an ensemble to file
+     * SECURITY FIX: Uses FileLockManager.atomicWriteFile() for atomic writes
+     */
+    save(ensemble: Ensemble, filePath: string): Promise<void>;
+    /**
+     * List all ensembles in the directory
+     */
+    list(): Promise<Ensemble[]>;
+    /**
+     * Find an ensemble matching a predicate
+     */
+    find(predicate: (ensemble: Ensemble) => boolean): Promise<Ensemble | undefined>;
+    /**
+     * Validate an ensemble
+     */
+    validate(ensemble: Ensemble): ElementValidationResult;
+    /**
+     * Parse ensemble file content
+     * SECURITY FIX: Uses SecureYamlParser to prevent YAML injection attacks
+     */
+    private parseEnsembleFile;
+    /**
+     * Convert ensemble data to YAML safely
+     * SECURITY FIX: Uses yaml.dump with security options
+     */
+    private toYamlSafe;
+    /**
+     * Import an ensemble from JSON
+     * SECURITY: Full validation of imported data
+     */
+    importElement(jsonData: string, format?: 'json' | 'yaml' | 'markdown'): Promise<Ensemble>;
+    /**
+     * Export an ensemble to JSON
+     */
+    exportElement(ensemble: Ensemble): Promise<string>;
+    /**
+     * Delete an ensemble file
+     */
+    delete(filePath: string): Promise<void>;
+    /**
+     * Check if an ensemble file exists
+     */
+    exists(filePath: string): Promise<boolean>;
+    /**
+     * Find multiple ensembles matching a predicate
+     */
+    findMany(predicate: (ensemble: Ensemble) => boolean): Promise<Ensemble[]>;
+    /**
+     * Validate a file path
+     */
+    validatePath(filePath: string): boolean;
+    /**
+     * Get the element type this manager handles
+     */
+    getElementType(): ElementType;
+    /**
+     * Get the file extension for ensemble files
+     */
+    getFileExtension(): string;
+}
+//# sourceMappingURL=EnsembleManager.d.ts.map

package/dist/elements/ensembles/EnsembleManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnsembleManager.d.ts","sourceRoot":"","sources":["../../../src/elements/ensembles/EnsembleManager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,EAAE,uBAAuB,EAAE,MAAM,kCAAkC,CAAC;AAO3E,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAGzC,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAKvD,qBAAa,eAAgB,YAAW,eAAe,CAAC,QAAQ,CAAC;IACnD,OAAO,CAAC,OAAO;gBAAP,OAAO,EAAE,MAAM;IASnC;;;OAGG;IACG,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;IAwD/C;;;OAGG;IACG,IAAI,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA8C/D;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;IAiCjC;;OAEG;IACG,IAAI,CAAC,SAAS,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,OAAO,GAAG,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC;IAKrF;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,uBAAuB;IAIrD;;;OAGG;YACW,iBAAiB;IA4E/B;;;OAGG;IACH,OAAO,CAAC,UAAU;IAelB;;;OAGG;IACG,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,UAAU,GAAG,OAAO,CAAC,QAAQ,CAAC;IAsD/F;;OAEG;IACG,aAAa,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC;IAWxD;;OAEG;IACG,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAoB7C;;OAEG;IACG,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAkBhD;;OAEG;IACG,QAAQ,CAAC,SAAS,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,OAAO,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;IAK/E;;OAEG;IACH,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAIvC;;OAEG;IACH,cAAc,IAAI,WAAW;IAI7B;;OAEG;IACH,gBAAgB,IAAI,MAAM;CAG3B"}

package/dist/elements/ensembles/EnsembleManager.js

@@ -0,0 +1,378 @@
+/**
+ * EnsembleManager - Implementation of IElementManager for Ensemble elements
+ * Handles CRUD operations and lifecycle management for ensembles
+ *
+ * SECURITY MEASURES (Following PersonaElementManager patterns):
+ * 1. CRITICAL: Uses FileLockManager for atomic file operations to prevent race conditions
+ * 2. HIGH: SecureYamlParser for YAML content validation to prevent injection attacks
+ * 3. MEDIUM: All user inputs validated and sanitized
+ * 4. MEDIUM: Audit logging for all security operations
+ * 5. Path validation to prevent directory traversal
+ */
+import { FileLockManager } from '../../security/fileLockManager.js';
+import { SecureYamlParser } from '../../security/secureYamlParser.js';
+import { SecurityMonitor } from '../../security/securityMonitor.js';
+import { validatePath } from '../../security/InputValidator.js';
+import { logger } from '../../utils/logger.js';
+import { Ensemble } from './Ensemble.js';
+import { ElementType } from '../../portfolio/types.js';
+import * as path from 'path';
+import * as fs from 'fs/promises';
+import * as yaml from 'js-yaml';
+export class EnsembleManager {
+    baseDir;
+    constructor(baseDir) {
+        this.baseDir = baseDir;
+        // Validate base directory
+        const validatedPath = validatePath(baseDir);
+        if (!validatedPath) {
+            throw new Error('Invalid base directory path');
+        }
+        this.baseDir = validatedPath;
+    }
+    /**
+     * Load an ensemble from file
+     * SECURITY FIX: Uses FileLockManager.atomicReadFile() to prevent race conditions
+     */
+    async load(filePath) {
+        // SECURITY: Validate file path
+        const validatedPath = validatePath(filePath);
+        if (!validatedPath) {
+            throw new Error('Invalid file path');
+        }
+        const fullPath = path.isAbsolute(validatedPath)
+            ? validatedPath
+            : path.join(this.baseDir, validatedPath);
+        try {
+            // CRITICAL FIX: Use atomic file read to prevent race conditions
+            // Previously: const content = await fs.readFile(fullPath, 'utf-8');
+            // Now: Uses FileLockManager with proper encoding object format
+            const content = await FileLockManager.atomicReadFile(fullPath, { encoding: 'utf-8' });
+            // Parse ensemble data
+            const ensembleData = await this.parseEnsembleFile(content, fullPath);
+            // Create ensemble instance
+            const ensemble = new Ensemble(ensembleData.metadata);
+            // Add elements if present
+            if (ensembleData.elements) {
+                for (const element of ensembleData.elements) {
+                    ensemble.addElement(element.elementId, element.elementType, element.role, {
+                        priority: element.priority,
+                        activationCondition: element.activationCondition,
+                        dependencies: element.dependencies
+                    });
+                }
+            }
+            // Restore shared context if present
+            if (ensembleData.sharedContext) {
+                ensemble.deserialize(JSON.stringify({
+                    ...ensembleData,
+                    elements: Array.from(ensemble.getElements().entries())
+                }));
+            }
+            logger.info(`Loaded ensemble from ${fullPath}`);
+            return ensemble;
+        }
+        catch (error) {
+            logger.error(`Failed to load ensemble from ${fullPath}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Save an ensemble to file
+     * SECURITY FIX: Uses FileLockManager.atomicWriteFile() for atomic writes
+     */
+    async save(ensemble, filePath) {
+        // SECURITY: Validate file path
+        const validatedPath = validatePath(filePath);
+        if (!validatedPath) {
+            throw new Error('Invalid file path');
+        }
+        const fullPath = path.isAbsolute(validatedPath)
+            ? validatedPath
+            : path.join(this.baseDir, validatedPath);
+        try {
+            // Ensure directory exists
+            await fs.mkdir(path.dirname(fullPath), { recursive: true });
+            // Prepare ensemble data
+            const ensembleData = {
+                metadata: ensemble.metadata,
+                elements: Array.from(ensemble.getElements().values()),
+                extensions: ensemble.extensions
+            };
+            // Convert to YAML with security measures
+            const yamlContent = this.toYamlSafe(ensembleData);
+            // CRITICAL FIX: Use atomic file write to prevent race conditions
+            // Previously: await fs.writeFile(fullPath, yamlContent, 'utf-8');
+            // Now: Uses FileLockManager for atomic operation
+            await FileLockManager.atomicWriteFile(fullPath, yamlContent, { encoding: 'utf-8' });
+            // Log security event
+            SecurityMonitor.logSecurityEvent({
+                type: 'ENSEMBLE_SAVED',
+                severity: 'LOW',
+                source: 'EnsembleManager.save',
+                details: `Ensemble saved to ${fullPath}`
+            });
+            logger.info(`Saved ensemble to ${fullPath}`);
+        }
+        catch (error) {
+            logger.error(`Failed to save ensemble to ${fullPath}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * List all ensembles in the directory
+     */
+    async list() {
+        try {
+            const files = await fs.readdir(this.baseDir);
+            const ensembles = [];
+            // Process files in parallel with limit
+            const BATCH_SIZE = 10;
+            for (let i = 0; i < files.length; i += BATCH_SIZE) {
+                const batch = files.slice(i, i + BATCH_SIZE);
+                const batchPromises = batch
+                    .filter(file => file.endsWith('.md') || file.endsWith('.yaml') || file.endsWith('.yml'))
+                    .map(file => this.load(file).catch(error => {
+                    logger.warn(`Failed to load ensemble ${file}:`, error);
+                    return null;
+                }));
+                const batchResults = await Promise.all(batchPromises);
+                ensembles.push(...batchResults.filter((e) => e !== null));
+            }
+            return ensembles;
+        }
+        catch (error) {
+            // Handle missing directory gracefully with type-safe check
+            if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {
+                logger.debug('Ensembles directory does not exist yet, returning empty array');
+                return [];
+            }
+            logger.error('Failed to list ensembles:', error);
+            return [];
+        }
+    }
+    /**
+     * Find an ensemble matching a predicate
+     */
+    async find(predicate) {
+        const ensembles = await this.list();
+        return ensembles.find(predicate);
+    }
+    /**
+     * Validate an ensemble
+     */
+    validate(ensemble) {
+        return ensemble.validate();
+    }
+    /**
+     * Parse ensemble file content
+     * SECURITY FIX: Uses SecureYamlParser to prevent YAML injection attacks
+     */
+    async parseEnsembleFile(content, filePath) {
+        try {
+            // Try to parse as YAML frontmatter (markdown file)
+            if (filePath.endsWith('.md')) {
+                const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+                if (match) {
+                    // HIGH SEVERITY FIX: Use SecureYamlParser to prevent YAML injection
+                    // Previously: Used unsafe YAML parsing without validation
+                    // Now: Uses SecureYamlParser which validates content
+                    const parsed = SecureYamlParser.parse(match[1], {
+                        maxYamlSize: 64 * 1024, // 64KB limit
+                        validateContent: true
+                    });
+                    // Log security event
+                    SecurityMonitor.logSecurityEvent({
+                        type: 'YAML_PARSE_SUCCESS',
+                        severity: 'LOW',
+                        source: 'EnsembleManager.parseEnsembleFile',
+                        details: 'YAML content safely parsed'
+                    });
+                    return {
+                        metadata: parsed.data,
+                        content: match[2].trim()
+                    };
+                }
+            }
+            // SECURITY FIX: For plain YAML files, check if content already has frontmatter
+            // Previously: Used direct YAML parsing without security validation
+            // Now: Uses SecureYamlParser for consistent security validation
+            // Check if content already has frontmatter markers
+            if (content.trim().startsWith('---')) {
+                // Content already has frontmatter, parse directly  
+                const parsed = SecureYamlParser.parse(content, {
+                    maxYamlSize: 64 * 1024, // 64KB limit
+                    validateContent: true
+                });
+                // Log security event
+                SecurityMonitor.logSecurityEvent({
+                    type: 'YAML_PARSE_SUCCESS',
+                    severity: 'LOW',
+                    source: 'EnsembleManager.parseEnsembleFile',
+                    details: 'YAML frontmatter content safely parsed'
+                });
+                return parsed.data;
+            }
+            else {
+                // Plain YAML without frontmatter - create frontmatter format
+                const frontmatterFormat = `---\n${content}\n---\n`;
+                const parsed = SecureYamlParser.parse(frontmatterFormat, {
+                    maxYamlSize: 64 * 1024, // 64KB limit
+                    validateContent: true
+                });
+                // Log security event
+                SecurityMonitor.logSecurityEvent({
+                    type: 'YAML_PARSE_SUCCESS',
+                    severity: 'LOW',
+                    source: 'EnsembleManager.parseEnsembleFile',
+                    details: 'Plain YAML content safely parsed'
+                });
+                return parsed.data;
+            }
+        }
+        catch (error) {
+            logger.error('Failed to parse ensemble file:', error);
+            throw new Error(`Invalid ensemble file format: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Convert ensemble data to YAML safely
+     * SECURITY FIX: Uses yaml.dump with security options
+     */
+    toYamlSafe(data) {
+        // SECURITY FIX: Use yaml.dump with FAILSAFE_SCHEMA and security options
+        // This prevents arbitrary code execution via YAML
+        const yamlStr = yaml.dump(data, {
+            schema: yaml.FAILSAFE_SCHEMA,
+            noRefs: true,
+            skipInvalid: true,
+            quotingType: '"',
+            forceQuotes: true
+        });
+        // Add frontmatter delimiters for markdown files
+        return `---\n${yamlStr}---\n`;
+    }
+    /**
+     * Import an ensemble from JSON
+     * SECURITY: Full validation of imported data
+     */
+    async importElement(jsonData, format) {
+        // Validate JSON structure
+        let data;
+        try {
+            data = JSON.parse(jsonData);
+        }
+        catch (error) {
+            throw new Error('Invalid JSON format');
+        }
+        // Validate required fields
+        if (!data.metadata || typeof data.metadata !== 'object') {
+            throw new Error('Missing or invalid metadata');
+        }
+        // Create ensemble with validated metadata
+        const ensemble = new Ensemble(data.metadata);
+        // Add elements with validation
+        if (data.elements && Array.isArray(data.elements)) {
+            for (const element of data.elements) {
+                if (!element.elementId || !element.elementType) {
+                    logger.warn('Skipping invalid element during import');
+                    continue;
+                }
+                try {
+                    ensemble.addElement(element.elementId, element.elementType, element.role || 'support', {
+                        priority: element.priority,
+                        activationCondition: element.activationCondition,
+                        dependencies: element.dependencies
+                    });
+                }
+                catch (error) {
+                    logger.warn(`Failed to add element ${element.elementId} during import:`, error);
+                }
+            }
+        }
+        // Return without saving - caller can save if needed
+        SecurityMonitor.logSecurityEvent({
+            type: 'ENSEMBLE_IMPORTED',
+            severity: 'MEDIUM',
+            source: 'EnsembleManager.importElement',
+            details: `Ensemble imported`
+        });
+        return ensemble;
+    }
+    /**
+     * Export an ensemble to JSON
+     */
+    async exportElement(ensemble) {
+        const data = {
+            metadata: ensemble.metadata,
+            elements: Array.from(ensemble.getElements().values()),
+            extensions: ensemble.extensions
+        };
+        // SECURITY FIX: Ensure safe JSON serialization
+        return JSON.stringify(data, null, 2);
+    }
+    /**
+     * Delete an ensemble file
+     */
+    async delete(filePath) {
+        const validatedPath = validatePath(filePath);
+        if (!validatedPath) {
+            throw new Error('Invalid file path');
+        }
+        const fullPath = path.isAbsolute(validatedPath)
+            ? validatedPath
+            : path.join(this.baseDir, validatedPath);
+        await fs.unlink(fullPath);
+        SecurityMonitor.logSecurityEvent({
+            type: 'ENSEMBLE_DELETED',
+            severity: 'MEDIUM',
+            source: 'EnsembleManager.delete',
+            details: `Ensemble deleted: ${fullPath}`
+        });
+    }
+    /**
+     * Check if an ensemble file exists
+     */
+    async exists(filePath) {
+        const validatedPath = validatePath(filePath);
+        if (!validatedPath) {
+            return false;
+        }
+        const fullPath = path.isAbsolute(validatedPath)
+            ? validatedPath
+            : path.join(this.baseDir, validatedPath);
+        try {
+            await fs.access(fullPath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Find multiple ensembles matching a predicate
+     */
+    async findMany(predicate) {
+        const ensembles = await this.list();
+        return ensembles.filter(predicate);
+    }
+    /**
+     * Validate a file path
+     */
+    validatePath(filePath) {
+        return validatePath(filePath) !== null;
+    }
+    /**
+     * Get the element type this manager handles
+     */
+    getElementType() {
+        return ElementType.ENSEMBLE;
+    }
+    /**
+     * Get the file extension for ensemble files
+     */
+    getFileExtension() {
+        return '.yaml';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"EnsembleManager.js","sourceRoot":"","sources":["../../../src/elements/ensembles/EnsembleManager.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * EnsembleManager - Implementation of IElementManager for Ensemble elements\n * Handles CRUD operations and lifecycle management for ensembles\n * \n * SECURITY MEASURES (Following PersonaElementManager patterns):\n * 1. CRITICAL: Uses FileLockManager for atomic file operations to prevent race conditions\n * 2. HIGH: SecureYamlParser for YAML content validation to prevent injection attacks\n * 3. MEDIUM: All user inputs validated and sanitized\n * 4. MEDIUM: Audit logging for all security operations\n * 5. Path validation to prevent directory traversal\n */\n\nimport { IElementManager } from '../../types/elements/index.js';\nimport { ElementValidationResult } from '../../types/elements/IElement.js';\nimport { FileLockManager } from '../../security/fileLockManager.js';\nimport { SecureYamlParser } from '../../security/secureYamlParser.js';\nimport { SecurityMonitor } from '../../security/securityMonitor.js';\nimport { sanitizeInput, validatePath } from '../../security/InputValidator.js';\nimport { UnicodeValidator } from '../../security/validators/unicodeValidator.js';\nimport { logger } from '../../utils/logger.js';\nimport { Ensemble } from './Ensemble.js';\nimport { EnsembleMetadata } from './types.js';\nimport { ENSEMBLE_LIMITS } from './constants.js';\nimport { ElementType } from '../../portfolio/types.js';\nimport * as path from 'path';\nimport * as fs from 'fs/promises';\nimport * as yaml from 'js-yaml';\n\nexport class EnsembleManager implements IElementManager<Ensemble> {\n  constructor(private baseDir: string) {\n    // Validate base directory\n    const validatedPath = validatePath(baseDir);\n    if (!validatedPath) {\n      throw new Error('Invalid base directory path');\n    }\n    this.baseDir = validatedPath;\n  }\n\n  /**\n   * Load an ensemble from file\n   * SECURITY FIX: Uses FileLockManager.atomicReadFile() to prevent race conditions\n   */\n  async load(filePath: string): Promise<Ensemble> {\n    // SECURITY: Validate file path\n    const validatedPath = validatePath(filePath);\n    if (!validatedPath) {\n      throw new Error('Invalid file path');\n    }\n\n    const fullPath = path.isAbsolute(validatedPath) \n      ? validatedPath \n      : path.join(this.baseDir, validatedPath);\n\n    try {\n      // CRITICAL FIX: Use atomic file read to prevent race conditions\n      // Previously: const content = await fs.readFile(fullPath, 'utf-8');\n      // Now: Uses FileLockManager with proper encoding object format\n      const content = await FileLockManager.atomicReadFile(fullPath, { encoding: 'utf-8' });\n\n      // Parse ensemble data\n      const ensembleData = await this.parseEnsembleFile(content, fullPath);\n      \n      // Create ensemble instance\n      const ensemble = new Ensemble(ensembleData.metadata);\n      \n      // Add elements if present\n      if (ensembleData.elements) {\n        for (const element of ensembleData.elements) {\n          ensemble.addElement(\n            element.elementId,\n            element.elementType,\n            element.role,\n            {\n              priority: element.priority,\n              activationCondition: element.activationCondition,\n              dependencies: element.dependencies\n            }\n          );\n        }\n      }\n\n      // Restore shared context if present\n      if (ensembleData.sharedContext) {\n        ensemble.deserialize(JSON.stringify({\n          ...ensembleData,\n          elements: Array.from(ensemble.getElements().entries())\n        }));\n      }\n\n      logger.info(`Loaded ensemble from ${fullPath}`);\n      return ensemble;\n\n    } catch (error) {\n      logger.error(`Failed to load ensemble from ${fullPath}:`, error);\n      throw error;\n    }\n  }\n\n  /**\n   * Save an ensemble to file\n   * SECURITY FIX: Uses FileLockManager.atomicWriteFile() for atomic writes\n   */\n  async save(ensemble: Ensemble, filePath: string): Promise<void> {\n    // SECURITY: Validate file path\n    const validatedPath = validatePath(filePath);\n    if (!validatedPath) {\n      throw new Error('Invalid file path');\n    }\n\n    const fullPath = path.isAbsolute(validatedPath) \n      ? validatedPath \n      : path.join(this.baseDir, validatedPath);\n\n    try {\n      // Ensure directory exists\n      await fs.mkdir(path.dirname(fullPath), { recursive: true });\n\n      // Prepare ensemble data\n      const ensembleData = {\n        metadata: ensemble.metadata,\n        elements: Array.from(ensemble.getElements().values()),\n        extensions: ensemble.extensions\n      };\n\n      // Convert to YAML with security measures\n      const yamlContent = this.toYamlSafe(ensembleData);\n\n      // CRITICAL FIX: Use atomic file write to prevent race conditions\n      // Previously: await fs.writeFile(fullPath, yamlContent, 'utf-8');\n      // Now: Uses FileLockManager for atomic operation\n      await FileLockManager.atomicWriteFile(fullPath, yamlContent, { encoding: 'utf-8' });\n\n      // Log security event\n      SecurityMonitor.logSecurityEvent({\n        type: 'ENSEMBLE_SAVED',\n        severity: 'LOW',\n        source: 'EnsembleManager.save',\n        details: `Ensemble saved to ${fullPath}`\n      });\n\n      logger.info(`Saved ensemble to ${fullPath}`);\n\n    } catch (error) {\n      logger.error(`Failed to save ensemble to ${fullPath}:`, error);\n      throw error;\n    }\n  }\n\n  /**\n   * List all ensembles in the directory\n   */\n  async list(): Promise<Ensemble[]> {\n    try {\n      const files = await fs.readdir(this.baseDir);\n      const ensembles: Ensemble[] = [];\n\n      // Process files in parallel with limit\n      const BATCH_SIZE = 10;\n      for (let i = 0; i < files.length; i += BATCH_SIZE) {\n        const batch = files.slice(i, i + BATCH_SIZE);\n        const batchPromises = batch\n          .filter(file => file.endsWith('.md') || file.endsWith('.yaml') || file.endsWith('.yml'))\n          .map(file => this.load(file).catch(error => {\n            logger.warn(`Failed to load ensemble ${file}:`, error);\n            return null;\n          }));\n\n        const batchResults = await Promise.all(batchPromises);\n        ensembles.push(...batchResults.filter((e): e is Ensemble => e !== null));\n      }\n\n      return ensembles;\n\n    } catch (error) {\n      // Handle missing directory gracefully with type-safe check\n      if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {\n        logger.debug('Ensembles directory does not exist yet, returning empty array');\n        return [];\n      }\n      logger.error('Failed to list ensembles:', error);\n      return [];\n    }\n  }\n\n  /**\n   * Find an ensemble matching a predicate\n   */\n  async find(predicate: (ensemble: Ensemble) => boolean): Promise<Ensemble | undefined> {\n    const ensembles = await this.list();\n    return ensembles.find(predicate);\n  }\n\n  /**\n   * Validate an ensemble\n   */\n  validate(ensemble: Ensemble): ElementValidationResult {\n    return ensemble.validate();\n  }\n\n  /**\n   * Parse ensemble file content\n   * SECURITY FIX: Uses SecureYamlParser to prevent YAML injection attacks\n   */\n  private async parseEnsembleFile(content: string, filePath: string): Promise<any> {\n    try {\n      // Try to parse as YAML frontmatter (markdown file)\n      if (filePath.endsWith('.md')) {\n        const match = content.match(/^---\\n([\\s\\S]*?)\\n---\\n([\\s\\S]*)$/);\n        if (match) {\n          // HIGH SEVERITY FIX: Use SecureYamlParser to prevent YAML injection\n          // Previously: Used unsafe YAML parsing without validation\n          // Now: Uses SecureYamlParser which validates content\n          const parsed = SecureYamlParser.parse(match[1], {\n            maxYamlSize: 64 * 1024, // 64KB limit\n            validateContent: true\n          });\n\n          // Log security event\n          SecurityMonitor.logSecurityEvent({\n            type: 'YAML_PARSE_SUCCESS',\n            severity: 'LOW',\n            source: 'EnsembleManager.parseEnsembleFile',\n            details: 'YAML content safely parsed'\n          });\n\n          return {\n            metadata: parsed.data as unknown as EnsembleMetadata,\n            content: match[2].trim()\n          };\n        }\n      }\n\n      // SECURITY FIX: For plain YAML files, check if content already has frontmatter\n      // Previously: Used direct YAML parsing without security validation\n      // Now: Uses SecureYamlParser for consistent security validation\n      \n      // Check if content already has frontmatter markers\n      if (content.trim().startsWith('---')) {\n        // Content already has frontmatter, parse directly  \n        const parsed = SecureYamlParser.parse(content, {\n          maxYamlSize: 64 * 1024, // 64KB limit\n          validateContent: true\n        });\n\n        // Log security event\n        SecurityMonitor.logSecurityEvent({\n          type: 'YAML_PARSE_SUCCESS',\n          severity: 'LOW',\n          source: 'EnsembleManager.parseEnsembleFile',\n          details: 'YAML frontmatter content safely parsed'\n        });\n\n        return parsed.data;\n      } else {\n        // Plain YAML without frontmatter - create frontmatter format\n        const frontmatterFormat = `---\\n${content}\\n---\\n`;\n        \n        const parsed = SecureYamlParser.parse(frontmatterFormat, {\n          maxYamlSize: 64 * 1024, // 64KB limit\n          validateContent: true\n        });\n\n        // Log security event\n        SecurityMonitor.logSecurityEvent({\n          type: 'YAML_PARSE_SUCCESS',\n          severity: 'LOW',\n          source: 'EnsembleManager.parseEnsembleFile',\n          details: 'Plain YAML content safely parsed'\n        });\n\n        return parsed.data;\n      }\n\n    } catch (error) {\n      logger.error('Failed to parse ensemble file:', error);\n      throw new Error(`Invalid ensemble file format: ${error instanceof Error ? error.message : 'Unknown error'}`);\n    }\n  }\n\n  /**\n   * Convert ensemble data to YAML safely\n   * SECURITY FIX: Uses yaml.dump with security options\n   */\n  private toYamlSafe(data: any): string {\n    // SECURITY FIX: Use yaml.dump with FAILSAFE_SCHEMA and security options\n    // This prevents arbitrary code execution via YAML\n    const yamlStr = yaml.dump(data, {\n      schema: yaml.FAILSAFE_SCHEMA,\n      noRefs: true,\n      skipInvalid: true,\n      quotingType: '\"',\n      forceQuotes: true\n    });\n\n    // Add frontmatter delimiters for markdown files\n    return `---\\n${yamlStr}---\\n`;\n  }\n\n  /**\n   * Import an ensemble from JSON\n   * SECURITY: Full validation of imported data\n   */\n  async importElement(jsonData: string, format?: 'json' | 'yaml' | 'markdown'): Promise<Ensemble> {\n    // Validate JSON structure\n    let data: any;\n    try {\n      data = JSON.parse(jsonData);\n    } catch (error) {\n      throw new Error('Invalid JSON format');\n    }\n\n    // Validate required fields\n    if (!data.metadata || typeof data.metadata !== 'object') {\n      throw new Error('Missing or invalid metadata');\n    }\n\n    // Create ensemble with validated metadata\n    const ensemble = new Ensemble(data.metadata);\n\n    // Add elements with validation\n    if (data.elements && Array.isArray(data.elements)) {\n      for (const element of data.elements) {\n        if (!element.elementId || !element.elementType) {\n          logger.warn('Skipping invalid element during import');\n          continue;\n        }\n\n        try {\n          ensemble.addElement(\n            element.elementId,\n            element.elementType,\n            element.role || 'support',\n            {\n              priority: element.priority,\n              activationCondition: element.activationCondition,\n              dependencies: element.dependencies\n            }\n          );\n        } catch (error) {\n          logger.warn(`Failed to add element ${element.elementId} during import:`, error);\n        }\n      }\n    }\n\n    // Return without saving - caller can save if needed\n\n    SecurityMonitor.logSecurityEvent({\n      type: 'ENSEMBLE_IMPORTED',\n      severity: 'MEDIUM',\n      source: 'EnsembleManager.importElement',\n      details: `Ensemble imported`\n    });\n\n    return ensemble;\n  }\n\n  /**\n   * Export an ensemble to JSON\n   */\n  async exportElement(ensemble: Ensemble): Promise<string> {\n    const data = {\n      metadata: ensemble.metadata,\n      elements: Array.from(ensemble.getElements().values()),\n      extensions: ensemble.extensions\n    };\n\n    // SECURITY FIX: Ensure safe JSON serialization\n    return JSON.stringify(data, null, 2);\n  }\n\n  /**\n   * Delete an ensemble file\n   */\n  async delete(filePath: string): Promise<void> {\n    const validatedPath = validatePath(filePath);\n    if (!validatedPath) {\n      throw new Error('Invalid file path');\n    }\n\n    const fullPath = path.isAbsolute(validatedPath) \n      ? validatedPath \n      : path.join(this.baseDir, validatedPath);\n\n    await fs.unlink(fullPath);\n\n    SecurityMonitor.logSecurityEvent({\n      type: 'ENSEMBLE_DELETED',\n      severity: 'MEDIUM',\n      source: 'EnsembleManager.delete',\n      details: `Ensemble deleted: ${fullPath}`\n    });\n  }\n\n  /**\n   * Check if an ensemble file exists\n   */\n  async exists(filePath: string): Promise<boolean> {\n    const validatedPath = validatePath(filePath);\n    if (!validatedPath) {\n      return false;\n    }\n\n    const fullPath = path.isAbsolute(validatedPath) \n      ? validatedPath \n      : path.join(this.baseDir, validatedPath);\n\n    try {\n      await fs.access(fullPath);\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  /**\n   * Find multiple ensembles matching a predicate\n   */\n  async findMany(predicate: (ensemble: Ensemble) => boolean): Promise<Ensemble[]> {\n    const ensembles = await this.list();\n    return ensembles.filter(predicate);\n  }\n\n  /**\n   * Validate a file path\n   */\n  validatePath(filePath: string): boolean {\n    return validatePath(filePath) !== null;\n  }\n\n  /**\n   * Get the element type this manager handles\n   */\n  getElementType(): ElementType {\n    return ElementType.ENSEMBLE;\n  }\n\n  /**\n   * Get the file extension for ensemble files\n   */\n  getFileExtension(): string {\n    return '.yaml';\n  }\n}"]}

package/dist/elements/ensembles/constants.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Constants for Ensemble elements
+ *
+ * Defines limits, defaults, and security constants following patterns from other elements
+ */
+/**
+ * Resource limits to prevent DoS attacks
+ */
+export declare const ENSEMBLE_LIMITS: {
+    readonly MAX_ELEMENTS: 50;
+    readonly MAX_NESTING_DEPTH: 5;
+    readonly MAX_ACTIVATION_TIME: 30000;
+    readonly MAX_CONTEXT_SIZE: 1000;
+    readonly MAX_CONTEXT_VALUE_SIZE: 10000;
+    readonly MAX_DEPENDENCIES: 10;
+    readonly MAX_CONDITION_LENGTH: 200;
+    readonly MIN_ACTIVATION_INTERVAL: 100;
+};
+/**
+ * Default values for ensemble configuration
+ */
+export declare const ENSEMBLE_DEFAULTS: {
+    readonly ACTIVATION_STRATEGY: "sequential";
+    readonly CONFLICT_RESOLUTION: "last-write";
+    readonly ELEMENT_ROLE: "support";
+    readonly PRIORITY: 50;
+    readonly ALLOW_NESTED: true;
+    readonly ACTIVATION_TIMEOUT: 5000;
+};
+/**
+ * Supported activation strategies
+ */
+export declare const ACTIVATION_STRATEGIES: readonly ["all", "sequential", "lazy", "conditional", "priority"];
+/**
+ * Supported conflict resolution strategies
+ */
+export declare const CONFLICT_STRATEGIES: readonly ["last-write", "first-write", "priority", "merge", "error"];
+/**
+ * Element roles
+ */
+export declare const ELEMENT_ROLES: readonly ["primary", "support", "override", "monitor"];
+/**
+ * Security event types for ensemble operations
+ */
+export declare const ENSEMBLE_SECURITY_EVENTS: {
+    readonly CIRCULAR_DEPENDENCY: "ENSEMBLE_CIRCULAR_DEPENDENCY";
+    readonly RESOURCE_LIMIT_EXCEEDED: "ENSEMBLE_RESOURCE_LIMIT_EXCEEDED";
+    readonly ACTIVATION_TIMEOUT: "ENSEMBLE_ACTIVATION_TIMEOUT";
+    readonly SUSPICIOUS_CONDITION: "ENSEMBLE_SUSPICIOUS_CONDITION";
+    readonly NESTED_DEPTH_EXCEEDED: "ENSEMBLE_NESTED_DEPTH_EXCEEDED";
+    readonly CONTEXT_SIZE_EXCEEDED: "ENSEMBLE_CONTEXT_SIZE_EXCEEDED";
+};
+/**
+ * Error messages for validation
+ */
+export declare const ENSEMBLE_ERRORS: {
+    readonly TOO_MANY_ELEMENTS: "Ensemble cannot contain more than 50 elements";
+    readonly NESTING_TOO_DEEP: "Ensemble nesting depth cannot exceed 5";
+    readonly CIRCULAR_DEPENDENCY: "Circular dependency detected in ensemble";
+    readonly INVALID_STRATEGY: "Invalid activation strategy";
+    readonly INVALID_CONFLICT_RESOLUTION: "Invalid conflict resolution strategy";
+    readonly ELEMENT_NOT_FOUND: "Element not found in ensemble";
+    readonly ACTIVATION_TIMEOUT: "Ensemble activation timed out";
+    readonly CONTEXT_OVERFLOW: "Shared context size exceeded limits";
+};
+/**
+ * Regex patterns for validation
+ */
+export declare const ENSEMBLE_PATTERNS: {
+    readonly CONDITION_PATTERN: RegExp;
+    readonly ELEMENT_ID_PATTERN: RegExp;
+};
+//# sourceMappingURL=constants.d.ts.map

package/dist/elements/ensembles/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/elements/ensembles/constants.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;;;;CASlB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;CAOpB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,qBAAqB,mEAMxB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,mBAAmB,sEAMtB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,aAAa,wDAKhB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;;;CAO3B,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;;;;CASlB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;CAKpB,CAAC"}