@dollhousemcp/mcp-server 1.3.0

package/dist/elements/agents/AgentManager.js

@@ -0,0 +1,615 @@
+/**
+ * AgentManager - Handles CRUD operations for Agent elements
+ * Follows patterns from PersonaElementManager and MemoryManager
+ *
+ * SECURITY: Uses FileLockManager for atomic operations and SecureYamlParser for safe YAML parsing
+ */
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import { Agent } from './Agent.js';
+import { ElementType } from '../../portfolio/types.js';
+import { FileLockManager } from '../../security/fileLockManager.js';
+import { SecureYamlParser } from '../../security/secureYamlParser.js';
+import * as yaml from 'js-yaml';
+import { sanitizeInput } from '../../security/InputValidator.js';
+import { UnicodeValidator } from '../../security/validators/unicodeValidator.js';
+import { SecurityMonitor } from '../../security/securityMonitor.js';
+import { logger } from '../../utils/logger.js';
+// Constants
+const AGENT_FILE_EXTENSION = '.md';
+const STATE_DIRECTORY = '.state';
+const STATE_FILE_EXTENSION = '.state.yaml';
+const MAX_FILE_SIZE = 100 * 1024; // 100KB
+const MAX_YAML_SIZE = 64 * 1024; // 64KB for frontmatter
+export class AgentManager {
+    agentsPath;
+    stateCache = new Map();
+    constructor(portfolioPath) {
+        this.agentsPath = path.join(portfolioPath, 'agents');
+    }
+    /**
+     * Initialize the agents directory structure
+     */
+    async initialize() {
+        try {
+            // Create agents directory if it doesn't exist
+            await fs.mkdir(this.agentsPath, { recursive: true });
+            // Create .state directory for agent states
+            const statePath = path.join(this.agentsPath, STATE_DIRECTORY);
+            await fs.mkdir(statePath, { recursive: true });
+            logger.info('AgentManager initialized', { path: this.agentsPath });
+        }
+        catch (error) {
+            logger.error('Failed to initialize AgentManager', error);
+            throw error;
+        }
+    }
+    /**
+     * Create a new agent
+     */
+    async create(name, description, content, metadata) {
+        try {
+            // Sanitize inputs
+            const sanitizedName = sanitizeInput(UnicodeValidator.normalize(name).normalizedContent, 100);
+            const sanitizedDescription = sanitizeInput(UnicodeValidator.normalize(description).normalizedContent, 500);
+            const sanitizedContent = sanitizeInput(UnicodeValidator.normalize(content).normalizedContent, 50000);
+            // Validate name
+            if (!this.validateElementName(sanitizedName)) {
+                return {
+                    success: false,
+                    message: 'Invalid agent name. Use only letters, numbers, hyphens, and underscores.'
+                };
+            }
+            // Check if agent already exists
+            const filename = this.getFilename(sanitizedName);
+            const filepath = path.join(this.agentsPath, filename);
+            // Create agent instance
+            const agent = new Agent({
+                name: sanitizedName,
+                description: sanitizedDescription,
+                ...metadata
+            });
+            // Set author
+            agent.metadata.author = this.getCurrentUserForAttribution();
+            // Prepare file content
+            const fileContent = this.serializeToFile(agent, sanitizedContent);
+            // SECURITY FIX: Use atomic file creation to prevent race conditions
+            // Previously: Used access() check followed by write, which could race
+            // Now: Use exclusive file creation that fails atomically if file exists
+            try {
+                const fd = await fs.open(filepath, 'wx'); // 'wx' = exclusive write, fails if exists
+                await fd.writeFile(fileContent, 'utf-8');
+                await fd.close();
+            }
+            catch (error) {
+                if (error.code === 'EEXIST') {
+                    return {
+                        success: false,
+                        message: `Agent '${sanitizedName}' already exists`
+                    };
+                }
+                throw error;
+            }
+            // Log security event
+            SecurityMonitor.logSecurityEvent({
+                type: 'ELEMENT_CREATED',
+                severity: 'LOW',
+                source: 'AgentManager.create',
+                details: `Agent '${sanitizedName}' created`,
+                additionalData: { agentId: agent.id }
+            });
+            logger.info(`Agent created: ${sanitizedName}`);
+            return {
+                success: true,
+                message: `🤖 **${sanitizedName}** by ${agent.metadata.author || 'anonymous'}`,
+                element: agent
+            };
+        }
+        catch (error) {
+            logger.error('Failed to create agent', error);
+            return {
+                success: false,
+                message: error instanceof Error ? error.message : 'Failed to create agent'
+            };
+        }
+    }
+    /**
+     * Read an agent by name
+     */
+    async read(name) {
+        try {
+            const sanitizedName = sanitizeInput(name, 100);
+            const filename = this.getFilename(sanitizedName);
+            const filepath = path.join(this.agentsPath, filename);
+            // Read file with lock
+            const content = await FileLockManager.atomicReadFile(filepath, { encoding: 'utf-8' });
+            // Check file size
+            if (content.length > MAX_FILE_SIZE) {
+                throw new Error(`Agent file exceeds maximum size of ${MAX_FILE_SIZE} bytes`);
+            }
+            // Parse file
+            const agentData = this.parseAgentFile(content);
+            // Create agent instance - ensure metadata is passed correctly
+            const agent = new Agent(agentData.metadata);
+            // Load state if available
+            const state = await this.loadAgentState(sanitizedName);
+            if (state) {
+                agent.deserialize(JSON.stringify({
+                    ...JSON.parse(agent.serialize()),
+                    state
+                }));
+            }
+            return agent;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return null;
+            }
+            logger.error(`Failed to read agent: ${name}`, error);
+            throw error;
+        }
+    }
+    /**
+     * Update an agent
+     */
+    async update(name, updates, content) {
+        try {
+            const agent = await this.read(name);
+            if (!agent) {
+                logger.warn(`Agent not found for update: ${name}`);
+                return false;
+            }
+            // Apply metadata updates
+            if (updates.description !== undefined) {
+                agent.metadata.description = sanitizeInput(UnicodeValidator.normalize(updates.description).normalizedContent, 500);
+            }
+            if (updates.specializations !== undefined) {
+                agent.extensions = {
+                    ...agent.extensions,
+                    specializations: updates.specializations.map((s) => sanitizeInput(s, 50))
+                };
+            }
+            if (updates.decisionFramework !== undefined) {
+                agent.extensions = {
+                    ...agent.extensions,
+                    decisionFramework: updates.decisionFramework
+                };
+            }
+            if (updates.riskTolerance !== undefined) {
+                agent.extensions = {
+                    ...agent.extensions,
+                    riskTolerance: updates.riskTolerance
+                };
+            }
+            // Update modification time
+            agent.metadata.modified = new Date().toISOString();
+            // Get current content if not provided
+            if (content === undefined) {
+                const filename = this.getFilename(name);
+                const filepath = path.join(this.agentsPath, filename);
+                const fileContent = await FileLockManager.atomicReadFile(filepath, { encoding: 'utf-8' });
+                const parsed = this.parseAgentFile(fileContent);
+                content = parsed.content;
+            }
+            // Save agent
+            const filename = this.getFilename(name);
+            const filepath = path.join(this.agentsPath, filename);
+            const fileContent = this.serializeToFile(agent, content);
+            await FileLockManager.atomicWriteFile(filepath, fileContent, { encoding: 'utf-8' });
+            // Save state if needed
+            if (agent.needsStatePersistence()) {
+                await this.saveAgentState(name, agent.getState());
+                agent.markStatePersisted();
+            }
+            logger.info(`Agent updated: ${name}`);
+            return true;
+        }
+        catch (error) {
+            logger.error(`Failed to update agent: ${name}`, error);
+            return false;
+        }
+    }
+    /**
+     * Delete an agent
+     */
+    async delete(name) {
+        try {
+            const sanitizedName = sanitizeInput(name, 100);
+            const filename = this.getFilename(sanitizedName);
+            const filepath = path.join(this.agentsPath, filename);
+            // Check if file exists
+            try {
+                await fs.access(filepath);
+            }
+            catch {
+                return;
+            }
+            // Delete main file
+            await fs.unlink(filepath);
+            // Delete state file if exists
+            const stateFilename = `${sanitizedName}${STATE_FILE_EXTENSION}`;
+            const stateFilepath = path.join(this.agentsPath, STATE_DIRECTORY, stateFilename);
+            try {
+                await fs.unlink(stateFilepath);
+                this.stateCache.delete(sanitizedName);
+            }
+            catch {
+                // State file might not exist
+            }
+            // Log security event
+            SecurityMonitor.logSecurityEvent({
+                type: 'ELEMENT_DELETED',
+                severity: 'MEDIUM',
+                source: 'AgentManager.delete',
+                details: `Agent '${sanitizedName}' deleted`
+            });
+            logger.info(`Agent deleted: ${sanitizedName}`);
+        }
+        catch (error) {
+            logger.error(`Failed to delete agent: ${name}`, error);
+            throw error;
+        }
+    }
+    /**
+     * List all agents
+     */
+    async list() {
+        try {
+            const files = await fs.readdir(this.agentsPath);
+            // Filter for agent files
+            const agentFiles = files.filter(file => file.endsWith(AGENT_FILE_EXTENSION) &&
+                !file.startsWith('.') &&
+                file !== STATE_DIRECTORY);
+            // Load all agents
+            const agents = [];
+            for (const file of agentFiles) {
+                const name = file.substring(0, file.length - AGENT_FILE_EXTENSION.length);
+                try {
+                    const agent = await this.read(name);
+                    if (agent) {
+                        agents.push(agent);
+                    }
+                }
+                catch (error) {
+                    logger.warn(`Failed to load agent ${name}:`, error);
+                }
+            }
+            return agents;
+        }
+        catch (error) {
+            // Handle missing directory gracefully with type-safe check
+            if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {
+                logger.debug('Agents directory does not exist yet, returning empty array');
+                return [];
+            }
+            logger.error('Failed to list agents', error);
+            return [];
+        }
+    }
+    /**
+     * Check if an agent exists
+     */
+    async exists(name) {
+        try {
+            const sanitizedName = sanitizeInput(name, 100);
+            const filename = this.getFilename(sanitizedName);
+            const filepath = path.join(this.agentsPath, filename);
+            await fs.access(filepath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Validate an agent name
+     */
+    validateName(name) {
+        if (!name || name.trim().length === 0) {
+            return { valid: false, error: 'Name cannot be empty' };
+        }
+        if (name.length > 100) {
+            return { valid: false, error: 'Name cannot exceed 100 characters' };
+        }
+        if (!this.validateElementName(name)) {
+            return {
+                valid: false,
+                error: 'Name can only contain letters, numbers, hyphens, and underscores'
+            };
+        }
+        return { valid: true };
+    }
+    /**
+     * Get element type
+     */
+    getElementType() {
+        return ElementType.AGENT;
+    }
+    /**
+     * Load agent state from file
+     */
+    async loadAgentState(name) {
+        try {
+            // Check cache first
+            if (this.stateCache.has(name)) {
+                return this.stateCache.get(name);
+            }
+            const stateFilename = `${name}${STATE_FILE_EXTENSION}`;
+            const stateFilepath = path.join(this.agentsPath, STATE_DIRECTORY, stateFilename);
+            const content = await FileLockManager.atomicReadFile(stateFilepath, { encoding: 'utf-8' });
+            // Parse YAML safely
+            const parsedContent = SecureYamlParser.parse(content, {
+                maxYamlSize: MAX_YAML_SIZE,
+                validateContent: true
+            });
+            const state = parsedContent.data;
+            // Convert string numbers back to numbers
+            if (state.sessionCount !== undefined) {
+                state.sessionCount = parseInt(state.sessionCount, 10);
+            }
+            // Convert goal numbers
+            if (state.goals) {
+                state.goals.forEach((goal) => {
+                    if (goal.importance !== undefined)
+                        goal.importance = parseInt(goal.importance, 10);
+                    if (goal.urgency !== undefined)
+                        goal.urgency = parseInt(goal.urgency, 10);
+                    if (goal.estimatedEffort !== undefined)
+                        goal.estimatedEffort = parseFloat(goal.estimatedEffort);
+                });
+            }
+            // Convert decision confidence
+            if (state.decisions) {
+                state.decisions.forEach((decision) => {
+                    if (decision.confidence !== undefined)
+                        decision.confidence = parseFloat(decision.confidence);
+                });
+            }
+            // Cache the state
+            this.stateCache.set(name, state);
+            return state;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return null;
+            }
+            logger.error(`Failed to load agent state: ${name}`, error);
+            return null;
+        }
+    }
+    /**
+     * Save agent state to file
+     */
+    async saveAgentState(name, state) {
+        try {
+            const stateFilename = `${name}${STATE_FILE_EXTENSION}`;
+            const stateFilepath = path.join(this.agentsPath, STATE_DIRECTORY, stateFilename);
+            // Convert dates to ISO strings and numbers to strings for FAILSAFE_SCHEMA
+            const serializedState = {
+                ...state,
+                lastActive: state.lastActive instanceof Date ? state.lastActive.toISOString() : state.lastActive,
+                sessionCount: String(state.sessionCount),
+                goals: state.goals.map(goal => ({
+                    ...goal,
+                    createdAt: goal.createdAt instanceof Date ? goal.createdAt.toISOString() : goal.createdAt,
+                    updatedAt: goal.updatedAt instanceof Date ? goal.updatedAt.toISOString() : goal.updatedAt,
+                    completedAt: goal.completedAt instanceof Date ? goal.completedAt.toISOString() : goal.completedAt,
+                    importance: goal.importance !== undefined ? String(goal.importance) : undefined,
+                    urgency: goal.urgency !== undefined ? String(goal.urgency) : undefined,
+                    estimatedEffort: goal.estimatedEffort !== undefined ? String(goal.estimatedEffort) : undefined
+                })),
+                decisions: state.decisions.map(decision => ({
+                    ...decision,
+                    timestamp: decision.timestamp instanceof Date ? decision.timestamp.toISOString() : decision.timestamp,
+                    confidence: decision.confidence !== undefined ? String(decision.confidence) : undefined
+                }))
+            };
+            // Convert state to YAML
+            const yamlContent = yaml.dump(serializedState, {
+                schema: yaml.FAILSAFE_SCHEMA,
+                noRefs: true,
+                sortKeys: true
+            });
+            // Validate size
+            if (yamlContent.length > MAX_YAML_SIZE) {
+                throw new Error(`State size exceeds maximum of ${MAX_YAML_SIZE} bytes`);
+            }
+            // Write atomically
+            await FileLockManager.atomicWriteFile(stateFilepath, yamlContent, { encoding: 'utf-8' });
+            // Update cache
+            this.stateCache.set(name, state);
+            logger.debug(`Agent state saved: ${name}`);
+        }
+        catch (error) {
+            logger.error(`Failed to save agent state: ${name}`, error);
+            throw error;
+        }
+    }
+    /**
+     * Parse agent file content
+     */
+    parseAgentFile(content) {
+        // Extract frontmatter and content
+        const frontmatterRegex = /^---\n([\s\S]*?)\n---\n([\s\S]*)$/;
+        const match = content.match(frontmatterRegex);
+        if (!match) {
+            throw new Error('Invalid agent file format - missing frontmatter');
+        }
+        const [, frontmatter, body] = match;
+        // Parse frontmatter - SecureYamlParser expects full content with frontmatter markers
+        // but we're passing just the YAML content, so we need to parse it directly
+        const parsedYaml = SecureYamlParser.parse(`---\n${frontmatter}\n---`, {
+            maxYamlSize: MAX_YAML_SIZE,
+            validateContent: false // We'll validate body separately
+        });
+        const metadata = parsedYaml.data;
+        // Validate type if using the typed metadata
+        const typedMetadata = metadata;
+        if (typedMetadata.type && typedMetadata.type !== ElementType.AGENT && typedMetadata.type !== 'agent') {
+            throw new Error(`Invalid element type: expected '${ElementType.AGENT}', got '${typedMetadata.type}'`);
+        }
+        return {
+            metadata,
+            content: body.trim()
+        };
+    }
+    /**
+     * Serialize agent to file format
+     */
+    serializeToFile(agent, content) {
+        const metadata = {
+            name: agent.metadata.name,
+            type: ElementType.AGENT,
+            version: agent.metadata.version,
+            author: agent.metadata.author,
+            created: agent.metadata.created || new Date().toISOString(),
+            modified: agent.metadata.modified || new Date().toISOString(),
+            description: agent.metadata.description,
+            decisionFramework: agent.extensions?.decisionFramework,
+            riskTolerance: agent.extensions?.riskTolerance,
+            learningEnabled: agent.extensions?.learningEnabled !== undefined ?
+                String(agent.extensions.learningEnabled) : undefined,
+            maxConcurrentGoals: agent.metadata.maxConcurrentGoals,
+            specializations: agent.extensions?.specializations
+        };
+        // Remove undefined values
+        Object.keys(metadata).forEach(key => {
+            if (metadata[key] === undefined) {
+                delete metadata[key];
+            }
+        });
+        const yamlContent = yaml.dump(metadata, {
+            schema: yaml.FAILSAFE_SCHEMA,
+            noRefs: true,
+            sortKeys: true
+        });
+        return `---\n${yamlContent}---\n\n${content}`;
+    }
+    /**
+     * Get filename for agent
+     */
+    getFilename(name) {
+        return `${name}${AGENT_FILE_EXTENSION}`;
+    }
+    /**
+     * Validate element name
+     */
+    validateElementName(name) {
+        // Only letters, numbers, hyphens, and underscores
+        return /^[a-zA-Z0-9_-]+$/.test(name);
+    }
+    /**
+     * Get current user for attribution
+     */
+    getCurrentUserForAttribution() {
+        return process.env.DOLLHOUSE_USER || 'anonymous';
+    }
+    /**
+     * Find an agent by predicate
+     */
+    async find(predicate) {
+        const agents = await this.list();
+        return agents.find(predicate);
+    }
+    /**
+     * Find many agents by predicate
+     */
+    async findMany(predicate) {
+        const agents = await this.list();
+        return agents.filter(predicate);
+    }
+    /**
+     * Validate an agent
+     */
+    validate(element) {
+        return element.validate();
+    }
+    /**
+     * Validate a path
+     */
+    validatePath(path) {
+        // Check for path traversal
+        if (path.includes('..') || path.includes('~')) {
+            return false;
+        }
+        // Check for absolute paths
+        if (path.startsWith('/') || path.match(/^[A-Za-z]:/)) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Get file extension
+     */
+    getFileExtension() {
+        return AGENT_FILE_EXTENSION;
+    }
+    /**
+     * Import an agent from data
+     */
+    async importElement(data, format) {
+        if (format === 'json') {
+            const parsed = JSON.parse(data);
+            const agent = new Agent(parsed.metadata);
+            if (parsed.state) {
+                agent.deserialize(JSON.stringify(parsed));
+            }
+            return agent;
+        }
+        else {
+            // Parse as markdown with YAML frontmatter
+            const agentData = this.parseAgentFile(data);
+            const agent = new Agent(agentData.metadata);
+            if (agentData.state) {
+                agent.deserialize(JSON.stringify({
+                    ...JSON.parse(agent.serialize()),
+                    state: agentData.state
+                }));
+            }
+            return agent;
+        }
+    }
+    /**
+     * Export an agent to a format
+     */
+    async exportElement(element, format) {
+        if (format === 'json') {
+            return element.serialize();
+        }
+        else {
+            // Export as markdown with YAML frontmatter
+            const content = `# ${element.metadata.name}\n\n${element.metadata.description || ''}`;
+            return this.serializeToFile(element, content);
+        }
+    }
+    /**
+     * Save an agent to a specific path
+     */
+    async save(element, targetPath) {
+        const name = targetPath.replace(AGENT_FILE_EXTENSION, '');
+        const content = `# ${element.metadata.name}\n\n${element.metadata.description || ''}`;
+        // Save the agent file
+        const filename = this.getFilename(name);
+        const filepath = path.isAbsolute(targetPath) ? targetPath : path.join(this.agentsPath, filename);
+        const fileContent = this.serializeToFile(element, content);
+        await FileLockManager.atomicWriteFile(filepath, fileContent, { encoding: 'utf-8' });
+        // Save state if needed
+        if (element.needsStatePersistence()) {
+            await this.saveAgentState(name, element.getState());
+            element.markStatePersisted();
+        }
+    }
+    /**
+     * Load an agent from a specific path
+     */
+    async load(targetPath) {
+        const agent = await this.read(targetPath.replace(AGENT_FILE_EXTENSION, ''));
+        if (!agent) {
+            // SECURITY FIX #206: Don't expose file paths in error messages
+            logger.error('Agent not found', { path: targetPath });
+            throw new Error('Agent not found');
+        }
+        return agent;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"AgentManager.js","sourceRoot":"","sources":["../../../src/elements/agents/AgentManager.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * AgentManager - Handles CRUD operations for Agent elements\n * Follows patterns from PersonaElementManager and MemoryManager\n * \n * SECURITY: Uses FileLockManager for atomic operations and SecureYamlParser for safe YAML parsing\n */\n\nimport { promises as fs } from 'fs';\nimport * as path from 'path';\nimport { Agent } from './Agent.js';\nimport { AgentMetadata, AgentState } from './types.js';\nimport { IElementManager, ElementValidationResult } from '../../types/elements/index.js';\nimport { ElementType } from '../../portfolio/types.js';\nimport { FileLockManager } from '../../security/fileLockManager.js';\nimport { SecureYamlParser } from '../../security/secureYamlParser.js';\nimport * as yaml from 'js-yaml';\nimport { sanitizeInput } from '../../security/InputValidator.js';\nimport { UnicodeValidator } from '../../security/validators/unicodeValidator.js';\nimport { SecurityMonitor } from '../../security/securityMonitor.js';\nimport { logger } from '../../utils/logger.js';\n\n// Constants\nconst AGENT_FILE_EXTENSION = '.md';\nconst STATE_DIRECTORY = '.state';\nconst STATE_FILE_EXTENSION = '.state.yaml';\nconst MAX_FILE_SIZE = 100 * 1024; // 100KB\nconst MAX_YAML_SIZE = 64 * 1024; // 64KB for frontmatter\n\n// Element creation result interface\ninterface ElementCreationResult {\n  success: boolean;\n  message: string;\n  element?: Agent;\n}\n\ninterface AgentFileData {\n  metadata: AgentMetadata;\n  content: string;\n  state?: AgentState;\n}\n\nexport class AgentManager implements IElementManager<Agent> {\n  private readonly agentsPath: string;\n  private readonly stateCache: Map<string, AgentState> = new Map();\n\n  constructor(portfolioPath: string) {\n    this.agentsPath = path.join(portfolioPath, 'agents');\n  }\n\n  /**\n   * Initialize the agents directory structure\n   */\n  public async initialize(): Promise<void> {\n    try {\n      // Create agents directory if it doesn't exist\n      await fs.mkdir(this.agentsPath, { recursive: true });\n      \n      // Create .state directory for agent states\n      const statePath = path.join(this.agentsPath, STATE_DIRECTORY);\n      await fs.mkdir(statePath, { recursive: true });\n      \n      logger.info('AgentManager initialized', { path: this.agentsPath });\n    } catch (error) {\n      logger.error('Failed to initialize AgentManager', error);\n      throw error;\n    }\n  }\n\n  /**\n   * Create a new agent\n   */\n  public async create(\n    name: string,\n    description: string,\n    content: string,\n    metadata?: Partial<AgentMetadata>\n  ): Promise<ElementCreationResult> {\n    try {\n      // Sanitize inputs\n      const sanitizedName = sanitizeInput(UnicodeValidator.normalize(name).normalizedContent, 100);\n      const sanitizedDescription = sanitizeInput(UnicodeValidator.normalize(description).normalizedContent, 500);\n      const sanitizedContent = sanitizeInput(UnicodeValidator.normalize(content).normalizedContent, 50000);\n\n      // Validate name\n      if (!this.validateElementName(sanitizedName)) {\n        return {\n          success: false,\n          message: 'Invalid agent name. Use only letters, numbers, hyphens, and underscores.'\n        };\n      }\n\n      // Check if agent already exists\n      const filename = this.getFilename(sanitizedName);\n      const filepath = path.join(this.agentsPath, filename);\n\n      // Create agent instance\n      const agent = new Agent({\n        name: sanitizedName,\n        description: sanitizedDescription,\n        ...metadata\n      });\n\n      // Set author\n      agent.metadata.author = this.getCurrentUserForAttribution();\n\n      // Prepare file content\n      const fileContent = this.serializeToFile(agent, sanitizedContent);\n\n      // SECURITY FIX: Use atomic file creation to prevent race conditions\n      // Previously: Used access() check followed by write, which could race\n      // Now: Use exclusive file creation that fails atomically if file exists\n      try {\n        const fd = await fs.open(filepath, 'wx'); // 'wx' = exclusive write, fails if exists\n        await fd.writeFile(fileContent, 'utf-8');\n        await fd.close();\n      } catch (error: any) {\n        if (error.code === 'EEXIST') {\n          return {\n            success: false,\n            message: `Agent '${sanitizedName}' already exists`\n          };\n        }\n        throw error;\n      }\n\n      // Log security event\n      SecurityMonitor.logSecurityEvent({\n        type: 'ELEMENT_CREATED',\n        severity: 'LOW',\n        source: 'AgentManager.create',\n        details: `Agent '${sanitizedName}' created`,\n        additionalData: { agentId: agent.id }\n      });\n\n      logger.info(`Agent created: ${sanitizedName}`);\n      \n      return {\n        success: true,\n        message: `🤖 **${sanitizedName}** by ${agent.metadata.author || 'anonymous'}`,\n        element: agent\n      };\n    } catch (error) {\n      logger.error('Failed to create agent', error);\n      return {\n        success: false,\n        message: error instanceof Error ? error.message : 'Failed to create agent'\n      };\n    }\n  }\n\n  /**\n   * Read an agent by name\n   */\n  public async read(name: string): Promise<Agent | null> {\n    try {\n      const sanitizedName = sanitizeInput(name, 100);\n      const filename = this.getFilename(sanitizedName);\n      const filepath = path.join(this.agentsPath, filename);\n\n      // Read file with lock\n      const content = await FileLockManager.atomicReadFile(filepath, { encoding: 'utf-8' });\n      \n      // Check file size\n      if (content.length > MAX_FILE_SIZE) {\n        throw new Error(`Agent file exceeds maximum size of ${MAX_FILE_SIZE} bytes`);\n      }\n\n      // Parse file\n      const agentData = this.parseAgentFile(content);\n      \n      // Create agent instance - ensure metadata is passed correctly\n      const agent = new Agent(agentData.metadata);\n      \n      // Load state if available\n      const state = await this.loadAgentState(sanitizedName);\n      if (state) {\n        agent.deserialize(JSON.stringify({\n          ...JSON.parse(agent.serialize()),\n          state\n        }));\n      }\n\n      return agent;\n    } catch (error) {\n      if ((error as any).code === 'ENOENT') {\n        return null;\n      }\n      logger.error(`Failed to read agent: ${name}`, error);\n      throw error;\n    }\n  }\n\n  /**\n   * Update an agent\n   */\n  public async update(\n    name: string,\n    updates: Partial<AgentMetadata>,\n    content?: string\n  ): Promise<boolean> {\n    try {\n      const agent = await this.read(name);\n      if (!agent) {\n        logger.warn(`Agent not found for update: ${name}`);\n        return false;\n      }\n\n      // Apply metadata updates\n      if (updates.description !== undefined) {\n        agent.metadata.description = sanitizeInput(\n          UnicodeValidator.normalize(updates.description).normalizedContent,\n          500\n        );\n      }\n\n      if (updates.specializations !== undefined) {\n        agent.extensions = {\n          ...agent.extensions,\n          specializations: updates.specializations.map((s: string) => sanitizeInput(s, 50))\n        };\n      }\n\n      if (updates.decisionFramework !== undefined) {\n        agent.extensions = {\n          ...agent.extensions,\n          decisionFramework: updates.decisionFramework\n        };\n      }\n\n      if (updates.riskTolerance !== undefined) {\n        agent.extensions = {\n          ...agent.extensions,\n          riskTolerance: updates.riskTolerance\n        };\n      }\n\n      // Update modification time\n      agent.metadata.modified = new Date().toISOString();\n\n      // Get current content if not provided\n      if (content === undefined) {\n        const filename = this.getFilename(name);\n        const filepath = path.join(this.agentsPath, filename);\n        const fileContent = await FileLockManager.atomicReadFile(filepath, { encoding: 'utf-8' });\n        const parsed = this.parseAgentFile(fileContent);\n        content = parsed.content;\n      }\n\n      // Save agent\n      const filename = this.getFilename(name);\n      const filepath = path.join(this.agentsPath, filename);\n      const fileContent = this.serializeToFile(agent, content);\n      \n      await FileLockManager.atomicWriteFile(filepath, fileContent, { encoding: 'utf-8' });\n\n      // Save state if needed\n      if (agent.needsStatePersistence()) {\n        await this.saveAgentState(name, agent.getState());\n        agent.markStatePersisted();\n      }\n\n      logger.info(`Agent updated: ${name}`);\n      return true;\n    } catch (error) {\n      logger.error(`Failed to update agent: ${name}`, error);\n      return false;\n    }\n  }\n\n  /**\n   * Delete an agent\n   */\n  public async delete(name: string): Promise<void> {\n    try {\n      const sanitizedName = sanitizeInput(name, 100);\n      const filename = this.getFilename(sanitizedName);\n      const filepath = path.join(this.agentsPath, filename);\n\n      // Check if file exists\n      try {\n        await fs.access(filepath);\n      } catch {\n        return;\n      }\n\n      // Delete main file\n      await fs.unlink(filepath);\n\n      // Delete state file if exists\n      const stateFilename = `${sanitizedName}${STATE_FILE_EXTENSION}`;\n      const stateFilepath = path.join(this.agentsPath, STATE_DIRECTORY, stateFilename);\n      try {\n        await fs.unlink(stateFilepath);\n        this.stateCache.delete(sanitizedName);\n      } catch {\n        // State file might not exist\n      }\n\n      // Log security event\n      SecurityMonitor.logSecurityEvent({\n        type: 'ELEMENT_DELETED',\n        severity: 'MEDIUM',\n        source: 'AgentManager.delete',\n        details: `Agent '${sanitizedName}' deleted`\n      });\n\n      logger.info(`Agent deleted: ${sanitizedName}`);\n    } catch (error) {\n      logger.error(`Failed to delete agent: ${name}`, error);\n      throw error;\n    }\n  }\n\n  /**\n   * List all agents\n   */\n  public async list(): Promise<Agent[]> {\n    try {\n      const files = await fs.readdir(this.agentsPath);\n      \n      // Filter for agent files\n      const agentFiles = files.filter(file => \n        file.endsWith(AGENT_FILE_EXTENSION) && \n        !file.startsWith('.') &&\n        file !== STATE_DIRECTORY\n      );\n\n      // Load all agents\n      const agents: Agent[] = [];\n      for (const file of agentFiles) {\n        const name = file.substring(0, file.length - AGENT_FILE_EXTENSION.length);\n        try {\n          const agent = await this.read(name);\n          if (agent) {\n            agents.push(agent);\n          }\n        } catch (error) {\n          logger.warn(`Failed to load agent ${name}:`, error);\n        }\n      }\n      return agents;\n    } catch (error) {\n      // Handle missing directory gracefully with type-safe check\n      if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {\n        logger.debug('Agents directory does not exist yet, returning empty array');\n        return [];\n      }\n      logger.error('Failed to list agents', error);\n      return [];\n    }\n  }\n\n  /**\n   * Check if an agent exists\n   */\n  public async exists(name: string): Promise<boolean> {\n    try {\n      const sanitizedName = sanitizeInput(name, 100);\n      const filename = this.getFilename(sanitizedName);\n      const filepath = path.join(this.agentsPath, filename);\n      \n      await fs.access(filepath);\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  /**\n   * Validate an agent name\n   */\n  public validateName(name: string): { valid: boolean; error?: string } {\n    if (!name || name.trim().length === 0) {\n      return { valid: false, error: 'Name cannot be empty' };\n    }\n\n    if (name.length > 100) {\n      return { valid: false, error: 'Name cannot exceed 100 characters' };\n    }\n\n    if (!this.validateElementName(name)) {\n      return { \n        valid: false, \n        error: 'Name can only contain letters, numbers, hyphens, and underscores' \n      };\n    }\n\n    return { valid: true };\n  }\n\n  /**\n   * Get element type\n   */\n  public getElementType(): ElementType {\n    return ElementType.AGENT;\n  }\n\n  /**\n   * Load agent state from file\n   */\n  private async loadAgentState(name: string): Promise<AgentState | null> {\n    try {\n      // Check cache first\n      if (this.stateCache.has(name)) {\n        return this.stateCache.get(name)!;\n      }\n\n      const stateFilename = `${name}${STATE_FILE_EXTENSION}`;\n      const stateFilepath = path.join(this.agentsPath, STATE_DIRECTORY, stateFilename);\n\n      const content = await FileLockManager.atomicReadFile(stateFilepath, { encoding: 'utf-8' });\n      \n      // Parse YAML safely\n      const parsedContent = SecureYamlParser.parse(content, {\n        maxYamlSize: MAX_YAML_SIZE,\n        validateContent: true\n      });\n      const state = parsedContent.data as any;\n      \n      // Convert string numbers back to numbers\n      if (state.sessionCount !== undefined) {\n        state.sessionCount = parseInt(state.sessionCount, 10);\n      }\n      \n      // Convert goal numbers\n      if (state.goals) {\n        state.goals.forEach((goal: any) => {\n          if (goal.importance !== undefined) goal.importance = parseInt(goal.importance, 10);\n          if (goal.urgency !== undefined) goal.urgency = parseInt(goal.urgency, 10);\n          if (goal.estimatedEffort !== undefined) goal.estimatedEffort = parseFloat(goal.estimatedEffort);\n        });\n      }\n      \n      // Convert decision confidence\n      if (state.decisions) {\n        state.decisions.forEach((decision: any) => {\n          if (decision.confidence !== undefined) decision.confidence = parseFloat(decision.confidence);\n        });\n      }\n\n      // Cache the state\n      this.stateCache.set(name, state);\n\n      return state;\n    } catch (error) {\n      if ((error as any).code === 'ENOENT') {\n        return null;\n      }\n      logger.error(`Failed to load agent state: ${name}`, error);\n      return null;\n    }\n  }\n\n  /**\n   * Save agent state to file\n   */\n  public async saveAgentState(name: string, state: AgentState): Promise<void> {\n    try {\n      const stateFilename = `${name}${STATE_FILE_EXTENSION}`;\n      const stateFilepath = path.join(this.agentsPath, STATE_DIRECTORY, stateFilename);\n\n      // Convert dates to ISO strings and numbers to strings for FAILSAFE_SCHEMA\n      const serializedState = {\n        ...state,\n        lastActive: state.lastActive instanceof Date ? state.lastActive.toISOString() : state.lastActive,\n        sessionCount: String(state.sessionCount),\n        goals: state.goals.map(goal => ({\n          ...goal,\n          createdAt: goal.createdAt instanceof Date ? goal.createdAt.toISOString() : goal.createdAt,\n          updatedAt: goal.updatedAt instanceof Date ? goal.updatedAt.toISOString() : goal.updatedAt,\n          completedAt: goal.completedAt instanceof Date ? goal.completedAt.toISOString() : goal.completedAt,\n          importance: goal.importance !== undefined ? String(goal.importance) : undefined,\n          urgency: goal.urgency !== undefined ? String(goal.urgency) : undefined,\n          estimatedEffort: goal.estimatedEffort !== undefined ? String(goal.estimatedEffort) : undefined\n        })),\n        decisions: state.decisions.map(decision => ({\n          ...decision,\n          timestamp: decision.timestamp instanceof Date ? decision.timestamp.toISOString() : decision.timestamp,\n          confidence: decision.confidence !== undefined ? String(decision.confidence) : undefined\n        }))\n      };\n\n      // Convert state to YAML\n      const yamlContent = yaml.dump(serializedState, {\n        schema: yaml.FAILSAFE_SCHEMA,\n        noRefs: true,\n        sortKeys: true\n      });\n\n      // Validate size\n      if (yamlContent.length > MAX_YAML_SIZE) {\n        throw new Error(`State size exceeds maximum of ${MAX_YAML_SIZE} bytes`);\n      }\n\n      // Write atomically\n      await FileLockManager.atomicWriteFile(stateFilepath, yamlContent, { encoding: 'utf-8' });\n\n      // Update cache\n      this.stateCache.set(name, state);\n\n      logger.debug(`Agent state saved: ${name}`);\n    } catch (error) {\n      logger.error(`Failed to save agent state: ${name}`, error);\n      throw error;\n    }\n  }\n\n  /**\n   * Parse agent file content\n   */\n  private parseAgentFile(content: string): AgentFileData {\n    // Extract frontmatter and content\n    const frontmatterRegex = /^---\\n([\\s\\S]*?)\\n---\\n([\\s\\S]*)$/;\n    const match = content.match(frontmatterRegex);\n\n    if (!match) {\n      throw new Error('Invalid agent file format - missing frontmatter');\n    }\n\n    const [, frontmatter, body] = match;\n\n    // Parse frontmatter - SecureYamlParser expects full content with frontmatter markers\n    // but we're passing just the YAML content, so we need to parse it directly\n    const parsedYaml = SecureYamlParser.parse(`---\\n${frontmatter}\\n---`, {\n      maxYamlSize: MAX_YAML_SIZE,\n      validateContent: false  // We'll validate body separately\n    });\n    const metadata = parsedYaml.data as unknown as AgentMetadata;\n\n    // Validate type if using the typed metadata\n    const typedMetadata = metadata as any;\n    if (typedMetadata.type && typedMetadata.type !== ElementType.AGENT && typedMetadata.type !== 'agent') {\n      throw new Error(`Invalid element type: expected '${ElementType.AGENT}', got '${typedMetadata.type}'`);\n    }\n\n    return {\n      metadata,\n      content: body.trim()\n    };\n  }\n\n  /**\n   * Serialize agent to file format\n   */\n  private serializeToFile(agent: Agent, content: string): string {\n    const metadata: any = {\n      name: agent.metadata.name,\n      type: ElementType.AGENT,\n      version: agent.metadata.version,\n      author: agent.metadata.author,\n      created: agent.metadata.created || new Date().toISOString(),\n      modified: agent.metadata.modified || new Date().toISOString(),\n      description: agent.metadata.description,\n      decisionFramework: agent.extensions?.decisionFramework,\n      riskTolerance: agent.extensions?.riskTolerance,\n      learningEnabled: agent.extensions?.learningEnabled !== undefined ? \n        String(agent.extensions.learningEnabled) : undefined,\n      maxConcurrentGoals: (agent.metadata as AgentMetadata).maxConcurrentGoals,\n      specializations: agent.extensions?.specializations\n    };\n\n    // Remove undefined values\n    Object.keys(metadata).forEach(key => {\n      if (metadata[key as keyof typeof metadata] === undefined) {\n        delete metadata[key as keyof typeof metadata];\n      }\n    });\n\n    const yamlContent = yaml.dump(metadata, {\n      schema: yaml.FAILSAFE_SCHEMA,\n      noRefs: true,\n      sortKeys: true\n    });\n    \n    return `---\\n${yamlContent}---\\n\\n${content}`;\n  }\n\n  /**\n   * Get filename for agent\n   */\n  private getFilename(name: string): string {\n    return `${name}${AGENT_FILE_EXTENSION}`;\n  }\n\n  /**\n   * Validate element name\n   */\n  private validateElementName(name: string): boolean {\n    // Only letters, numbers, hyphens, and underscores\n    return /^[a-zA-Z0-9_-]+$/.test(name);\n  }\n\n  /**\n   * Get current user for attribution\n   */\n  private getCurrentUserForAttribution(): string {\n    return process.env.DOLLHOUSE_USER || 'anonymous';\n  }\n\n  /**\n   * Find an agent by predicate\n   */\n  public async find(predicate: (element: Agent) => boolean): Promise<Agent | undefined> {\n    const agents = await this.list();\n    return agents.find(predicate);\n  }\n\n  /**\n   * Find many agents by predicate\n   */\n  public async findMany(predicate: (element: Agent) => boolean): Promise<Agent[]> {\n    const agents = await this.list();\n    return agents.filter(predicate);\n  }\n\n  /**\n   * Validate an agent\n   */\n  public validate(element: Agent): ElementValidationResult {\n    return element.validate();\n  }\n\n  /**\n   * Validate a path\n   */\n  public validatePath(path: string): boolean {\n    // Check for path traversal\n    if (path.includes('..') || path.includes('~')) {\n      return false;\n    }\n    // Check for absolute paths\n    if (path.startsWith('/') || path.match(/^[A-Za-z]:/)) {\n      return false;\n    }\n    return true;\n  }\n\n  /**\n   * Get file extension\n   */\n  public getFileExtension(): string {\n    return AGENT_FILE_EXTENSION;\n  }\n\n  /**\n   * Import an agent from data\n   */\n  public async importElement(data: string, format?: 'json' | 'yaml' | 'markdown'): Promise<Agent> {\n    if (format === 'json') {\n      const parsed = JSON.parse(data);\n      const agent = new Agent(parsed.metadata);\n      if (parsed.state) {\n        agent.deserialize(JSON.stringify(parsed));\n      }\n      return agent;\n    } else {\n      // Parse as markdown with YAML frontmatter\n      const agentData = this.parseAgentFile(data);\n      const agent = new Agent(agentData.metadata);\n      if (agentData.state) {\n        agent.deserialize(JSON.stringify({\n          ...JSON.parse(agent.serialize()),\n          state: agentData.state\n        }));\n      }\n      return agent;\n    }\n  }\n\n  /**\n   * Export an agent to a format\n   */\n  public async exportElement(element: Agent, format?: 'json' | 'yaml' | 'markdown'): Promise<string> {\n    if (format === 'json') {\n      return element.serialize();\n    } else {\n      // Export as markdown with YAML frontmatter\n      const content = `# ${element.metadata.name}\\n\\n${element.metadata.description || ''}`;\n      return this.serializeToFile(element, content);\n    }\n  }\n\n  /**\n   * Save an agent to a specific path\n   */\n  public async save(element: Agent, targetPath: string): Promise<void> {\n    const name = targetPath.replace(AGENT_FILE_EXTENSION, '');\n    const content = `# ${element.metadata.name}\\n\\n${element.metadata.description || ''}`;\n    \n    // Save the agent file\n    const filename = this.getFilename(name);\n    const filepath = path.isAbsolute(targetPath) ? targetPath : path.join(this.agentsPath, filename);\n    const fileContent = this.serializeToFile(element, content);\n    await FileLockManager.atomicWriteFile(filepath, fileContent, { encoding: 'utf-8' });\n\n    // Save state if needed\n    if (element.needsStatePersistence()) {\n      await this.saveAgentState(name, element.getState());\n      element.markStatePersisted();\n    }\n  }\n\n  /**\n   * Load an agent from a specific path\n   */\n  public async load(targetPath: string): Promise<Agent> {\n    const agent = await this.read(targetPath.replace(AGENT_FILE_EXTENSION, ''));\n    if (!agent) {\n      // SECURITY FIX #206: Don't expose file paths in error messages\n      logger.error('Agent not found', { path: targetPath });\n      throw new Error('Agent not found');\n    }\n    return agent;\n  }\n}"]}