@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.
195 lines • 24.8 kB
JavaScript
import { logger } from '../utils/logger.js';
import * as fs from 'fs/promises';
import * as path from 'path';
import { randomBytes } from 'crypto';
import { getValidatedLockTimeout } from '../config/performance-constants.js';
/**
* FileLockManager - Prevents race conditions in concurrent file operations
*
* Features:
* - Resource-based locking with automatic cleanup
* - Configurable timeouts to prevent deadlocks
* - Atomic file operations with write-rename pattern
* - Lock queueing for concurrent requests
* - Comprehensive error handling and logging
* - Performance metrics tracking
*/
export class FileLockManager {
// Map of resource identifiers to their lock promises
locks = new Map();
// Lock acquisition metrics for monitoring
metrics = {
totalLockRequests: 0,
lockWaitTime: new Map(),
lockTimeouts: 0,
concurrentWaits: 0
};
logListener;
addLogListener(fn) {
this.logListener = fn;
return () => { this.logListener = undefined; };
}
// Default timeout for lock operations - using centralized configuration
DEFAULT_TIMEOUT_MS = getValidatedLockTimeout();
// Temporary file directory
TEMP_DIR = '.tmp';
/**
* Execute an operation with exclusive lock on a resource
* @param resource - Unique identifier for the resource (e.g., 'persona:name')
* @param operation - Async function to execute while holding the lock
* @param options - Lock options including timeout
* @returns Result of the operation
*/
async withLock(resource, operation, options = {}) {
const startTime = Date.now();
this.metrics.totalLockRequests++;
// Wait for any existing operation on this resource
const existingLock = this.locks.get(resource);
if (existingLock) {
this.metrics.concurrentWaits++;
const shortResource = path.basename(resource);
logger.debug(`Lock contention on: ${shortResource}`, { resource });
this.logListener?.('debug', 'Detect lock contention', { resource });
try {
await existingLock;
}
catch {
// Previous operation failed, but we can proceed
logger.debug(`Previous operation on ${resource} failed, proceeding`);
}
}
// Create new lock for this operation
const timeout = options.timeout || this.DEFAULT_TIMEOUT_MS;
const lockPromise = this.executeWithTimeout(operation, timeout, resource);
this.locks.set(resource, lockPromise);
try {
const result = await lockPromise;
// Record metrics
const waitTime = Date.now() - startTime;
if (!this.metrics.lockWaitTime.has(resource)) {
this.metrics.lockWaitTime.set(resource, []);
}
this.metrics.lockWaitTime.get(resource).push(waitTime);
// Only log locks that actually waited (>5ms indicates real contention)
if (waitTime > 5) {
const shortResource = path.basename(resource);
logger.debug(`Slow lock: ${shortResource} (${waitTime}ms)`);
}
return result;
}
finally {
// Clean up lock - unconditional delete is safe and race-free
// This operation completed, so remove its lock from the map
this.locks.delete(resource);
}
}
/**
* Execute operation with timeout protection
*/
async executeWithTimeout(operation, timeoutMs, resource) {
let timeoutHandle;
const timeoutPromise = new Promise((_, reject) => {
timeoutHandle = setTimeout(() => {
this.metrics.lockTimeouts++;
this.logListener?.('warn', 'Lock acquisition times out', { resource, timeoutMs });
reject(new Error(`Lock operation timeout for resource: ${resource}`));
}, timeoutMs);
});
try {
const result = await Promise.race([operation(), timeoutPromise]);
if (timeoutHandle)
clearTimeout(timeoutHandle);
return result;
}
catch (error) {
if (timeoutHandle)
clearTimeout(timeoutHandle);
throw error;
}
}
/**
* Perform atomic file write operation
* Writes to temporary file then renames to ensure atomicity
*/
async atomicWriteFile(filePath, content, options) {
const tempPath = await this.getTempFilePath(filePath);
const dir = path.dirname(tempPath);
try {
// Ensure temp directory exists
await fs.mkdir(dir, { recursive: true });
// Write to temporary file
await fs.writeFile(tempPath, content, options);
// Atomic rename (on same filesystem)
await fs.rename(tempPath, filePath);
}
catch (error) {
// Clean up temp file on error
try {
await fs.unlink(tempPath);
logger.debug(`Cleaned up temp file after error: ${tempPath}`);
}
catch (unlinkError) {
// Log cleanup failure but don't throw - original error is more important
logger.warn(`Failed to clean up temp file ${tempPath}: ${unlinkError}`);
}
throw error;
}
}
/**
* Perform atomic file read with lock
*/
async atomicReadFile(filePath, options) {
return this.withLock(`file:${filePath}`, async () => {
const content = await fs.readFile(filePath, options);
return content.toString();
});
}
/**
* Generate temporary file path for atomic operations
*/
async getTempFilePath(originalPath) {
const dir = path.dirname(originalPath);
const basename = path.basename(originalPath);
const random = randomBytes(8).toString('hex');
return path.join(dir, this.TEMP_DIR, `${basename}.${random}.tmp`);
}
/**
* Get lock metrics for monitoring
*/
getMetrics() {
const avgWaitTimes = new Map();
for (const [resource, times] of this.metrics.lockWaitTime.entries()) {
if (times.length > 0) {
const avg = times.reduce((a, b) => a + b, 0) / times.length;
avgWaitTimes.set(resource, Math.round(avg));
}
}
return {
totalRequests: this.metrics.totalLockRequests,
activeLocksCount: this.locks.size,
timeouts: this.metrics.lockTimeouts,
concurrentWaits: this.metrics.concurrentWaits,
avgWaitTimeByResource: Object.fromEntries(avgWaitTimes),
activeLocks: Array.from(this.locks.keys())
};
}
/**
* Clear all locks (use with caution - mainly for testing)
*/
clearAllLocks() {
this.locks.clear();
logger.warn('All file locks cleared - use only for testing/recovery');
}
/**
* Reset metrics
*/
resetMetrics() {
this.metrics = {
totalLockRequests: 0,
lockWaitTime: new Map(),
lockTimeouts: 0,
concurrentWaits: 0
};
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fileLockManager.js","sourceRoot":"","sources":["../../src/security/fileLockManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,KAAK,EAAE,MAAM,aAAa,CAAC;AAClC,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAC7B,OAAO,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AACrC,OAAO,EAAE,uBAAuB,EAAE,MAAM,oCAAoC,CAAC;AAE7E;;;;;;;;;;GAUG;AACH,MAAM,OAAO,eAAe;IAC1B,qDAAqD;IAC7C,KAAK,GAAG,IAAI,GAAG,EAAwB,CAAC;IAEhD,0CAA0C;IAClC,OAAO,GAAG;QAChB,iBAAiB,EAAE,CAAC;QACpB,YAAY,EAAE,IAAI,GAAG,EAAoB;QACzC,YAAY,EAAE,CAAC;QACf,eAAe,EAAE,CAAC;KACnB,CAAC;IAEM,WAAW,CAAyG;IAE5H,cAAc,CAAC,EAAyG;QACtH,IAAI,CAAC,WAAW,GAAG,EAAE,CAAC;QACtB,OAAO,GAAG,EAAE,GAAG,IAAI,CAAC,WAAW,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;IACjD,CAAC;IAED,wEAAwE;IACvD,kBAAkB,GAAG,uBAAuB,EAAE,CAAC;IAEhE,2BAA2B;IACV,QAAQ,GAAG,MAAM,CAAC;IAEnC;;;;;;OAMG;IACH,KAAK,CAAC,QAAQ,CACZ,QAAgB,EAChB,SAA2B,EAC3B,UAAgC,EAAE;QAElC,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAC7B,IAAI,CAAC,OAAO,CAAC,iBAAiB,EAAE,CAAC;QAEjC,mDAAmD;QACnD,MAAM,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAC9C,IAAI,YAAY,EAAE,CAAC;YACjB,IAAI,CAAC,OAAO,CAAC,eAAe,EAAE,CAAC;YAC/B,MAAM,aAAa,GAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;YAC9C,MAAM,CAAC,KAAK,CAAC,uBAAuB,aAAa,EAAE,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC;YACnE,IAAI,CAAC,WAAW,EAAE,CAAC,OAAO,EAAE,wBAAwB,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC;YAEpE,IAAI,CAAC;gBACH,MAAM,YAAY,CAAC;YACrB,CAAC;YAAC,MAAM,CAAC;gBACP,gDAAgD;gBAChD,MAAM,CAAC,KAAK,CAAC,yBAAyB,QAAQ,qBAAqB,CAAC,CAAC;YACvE,CAAC;QACH,CAAC;QAED,qCAAqC;QACrC,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,IAAI,IAAI,CAAC,kBAAkB,CAAC;QAC3D,MAAM,WAAW,GAAG,IAAI,CAAC,kBAAkB,CAAC,SAAS,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;QAC1E,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;QAEtC,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,WAAW,CAAC;YAEjC,iBAAiB;YACjB,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,CAAC;YACxC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;gBAC7C,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,GAAG,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;YAC9C,CAAC;YACD,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,GAAG,CAAC,QAAQ,CAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YAExD,uEAAuE;YACvE,IAAI,QAAQ,GAAG,CAAC,EAAE,CAAC;gBACjB,MAAM,aAAa,GAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;gBAC9C,MAAM,CAAC,KAAK,CAAC,cAAc,aAAa,KAAK,QAAQ,KAAK,CAAC,CAAC;YAC9D,CAAC;YACD,OAAO,MAAM,CAAC;QAChB,CAAC;gBAAS,CAAC;YACT,6DAA6D;YAC7D,4DAA4D;YAC5D,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAC9B,CAAC;IACH,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,kBAAkB,CAC9B,SAA2B,EAC3B,SAAiB,EACjB,QAAgB;QAEhB,IAAI,aAAyC,CAAC;QAE9C,MAAM,cAAc,GAAG,IAAI,OAAO,CAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE;YACtD,aAAa,GAAG,UAAU,CAAC,GAAG,EAAE;gBAC9B,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC;gBAC5B,IAAI,CAAC,WAAW,EAAE,CAAC,MAAM,EAAE,4BAA4B,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC,CAAC;gBAClF,MAAM,CAAC,IAAI,KAAK,CAAC,wCAAwC,QAAQ,EAAE,CAAC,CAAC,CAAC;YACxE,CAAC,EAAE,SAAS,CAAC,CAAC;QAChB,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,cAAc,CAAC,CAAC,CAAC;YACjE,IAAI,aAAa;gBAAE,YAAY,CAAC,aAAa,CAAC,CAAC;YAC/C,OAAO,MAAM,CAAC;QAChB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,aAAa;gBAAE,YAAY,CAAC,aAAa,CAAC,CAAC;YAC/C,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,eAAe,CACnB,QAAgB,EAChB,OAAe,EACf,OAAuC;QAEvC,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC;QACtD,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QAEnC,IAAI,CAAC;YACH,+BAA+B;YAC/B,MAAM,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;YAEzC,0BAA0B;YAC1B,MAAM,EAAE,CAAC,SAAS,CAAC,QAAQ,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;YAE/C,qCAAqC;YACrC,MAAM,EAAE,CAAC,MAAM,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;QAEtC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,8BAA8B;YAC9B,IAAI,CAAC;gBACH,MAAM,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;gBAC1B,MAAM,CAAC,KAAK,CAAC,qCAAqC,QAAQ,EAAE,CAAC,CAAC;YAChE,CAAC;YAAC,OAAO,WAAW,EAAE,CAAC;gBACrB,yEAAyE;gBACzE,MAAM,CAAC,IAAI,CAAC,gCAAgC,QAAQ,KAAK,WAAW,EAAE,CAAC,CAAC;YAC1E,CAAC;YACD,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,cAAc,CAClB,QAAgB,EAChB,OAAuC;QAEvC,OAAO,IAAI,CAAC,QAAQ,CAAC,QAAQ,QAAQ,EAAE,EAAE,KAAK,IAAI,EAAE;YAClD,MAAM,OAAO,GAAG,MAAM,EAAE,CAAC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;YACrD,OAAO,OAAO,CAAC,QAAQ,EAAE,CAAC;QAC5B,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,eAAe,CAAC,YAAoB;QAChD,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;QACvC,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC;QAC7C,MAAM,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QAC9C,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,QAAQ,EAAE,GAAG,QAAQ,IAAI,MAAM,MAAM,CAAC,CAAC;IACpE,CAAC;IAED;;OAEG;IACH,UAAU;QACR,MAAM,YAAY,GAAG,IAAI,GAAG,EAAkB,CAAC;QAC/C,KAAK,MAAM,CAAC,QAAQ,EAAE,KAAK,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,OAAO,EAAE,EAAE,CAAC;YACpE,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACrB,MAAM,GAAG,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,GAAG,KAAK,CAAC,MAAM,CAAC;gBAC5D,YAAY,CAAC,GAAG,CAAC,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;YAC9C,CAAC;QACH,CAAC;QAED,OAAO;YACL,aAAa,EAAE,IAAI,CAAC,OAAO,CAAC,iBAAiB;YAC7C,gBAAgB,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI;YACjC,QAAQ,EAAE,IAAI,CAAC,OAAO,CAAC,YAAY;YACnC,eAAe,EAAE,IAAI,CAAC,OAAO,CAAC,eAAe;YAC7C,qBAAqB,EAAE,MAAM,CAAC,WAAW,CAAC,YAAY,CAAC;YACvD,WAAW,EAAE,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;SAC3C,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,aAAa;QACX,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;QACnB,MAAM,CAAC,IAAI,CAAC,wDAAwD,CAAC,CAAC;IACxE,CAAC;IAED;;OAEG;IACH,YAAY;QACV,IAAI,CAAC,OAAO,GAAG;YACb,iBAAiB,EAAE,CAAC;YACpB,YAAY,EAAE,IAAI,GAAG,EAAoB;YACzC,YAAY,EAAE,CAAC;YACf,eAAe,EAAE,CAAC;SACnB,CAAC;IACJ,CAAC;CACF","sourcesContent":["import { logger } from '../utils/logger.js';\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\nimport { randomBytes } from 'crypto';\nimport { getValidatedLockTimeout } from '../config/performance-constants.js';\n\n/**\n * FileLockManager - Prevents race conditions in concurrent file operations\n * \n * Features:\n * - Resource-based locking with automatic cleanup\n * - Configurable timeouts to prevent deadlocks\n * - Atomic file operations with write-rename pattern\n * - Lock queueing for concurrent requests\n * - Comprehensive error handling and logging\n * - Performance metrics tracking\n */\nexport class FileLockManager {\n  // Map of resource identifiers to their lock promises\n  private locks = new Map<string, Promise<any>>();\n\n  // Lock acquisition metrics for monitoring\n  private metrics = {\n    totalLockRequests: 0,\n    lockWaitTime: new Map<string, number[]>(),\n    lockTimeouts: 0,\n    concurrentWaits: 0\n  };\n\n  private logListener?: (level: 'debug' | 'info' | 'warn' | 'error', message: string, data?: Record<string, unknown>) => void;\n\n  addLogListener(fn: (level: 'debug' | 'info' | 'warn' | 'error', message: string, data?: Record<string, unknown>) => void): () => void {\n    this.logListener = fn;\n    return () => { this.logListener = undefined; };\n  }\n\n  // Default timeout for lock operations - using centralized configuration\n  private readonly DEFAULT_TIMEOUT_MS = getValidatedLockTimeout();\n\n  // Temporary file directory\n  private readonly TEMP_DIR = '.tmp';\n\n  /**\n   * Execute an operation with exclusive lock on a resource\n   * @param resource - Unique identifier for the resource (e.g., 'persona:name')\n   * @param operation - Async function to execute while holding the lock\n   * @param options - Lock options including timeout\n   * @returns Result of the operation\n   */\n  async withLock<T>(\n    resource: string,\n    operation: () => Promise<T>,\n    options: { timeout?: number } = {}\n  ): Promise<T> {\n    const startTime = Date.now();\n    this.metrics.totalLockRequests++;\n    \n    // Wait for any existing operation on this resource\n    const existingLock = this.locks.get(resource);\n    if (existingLock) {\n      this.metrics.concurrentWaits++;\n      const shortResource = path.basename(resource);\n      logger.debug(`Lock contention on: ${shortResource}`, { resource });\n      this.logListener?.('debug', 'Detect lock contention', { resource });\n      \n      try {\n        await existingLock;\n      } catch {\n        // Previous operation failed, but we can proceed\n        logger.debug(`Previous operation on ${resource} failed, proceeding`);\n      }\n    }\n    \n    // Create new lock for this operation\n    const timeout = options.timeout || this.DEFAULT_TIMEOUT_MS;\n    const lockPromise = this.executeWithTimeout(operation, timeout, resource);\n    this.locks.set(resource, lockPromise);\n    \n    try {\n      const result = await lockPromise;\n      \n      // Record metrics\n      const waitTime = Date.now() - startTime;\n      if (!this.metrics.lockWaitTime.has(resource)) {\n        this.metrics.lockWaitTime.set(resource, []);\n      }\n      this.metrics.lockWaitTime.get(resource)!.push(waitTime);\n      \n      // Only log locks that actually waited (>5ms indicates real contention)\n      if (waitTime > 5) {\n        const shortResource = path.basename(resource);\n        logger.debug(`Slow lock: ${shortResource} (${waitTime}ms)`);\n      }\n      return result;\n    } finally {\n      // Clean up lock - unconditional delete is safe and race-free\n      // This operation completed, so remove its lock from the map\n      this.locks.delete(resource);\n    }\n  }\n\n  /**\n   * Execute operation with timeout protection\n   */\n  private async executeWithTimeout<T>(\n    operation: () => Promise<T>,\n    timeoutMs: number,\n    resource: string\n  ): Promise<T> {\n    let timeoutHandle: NodeJS.Timeout | undefined;\n    \n    const timeoutPromise = new Promise<never>((_, reject) => {\n      timeoutHandle = setTimeout(() => {\n        this.metrics.lockTimeouts++;\n        this.logListener?.('warn', 'Lock acquisition times out', { resource, timeoutMs });\n        reject(new Error(`Lock operation timeout for resource: ${resource}`));\n      }, timeoutMs);\n    });\n    \n    try {\n      const result = await Promise.race([operation(), timeoutPromise]);\n      if (timeoutHandle) clearTimeout(timeoutHandle);\n      return result;\n    } catch (error) {\n      if (timeoutHandle) clearTimeout(timeoutHandle);\n      throw error;\n    }\n  }\n\n  /**\n   * Perform atomic file write operation\n   * Writes to temporary file then renames to ensure atomicity\n   */\n  async atomicWriteFile(\n    filePath: string,\n    content: string,\n    options?: { encoding?: BufferEncoding }\n  ): Promise<void> {\n    const tempPath = await this.getTempFilePath(filePath);\n    const dir = path.dirname(tempPath);\n    \n    try {\n      // Ensure temp directory exists\n      await fs.mkdir(dir, { recursive: true });\n      \n      // Write to temporary file\n      await fs.writeFile(tempPath, content, options);\n      \n      // Atomic rename (on same filesystem)\n      await fs.rename(tempPath, filePath);\n      \n    } catch (error) {\n      // Clean up temp file on error\n      try {\n        await fs.unlink(tempPath);\n        logger.debug(`Cleaned up temp file after error: ${tempPath}`);\n      } catch (unlinkError) {\n        // Log cleanup failure but don't throw - original error is more important\n        logger.warn(`Failed to clean up temp file ${tempPath}: ${unlinkError}`);\n      }\n      throw error;\n    }\n  }\n\n  /**\n   * Perform atomic file read with lock\n   */\n  async atomicReadFile(\n    filePath: string,\n    options?: { encoding?: BufferEncoding }\n  ): Promise<string> {\n    return this.withLock(`file:${filePath}`, async () => {\n      const content = await fs.readFile(filePath, options);\n      return content.toString();\n    });\n  }\n\n  /**\n   * Generate temporary file path for atomic operations\n   */\n  private async getTempFilePath(originalPath: string): Promise<string> {\n    const dir = path.dirname(originalPath);\n    const basename = path.basename(originalPath);\n    const random = randomBytes(8).toString('hex');\n    return path.join(dir, this.TEMP_DIR, `${basename}.${random}.tmp`);\n  }\n\n  /**\n   * Get lock metrics for monitoring\n   */\n  getMetrics() {\n    const avgWaitTimes = new Map<string, number>();\n    for (const [resource, times] of this.metrics.lockWaitTime.entries()) {\n      if (times.length > 0) {\n        const avg = times.reduce((a, b) => a + b, 0) / times.length;\n        avgWaitTimes.set(resource, Math.round(avg));\n      }\n    }\n    \n    return {\n      totalRequests: this.metrics.totalLockRequests,\n      activeLocksCount: this.locks.size,\n      timeouts: this.metrics.lockTimeouts,\n      concurrentWaits: this.metrics.concurrentWaits,\n      avgWaitTimeByResource: Object.fromEntries(avgWaitTimes),\n      activeLocks: Array.from(this.locks.keys())\n    };\n  }\n\n  /**\n   * Clear all locks (use with caution - mainly for testing)\n   */\n  clearAllLocks(): void {\n    this.locks.clear();\n    logger.warn('All file locks cleared - use only for testing/recovery');\n  }\n\n  /**\n   * Reset metrics\n   */\n  resetMetrics(): void {\n    this.metrics = {\n      totalLockRequests: 0,\n      lockWaitTime: new Map<string, number[]>(),\n      lockTimeouts: 0,\n      concurrentWaits: 0\n    };\n  }\n}"]}