@dollhousemcp/mcp-server 1.8.0 → 1.9.0

package/dist/elements/memories/MemoryManager.js

@@ -0,0 +1,607 @@
+/**
+ * MemoryManager - Implementation of IElementManager for Memory elements
+ * Handles CRUD operations and lifecycle management for memories implementing IElement
+ *
+ * FIXES IMPLEMENTED:
+ * 1. CRITICAL: Fixed race conditions in file operations by using FileLockManager for atomic reads/writes
+ * 2. HIGH: Fixed unvalidated YAML parsing vulnerability by using SecureYamlParser
+ * 3. MEDIUM: All user inputs are now validated and sanitized
+ * 4. MEDIUM: Audit logging added for security operations
+ * 5. MEDIUM: Path validation prevents directory traversal attacks
+ */
+import { Memory } from './Memory.js';
+import { ElementType } from '../../portfolio/types.js';
+import { PortfolioManager } from '../../portfolio/PortfolioManager.js';
+import { FileLockManager } from '../../security/fileLockManager.js';
+import { SecureYamlParser } from '../../security/secureYamlParser.js';
+import { SecurityMonitor } from '../../security/securityMonitor.js';
+import { sanitizeInput } from '../../security/InputValidator.js';
+import { MEMORY_CONSTANTS, MEMORY_SECURITY_EVENTS } from './constants.js';
+import * as path from 'path';
+import * as fs from 'fs/promises';
+import * as yaml from 'js-yaml';
+import * as crypto from 'crypto';
+export class MemoryManager {
+    portfolioManager;
+    memoriesDir;
+    memoryCache = new Map();
+    contentHashIndex = new Map();
+    // PERFORMANCE IMPROVEMENT: Cache for date folders to avoid directory scanning
+    // Invalidated when new folders are created
+    dateFoldersCache = null;
+    dateFoldersCacheTimestamp = 0;
+    constructor() {
+        this.portfolioManager = PortfolioManager.getInstance();
+        this.memoriesDir = this.portfolioManager.getElementDir(ElementType.MEMORY);
+    }
+    /**
+     * Load a memory from file
+     * SECURITY FIX #1: Uses FileLockManager.atomicReadFile() instead of fs.readFile()
+     * to prevent race conditions and ensure atomic file operations
+     * @param filePath Path to the memory file to load
+     * @returns Promise resolving to the loaded Memory instance
+     * @throws {Error} When file cannot be found or path validation fails
+     * @throws {Error} When YAML parsing fails or content is malformed
+     * @throws {Error} When memory validation fails after loading
+     */
+    async load(filePath) {
+        try {
+            let fullPath;
+            // Check if it's a relative path (no date folder)
+            if (!filePath.includes(path.sep) || !filePath.match(/^\d{4}-\d{2}-\d{2}/)) {
+                // Search in date folders
+                const dateFolders = await this.getDateFolders();
+                let found = false;
+                for (const dateFolder of dateFolders) {
+                    const testPath = path.join(this.memoriesDir, dateFolder, filePath);
+                    if (await fs.access(testPath).then(() => true).catch(() => false)) {
+                        fullPath = testPath;
+                        found = true;
+                        break;
+                    }
+                }
+                if (!found) {
+                    // Fall back to root directory for backward compatibility during transition
+                    fullPath = await this.validateAndResolvePath(filePath);
+                }
+            }
+            else {
+                fullPath = await this.validateAndResolvePath(filePath);
+            }
+            // Ensure fullPath is defined
+            if (!fullPath) {
+                throw new Error(`Could not resolve path: ${filePath}`);
+            }
+            // Check cache first
+            const cached = this.memoryCache.get(fullPath);
+            if (cached) {
+                return cached;
+            }
+            // 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' });
+            // HIGH SEVERITY FIX: Use SecureYamlParser to prevent YAML injection attacks
+            // Previously: Could use unsafe YAML parsing
+            // Now: Uses SecureYamlParser which validates content and prevents malicious patterns
+            const parsed = SecureYamlParser.parse(content, {
+                maxYamlSize: MEMORY_CONSTANTS.MAX_YAML_SIZE,
+                validateContent: true
+            });
+            // Extract metadata and content
+            const { metadata, content: memoryContent } = this.parseMemoryFile(parsed);
+            // Create memory instance
+            const memory = new Memory(metadata);
+            // Load saved entries if present
+            if (parsed.data && parsed.data.entries) {
+                memory.deserialize(JSON.stringify({
+                    id: memory.id,
+                    type: memory.type,
+                    version: memory.version,
+                    metadata: memory.metadata,
+                    extensions: memory.extensions,
+                    entries: parsed.data.entries
+                }));
+            }
+            // Cache the loaded memory
+            this.memoryCache.set(fullPath, memory);
+            // Log successful load
+            SecurityMonitor.logSecurityEvent({
+                type: MEMORY_SECURITY_EVENTS.MEMORY_LOADED,
+                severity: 'LOW',
+                source: 'MemoryManager.load',
+                details: `Loaded memory from ${path.basename(fullPath)}`
+            });
+            return memory;
+        }
+        catch (error) {
+            SecurityMonitor.logSecurityEvent({
+                type: MEMORY_SECURITY_EVENTS.MEMORY_LOAD_FAILED,
+                severity: 'MEDIUM',
+                source: 'MemoryManager.load',
+                details: `Failed to load memory from ${filePath}: ${error}`
+            });
+            throw new Error(`Failed to load memory: ${error}`);
+        }
+    }
+    /**
+     * Generate date-based path for memory storage
+     * Creates YYYY-MM-DD folder structure to prevent flat directory issues
+     * @param element Memory element to save
+     * @param fileName Optional custom filename
+     * @returns Full path to memory file
+     */
+    async generateMemoryPath(element, fileName) {
+        const date = new Date();
+        const dateFolder = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')}`;
+        const datePath = path.join(this.memoriesDir, dateFolder);
+        // Ensure date folder exists
+        await fs.mkdir(datePath, { recursive: true });
+        // PERFORMANCE IMPROVEMENT: Invalidate date folders cache since we created a new folder
+        this.dateFoldersCache = null;
+        // Generate filename
+        const baseName = fileName || `${element.metadata.name?.toLowerCase().replace(/\s+/g, '-') || 'memory'}.yaml`;
+        let finalName = baseName;
+        let version = 1;
+        // Handle collisions with version suffix
+        while (await fs.access(path.join(datePath, finalName)).then(() => true).catch(() => false)) {
+            version++;
+            finalName = baseName.replace('.yaml', `-v${version}.yaml`);
+        }
+        return path.join(datePath, finalName);
+    }
+    /**
+     * Calculate SHA-256 hash of memory content for deduplication
+     * Implements Issue #994 - Content-based deduplication
+     */
+    calculateContentHash(element) {
+        const content = JSON.stringify({
+            metadata: element.metadata,
+            entries: JSON.parse(element.serialize()).entries
+        });
+        return crypto.createHash('sha256').update(content).digest('hex');
+    }
+    /**
+     * Get all date folders in memories directory
+     * PERFORMANCE IMPROVEMENT: Uses cache to avoid repeated directory scanning
+     * Cache is invalidated when new folders are created or after 60 seconds
+     * @returns Array of date folder names
+     */
+    async getDateFolders() {
+        const now = Date.now();
+        const CACHE_TTL = 60000; // 60 seconds
+        // Return cached result if valid
+        if (this.dateFoldersCache !== null &&
+            (now - this.dateFoldersCacheTimestamp) < CACHE_TTL) {
+            return this.dateFoldersCache;
+        }
+        try {
+            const entries = await fs.readdir(this.memoriesDir, { withFileTypes: true });
+            const folders = entries
+                .filter(entry => entry.isDirectory() && /^\d{4}-\d{2}-\d{2}$/.test(entry.name))
+                .map(entry => entry.name)
+                .sort()
+                .reverse(); // Most recent first
+            // Cache the result
+            this.dateFoldersCache = folders;
+            this.dateFoldersCacheTimestamp = now;
+            return folders;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                // Cache empty result
+                this.dateFoldersCache = [];
+                this.dateFoldersCacheTimestamp = now;
+                return [];
+            }
+            throw error;
+        }
+    }
+    /**
+     * Save a memory to file
+     * SECURITY FIX #1: Uses FileLockManager.atomicWriteFile() for atomic operations
+     * @param element Memory element to save
+     * @param filePath Optional custom file path, defaults to date-based path
+     * @returns Promise that resolves when save is complete
+     * @throws {Error} When memory validation fails before saving
+     * @throws {Error} When path validation fails or file system errors occur
+     * @throws {Error} When atomic write operation fails
+     */
+    async save(element, filePath) {
+        try {
+            // Validate element
+            const validation = element.validate();
+            if (!validation.valid) {
+                throw new Error(`Invalid memory: ${validation.errors?.map(e => e.message).join(', ')}`);
+            }
+            // Calculate content hash for deduplication
+            const contentHash = this.calculateContentHash(element);
+            const existingPath = this.contentHashIndex.get(contentHash);
+            if (existingPath) {
+                // Log duplicate detection
+                SecurityMonitor.logSecurityEvent({
+                    type: 'MEMORY_DUPLICATE_DETECTED',
+                    severity: 'LOW',
+                    source: 'MemoryManager.save',
+                    details: `Duplicate content detected. Existing: ${existingPath}`
+                });
+            }
+            // Generate date-based path if not provided
+            const fullPath = filePath
+                ? await this.validateAndResolvePath(filePath)
+                : await this.generateMemoryPath(element);
+            // Ensure parent directory exists (for date folders)
+            await fs.mkdir(path.dirname(fullPath), { recursive: true });
+            // Get memory statistics
+            const stats = element.getStats();
+            // Prepare data for saving
+            const data = {
+                metadata: element.metadata,
+                extensions: element.extensions,
+                stats: {
+                    totalEntries: stats.totalEntries,
+                    totalSize: stats.totalSize,
+                    oldestEntry: stats.oldestEntry?.toISOString(),
+                    newestEntry: stats.newestEntry?.toISOString(),
+                    topTags: Array.from(stats.tagFrequency.entries())
+                        .sort((a, b) => b[1] - a[1])
+                        .slice(0, 10)
+                        .map(([tag, count]) => ({ tag, count }))
+                },
+                entries: JSON.parse(element.serialize()).entries
+            };
+            // SECURITY FIX: Use secure YAML dumping with safety options
+            // Previously: Could allow dangerous YAML features
+            // Now: Uses FAILSAFE_SCHEMA and security options to prevent code execution
+            const yamlContent = yaml.dump(data, {
+                schema: yaml.FAILSAFE_SCHEMA,
+                noRefs: true,
+                skipInvalid: true,
+                sortKeys: true
+            });
+            // CRITICAL FIX: Use atomic file write to prevent corruption
+            // Previously: await fs.writeFile(fullPath, yamlContent, 'utf-8');
+            // Now: Uses FileLockManager for atomic write with proper encoding
+            await FileLockManager.atomicWriteFile(fullPath, yamlContent, { encoding: 'utf-8' });
+            // Update cache
+            this.memoryCache.set(fullPath, element);
+            // Update content hash index
+            this.contentHashIndex.set(contentHash, fullPath);
+            // Log successful save
+            SecurityMonitor.logSecurityEvent({
+                type: MEMORY_SECURITY_EVENTS.MEMORY_SAVED,
+                severity: 'LOW',
+                source: 'MemoryManager.save',
+                details: `Saved memory to ${path.basename(fullPath)} with ${stats.totalEntries} entries`
+            });
+        }
+        catch (error) {
+            SecurityMonitor.logSecurityEvent({
+                type: MEMORY_SECURITY_EVENTS.MEMORY_SAVE_FAILED,
+                severity: 'HIGH',
+                source: 'MemoryManager.save',
+                details: `Failed to save memory to ${filePath}: ${error}`
+            });
+            throw new Error(`Failed to save memory: ${error}`);
+        }
+    }
+    /**
+     * List all available memories
+     */
+    async list() {
+        const memories = [];
+        try {
+            // Get all date folders
+            const dateFolders = await this.getDateFolders();
+            // Also check root directory for any legacy files
+            const rootFiles = await fs.readdir(this.memoriesDir)
+                .then(files => files.filter(f => f.endsWith('.yaml')))
+                .catch(() => []);
+            // Process root files first (legacy)
+            for (const file of rootFiles) {
+                try {
+                    const memory = await this.load(file);
+                    memories.push(memory);
+                }
+                catch (error) {
+                    SecurityMonitor.logSecurityEvent({
+                        type: MEMORY_SECURITY_EVENTS.MEMORY_LIST_ITEM_FAILED,
+                        severity: 'LOW',
+                        source: 'MemoryManager.list',
+                        details: `Failed to load ${file}: ${error}`
+                    });
+                }
+            }
+            // Process date folders
+            for (const dateFolder of dateFolders) {
+                const folderPath = path.join(this.memoriesDir, dateFolder);
+                const files = await fs.readdir(folderPath)
+                    .then(files => files.filter(f => f.endsWith('.yaml')))
+                    .catch(() => []);
+                for (const file of files) {
+                    try {
+                        const memory = await this.load(path.join(dateFolder, file));
+                        memories.push(memory);
+                    }
+                    catch (error) {
+                        SecurityMonitor.logSecurityEvent({
+                            type: MEMORY_SECURITY_EVENTS.MEMORY_LIST_ITEM_FAILED,
+                            severity: 'LOW',
+                            source: 'MemoryManager.list',
+                            details: `Failed to load ${dateFolder}/${file}: ${error}`
+                        });
+                    }
+                }
+            }
+            return memories;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                // Directory doesn't exist yet
+                return [];
+            }
+            throw error;
+        }
+    }
+    /**
+     * Find memories matching a predicate
+     */
+    async find(predicate) {
+        const memories = await this.list();
+        return memories.find(predicate);
+    }
+    /**
+     * Find multiple memories matching a predicate
+     */
+    async findMany(predicate) {
+        const memories = await this.list();
+        return memories.filter(predicate);
+    }
+    /**
+     * Delete a memory file
+     * SECURITY: Validates path and logs deletion
+     */
+    async delete(filePath) {
+        try {
+            const fullPath = await this.validateAndResolvePath(filePath);
+            // Check if file exists
+            await fs.access(fullPath);
+            // Delete the file
+            await fs.unlink(fullPath);
+            // Remove from cache
+            this.memoryCache.delete(fullPath);
+            SecurityMonitor.logSecurityEvent({
+                type: MEMORY_SECURITY_EVENTS.MEMORY_DELETED,
+                severity: 'MEDIUM',
+                source: 'MemoryManager.delete',
+                details: `Deleted memory file: ${path.basename(fullPath)}`
+            });
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                // File doesn't exist, not an error for delete operation
+                return;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Check if a memory file exists
+     */
+    async exists(filePath) {
+        try {
+            const fullPath = await this.validateAndResolvePath(filePath);
+            await fs.access(fullPath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Create a new memory with metadata
+     */
+    async create(metadata) {
+        return new Memory(metadata);
+    }
+    /**
+     * Import a memory from JSON/YAML string
+     * SECURITY: Full validation of imported content
+     * @param data JSON or YAML string containing memory data
+     * @param format Format of the input data ('json' or 'yaml')
+     * @returns Promise resolving to the imported Memory instance
+     * @throws {Error} When JSON/YAML parsing fails
+     * @throws {Error} When imported data is missing required fields
+     * @throws {Error} When YAML content exceeds maximum allowed size
+     * @throws {Error} When imported memory fails validation
+     */
+    async importElement(data, format = 'yaml') {
+        try {
+            let parsed;
+            if (format === 'json') {
+                parsed = JSON.parse(data);
+            }
+            else {
+                // HIGH SEVERITY FIX: Use secure YAML parsing
+                // Memory import expects pure YAML (not frontmatter), so we parse it securely
+                try {
+                    // First validate the YAML content size
+                    if (data.length > MEMORY_CONSTANTS.MAX_YAML_SIZE) {
+                        throw new Error('YAML content exceeds maximum allowed size');
+                    }
+                    // Create a wrapper to use SecureYamlParser with pure YAML
+                    // Add minimal frontmatter markers to satisfy parser
+                    const wrappedYaml = `---\n${data}\n---\n`;
+                    const parseResult = SecureYamlParser.parse(wrappedYaml, {
+                        maxYamlSize: MEMORY_CONSTANTS.MAX_YAML_SIZE,
+                        validateContent: true
+                    });
+                    // Extract the parsed data (will be in the 'data' property)
+                    parsed = parseResult.data;
+                }
+                catch (yamlError) {
+                    throw new Error(`Invalid YAML: ${yamlError}`);
+                }
+                // Validate it's an object
+                if (!parsed || typeof parsed !== 'object') {
+                    throw new Error('YAML must contain an object');
+                }
+            }
+            // Handle different structures from YAML parsing
+            let metadata = parsed.metadata;
+            let entries = parsed.entries || (parsed.data && parsed.data.entries);
+            // Validate required fields
+            if (!metadata || !metadata.name) {
+                throw new Error('Memory must have metadata with name');
+            }
+            // Create memory instance
+            const memory = new Memory(metadata);
+            // Load entries if present
+            if (entries) {
+                memory.deserialize(JSON.stringify({
+                    id: memory.id,
+                    type: memory.type,
+                    version: memory.version,
+                    metadata: memory.metadata,
+                    extensions: memory.extensions,
+                    entries: entries
+                }));
+            }
+            return memory;
+        }
+        catch (error) {
+            SecurityMonitor.logSecurityEvent({
+                type: MEMORY_SECURITY_EVENTS.MEMORY_IMPORT_FAILED,
+                severity: 'MEDIUM',
+                source: 'MemoryManager.importElement',
+                details: `Failed to import memory: ${error}`
+            });
+            throw new Error(`Failed to import memory: ${error}`);
+        }
+    }
+    /**
+     * Export a memory to YAML string
+     */
+    async exportElement(element) {
+        const stats = element.getStats();
+        const data = {
+            metadata: element.metadata,
+            extensions: element.extensions,
+            stats: {
+                totalEntries: stats.totalEntries,
+                totalSize: stats.totalSize,
+                oldestEntry: stats.oldestEntry?.toISOString(),
+                newestEntry: stats.newestEntry?.toISOString()
+            },
+            entries: JSON.parse(element.serialize()).entries
+        };
+        // SECURITY FIX: Use secure YAML dumping
+        return yaml.dump(data, {
+            schema: yaml.FAILSAFE_SCHEMA,
+            noRefs: true,
+            skipInvalid: true,
+            sortKeys: true
+        });
+    }
+    /**
+     * Validate a memory element
+     */
+    validate(element) {
+        return element.validate();
+    }
+    /**
+     * Validate and resolve a file path
+     * SECURITY: Prevents directory traversal attacks
+     */
+    validatePath(filePath) {
+        try {
+            // Perform synchronous validation checks
+            const normalized = path.normalize(filePath);
+            // Check for path traversal attempts
+            if (normalized.includes('..') || path.isAbsolute(normalized)) {
+                return false;
+            }
+            // Ensure proper extension
+            if (!normalized.endsWith('.md') && !normalized.endsWith('.yaml') && !normalized.endsWith('.yml')) {
+                return false;
+            }
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get the element type this manager handles
+     */
+    getElementType() {
+        return ElementType.MEMORY;
+    }
+    /**
+     * Get the file extension for memory files
+     */
+    getFileExtension() {
+        return '.yaml';
+    }
+    // Private helper methods
+    /**
+     * Validate and resolve a file path to prevent security issues
+     * @param filePath Path to validate and resolve
+     * @returns Promise resolving to the validated full path
+     * @throws {Error} When path contains traversal attempts (../)
+     * @throws {Error} When path is absolute or invalid
+     * @throws {Error} When file extension is not allowed (.md, .yaml, .yml)
+     * @throws {Error} When resolved path would be outside memories directory
+     */
+    async validateAndResolvePath(filePath) {
+        // SECURITY FIX: Comprehensive path validation
+        const normalized = path.normalize(filePath);
+        // Check for path traversal attempts
+        if (normalized.includes('..') || path.isAbsolute(normalized)) {
+            SecurityMonitor.logSecurityEvent({
+                type: 'PATH_TRAVERSAL_ATTEMPT',
+                severity: 'HIGH',
+                source: 'MemoryManager.validateAndResolvePath',
+                details: `Blocked path traversal attempt: ${filePath}`
+            });
+            throw new Error('Invalid file path: Path traversal detected');
+        }
+        // Ensure proper extension
+        if (!normalized.endsWith('.md') && !normalized.endsWith('.yaml') && !normalized.endsWith('.yml')) {
+            throw new Error('Memory files must have .md, .yaml, or .yml extension');
+        }
+        // Construct full path
+        const fullPath = path.join(this.memoriesDir, normalized);
+        // Verify it's within memories directory
+        const relative = path.relative(this.memoriesDir, fullPath);
+        if (relative.startsWith('..') || path.isAbsolute(relative)) {
+            throw new Error('File path must be within memories directory');
+        }
+        return fullPath;
+    }
+    parseMemoryFile(parsed) {
+        // Extract metadata with validation
+        const metadata = {
+            name: sanitizeInput(parsed.metadata?.name || 'Unnamed Memory', 100),
+            description: parsed.metadata?.description ?
+                sanitizeInput(parsed.metadata.description, 500) :
+                '',
+            version: parsed.metadata?.version || '1.0.0',
+            author: parsed.metadata?.author,
+            created: parsed.metadata?.created,
+            modified: new Date().toISOString(),
+            tags: Array.isArray(parsed.metadata?.tags) ?
+                parsed.metadata.tags.map((tag) => sanitizeInput(tag, MEMORY_CONSTANTS.MAX_TAG_LENGTH)) :
+                [],
+            storageBackend: parsed.metadata?.storageBackend || MEMORY_CONSTANTS.DEFAULT_STORAGE_BACKEND,
+            retentionDays: parsed.metadata?.retentionDays || MEMORY_CONSTANTS.DEFAULT_RETENTION_DAYS,
+            privacyLevel: parsed.metadata?.privacyLevel || MEMORY_CONSTANTS.DEFAULT_PRIVACY_LEVEL,
+            searchable: parsed.metadata?.searchable !== false,
+            maxEntries: parsed.metadata?.maxEntries || MEMORY_CONSTANTS.MAX_ENTRIES_DEFAULT
+        };
+        // Extract content (if any)
+        const content = parsed.content || '';
+        return { metadata, content };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"MemoryManager.js","sourceRoot":"","sources":["../../../src/elements/memories/MemoryManager.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * MemoryManager - Implementation of IElementManager for Memory elements\n * Handles CRUD operations and lifecycle management for memories implementing IElement\n * \n * FIXES IMPLEMENTED:\n * 1. CRITICAL: Fixed race conditions in file operations by using FileLockManager for atomic reads/writes\n * 2. HIGH: Fixed unvalidated YAML parsing vulnerability by using SecureYamlParser\n * 3. MEDIUM: All user inputs are now validated and sanitized\n * 4. MEDIUM: Audit logging added for security operations\n * 5. MEDIUM: Path validation prevents directory traversal attacks\n */\n\nimport { Memory, MemoryMetadata, MemoryEntry } from './Memory.js';\nimport { IElementManager } from '../../types/elements/IElementManager.js';\nimport { ElementValidationResult } from '../../types/elements/IElement.js';\nimport { ElementType } from '../../portfolio/types.js';\nimport { PortfolioManager } from '../../portfolio/PortfolioManager.js';\nimport { FileLockManager } from '../../security/fileLockManager.js';\nimport { SecureYamlParser } from '../../security/secureYamlParser.js';\nimport { SecurityMonitor } from '../../security/securityMonitor.js';\nimport { UnicodeValidator } from '../../security/validators/unicodeValidator.js';\nimport { sanitizeInput } from '../../security/InputValidator.js';\nimport { MEMORY_CONSTANTS, MEMORY_SECURITY_EVENTS } from './constants.js';\nimport * as path from 'path';\nimport * as fs from 'fs/promises';\nimport * as yaml from 'js-yaml';\nimport * as crypto from 'crypto';\n\nexport class MemoryManager implements IElementManager<Memory> {\n  private portfolioManager: PortfolioManager;\n  private memoriesDir: string;\n  private memoryCache: Map<string, Memory> = new Map();\n  private contentHashIndex: Map<string, string> = new Map();\n\n  // PERFORMANCE IMPROVEMENT: Cache for date folders to avoid directory scanning\n  // Invalidated when new folders are created\n  private dateFoldersCache: string[] | null = null;\n  private dateFoldersCacheTimestamp: number = 0;\n  \n  constructor() {\n    this.portfolioManager = PortfolioManager.getInstance();\n    this.memoriesDir = this.portfolioManager.getElementDir(ElementType.MEMORY);\n  }\n  \n  /**\n   * Load a memory from file\n   * SECURITY FIX #1: Uses FileLockManager.atomicReadFile() instead of fs.readFile()\n   * to prevent race conditions and ensure atomic file operations\n   * @param filePath Path to the memory file to load\n   * @returns Promise resolving to the loaded Memory instance\n   * @throws {Error} When file cannot be found or path validation fails\n   * @throws {Error} When YAML parsing fails or content is malformed\n   * @throws {Error} When memory validation fails after loading\n   */\n  async load(filePath: string): Promise<Memory> {\n    try {\n      let fullPath: string | undefined;\n\n      // Check if it's a relative path (no date folder)\n      if (!filePath.includes(path.sep) || !filePath.match(/^\\d{4}-\\d{2}-\\d{2}/)) {\n        // Search in date folders\n        const dateFolders = await this.getDateFolders();\n        let found = false;\n\n        for (const dateFolder of dateFolders) {\n          const testPath = path.join(this.memoriesDir, dateFolder, filePath);\n          if (await fs.access(testPath).then(() => true).catch(() => false)) {\n            fullPath = testPath;\n            found = true;\n            break;\n          }\n        }\n\n        if (!found) {\n          // Fall back to root directory for backward compatibility during transition\n          fullPath = await this.validateAndResolvePath(filePath);\n        }\n      } else {\n        fullPath = await this.validateAndResolvePath(filePath);\n      }\n\n      // Ensure fullPath is defined\n      if (!fullPath) {\n        throw new Error(`Could not resolve path: ${filePath}`);\n      }\n      \n      // Check cache first\n      const cached = this.memoryCache.get(fullPath);\n      if (cached) {\n        return cached;\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      // HIGH SEVERITY FIX: Use SecureYamlParser to prevent YAML injection attacks\n      // Previously: Could use unsafe YAML parsing\n      // Now: Uses SecureYamlParser which validates content and prevents malicious patterns\n      const parsed = SecureYamlParser.parse(content, {\n        maxYamlSize: MEMORY_CONSTANTS.MAX_YAML_SIZE,\n        validateContent: true\n      });\n      \n      // Extract metadata and content\n      const { metadata, content: memoryContent } = this.parseMemoryFile(parsed);\n      \n      // Create memory instance\n      const memory = new Memory(metadata);\n      \n      // Load saved entries if present\n      if (parsed.data && parsed.data.entries) {\n        memory.deserialize(JSON.stringify({\n          id: memory.id,\n          type: memory.type,\n          version: memory.version,\n          metadata: memory.metadata,\n          extensions: memory.extensions,\n          entries: parsed.data.entries\n        }));\n      }\n      \n      // Cache the loaded memory\n      this.memoryCache.set(fullPath, memory);\n      \n      // Log successful load\n      SecurityMonitor.logSecurityEvent({\n        type: MEMORY_SECURITY_EVENTS.MEMORY_LOADED,\n        severity: 'LOW',\n        source: 'MemoryManager.load',\n        details: `Loaded memory from ${path.basename(fullPath)}`\n      });\n      \n      return memory;\n      \n    } catch (error) {\n      SecurityMonitor.logSecurityEvent({\n        type: MEMORY_SECURITY_EVENTS.MEMORY_LOAD_FAILED,\n        severity: 'MEDIUM',\n        source: 'MemoryManager.load',\n        details: `Failed to load memory from ${filePath}: ${error}`\n      });\n      throw new Error(`Failed to load memory: ${error}`);\n    }\n  }\n\n  /**\n   * Generate date-based path for memory storage\n   * Creates YYYY-MM-DD folder structure to prevent flat directory issues\n   * @param element Memory element to save\n   * @param fileName Optional custom filename\n   * @returns Full path to memory file\n   */\n  private async generateMemoryPath(element: Memory, fileName?: string): Promise<string> {\n    const date = new Date();\n    const dateFolder = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')}`;\n    const datePath = path.join(this.memoriesDir, dateFolder);\n\n    // Ensure date folder exists\n    await fs.mkdir(datePath, { recursive: true });\n\n    // PERFORMANCE IMPROVEMENT: Invalidate date folders cache since we created a new folder\n    this.dateFoldersCache = null;\n\n    // Generate filename\n    const baseName = fileName || `${element.metadata.name?.toLowerCase().replace(/\\s+/g, '-') || 'memory'}.yaml`;\n    let finalName = baseName;\n    let version = 1;\n\n    // Handle collisions with version suffix\n    while (await fs.access(path.join(datePath, finalName)).then(() => true).catch(() => false)) {\n      version++;\n      finalName = baseName.replace('.yaml', `-v${version}.yaml`);\n    }\n\n    return path.join(datePath, finalName);\n  }\n\n  /**\n   * Calculate SHA-256 hash of memory content for deduplication\n   * Implements Issue #994 - Content-based deduplication\n   */\n  private calculateContentHash(element: Memory): string {\n    const content = JSON.stringify({\n      metadata: element.metadata,\n      entries: JSON.parse(element.serialize()).entries\n    });\n    return crypto.createHash('sha256').update(content).digest('hex');\n  }\n\n  /**\n   * Get all date folders in memories directory\n   * PERFORMANCE IMPROVEMENT: Uses cache to avoid repeated directory scanning\n   * Cache is invalidated when new folders are created or after 60 seconds\n   * @returns Array of date folder names\n   */\n  private async getDateFolders(): Promise<string[]> {\n    const now = Date.now();\n    const CACHE_TTL = 60000; // 60 seconds\n\n    // Return cached result if valid\n    if (this.dateFoldersCache !== null &&\n        (now - this.dateFoldersCacheTimestamp) < CACHE_TTL) {\n      return this.dateFoldersCache;\n    }\n\n    try {\n      const entries = await fs.readdir(this.memoriesDir, { withFileTypes: true });\n      const folders = entries\n        .filter(entry => entry.isDirectory() && /^\\d{4}-\\d{2}-\\d{2}$/.test(entry.name))\n        .map(entry => entry.name)\n        .sort()\n        .reverse(); // Most recent first\n\n      // Cache the result\n      this.dateFoldersCache = folders;\n      this.dateFoldersCacheTimestamp = now;\n\n      return folders;\n    } catch (error) {\n      if ((error as any).code === 'ENOENT') {\n        // Cache empty result\n        this.dateFoldersCache = [];\n        this.dateFoldersCacheTimestamp = now;\n        return [];\n      }\n      throw error;\n    }\n  }\n\n  /**\n   * Save a memory to file\n   * SECURITY FIX #1: Uses FileLockManager.atomicWriteFile() for atomic operations\n   * @param element Memory element to save\n   * @param filePath Optional custom file path, defaults to date-based path\n   * @returns Promise that resolves when save is complete\n   * @throws {Error} When memory validation fails before saving\n   * @throws {Error} When path validation fails or file system errors occur\n   * @throws {Error} When atomic write operation fails\n   */\n  async save(element: Memory, filePath?: string): Promise<void> {\n    try {\n      // Validate element\n      const validation = element.validate();\n      if (!validation.valid) {\n        throw new Error(`Invalid memory: ${validation.errors?.map(e => e.message).join(', ')}`);\n      }\n\n      // Calculate content hash for deduplication\n      const contentHash = this.calculateContentHash(element);\n      const existingPath = this.contentHashIndex.get(contentHash);\n\n      if (existingPath) {\n        // Log duplicate detection\n        SecurityMonitor.logSecurityEvent({\n          type: 'MEMORY_DUPLICATE_DETECTED',\n          severity: 'LOW',\n          source: 'MemoryManager.save',\n          details: `Duplicate content detected. Existing: ${existingPath}`\n        });\n      }\n\n      // Generate date-based path if not provided\n      const fullPath = filePath\n        ? await this.validateAndResolvePath(filePath)\n        : await this.generateMemoryPath(element);\n\n      // Ensure parent directory exists (for date folders)\n      await fs.mkdir(path.dirname(fullPath), { recursive: true });\n      \n      // Get memory statistics\n      const stats = element.getStats();\n      \n      // Prepare data for saving\n      const data = {\n        metadata: element.metadata,\n        extensions: element.extensions,\n        stats: {\n          totalEntries: stats.totalEntries,\n          totalSize: stats.totalSize,\n          oldestEntry: stats.oldestEntry?.toISOString(),\n          newestEntry: stats.newestEntry?.toISOString(),\n          topTags: Array.from(stats.tagFrequency.entries())\n            .sort((a, b) => b[1] - a[1])\n            .slice(0, 10)\n            .map(([tag, count]) => ({ tag, count }))\n        },\n        entries: JSON.parse(element.serialize()).entries\n      };\n      \n      // SECURITY FIX: Use secure YAML dumping with safety options\n      // Previously: Could allow dangerous YAML features\n      // Now: Uses FAILSAFE_SCHEMA and security options to prevent code execution\n      const yamlContent = yaml.dump(data, {\n        schema: yaml.FAILSAFE_SCHEMA,\n        noRefs: true,\n        skipInvalid: true,\n        sortKeys: true\n      });\n      \n      // CRITICAL FIX: Use atomic file write to prevent corruption\n      // Previously: await fs.writeFile(fullPath, yamlContent, 'utf-8');\n      // Now: Uses FileLockManager for atomic write with proper encoding\n      await FileLockManager.atomicWriteFile(fullPath, yamlContent, { encoding: 'utf-8' });\n      \n      // Update cache\n      this.memoryCache.set(fullPath, element);\n\n      // Update content hash index\n      this.contentHashIndex.set(contentHash, fullPath);\n\n      // Log successful save\n      SecurityMonitor.logSecurityEvent({\n        type: MEMORY_SECURITY_EVENTS.MEMORY_SAVED,\n        severity: 'LOW',\n        source: 'MemoryManager.save',\n        details: `Saved memory to ${path.basename(fullPath)} with ${stats.totalEntries} entries`\n      });\n      \n    } catch (error) {\n      SecurityMonitor.logSecurityEvent({\n        type: MEMORY_SECURITY_EVENTS.MEMORY_SAVE_FAILED,\n        severity: 'HIGH',\n        source: 'MemoryManager.save',\n        details: `Failed to save memory to ${filePath}: ${error}`\n      });\n      throw new Error(`Failed to save memory: ${error}`);\n    }\n  }\n  \n  /**\n   * List all available memories\n   */\n  async list(): Promise<Memory[]> {\n    const memories: Memory[] = [];\n\n    try {\n      // Get all date folders\n      const dateFolders = await this.getDateFolders();\n\n      // Also check root directory for any legacy files\n      const rootFiles = await fs.readdir(this.memoriesDir)\n        .then(files => files.filter(f => f.endsWith('.yaml')))\n        .catch(() => []);\n\n      // Process root files first (legacy)\n      for (const file of rootFiles) {\n        try {\n          const memory = await this.load(file);\n          memories.push(memory);\n        } catch (error) {\n          SecurityMonitor.logSecurityEvent({\n            type: MEMORY_SECURITY_EVENTS.MEMORY_LIST_ITEM_FAILED,\n            severity: 'LOW',\n            source: 'MemoryManager.list',\n            details: `Failed to load ${file}: ${error}`\n          });\n        }\n      }\n\n      // Process date folders\n      for (const dateFolder of dateFolders) {\n        const folderPath = path.join(this.memoriesDir, dateFolder);\n        const files = await fs.readdir(folderPath)\n          .then(files => files.filter(f => f.endsWith('.yaml')))\n          .catch(() => []);\n\n        for (const file of files) {\n          try {\n            const memory = await this.load(path.join(dateFolder, file));\n            memories.push(memory);\n          } catch (error) {\n            SecurityMonitor.logSecurityEvent({\n              type: MEMORY_SECURITY_EVENTS.MEMORY_LIST_ITEM_FAILED,\n              severity: 'LOW',\n              source: 'MemoryManager.list',\n              details: `Failed to load ${dateFolder}/${file}: ${error}`\n            });\n          }\n        }\n      }\n\n      return memories;\n      \n    } catch (error) {\n      if ((error as any).code === 'ENOENT') {\n        // Directory doesn't exist yet\n        return [];\n      }\n      throw error;\n    }\n  }\n  \n  /**\n   * Find memories matching a predicate\n   */\n  async find(predicate: (element: Memory) => boolean): Promise<Memory | undefined> {\n    const memories = await this.list();\n    return memories.find(predicate);\n  }\n  \n  /**\n   * Find multiple memories matching a predicate\n   */\n  async findMany(predicate: (element: Memory) => boolean): Promise<Memory[]> {\n    const memories = await this.list();\n    return memories.filter(predicate);\n  }\n  \n  /**\n   * Delete a memory file\n   * SECURITY: Validates path and logs deletion\n   */\n  async delete(filePath: string): Promise<void> {\n    try {\n      const fullPath = await this.validateAndResolvePath(filePath);\n      \n      // Check if file exists\n      await fs.access(fullPath);\n      \n      // Delete the file\n      await fs.unlink(fullPath);\n      \n      // Remove from cache\n      this.memoryCache.delete(fullPath);\n      \n      SecurityMonitor.logSecurityEvent({\n        type: MEMORY_SECURITY_EVENTS.MEMORY_DELETED,\n        severity: 'MEDIUM',\n        source: 'MemoryManager.delete',\n        details: `Deleted memory file: ${path.basename(fullPath)}`\n      });\n      \n    } catch (error) {\n      if ((error as any).code === 'ENOENT') {\n        // File doesn't exist, not an error for delete operation\n        return;\n      }\n      throw error;\n    }\n  }\n  \n  /**\n   * Check if a memory file exists\n   */\n  async exists(filePath: string): Promise<boolean> {\n    try {\n      const fullPath = await this.validateAndResolvePath(filePath);\n      await fs.access(fullPath);\n      return true;\n    } catch {\n      return false;\n    }\n  }\n  \n  /**\n   * Create a new memory with metadata\n   */\n  async create(metadata: Partial<MemoryMetadata>): Promise<Memory> {\n    return new Memory(metadata);\n  }\n  \n  /**\n   * Import a memory from JSON/YAML string\n   * SECURITY: Full validation of imported content\n   * @param data JSON or YAML string containing memory data\n   * @param format Format of the input data ('json' or 'yaml')\n   * @returns Promise resolving to the imported Memory instance\n   * @throws {Error} When JSON/YAML parsing fails\n   * @throws {Error} When imported data is missing required fields\n   * @throws {Error} When YAML content exceeds maximum allowed size\n   * @throws {Error} When imported memory fails validation\n   */\n  async importElement(data: string, format: 'json' | 'yaml' = 'yaml'): Promise<Memory> {\n    try {\n      let parsed: any;\n      \n      if (format === 'json') {\n        parsed = JSON.parse(data);\n      } else {\n        // HIGH SEVERITY FIX: Use secure YAML parsing\n        // Memory import expects pure YAML (not frontmatter), so we parse it securely\n        try {\n          // First validate the YAML content size\n          if (data.length > MEMORY_CONSTANTS.MAX_YAML_SIZE) {\n            throw new Error('YAML content exceeds maximum allowed size');\n          }\n          \n          // Create a wrapper to use SecureYamlParser with pure YAML\n          // Add minimal frontmatter markers to satisfy parser\n          const wrappedYaml = `---\\n${data}\\n---\\n`;\n          \n          const parseResult = SecureYamlParser.parse(wrappedYaml, {\n            maxYamlSize: MEMORY_CONSTANTS.MAX_YAML_SIZE,\n            validateContent: true\n          });\n          \n          // Extract the parsed data (will be in the 'data' property)\n          parsed = parseResult.data;\n          \n        } catch (yamlError) {\n          throw new Error(`Invalid YAML: ${yamlError}`);\n        }\n        \n        // Validate it's an object\n        if (!parsed || typeof parsed !== 'object') {\n          throw new Error('YAML must contain an object');\n        }\n      }\n      \n      // Handle different structures from YAML parsing\n      let metadata = parsed.metadata;\n      let entries = parsed.entries || (parsed.data && parsed.data.entries);\n      \n      // Validate required fields\n      if (!metadata || !metadata.name) {\n        throw new Error('Memory must have metadata with name');\n      }\n      \n      // Create memory instance\n      const memory = new Memory(metadata);\n      \n      // Load entries if present\n      if (entries) {\n        memory.deserialize(JSON.stringify({\n          id: memory.id,\n          type: memory.type,\n          version: memory.version,\n          metadata: memory.metadata,\n          extensions: memory.extensions,\n          entries: entries\n        }));\n      }\n      \n      return memory;\n      \n    } catch (error) {\n      SecurityMonitor.logSecurityEvent({\n        type: MEMORY_SECURITY_EVENTS.MEMORY_IMPORT_FAILED,\n        severity: 'MEDIUM',\n        source: 'MemoryManager.importElement',\n        details: `Failed to import memory: ${error}`\n      });\n      throw new Error(`Failed to import memory: ${error}`);\n    }\n  }\n  \n  /**\n   * Export a memory to YAML string\n   */\n  async exportElement(element: Memory): Promise<string> {\n    const stats = element.getStats();\n    const data = {\n      metadata: element.metadata,\n      extensions: element.extensions,\n      stats: {\n        totalEntries: stats.totalEntries,\n        totalSize: stats.totalSize,\n        oldestEntry: stats.oldestEntry?.toISOString(),\n        newestEntry: stats.newestEntry?.toISOString()\n      },\n      entries: JSON.parse(element.serialize()).entries\n    };\n    \n    // SECURITY FIX: Use secure YAML dumping\n    return yaml.dump(data, {\n      schema: yaml.FAILSAFE_SCHEMA,\n      noRefs: true,\n      skipInvalid: true,\n      sortKeys: true\n    });\n  }\n  \n  /**\n   * Validate a memory element\n   */\n  validate(element: Memory): ElementValidationResult {\n    return element.validate();\n  }\n  \n  /**\n   * Validate and resolve a file path\n   * SECURITY: Prevents directory traversal attacks\n   */\n  validatePath(filePath: string): boolean {\n    try {\n      // Perform synchronous validation checks\n      const normalized = path.normalize(filePath);\n      \n      // Check for path traversal attempts\n      if (normalized.includes('..') || path.isAbsolute(normalized)) {\n        return false;\n      }\n      \n      // Ensure proper extension\n      if (!normalized.endsWith('.md') && !normalized.endsWith('.yaml') && !normalized.endsWith('.yml')) {\n        return false;\n      }\n      \n      return true;\n    } catch {\n      return false;\n    }\n  }\n  \n  /**\n   * Get the element type this manager handles\n   */\n  getElementType(): ElementType {\n    return ElementType.MEMORY;\n  }\n  \n  /**\n   * Get the file extension for memory files\n   */\n  getFileExtension(): string {\n    return '.yaml';\n  }\n  \n  // Private helper methods\n  \n  /**\n   * Validate and resolve a file path to prevent security issues\n   * @param filePath Path to validate and resolve\n   * @returns Promise resolving to the validated full path\n   * @throws {Error} When path contains traversal attempts (../)\n   * @throws {Error} When path is absolute or invalid\n   * @throws {Error} When file extension is not allowed (.md, .yaml, .yml)\n   * @throws {Error} When resolved path would be outside memories directory\n   */\n  private async validateAndResolvePath(filePath: string): Promise<string> {\n    // SECURITY FIX: Comprehensive path validation\n    const normalized = path.normalize(filePath);\n    \n    // Check for path traversal attempts\n    if (normalized.includes('..') || path.isAbsolute(normalized)) {\n      SecurityMonitor.logSecurityEvent({\n        type: 'PATH_TRAVERSAL_ATTEMPT',\n        severity: 'HIGH',\n        source: 'MemoryManager.validateAndResolvePath',\n        details: `Blocked path traversal attempt: ${filePath}`\n      });\n      throw new Error('Invalid file path: Path traversal detected');\n    }\n    \n    // Ensure proper extension\n    if (!normalized.endsWith('.md') && !normalized.endsWith('.yaml') && !normalized.endsWith('.yml')) {\n      throw new Error('Memory files must have .md, .yaml, or .yml extension');\n    }\n    \n    // Construct full path\n    const fullPath = path.join(this.memoriesDir, normalized);\n    \n    // Verify it's within memories directory\n    const relative = path.relative(this.memoriesDir, fullPath);\n    if (relative.startsWith('..') || path.isAbsolute(relative)) {\n      throw new Error('File path must be within memories directory');\n    }\n    \n    return fullPath;\n  }\n  \n  private parseMemoryFile(parsed: any): { metadata: MemoryMetadata; content: string } {\n    // Extract metadata with validation\n    const metadata: MemoryMetadata = {\n      name: sanitizeInput(parsed.metadata?.name || 'Unnamed Memory', 100),\n      description: parsed.metadata?.description ? \n        sanitizeInput(parsed.metadata.description, 500) : \n        '',\n      version: parsed.metadata?.version || '1.0.0',\n      author: parsed.metadata?.author,\n      created: parsed.metadata?.created,\n      modified: new Date().toISOString(),\n      tags: Array.isArray(parsed.metadata?.tags) ?\n        parsed.metadata.tags.map((tag: string) => sanitizeInput(tag, MEMORY_CONSTANTS.MAX_TAG_LENGTH)) :\n        [],\n      storageBackend: parsed.metadata?.storageBackend || MEMORY_CONSTANTS.DEFAULT_STORAGE_BACKEND,\n      retentionDays: parsed.metadata?.retentionDays || MEMORY_CONSTANTS.DEFAULT_RETENTION_DAYS,\n      privacyLevel: parsed.metadata?.privacyLevel || MEMORY_CONSTANTS.DEFAULT_PRIVACY_LEVEL,\n      searchable: parsed.metadata?.searchable !== false,\n      maxEntries: parsed.metadata?.maxEntries || MEMORY_CONSTANTS.MAX_ENTRIES_DEFAULT\n    };\n    \n    // Extract content (if any)\n    const content = parsed.content || '';\n    \n    return { metadata, content };\n  }\n}"]}