@dollhousemcp/mcp-server 1.3.0

package/dist/persona/PersonaElementManager.d.ts

@@ -0,0 +1,97 @@
+/**
+ * PersonaElementManager - Implementation of IElementManager for PersonaElement
+ * Handles CRUD operations and lifecycle management for personas implementing IElement
+ *
+ * SECURITY FIXES IMPLEMENTED (PR #319):
+ * 1. CRITICAL: Fixed race conditions in file operations by using FileLockManager for atomic reads/writes
+ * 2. CRITICAL: Fixed dynamic require() statements by using static imports
+ * 3. HIGH: Fixed unvalidated YAML parsing vulnerability by using SecureYamlParser
+ * 4. MEDIUM: All user inputs are now validated and sanitized
+ * 5. MEDIUM: Audit logging added for security operations
+ */
+import { IElementManager, ElementValidationResult } from '../types/elements/index.js';
+import { ElementType } from '../portfolio/types.js';
+import { PersonaElement, PersonaElementMetadata } from './PersonaElement.js';
+import { PortfolioManager } from '../portfolio/PortfolioManager.js';
+export declare class PersonaElementManager implements IElementManager<PersonaElement> {
+    private portfolioManager;
+    private personasDir;
+    constructor(portfolioManager?: PortfolioManager);
+    /**
+     * Load a persona from file
+     * SECURITY FIX #1: Uses FileLockManager.atomicReadFile() instead of fs.readFile()
+     * to prevent race conditions and ensure atomic file operations
+     */
+    load(filePath: string): Promise<PersonaElement>;
+    /**
+     * Save a persona to file
+     * SECURITY FIX #1: Uses FileLockManager.atomicWriteFile() instead of fs.writeFile()
+     * to prevent race conditions and ensure atomic file operations
+     */
+    save(element: PersonaElement, filePath: string): Promise<void>;
+    /**
+     * Delete a persona file
+     */
+    delete(filePath: string): Promise<void>;
+    /**
+     * Check if a persona file exists
+     */
+    exists(filePath: string): Promise<boolean>;
+    /**
+     * List all personas
+     */
+    list(): Promise<PersonaElement[]>;
+    /**
+     * Find a persona by predicate
+     */
+    find(predicate: (element: PersonaElement) => boolean): Promise<PersonaElement | undefined>;
+    /**
+     * Find multiple personas by predicate
+     */
+    findMany(predicate: (element: PersonaElement) => boolean): Promise<PersonaElement[]>;
+    /**
+     * Validate a persona element
+     */
+    validate(element: PersonaElement): ElementValidationResult;
+    /**
+     * Validate a file path
+     */
+    validatePath(filePath: string): boolean;
+    /**
+     * Get element type
+     */
+    getElementType(): ElementType;
+    /**
+     * Get file extension
+     */
+    getFileExtension(): string;
+    /**
+     * Import persona from data
+     * SECURITY FIX #3: Uses SecureYamlParser instead of unsafe YAML parsing to prevent
+     * YAML deserialization attacks and injection vulnerabilities
+     */
+    importElement(data: string, format?: 'json' | 'yaml' | 'markdown'): Promise<PersonaElement>;
+    /**
+     * Export persona to data
+     * SECURITY FIX #2: Uses static import of js-yaml at top of file instead of
+     * dynamic require() for better security and bundling
+     * SECURITY FIX #3: Uses secure YAML dumping with safety options
+     */
+    exportElement(element: PersonaElement, format?: 'json' | 'yaml' | 'markdown'): Promise<string>;
+    /**
+     * Helper: Convert JSON data to markdown format
+     * SECURITY FIX #2: Uses statically imported yaml module
+     * SECURITY FIX #3: Uses secure YAML dumping with safety options
+     * Note: This is for internal conversion only, user-provided YAML must use SecureYamlParser
+     */
+    private jsonToMarkdown;
+    /**
+     * Create a new persona with default metadata
+     */
+    create(metadata: Partial<PersonaElementMetadata>): PersonaElement;
+    /**
+     * Get default filename for a persona
+     */
+    getDefaultFilename(persona: PersonaElement): string;
+}
+//# sourceMappingURL=PersonaElementManager.d.ts.map

