@dollhousemcp/mcp-server 1.3.0

package/dist/elements/memories/Memory.js

@@ -0,0 +1,470 @@
+/**
+ * Memory Element - Persistent context storage for continuity and learning
+ *
+ * Provides multiple storage backends, retention policies, and search capabilities
+ * for maintaining context across sessions and interactions.
+ *
+ * SECURITY MEASURES IMPLEMENTED:
+ * 1. Input sanitization for all memory content
+ * 2. Memory size limits to prevent unbounded growth
+ * 3. Path validation for file-based storage
+ * 4. Retention policy enforcement
+ * 5. Privacy level access control
+ * 6. Audit logging for all operations
+ */
+import { BaseElement } from '../BaseElement.js';
+import { ElementType } from '../../portfolio/types.js';
+import { UnicodeValidator } from '../../security/validators/unicodeValidator.js';
+import { SecurityMonitor } from '../../security/securityMonitor.js';
+import { sanitizeInput } from '../../security/InputValidator.js';
+import { MEMORY_CONSTANTS, MEMORY_SECURITY_EVENTS } from './constants.js';
+import DOMPurify from 'dompurify';
+import { JSDOM } from 'jsdom';
+// Initialize DOMPurify with JSDOM
+const window = new JSDOM('').window;
+const purify = DOMPurify(window);
+// Configure DOMPurify for memory content - strip all HTML but keep text
+purify.setConfig({
+    ALLOWED_TAGS: [], // No HTML tags allowed
+    ALLOWED_ATTR: [], // No attributes allowed
+    KEEP_CONTENT: true // Keep text content
+});
+/**
+ * Sanitize content for memory storage
+ * More permissive than sanitizeInput - allows punctuation, quotes, etc.
+ * but still prevents XSS and control characters
+ */
+function sanitizeMemoryContent(content, maxLength) {
+    if (!content || typeof content !== 'string') {
+        return '';
+    }
+    // First normalize Unicode
+    const normalized = UnicodeValidator.normalize(content).normalizedContent;
+    // Use DOMPurify to strip any HTML/XSS attempts but keep text
+    const cleaned = purify.sanitize(normalized);
+    // Remove only control characters and null bytes
+    return cleaned
+        .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, '') // Remove control chars except \t \n \r
+        .substring(0, maxLength)
+        .trim();
+}
+export class Memory extends BaseElement {
+    // Memory-specific properties
+    entries = new Map();
+    storageBackend;
+    retentionDays;
+    privacyLevel;
+    searchable;
+    maxEntries;
+    constructor(metadata = {}) {
+        // SECURITY FIX: Sanitize all inputs during construction
+        const sanitizedMetadata = {
+            ...metadata,
+            name: metadata.name ?
+                sanitizeInput(UnicodeValidator.normalize(metadata.name).normalizedContent, 100) :
+                'Unnamed Memory',
+            description: metadata.description ?
+                sanitizeInput(UnicodeValidator.normalize(metadata.description).normalizedContent, 500) :
+                undefined
+        };
+        super(ElementType.MEMORY, sanitizedMetadata);
+        // Initialize memory-specific properties with defaults
+        this.storageBackend = metadata.storageBackend || MEMORY_CONSTANTS.DEFAULT_STORAGE_BACKEND;
+        this.retentionDays = metadata.retentionDays || MEMORY_CONSTANTS.DEFAULT_RETENTION_DAYS;
+        // Validate privacy level - default to private if invalid
+        this.privacyLevel = (metadata.privacyLevel && MEMORY_CONSTANTS.PRIVACY_LEVELS.includes(metadata.privacyLevel))
+            ? metadata.privacyLevel
+            : MEMORY_CONSTANTS.DEFAULT_PRIVACY_LEVEL;
+        this.searchable = metadata.searchable !== false;
+        this.maxEntries = Math.min(metadata.maxEntries || MEMORY_CONSTANTS.MAX_ENTRIES_DEFAULT, MEMORY_CONSTANTS.MAX_ENTRIES_DEFAULT);
+        // Set up extensions
+        this.extensions = {
+            storageBackend: this.storageBackend,
+            retentionDays: this.retentionDays,
+            privacyLevel: this.privacyLevel,
+            searchable: this.searchable,
+            maxEntries: this.maxEntries,
+            encryptionEnabled: metadata.encryptionEnabled || false
+        };
+        // Log memory creation
+        SecurityMonitor.logSecurityEvent({
+            type: MEMORY_SECURITY_EVENTS.MEMORY_CREATED,
+            severity: 'LOW',
+            source: 'Memory.constructor',
+            details: `Memory created: ${this.metadata.name} with ${this.storageBackend} backend`
+        });
+    }
+    /**
+     * Add a new memory entry
+     * SECURITY: Validates and sanitizes all input, enforces size limits
+     */
+    async addEntry(content, tags, metadata) {
+        // Validate memory size limits
+        if (this.entries.size >= this.maxEntries) {
+            // SECURITY FIX: Enforce retention policy when at capacity
+            await this.enforceRetentionPolicy();
+            // If still at capacity after retention, remove oldest to make room
+            if (this.entries.size >= this.maxEntries) {
+                const oldestEntry = Array.from(this.entries.values())
+                    .sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime())[0];
+                if (oldestEntry) {
+                    this.entries.delete(oldestEntry.id);
+                }
+            }
+        }
+        // SECURITY FIX: Validate and sanitize content
+        const sanitizedContent = sanitizeMemoryContent(content, MEMORY_CONSTANTS.MAX_ENTRY_SIZE);
+        if (!sanitizedContent || sanitizedContent.trim().length === 0) {
+            throw new Error('Memory content cannot be empty');
+        }
+        // SECURITY FIX: Validate and sanitize tags
+        const sanitizedTags = tags ? this.sanitizeTags(tags) : [];
+        // Create memory entry
+        const entry = {
+            id: `mem_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+            timestamp: new Date(),
+            content: sanitizedContent,
+            tags: sanitizedTags,
+            metadata: this.sanitizeMetadata(metadata),
+            privacyLevel: this.privacyLevel,
+            expiresAt: this.calculateExpiryDate()
+        };
+        // Store entry
+        this.entries.set(entry.id, entry);
+        this._isDirty = true;
+        // Log memory addition
+        SecurityMonitor.logSecurityEvent({
+            type: MEMORY_SECURITY_EVENTS.MEMORY_ADDED,
+            severity: 'LOW',
+            source: 'Memory.addEntry',
+            details: `Added memory entry ${entry.id} with ${sanitizedTags.length} tags`
+        });
+        return entry;
+    }
+    /**
+     * Search memory entries
+     * SECURITY: Respects privacy levels and sanitizes search queries
+     */
+    async search(options = {}) {
+        // SECURITY FIX: Sanitize search query (use regular sanitizeInput for queries)
+        const sanitizedQuery = options.query ?
+            sanitizeInput(UnicodeValidator.normalize(options.query).normalizedContent, 200) :
+            undefined;
+        // PERFORMANCE OPTIMIZATION: Single-pass filtering to reduce allocations
+        let results = [];
+        const queryLower = sanitizedQuery?.toLowerCase();
+        const searchTags = options.tags && options.tags.length > 0 ? this.sanitizeTags(options.tags) : null;
+        // Single iteration through entries with all filters applied
+        for (const entry of this.entries.values()) {
+            // Privacy level check
+            if (options.privacyLevel &&
+                !this.canAccessPrivacyLevel(entry.privacyLevel || MEMORY_CONSTANTS.DEFAULT_PRIVACY_LEVEL, options.privacyLevel)) {
+                continue;
+            }
+            // Query text check
+            if (queryLower) {
+                const contentMatch = entry.content.toLowerCase().includes(queryLower);
+                const tagMatch = entry.tags?.some(tag => tag.toLowerCase().includes(queryLower));
+                if (!contentMatch && !tagMatch) {
+                    continue;
+                }
+            }
+            // Tag filter check
+            if (searchTags && !searchTags.some(searchTag => entry.tags?.includes(searchTag))) {
+                continue;
+            }
+            // Date range checks
+            if (options.startDate && entry.timestamp < options.startDate) {
+                continue;
+            }
+            if (options.endDate && entry.timestamp > options.endDate) {
+                continue;
+            }
+            // Entry passes all filters
+            results.push(entry);
+        }
+        // Sort by timestamp (newest first) - using string comparison for IDs as secondary sort
+        results.sort((a, b) => {
+            const timeDiff = b.timestamp.getTime() - a.timestamp.getTime();
+            if (timeDiff !== 0)
+                return timeDiff;
+            // If timestamps are exactly the same, sort by ID (which contains timestamp)
+            return b.id.localeCompare(a.id);
+        });
+        // Apply limit
+        if (options.limit && options.limit > 0) {
+            results = results.slice(0, options.limit);
+        }
+        // Log search operation
+        SecurityMonitor.logSecurityEvent({
+            type: MEMORY_SECURITY_EVENTS.MEMORY_SEARCHED,
+            severity: 'LOW',
+            source: 'Memory.search',
+            details: `Searched memories with query: ${sanitizedQuery || 'none'}, found ${results.length} results`
+        });
+        return results;
+    }
+    /**
+     * Get a specific memory entry by ID
+     */
+    async getEntry(id) {
+        return this.entries.get(id);
+    }
+    /**
+     * Delete a memory entry
+     * SECURITY: Validates permissions and logs deletion
+     */
+    async deleteEntry(id) {
+        const entry = this.entries.get(id);
+        if (!entry) {
+            return false;
+        }
+        // SECURITY: Check if sensitive memories can be deleted
+        if (entry.privacyLevel === 'sensitive') {
+            SecurityMonitor.logSecurityEvent({
+                type: MEMORY_SECURITY_EVENTS.SENSITIVE_MEMORY_DELETED,
+                severity: 'MEDIUM',
+                source: 'Memory.deleteEntry',
+                details: `Sensitive memory ${id} deleted`
+            });
+        }
+        this.entries.delete(id);
+        this._isDirty = true;
+        return true;
+    }
+    /**
+     * Enforce retention policy by removing expired entries
+     * SECURITY: Ensures memory doesn't grow unbounded
+     */
+    async enforceRetentionPolicy() {
+        const now = new Date();
+        let deletedCount = 0;
+        // Remove expired entries
+        for (const [id, entry] of this.entries) {
+            if (entry.expiresAt && entry.expiresAt < now) {
+                this.entries.delete(id);
+                deletedCount++;
+            }
+        }
+        // If still at or over capacity, remove oldest entries to make room for one more
+        if (this.entries.size >= this.maxEntries) {
+            const sortedEntries = Array.from(this.entries.entries())
+                .sort((a, b) => a[1].timestamp.getTime() - b[1].timestamp.getTime());
+            // Remove one extra to make room for new entry
+            const toDelete = Math.max(1, this.entries.size - this.maxEntries + 1);
+            for (let i = 0; i < toDelete && i < sortedEntries.length; i++) {
+                this.entries.delete(sortedEntries[i][0]);
+                deletedCount++;
+            }
+        }
+        if (deletedCount > 0) {
+            this._isDirty = true;
+            SecurityMonitor.logSecurityEvent({
+                type: MEMORY_SECURITY_EVENTS.RETENTION_POLICY_ENFORCED,
+                severity: 'LOW',
+                source: 'Memory.enforceRetentionPolicy',
+                details: `Removed ${deletedCount} expired memories`
+            });
+        }
+        return deletedCount;
+    }
+    /**
+     * Clear all memory entries
+     * SECURITY: Requires confirmation and logs the action
+     */
+    async clearAll(confirm = false) {
+        if (!confirm) {
+            throw new Error('Memory clear requires confirmation');
+        }
+        const count = this.entries.size;
+        this.entries.clear();
+        this._isDirty = true;
+        SecurityMonitor.logSecurityEvent({
+            type: MEMORY_SECURITY_EVENTS.MEMORY_CLEARED,
+            severity: 'HIGH',
+            source: 'Memory.clearAll',
+            details: `Cleared all ${count} memory entries`
+        });
+    }
+    /**
+     * Get memory statistics
+     */
+    getStats() {
+        let totalSize = 0;
+        let oldestEntry;
+        let newestEntry;
+        const tagFrequency = new Map();
+        for (const entry of this.entries.values()) {
+            totalSize += entry.content.length;
+            if (!oldestEntry || entry.timestamp < oldestEntry) {
+                oldestEntry = entry.timestamp;
+            }
+            if (!newestEntry || entry.timestamp > newestEntry) {
+                newestEntry = entry.timestamp;
+            }
+            entry.tags?.forEach(tag => {
+                tagFrequency.set(tag, (tagFrequency.get(tag) || 0) + 1);
+            });
+        }
+        return {
+            totalEntries: this.entries.size,
+            totalSize,
+            oldestEntry,
+            newestEntry,
+            tagFrequency
+        };
+    }
+    /**
+     * Validate the memory element
+     */
+    validate() {
+        const result = super.validate();
+        // Initialize errors array if not present
+        if (!result.errors) {
+            result.errors = [];
+        }
+        // Additional memory-specific validation
+        if (this.retentionDays < MEMORY_CONSTANTS.MIN_RETENTION_DAYS || this.retentionDays > MEMORY_CONSTANTS.MAX_RETENTION_DAYS) {
+            result.errors.push({
+                field: 'retentionDays',
+                message: `Retention days must be between ${MEMORY_CONSTANTS.MIN_RETENTION_DAYS} and ${MEMORY_CONSTANTS.MAX_RETENTION_DAYS}`,
+                severity: 'error'
+            });
+        }
+        if (this.maxEntries < 1 || this.maxEntries > MEMORY_CONSTANTS.MAX_ENTRIES_DEFAULT) {
+            result.errors.push({
+                field: 'maxEntries',
+                message: `Max entries must be between 1 and ${MEMORY_CONSTANTS.MAX_ENTRIES_DEFAULT}`,
+                severity: 'error'
+            });
+        }
+        // Check memory size
+        const stats = this.getStats();
+        if (stats.totalSize > MEMORY_CONSTANTS.MAX_MEMORY_SIZE) {
+            result.errors.push({
+                field: 'memory',
+                message: `Total memory size (${stats.totalSize}) exceeds limit (${MEMORY_CONSTANTS.MAX_MEMORY_SIZE})`,
+                severity: 'error'
+            });
+        }
+        // Update validity based on our checks
+        return {
+            ...result,
+            valid: result.errors.length === 0
+        };
+    }
+    /**
+     * Serialize memory to string
+     */
+    serialize() {
+        const data = {
+            id: this.id,
+            type: this.type,
+            version: this.version,
+            metadata: this.metadata,
+            extensions: this.extensions,
+            entries: Array.from(this.entries.values())
+        };
+        return JSON.stringify(data, null, 2);
+    }
+    /**
+     * Deserialize memory from string
+     * SECURITY: Validates all loaded data
+     */
+    deserialize(data) {
+        try {
+            const parsed = JSON.parse(data);
+            // Validate basic structure
+            if (!parsed.id || !parsed.type || parsed.type !== ElementType.MEMORY) {
+                throw new Error('Invalid memory data format');
+            }
+            // Update properties
+            this.id = parsed.id;
+            this.version = parsed.version || '1.0.0';
+            this.metadata = parsed.metadata || {};
+            this.extensions = parsed.extensions || {};
+            // Clear and reload entries
+            this.entries.clear();
+            if (Array.isArray(parsed.entries)) {
+                for (const entry of parsed.entries) {
+                    if (this.isValidEntry(entry)) {
+                        // Re-sanitize on load
+                        entry.content = sanitizeMemoryContent(entry.content, MEMORY_CONSTANTS.MAX_ENTRY_SIZE);
+                        entry.tags = this.sanitizeTags(entry.tags || []);
+                        entry.timestamp = new Date(entry.timestamp);
+                        if (entry.expiresAt) {
+                            entry.expiresAt = new Date(entry.expiresAt);
+                        }
+                        this.entries.set(entry.id, entry);
+                    }
+                }
+            }
+            // Enforce retention policy after loading
+            this.enforceRetentionPolicy();
+        }
+        catch (error) {
+            SecurityMonitor.logSecurityEvent({
+                type: MEMORY_SECURITY_EVENTS.MEMORY_DESERIALIZE_FAILED,
+                severity: 'HIGH',
+                source: 'Memory.deserialize',
+                details: `Failed to deserialize memory: ${error}`
+            });
+            throw new Error(`Failed to deserialize memory: ${error}`);
+        }
+    }
+    // Private helper methods
+    calculateExpiryDate() {
+        const expiry = new Date();
+        expiry.setDate(expiry.getDate() + this.retentionDays);
+        return expiry;
+    }
+    sanitizeTags(tags) {
+        // SECURITY FIX: Limit number of tags and sanitize each
+        const limitedTags = tags.slice(0, MEMORY_CONSTANTS.MAX_TAGS_PER_ENTRY);
+        return limitedTags
+            .map(tag => {
+            const normalized = UnicodeValidator.normalize(tag).normalizedContent;
+            return sanitizeInput(normalized, MEMORY_CONSTANTS.MAX_TAG_LENGTH);
+        })
+            .filter(tag => tag && tag.length > 0);
+    }
+    sanitizeMetadata(metadata) {
+        if (!metadata)
+            return undefined;
+        // SECURITY FIX: Sanitize metadata values
+        const sanitized = {};
+        const maxKeys = MEMORY_CONSTANTS.MAX_METADATA_KEYS;
+        let keyCount = 0;
+        for (const [key, value] of Object.entries(metadata)) {
+            if (keyCount >= maxKeys)
+                break;
+            const sanitizedKey = sanitizeInput(key, MEMORY_CONSTANTS.MAX_METADATA_KEY_LENGTH);
+            if (sanitizedKey && typeof value === 'string') {
+                sanitized[sanitizedKey] = sanitizeInput(value, MEMORY_CONSTANTS.MAX_METADATA_VALUE_LENGTH);
+                keyCount++;
+            }
+            else if (sanitizedKey && typeof value === 'number') {
+                sanitized[sanitizedKey] = value;
+                keyCount++;
+            }
+            // Skip other types for security
+        }
+        return sanitized;
+    }
+    canAccessPrivacyLevel(entryLevel, requestedLevel) {
+        const levels = MEMORY_CONSTANTS.PRIVACY_LEVELS;
+        const entryIndex = levels.indexOf(entryLevel);
+        const requestedIndex = levels.indexOf(requestedLevel);
+        // Can only access entries at or below the requested privacy level
+        // e.g., if requesting 'private', can see 'public' and 'private' but not 'sensitive'
+        return entryIndex <= requestedIndex;
+    }
+    isValidEntry(entry) {
+        return entry &&
+            typeof entry.id === 'string' &&
+            typeof entry.content === 'string' &&
+            entry.timestamp &&
+            (!entry.tags || Array.isArray(entry.tags));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Memory.js","sourceRoot":"","sources":["../../../src/elements/memories/Memory.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Memory Element - Persistent context storage for continuity and learning\n * \n * Provides multiple storage backends, retention policies, and search capabilities\n * for maintaining context across sessions and interactions.\n * \n * SECURITY MEASURES IMPLEMENTED:\n * 1. Input sanitization for all memory content\n * 2. Memory size limits to prevent unbounded growth\n * 3. Path validation for file-based storage\n * 4. Retention policy enforcement\n * 5. Privacy level access control\n * 6. Audit logging for all operations\n */\n\nimport { BaseElement } from '../BaseElement.js';\nimport { IElement, ElementValidationResult, ValidationError } from '../../types/elements/index.js';\nimport { ElementType } from '../../portfolio/types.js';\nimport { IElementMetadata } from '../../types/elements/IElement.js';\nimport { UnicodeValidator } from '../../security/validators/unicodeValidator.js';\nimport { SecurityMonitor } from '../../security/securityMonitor.js';\nimport { sanitizeInput } from '../../security/InputValidator.js';\nimport { MEMORY_CONSTANTS, MEMORY_SECURITY_EVENTS, PrivacyLevel, StorageBackend } from './constants.js';\nimport DOMPurify from 'dompurify';\nimport { JSDOM } from 'jsdom';\nimport * as path from 'path';\n\n// Initialize DOMPurify with JSDOM\nconst window = new JSDOM('').window;\nconst purify = DOMPurify(window as any);\n\n// Configure DOMPurify for memory content - strip all HTML but keep text\npurify.setConfig({\n  ALLOWED_TAGS: [],  // No HTML tags allowed\n  ALLOWED_ATTR: [],  // No attributes allowed\n  KEEP_CONTENT: true // Keep text content\n});\n\n/**\n * Sanitize content for memory storage\n * More permissive than sanitizeInput - allows punctuation, quotes, etc.\n * but still prevents XSS and control characters\n */\nfunction sanitizeMemoryContent(content: string, maxLength: number): string {\n  if (!content || typeof content !== 'string') {\n    return '';\n  }\n  \n  // First normalize Unicode\n  const normalized = UnicodeValidator.normalize(content).normalizedContent;\n  \n  // Use DOMPurify to strip any HTML/XSS attempts but keep text\n  const cleaned = purify.sanitize(normalized);\n  \n  // Remove only control characters and null bytes\n  return cleaned\n    .replace(/[\\x00-\\x08\\x0B\\x0C\\x0E-\\x1F\\x7F]/g, '') // Remove control chars except \\t \\n \\r\n    .substring(0, maxLength)\n    .trim();\n}\n\nexport interface MemoryMetadata extends IElementMetadata {\n  storageBackend?: StorageBackend;\n  retentionDays?: number;\n  privacyLevel?: PrivacyLevel;\n  searchable?: boolean;\n  maxEntries?: number;\n  encryptionEnabled?: boolean;\n}\n\nexport interface MemoryEntry {\n  id: string;\n  timestamp: Date;\n  content: string;\n  tags?: string[];\n  metadata?: Record<string, any>;\n  expiresAt?: Date;\n  privacyLevel?: PrivacyLevel;\n}\n\nexport interface MemorySearchOptions {\n  query?: string;\n  tags?: string[];\n  startDate?: Date;\n  endDate?: Date;\n  limit?: number;\n  privacyLevel?: PrivacyLevel;\n}\n\nexport class Memory extends BaseElement implements IElement {\n  // Memory-specific properties\n  private entries: Map<string, MemoryEntry> = new Map();\n  private storageBackend: StorageBackend;\n  private retentionDays: number;\n  private privacyLevel: PrivacyLevel;\n  private searchable: boolean;\n  private maxEntries: number;\n  \n  constructor(metadata: Partial<MemoryMetadata> = {}) {\n    // SECURITY FIX: Sanitize all inputs during construction\n    const sanitizedMetadata = {\n      ...metadata,\n      name: metadata.name ? \n        sanitizeInput(UnicodeValidator.normalize(metadata.name).normalizedContent, 100) : \n        'Unnamed Memory',\n      description: metadata.description ? \n        sanitizeInput(UnicodeValidator.normalize(metadata.description).normalizedContent, 500) : \n        undefined\n    };\n    \n    super(ElementType.MEMORY, sanitizedMetadata);\n    \n    // Initialize memory-specific properties with defaults\n    this.storageBackend = metadata.storageBackend || MEMORY_CONSTANTS.DEFAULT_STORAGE_BACKEND;\n    this.retentionDays = metadata.retentionDays || MEMORY_CONSTANTS.DEFAULT_RETENTION_DAYS;\n    // Validate privacy level - default to private if invalid\n    this.privacyLevel = (metadata.privacyLevel && MEMORY_CONSTANTS.PRIVACY_LEVELS.includes(metadata.privacyLevel)) \n      ? metadata.privacyLevel \n      : MEMORY_CONSTANTS.DEFAULT_PRIVACY_LEVEL;\n    this.searchable = metadata.searchable !== false;\n    this.maxEntries = Math.min(\n      metadata.maxEntries || MEMORY_CONSTANTS.MAX_ENTRIES_DEFAULT,\n      MEMORY_CONSTANTS.MAX_ENTRIES_DEFAULT\n    );\n    \n    // Set up extensions\n    this.extensions = {\n      storageBackend: this.storageBackend,\n      retentionDays: this.retentionDays,\n      privacyLevel: this.privacyLevel,\n      searchable: this.searchable,\n      maxEntries: this.maxEntries,\n      encryptionEnabled: metadata.encryptionEnabled || false\n    };\n    \n    // Log memory creation\n    SecurityMonitor.logSecurityEvent({\n      type: MEMORY_SECURITY_EVENTS.MEMORY_CREATED,\n      severity: 'LOW',\n      source: 'Memory.constructor',\n      details: `Memory created: ${this.metadata.name} with ${this.storageBackend} backend`\n    });\n  }\n  \n  /**\n   * Add a new memory entry\n   * SECURITY: Validates and sanitizes all input, enforces size limits\n   */\n  public async addEntry(content: string, tags?: string[], metadata?: Record<string, any>): Promise<MemoryEntry> {\n    // Validate memory size limits\n    if (this.entries.size >= this.maxEntries) {\n      // SECURITY FIX: Enforce retention policy when at capacity\n      await this.enforceRetentionPolicy();\n      \n      // If still at capacity after retention, remove oldest to make room\n      if (this.entries.size >= this.maxEntries) {\n        const oldestEntry = Array.from(this.entries.values())\n          .sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime())[0];\n        if (oldestEntry) {\n          this.entries.delete(oldestEntry.id);\n        }\n      }\n    }\n    \n    // SECURITY FIX: Validate and sanitize content\n    const sanitizedContent = sanitizeMemoryContent(content, MEMORY_CONSTANTS.MAX_ENTRY_SIZE);\n    \n    if (!sanitizedContent || sanitizedContent.trim().length === 0) {\n      throw new Error('Memory content cannot be empty');\n    }\n    \n    // SECURITY FIX: Validate and sanitize tags\n    const sanitizedTags = tags ? this.sanitizeTags(tags) : [];\n    \n    // Create memory entry\n    const entry: MemoryEntry = {\n      id: `mem_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,\n      timestamp: new Date(),\n      content: sanitizedContent,\n      tags: sanitizedTags,\n      metadata: this.sanitizeMetadata(metadata),\n      privacyLevel: this.privacyLevel,\n      expiresAt: this.calculateExpiryDate()\n    };\n    \n    // Store entry\n    this.entries.set(entry.id, entry);\n    this._isDirty = true;\n    \n    // Log memory addition\n    SecurityMonitor.logSecurityEvent({\n      type: MEMORY_SECURITY_EVENTS.MEMORY_ADDED,\n      severity: 'LOW',\n      source: 'Memory.addEntry',\n      details: `Added memory entry ${entry.id} with ${sanitizedTags.length} tags`\n    });\n    \n    return entry;\n  }\n  \n  /**\n   * Search memory entries\n   * SECURITY: Respects privacy levels and sanitizes search queries\n   */\n  public async search(options: MemorySearchOptions = {}): Promise<MemoryEntry[]> {\n    // SECURITY FIX: Sanitize search query (use regular sanitizeInput for queries)\n    const sanitizedQuery = options.query ? \n      sanitizeInput(UnicodeValidator.normalize(options.query).normalizedContent, 200) : \n      undefined;\n    \n    // PERFORMANCE OPTIMIZATION: Single-pass filtering to reduce allocations\n    let results: MemoryEntry[] = [];\n    const queryLower = sanitizedQuery?.toLowerCase();\n    const searchTags = options.tags && options.tags.length > 0 ? this.sanitizeTags(options.tags) : null;\n    \n    // Single iteration through entries with all filters applied\n    for (const entry of this.entries.values()) {\n      // Privacy level check\n      if (options.privacyLevel && \n          !this.canAccessPrivacyLevel(entry.privacyLevel || MEMORY_CONSTANTS.DEFAULT_PRIVACY_LEVEL, options.privacyLevel)) {\n        continue;\n      }\n      \n      // Query text check\n      if (queryLower) {\n        const contentMatch = entry.content.toLowerCase().includes(queryLower);\n        const tagMatch = entry.tags?.some(tag => tag.toLowerCase().includes(queryLower));\n        if (!contentMatch && !tagMatch) {\n          continue;\n        }\n      }\n      \n      // Tag filter check\n      if (searchTags && !searchTags.some(searchTag => entry.tags?.includes(searchTag))) {\n        continue;\n      }\n      \n      // Date range checks\n      if (options.startDate && entry.timestamp < options.startDate) {\n        continue;\n      }\n      if (options.endDate && entry.timestamp > options.endDate) {\n        continue;\n      }\n      \n      // Entry passes all filters\n      results.push(entry);\n    }\n    \n    // Sort by timestamp (newest first) - using string comparison for IDs as secondary sort\n    results.sort((a, b) => {\n      const timeDiff = b.timestamp.getTime() - a.timestamp.getTime();\n      if (timeDiff !== 0) return timeDiff;\n      // If timestamps are exactly the same, sort by ID (which contains timestamp)\n      return b.id.localeCompare(a.id);\n    });\n    \n    // Apply limit\n    if (options.limit && options.limit > 0) {\n      results = results.slice(0, options.limit);\n    }\n    \n    // Log search operation\n    SecurityMonitor.logSecurityEvent({\n      type: MEMORY_SECURITY_EVENTS.MEMORY_SEARCHED,\n      severity: 'LOW',\n      source: 'Memory.search',\n      details: `Searched memories with query: ${sanitizedQuery || 'none'}, found ${results.length} results`\n    });\n    \n    return results;\n  }\n  \n  /**\n   * Get a specific memory entry by ID\n   */\n  public async getEntry(id: string): Promise<MemoryEntry | undefined> {\n    return this.entries.get(id);\n  }\n  \n  /**\n   * Delete a memory entry\n   * SECURITY: Validates permissions and logs deletion\n   */\n  public async deleteEntry(id: string): Promise<boolean> {\n    const entry = this.entries.get(id);\n    if (!entry) {\n      return false;\n    }\n    \n    // SECURITY: Check if sensitive memories can be deleted\n    if (entry.privacyLevel === 'sensitive') {\n      SecurityMonitor.logSecurityEvent({\n        type: MEMORY_SECURITY_EVENTS.SENSITIVE_MEMORY_DELETED,\n        severity: 'MEDIUM',\n        source: 'Memory.deleteEntry',\n        details: `Sensitive memory ${id} deleted`\n      });\n    }\n    \n    this.entries.delete(id);\n    this._isDirty = true;\n    \n    return true;\n  }\n  \n  /**\n   * Enforce retention policy by removing expired entries\n   * SECURITY: Ensures memory doesn't grow unbounded\n   */\n  public async enforceRetentionPolicy(): Promise<number> {\n    const now = new Date();\n    let deletedCount = 0;\n    \n    // Remove expired entries\n    for (const [id, entry] of this.entries) {\n      if (entry.expiresAt && entry.expiresAt < now) {\n        this.entries.delete(id);\n        deletedCount++;\n      }\n    }\n    \n    // If still at or over capacity, remove oldest entries to make room for one more\n    if (this.entries.size >= this.maxEntries) {\n      const sortedEntries = Array.from(this.entries.entries())\n        .sort((a, b) => a[1].timestamp.getTime() - b[1].timestamp.getTime());\n      \n      // Remove one extra to make room for new entry\n      const toDelete = Math.max(1, this.entries.size - this.maxEntries + 1);\n      for (let i = 0; i < toDelete && i < sortedEntries.length; i++) {\n        this.entries.delete(sortedEntries[i][0]);\n        deletedCount++;\n      }\n    }\n    \n    if (deletedCount > 0) {\n      this._isDirty = true;\n      SecurityMonitor.logSecurityEvent({\n        type: MEMORY_SECURITY_EVENTS.RETENTION_POLICY_ENFORCED,\n        severity: 'LOW',\n        source: 'Memory.enforceRetentionPolicy',\n        details: `Removed ${deletedCount} expired memories`\n      });\n    }\n    \n    return deletedCount;\n  }\n  \n  /**\n   * Clear all memory entries\n   * SECURITY: Requires confirmation and logs the action\n   */\n  public async clearAll(confirm: boolean = false): Promise<void> {\n    if (!confirm) {\n      throw new Error('Memory clear requires confirmation');\n    }\n    \n    const count = this.entries.size;\n    this.entries.clear();\n    this._isDirty = true;\n    \n    SecurityMonitor.logSecurityEvent({\n      type: MEMORY_SECURITY_EVENTS.MEMORY_CLEARED,\n      severity: 'HIGH',\n      source: 'Memory.clearAll',\n      details: `Cleared all ${count} memory entries`\n    });\n  }\n  \n  /**\n   * Get memory statistics\n   */\n  public getStats(): {\n    totalEntries: number;\n    totalSize: number;\n    oldestEntry?: Date;\n    newestEntry?: Date;\n    tagFrequency: Map<string, number>;\n  } {\n    let totalSize = 0;\n    let oldestEntry: Date | undefined;\n    let newestEntry: Date | undefined;\n    const tagFrequency = new Map<string, number>();\n    \n    for (const entry of this.entries.values()) {\n      totalSize += entry.content.length;\n      \n      if (!oldestEntry || entry.timestamp < oldestEntry) {\n        oldestEntry = entry.timestamp;\n      }\n      if (!newestEntry || entry.timestamp > newestEntry) {\n        newestEntry = entry.timestamp;\n      }\n      \n      entry.tags?.forEach(tag => {\n        tagFrequency.set(tag, (tagFrequency.get(tag) || 0) + 1);\n      });\n    }\n    \n    return {\n      totalEntries: this.entries.size,\n      totalSize,\n      oldestEntry,\n      newestEntry,\n      tagFrequency\n    };\n  }\n  \n  /**\n   * Validate the memory element\n   */\n  public override validate(): ElementValidationResult {\n    const result = super.validate();\n    \n    // Initialize errors array if not present\n    if (!result.errors) {\n      result.errors = [];\n    }\n    \n    // Additional memory-specific validation\n    if (this.retentionDays < MEMORY_CONSTANTS.MIN_RETENTION_DAYS || this.retentionDays > MEMORY_CONSTANTS.MAX_RETENTION_DAYS) {\n      result.errors.push({\n        field: 'retentionDays',\n        message: `Retention days must be between ${MEMORY_CONSTANTS.MIN_RETENTION_DAYS} and ${MEMORY_CONSTANTS.MAX_RETENTION_DAYS}`,\n        severity: 'error'\n      } as ValidationError);\n    }\n    \n    if (this.maxEntries < 1 || this.maxEntries > MEMORY_CONSTANTS.MAX_ENTRIES_DEFAULT) {\n      result.errors.push({\n        field: 'maxEntries',\n        message: `Max entries must be between 1 and ${MEMORY_CONSTANTS.MAX_ENTRIES_DEFAULT}`,\n        severity: 'error'\n      } as ValidationError);\n    }\n    \n    // Check memory size\n    const stats = this.getStats();\n    if (stats.totalSize > MEMORY_CONSTANTS.MAX_MEMORY_SIZE) {\n      result.errors.push({\n        field: 'memory',\n        message: `Total memory size (${stats.totalSize}) exceeds limit (${MEMORY_CONSTANTS.MAX_MEMORY_SIZE})`,\n        severity: 'error'\n      } as ValidationError);\n    }\n    \n    // Update validity based on our checks\n    return {\n      ...result,\n      valid: result.errors.length === 0\n    };\n  }\n  \n  /**\n   * Serialize memory to string\n   */\n  public override serialize(): string {\n    const data = {\n      id: this.id,\n      type: this.type,\n      version: this.version,\n      metadata: this.metadata,\n      extensions: this.extensions,\n      entries: Array.from(this.entries.values())\n    };\n    \n    return JSON.stringify(data, null, 2);\n  }\n  \n  /**\n   * Deserialize memory from string\n   * SECURITY: Validates all loaded data\n   */\n  public override deserialize(data: string): void {\n    try {\n      const parsed = JSON.parse(data);\n      \n      // Validate basic structure\n      if (!parsed.id || !parsed.type || parsed.type !== ElementType.MEMORY) {\n        throw new Error('Invalid memory data format');\n      }\n      \n      // Update properties\n      this.id = parsed.id;\n      this.version = parsed.version || '1.0.0';\n      this.metadata = parsed.metadata || {};\n      this.extensions = parsed.extensions || {};\n      \n      // Clear and reload entries\n      this.entries.clear();\n      if (Array.isArray(parsed.entries)) {\n        for (const entry of parsed.entries) {\n          if (this.isValidEntry(entry)) {\n            // Re-sanitize on load\n            entry.content = sanitizeMemoryContent(entry.content, MEMORY_CONSTANTS.MAX_ENTRY_SIZE);\n            entry.tags = this.sanitizeTags(entry.tags || []);\n            entry.timestamp = new Date(entry.timestamp);\n            if (entry.expiresAt) {\n              entry.expiresAt = new Date(entry.expiresAt);\n            }\n            this.entries.set(entry.id, entry);\n          }\n        }\n      }\n      \n      // Enforce retention policy after loading\n      this.enforceRetentionPolicy();\n      \n    } catch (error) {\n      SecurityMonitor.logSecurityEvent({\n        type: MEMORY_SECURITY_EVENTS.MEMORY_DESERIALIZE_FAILED,\n        severity: 'HIGH',\n        source: 'Memory.deserialize',\n        details: `Failed to deserialize memory: ${error}`\n      });\n      throw new Error(`Failed to deserialize memory: ${error}`);\n    }\n  }\n  \n  // Private helper methods\n  \n  private calculateExpiryDate(): Date {\n    const expiry = new Date();\n    expiry.setDate(expiry.getDate() + this.retentionDays);\n    return expiry;\n  }\n  \n  private sanitizeTags(tags: string[]): string[] {\n    // SECURITY FIX: Limit number of tags and sanitize each\n    const limitedTags = tags.slice(0, MEMORY_CONSTANTS.MAX_TAGS_PER_ENTRY);\n    \n    return limitedTags\n      .map(tag => {\n        const normalized = UnicodeValidator.normalize(tag).normalizedContent;\n        return sanitizeInput(normalized, MEMORY_CONSTANTS.MAX_TAG_LENGTH);\n      })\n      .filter(tag => tag && tag.length > 0);\n  }\n  \n  private sanitizeMetadata(metadata?: Record<string, any>): Record<string, any> | undefined {\n    if (!metadata) return undefined;\n    \n    // SECURITY FIX: Sanitize metadata values\n    const sanitized: Record<string, any> = {};\n    const maxKeys = MEMORY_CONSTANTS.MAX_METADATA_KEYS;\n    let keyCount = 0;\n    \n    for (const [key, value] of Object.entries(metadata)) {\n      if (keyCount >= maxKeys) break;\n      \n      const sanitizedKey = sanitizeInput(key, MEMORY_CONSTANTS.MAX_METADATA_KEY_LENGTH);\n      if (sanitizedKey && typeof value === 'string') {\n        sanitized[sanitizedKey] = sanitizeInput(value, MEMORY_CONSTANTS.MAX_METADATA_VALUE_LENGTH);\n        keyCount++;\n      } else if (sanitizedKey && typeof value === 'number') {\n        sanitized[sanitizedKey] = value;\n        keyCount++;\n      }\n      // Skip other types for security\n    }\n    \n    return sanitized;\n  }\n  \n  private canAccessPrivacyLevel(entryLevel: string, requestedLevel: string): boolean {\n    const levels = MEMORY_CONSTANTS.PRIVACY_LEVELS;\n    const entryIndex = levels.indexOf(entryLevel as PrivacyLevel);\n    const requestedIndex = levels.indexOf(requestedLevel as PrivacyLevel);\n    \n    // Can only access entries at or below the requested privacy level\n    // e.g., if requesting 'private', can see 'public' and 'private' but not 'sensitive'\n    return entryIndex <= requestedIndex;\n  }\n  \n  private isValidEntry(entry: any): boolean {\n    return entry &&\n      typeof entry.id === 'string' &&\n      typeof entry.content === 'string' &&\n      entry.timestamp &&\n      (!entry.tags || Array.isArray(entry.tags));\n  }\n}"]}

package/dist/elements/memories/MemoryManager.d.ts

@@ -0,0 +1,86 @@
+/**
+ * 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, MemoryMetadata } from './Memory.js';
+import { IElementManager } from '../../types/elements/IElementManager.js';
+import { ElementValidationResult } from '../../types/elements/IElement.js';
+import { ElementType } from '../../portfolio/types.js';
+export declare class MemoryManager implements IElementManager<Memory> {
+    private portfolioManager;
+    private memoriesDir;
+    private memoryCache;
+    constructor();
+    /**
+     * Load a memory 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<Memory>;
+    /**
+     * Save a memory to file
+     * SECURITY FIX #1: Uses FileLockManager.atomicWriteFile() for atomic operations
+     */
+    save(element: Memory, filePath: string): Promise<void>;
+    /**
+     * List all available memories
+     */
+    list(): Promise<Memory[]>;
+    /**
+     * Find memories matching a predicate
+     */
+    find(predicate: (element: Memory) => boolean): Promise<Memory | undefined>;
+    /**
+     * Find multiple memories matching a predicate
+     */
+    findMany(predicate: (element: Memory) => boolean): Promise<Memory[]>;
+    /**
+     * Delete a memory file
+     * SECURITY: Validates path and logs deletion
+     */
+    delete(filePath: string): Promise<void>;
+    /**
+     * Check if a memory file exists
+     */
+    exists(filePath: string): Promise<boolean>;
+    /**
+     * Create a new memory with metadata
+     */
+    create(metadata: Partial<MemoryMetadata>): Promise<Memory>;
+    /**
+     * Import a memory from JSON/YAML string
+     * SECURITY: Full validation of imported content
+     */
+    importElement(data: string, format?: 'json' | 'yaml'): Promise<Memory>;
+    /**
+     * Export a memory to YAML string
+     */
+    exportElement(element: Memory): Promise<string>;
+    /**
+     * Validate a memory element
+     */
+    validate(element: Memory): ElementValidationResult;
+    /**
+     * Validate and resolve a file path
+     * SECURITY: Prevents directory traversal attacks
+     */
+    validatePath(filePath: string): boolean;
+    /**
+     * Get the element type this manager handles
+     */
+    getElementType(): ElementType;
+    /**
+     * Get the file extension for memory files
+     */
+    getFileExtension(): string;
+    private validateAndResolvePath;
+    private parseMemoryFile;
+}
+//# sourceMappingURL=MemoryManager.d.ts.map

