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