claude-flow-novice 2.15.2 → 2.15.4

package/dist/lib/file-lock-manager.js

@@ -0,0 +1,578 @@
+/**
+ * File Lock Manager
+ *
+ * Centralized file locking system with queuing, renewal, and monitoring.
+ * Part of Task 4.2: Centralized File Locking & Atomic Operations
+ *
+ * Features:
+ * - Lock acquisition with configurable timeout (300s default)
+ * - Waiting queue for blocked processes
+ * - Lock renewal for long-running operations
+ * - Force release capability for stuck locks
+ * - Owner tracking (process ID + agent ID)
+ * - Stale lock detection and cleanup
+ * - Performance monitoring (<100ms acquisition target)
+ * - Automatic lock release on process exit
+ *
+ * Usage:
+ *   const manager = new FileLockManager();
+ *   const lock = await manager.acquireLock('/path/to/file.txt', {
+ *     agentId: 'backend-dev-001',
+ *     timeout: 30000
+ *   });
+ *   try {
+ *     // Perform file operations
+ *   } finally {
+ *     await manager.releaseLock(lock.id);
+ *   }
+ */ import * as fs from 'fs';
+import * as path from 'path';
+import { promisify } from 'util';
+import { randomUUID } from 'crypto';
+import { createLogger } from './logging.js';
+import { createError, ErrorCode, createTimeoutError } from './errors.js';
+const logger = createLogger('file-lock-manager');
+const fsWriteFile = promisify(fs.writeFile);
+const fsReadFile = promisify(fs.readFile);
+const fsUnlink = promisify(fs.unlink);
+const fsStat = promisify(fs.stat);
+const fsMkdir = promisify(fs.mkdir);
+const fsAccess = promisify(fs.access);
+/**
+ * Lock directory (defaults to /tmp/cfn-locks/)
+ */ const LOCK_DIR = process.env.CFN_LOCK_DIR || '/tmp/cfn-locks';
+/**
+ * File Lock Manager
+ *
+ * Manages file locks with queuing, renewal, and monitoring capabilities.
+ */ export class FileLockManager {
+    activeLocks = new Map();
+    lockQueues = new Map();
+    metrics = {
+        acquisitions: 0,
+        releases: 0,
+        activeLocks: 0,
+        timeouts: 0,
+        staleLocksRemoved: 0,
+        avgAcquisitionTimeMs: 0,
+        totalAcquisitionTimeMs: 0,
+        renewals: 0,
+        forceReleases: 0
+    };
+    cleanupInterval = null;
+    constructor(){
+        this.ensureLockDirectory();
+        this.setupCleanupInterval();
+        this.setupProcessExitHandlers();
+    }
+    /**
+   * Acquire a file lock
+   *
+   * @param filePath - Path to file to lock
+   * @param options - Lock acquisition options
+   * @returns Promise<FileLock> - Lock instance
+   * @throws LOCK_TIMEOUT if acquisition times out
+   */ async acquireLock(filePath, options = {}) {
+        const startTime = Date.now();
+        const opts = {
+            timeout: options.timeout || 300000,
+            retryInterval: options.retryInterval || 100,
+            agentId: options.agentId,
+            waitInQueue: options.waitInQueue !== false,
+            staleTimeout: options.staleTimeout || 300000
+        };
+        const absolutePath = path.resolve(filePath);
+        const lockPath = this.getLockPath(absolutePath);
+        const lockId = randomUUID();
+        logger.debug('Attempting lock acquisition', {
+            filePath: absolutePath,
+            lockId,
+            agentId: opts.agentId
+        });
+        // Try immediate acquisition
+        const immediateLock = await this.tryAcquireLock(absolutePath, lockPath, lockId, opts);
+        if (immediateLock) {
+            const acquisitionTime = Date.now() - startTime;
+            this.recordAcquisition(acquisitionTime);
+            logger.info('Lock acquired immediately', {
+                filePath: absolutePath,
+                lockId,
+                acquisitionTimeMs: acquisitionTime
+            });
+            return immediateLock;
+        }
+        // If immediate acquisition failed and queuing is enabled, wait in queue
+        if (opts.waitInQueue) {
+            return this.waitInQueue(absolutePath, lockPath, lockId, opts, startTime);
+        }
+        throw createTimeoutError(`acquire lock on ${absolutePath}`, 0);
+    }
+    /**
+   * Try to acquire lock immediately
+   */ async tryAcquireLock(filePath, lockPath, lockId, options) {
+        try {
+            // Check if lock file exists
+            const exists = await this.fileExists(lockPath);
+            if (exists) {
+                // Check if lock is stale
+                const isStale = await this.isLockStale(lockPath, options.staleTimeout);
+                if (isStale) {
+                    logger.warn('Removing stale lock', {
+                        lockPath
+                    });
+                    await this.forceReleaseLock(lockPath);
+                    this.metrics.staleLocksRemoved++;
+                } else {
+                    return null; // Lock is held by another process
+                }
+            }
+            // Create lock
+            const owner = {
+                pid: process.pid,
+                agentId: options.agentId,
+                hostname: require('os').hostname()
+            };
+            const expiresAt = new Date(Date.now() + options.timeout);
+            const metadata = {
+                lockId,
+                filePath,
+                owner,
+                acquiredAt: new Date().toISOString(),
+                expiresAt: expiresAt.toISOString(),
+                timeoutMs: options.timeout,
+                renewalCount: 0
+            };
+            // Write lock file atomically
+            await this.writeLockFile(lockPath, metadata);
+            // Verify we won the race
+            const verify = await this.readLockFile(lockPath);
+            if (verify.lockId !== lockId) {
+                logger.debug('Lost lock race', {
+                    lockId,
+                    winnerId: verify.lockId
+                });
+                return null;
+            }
+            // Create and store lock instance
+            const lock = {
+                id: lockId,
+                filePath,
+                lockPath,
+                owner,
+                acquiredAt: new Date(),
+                expiresAt,
+                timeoutMs: options.timeout,
+                renewalCount: 0
+            };
+            this.activeLocks.set(lockId, lock);
+            this.metrics.activeLocks++;
+            return lock;
+        } catch (error) {
+            logger.error('Error during lock acquisition attempt', error instanceof Error ? error : undefined, {
+                filePath,
+                lockId
+            });
+            return null;
+        }
+    }
+    /**
+   * Wait in queue for lock availability
+   */ async waitInQueue(filePath, lockPath, lockId, options, startTime) {
+        return new Promise((resolve, reject)=>{
+            const queueEntry = {
+                id: randomUUID(),
+                filePath,
+                agentId: options.agentId,
+                pid: process.pid,
+                queuedAt: new Date(),
+                resolve,
+                reject
+            };
+            // Set timeout
+            queueEntry.timeoutTimer = setTimeout(()=>{
+                this.removeFromQueue(filePath, queueEntry.id);
+                this.metrics.timeouts++;
+                reject(createTimeoutError(`acquire lock on ${filePath}`, options.timeout));
+            }, options.timeout);
+            // Add to queue
+            if (!this.lockQueues.has(filePath)) {
+                this.lockQueues.set(filePath, []);
+            }
+            this.lockQueues.get(filePath).push(queueEntry);
+            logger.debug('Added to lock queue', {
+                filePath,
+                queuePosition: this.lockQueues.get(filePath).length,
+                agentId: options.agentId
+            });
+            // Start polling for lock availability
+            this.pollForLock(filePath, lockPath, lockId, options, queueEntry, startTime);
+        });
+    }
+    /**
+   * Poll for lock availability
+   */ async pollForLock(filePath, lockPath, lockId, options, queueEntry, startTime) {
+        const pollInterval = setInterval(async ()=>{
+            try {
+                const lock = await this.tryAcquireLock(filePath, lockPath, lockId, options);
+                if (lock) {
+                    clearInterval(pollInterval);
+                    if (queueEntry.timeoutTimer) {
+                        clearTimeout(queueEntry.timeoutTimer);
+                    }
+                    this.removeFromQueue(filePath, queueEntry.id);
+                    const acquisitionTime = Date.now() - startTime;
+                    this.recordAcquisition(acquisitionTime);
+                    logger.info('Lock acquired from queue', {
+                        filePath,
+                        lockId,
+                        waitTimeMs: acquisitionTime
+                    });
+                    queueEntry.resolve(lock);
+                }
+            } catch (error) {
+                clearInterval(pollInterval);
+                if (queueEntry.timeoutTimer) {
+                    clearTimeout(queueEntry.timeoutTimer);
+                }
+                this.removeFromQueue(filePath, queueEntry.id);
+                queueEntry.reject(error instanceof Error ? error : new Error(`Lock acquisition failed: ${String(error)}`));
+            }
+        }, options.retryInterval);
+    }
+    /**
+   * Release a lock
+   *
+   * @param lockId - Lock ID to release
+   * @returns Promise that resolves when lock is released
+   */ async releaseLock(lockId) {
+        const lock = this.activeLocks.get(lockId);
+        if (!lock) {
+            logger.warn('Attempted to release non-existent lock', {
+                lockId
+            });
+            return;
+        }
+        try {
+            // Remove lock file
+            await fsUnlink(lock.lockPath);
+            // Remove from active locks
+            this.activeLocks.delete(lockId);
+            this.metrics.activeLocks--;
+            this.metrics.releases++;
+            logger.info('Lock released', {
+                lockId,
+                filePath: lock.filePath,
+                heldDurationMs: Date.now() - lock.acquiredAt.getTime()
+            });
+        } catch (error) {
+            logger.error('Error releasing lock', error instanceof Error ? error : undefined, {
+                lockId,
+                filePath: lock.filePath
+            });
+            throw createError(ErrorCode.LOCK_RELEASE_FAILED, `Failed to release lock ${lockId}`, {
+                lockId,
+                filePath: lock.filePath
+            }, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+   * Renew a lock (extend expiration time)
+   *
+   * @param lockId - Lock ID to renew
+   * @param extensionMs - Extension time in milliseconds
+   * @returns Promise that resolves when lock is renewed
+   */ async renewLock(lockId, extensionMs = 300000) {
+        const lock = this.activeLocks.get(lockId);
+        if (!lock) {
+            throw createError(ErrorCode.LOCK_NOT_FOUND, `Lock not found: ${lockId}`, {
+                lockId
+            });
+        }
+        try {
+            // Read current metadata
+            const metadata = await this.readLockFile(lock.lockPath);
+            // Verify ownership
+            if (metadata.lockId !== lockId) {
+                throw createError(ErrorCode.LOCK_OWNERSHIP_MISMATCH, 'Lock ownership mismatch during renewal', {
+                    lockId,
+                    actualOwnerId: metadata.lockId
+                });
+            }
+            // Update expiration
+            const newExpiresAt = new Date(Date.now() + extensionMs);
+            metadata.expiresAt = newExpiresAt.toISOString();
+            metadata.lastRenewedAt = new Date().toISOString();
+            metadata.renewalCount++;
+            // Write updated metadata
+            await this.writeLockFile(lock.lockPath, metadata);
+            // Update in-memory lock
+            lock.expiresAt = newExpiresAt;
+            lock.renewalCount = metadata.renewalCount;
+            this.metrics.renewals++;
+            logger.info('Lock renewed', {
+                lockId,
+                filePath: lock.filePath,
+                newExpiresAt: newExpiresAt.toISOString(),
+                renewalCount: metadata.renewalCount
+            });
+        } catch (error) {
+            logger.error('Error renewing lock', error instanceof Error ? error : undefined, {
+                lockId,
+                filePath: lock.filePath
+            });
+            throw error;
+        }
+    }
+    /**
+   * Force release a lock (for stuck locks)
+   *
+   * @param lockPath - Path to lock file
+   * @returns Promise that resolves when lock is force-released
+   */ async forceReleaseLock(lockPath) {
+        try {
+            const exists = await this.fileExists(lockPath);
+            if (exists) {
+                const metadata = await this.readLockFile(lockPath);
+                await fsUnlink(lockPath);
+                // Remove from active locks if present
+                if (this.activeLocks.has(metadata.lockId)) {
+                    this.activeLocks.delete(metadata.lockId);
+                    this.metrics.activeLocks--;
+                }
+                this.metrics.forceReleases++;
+                logger.warn('Lock force-released', {
+                    lockPath,
+                    lockId: metadata.lockId,
+                    owner: metadata.owner
+                });
+            }
+        } catch (error) {
+            logger.error('Error force-releasing lock', error instanceof Error ? error : undefined, {
+                lockPath
+            });
+            throw error;
+        }
+    }
+    /**
+   * Get lock metrics
+   */ getMetrics() {
+        return {
+            ...this.metrics
+        };
+    }
+    /**
+   * Get queue status for a file
+   */ getQueueStatus(filePath) {
+        const absolutePath = path.resolve(filePath);
+        const queue = this.lockQueues.get(absolutePath);
+        if (!queue || queue.length === 0) {
+            return null;
+        }
+        return {
+            position: 1,
+            total: queue.length
+        };
+    }
+    /**
+   * Helper: Get lock file path
+   */ getLockPath(filePath) {
+        const hash = this.hashFilePath(filePath);
+        return path.join(LOCK_DIR, `${hash}.lock`);
+    }
+    /**
+   * Helper: Hash file path for lock file naming
+   */ hashFilePath(filePath) {
+        const crypto = require('crypto');
+        return crypto.createHash('sha256').update(filePath).digest('hex').substring(0, 16);
+    }
+    /**
+   * Helper: Check if file exists
+   */ async fileExists(filePath) {
+        try {
+            await fsAccess(filePath, fs.constants.F_OK);
+            return true;
+        } catch  {
+            return false;
+        }
+    }
+    /**
+   * Helper: Check if lock is stale
+   */ async isLockStale(lockPath, staleTimeout) {
+        try {
+            const metadata = await this.readLockFile(lockPath);
+            const expiresAt = new Date(metadata.expiresAt);
+            const now = new Date();
+            return now > expiresAt;
+        } catch  {
+            // If we can't read the lock file, consider it stale
+            return true;
+        }
+    }
+    /**
+   * Helper: Write lock file
+   */ async writeLockFile(lockPath, metadata) {
+        await fsWriteFile(lockPath, JSON.stringify(metadata, null, 2), 'utf8');
+    }
+    /**
+   * Helper: Read lock file
+   */ async readLockFile(lockPath) {
+        const content = await fsReadFile(lockPath, 'utf8');
+        return JSON.parse(content);
+    }
+    /**
+   * Helper: Remove entry from queue
+   */ removeFromQueue(filePath, entryId) {
+        const queue = this.lockQueues.get(filePath);
+        if (queue) {
+            const index = queue.findIndex((e)=>e.id === entryId);
+            if (index !== -1) {
+                queue.splice(index, 1);
+            }
+            if (queue.length === 0) {
+                this.lockQueues.delete(filePath);
+            }
+        }
+    }
+    /**
+   * Helper: Record acquisition metrics
+   */ recordAcquisition(acquisitionTimeMs) {
+        this.metrics.acquisitions++;
+        this.metrics.totalAcquisitionTimeMs += acquisitionTimeMs;
+        this.metrics.avgAcquisitionTimeMs = this.metrics.totalAcquisitionTimeMs / this.metrics.acquisitions;
+    }
+    /**
+   * Ensure lock directory exists
+   */ ensureLockDirectory() {
+        try {
+            if (!fs.existsSync(LOCK_DIR)) {
+                fs.mkdirSync(LOCK_DIR, {
+                    recursive: true,
+                    mode: 0o755
+                });
+                logger.info('Created lock directory', {
+                    directory: LOCK_DIR
+                });
+            }
+        } catch (error) {
+            logger.error('Failed to create lock directory', error instanceof Error ? error : undefined, {
+                directory: LOCK_DIR
+            });
+        }
+    }
+    /**
+   * Setup periodic cleanup of stale locks
+   */ setupCleanupInterval() {
+        // Clean up stale locks every 60 seconds
+        this.cleanupInterval = setInterval(async ()=>{
+            await this.cleanupStaleLocks();
+        }, 60000);
+    }
+    /**
+   * Cleanup stale locks
+   */ async cleanupStaleLocks() {
+        try {
+            const files = fs.readdirSync(LOCK_DIR);
+            for (const file of files){
+                if (file.endsWith('.lock')) {
+                    const lockPath = path.join(LOCK_DIR, file);
+                    const isStale = await this.isLockStale(lockPath, 300000);
+                    if (isStale) {
+                        await this.forceReleaseLock(lockPath);
+                    }
+                }
+            }
+        } catch (error) {
+            logger.error('Error during stale lock cleanup', error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+   * Setup process exit handlers to release locks
+   */ setupProcessExitHandlers() {
+        const cleanup = async ()=>{
+            logger.info('Process exiting, releasing all locks', {
+                activeLocksCount: this.activeLocks.size
+            });
+            for (const [lockId, lock] of this.activeLocks.entries()){
+                try {
+                    await this.releaseLock(lockId);
+                } catch (error) {
+                    logger.error('Error releasing lock on exit', error instanceof Error ? error : undefined, {
+                        lockId,
+                        filePath: lock.filePath
+                    });
+                }
+            }
+            if (this.cleanupInterval) {
+                clearInterval(this.cleanupInterval);
+            }
+        };
+        process.on('exit', ()=>{
+            // Synchronous cleanup only
+            for (const [, lock] of this.activeLocks.entries()){
+                try {
+                    fs.unlinkSync(lock.lockPath);
+                } catch  {}
+            }
+        });
+        process.on('SIGINT', async ()=>{
+            await cleanup();
+            process.exit(0);
+        });
+        process.on('SIGTERM', async ()=>{
+            await cleanup();
+            process.exit(0);
+        });
+    }
+    /**
+   * Shutdown the lock manager
+   */ async shutdown() {
+        logger.info('Shutting down file lock manager');
+        // Clear cleanup interval
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+        }
+        // Release all active locks
+        for (const lockId of this.activeLocks.keys()){
+            await this.releaseLock(lockId);
+        }
+        // Clear all queues
+        for (const [, queue] of this.lockQueues.entries()){
+            for (const entry of queue){
+                if (entry.timeoutTimer) {
+                    clearTimeout(entry.timeoutTimer);
+                }
+                entry.reject(new Error('Lock manager shutting down'));
+            }
+        }
+        this.lockQueues.clear();
+    }
+}
+/**
+ * Singleton instance
+ */ let defaultManager = null;
+/**
+ * Get the default file lock manager instance
+ */ export function getFileLockManager() {
+    if (!defaultManager) {
+        defaultManager = new FileLockManager();
+    }
+    return defaultManager;
+}
+/**
+ * Execute a function with file lock
+ *
+ * @param filePath - File to lock
+ * @param fn - Function to execute
+ * @param options - Lock options
+ * @returns Promise that resolves with function result
+ */ export async function withFileLock(filePath, fn, options = {}) {
+    const manager = getFileLockManager();
+    const lock = await manager.acquireLock(filePath, options);
+    try {
+        return await fn();
+    } finally{
+        await manager.releaseLock(lock.id);
+    }
+}
+
+//# sourceMappingURL=file-lock-manager.js.map

package/dist/lib/file-lock-manager.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/file-lock-manager.ts"],"sourcesContent":["/**\r\n * File Lock Manager\r\n *\r\n * Centralized file locking system with queuing, renewal, and monitoring.\r\n * Part of Task 4.2: Centralized File Locking & Atomic Operations\r\n *\r\n * Features:\r\n * - Lock acquisition with configurable timeout (300s default)\r\n * - Waiting queue for blocked processes\r\n * - Lock renewal for long-running operations\r\n * - Force release capability for stuck locks\r\n * - Owner tracking (process ID + agent ID)\r\n * - Stale lock detection and cleanup\r\n * - Performance monitoring (<100ms acquisition target)\r\n * - Automatic lock release on process exit\r\n *\r\n * Usage:\r\n *   const manager = new FileLockManager();\r\n *   const lock = await manager.acquireLock('/path/to/file.txt', {\r\n *     agentId: 'backend-dev-001',\r\n *     timeout: 30000\r\n *   });\r\n *   try {\r\n *     // Perform file operations\r\n *   } finally {\r\n *     await manager.releaseLock(lock.id);\r\n *   }\r\n */\r\n\r\nimport * as fs from 'fs';\r\nimport * as path from 'path';\r\nimport { promisify } from 'util';\r\nimport { randomUUID } from 'crypto';\r\nimport { createLogger } from './logging.js';\r\nimport { createError, ErrorCode, createTimeoutError } from './errors.js';\r\n\r\nconst logger = createLogger('file-lock-manager');\r\n\r\nconst fsWriteFile = promisify(fs.writeFile);\r\nconst fsReadFile = promisify(fs.readFile);\r\nconst fsUnlink = promisify(fs.unlink);\r\nconst fsStat = promisify(fs.stat);\r\nconst fsMkdir = promisify(fs.mkdir);\r\nconst fsAccess = promisify(fs.access);\r\n\r\n/**\r\n * Lock directory (defaults to /tmp/cfn-locks/)\r\n */\r\nconst LOCK_DIR = process.env.CFN_LOCK_DIR || '/tmp/cfn-locks';\r\n\r\n/**\r\n * Lock owner information\r\n */\r\nexport interface LockOwner {\r\n  /** Process ID */\r\n  pid: number;\r\n  /** Agent ID (optional) */\r\n  agentId?: string;\r\n  /** Hostname (for distributed systems) */\r\n  hostname: string;\r\n}\r\n\r\n/**\r\n * Lock metadata stored in lock file\r\n */\r\nexport interface LockMetadata {\r\n  /** Unique lock ID */\r\n  lockId: string;\r\n  /** File path being locked */\r\n  filePath: string;\r\n  /** Lock owner information */\r\n  owner: LockOwner;\r\n  /** Acquisition timestamp */\r\n  acquiredAt: string;\r\n  /** Expiration timestamp */\r\n  expiresAt: string;\r\n  /** Timeout in milliseconds */\r\n  timeoutMs: number;\r\n  /** Last renewal timestamp */\r\n  lastRenewedAt?: string;\r\n  /** Number of renewals */\r\n  renewalCount: number;\r\n}\r\n\r\n/**\r\n * Active lock instance\r\n */\r\nexport interface FileLock {\r\n  /** Lock ID */\r\n  id: string;\r\n  /** File path */\r\n  filePath: string;\r\n  /** Lock file path */\r\n  lockPath: string;\r\n  /** Owner information */\r\n  owner: LockOwner;\r\n  /** Acquisition time */\r\n  acquiredAt: Date;\r\n  /** Expiration time */\r\n  expiresAt: Date;\r\n  /** Timeout in milliseconds */\r\n  timeoutMs: number;\r\n  /** Renewal count */\r\n  renewalCount: number;\r\n}\r\n\r\n/**\r\n * Lock acquisition options\r\n */\r\nexport interface LockAcquisitionOptions {\r\n  /** Timeout in milliseconds (default: 300000 = 5 minutes) */\r\n  timeout?: number;\r\n  /** Retry interval in milliseconds (default: 100) */\r\n  retryInterval?: number;\r\n  /** Agent ID for tracking */\r\n  agentId?: string;\r\n  /** Wait in queue if lock is held (default: true) */\r\n  waitInQueue?: boolean;\r\n  /** Stale lock detection timeout in milliseconds (default: 300000) */\r\n  staleTimeout?: number;\r\n}\r\n\r\n/**\r\n * Queue entry for waiting processes\r\n */\r\ninterface QueueEntry {\r\n  /** Entry ID */\r\n  id: string;\r\n  /** File path */\r\n  filePath: string;\r\n  /** Agent ID */\r\n  agentId?: string;\r\n  /** Process ID */\r\n  pid: number;\r\n  /** Queued timestamp */\r\n  queuedAt: Date;\r\n  /** Resolve function */\r\n  resolve: (lock: FileLock) => void;\r\n  /** Reject function */\r\n  reject: (error: Error) => void;\r\n  /** Timeout timer */\r\n  timeoutTimer?: NodeJS.Timeout;\r\n}\r\n\r\n/**\r\n * Lock acquisition metrics\r\n */\r\nexport interface LockMetrics {\r\n  /** Total lock acquisitions */\r\n  acquisitions: number;\r\n  /** Total lock releases */\r\n  releases: number;\r\n  /** Current active locks */\r\n  activeLocks: number;\r\n  /** Total lock timeouts */\r\n  timeouts: number;\r\n  /** Total stale locks cleaned */\r\n  staleLocksRemoved: number;\r\n  /** Average acquisition time (ms) */\r\n  avgAcquisitionTimeMs: number;\r\n  /** Total time spent acquiring locks (ms) */\r\n  totalAcquisitionTimeMs: number;\r\n  /** Lock renewals */\r\n  renewals: number;\r\n  /** Force releases */\r\n  forceReleases: number;\r\n}\r\n\r\n/**\r\n * File Lock Manager\r\n *\r\n * Manages file locks with queuing, renewal, and monitoring capabilities.\r\n */\r\nexport class FileLockManager {\r\n  private activeLocks: Map<string, FileLock> = new Map();\r\n  private lockQueues: Map<string, QueueEntry[]> = new Map();\r\n  private metrics: LockMetrics = {\r\n    acquisitions: 0,\r\n    releases: 0,\r\n    activeLocks: 0,\r\n    timeouts: 0,\r\n    staleLocksRemoved: 0,\r\n    avgAcquisitionTimeMs: 0,\r\n    totalAcquisitionTimeMs: 0,\r\n    renewals: 0,\r\n    forceReleases: 0,\r\n  };\r\n  private cleanupInterval: NodeJS.Timeout | null = null;\r\n\r\n  constructor() {\r\n    this.ensureLockDirectory();\r\n    this.setupCleanupInterval();\r\n    this.setupProcessExitHandlers();\r\n  }\r\n\r\n  /**\r\n   * Acquire a file lock\r\n   *\r\n   * @param filePath - Path to file to lock\r\n   * @param options - Lock acquisition options\r\n   * @returns Promise<FileLock> - Lock instance\r\n   * @throws LOCK_TIMEOUT if acquisition times out\r\n   */\r\n  async acquireLock(\r\n    filePath: string,\r\n    options: LockAcquisitionOptions = {}\r\n  ): Promise<FileLock> {\r\n    const startTime = Date.now();\r\n    const opts = {\r\n      timeout: options.timeout || 300000, // 5 minutes default\r\n      retryInterval: options.retryInterval || 100,\r\n      agentId: options.agentId,\r\n      waitInQueue: options.waitInQueue !== false,\r\n      staleTimeout: options.staleTimeout || 300000,\r\n    };\r\n\r\n    const absolutePath = path.resolve(filePath);\r\n    const lockPath = this.getLockPath(absolutePath);\r\n    const lockId = randomUUID();\r\n\r\n    logger.debug('Attempting lock acquisition', {\r\n      filePath: absolutePath,\r\n      lockId,\r\n      agentId: opts.agentId,\r\n    });\r\n\r\n    // Try immediate acquisition\r\n    const immediateLock = await this.tryAcquireLock(\r\n      absolutePath,\r\n      lockPath,\r\n      lockId,\r\n      opts\r\n    );\r\n\r\n    if (immediateLock) {\r\n      const acquisitionTime = Date.now() - startTime;\r\n      this.recordAcquisition(acquisitionTime);\r\n      logger.info('Lock acquired immediately', {\r\n        filePath: absolutePath,\r\n        lockId,\r\n        acquisitionTimeMs: acquisitionTime,\r\n      });\r\n      return immediateLock;\r\n    }\r\n\r\n    // If immediate acquisition failed and queuing is enabled, wait in queue\r\n    if (opts.waitInQueue) {\r\n      return this.waitInQueue(absolutePath, lockPath, lockId, opts, startTime);\r\n    }\r\n\r\n    throw createTimeoutError(`acquire lock on ${absolutePath}`, 0);\r\n  }\r\n\r\n  /**\r\n   * Try to acquire lock immediately\r\n   */\r\n  private async tryAcquireLock(\r\n    filePath: string,\r\n    lockPath: string,\r\n    lockId: string,\r\n    options: Required<LockAcquisitionOptions>\r\n  ): Promise<FileLock | null> {\r\n    try {\r\n      // Check if lock file exists\r\n      const exists = await this.fileExists(lockPath);\r\n\r\n      if (exists) {\r\n        // Check if lock is stale\r\n        const isStale = await this.isLockStale(lockPath, options.staleTimeout);\r\n\r\n        if (isStale) {\r\n          logger.warn('Removing stale lock', { lockPath });\r\n          await this.forceReleaseLock(lockPath);\r\n          this.metrics.staleLocksRemoved++;\r\n        } else {\r\n          return null; // Lock is held by another process\r\n        }\r\n      }\r\n\r\n      // Create lock\r\n      const owner: LockOwner = {\r\n        pid: process.pid,\r\n        agentId: options.agentId,\r\n        hostname: require('os').hostname(),\r\n      };\r\n\r\n      const expiresAt = new Date(Date.now() + options.timeout);\r\n      const metadata: LockMetadata = {\r\n        lockId,\r\n        filePath,\r\n        owner,\r\n        acquiredAt: new Date().toISOString(),\r\n        expiresAt: expiresAt.toISOString(),\r\n        timeoutMs: options.timeout,\r\n        renewalCount: 0,\r\n      };\r\n\r\n      // Write lock file atomically\r\n      await this.writeLockFile(lockPath, metadata);\r\n\r\n      // Verify we won the race\r\n      const verify = await this.readLockFile(lockPath);\r\n      if (verify.lockId !== lockId) {\r\n        logger.debug('Lost lock race', { lockId, winnerId: verify.lockId });\r\n        return null;\r\n      }\r\n\r\n      // Create and store lock instance\r\n      const lock: FileLock = {\r\n        id: lockId,\r\n        filePath,\r\n        lockPath,\r\n        owner,\r\n        acquiredAt: new Date(),\r\n        expiresAt,\r\n        timeoutMs: options.timeout,\r\n        renewalCount: 0,\r\n      };\r\n\r\n      this.activeLocks.set(lockId, lock);\r\n      this.metrics.activeLocks++;\r\n\r\n      return lock;\r\n    } catch (error) {\r\n      logger.error(\r\n        'Error during lock acquisition attempt',\r\n        error instanceof Error ? error : undefined,\r\n        { filePath, lockId }\r\n      );\r\n      return null;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Wait in queue for lock availability\r\n   */\r\n  private async waitInQueue(\r\n    filePath: string,\r\n    lockPath: string,\r\n    lockId: string,\r\n    options: Required<LockAcquisitionOptions>,\r\n    startTime: number\r\n  ): Promise<FileLock> {\r\n    return new Promise((resolve, reject) => {\r\n      const queueEntry: QueueEntry = {\r\n        id: randomUUID(),\r\n        filePath,\r\n        agentId: options.agentId,\r\n        pid: process.pid,\r\n        queuedAt: new Date(),\r\n        resolve,\r\n        reject,\r\n      };\r\n\r\n      // Set timeout\r\n      queueEntry.timeoutTimer = setTimeout(() => {\r\n        this.removeFromQueue(filePath, queueEntry.id);\r\n        this.metrics.timeouts++;\r\n        reject(createTimeoutError(`acquire lock on ${filePath}`, options.timeout));\r\n      }, options.timeout);\r\n\r\n      // Add to queue\r\n      if (!this.lockQueues.has(filePath)) {\r\n        this.lockQueues.set(filePath, []);\r\n      }\r\n      this.lockQueues.get(filePath)!.push(queueEntry);\r\n\r\n      logger.debug('Added to lock queue', {\r\n        filePath,\r\n        queuePosition: this.lockQueues.get(filePath)!.length,\r\n        agentId: options.agentId,\r\n      });\r\n\r\n      // Start polling for lock availability\r\n      this.pollForLock(filePath, lockPath, lockId, options, queueEntry, startTime);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Poll for lock availability\r\n   */\r\n  private async pollForLock(\r\n    filePath: string,\r\n    lockPath: string,\r\n    lockId: string,\r\n    options: Required<LockAcquisitionOptions>,\r\n    queueEntry: QueueEntry,\r\n    startTime: number\r\n  ): Promise<void> {\r\n    const pollInterval = setInterval(async () => {\r\n      try {\r\n        const lock = await this.tryAcquireLock(filePath, lockPath, lockId, options);\r\n\r\n        if (lock) {\r\n          clearInterval(pollInterval);\r\n          if (queueEntry.timeoutTimer) {\r\n            clearTimeout(queueEntry.timeoutTimer);\r\n          }\r\n          this.removeFromQueue(filePath, queueEntry.id);\r\n\r\n          const acquisitionTime = Date.now() - startTime;\r\n          this.recordAcquisition(acquisitionTime);\r\n\r\n          logger.info('Lock acquired from queue', {\r\n            filePath,\r\n            lockId,\r\n            waitTimeMs: acquisitionTime,\r\n          });\r\n\r\n          queueEntry.resolve(lock);\r\n        }\r\n      } catch (error) {\r\n        clearInterval(pollInterval);\r\n        if (queueEntry.timeoutTimer) {\r\n          clearTimeout(queueEntry.timeoutTimer);\r\n        }\r\n        this.removeFromQueue(filePath, queueEntry.id);\r\n        queueEntry.reject(\r\n          error instanceof Error\r\n            ? error\r\n            : new Error(`Lock acquisition failed: ${String(error)}`)\r\n        );\r\n      }\r\n    }, options.retryInterval);\r\n  }\r\n\r\n  /**\r\n   * Release a lock\r\n   *\r\n   * @param lockId - Lock ID to release\r\n   * @returns Promise that resolves when lock is released\r\n   */\r\n  async releaseLock(lockId: string): Promise<void> {\r\n    const lock = this.activeLocks.get(lockId);\r\n\r\n    if (!lock) {\r\n      logger.warn('Attempted to release non-existent lock', { lockId });\r\n      return;\r\n    }\r\n\r\n    try {\r\n      // Remove lock file\r\n      await fsUnlink(lock.lockPath);\r\n\r\n      // Remove from active locks\r\n      this.activeLocks.delete(lockId);\r\n      this.metrics.activeLocks--;\r\n      this.metrics.releases++;\r\n\r\n      logger.info('Lock released', {\r\n        lockId,\r\n        filePath: lock.filePath,\r\n        heldDurationMs: Date.now() - lock.acquiredAt.getTime(),\r\n      });\r\n    } catch (error) {\r\n      logger.error(\r\n        'Error releasing lock',\r\n        error instanceof Error ? error : undefined,\r\n        { lockId, filePath: lock.filePath }\r\n      );\r\n      throw createError(\r\n        ErrorCode.LOCK_RELEASE_FAILED,\r\n        `Failed to release lock ${lockId}`,\r\n        { lockId, filePath: lock.filePath },\r\n        error instanceof Error ? error : undefined\r\n      );\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Renew a lock (extend expiration time)\r\n   *\r\n   * @param lockId - Lock ID to renew\r\n   * @param extensionMs - Extension time in milliseconds\r\n   * @returns Promise that resolves when lock is renewed\r\n   */\r\n  async renewLock(lockId: string, extensionMs: number = 300000): Promise<void> {\r\n    const lock = this.activeLocks.get(lockId);\r\n\r\n    if (!lock) {\r\n      throw createError(ErrorCode.LOCK_NOT_FOUND, `Lock not found: ${lockId}`, {\r\n        lockId,\r\n      });\r\n    }\r\n\r\n    try {\r\n      // Read current metadata\r\n      const metadata = await this.readLockFile(lock.lockPath);\r\n\r\n      // Verify ownership\r\n      if (metadata.lockId !== lockId) {\r\n        throw createError(\r\n          ErrorCode.LOCK_OWNERSHIP_MISMATCH,\r\n          'Lock ownership mismatch during renewal',\r\n          { lockId, actualOwnerId: metadata.lockId }\r\n        );\r\n      }\r\n\r\n      // Update expiration\r\n      const newExpiresAt = new Date(Date.now() + extensionMs);\r\n      metadata.expiresAt = newExpiresAt.toISOString();\r\n      metadata.lastRenewedAt = new Date().toISOString();\r\n      metadata.renewalCount++;\r\n\r\n      // Write updated metadata\r\n      await this.writeLockFile(lock.lockPath, metadata);\r\n\r\n      // Update in-memory lock\r\n      lock.expiresAt = newExpiresAt;\r\n      lock.renewalCount = metadata.renewalCount;\r\n\r\n      this.metrics.renewals++;\r\n\r\n      logger.info('Lock renewed', {\r\n        lockId,\r\n        filePath: lock.filePath,\r\n        newExpiresAt: newExpiresAt.toISOString(),\r\n        renewalCount: metadata.renewalCount,\r\n      });\r\n    } catch (error) {\r\n      logger.error(\r\n        'Error renewing lock',\r\n        error instanceof Error ? error : undefined,\r\n        { lockId, filePath: lock.filePath }\r\n      );\r\n      throw error;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Force release a lock (for stuck locks)\r\n   *\r\n   * @param lockPath - Path to lock file\r\n   * @returns Promise that resolves when lock is force-released\r\n   */\r\n  async forceReleaseLock(lockPath: string): Promise<void> {\r\n    try {\r\n      const exists = await this.fileExists(lockPath);\r\n\r\n      if (exists) {\r\n        const metadata = await this.readLockFile(lockPath);\r\n        await fsUnlink(lockPath);\r\n\r\n        // Remove from active locks if present\r\n        if (this.activeLocks.has(metadata.lockId)) {\r\n          this.activeLocks.delete(metadata.lockId);\r\n          this.metrics.activeLocks--;\r\n        }\r\n\r\n        this.metrics.forceReleases++;\r\n\r\n        logger.warn('Lock force-released', {\r\n          lockPath,\r\n          lockId: metadata.lockId,\r\n          owner: metadata.owner,\r\n        });\r\n      }\r\n    } catch (error) {\r\n      logger.error(\r\n        'Error force-releasing lock',\r\n        error instanceof Error ? error : undefined,\r\n        { lockPath }\r\n      );\r\n      throw error;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get lock metrics\r\n   */\r\n  getMetrics(): LockMetrics {\r\n    return { ...this.metrics };\r\n  }\r\n\r\n  /**\r\n   * Get queue status for a file\r\n   */\r\n  getQueueStatus(filePath: string): { position: number; total: number } | null {\r\n    const absolutePath = path.resolve(filePath);\r\n    const queue = this.lockQueues.get(absolutePath);\r\n\r\n    if (!queue || queue.length === 0) {\r\n      return null;\r\n    }\r\n\r\n    return {\r\n      position: 1, // First in queue\r\n      total: queue.length,\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Helper: Get lock file path\r\n   */\r\n  private getLockPath(filePath: string): string {\r\n    const hash = this.hashFilePath(filePath);\r\n    return path.join(LOCK_DIR, `${hash}.lock`);\r\n  }\r\n\r\n  /**\r\n   * Helper: Hash file path for lock file naming\r\n   */\r\n  private hashFilePath(filePath: string): string {\r\n    const crypto = require('crypto');\r\n    return crypto.createHash('sha256').update(filePath).digest('hex').substring(0, 16);\r\n  }\r\n\r\n  /**\r\n   * Helper: Check if file exists\r\n   */\r\n  private async fileExists(filePath: string): Promise<boolean> {\r\n    try {\r\n      await fsAccess(filePath, fs.constants.F_OK);\r\n      return true;\r\n    } catch {\r\n      return false;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Helper: Check if lock is stale\r\n   */\r\n  private async isLockStale(lockPath: string, staleTimeout: number): Promise<boolean> {\r\n    try {\r\n      const metadata = await this.readLockFile(lockPath);\r\n      const expiresAt = new Date(metadata.expiresAt);\r\n      const now = new Date();\r\n\r\n      return now > expiresAt;\r\n    } catch {\r\n      // If we can't read the lock file, consider it stale\r\n      return true;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Helper: Write lock file\r\n   */\r\n  private async writeLockFile(lockPath: string, metadata: LockMetadata): Promise<void> {\r\n    await fsWriteFile(lockPath, JSON.stringify(metadata, null, 2), 'utf8');\r\n  }\r\n\r\n  /**\r\n   * Helper: Read lock file\r\n   */\r\n  private async readLockFile(lockPath: string): Promise<LockMetadata> {\r\n    const content = await fsReadFile(lockPath, 'utf8');\r\n    return JSON.parse(content) as LockMetadata;\r\n  }\r\n\r\n  /**\r\n   * Helper: Remove entry from queue\r\n   */\r\n  private removeFromQueue(filePath: string, entryId: string): void {\r\n    const queue = this.lockQueues.get(filePath);\r\n    if (queue) {\r\n      const index = queue.findIndex((e) => e.id === entryId);\r\n      if (index !== -1) {\r\n        queue.splice(index, 1);\r\n      }\r\n      if (queue.length === 0) {\r\n        this.lockQueues.delete(filePath);\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Helper: Record acquisition metrics\r\n   */\r\n  private recordAcquisition(acquisitionTimeMs: number): void {\r\n    this.metrics.acquisitions++;\r\n    this.metrics.totalAcquisitionTimeMs += acquisitionTimeMs;\r\n    this.metrics.avgAcquisitionTimeMs =\r\n      this.metrics.totalAcquisitionTimeMs / this.metrics.acquisitions;\r\n  }\r\n\r\n  /**\r\n   * Ensure lock directory exists\r\n   */\r\n  private ensureLockDirectory(): void {\r\n    try {\r\n      if (!fs.existsSync(LOCK_DIR)) {\r\n        fs.mkdirSync(LOCK_DIR, { recursive: true, mode: 0o755 });\r\n        logger.info('Created lock directory', { directory: LOCK_DIR });\r\n      }\r\n    } catch (error) {\r\n      logger.error(\r\n        'Failed to create lock directory',\r\n        error instanceof Error ? error : undefined,\r\n        { directory: LOCK_DIR }\r\n      );\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Setup periodic cleanup of stale locks\r\n   */\r\n  private setupCleanupInterval(): void {\r\n    // Clean up stale locks every 60 seconds\r\n    this.cleanupInterval = setInterval(async () => {\r\n      await this.cleanupStaleLocks();\r\n    }, 60000);\r\n  }\r\n\r\n  /**\r\n   * Cleanup stale locks\r\n   */\r\n  private async cleanupStaleLocks(): Promise<void> {\r\n    try {\r\n      const files = fs.readdirSync(LOCK_DIR);\r\n\r\n      for (const file of files) {\r\n        if (file.endsWith('.lock')) {\r\n          const lockPath = path.join(LOCK_DIR, file);\r\n          const isStale = await this.isLockStale(lockPath, 300000);\r\n\r\n          if (isStale) {\r\n            await this.forceReleaseLock(lockPath);\r\n          }\r\n        }\r\n      }\r\n    } catch (error) {\r\n      logger.error(\r\n        'Error during stale lock cleanup',\r\n        error instanceof Error ? error : undefined\r\n      );\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Setup process exit handlers to release locks\r\n   */\r\n  private setupProcessExitHandlers(): void {\r\n    const cleanup = async () => {\r\n      logger.info('Process exiting, releasing all locks', {\r\n        activeLocksCount: this.activeLocks.size,\r\n      });\r\n\r\n      for (const [lockId, lock] of this.activeLocks.entries()) {\r\n        try {\r\n          await this.releaseLock(lockId);\r\n        } catch (error) {\r\n          logger.error(\r\n            'Error releasing lock on exit',\r\n            error instanceof Error ? error : undefined,\r\n            { lockId, filePath: lock.filePath }\r\n          );\r\n        }\r\n      }\r\n\r\n      if (this.cleanupInterval) {\r\n        clearInterval(this.cleanupInterval);\r\n      }\r\n    };\r\n\r\n    process.on('exit', () => {\r\n      // Synchronous cleanup only\r\n      for (const [, lock] of this.activeLocks.entries()) {\r\n        try {\r\n          fs.unlinkSync(lock.lockPath);\r\n        } catch {}\r\n      }\r\n    });\r\n\r\n    process.on('SIGINT', async () => {\r\n      await cleanup();\r\n      process.exit(0);\r\n    });\r\n\r\n    process.on('SIGTERM', async () => {\r\n      await cleanup();\r\n      process.exit(0);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Shutdown the lock manager\r\n   */\r\n  async shutdown(): Promise<void> {\r\n    logger.info('Shutting down file lock manager');\r\n\r\n    // Clear cleanup interval\r\n    if (this.cleanupInterval) {\r\n      clearInterval(this.cleanupInterval);\r\n    }\r\n\r\n    // Release all active locks\r\n    for (const lockId of this.activeLocks.keys()) {\r\n      await this.releaseLock(lockId);\r\n    }\r\n\r\n    // Clear all queues\r\n    for (const [, queue] of this.lockQueues.entries()) {\r\n      for (const entry of queue) {\r\n        if (entry.timeoutTimer) {\r\n          clearTimeout(entry.timeoutTimer);\r\n        }\r\n        entry.reject(new Error('Lock manager shutting down'));\r\n      }\r\n    }\r\n    this.lockQueues.clear();\r\n  }\r\n}\r\n\r\n/**\r\n * Singleton instance\r\n */\r\nlet defaultManager: FileLockManager | null = null;\r\n\r\n/**\r\n * Get the default file lock manager instance\r\n */\r\nexport function getFileLockManager(): FileLockManager {\r\n  if (!defaultManager) {\r\n    defaultManager = new FileLockManager();\r\n  }\r\n  return defaultManager;\r\n}\r\n\r\n/**\r\n * Execute a function with file lock\r\n *\r\n * @param filePath - File to lock\r\n * @param fn - Function to execute\r\n * @param options - Lock options\r\n * @returns Promise that resolves with function result\r\n */\r\nexport async function withFileLock<T>(\r\n  filePath: string,\r\n  fn: () => Promise<T>,\r\n  options: LockAcquisitionOptions = {}\r\n): Promise<T> {\r\n  const manager = getFileLockManager();\r\n  const lock = await manager.acquireLock(filePath, options);\r\n\r\n  try {\r\n    return await fn();\r\n  } finally {\r\n    await manager.releaseLock(lock.id);\r\n  }\r\n}\r\n"],"names":["fs","path","promisify","randomUUID","createLogger","createError","ErrorCode","createTimeoutError","logger","fsWriteFile","writeFile","fsReadFile","readFile","fsUnlink","unlink","fsStat","stat","fsMkdir","mkdir","fsAccess","access","LOCK_DIR","process","env","CFN_LOCK_DIR","FileLockManager","activeLocks","Map","lockQueues","metrics","acquisitions","releases","timeouts","staleLocksRemoved","avgAcquisitionTimeMs","totalAcquisitionTimeMs","renewals","forceReleases","cleanupInterval","ensureLockDirectory","setupCleanupInterval","setupProcessExitHandlers","acquireLock","filePath","options","startTime","Date","now","opts","timeout","retryInterval","agentId","waitInQueue","staleTimeout","absolutePath","resolve","lockPath","getLockPath","lockId","debug","immediateLock","tryAcquireLock","acquisitionTime","recordAcquisition","info","acquisitionTimeMs","exists","fileExists","isStale","isLockStale","warn","forceReleaseLock","owner","pid","hostname","require","expiresAt","metadata","acquiredAt","toISOString","timeoutMs","renewalCount","writeLockFile","verify","readLockFile","winnerId","lock","id","set","error","Error","undefined","Promise","reject","queueEntry","queuedAt","timeoutTimer","setTimeout","removeFromQueue","has","get","push","queuePosition","length","pollForLock","pollInterval","setInterval","clearInterval","clearTimeout","waitTimeMs","String","releaseLock","delete","heldDurationMs","getTime","LOCK_RELEASE_FAILED","renewLock","extensionMs","LOCK_NOT_FOUND","LOCK_OWNERSHIP_MISMATCH","actualOwnerId","newExpiresAt","lastRenewedAt","getMetrics","getQueueStatus","queue","position","total","hash","hashFilePath","join","crypto","createHash","update","digest","substring","constants","F_OK","JSON","stringify","content","parse","entryId","index","findIndex","e","splice","existsSync","mkdirSync","recursive","mode","directory","cleanupStaleLocks","files","readdirSync","file","endsWith","cleanup","activeLocksCount","size","entries","on","unlinkSync","exit","shutdown","keys","entry","clear","defaultManager","getFileLockManager","withFileLock","fn","manager"],"mappings":"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"}