@magentrix-corp/magentrix-cli 1.3.10 → 1.3.11

package/utils/iris/linker.js

@@ -2,9 +2,68 @@ import { existsSync } from 'node:fs';
 import { resolve, basename } from 'node:path';
 import Config from '../config.js';
 import { readVueConfig } from './config-reader.js';
+import { validateSlug } from './validation.js';
+import { formatError, formatCorruptedConfigError, detectErrorType, ErrorTypes } from './errors.js';
 
 const config = new Config();
 
+/**
+ * Safe wrapper for reading config that handles corruption.
+ *
+ * @param {string} key - Config key to read
+ * @param {Object} options - Config options
+ * @returns {{success: boolean, data: any, error: string | null}}
+ */
+function safeConfigRead(key, options) {
+    try {
+        const data = config.read(key, options);
+        return { success: true, data, error: null };
+    } catch (err) {
+        const errorType = detectErrorType(err);
+        if (errorType === ErrorTypes.CORRUPTED) {
+            return {
+                success: false,
+                data: null,
+                error: formatCorruptedConfigError({
+                    configPath: config.getGlobalConfigPath?.() || '~/.config/magentrix/config.json',
+                    error: err
+                })
+            };
+        }
+        return { success: false, data: null, error: err.message };
+    }
+}
+
+/**
+ * Safe wrapper for saving config that handles errors.
+ *
+ * @param {string} key - Config key to save
+ * @param {any} value - Value to save
+ * @param {Object} options - Config options
+ * @returns {{success: boolean, error: string | null}}
+ */
+function safeConfigSave(key, value, options) {
+    try {
+        config.save(key, value, options);
+        return { success: true, error: null };
+    } catch (err) {
+        const errorType = detectErrorType(err);
+        if (errorType === ErrorTypes.PERMISSION) {
+            return {
+                success: false,
+                error: `Permission denied saving config. Check file permissions for the global config directory.`
+            };
+        }
+        if (errorType === ErrorTypes.DISK_FULL) {
+            return {
+                success: false,
+                error: `Disk full - cannot save config. Free up disk space and try again.`
+            };
+        }
+        return { success: false, error: `Failed to save config: ${err.message}` };
+    }
+}
+
 /**
  * Get all linked Vue projects from global config.
  *
@@ -17,19 +76,27 @@ const config = new Config();
  * }>}
  */
 export function getLinkedProjects() {
-    const linkedProjects = config.read('linkedVueProjects', {
+    const result = safeConfigRead('linkedVueProjects', {
         global: true  // Store globally so projects persist across Magentrix workspaces
     });
-    return linkedProjects || [];
+
+    if (!result.success) {
+        // Log error but return empty array to allow graceful degradation
+        console.error(result.error);
+        return [];
+    }
+
+    return result.data || [];
 }
 
 /**
  * Save linked projects to global config.
  *
  * @param {Array} projects - Array of linked projects
+ * @returns {{success: boolean, error: string | null}}
  */
 function saveLinkedProjects(projects) {
-    config.save('linkedVueProjects', projects, {
+    return safeConfigSave('linkedVueProjects', projects, {
         global: true
     });
 }
@@ -230,7 +297,16 @@ export function linkVueProject(projectPath) {
             appIconId: vueConfig.appIconId,
             siteUrl: vueConfig.siteUrl
         };
-        saveLinkedProjects(projects);
+
+        const saveResult = saveLinkedProjects(projects);
+        if (!saveResult.success) {
+            return {
+                success: false,
+                project: null,
+                error: saveResult.error,
+                updated: false
+            };
+        }
 
         return {
             success: true,
@@ -265,7 +341,16 @@ export function linkVueProject(projectPath) {
     // Add to linked projects
     const projects = getLinkedProjects();
     projects.push(newProject);
-    saveLinkedProjects(projects);
+
+    const saveResult = saveLinkedProjects(projects);
+    if (!saveResult.success) {
+        return {
+            success: false,
+            project: null,
+            error: saveResult.error,
+            updated: false
+        };
+    }
 
     return {
         success: true,
@@ -310,7 +395,15 @@ export function unlinkVueProject(projectPathOrSlug) {
 
     // Remove from list
     const [removed] = projects.splice(index, 1);
-    saveLinkedProjects(projects);
+    const saveResult = saveLinkedProjects(projects);
+
+    if (!saveResult.success) {
+        return {
+            success: false,
+            project: null,
+            error: saveResult.error
+        };
+    }
 
     return {
         success: true,
@@ -323,8 +416,10 @@ export function unlinkVueProject(projectPathOrSlug) {
  * Remove all invalid (non-existent paths) linked projects.
  *
  * @returns {{
+ *   success: boolean,
  *   removed: number,
- *   projects: Array<{path: string, slug: string, appName: string}>
+ *   projects: Array<{path: string, slug: string, appName: string}>,
+ *   error: string | null
  * }}
  */
 export function cleanupInvalidProjects() {
@@ -341,12 +436,22 @@ export function cleanupInvalidProjects() {
     }
 
     if (removedProjects.length > 0) {
-        saveLinkedProjects(validProjects);
+        const saveResult = saveLinkedProjects(validProjects);
+        if (!saveResult.success) {
+            return {
+                success: false,
+                removed: 0,
+                projects: [],
+                error: saveResult.error
+            };
+        }
     }
 
     return {
+        success: true,
         removed: removedProjects.length,
-        projects: removedProjects
+        projects: removedProjects,
+        error: null
     };
 }
 
@@ -354,20 +459,20 @@ export function cleanupInvalidProjects() {
  * Update the last build timestamp for a linked project.
  *
  * @param {string} slug - The app slug
- * @returns {boolean} - True if updated, false if not found
+ * @returns {{success: boolean, error: string | null}}
  */
 export function updateLastBuild(slug) {
     const projects = getLinkedProjects();
     const index = projects.findIndex(p => p.slug === slug);
 
     if (index === -1) {
-        return false;
+        return { success: false, error: 'Project not found' };
     }
 
     projects[index].lastBuild = new Date().toISOString();
-    saveLinkedProjects(projects);
+    const saveResult = saveLinkedProjects(projects);
 
-    return true;
+    return saveResult;
 }
 
 /**

package/utils/iris/lock.js

@@ -0,0 +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)}`;
+}