package/dist/persona/PersonaElementManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PersonaElementManager.d.ts","sourceRoot":"","sources":["../../src/persona/PersonaElementManager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAKH,OAAO,EAAE,eAAe,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AACtF,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAC7E,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AAQpE,qBAAa,qBAAsB,YAAW,eAAe,CAAC,cAAc,CAAC;IAC3E,OAAO,CAAC,gBAAgB,CAAmB;IAC3C,OAAO,CAAC,WAAW,CAAS;gBAEhB,gBAAgB,CAAC,EAAE,gBAAgB;IAK/C;;;;OAIG;IACG,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;IA8BrD;;;;OAIG;IACG,IAAI,CAAC,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAmCpE;;OAEG;IACG,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAqB7C;;OAEG;IACG,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAYhD;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC;IA6BvC;;OAEG;IACG,IAAI,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,OAAO,GAAG,OAAO,CAAC,cAAc,GAAG,SAAS,CAAC;IAKhG;;OAEG;IACG,QAAQ,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,OAAO,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IAK1F;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,cAAc,GAAG,uBAAuB;IAI1D;;OAEG;IACH,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAoBvC;;OAEG;IACH,cAAc,IAAI,WAAW;IAI7B;;OAEG;IACH,gBAAgB,IAAI,MAAM;IAI1B;;;;OAIG;IACG,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,MAAM,GAAG,MAAM,GAAG,UAAuB,GAAG,OAAO,CAAC,cAAc,CAAC;IAmD7G;;;;;OAKG;IACG,aAAa,CAAC,OAAO,EAAE,cAAc,EAAE,MAAM,GAAE,MAAM,GAAG,MAAM,GAAG,UAAuB,GAAG,OAAO,CAAC,MAAM,CAAC;IA4BhH;;;;;OAKG;IACH,OAAO,CAAC,cAAc;IAYtB;;OAEG;IACH,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,sBAAsB,CAAC,GAAG,cAAc;IAmBjE;;OAEG;IACH,kBAAkB,CAAC,OAAO,EAAE,cAAc,GAAG,MAAM;CASpD"}

package/dist/persona/PersonaElementManager.js

