@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.
341 lines • 42.9 kB
JavaScript
import * as fs from 'fs/promises';
import * as path from 'path';
import { logger } from './logger.js';
import { FileOperationsService } from '../services/FileOperationsService.js';
import { FileLockManager } from '../security/fileLockManager.js';
// Singleton file operations service for static methods
let fileOperationsService = null;
function getFileOperationsService() {
if (!fileOperationsService) {
fileOperationsService = new FileOperationsService(new FileLockManager());
}
return fileOperationsService;
}
/**
* Cross-platform file operations utility
* Centralizes common file operations with progress reporting and error handling
*/
export class FileOperations {
/**
* Recursively copy a directory with progress reporting
* Works cross-platform without relying on shell commands
*/
static async copyDirectory(src, dest, options = {}) {
const { onProgress, excludePatterns = [], maxRetries = 3 } = options;
// First, calculate total files for progress reporting
const stats = await this.calculateDirectoryStats(src, excludePatterns);
let copiedFiles = 0;
await this.copyDirectoryRecursive(src, dest, excludePatterns, maxRetries, (currentFile) => {
copiedFiles++;
if (onProgress) {
onProgress(copiedFiles, stats.totalFiles, currentFile);
}
});
}
/**
* Calculate directory statistics for progress reporting
*/
static async calculateDirectoryStats(dir, excludePatterns) {
const fileOps = getFileOperationsService();
let totalFiles = 0;
let totalSize = 0;
try {
const entries = await fileOps.listDirectoryWithTypes(dir);
for (const entry of entries) {
const fullPath = path.join(dir, entry.name);
// Skip excluded patterns
if (this.shouldExclude(entry.name, excludePatterns)) {
continue;
}
if (entry.isDirectory) {
const subStats = await this.calculateDirectoryStats(fullPath, excludePatterns);
totalFiles += subStats.totalFiles;
totalSize += subStats.totalSize;
}
else {
totalFiles++;
try {
const stat = await fileOps.stat(fullPath);
totalSize += stat.size;
}
catch (error) {
// Log stat errors for debugging - could indicate permissions, corruption, or disk errors
logger.warn(`[FileOperations] Failed to stat file ${fullPath}:`, {
error: error instanceof Error ? error.message : String(error),
code: error.code
});
// Continue without this file's size
}
}
}
}
catch (error) {
logger.warn(`[FileOperations] Error calculating stats for ${dir}:`, error);
}
return { totalFiles, totalSize };
}
/**
* Internal recursive copy implementation
*/
static async copyDirectoryRecursive(src, dest, excludePatterns, maxRetries, onFileCopied) {
const fileOps = getFileOperationsService();
// Ensure destination directory exists
await fileOps.createDirectory(dest);
const entries = await fileOps.listDirectoryWithTypes(src);
for (const entry of entries) {
const srcPath = path.join(src, entry.name);
const destPath = path.join(dest, entry.name);
// Skip excluded patterns
if (this.shouldExclude(entry.name, excludePatterns)) {
logger.debug(`[FileOperations] Skipping excluded: ${entry.name}`);
continue;
}
if (entry.isDirectory) {
await this.copyDirectoryRecursive(srcPath, destPath, excludePatterns, maxRetries, onFileCopied);
}
else {
await this.copyFileWithRetry(srcPath, destPath, maxRetries);
onFileCopied(srcPath);
}
}
}
/**
* Copy a single file with retry logic
*/
static async copyFileWithRetry(src, dest, maxRetries) {
const fileOps = getFileOperationsService();
let lastError = null;
for (let attempt = 1; attempt <= maxRetries; attempt++) {
try {
await fileOps.copyFile(src, dest, { source: 'FileOperations.copyFileWithRetry' });
return; // Success
}
catch (error) {
lastError = error;
logger.debug(`[FileOperations] Copy attempt ${attempt} failed for ${src}: ${error}`);
if (attempt < maxRetries) {
// Wait before retry (exponential backoff)
await new Promise(resolve => setTimeout(resolve, Math.pow(2, attempt) * 100));
}
}
}
// All retries failed
throw new Error(`Failed to copy ${src} after ${maxRetries} attempts: ${lastError?.message}`);
}
/**
* Check if a file/directory should be excluded
*
* FIX: ReDoS vulnerability - replaced unsafe glob-to-regex conversion
* Previously: Used pattern.replace with .* which could cause catastrophic backtracking
* Now: Uses safe glob matching with proper escaping and bounded patterns
* SonarCloud: Resolves DOS vulnerability hotspot
*/
static shouldExclude(name, patterns) {
// Input validation to prevent DOS
if (name.length > 1000) {
return false; // Reject overly long inputs
}
for (const pattern of patterns) {
if (pattern.includes('*')) {
// Safe glob support - prevent ReDoS
// Escape special regex chars except *
// FIX: Use String.raw and replaceAll (SonarCloud S7780, S7781)
const escaped = pattern.replaceAll(/[.+?^${}()|[\]\\]/g, String.raw `\$&`);
// Replace * with [^/]* (match anything except path separator)
// This prevents catastrophic backtracking
const safePattern = escaped.replaceAll('*', '[^/]*');
try {
// FIX: Use template literal to avoid security scanner false positive (PR #1187)
// This is NOT SQL injection - it's a RegExp pattern
const regex = new RegExp(`^${safePattern}$`);
if (regex.test(name))
return true;
}
catch (error) {
// Invalid pattern - log and skip it
logger.debug(`[FileOperations] Invalid regex pattern: ${pattern}`, {
error: error instanceof Error ? error.message : String(error)
});
continue;
}
}
else if (name === pattern) {
return true;
}
}
return false;
}
/**
* Remove a directory with progress reporting
*/
static async removeDirectory(dir, options = {}) {
const stats = await this.calculateDirectoryStats(dir, []);
let removedFiles = 0;
await this.removeDirectoryRecursive(dir, () => {
removedFiles++;
if (options.onProgress) {
options.onProgress(removedFiles, stats.totalFiles);
}
});
}
/**
* Internal recursive remove implementation
*/
static async removeDirectoryRecursive(dir, onFileRemoved) {
const fileOps = getFileOperationsService();
try {
const entries = await fileOps.listDirectoryWithTypes(dir);
for (const entry of entries) {
const fullPath = path.join(dir, entry.name);
if (entry.isDirectory) {
await this.removeDirectoryRecursive(fullPath, onFileRemoved);
}
else {
await fileOps.deleteFile(fullPath, undefined, { source: 'FileOperations.removeDirectoryRecursive' });
onFileRemoved();
}
}
// Remove the now-empty directory
await fs.rmdir(dir);
}
catch (error) {
logger.error(`[FileOperations] Error removing directory ${dir}:`, error);
throw error;
}
}
/**
* Create a transaction manager for atomic file operations
*/
static createTransaction() {
return new FileTransaction();
}
}
/**
* Transaction manager for atomic file operations
* Ensures all operations succeed or all are rolled back
*/
export class FileTransaction {
// FIX: Mark as readonly since never reassigned (SonarCloud S2933)
operations = [];
completed = false;
fileOps;
constructor(fileOperations) {
this.fileOps = fileOperations || getFileOperationsService();
}
/**
* Add a move operation to the transaction
*/
async addMove(source, destination) {
if (this.completed) {
throw new Error('Transaction already completed');
}
// Perform the move
await this.fileOps.renameFile(source, destination);
// Add rollback operation
this.operations.push({
type: 'move',
source,
destination,
rollback: async () => {
try {
await this.fileOps.renameFile(destination, source);
}
catch (error) {
logger.error(`[FileTransaction] Failed to rollback move from ${destination} to ${source}:`, error);
}
}
});
}
/**
* Add a copy operation to the transaction
*/
async addCopy(source, destination) {
if (this.completed) {
throw new Error('Transaction already completed');
}
// Perform the copy
await FileOperations.copyDirectory(source, destination);
// Add rollback operation
this.operations.push({
type: 'copy',
source,
destination,
rollback: async () => {
try {
await fs.rm(destination, { recursive: true, force: true });
}
catch (error) {
logger.error(`[FileTransaction] Failed to rollback copy at ${destination}:`, error);
}
}
});
}
/**
* Add a delete operation to the transaction
*/
async addDelete(deletePath, backupPath) {
if (this.completed) {
throw new Error('Transaction already completed');
}
// If backup path provided, move instead of delete
if (backupPath) {
await this.fileOps.renameFile(deletePath, backupPath);
this.operations.push({
type: 'delete',
source: deletePath,
destination: backupPath,
rollback: async () => {
try {
await this.fileOps.renameFile(backupPath, deletePath);
}
catch (error) {
logger.error(`[FileTransaction] Failed to restore deleted item from ${backupPath} to ${deletePath}:`, error);
}
}
});
}
else {
// Direct delete (no rollback possible)
await fs.rm(deletePath, { recursive: true, force: true });
this.operations.push({
type: 'delete',
source: deletePath,
rollback: async () => {
logger.warn(`[FileTransaction] Cannot rollback permanent deletion of ${deletePath}`);
}
});
}
}
/**
* Commit the transaction (mark as successful)
*/
commit() {
this.completed = true;
}
/**
* Rollback all operations in reverse order
*/
async rollback() {
logger.info(`[FileTransaction] Rolling back ${this.operations.length} operations`);
// Rollback in reverse order
for (let i = this.operations.length - 1; i >= 0; i--) {
const operation = this.operations[i];
logger.info(`[FileTransaction] Rolling back ${operation.type} operation`);
try {
await operation.rollback();
}
catch (error) {
logger.error(`[FileTransaction] Rollback failed for operation ${i}:`, error);
// Continue with other rollbacks
}
}
this.completed = true;
}
/**
* Check if any operations have been performed
*/
hasOperations() {
return this.operations.length > 0;
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fileOperations.js","sourceRoot":"","sources":["../../src/utils/fileOperations.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs/promises';\nimport * as path from 'path';\nimport { logger } from './logger.js';\nimport { IFileOperationsService, FileOperationsService } from '../services/FileOperationsService.js';\nimport { FileLockManager } from '../security/fileLockManager.js';\n\n// Singleton file operations service for static methods\nlet fileOperationsService: IFileOperationsService | null = null;\n\nfunction getFileOperationsService(): IFileOperationsService {\n  if (!fileOperationsService) {\n    fileOperationsService = new FileOperationsService(new FileLockManager());\n  }\n  return fileOperationsService;\n}\n\nexport interface CopyOptions {\n  onProgress?: (copied: number, total: number, currentFile: string) => void;\n  excludePatterns?: string[];\n  maxRetries?: number;\n}\n\nexport interface FileStats {\n  totalFiles: number;\n  totalSize: number;\n}\n\n/**\n * Cross-platform file operations utility\n * Centralizes common file operations with progress reporting and error handling\n */\nexport class FileOperations {\n  /**\n   * Recursively copy a directory with progress reporting\n   * Works cross-platform without relying on shell commands\n   */\n  static async copyDirectory(\n    src: string, \n    dest: string, \n    options: CopyOptions = {}\n  ): Promise<void> {\n    const { onProgress, excludePatterns = [], maxRetries = 3 } = options;\n    \n    // First, calculate total files for progress reporting\n    const stats = await this.calculateDirectoryStats(src, excludePatterns);\n    let copiedFiles = 0;\n    \n    await this.copyDirectoryRecursive(\n      src, \n      dest, \n      excludePatterns,\n      maxRetries,\n      (currentFile) => {\n        copiedFiles++;\n        if (onProgress) {\n          onProgress(copiedFiles, stats.totalFiles, currentFile);\n        }\n      }\n    );\n  }\n  \n  /**\n   * Calculate directory statistics for progress reporting\n   */\n  private static async calculateDirectoryStats(\n    dir: string,\n    excludePatterns: string[]\n  ): Promise<FileStats> {\n    const fileOps = getFileOperationsService();\n    let totalFiles = 0;\n    let totalSize = 0;\n\n    try {\n      const entries = await fileOps.listDirectoryWithTypes(dir);\n\n      for (const entry of entries) {\n        const fullPath = path.join(dir, entry.name);\n\n        // Skip excluded patterns\n        if (this.shouldExclude(entry.name, excludePatterns)) {\n          continue;\n        }\n\n        if (entry.isDirectory) {\n          const subStats = await this.calculateDirectoryStats(fullPath, excludePatterns);\n          totalFiles += subStats.totalFiles;\n          totalSize += subStats.totalSize;\n        } else {\n          totalFiles++;\n          try {\n            const stat = await fileOps.stat(fullPath);\n            totalSize += stat.size;\n          } catch (error) {\n            // Log stat errors for debugging - could indicate permissions, corruption, or disk errors\n            logger.warn(`[FileOperations] Failed to stat file ${fullPath}:`, {\n              error: error instanceof Error ? error.message : String(error),\n              code: (error as NodeJS.ErrnoException).code\n            });\n            // Continue without this file's size\n          }\n        }\n      }\n    } catch (error) {\n      logger.warn(`[FileOperations] Error calculating stats for ${dir}:`, error);\n    }\n\n    return { totalFiles, totalSize };\n  }\n  \n  /**\n   * Internal recursive copy implementation\n   */\n  private static async copyDirectoryRecursive(\n    src: string,\n    dest: string,\n    excludePatterns: string[],\n    maxRetries: number,\n    onFileCopied: (file: string) => void\n  ): Promise<void> {\n    const fileOps = getFileOperationsService();\n\n    // Ensure destination directory exists\n    await fileOps.createDirectory(dest);\n\n    const entries = await fileOps.listDirectoryWithTypes(src);\n\n    for (const entry of entries) {\n      const srcPath = path.join(src, entry.name);\n      const destPath = path.join(dest, entry.name);\n\n      // Skip excluded patterns\n      if (this.shouldExclude(entry.name, excludePatterns)) {\n        logger.debug(`[FileOperations] Skipping excluded: ${entry.name}`);\n        continue;\n      }\n\n      if (entry.isDirectory) {\n        await this.copyDirectoryRecursive(\n          srcPath,\n          destPath,\n          excludePatterns,\n          maxRetries,\n          onFileCopied\n        );\n      } else {\n        await this.copyFileWithRetry(srcPath, destPath, maxRetries);\n        onFileCopied(srcPath);\n      }\n    }\n  }\n  \n  /**\n   * Copy a single file with retry logic\n   */\n  private static async copyFileWithRetry(\n    src: string,\n    dest: string,\n    maxRetries: number\n  ): Promise<void> {\n    const fileOps = getFileOperationsService();\n    let lastError: Error | null = null;\n\n    for (let attempt = 1; attempt <= maxRetries; attempt++) {\n      try {\n        await fileOps.copyFile(src, dest, { source: 'FileOperations.copyFileWithRetry' });\n        return; // Success\n      } catch (error) {\n        lastError = error as Error;\n        logger.debug(`[FileOperations] Copy attempt ${attempt} failed for ${src}: ${error}`);\n\n        if (attempt < maxRetries) {\n          // Wait before retry (exponential backoff)\n          await new Promise(resolve => setTimeout(resolve, Math.pow(2, attempt) * 100));\n        }\n      }\n    }\n\n    // All retries failed\n    throw new Error(`Failed to copy ${src} after ${maxRetries} attempts: ${lastError?.message}`);\n  }\n  \n  /**\n   * Check if a file/directory should be excluded\n   *\n   * FIX: ReDoS vulnerability - replaced unsafe glob-to-regex conversion\n   * Previously: Used pattern.replace with .* which could cause catastrophic backtracking\n   * Now: Uses safe glob matching with proper escaping and bounded patterns\n   * SonarCloud: Resolves DOS vulnerability hotspot\n   */\n  private static shouldExclude(name: string, patterns: string[]): boolean {\n    // Input validation to prevent DOS\n    if (name.length > 1000) {\n      return false; // Reject overly long inputs\n    }\n\n    for (const pattern of patterns) {\n      if (pattern.includes('*')) {\n        // Safe glob support - prevent ReDoS\n        // Escape special regex chars except *\n        // FIX: Use String.raw and replaceAll (SonarCloud S7780, S7781)\n        const escaped = pattern.replaceAll(/[.+?^${}()|[\\]\\\\]/g, String.raw`\\$&`);\n        // Replace * with [^/]* (match anything except path separator)\n        // This prevents catastrophic backtracking\n        const safePattern = escaped.replaceAll('*', '[^/]*');\n\n        try {\n          // FIX: Use template literal to avoid security scanner false positive (PR #1187)\n          // This is NOT SQL injection - it's a RegExp pattern\n          const regex = new RegExp(`^${safePattern}$`);\n          if (regex.test(name)) return true;\n        } catch (error) {\n          // Invalid pattern - log and skip it\n          logger.debug(`[FileOperations] Invalid regex pattern: ${pattern}`, {\n            error: error instanceof Error ? error.message : String(error)\n          });\n          continue;\n        }\n      } else if (name === pattern) {\n        return true;\n      }\n    }\n    return false;\n  }\n  \n  /**\n   * Remove a directory with progress reporting\n   */\n  static async removeDirectory(\n    dir: string,\n    options: { onProgress?: (removed: number, total: number) => void } = {}\n  ): Promise<void> {\n    const stats = await this.calculateDirectoryStats(dir, []);\n    let removedFiles = 0;\n    \n    await this.removeDirectoryRecursive(dir, () => {\n      removedFiles++;\n      if (options.onProgress) {\n        options.onProgress(removedFiles, stats.totalFiles);\n      }\n    });\n  }\n  \n  /**\n   * Internal recursive remove implementation\n   */\n  private static async removeDirectoryRecursive(\n    dir: string,\n    onFileRemoved: () => void\n  ): Promise<void> {\n    const fileOps = getFileOperationsService();\n\n    try {\n      const entries = await fileOps.listDirectoryWithTypes(dir);\n\n      for (const entry of entries) {\n        const fullPath = path.join(dir, entry.name);\n\n        if (entry.isDirectory) {\n          await this.removeDirectoryRecursive(fullPath, onFileRemoved);\n        } else {\n          await fileOps.deleteFile(fullPath, undefined, { source: 'FileOperations.removeDirectoryRecursive' });\n          onFileRemoved();\n        }\n      }\n\n      // Remove the now-empty directory\n      await fs.rmdir(dir);\n    } catch (error) {\n      logger.error(`[FileOperations] Error removing directory ${dir}:`, error);\n      throw error;\n    }\n  }\n  \n  /**\n   * Create a transaction manager for atomic file operations\n   */\n  static createTransaction(): FileTransaction {\n    return new FileTransaction();\n  }\n}\n\n/**\n * Transaction manager for atomic file operations\n * Ensures all operations succeed or all are rolled back\n */\nexport class FileTransaction {\n  // FIX: Mark as readonly since never reassigned (SonarCloud S2933)\n  private readonly operations: Array<{\n    type: 'move' | 'copy' | 'delete' | 'create';\n    source?: string;\n    destination?: string;\n    rollback: () => Promise<void>;\n  }> = [];\n\n  private completed = false;\n  private readonly fileOps: IFileOperationsService;\n\n  constructor(fileOperations?: IFileOperationsService) {\n    this.fileOps = fileOperations || getFileOperationsService();\n  }\n  \n  /**\n   * Add a move operation to the transaction\n   */\n  async addMove(source: string, destination: string): Promise<void> {\n    if (this.completed) {\n      throw new Error('Transaction already completed');\n    }\n\n    // Perform the move\n    await this.fileOps.renameFile(source, destination);\n\n    // Add rollback operation\n    this.operations.push({\n      type: 'move',\n      source,\n      destination,\n      rollback: async () => {\n        try {\n          await this.fileOps.renameFile(destination, source);\n        } catch (error) {\n          logger.error(`[FileTransaction] Failed to rollback move from ${destination} to ${source}:`, error);\n        }\n      }\n    });\n  }\n  \n  /**\n   * Add a copy operation to the transaction\n   */\n  async addCopy(source: string, destination: string): Promise<void> {\n    if (this.completed) {\n      throw new Error('Transaction already completed');\n    }\n    \n    // Perform the copy\n    await FileOperations.copyDirectory(source, destination);\n    \n    // Add rollback operation\n    this.operations.push({\n      type: 'copy',\n      source,\n      destination,\n      rollback: async () => {\n        try {\n          await fs.rm(destination, { recursive: true, force: true });\n        } catch (error) {\n          logger.error(`[FileTransaction] Failed to rollback copy at ${destination}:`, error);\n        }\n      }\n    });\n  }\n  \n  /**\n   * Add a delete operation to the transaction\n   */\n  async addDelete(deletePath: string, backupPath?: string): Promise<void> {\n    if (this.completed) {\n      throw new Error('Transaction already completed');\n    }\n\n    // If backup path provided, move instead of delete\n    if (backupPath) {\n      await this.fileOps.renameFile(deletePath, backupPath);\n\n      this.operations.push({\n        type: 'delete',\n        source: deletePath,\n        destination: backupPath,\n        rollback: async () => {\n          try {\n            await this.fileOps.renameFile(backupPath, deletePath);\n          } catch (error) {\n            logger.error(`[FileTransaction] Failed to restore deleted item from ${backupPath} to ${deletePath}:`, error);\n          }\n        }\n      });\n    } else {\n      // Direct delete (no rollback possible)\n      await fs.rm(deletePath, { recursive: true, force: true });\n\n      this.operations.push({\n        type: 'delete',\n        source: deletePath,\n        rollback: async () => {\n          logger.warn(`[FileTransaction] Cannot rollback permanent deletion of ${deletePath}`);\n        }\n      });\n    }\n  }\n  \n  /**\n   * Commit the transaction (mark as successful)\n   */\n  commit(): void {\n    this.completed = true;\n  }\n  \n  /**\n   * Rollback all operations in reverse order\n   */\n  async rollback(): Promise<void> {\n    logger.info(`[FileTransaction] Rolling back ${this.operations.length} operations`);\n    \n    // Rollback in reverse order\n    for (let i = this.operations.length - 1; i >= 0; i--) {\n      const operation = this.operations[i];\n      logger.info(`[FileTransaction] Rolling back ${operation.type} operation`);\n      \n      try {\n        await operation.rollback();\n      } catch (error) {\n        logger.error(`[FileTransaction] Rollback failed for operation ${i}:`, error);\n        // Continue with other rollbacks\n      }\n    }\n    \n    this.completed = true;\n  }\n  \n  /**\n   * Check if any operations have been performed\n   */\n  hasOperations(): boolean {\n    return this.operations.length > 0;\n  }\n}"]}