@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.
226 lines • 27.5 kB
JavaScript
/**
* ElementFileOperations - Common file operations for element managers
*
* Provides shared file handling operations for all element types:
* - Reading files with frontmatter parsing
* - Writing files with atomic operations
* - Directory scanning and filtering
*
* SECURITY: All operations use FileLockManager for atomic reads/writes
* PATH VALIDATION: All paths are validated before file operations
* LOGGING: Operations are logged for debugging and audit trail
*/
import { sanitizeInput, validatePath } from '../../security/InputValidator.js';
import { SecurityMonitor } from '../../security/securityMonitor.js';
import { logger } from '../../utils/logger.js';
import { promises as fs } from 'fs';
import * as path from 'path';
import matter from 'gray-matter';
/**
* Utility class for common file operations
* Used by BaseElementManager and can be used by other managers
*
* DEPENDENCY INJECTION: Requires FileLockManager instance for atomic operations
*/
export class ElementFileOperations {
fileLockManager;
/**
* Constructor - accepts FileLockManager for atomic operations
* @param fileLockManager - FileLockManager instance for atomic file operations
*/
constructor(fileLockManager) {
this.fileLockManager = fileLockManager;
}
/**
* Atomically read a file with frontmatter
* SECURITY: Uses FileLockManager to prevent race conditions
*
* @param filePath - Absolute or relative path to file
* @param baseDir - Base directory for validation
* @param options - Operation options
* @returns Parsed file with metadata and content
*/
async readFileWithFrontmatter(filePath, baseDir, options = {}) {
const { maxSize = 1024 * 1024, // 1MB default
validatePath: shouldValidatePath = true } = options;
// SECURITY: Sanitize path
const sanitizedPath = sanitizeInput(filePath, 255);
// Validate path if requested
if (shouldValidatePath) {
try {
validatePath(sanitizedPath, baseDir);
}
catch (error) {
throw new Error(`Invalid file path: ${error instanceof Error ? error.message : 'Invalid path'}`);
}
}
// Resolve full path
const fullPath = path.isAbsolute(sanitizedPath)
? sanitizedPath
: path.join(baseDir, sanitizedPath);
// Check file size before reading
const stats = await fs.stat(fullPath);
if (stats.size > maxSize) {
throw new Error(`File too large: ${stats.size} bytes (max: ${maxSize})`);
}
// CRITICAL FIX: Use atomic file read via injected instance
const raw = await this.fileLockManager.atomicReadFile(fullPath, { encoding: 'utf-8' });
// Parse frontmatter
const parsed = matter(raw);
return {
metadata: parsed.data,
content: parsed.content,
raw
};
}
/**
* Atomically write a file with frontmatter
* SECURITY: Uses FileLockManager to prevent corruption
*
* @param filePath - Absolute or relative path to file
* @param metadata - YAML frontmatter metadata
* @param content - File content
* @param baseDir - Base directory for validation
* @param options - Operation options
*/
async writeFileWithFrontmatter(filePath, metadata, content, baseDir, options = {}) {
const { validatePath: shouldValidatePath = true, ensureDir = true } = options;
// SECURITY: Sanitize path
const sanitizedPath = sanitizeInput(filePath, 255);
// Validate path if requested
if (shouldValidatePath) {
try {
validatePath(sanitizedPath, baseDir);
}
catch (error) {
throw new Error(`Invalid file path: ${error instanceof Error ? error.message : 'Invalid path'}`);
}
}
// Resolve full path
const fullPath = path.isAbsolute(sanitizedPath)
? sanitizedPath
: path.join(baseDir, sanitizedPath);
// Ensure directory exists
if (ensureDir) {
await fs.mkdir(path.dirname(fullPath), { recursive: true });
}
// Clean metadata to remove undefined values
const cleanMetadata = Object.entries(metadata).reduce((acc, [key, value]) => {
if (key !== 'gatekeeperDiagnostics' && value !== undefined) {
acc[key] = value;
}
return acc;
}, {});
// Create frontmatter content
const fileContent = matter.stringify(content, cleanMetadata);
// CRITICAL FIX: Use atomic file write via injected instance
await this.fileLockManager.atomicWriteFile(fullPath, fileContent, { encoding: 'utf-8' });
}
/**
* Validate path is within base directory and resolve to absolute path
* SECURITY: Prevents path traversal attacks
*
* @param filePath - Path to validate
* @param baseDir - Base directory
* @returns Normalized absolute path
* @throws Error if path is invalid or outside base directory
*/
validateAndResolvePath(filePath, baseDir) {
const sanitizedPath = sanitizeInput(filePath, 255);
// Resolve to absolute path
const fullPath = path.isAbsolute(sanitizedPath)
? sanitizedPath
: path.join(baseDir, sanitizedPath);
// Normalize and check path traversal
const normalizedPath = path.normalize(fullPath);
if (!normalizedPath.startsWith(baseDir)) {
SecurityMonitor.logSecurityEvent({
type: 'PATH_TRAVERSAL_ATTEMPT',
severity: 'CRITICAL',
source: 'ElementFileOperations.validateAndResolvePath',
details: `Attempted to access file outside directory: ${sanitizedPath}`
});
throw new Error('Path traversal attempt detected');
}
return normalizedPath;
}
/**
* Generate filename from element name
* Converts name to lowercase and replaces invalid characters with hyphens
*
* @param name - Element name
* @param extension - File extension (default: '.md')
* @returns Sanitized filename
*/
generateFilename(name, extension = '.md') {
const sanitized = sanitizeInput(name, 100);
const filename = sanitized
.toLowerCase()
.replaceAll(/[^a-z0-9-]/g, '-')
.replaceAll(/-+/g, '-')
.replaceAll(/^-|-$/g, '');
return `${filename}${extension}`;
}
/**
* Check if a file exists
*
* @param filePath - Path to check
* @param baseDir - Base directory (optional)
* @returns True if file exists
*/
async fileExists(filePath, baseDir) {
try {
const sanitizedPath = sanitizeInput(filePath, 255);
const fullPath = baseDir
? path.join(baseDir, sanitizedPath)
: sanitizedPath;
await fs.access(fullPath);
return true;
}
catch {
return false;
}
}
/**
* Delete a file with validation
* SECURITY: Validates path before deletion
*
* @param filePath - Path to delete
* @param baseDir - Base directory for validation
* @throws Error if path is invalid
*/
async deleteFile(filePath, baseDir) {
const normalizedPath = this.validateAndResolvePath(filePath, baseDir);
// Log security event
SecurityMonitor.logSecurityEvent({
type: 'ELEMENT_DELETED',
severity: 'MEDIUM',
source: 'ElementFileOperations.deleteFile',
details: `File deleted: ${path.basename(normalizedPath)}`
});
await fs.unlink(normalizedPath);
}
/**
* List files in a directory
*
* @param dir - Directory to list
* @param extension - Filter by extension (optional)
* @returns Array of file paths
*/
async listFiles(dir, extension) {
try {
// Ensure directory exists
await fs.mkdir(dir, { recursive: true });
const files = await fs.readdir(dir);
if (extension) {
return files.filter(f => f.endsWith(extension));
}
return files;
}
catch (error) {
logger.error(`Failed to list files in ${dir}:`, error);
return [];
}
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ElementFileOperations.js","sourceRoot":"","sources":["../../../src/elements/base/ElementFileOperations.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ElementFileOperations - Common file operations for element managers\n *\n * Provides shared file handling operations for all element types:\n * - Reading files with frontmatter parsing\n * - Writing files with atomic operations\n * - Directory scanning and filtering\n *\n * SECURITY: All operations use FileLockManager for atomic reads/writes\n * PATH VALIDATION: All paths are validated before file operations\n * LOGGING: Operations are logged for debugging and audit trail\n */\n\nimport { FileLockManager } from '../../security/fileLockManager.js';\nimport { sanitizeInput, validatePath } from '../../security/InputValidator.js';\nimport { SecurityMonitor } from '../../security/securityMonitor.js';\nimport { logger } from '../../utils/logger.js';\nimport { promises as fs } from 'fs';\nimport * as path from 'path';\nimport matter from 'gray-matter';\n\n/**\n * Result of parsing a file with frontmatter\n */\nexport interface ParsedFile {\n  metadata: any;\n  content: string;\n  raw: string;\n}\n\n/**\n * Options for file operations\n */\nexport interface FileOperationOptions {\n  /** Maximum file size in bytes (default: 1MB) */\n  maxSize?: number;\n  /** Whether to validate path is within base directory (default: true) */\n  validatePath?: boolean;\n  /** Whether to create directory if it doesn't exist (default: true) */\n  ensureDir?: boolean;\n}\n\n/**\n * Utility class for common file operations\n * Used by BaseElementManager and can be used by other managers\n *\n * DEPENDENCY INJECTION: Requires FileLockManager instance for atomic operations\n */\nexport class ElementFileOperations {\n  private fileLockManager: FileLockManager;\n\n  /**\n   * Constructor - accepts FileLockManager for atomic operations\n   * @param fileLockManager - FileLockManager instance for atomic file operations\n   */\n  constructor(fileLockManager: FileLockManager) {\n    this.fileLockManager = fileLockManager;\n  }\n\n  /**\n   * Atomically read a file with frontmatter\n   * SECURITY: Uses FileLockManager to prevent race conditions\n   *\n   * @param filePath - Absolute or relative path to file\n   * @param baseDir - Base directory for validation\n   * @param options - Operation options\n   * @returns Parsed file with metadata and content\n   */\n  async readFileWithFrontmatter(\n    filePath: string,\n    baseDir: string,\n    options: FileOperationOptions = {}\n  ): Promise<ParsedFile> {\n    const {\n      maxSize = 1024 * 1024, // 1MB default\n      validatePath: shouldValidatePath = true\n    } = options;\n\n    // SECURITY: Sanitize path\n    const sanitizedPath = sanitizeInput(filePath, 255);\n\n    // Validate path if requested\n    if (shouldValidatePath) {\n      try {\n        validatePath(sanitizedPath, baseDir);\n      } catch (error) {\n        throw new Error(`Invalid file path: ${error instanceof Error ? error.message : 'Invalid path'}`);\n      }\n    }\n\n    // Resolve full path\n    const fullPath = path.isAbsolute(sanitizedPath)\n      ? sanitizedPath\n      : path.join(baseDir, sanitizedPath);\n\n    // Check file size before reading\n    const stats = await fs.stat(fullPath);\n    if (stats.size > maxSize) {\n      throw new Error(`File too large: ${stats.size} bytes (max: ${maxSize})`);\n    }\n\n    // CRITICAL FIX: Use atomic file read via injected instance\n    const raw = await this.fileLockManager.atomicReadFile(fullPath, { encoding: 'utf-8' });\n\n    // Parse frontmatter\n    const parsed = matter(raw);\n\n    return {\n      metadata: parsed.data,\n      content: parsed.content,\n      raw\n    };\n  }\n\n  /**\n   * Atomically write a file with frontmatter\n   * SECURITY: Uses FileLockManager to prevent corruption\n   *\n   * @param filePath - Absolute or relative path to file\n   * @param metadata - YAML frontmatter metadata\n   * @param content - File content\n   * @param baseDir - Base directory for validation\n   * @param options - Operation options\n   */\n  async writeFileWithFrontmatter(\n    filePath: string,\n    metadata: any,\n    content: string,\n    baseDir: string,\n    options: FileOperationOptions = {}\n  ): Promise<void> {\n    const {\n      validatePath: shouldValidatePath = true,\n      ensureDir = true\n    } = options;\n\n    // SECURITY: Sanitize path\n    const sanitizedPath = sanitizeInput(filePath, 255);\n\n    // Validate path if requested\n    if (shouldValidatePath) {\n      try {\n        validatePath(sanitizedPath, baseDir);\n      } catch (error) {\n        throw new Error(`Invalid file path: ${error instanceof Error ? error.message : 'Invalid path'}`);\n      }\n    }\n\n    // Resolve full path\n    const fullPath = path.isAbsolute(sanitizedPath)\n      ? sanitizedPath\n      : path.join(baseDir, sanitizedPath);\n\n    // Ensure directory exists\n    if (ensureDir) {\n      await fs.mkdir(path.dirname(fullPath), { recursive: true });\n    }\n\n    // Clean metadata to remove undefined values\n    const cleanMetadata = Object.entries(metadata).reduce((acc, [key, value]) => {\n      if (key !== 'gatekeeperDiagnostics' && value !== undefined) {\n        acc[key] = value;\n      }\n      return acc;\n    }, {} as any);\n\n    // Create frontmatter content\n    const fileContent = matter.stringify(content, cleanMetadata);\n\n    // CRITICAL FIX: Use atomic file write via injected instance\n    await this.fileLockManager.atomicWriteFile(fullPath, fileContent, { encoding: 'utf-8' });\n  }\n\n  /**\n   * Validate path is within base directory and resolve to absolute path\n   * SECURITY: Prevents path traversal attacks\n   *\n   * @param filePath - Path to validate\n   * @param baseDir - Base directory\n   * @returns Normalized absolute path\n   * @throws Error if path is invalid or outside base directory\n   */\n  validateAndResolvePath(filePath: string, baseDir: string): string {\n    const sanitizedPath = sanitizeInput(filePath, 255);\n\n    // Resolve to absolute path\n    const fullPath = path.isAbsolute(sanitizedPath)\n      ? sanitizedPath\n      : path.join(baseDir, sanitizedPath);\n\n    // Normalize and check path traversal\n    const normalizedPath = path.normalize(fullPath);\n\n    if (!normalizedPath.startsWith(baseDir)) {\n      SecurityMonitor.logSecurityEvent({\n        type: 'PATH_TRAVERSAL_ATTEMPT',\n        severity: 'CRITICAL',\n        source: 'ElementFileOperations.validateAndResolvePath',\n        details: `Attempted to access file outside directory: ${sanitizedPath}`\n      });\n      throw new Error('Path traversal attempt detected');\n    }\n\n    return normalizedPath;\n  }\n\n  /**\n   * Generate filename from element name\n   * Converts name to lowercase and replaces invalid characters with hyphens\n   *\n   * @param name - Element name\n   * @param extension - File extension (default: '.md')\n   * @returns Sanitized filename\n   */\n  generateFilename(name: string, extension: string = '.md'): string {\n    const sanitized = sanitizeInput(name, 100);\n    const filename = sanitized\n      .toLowerCase()\n      .replaceAll(/[^a-z0-9-]/g, '-')\n      .replaceAll(/-+/g, '-')\n      .replaceAll(/^-|-$/g, '');\n\n    return `${filename}${extension}`;\n  }\n\n  /**\n   * Check if a file exists\n   *\n   * @param filePath - Path to check\n   * @param baseDir - Base directory (optional)\n   * @returns True if file exists\n   */\n  async fileExists(filePath: string, baseDir?: string): Promise<boolean> {\n    try {\n      const sanitizedPath = sanitizeInput(filePath, 255);\n      const fullPath = baseDir\n        ? path.join(baseDir, sanitizedPath)\n        : sanitizedPath;\n      await fs.access(fullPath);\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  /**\n   * Delete a file with validation\n   * SECURITY: Validates path before deletion\n   *\n   * @param filePath - Path to delete\n   * @param baseDir - Base directory for validation\n   * @throws Error if path is invalid\n   */\n  async deleteFile(filePath: string, baseDir: string): Promise<void> {\n    const normalizedPath = this.validateAndResolvePath(filePath, baseDir);\n\n    // Log security event\n    SecurityMonitor.logSecurityEvent({\n      type: 'ELEMENT_DELETED',\n      severity: 'MEDIUM',\n      source: 'ElementFileOperations.deleteFile',\n      details: `File deleted: ${path.basename(normalizedPath)}`\n    });\n\n    await fs.unlink(normalizedPath);\n  }\n\n  /**\n   * List files in a directory\n   *\n   * @param dir - Directory to list\n   * @param extension - Filter by extension (optional)\n   * @returns Array of file paths\n   */\n  async listFiles(dir: string, extension?: string): Promise<string[]> {\n    try {\n      // Ensure directory exists\n      await fs.mkdir(dir, { recursive: true });\n\n      const files = await fs.readdir(dir);\n\n      if (extension) {\n        return files.filter(f => f.endsWith(extension));\n      }\n\n      return files;\n    } catch (error) {\n      logger.error(`Failed to list files in ${dir}:`, error);\n      return [];\n    }\n  }\n}\n"]}