@@ -0,0 +1,348 @@
+/**
+ * PersonaElementManager - Implementation of IElementManager for PersonaElement
+ * Handles CRUD operations and lifecycle management for personas implementing IElement
+ *
+ * SECURITY FIXES IMPLEMENTED (PR #319):
+ * 1. CRITICAL: Fixed race conditions in file operations by using FileLockManager for atomic reads/writes
+ * 2. CRITICAL: Fixed dynamic require() statements by using static imports
+ * 3. HIGH: Fixed unvalidated YAML parsing vulnerability by using SecureYamlParser
+ * 4. MEDIUM: All user inputs are now validated and sanitized
+ * 5. MEDIUM: Audit logging added for security operations
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as yaml from 'js-yaml';
+import { ElementType } from '../portfolio/types.js';
+import { PersonaElement } from './PersonaElement.js';
+import { PortfolioManager } from '../portfolio/PortfolioManager.js';
+import { logger } from '../utils/logger.js';
+import { validatePath } from '../security/InputValidator.js';
+import { ensureDirectory } from '../utils/filesystem.js';
+import { FileLockManager } from '../security/fileLockManager.js';
+import { SecureYamlParser } from '../security/secureYamlParser.js';
+import { SecurityMonitor } from '../security/securityMonitor.js';
+export class PersonaElementManager {
+    portfolioManager;
+    personasDir;
+    constructor(portfolioManager) {
+        this.portfolioManager = portfolioManager || PortfolioManager.getInstance();
+        this.personasDir = this.portfolioManager.getElementDir(ElementType.PERSONA);
+    }
+    /**
+     * Load a persona from file
+     * SECURITY FIX #1: Uses FileLockManager.atomicReadFile() instead of fs.readFile()
+     * to prevent race conditions and ensure atomic file operations
+     */
+    async load(filePath) {
+        try {
+            // Resolve full path if relative
+            const fullPath = path.isAbsolute(filePath) ? filePath : path.join(this.personasDir, filePath);
+            // Validate path security
+            if (!this.validatePath(fullPath)) {
+                // SECURITY FIX #206: Don't expose user paths in error messages
+                logger.error('Invalid or unsafe path', { path: filePath });
+                throw new Error('Invalid or unsafe path');
+            }
+            // 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' });
+            // Create a new PersonaElement and deserialize
+            const persona = new PersonaElement({}, '', path.basename(fullPath));
+            persona.deserialize(content);
+            logger.debug(`Loaded persona: ${persona.metadata.name} from ${filePath}`);
+            return persona;
+        }
+        catch (error) {
+            logger.error(`Failed to load persona from ${filePath}: ${error}`);
+            throw new Error(`Failed to load persona: ${error}`);
+        }
+    }
+    /**
+     * Save a persona to file
+     * SECURITY FIX #1: Uses FileLockManager.atomicWriteFile() instead of fs.writeFile()
+     * to prevent race conditions and ensure atomic file operations
+     */
+    async save(element, filePath) {
+        try {
+            // Ensure personas directory exists
+            await ensureDirectory(this.personasDir);
+            // Resolve full path if relative
+            const fullPath = path.isAbsolute(filePath) ? filePath : path.join(this.personasDir, filePath);
+            // Validate path security
+            if (!this.validatePath(fullPath)) {
+                // SECURITY FIX #206: Don't expose user paths in error messages
+                logger.error('Invalid or unsafe path', { path: filePath });
+                throw new Error('Invalid or unsafe path');
+            }
+            // Serialize the persona
+            const content = element.serialize();
+            // CRITICAL FIX: Use atomic file write to prevent corruption during interruptions
+            // Previously: await fs.writeFile(fullPath, content, 'utf-8');
+            // Now: Uses FileLockManager with proper encoding object format
+            // This prevents partial writes and data corruption if the process is interrupted
+            await FileLockManager.atomicWriteFile(fullPath, content, { encoding: 'utf-8' });
+            // Update filename in element
+            element.filename = path.basename(fullPath);
+            logger.debug(`Saved persona: ${element.metadata.name} to ${filePath}`);
+        }
+        catch (error) {
+            logger.error(`Failed to save persona to ${filePath}: ${error}`);
+            throw new Error(`Failed to save persona: ${error}`);
+        }
+    }
+    /**
+     * Delete a persona file
+     */
+    async delete(filePath) {
+        try {
+            // Resolve full path if relative
+            const fullPath = path.isAbsolute(filePath) ? filePath : path.join(this.personasDir, filePath);
+            // Validate path security
+            if (!this.validatePath(fullPath)) {
+                // SECURITY FIX #206: Don't expose user paths in error messages
+                logger.error('Invalid or unsafe path', { path: filePath });
+                throw new Error('Invalid or unsafe path');
+            }
+            await fs.unlink(fullPath);
+            logger.debug(`Deleted persona file: ${filePath}`);
+        }
+        catch (error) {
+            logger.error(`Failed to delete persona ${filePath}: ${error}`);
+            throw new Error(`Failed to delete persona: ${error}`);
+        }
+    }
+    /**
+     * Check if a persona file exists
+     */
+    async exists(filePath) {
+        try {
+            // Resolve full path if relative
+            const fullPath = path.isAbsolute(filePath) ? filePath : path.join(this.personasDir, filePath);
+            await fs.access(fullPath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * List all personas
+     */
+    async list() {
+        try {
+            // Ensure directory exists
+            await ensureDirectory(this.personasDir);
+            const files = await fs.readdir(this.personasDir);
+            const markdownFiles = files.filter(file => file.endsWith('.md'));
+            const personas = [];
+            for (const file of markdownFiles) {
+                try {
+                    const persona = await this.load(file);
+                    personas.push(persona);
+                }
+                catch (error) {
+                    logger.error(`Error loading persona ${file}: ${error}`);
+                    // Continue with other personas
+                }
+            }
+            logger.debug(`Loaded ${personas.length} personas from ${this.personasDir}`);
+            return personas;
+        }
+        catch (error) {
+            logger.error(`Failed to list personas: ${error}`);
+            return [];
+        }
+    }
+    /**
+     * Find a persona by predicate
+     */
+    async find(predicate) {
+        const personas = await this.list();
+        return personas.find(predicate);
+    }
+    /**
+     * Find multiple personas by predicate
+     */
+    async findMany(predicate) {
+        const personas = await this.list();
+        return personas.filter(predicate);
+    }
+    /**
+     * Validate a persona element
+     */
+    validate(element) {
+        return element.validate();
+    }
+    /**
+     * Validate a file path
+     */
+    validatePath(filePath) {
+        try {
+            validatePath(filePath);
+            // Additional check: must be .md file
+            if (!filePath.endsWith('.md')) {
+                return false;
+            }
+            // Must be within personas directory
+            const fullPath = path.resolve(filePath);
+            const personasDirPath = path.resolve(this.personasDir);
+            return fullPath.startsWith(personasDirPath);
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get element type
+     */
+    getElementType() {
+        return ElementType.PERSONA;
+    }
+    /**
+     * Get file extension
+     */
+    getFileExtension() {
+        return '.md';
+    }
+    /**
+     * Import persona from data
+     * SECURITY FIX #3: Uses SecureYamlParser instead of unsafe YAML parsing to prevent
+     * YAML deserialization attacks and injection vulnerabilities
+     */
+    async importElement(data, format = 'markdown') {
+        try {
+            const persona = new PersonaElement({});
+            if (format === 'markdown') {
+                persona.deserialize(data);
+            }
+            else if (format === 'json') {
+                const jsonData = JSON.parse(data);
+                persona.deserialize(this.jsonToMarkdown(jsonData));
+            }
+            else if (format === 'yaml') {
+                // HIGH SEVERITY FIX: Use SecureYamlParser to prevent YAML injection attacks
+                // Previously: Used unsafe YAML parsing without validation
+                // Now: Uses SecureYamlParser which validates content and prevents malicious patterns
+                try {
+                    const parsed = SecureYamlParser.parse(data, {
+                        maxYamlSize: 64 * 1024, // 64KB limit
+                        validateContent: true
+                    });
+                    // Log security event for audit trail
+                    SecurityMonitor.logSecurityEvent({
+                        type: 'YAML_PARSE_SUCCESS',
+                        severity: 'LOW',
+                        source: 'PersonaElementManager.importElement',
+                        details: 'YAML content safely parsed during import'
+                    });
+                    // Convert parsed YAML to markdown format
+                    persona.deserialize(this.jsonToMarkdown(parsed.data));
+                }
+                catch (securityError) {
+                    // Log the security violation
+                    SecurityMonitor.logSecurityEvent({
+                        type: 'YAML_INJECTION_ATTEMPT',
+                        severity: 'HIGH',
+                        source: 'PersonaElementManager.importElement',
+                        details: `YAML parsing failed security validation: ${securityError}`
+                    });
+                    throw securityError;
+                }
+            }
+            else {
+                throw new Error(`Unsupported format: ${format}`);
+            }
+            return persona;
+        }
+        catch (error) {
+            logger.error(`Failed to import persona: ${error}`);
+            throw new Error(`Import failed: ${error}`);
+        }
+    }
+    /**
+     * Export persona to data
+     * SECURITY FIX #2: Uses static import of js-yaml at top of file instead of
+     * dynamic require() for better security and bundling
+     * SECURITY FIX #3: Uses secure YAML dumping with safety options
+     */
+    async exportElement(element, format = 'markdown') {
+        try {
+            if (format === 'markdown') {
+                return element.serialize();
+            }
+            else if (format === 'json') {
+                const legacy = element.toLegacy();
+                return JSON.stringify({ ...legacy, content: element.content }, null, 2);
+            }
+            else if (format === 'yaml') {
+                const legacy = element.toLegacy();
+                // CRITICAL FIX: Using safe YAML dump with security options
+                // Previously: Used dynamic require without safety options
+                // Now: Uses static import with safe schema and security flags
+                return yaml.dump({ ...legacy, content: element.content }, {
+                    schema: yaml.FAILSAFE_SCHEMA, // Use restricted schema
+                    skipInvalid: true, // Skip invalid data instead of throwing
+                    noRefs: true, // Prevent reference attacks
+                    noCompatMode: true // Use strict YAML mode
+                });
+            }
+            else {
+                throw new Error(`Unsupported format: ${format}`);
+            }
+        }
+        catch (error) {
+            logger.error(`Failed to export persona: ${error}`);
+            throw new Error(`Export failed: ${error}`);
+        }
+    }
+    /**
+     * Helper: Convert JSON data to markdown format
+     * SECURITY FIX #2: Uses statically imported yaml module
+     * SECURITY FIX #3: Uses secure YAML dumping with safety options
+     * Note: This is for internal conversion only, user-provided YAML must use SecureYamlParser
+     */
+    jsonToMarkdown(data) {
+        const { content, ...metadata } = data;
+        // Using safe YAML dump with security options
+        const yamlFrontmatter = yaml.dump(metadata, {
+            schema: yaml.FAILSAFE_SCHEMA, // Use restricted schema
+            skipInvalid: true, // Skip invalid data
+            noRefs: true, // Prevent reference attacks
+            noCompatMode: true // Use strict YAML mode
+        });
+        return `---\n${yamlFrontmatter}---\n\n${content || ''}`;
+    }
+    /**
+     * Create a new persona with default metadata
+     */
+    create(metadata) {
+        const defaultMetadata = {
+            name: 'New Persona',
+            description: 'A new persona',
+            version: '1.0.0',
+            category: 'personal',
+            age_rating: 'all',
+            ai_generated: false,
+            generation_method: 'human',
+            price: 'free',
+            license: 'CC-BY-SA-4.0',
+            created_date: new Date().toISOString().split('T')[0],
+            triggers: [],
+            content_flags: []
+        };
+        return new PersonaElement({ ...defaultMetadata, ...metadata });
+    }
+    /**
+     * Get default filename for a persona
+     */
+    getDefaultFilename(persona) {
+        // Convert name to safe filename
+        const safeName = persona.metadata.name
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, '-')
+            .replace(/^-+|-+$/g, '');
+        return `${safeName}.md`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PersonaElementManager.js","sourceRoot":"","sources":["../../src/persona/PersonaElementManager.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * PersonaElementManager - Implementation of IElementManager for PersonaElement\n * Handles CRUD operations and lifecycle management for personas implementing IElement\n * \n * SECURITY FIXES IMPLEMENTED (PR #319):\n * 1. CRITICAL: Fixed race conditions in file operations by using FileLockManager for atomic reads/writes\n * 2. CRITICAL: Fixed dynamic require() statements by using static imports\n * 3. HIGH: Fixed unvalidated YAML parsing vulnerability by using SecureYamlParser\n * 4. MEDIUM: All user inputs are now validated and sanitized\n * 5. MEDIUM: Audit logging added for security operations\n */\n\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\nimport * as yaml from 'js-yaml';\nimport { IElementManager, ElementValidationResult } from '../types/elements/index.js';\nimport { ElementType } from '../portfolio/types.js';\nimport { PersonaElement, PersonaElementMetadata } from './PersonaElement.js';\nimport { PortfolioManager } from '../portfolio/PortfolioManager.js';\nimport { logger } from '../utils/logger.js';\nimport { validatePath, validateFilename } from '../security/InputValidator.js';\nimport { ensureDirectory } from '../utils/filesystem.js';\nimport { FileLockManager } from '../security/fileLockManager.js';\nimport { SecureYamlParser } from '../security/secureYamlParser.js';\nimport { SecurityMonitor } from '../security/securityMonitor.js';\n\nexport class PersonaElementManager implements IElementManager<PersonaElement> {\n  private portfolioManager: PortfolioManager;\n  private personasDir: string;\n\n  constructor(portfolioManager?: PortfolioManager) {\n    this.portfolioManager = portfolioManager || PortfolioManager.getInstance();\n    this.personasDir = this.portfolioManager.getElementDir(ElementType.PERSONA);\n  }\n\n  /**\n   * Load a persona from file\n   * SECURITY FIX #1: Uses FileLockManager.atomicReadFile() instead of fs.readFile()\n   * to prevent race conditions and ensure atomic file operations\n   */\n  async load(filePath: string): Promise<PersonaElement> {\n    try {\n      // Resolve full path if relative\n      const fullPath = path.isAbsolute(filePath) ? filePath : path.join(this.personasDir, filePath);\n      \n      // Validate path security\n      if (!this.validatePath(fullPath)) {\n        // SECURITY FIX #206: Don't expose user paths in error messages\n        logger.error('Invalid or unsafe path', { path: filePath });\n        throw new Error('Invalid or unsafe path');\n      }\n\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      // Create a new PersonaElement and deserialize\n      const persona = new PersonaElement({}, '', path.basename(fullPath));\n      persona.deserialize(content);\n      \n      logger.debug(`Loaded persona: ${persona.metadata.name} from ${filePath}`);\n      return persona;\n\n    } catch (error) {\n      logger.error(`Failed to load persona from ${filePath}: ${error}`);\n      throw new Error(`Failed to load persona: ${error}`);\n    }\n  }\n\n  /**\n   * Save a persona to file\n   * SECURITY FIX #1: Uses FileLockManager.atomicWriteFile() instead of fs.writeFile()\n   * to prevent race conditions and ensure atomic file operations\n   */\n  async save(element: PersonaElement, filePath: string): Promise<void> {\n    try {\n      // Ensure personas directory exists\n      await ensureDirectory(this.personasDir);\n\n      // Resolve full path if relative\n      const fullPath = path.isAbsolute(filePath) ? filePath : path.join(this.personasDir, filePath);\n      \n      // Validate path security\n      if (!this.validatePath(fullPath)) {\n        // SECURITY FIX #206: Don't expose user paths in error messages\n        logger.error('Invalid or unsafe path', { path: filePath });\n        throw new Error('Invalid or unsafe path');\n      }\n\n      // Serialize the persona\n      const content = element.serialize();\n      \n      // CRITICAL FIX: Use atomic file write to prevent corruption during interruptions\n      // Previously: await fs.writeFile(fullPath, content, 'utf-8');\n      // Now: Uses FileLockManager with proper encoding object format\n      // This prevents partial writes and data corruption if the process is interrupted\n      await FileLockManager.atomicWriteFile(fullPath, content, { encoding: 'utf-8' });\n      \n      // Update filename in element\n      element.filename = path.basename(fullPath);\n      \n      logger.debug(`Saved persona: ${element.metadata.name} to ${filePath}`);\n\n    } catch (error) {\n      logger.error(`Failed to save persona to ${filePath}: ${error}`);\n      throw new Error(`Failed to save persona: ${error}`);\n    }\n  }\n\n  /**\n   * Delete a persona file\n   */\n  async delete(filePath: string): Promise<void> {\n    try {\n      // Resolve full path if relative\n      const fullPath = path.isAbsolute(filePath) ? filePath : path.join(this.personasDir, filePath);\n      \n      // Validate path security\n      if (!this.validatePath(fullPath)) {\n        // SECURITY FIX #206: Don't expose user paths in error messages\n        logger.error('Invalid or unsafe path', { path: filePath });\n        throw new Error('Invalid or unsafe path');\n      }\n\n      await fs.unlink(fullPath);\n      logger.debug(`Deleted persona file: ${filePath}`);\n\n    } catch (error) {\n      logger.error(`Failed to delete persona ${filePath}: ${error}`);\n      throw new Error(`Failed to delete persona: ${error}`);\n    }\n  }\n\n  /**\n   * Check if a persona file exists\n   */\n  async exists(filePath: string): Promise<boolean> {\n    try {\n      // Resolve full path if relative\n      const fullPath = path.isAbsolute(filePath) ? filePath : path.join(this.personasDir, filePath);\n      \n      await fs.access(fullPath);\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  /**\n   * List all personas\n   */\n  async list(): Promise<PersonaElement[]> {\n    try {\n      // Ensure directory exists\n      await ensureDirectory(this.personasDir);\n\n      const files = await fs.readdir(this.personasDir);\n      const markdownFiles = files.filter(file => file.endsWith('.md'));\n      \n      const personas: PersonaElement[] = [];\n      \n      for (const file of markdownFiles) {\n        try {\n          const persona = await this.load(file);\n          personas.push(persona);\n        } catch (error) {\n          logger.error(`Error loading persona ${file}: ${error}`);\n          // Continue with other personas\n        }\n      }\n\n      logger.debug(`Loaded ${personas.length} personas from ${this.personasDir}`);\n      return personas;\n\n    } catch (error) {\n      logger.error(`Failed to list personas: ${error}`);\n      return [];\n    }\n  }\n\n  /**\n   * Find a persona by predicate\n   */\n  async find(predicate: (element: PersonaElement) => boolean): Promise<PersonaElement | undefined> {\n    const personas = await this.list();\n    return personas.find(predicate);\n  }\n\n  /**\n   * Find multiple personas by predicate\n   */\n  async findMany(predicate: (element: PersonaElement) => boolean): Promise<PersonaElement[]> {\n    const personas = await this.list();\n    return personas.filter(predicate);\n  }\n\n  /**\n   * Validate a persona element\n   */\n  validate(element: PersonaElement): ElementValidationResult {\n    return element.validate();\n  }\n\n  /**\n   * Validate a file path\n   */\n  validatePath(filePath: string): boolean {\n    try {\n      validatePath(filePath);\n      \n      // Additional check: must be .md file\n      if (!filePath.endsWith('.md')) {\n        return false;\n      }\n      \n      // Must be within personas directory\n      const fullPath = path.resolve(filePath);\n      const personasDirPath = path.resolve(this.personasDir);\n      \n      return fullPath.startsWith(personasDirPath);\n      \n    } catch {\n      return false;\n    }\n  }\n\n  /**\n   * Get element type\n   */\n  getElementType(): ElementType {\n    return ElementType.PERSONA;\n  }\n\n  /**\n   * Get file extension\n   */\n  getFileExtension(): string {\n    return '.md';\n  }\n\n  /**\n   * Import persona from data\n   * SECURITY FIX #3: Uses SecureYamlParser instead of unsafe YAML parsing to prevent\n   * YAML deserialization attacks and injection vulnerabilities\n   */\n  async importElement(data: string, format: 'json' | 'yaml' | 'markdown' = 'markdown'): Promise<PersonaElement> {\n    try {\n      const persona = new PersonaElement({});\n      \n      if (format === 'markdown') {\n        persona.deserialize(data);\n      } else if (format === 'json') {\n        const jsonData = JSON.parse(data);\n        persona.deserialize(this.jsonToMarkdown(jsonData));\n      } else if (format === 'yaml') {\n        // HIGH SEVERITY FIX: Use SecureYamlParser to prevent YAML injection attacks\n        // Previously: Used unsafe YAML parsing without validation\n        // Now: Uses SecureYamlParser which validates content and prevents malicious patterns\n        try {\n          const parsed = SecureYamlParser.parse(data, {\n            maxYamlSize: 64 * 1024, // 64KB limit\n            validateContent: true\n          });\n          \n          // Log security event for audit trail\n          SecurityMonitor.logSecurityEvent({\n            type: 'YAML_PARSE_SUCCESS',\n            severity: 'LOW',\n            source: 'PersonaElementManager.importElement',\n            details: 'YAML content safely parsed during import'\n          });\n          \n          // Convert parsed YAML to markdown format\n          persona.deserialize(this.jsonToMarkdown(parsed.data));\n        } catch (securityError) {\n          // Log the security violation\n          SecurityMonitor.logSecurityEvent({\n            type: 'YAML_INJECTION_ATTEMPT',\n            severity: 'HIGH',\n            source: 'PersonaElementManager.importElement',\n            details: `YAML parsing failed security validation: ${securityError}`\n          });\n          throw securityError;\n        }\n      } else {\n        throw new Error(`Unsupported format: ${format}`);\n      }\n\n      return persona;\n\n    } catch (error) {\n      logger.error(`Failed to import persona: ${error}`);\n      throw new Error(`Import failed: ${error}`);\n    }\n  }\n\n  /**\n   * Export persona to data\n   * SECURITY FIX #2: Uses static import of js-yaml at top of file instead of\n   * dynamic require() for better security and bundling\n   * SECURITY FIX #3: Uses secure YAML dumping with safety options\n   */\n  async exportElement(element: PersonaElement, format: 'json' | 'yaml' | 'markdown' = 'markdown'): Promise<string> {\n    try {\n      if (format === 'markdown') {\n        return element.serialize();\n      } else if (format === 'json') {\n        const legacy = element.toLegacy();\n        return JSON.stringify({ ...legacy, content: element.content }, null, 2);\n      } else if (format === 'yaml') {\n        const legacy = element.toLegacy();\n        // CRITICAL FIX: Using safe YAML dump with security options\n        // Previously: Used dynamic require without safety options\n        // Now: Uses static import with safe schema and security flags\n        return yaml.dump({ ...legacy, content: element.content }, {\n          schema: yaml.FAILSAFE_SCHEMA,  // Use restricted schema\n          skipInvalid: true,              // Skip invalid data instead of throwing\n          noRefs: true,                   // Prevent reference attacks\n          noCompatMode: true              // Use strict YAML mode\n        });\n      } else {\n        throw new Error(`Unsupported format: ${format}`);\n      }\n\n    } catch (error) {\n      logger.error(`Failed to export persona: ${error}`);\n      throw new Error(`Export failed: ${error}`);\n    }\n  }\n\n  /**\n   * Helper: Convert JSON data to markdown format\n   * SECURITY FIX #2: Uses statically imported yaml module\n   * SECURITY FIX #3: Uses secure YAML dumping with safety options\n   * Note: This is for internal conversion only, user-provided YAML must use SecureYamlParser\n   */\n  private jsonToMarkdown(data: any): string {\n    const { content, ...metadata } = data;\n    // Using safe YAML dump with security options\n    const yamlFrontmatter = yaml.dump(metadata, {\n      schema: yaml.FAILSAFE_SCHEMA,  // Use restricted schema\n      skipInvalid: true,              // Skip invalid data\n      noRefs: true,                   // Prevent reference attacks\n      noCompatMode: true              // Use strict YAML mode\n    });\n    return `---\\n${yamlFrontmatter}---\\n\\n${content || ''}`;\n  }\n\n  /**\n   * Create a new persona with default metadata\n   */\n  create(metadata: Partial<PersonaElementMetadata>): PersonaElement {\n    const defaultMetadata: Partial<PersonaElementMetadata> = {\n      name: 'New Persona',\n      description: 'A new persona',\n      version: '1.0.0',\n      category: 'personal',\n      age_rating: 'all',\n      ai_generated: false,\n      generation_method: 'human',\n      price: 'free',\n      license: 'CC-BY-SA-4.0',\n      created_date: new Date().toISOString().split('T')[0],\n      triggers: [],\n      content_flags: []\n    };\n\n    return new PersonaElement({ ...defaultMetadata, ...metadata });\n  }\n\n  /**\n   * Get default filename for a persona\n   */\n  getDefaultFilename(persona: PersonaElement): string {\n    // Convert name to safe filename\n    const safeName = persona.metadata.name\n      .toLowerCase()\n      .replace(/[^a-z0-9]+/g, '-')\n      .replace(/^-+|-+$/g, '');\n    \n    return `${safeName}.md`;\n  }\n}"]}

package/dist/persona/PersonaLoader.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Persona loading and file management
+ */
+import { Persona } from '../types/persona.js';
+export declare class PersonaLoader {
+    private personasDir;
+    private portfolioManager;
+    constructor(personasDir?: string);
+    /**
+     * Load all personas from the personas directory
+     */
+    loadAll(getCurrentUser: () => string | null): Promise<Map<string, Persona>>;
+    /**
+     * Load a single persona from file
+     */
+    loadPersona(filename: string, getCurrentUser: () => string | null): Promise<Persona | null>;
+    /**
+     * Save a persona to file
+     */
+    savePersona(persona: Persona): Promise<void>;
+    /**
+     * Delete a persona file
+     */
+    deletePersona(filename: string): Promise<void>;
+    /**
+     * Check if a persona file exists
+     */
+    personaExists(filename: string): Promise<boolean>;
+    /**
+     * Set default metadata values
+     */
+    private setDefaultMetadata;
+}
+//# sourceMappingURL=PersonaLoader.d.ts.map

package/dist/persona/PersonaLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PersonaLoader.d.ts","sourceRoot":"","sources":["../../src/persona/PersonaLoader.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,OAAO,EAAE,OAAO,EAAmB,MAAM,qBAAqB,CAAC;AAO/D,qBAAa,aAAa;IACxB,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,gBAAgB,CAAmB;gBAE/B,WAAW,CAAC,EAAE,MAAM;IAQhC;;OAEG;IACG,OAAO,CAAC,cAAc,EAAE,MAAM,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IA4BjF;;OAEG;IACG,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;IAiDjG;;OAEG;IACG,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAUlD;;OAEG;IACG,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAKpD;;OAEG;IACG,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAUvD;;OAEG;IACH,OAAO,CAAC,kBAAkB;CAS3B"}