@magentrix-corp/magentrix-cli 1.3.16 → 1.3.17

package/utils/iris/backup.js

@@ -1,411 +1,411 @@
-import fs from 'fs';
-import path from 'path';
-import { createIrisZip } from './zipper.js';
-import { extractIrisZip } from './zipper.js';
-import {
-    detectErrorType,
-    ErrorTypes,
-    formatPermissionError,
-    formatDiskFullError,
-    formatFileLockError
-} from './errors.js';
-
-const BACKUP_DIR = '.magentrix/iris-backups';
-
-/**
- * Maximum backup age in days. Older backups will be cleaned up.
- */
-const MAX_BACKUP_AGE_DAYS = 30;
-
-/**
- * Create a backup of an Iris app before deletion.
- *
- * @param {string} appPath - Path to the Iris app folder (e.g., src/iris-apps/my-app)
- * @param {object} metadata - Additional metadata to save
- * @param {string} metadata.slug - App slug
- * @param {string} metadata.appName - App display name
- * @param {object} [metadata.linkedProject] - Linked Vue project info (if any)
- * @returns {Promise<{success: boolean, backupPath: string | null, error: string | null}>}
- */
-export async function backupIrisApp(appPath, metadata) {
-    const { slug } = metadata;
-    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
-    const backupName = `${slug}-${timestamp}`;
-    const backupPath = path.join(process.cwd(), BACKUP_DIR, backupName);
-
-    try {
-        // Ensure backup directory exists
-        fs.mkdirSync(backupPath, { recursive: true });
-    } catch (err) {
-        const errorType = detectErrorType(err);
-        if (errorType === ErrorTypes.PERMISSION) {
-            return {
-                success: false,
-                backupPath: null,
-                error: formatPermissionError({
-                    operation: 'create backup directory',
-                    path: backupPath
-                }),
-                isPermissionError: true
-            };
-        }
-        if (errorType === ErrorTypes.DISK_FULL) {
-            return {
-                success: false,
-                backupPath: null,
-                error: formatDiskFullError({
-                    operation: 'create backup',
-                    path: backupPath
-                }),
-                isDiskFull: true
-            };
-        }
-        return {
-            success: false,
-            backupPath: null,
-            error: `Failed to create backup directory: ${err.message}`
-        };
-    }
-
-    try {
-        // Create ZIP of app files
-        const zipBuffer = await createIrisZip(appPath, slug);
-        const zipPath = path.join(backupPath, `${slug}.zip`);
-        fs.writeFileSync(zipPath, zipBuffer);
-    } catch (err) {
-        // Clean up partial backup
-        try {
-            fs.rmSync(backupPath, { recursive: true, force: true });
-        } catch {
-            // Ignore cleanup errors
-        }
-
-        const errorType = detectErrorType(err);
-        if (errorType === ErrorTypes.PERMISSION) {
-            return {
-                success: false,
-                backupPath: null,
-                error: formatPermissionError({
-                    operation: 'write backup files',
-                    path: backupPath
-                }),
-                isPermissionError: true
-            };
-        }
-        if (errorType === ErrorTypes.DISK_FULL) {
-            return {
-                success: false,
-                backupPath: null,
-                error: formatDiskFullError({
-                    operation: 'create backup',
-                    path: backupPath
-                }),
-                isDiskFull: true
-            };
-        }
-        return {
-            success: false,
-            backupPath: null,
-            error: `Failed to create backup ZIP: ${err.message}`
-        };
-    }
-
-    try {
-        // Save metadata
-        const metadataPath = path.join(backupPath, 'metadata.json');
-        fs.writeFileSync(metadataPath, JSON.stringify({
-            ...metadata,
-            deletedAt: new Date().toISOString(),
-            backupName,
-            originalPath: appPath
-        }, null, 2));
-    } catch (err) {
-        // Clean up partial backup
-        try {
-            fs.rmSync(backupPath, { recursive: true, force: true });
-        } catch {
-            // Ignore cleanup errors
-        }
-        return {
-            success: false,
-            backupPath: null,
-            error: `Failed to save backup metadata: ${err.message}`
-        };
-    }
-
-    return {
-        success: true,
-        backupPath,
-        error: null
-    };
-}
-
-/**
- * List all available Iris app backups.
- *
- * @returns {Array<{
- *   backupName: string,
- *   slug: string,
- *   appName: string,
- *   deletedAt: string,
- *   linkedProject: object | null,
- *   backupPath: string
- * }>}
- */
-export function listBackups() {
-    const backupsDir = path.join(process.cwd(), BACKUP_DIR);
-
-    if (!fs.existsSync(backupsDir)) {
-        return [];
-    }
-
-    const backups = [];
-    const entries = fs.readdirSync(backupsDir, { withFileTypes: true });
-
-    for (const entry of entries) {
-        if (!entry.isDirectory()) continue;
-
-        const backupPath = path.join(backupsDir, entry.name);
-        const metadataPath = path.join(backupPath, 'metadata.json');
-
-        if (!fs.existsSync(metadataPath)) continue;
-
-        try {
-            const metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf-8'));
-            backups.push({
-                ...metadata,
-                backupPath
-            });
-        } catch {
-            // Skip invalid backups
-        }
-    }
-
-    // Sort by deletedAt (newest first)
-    return backups.sort((a, b) =>
-        new Date(b.deletedAt).getTime() - new Date(a.deletedAt).getTime()
-    );
-}
-
-/**
- * Restore an Iris app from backup.
- *
- * @param {string} backupPath - Path to the backup folder
- * @param {object} options - Recovery options
- * @param {boolean} options.restoreLink - Whether to restore the linked project (default: true)
- * @param {boolean} options.restoreLocal - Whether to restore local files (default: true)
- * @returns {Promise<{
- *   success: boolean,
- *   restoredFiles: boolean,
- *   restoredLink: boolean,
- *   linkedProjectPathExists: boolean,
- *   warnings: string[],
- *   error: string | null,
- *   isPermissionError: boolean,
- *   targetPath: string | null
- * }>}
- */
-export async function restoreIrisApp(backupPath, options = {}) {
-    const { restoreLink = true, restoreLocal = true } = options;
-    const result = {
-        success: false,
-        restoredFiles: false,
-        restoredLink: false,
-        linkedProjectPathExists: true,
-        warnings: [],
-        error: null,
-        isPermissionError: false,
-        isFileLocked: false,
-        isCorrupted: false,
-        targetPath: null
-    };
-
-    // Read metadata
-    const metadataPath = path.join(backupPath, 'metadata.json');
-    if (!fs.existsSync(metadataPath)) {
-        result.error = 'Backup metadata not found. The backup may be incomplete or corrupted.';
-        result.isCorrupted = true;
-        return result;
-    }
-
-    let metadata;
-    try {
-        const metadataContent = fs.readFileSync(metadataPath, 'utf-8');
-        metadata = JSON.parse(metadataContent);
-    } catch (err) {
-        if (err instanceof SyntaxError) {
-            result.error = 'Backup metadata is corrupted (invalid JSON). The backup may be damaged.';
-            result.isCorrupted = true;
-        } else {
-            result.error = `Failed to read backup metadata: ${err.message}`;
-        }
-        return result;
-    }
-
-    const { slug, linkedProject } = metadata;
-
-    if (!slug) {
-        result.error = 'Backup metadata is missing required "slug" field. The backup may be corrupted.';
-        result.isCorrupted = true;
-        return result;
-    }
-
-    // Restore local files
-    if (restoreLocal) {
-        const zipPath = path.join(backupPath, `${slug}.zip`);
-        if (!fs.existsSync(zipPath)) {
-            result.error = 'Backup ZIP file not found. The backup may be incomplete.';
-            result.isCorrupted = true;
-            return result;
-        }
-
-        let zipBuffer;
-        try {
-            zipBuffer = fs.readFileSync(zipPath);
-        } catch (err) {
-            const errorType = detectErrorType(err);
-            if (errorType === ErrorTypes.PERMISSION) {
-                result.error = formatPermissionError({
-                    operation: 'read backup file',
-                    path: zipPath
-                });
-                result.isPermissionError = true;
-            } else if (errorType === ErrorTypes.FILE_LOCKED) {
-                result.error = formatFileLockError({ path: zipPath });
-                result.isFileLocked = true;
-            } else {
-                result.error = `Failed to read backup file: ${err.message}`;
-            }
-            return result;
-        }
-
-        const targetDir = path.join(process.cwd(), 'src', 'iris-apps');
-        const appTargetDir = path.join(targetDir, slug);
-        result.targetPath = appTargetDir;
-
-        // Ensure target directory exists
-        try {
-            fs.mkdirSync(targetDir, { recursive: true });
-        } catch (err) {
-            const errorType = detectErrorType(err);
-            if (errorType === ErrorTypes.PERMISSION) {
-                result.error = formatPermissionError({
-                    operation: 'create restore directory',
-                    path: targetDir
-                });
-                result.isPermissionError = true;
-            } else {
-                result.error = `Failed to create restore directory: ${err.message}`;
-            }
-            return result;
-        }
-
-        // Extract backup
-        try {
-            await extractIrisZip(zipBuffer, targetDir);
-            result.restoredFiles = true;
-        } catch (err) {
-            const errorType = detectErrorType(err);
-            if (errorType === ErrorTypes.PERMISSION) {
-                result.error = formatPermissionError({
-                    operation: 'extract backup files',
-                    path: appTargetDir
-                });
-                result.isPermissionError = true;
-            } else if (errorType === ErrorTypes.FILE_LOCKED) {
-                result.error = formatFileLockError({ path: appTargetDir });
-                result.isFileLocked = true;
-            } else if (errorType === ErrorTypes.DISK_FULL) {
-                result.error = formatDiskFullError({
-                    operation: 'restore backup',
-                    path: appTargetDir
-                });
-            } else if (err.message?.includes('invalid') || err.message?.includes('corrupt')) {
-                result.error = 'Backup ZIP file appears to be corrupted. The backup cannot be restored.';
-                result.isCorrupted = true;
-            } else {
-                result.error = `Failed to extract backup: ${err.message}`;
-            }
-            return result;
-        }
-    }
-
-    // Restore linked project
-    if (restoreLink && linkedProject) {
-        // Check if the linked project path still exists
-        if (!fs.existsSync(linkedProject.path)) {
-            result.linkedProjectPathExists = false;
-            result.warnings.push(
-                `Linked Vue project no longer exists at: ${linkedProject.path}`
-            );
-        } else {
-            result.restoredLink = true;
-        }
-    }
-
-    result.success = true;
-    return result;
-}
-
-/**
- * Delete a backup folder.
- *
- * @param {string} backupPath - Path to the backup folder
- * @returns {{success: boolean, error: string | null}}
- */
-export function deleteBackup(backupPath) {
-    try {
-        if (fs.existsSync(backupPath)) {
-            fs.rmSync(backupPath, { recursive: true, force: true });
-        }
-        return { success: true, error: null };
-    } catch (err) {
-        const errorType = detectErrorType(err);
-        if (errorType === ErrorTypes.PERMISSION) {
-            return {
-                success: false,
-                error: formatPermissionError({
-                    operation: 'delete backup',
-                    path: backupPath
-                })
-            };
-        }
-        if (errorType === ErrorTypes.FILE_LOCKED) {
-            return {
-                success: false,
-                error: formatFileLockError({ path: backupPath })
-            };
-        }
-        return {
-            success: false,
-            error: `Failed to delete backup: ${err.message}`
-        };
-    }
-}
-
-/**
- * Clean up old backups (older than MAX_BACKUP_AGE_DAYS).
- *
- * @returns {{cleaned: number, errors: number}}
- */
-export function cleanupOldBackups() {
-    const result = { cleaned: 0, errors: 0 };
-    const backups = listBackups();
-
-    const now = Date.now();
-    const maxAge = MAX_BACKUP_AGE_DAYS * 24 * 60 * 60 * 1000;
-
-    for (const backup of backups) {
-        const age = now - new Date(backup.deletedAt).getTime();
-        if (age > maxAge) {
-            const deleteResult = deleteBackup(backup.backupPath);
-            if (deleteResult.success) {
-                result.cleaned++;
-            } else {
-                result.errors++;
-            }
-        }
-    }
-
-    return result;
-}
+import fs from 'fs';
+import path from 'path';
+import { createIrisZip } from './zipper.js';
+import { extractIrisZip } from './zipper.js';
+import {
+    detectErrorType,
+    ErrorTypes,
+    formatPermissionError,
+    formatDiskFullError,
+    formatFileLockError
+} from './errors.js';
+
+const BACKUP_DIR = '.magentrix/iris-backups';
+
+/**
+ * Maximum backup age in days. Older backups will be cleaned up.
+ */
+const MAX_BACKUP_AGE_DAYS = 30;
+
+/**
+ * Create a backup of an Iris app before deletion.
+ *
+ * @param {string} appPath - Path to the Iris app folder (e.g., src/iris-apps/my-app)
+ * @param {object} metadata - Additional metadata to save
+ * @param {string} metadata.slug - App slug
+ * @param {string} metadata.appName - App display name
+ * @param {object} [metadata.linkedProject] - Linked Vue project info (if any)
+ * @returns {Promise<{success: boolean, backupPath: string | null, error: string | null}>}
+ */
+export async function backupIrisApp(appPath, metadata) {
+    const { slug } = metadata;
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+    const backupName = `${slug}-${timestamp}`;
+    const backupPath = path.join(process.cwd(), BACKUP_DIR, backupName);
+
+    try {
+        // Ensure backup directory exists
+        fs.mkdirSync(backupPath, { recursive: true });
+    } catch (err) {
+        const errorType = detectErrorType(err);
+        if (errorType === ErrorTypes.PERMISSION) {
+            return {
+                success: false,
+                backupPath: null,
+                error: formatPermissionError({
+                    operation: 'create backup directory',
+                    path: backupPath
+                }),
+                isPermissionError: true
+            };
+        }
+        if (errorType === ErrorTypes.DISK_FULL) {
+            return {
+                success: false,
+                backupPath: null,
+                error: formatDiskFullError({
+                    operation: 'create backup',
+                    path: backupPath
+                }),
+                isDiskFull: true
+            };
+        }
+        return {
+            success: false,
+            backupPath: null,
+            error: `Failed to create backup directory: ${err.message}`
+        };
+    }
+
+    try {
+        // Create ZIP of app files
+        const zipBuffer = await createIrisZip(appPath, slug);
+        const zipPath = path.join(backupPath, `${slug}.zip`);
+        fs.writeFileSync(zipPath, zipBuffer);
+    } catch (err) {
+        // Clean up partial backup
+        try {
+            fs.rmSync(backupPath, { recursive: true, force: true });
+        } catch {
+            // Ignore cleanup errors
+        }
+
+        const errorType = detectErrorType(err);
+        if (errorType === ErrorTypes.PERMISSION) {
+            return {
+                success: false,
+                backupPath: null,
+                error: formatPermissionError({
+                    operation: 'write backup files',
+                    path: backupPath
+                }),
+                isPermissionError: true
+            };
+        }
+        if (errorType === ErrorTypes.DISK_FULL) {
+            return {
+                success: false,
+                backupPath: null,
+                error: formatDiskFullError({
+                    operation: 'create backup',
+                    path: backupPath
+                }),
+                isDiskFull: true
+            };
+        }
+        return {
+            success: false,
+            backupPath: null,
+            error: `Failed to create backup ZIP: ${err.message}`
+        };
+    }
+
+    try {
+        // Save metadata
+        const metadataPath = path.join(backupPath, 'metadata.json');
+        fs.writeFileSync(metadataPath, JSON.stringify({
+            ...metadata,
+            deletedAt: new Date().toISOString(),
+            backupName,
+            originalPath: appPath
+        }, null, 2));
+    } catch (err) {
+        // Clean up partial backup
+        try {
+            fs.rmSync(backupPath, { recursive: true, force: true });
+        } catch {
+            // Ignore cleanup errors
+        }
+        return {
+            success: false,
+            backupPath: null,
+            error: `Failed to save backup metadata: ${err.message}`
+        };
+    }
+
+    return {
+        success: true,
+        backupPath,
+        error: null
+    };
+}
+
+/**
+ * List all available Iris app backups.
+ *
+ * @returns {Array<{
+ *   backupName: string,
+ *   slug: string,
+ *   appName: string,
+ *   deletedAt: string,
+ *   linkedProject: object | null,
+ *   backupPath: string
+ * }>}
+ */
+export function listBackups() {
+    const backupsDir = path.join(process.cwd(), BACKUP_DIR);
+
+    if (!fs.existsSync(backupsDir)) {
+        return [];
+    }
+
+    const backups = [];
+    const entries = fs.readdirSync(backupsDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+
+        const backupPath = path.join(backupsDir, entry.name);
+        const metadataPath = path.join(backupPath, 'metadata.json');
+
+        if (!fs.existsSync(metadataPath)) continue;
+
+        try {
+            const metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf-8'));
+            backups.push({
+                ...metadata,
+                backupPath
+            });
+        } catch {
+            // Skip invalid backups
+        }
+    }
+
+    // Sort by deletedAt (newest first)
+    return backups.sort((a, b) =>
+        new Date(b.deletedAt).getTime() - new Date(a.deletedAt).getTime()
+    );
+}
+
+/**
+ * Restore an Iris app from backup.
+ *
+ * @param {string} backupPath - Path to the backup folder
+ * @param {object} options - Recovery options
+ * @param {boolean} options.restoreLink - Whether to restore the linked project (default: true)
+ * @param {boolean} options.restoreLocal - Whether to restore local files (default: true)
+ * @returns {Promise<{
+ *   success: boolean,
+ *   restoredFiles: boolean,
+ *   restoredLink: boolean,
+ *   linkedProjectPathExists: boolean,
+ *   warnings: string[],
+ *   error: string | null,
+ *   isPermissionError: boolean,
+ *   targetPath: string | null
+ * }>}
+ */
+export async function restoreIrisApp(backupPath, options = {}) {
+    const { restoreLink = true, restoreLocal = true } = options;
+    const result = {
+        success: false,
+        restoredFiles: false,
+        restoredLink: false,
+        linkedProjectPathExists: true,
+        warnings: [],
+        error: null,
+        isPermissionError: false,
+        isFileLocked: false,
+        isCorrupted: false,
+        targetPath: null
+    };
+
+    // Read metadata
+    const metadataPath = path.join(backupPath, 'metadata.json');
+    if (!fs.existsSync(metadataPath)) {
+        result.error = 'Backup metadata not found. The backup may be incomplete or corrupted.';
+        result.isCorrupted = true;
+        return result;
+    }
+
+    let metadata;
+    try {
+        const metadataContent = fs.readFileSync(metadataPath, 'utf-8');
+        metadata = JSON.parse(metadataContent);
+    } catch (err) {
+        if (err instanceof SyntaxError) {
+            result.error = 'Backup metadata is corrupted (invalid JSON). The backup may be damaged.';
+            result.isCorrupted = true;
+        } else {
+            result.error = `Failed to read backup metadata: ${err.message}`;
+        }
+        return result;
+    }
+
+    const { slug, linkedProject } = metadata;
+
+    if (!slug) {
+        result.error = 'Backup metadata is missing required "slug" field. The backup may be corrupted.';
+        result.isCorrupted = true;
+        return result;
+    }
+
+    // Restore local files
+    if (restoreLocal) {
+        const zipPath = path.join(backupPath, `${slug}.zip`);
+        if (!fs.existsSync(zipPath)) {
+            result.error = 'Backup ZIP file not found. The backup may be incomplete.';
+            result.isCorrupted = true;
+            return result;
+        }
+
+        let zipBuffer;
+        try {
+            zipBuffer = fs.readFileSync(zipPath);
+        } catch (err) {
+            const errorType = detectErrorType(err);
+            if (errorType === ErrorTypes.PERMISSION) {
+                result.error = formatPermissionError({
+                    operation: 'read backup file',
+                    path: zipPath
+                });
+                result.isPermissionError = true;
+            } else if (errorType === ErrorTypes.FILE_LOCKED) {
+                result.error = formatFileLockError({ path: zipPath });
+                result.isFileLocked = true;
+            } else {
+                result.error = `Failed to read backup file: ${err.message}`;
+            }
+            return result;
+        }
+
+        const targetDir = path.join(process.cwd(), 'src', 'iris-apps');
+        const appTargetDir = path.join(targetDir, slug);
+        result.targetPath = appTargetDir;
+
+        // Ensure target directory exists
+        try {
+            fs.mkdirSync(targetDir, { recursive: true });
+        } catch (err) {
+            const errorType = detectErrorType(err);
+            if (errorType === ErrorTypes.PERMISSION) {
+                result.error = formatPermissionError({
+                    operation: 'create restore directory',
+                    path: targetDir
+                });
+                result.isPermissionError = true;
+            } else {
+                result.error = `Failed to create restore directory: ${err.message}`;
+            }
+            return result;
+        }
+
+        // Extract backup
+        try {
+            await extractIrisZip(zipBuffer, targetDir);
+            result.restoredFiles = true;
+        } catch (err) {
+            const errorType = detectErrorType(err);
+            if (errorType === ErrorTypes.PERMISSION) {
+                result.error = formatPermissionError({
+                    operation: 'extract backup files',
+                    path: appTargetDir
+                });
+                result.isPermissionError = true;
+            } else if (errorType === ErrorTypes.FILE_LOCKED) {
+                result.error = formatFileLockError({ path: appTargetDir });
+                result.isFileLocked = true;
+            } else if (errorType === ErrorTypes.DISK_FULL) {
+                result.error = formatDiskFullError({
+                    operation: 'restore backup',
+                    path: appTargetDir
+                });
+            } else if (err.message?.includes('invalid') || err.message?.includes('corrupt')) {
+                result.error = 'Backup ZIP file appears to be corrupted. The backup cannot be restored.';
+                result.isCorrupted = true;
+            } else {
+                result.error = `Failed to extract backup: ${err.message}`;
+            }
+            return result;
+        }
+    }
+
+    // Restore linked project
+    if (restoreLink && linkedProject) {
+        // Check if the linked project path still exists
+        if (!fs.existsSync(linkedProject.path)) {
+            result.linkedProjectPathExists = false;
+            result.warnings.push(
+                `Linked Vue project no longer exists at: ${linkedProject.path}`
+            );
+        } else {
+            result.restoredLink = true;
+        }
+    }
+
+    result.success = true;
+    return result;
+}
+
+/**
+ * Delete a backup folder.
+ *
+ * @param {string} backupPath - Path to the backup folder
+ * @returns {{success: boolean, error: string | null}}
+ */
+export function deleteBackup(backupPath) {
+    try {
+        if (fs.existsSync(backupPath)) {
+            fs.rmSync(backupPath, { recursive: true, force: true });
+        }
+        return { success: true, error: null };
+    } catch (err) {
+        const errorType = detectErrorType(err);
+        if (errorType === ErrorTypes.PERMISSION) {
+            return {
+                success: false,
+                error: formatPermissionError({
+                    operation: 'delete backup',
+                    path: backupPath
+                })
+            };
+        }
+        if (errorType === ErrorTypes.FILE_LOCKED) {
+            return {
+                success: false,
+                error: formatFileLockError({ path: backupPath })
+            };
+        }
+        return {
+            success: false,
+            error: `Failed to delete backup: ${err.message}`
+        };
+    }
+}
+
+/**
+ * Clean up old backups (older than MAX_BACKUP_AGE_DAYS).
+ *
+ * @returns {{cleaned: number, errors: number}}
+ */
+export function cleanupOldBackups() {
+    const result = { cleaned: 0, errors: 0 };
+    const backups = listBackups();
+
+    const now = Date.now();
+    const maxAge = MAX_BACKUP_AGE_DAYS * 24 * 60 * 60 * 1000;
+
+    for (const backup of backups) {
+        const age = now - new Date(backup.deletedAt).getTime();
+        if (age > maxAge) {
+            const deleteResult = deleteBackup(backup.backupPath);
+            if (deleteResult.success) {
+                result.cleaned++;
+            } else {
+                result.errors++;
+            }
+        }
+    }
+
+    return result;
+}