@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.
291 lines • 34.7 kB
JavaScript
import * as fs from 'fs/promises';
import * as path from 'path';
import { logger } from './logger.js';
/**
* 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) {
let totalFiles = 0;
let totalSize = 0;
try {
const entries = await fs.readdir(dir, { withFileTypes: true });
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 fs.stat(fullPath);
totalSize += stat.size;
}
catch {
// Ignore stat errors
}
}
}
}
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) {
// Ensure destination directory exists
await fs.mkdir(dest, { recursive: true });
const entries = await fs.readdir(src, { withFileTypes: true });
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) {
let lastError = null;
for (let attempt = 1; attempt <= maxRetries; attempt++) {
try {
await fs.copyFile(src, dest);
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
*/
static shouldExclude(name, patterns) {
for (const pattern of patterns) {
if (pattern.includes('*')) {
// Simple glob support
const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
if (regex.test(name))
return true;
}
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) {
try {
const entries = await fs.readdir(dir, { withFileTypes: true });
for (const entry of entries) {
const fullPath = path.join(dir, entry.name);
if (entry.isDirectory()) {
await this.removeDirectoryRecursive(fullPath, onFileRemoved);
}
else {
await fs.unlink(fullPath);
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 {
operations = [];
completed = false;
/**
* Add a move operation to the transaction
*/
async addMove(source, destination) {
if (this.completed) {
throw new Error('Transaction already completed');
}
// Perform the move
await fs.rename(source, destination);
// Add rollback operation
this.operations.push({
type: 'move',
source,
destination,
rollback: async () => {
try {
await fs.rename(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(path, backupPath) {
if (this.completed) {
throw new Error('Transaction already completed');
}
// If backup path provided, move instead of delete
if (backupPath) {
await fs.rename(path, backupPath);
this.operations.push({
type: 'delete',
source: path,
destination: backupPath,
rollback: async () => {
try {
await fs.rename(backupPath, path);
}
catch (error) {
logger.error(`[FileTransaction] Failed to restore deleted item from ${backupPath} to ${path}:`, error);
}
}
});
}
else {
// Direct delete (no rollback possible)
await fs.rm(path, { recursive: true, force: true });
this.operations.push({
type: 'delete',
source: path,
rollback: async () => {
logger.warn(`[FileTransaction] Cannot rollback permanent deletion of ${path}`);
}
});
}
}
/**
* 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';\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    let totalFiles = 0;\n    let totalSize = 0;\n    \n    try {\n      const entries = await fs.readdir(dir, { withFileTypes: true });\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 fs.stat(fullPath);\n            totalSize += stat.size;\n          } catch {\n            // Ignore stat errors\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    // Ensure destination directory exists\n    await fs.mkdir(dest, { recursive: true });\n    \n    const entries = await fs.readdir(src, { withFileTypes: true });\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    let lastError: Error | null = null;\n    \n    for (let attempt = 1; attempt <= maxRetries; attempt++) {\n      try {\n        await fs.copyFile(src, dest);\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  private static shouldExclude(name: string, patterns: string[]): boolean {\n    for (const pattern of patterns) {\n      if (pattern.includes('*')) {\n        // Simple glob support\n        const regex = new RegExp('^' + pattern.replace(/\\*/g, '.*') + '$');\n        if (regex.test(name)) return true;\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    try {\n      const entries = await fs.readdir(dir, { withFileTypes: true });\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 fs.unlink(fullPath);\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  private 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  \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 fs.rename(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 fs.rename(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(path: 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 fs.rename(path, backupPath);\n      \n      this.operations.push({\n        type: 'delete',\n        source: path,\n        destination: backupPath,\n        rollback: async () => {\n          try {\n            await fs.rename(backupPath, path);\n          } catch (error) {\n            logger.error(`[FileTransaction] Failed to restore deleted item from ${backupPath} to ${path}:`, error);\n          }\n        }\n      });\n    } else {\n      // Direct delete (no rollback possible)\n      await fs.rm(path, { recursive: true, force: true });\n      \n      this.operations.push({\n        type: 'delete',\n        source: path,\n        rollback: async () => {\n          logger.warn(`[FileTransaction] Cannot rollback permanent deletion of ${path}`);\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}"]}