@magentrix-corp/magentrix-cli 1.3.16 → 1.3.17

package/utils/iris/lock.js

@@ -1,360 +1,360 @@
-/**
- * Operation locking system for Iris Vue integration.
- * Prevents concurrent operations that could cause data corruption.
- */
-
-import { existsSync, writeFileSync, readFileSync, unlinkSync, mkdirSync } from 'node:fs';
-import { join, dirname } from 'node:path';
-import { formatConcurrentOperationError } from './errors.js';
-
-/**
- * Lock directory relative to workspace.
- */
-const LOCK_DIR = '.magentrix/locks';
-
-/**
- * Lock types for different operations.
- */
-export const LockTypes = {
-    BUILD: 'build',
-    STAGE: 'stage',
-    PUBLISH: 'publish',
-    DELETE: 'delete',
-    RECOVER: 'recover',
-    DEV_SERVER: 'dev-server'
-};
-
-/**
- * Default lock timeout in milliseconds (5 minutes).
- * Locks older than this are considered stale and can be overwritten.
- */
-const DEFAULT_LOCK_TIMEOUT = 5 * 60 * 1000;
-
-/**
- * Get the lock file path for a given lock type and context.
- *
- * @param {string} lockType - One of LockTypes
- * @param {string} context - Context identifier (e.g., workspace path, project slug)
- * @param {string} basePath - Base path for lock files (defaults to cwd)
- * @returns {string} - Path to the lock file
- */
-function getLockPath(lockType, context = 'global', basePath = process.cwd()) {
-    const lockDir = join(basePath, LOCK_DIR);
-    const safeContext = context.replace(/[^a-zA-Z0-9-_]/g, '_');
-    return join(lockDir, `${lockType}-${safeContext}.lock`);
-}
-
-/**
- * Create lock file data.
- *
- * @param {string} operation - Description of the operation
- * @returns {Object} - Lock data
- */
-function createLockData(operation) {
-    return {
-        pid: process.pid,
-        operation,
-        startedAt: new Date().toISOString(),
-        hostname: process.env.HOSTNAME || process.env.COMPUTERNAME || 'unknown'
-    };
-}
-
-/**
- * Check if a lock is stale (older than timeout).
- *
- * @param {Object} lockData - The lock file data
- * @param {number} timeout - Timeout in milliseconds
- * @returns {boolean} - True if lock is stale
- */
-function isLockStale(lockData, timeout = DEFAULT_LOCK_TIMEOUT) {
-    if (!lockData.startedAt) {
-        return true;
-    }
-
-    const startTime = new Date(lockData.startedAt).getTime();
-    const now = Date.now();
-
-    return (now - startTime) > timeout;
-}
-
-/**
- * Check if the process that created the lock is still running.
- *
- * @param {number} pid - Process ID to check
- * @returns {boolean} - True if process is running
- */
-function isProcessRunning(pid) {
-    try {
-        // Sending signal 0 checks if process exists without killing it
-        process.kill(pid, 0);
-        return true;
-    } catch (err) {
-        // ESRCH means process doesn't exist
-        // EPERM means process exists but we don't have permission
-        return err.code === 'EPERM';
-    }
-}
-
-/**
- * Acquire a lock for an operation.
- *
- * @param {string} lockType - One of LockTypes
- * @param {Object} options - Lock options
- * @param {string} options.context - Context identifier
- * @param {string} options.operation - Description of the operation
- * @param {string} options.basePath - Base path for lock files
- * @param {number} options.timeout - Lock timeout in milliseconds
- * @param {boolean} options.force - Force acquire even if locked
- * @returns {{
- *   acquired: boolean,
- *   lockPath: string,
- *   error: string | null,
- *   existingLock: Object | null
- * }}
- */
-export function acquireLock(lockType, options = {}) {
-    const {
-        context = 'global',
-        operation = lockType,
-        basePath = process.cwd(),
-        timeout = DEFAULT_LOCK_TIMEOUT,
-        force = false
-    } = options;
-
-    const lockPath = getLockPath(lockType, context, basePath);
-    const lockDir = dirname(lockPath);
-
-    const result = {
-        acquired: false,
-        lockPath,
-        error: null,
-        existingLock: null
-    };
-
-    // Ensure lock directory exists
-    try {
-        if (!existsSync(lockDir)) {
-            mkdirSync(lockDir, { recursive: true });
-        }
-    } catch (err) {
-        result.error = `Failed to create lock directory: ${err.message}`;
-        return result;
-    }
-
-    // Check for existing lock
-    if (existsSync(lockPath)) {
-        try {
-            const existingData = JSON.parse(readFileSync(lockPath, 'utf-8'));
-            result.existingLock = existingData;
-
-            // Check if lock is stale or process is dead
-            const stale = isLockStale(existingData, timeout);
-            const processGone = existingData.pid && !isProcessRunning(existingData.pid);
-
-            if (!force && !stale && !processGone) {
-                // Lock is valid and held by another process
-                result.error = formatConcurrentOperationError({
-                    operation,
-                    lockHolder: `${existingData.operation} (PID: ${existingData.pid})`,
-                    lockFile: lockPath
-                });
-                return result;
-            }
-
-            // Lock is stale or orphaned, we can take over
-            console.log(`Note: Removed stale lock from ${existingData.operation}`);
-        } catch (err) {
-            // Invalid lock file, we can overwrite it
-            console.log(`Note: Removed invalid lock file`);
-        }
-    }
-
-    // Create new lock
-    try {
-        const lockData = createLockData(operation);
-        writeFileSync(lockPath, JSON.stringify(lockData, null, 2), 'utf-8');
-        result.acquired = true;
-    } catch (err) {
-        result.error = `Failed to create lock: ${err.message}`;
-        return result;
-    }
-
-    return result;
-}
-
-/**
- * Release a lock.
- *
- * @param {string} lockType - One of LockTypes
- * @param {Object} options - Options
- * @param {string} options.context - Context identifier
- * @param {string} options.basePath - Base path for lock files
- * @returns {boolean} - True if lock was released
- */
-export function releaseLock(lockType, options = {}) {
-    const {
-        context = 'global',
-        basePath = process.cwd()
-    } = options;
-
-    const lockPath = getLockPath(lockType, context, basePath);
-
-    try {
-        if (existsSync(lockPath)) {
-            // Verify this is our lock before deleting
-            try {
-                const lockData = JSON.parse(readFileSync(lockPath, 'utf-8'));
-                if (lockData.pid !== process.pid) {
-                    // Not our lock, don't delete
-                    return false;
-                }
-            } catch {
-                // Can't read lock, assume it's okay to delete
-            }
-
-            unlinkSync(lockPath);
-        }
-        return true;
-    } catch (err) {
-        // Failed to release, but don't crash
-        console.log(`Warning: Could not release lock: ${err.message}`);
-        return false;
-    }
-}
-
-/**
- * Check if an operation is locked.
- *
- * @param {string} lockType - One of LockTypes
- * @param {Object} options - Options
- * @param {string} options.context - Context identifier
- * @param {string} options.basePath - Base path for lock files
- * @param {number} options.timeout - Lock timeout in milliseconds
- * @returns {{
- *   locked: boolean,
- *   lockData: Object | null,
- *   stale: boolean
- * }}
- */
-export function checkLock(lockType, options = {}) {
-    const {
-        context = 'global',
-        basePath = process.cwd(),
-        timeout = DEFAULT_LOCK_TIMEOUT
-    } = options;
-
-    const lockPath = getLockPath(lockType, context, basePath);
-
-    const result = {
-        locked: false,
-        lockData: null,
-        stale: false
-    };
-
-    if (!existsSync(lockPath)) {
-        return result;
-    }
-
-    try {
-        const lockData = JSON.parse(readFileSync(lockPath, 'utf-8'));
-        result.lockData = lockData;
-
-        const stale = isLockStale(lockData, timeout);
-        const processGone = lockData.pid && !isProcessRunning(lockData.pid);
-
-        result.stale = stale || processGone;
-        result.locked = !result.stale;
-    } catch {
-        // Invalid lock file
-        result.stale = true;
-    }
-
-    return result;
-}
-
-/**
- * Execute a function with a lock.
- * Automatically acquires lock before execution and releases after.
- *
- * @param {string} lockType - One of LockTypes
- * @param {Function} fn - Async function to execute
- * @param {Object} options - Lock options
- * @returns {Promise<*>} - Result of the function
- */
-export async function withLock(lockType, fn, options = {}) {
-    const lockResult = acquireLock(lockType, options);
-
-    if (!lockResult.acquired) {
-        throw new Error(lockResult.error || 'Failed to acquire lock');
-    }
-
-    try {
-        return await fn();
-    } finally {
-        releaseLock(lockType, options);
-    }
-}
-
-/**
- * Clean up all stale locks in a directory.
- *
- * @param {string} basePath - Base path for lock files
- * @param {number} timeout - Lock timeout in milliseconds
- * @returns {number} - Number of locks cleaned up
- */
-export function cleanupStaleLocks(basePath = process.cwd(), timeout = DEFAULT_LOCK_TIMEOUT) {
-    const lockDir = join(basePath, LOCK_DIR);
-    let cleaned = 0;
-
-    if (!existsSync(lockDir)) {
-        return 0;
-    }
-
-    try {
-        const { readdirSync } = require('node:fs');
-        const files = readdirSync(lockDir);
-
-        for (const file of files) {
-            if (!file.endsWith('.lock')) continue;
-
-            const lockPath = join(lockDir, file);
-            try {
-                const lockData = JSON.parse(readFileSync(lockPath, 'utf-8'));
-
-                if (isLockStale(lockData, timeout) || !isProcessRunning(lockData.pid)) {
-                    unlinkSync(lockPath);
-                    cleaned++;
-                }
-            } catch {
-                // Invalid lock file, remove it
-                try {
-                    unlinkSync(lockPath);
-                    cleaned++;
-                } catch {
-                    // Couldn't delete, skip
-                }
-            }
-        }
-    } catch {
-        // Can't read directory, skip cleanup
-    }
-
-    return cleaned;
-}
-
-/**
- * Create a project-specific lock context from a path.
- *
- * @param {string} projectPath - Path to the project
- * @returns {string} - Lock context identifier
- */
-export function createProjectContext(projectPath) {
-    // Create a short hash-like identifier from the path
-    let hash = 0;
-    for (let i = 0; i < projectPath.length; i++) {
-        const char = projectPath.charCodeAt(i);
-        hash = ((hash << 5) - hash) + char;
-        hash = hash & hash; // Convert to 32bit integer
-    }
-    return `project-${Math.abs(hash).toString(36)}`;
-}
+/**
+ * Operation locking system for Iris Vue integration.
+ * Prevents concurrent operations that could cause data corruption.
+ */
+
+import { existsSync, writeFileSync, readFileSync, unlinkSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { formatConcurrentOperationError } from './errors.js';
+
+/**
+ * Lock directory relative to workspace.
+ */
+const LOCK_DIR = '.magentrix/locks';
+
+/**
+ * Lock types for different operations.
+ */
+export const LockTypes = {
+    BUILD: 'build',
+    STAGE: 'stage',
+    PUBLISH: 'publish',
+    DELETE: 'delete',
+    RECOVER: 'recover',
+    DEV_SERVER: 'dev-server'
+};
+
+/**
+ * Default lock timeout in milliseconds (5 minutes).
+ * Locks older than this are considered stale and can be overwritten.
+ */
+const DEFAULT_LOCK_TIMEOUT = 5 * 60 * 1000;
+
+/**
+ * Get the lock file path for a given lock type and context.
+ *
+ * @param {string} lockType - One of LockTypes
+ * @param {string} context - Context identifier (e.g., workspace path, project slug)
+ * @param {string} basePath - Base path for lock files (defaults to cwd)
+ * @returns {string} - Path to the lock file
+ */
+function getLockPath(lockType, context = 'global', basePath = process.cwd()) {
+    const lockDir = join(basePath, LOCK_DIR);
+    const safeContext = context.replace(/[^a-zA-Z0-9-_]/g, '_');
+    return join(lockDir, `${lockType}-${safeContext}.lock`);
+}
+
+/**
+ * Create lock file data.
+ *
+ * @param {string} operation - Description of the operation
+ * @returns {Object} - Lock data
+ */
+function createLockData(operation) {
+    return {
+        pid: process.pid,
+        operation,
+        startedAt: new Date().toISOString(),
+        hostname: process.env.HOSTNAME || process.env.COMPUTERNAME || 'unknown'
+    };
+}
+
+/**
+ * Check if a lock is stale (older than timeout).
+ *
+ * @param {Object} lockData - The lock file data
+ * @param {number} timeout - Timeout in milliseconds
+ * @returns {boolean} - True if lock is stale
+ */
+function isLockStale(lockData, timeout = DEFAULT_LOCK_TIMEOUT) {
+    if (!lockData.startedAt) {
+        return true;
+    }
+
+    const startTime = new Date(lockData.startedAt).getTime();
+    const now = Date.now();
+
+    return (now - startTime) > timeout;
+}
+
+/**
+ * Check if the process that created the lock is still running.
+ *
+ * @param {number} pid - Process ID to check
+ * @returns {boolean} - True if process is running
+ */
+function isProcessRunning(pid) {
+    try {
+        // Sending signal 0 checks if process exists without killing it
+        process.kill(pid, 0);
+        return true;
+    } catch (err) {
+        // ESRCH means process doesn't exist
+        // EPERM means process exists but we don't have permission
+        return err.code === 'EPERM';
+    }
+}
+
+/**
+ * Acquire a lock for an operation.
+ *
+ * @param {string} lockType - One of LockTypes
+ * @param {Object} options - Lock options
+ * @param {string} options.context - Context identifier
+ * @param {string} options.operation - Description of the operation
+ * @param {string} options.basePath - Base path for lock files
+ * @param {number} options.timeout - Lock timeout in milliseconds
+ * @param {boolean} options.force - Force acquire even if locked
+ * @returns {{
+ *   acquired: boolean,
+ *   lockPath: string,
+ *   error: string | null,
+ *   existingLock: Object | null
+ * }}
+ */
+export function acquireLock(lockType, options = {}) {
+    const {
+        context = 'global',
+        operation = lockType,
+        basePath = process.cwd(),
+        timeout = DEFAULT_LOCK_TIMEOUT,
+        force = false
+    } = options;
+
+    const lockPath = getLockPath(lockType, context, basePath);
+    const lockDir = dirname(lockPath);
+
+    const result = {
+        acquired: false,
+        lockPath,
+        error: null,
+        existingLock: null
+    };
+
+    // Ensure lock directory exists
+    try {
+        if (!existsSync(lockDir)) {
+            mkdirSync(lockDir, { recursive: true });
+        }
+    } catch (err) {
+        result.error = `Failed to create lock directory: ${err.message}`;
+        return result;
+    }
+
+    // Check for existing lock
+    if (existsSync(lockPath)) {
+        try {
+            const existingData = JSON.parse(readFileSync(lockPath, 'utf-8'));
+            result.existingLock = existingData;
+
+            // Check if lock is stale or process is dead
+            const stale = isLockStale(existingData, timeout);
+            const processGone = existingData.pid && !isProcessRunning(existingData.pid);
+
+            if (!force && !stale && !processGone) {
+                // Lock is valid and held by another process
+                result.error = formatConcurrentOperationError({
+                    operation,
+                    lockHolder: `${existingData.operation} (PID: ${existingData.pid})`,
+                    lockFile: lockPath
+                });
+                return result;
+            }
+
+            // Lock is stale or orphaned, we can take over
+            console.log(`Note: Removed stale lock from ${existingData.operation}`);
+        } catch (err) {
+            // Invalid lock file, we can overwrite it
+            console.log(`Note: Removed invalid lock file`);
+        }
+    }
+
+    // Create new lock
+    try {
+        const lockData = createLockData(operation);
+        writeFileSync(lockPath, JSON.stringify(lockData, null, 2), 'utf-8');
+        result.acquired = true;
+    } catch (err) {
+        result.error = `Failed to create lock: ${err.message}`;
+        return result;
+    }
+
+    return result;
+}
+
+/**
+ * Release a lock.
+ *
+ * @param {string} lockType - One of LockTypes
+ * @param {Object} options - Options
+ * @param {string} options.context - Context identifier
+ * @param {string} options.basePath - Base path for lock files
+ * @returns {boolean} - True if lock was released
+ */
+export function releaseLock(lockType, options = {}) {
+    const {
+        context = 'global',
+        basePath = process.cwd()
+    } = options;
+
+    const lockPath = getLockPath(lockType, context, basePath);
+
+    try {
+        if (existsSync(lockPath)) {
+            // Verify this is our lock before deleting
+            try {
+                const lockData = JSON.parse(readFileSync(lockPath, 'utf-8'));
+                if (lockData.pid !== process.pid) {
+                    // Not our lock, don't delete
+                    return false;
+                }
+            } catch {
+                // Can't read lock, assume it's okay to delete
+            }
+
+            unlinkSync(lockPath);
+        }
+        return true;
+    } catch (err) {
+        // Failed to release, but don't crash
+        console.log(`Warning: Could not release lock: ${err.message}`);
+        return false;
+    }
+}
+
+/**
+ * Check if an operation is locked.
+ *
+ * @param {string} lockType - One of LockTypes
+ * @param {Object} options - Options
+ * @param {string} options.context - Context identifier
+ * @param {string} options.basePath - Base path for lock files
+ * @param {number} options.timeout - Lock timeout in milliseconds
+ * @returns {{
+ *   locked: boolean,
+ *   lockData: Object | null,
+ *   stale: boolean
+ * }}
+ */
+export function checkLock(lockType, options = {}) {
+    const {
+        context = 'global',
+        basePath = process.cwd(),
+        timeout = DEFAULT_LOCK_TIMEOUT
+    } = options;
+
+    const lockPath = getLockPath(lockType, context, basePath);
+
+    const result = {
+        locked: false,
+        lockData: null,
+        stale: false
+    };
+
+    if (!existsSync(lockPath)) {
+        return result;
+    }
+
+    try {
+        const lockData = JSON.parse(readFileSync(lockPath, 'utf-8'));
+        result.lockData = lockData;
+
+        const stale = isLockStale(lockData, timeout);
+        const processGone = lockData.pid && !isProcessRunning(lockData.pid);
+
+        result.stale = stale || processGone;
+        result.locked = !result.stale;
+    } catch {
+        // Invalid lock file
+        result.stale = true;
+    }
+
+    return result;
+}
+
+/**
+ * Execute a function with a lock.
+ * Automatically acquires lock before execution and releases after.
+ *
+ * @param {string} lockType - One of LockTypes
+ * @param {Function} fn - Async function to execute
+ * @param {Object} options - Lock options
+ * @returns {Promise<*>} - Result of the function
+ */
+export async function withLock(lockType, fn, options = {}) {
+    const lockResult = acquireLock(lockType, options);
+
+    if (!lockResult.acquired) {
+        throw new Error(lockResult.error || 'Failed to acquire lock');
+    }
+
+    try {
+        return await fn();
+    } finally {
+        releaseLock(lockType, options);
+    }
+}
+
+/**
+ * Clean up all stale locks in a directory.
+ *
+ * @param {string} basePath - Base path for lock files
+ * @param {number} timeout - Lock timeout in milliseconds
+ * @returns {number} - Number of locks cleaned up
+ */
+export function cleanupStaleLocks(basePath = process.cwd(), timeout = DEFAULT_LOCK_TIMEOUT) {
+    const lockDir = join(basePath, LOCK_DIR);
+    let cleaned = 0;
+
+    if (!existsSync(lockDir)) {
+        return 0;
+    }
+
+    try {
+        const { readdirSync } = require('node:fs');
+        const files = readdirSync(lockDir);
+
+        for (const file of files) {
+            if (!file.endsWith('.lock')) continue;
+
+            const lockPath = join(lockDir, file);
+            try {
+                const lockData = JSON.parse(readFileSync(lockPath, 'utf-8'));
+
+                if (isLockStale(lockData, timeout) || !isProcessRunning(lockData.pid)) {
+                    unlinkSync(lockPath);
+                    cleaned++;
+                }
+            } catch {
+                // Invalid lock file, remove it
+                try {
+                    unlinkSync(lockPath);
+                    cleaned++;
+                } catch {
+                    // Couldn't delete, skip
+                }
+            }
+        }
+    } catch {
+        // Can't read directory, skip cleanup
+    }
+
+    return cleaned;
+}
+
+/**
+ * Create a project-specific lock context from a path.
+ *
+ * @param {string} projectPath - Path to the project
+ * @returns {string} - Lock context identifier
+ */
+export function createProjectContext(projectPath) {
+    // Create a short hash-like identifier from the path
+    let hash = 0;
+    for (let i = 0; i < projectPath.length; i++) {
+        const char = projectPath.charCodeAt(i);
+        hash = ((hash << 5) - hash) + char;
+        hash = hash & hash; // Convert to 32bit integer
+    }
+    return `project-${Math.abs(hash).toString(36)}`;
+}