package/dist/elements/memories/MemoryManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MemoryManager.d.ts","sourceRoot":"","sources":["../../../src/elements/memories/MemoryManager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,MAAM,EAAE,cAAc,EAAe,MAAM,aAAa,CAAC;AAClE,OAAO,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAC1E,OAAO,EAAE,uBAAuB,EAAE,MAAM,kCAAkC,CAAC;AAC3E,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAYvD,qBAAa,aAAc,YAAW,eAAe,CAAC,MAAM,CAAC;IAC3D,OAAO,CAAC,gBAAgB,CAAmB;IAC3C,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,WAAW,CAAkC;;IAOrD;;;;OAIG;IACG,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAkE7C;;;OAGG;IACG,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAoE5D;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAiC/B;;OAEG;IACG,IAAI,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAKhF;;OAEG;IACG,QAAQ,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAK1E;;;OAGG;IACG,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA6B7C;;OAEG;IACG,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAUhD;;OAEG;IACG,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,cAAc,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAIhE;;;OAGG;IACG,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,MAAM,GAAG,MAAe,GAAG,OAAO,CAAC,MAAM,CAAC;IA0EpF;;OAEG;IACG,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAuBrD;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,uBAAuB;IAIlD;;;OAGG;IACH,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAqBvC;;OAEG;IACH,cAAc,IAAI,WAAW;IAI7B;;OAEG;IACH,gBAAgB,IAAI,MAAM;YAMZ,sBAAsB;IAgCpC,OAAO,CAAC,eAAe;CA0BxB"}