@magentrix-corp/magentrix-cli 1.2.0 → 1.3.0

package/utils/iris/backup.js

@@ -0,0 +1,201 @@
+import fs from 'fs';
+import path from 'path';
+import { createIrisZip } from './zipper.js';
+import { extractIrisZip } from './zipper.js';
+
+const BACKUP_DIR = '.magentrix/iris-backups';
+
+/**
+ * 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) {
+    try {
+        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);
+
+        // Create backup directory
+        fs.mkdirSync(backupPath, { recursive: true });
+
+        // Create ZIP of app files
+        const zipBuffer = await createIrisZip(appPath, slug);
+        const zipPath = path.join(backupPath, `${slug}.zip`);
+        fs.writeFileSync(zipPath, zipBuffer);
+
+        // Save metadata
+        const metadataPath = path.join(backupPath, 'metadata.json');
+        fs.writeFileSync(metadataPath, JSON.stringify({
+            ...metadata,
+            deletedAt: new Date().toISOString(),
+            backupName,
+            originalPath: appPath
+        }, null, 2));
+
+        return {
+            success: true,
+            backupPath,
+            error: null
+        };
+    } catch (error) {
+        return {
+            success: false,
+            backupPath: null,
+            error: error.message
+        };
+    }
+}
+
+/**
+ * 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,
+        targetPath: null
+    };
+
+    try {
+        // Read metadata
+        const metadataPath = path.join(backupPath, 'metadata.json');
+        if (!fs.existsSync(metadataPath)) {
+            result.error = 'Backup metadata not found';
+            return result;
+        }
+
+        const metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf-8'));
+        const { slug, linkedProject } = metadata;
+
+        // Restore local files
+        if (restoreLocal) {
+            const zipPath = path.join(backupPath, `${slug}.zip`);
+            if (!fs.existsSync(zipPath)) {
+                result.error = 'Backup ZIP file not found';
+                return result;
+            }
+
+            const zipBuffer = fs.readFileSync(zipPath);
+            const targetDir = path.join(process.cwd(), 'src', 'iris-apps');
+            const appTargetDir = path.join(targetDir, slug);
+            result.targetPath = appTargetDir;
+
+            // Ensure target directory exists
+            fs.mkdirSync(targetDir, { recursive: true });
+
+            // Extract backup
+            await extractIrisZip(zipBuffer, targetDir);
+            result.restoredFiles = true;
+        }
+
+        // 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;
+    } catch (error) {
+        result.error = error.message;
+        result.isPermissionError = error.code === 'EACCES' || error.code === 'EPERM';
+        return result;
+    }
+}
+
+/**
+ * Delete a backup folder.
+ *
+ * @param {string} backupPath - Path to the backup folder
+ */
+export function deleteBackup(backupPath) {
+    try {
+        if (fs.existsSync(backupPath)) {
+            fs.rmSync(backupPath, { recursive: true, force: true });
+        }
+    } catch {
+        // Ignore errors
+    }
+}

package/utils/iris/builder.js

@@ -0,0 +1,304 @@
+import { spawn } from 'node:child_process';
+import { existsSync, mkdirSync, cpSync, rmSync, readdirSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { validateIrisBuild } from './validator.js';
+import { updateLastBuild } from './linker.js';
+import { EXPORT_ROOT, IRIS_APPS_DIR } from '../../vars/global.js';
+
+/**
+ * Build a Vue project using npm run build.
+ *
+ * @param {string} projectPath - Path to the Vue project
+ * @param {Object} options - Build options
+ * @param {boolean} options.silent - Suppress build output
+ * @returns {Promise<{
+ *   success: boolean,
+ *   output: string,
+ *   error: string | null,
+ *   distPath: string | null
+ * }>}
+ */
+export async function buildVueProject(projectPath, options = {}) {
+    const { silent = false } = options;
+    const resolvedPath = resolve(projectPath);
+
+    // Check for package.json
+    if (!existsSync(join(resolvedPath, 'package.json'))) {
+        return {
+            success: false,
+            output: '',
+            error: `No package.json found in ${resolvedPath}`,
+            distPath: null
+        };
+    }
+
+    // Check for node_modules
+    if (!existsSync(join(resolvedPath, 'node_modules'))) {
+        return {
+            success: false,
+            output: '',
+            error: `No node_modules found. Run 'npm install' in ${resolvedPath} first.`,
+            distPath: null
+        };
+    }
+
+    return new Promise((resolvePromise) => {
+        const output = [];
+        const errorOutput = [];
+
+        // Determine npm command based on platform
+        const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+
+        const child = spawn(npmCmd, ['run', 'build'], {
+            cwd: resolvedPath,
+            shell: false,
+            env: { ...process.env, FORCE_COLOR: '1' }
+        });
+
+        child.stdout.on('data', (data) => {
+            const text = data.toString();
+            output.push(text);
+            if (!silent) {
+                process.stdout.write(text);
+            }
+        });
+
+        child.stderr.on('data', (data) => {
+            const text = data.toString();
+            errorOutput.push(text);
+            if (!silent) {
+                process.stderr.write(text);
+            }
+        });
+
+        child.on('close', (code) => {
+            const fullOutput = output.join('');
+            const fullError = errorOutput.join('');
+
+            if (code !== 0) {
+                resolvePromise({
+                    success: false,
+                    output: fullOutput,
+                    error: fullError || `Build process exited with code ${code}`,
+                    distPath: null
+                });
+                return;
+            }
+
+            // Find dist directory (Vue typically outputs to 'dist')
+            const possibleDistPaths = ['dist', 'build', 'output'];
+            let distPath = null;
+
+            for (const distDir of possibleDistPaths) {
+                const fullPath = join(resolvedPath, distDir);
+                if (existsSync(fullPath)) {
+                    distPath = fullPath;
+                    break;
+                }
+            }
+
+            if (!distPath) {
+                resolvePromise({
+                    success: false,
+                    output: fullOutput,
+                    error: 'Build completed but no dist/build directory found',
+                    distPath: null
+                });
+                return;
+            }
+
+            resolvePromise({
+                success: true,
+                output: fullOutput,
+                error: null,
+                distPath
+            });
+        });
+
+        child.on('error', (err) => {
+            resolvePromise({
+                success: false,
+                output: output.join(''),
+                error: `Failed to start build process: ${err.message}`,
+                distPath: null
+            });
+        });
+    });
+}
+
+/**
+ * Stage build output to the CLI project's iris-apps directory.
+ *
+ * @param {string} distPath - Path to the build output (dist directory)
+ * @param {string} slug - The app slug (folder name)
+ * @param {string} cliProjectPath - Path to the CLI project root (defaults to CWD)
+ * @returns {{
+ *   success: boolean,
+ *   stagedPath: string | null,
+ *   error: string | null,
+ *   fileCount: number
+ * }}
+ */
+export function stageToCliProject(distPath, slug, cliProjectPath = process.cwd()) {
+    const resolvedDistPath = resolve(distPath);
+    const irisAppsDir = join(cliProjectPath, EXPORT_ROOT, IRIS_APPS_DIR);
+    const targetDir = join(irisAppsDir, slug);
+
+    // Validate dist path exists
+    if (!existsSync(resolvedDistPath)) {
+        return {
+            success: false,
+            stagedPath: null,
+            error: `Dist path does not exist: ${resolvedDistPath}`,
+            fileCount: 0
+        };
+    }
+
+    // Validate build output
+    const validation = validateIrisBuild(resolvedDistPath);
+    if (!validation.valid) {
+        return {
+            success: false,
+            stagedPath: null,
+            error: `Invalid build output:\n${validation.errors.join('\n')}`,
+            fileCount: 0
+        };
+    }
+
+    // Ensure iris-apps directory exists
+    if (!existsSync(irisAppsDir)) {
+        mkdirSync(irisAppsDir, { recursive: true });
+    }
+
+    // Remove existing app directory if it exists
+    if (existsSync(targetDir)) {
+        rmSync(targetDir, { recursive: true, force: true });
+    }
+
+    // Copy dist contents to target
+    try {
+        cpSync(resolvedDistPath, targetDir, { recursive: true });
+    } catch (err) {
+        return {
+            success: false,
+            stagedPath: null,
+            error: `Failed to copy build output: ${err.message}`,
+            fileCount: 0
+        };
+    }
+
+    // Count files copied
+    const fileCount = countFiles(targetDir);
+
+    // Update last build timestamp for linked project
+    updateLastBuild(slug);
+
+    return {
+        success: true,
+        stagedPath: targetDir,
+        error: null,
+        fileCount
+    };
+}
+
+/**
+ * Count files recursively in a directory.
+ *
+ * @param {string} dir - Directory to count files in
+ * @returns {number} - Number of files
+ */
+function countFiles(dir) {
+    if (!existsSync(dir)) return 0;
+
+    let count = 0;
+    const items = readdirSync(dir, { withFileTypes: true });
+
+    for (const item of items) {
+        if (item.isDirectory()) {
+            count += countFiles(join(dir, item.name));
+        } else {
+            count++;
+        }
+    }
+
+    return count;
+}
+
+/**
+ * Find an existing dist directory in a Vue project.
+ *
+ * @param {string} projectPath - Path to the Vue project
+ * @returns {string | null} - Path to dist directory or null if not found
+ */
+export function findDistDirectory(projectPath) {
+    const possibleDistPaths = ['dist', 'build', 'output'];
+
+    for (const distDir of possibleDistPaths) {
+        const fullPath = join(projectPath, distDir);
+        if (existsSync(fullPath)) {
+            return fullPath;
+        }
+    }
+
+    return null;
+}
+
+/**
+ * Format build error for display.
+ *
+ * @param {string} projectPath - Path to the Vue project
+ * @param {string} errorOutput - Error output from build
+ * @returns {string} - Formatted error message
+ */
+export function formatBuildError(projectPath, errorOutput) {
+    return `Build Failed
+────────────────────────────────────────────────────
+
+The Vue.js build process failed. This is a project issue, not a CLI issue.
+
+Error output:
+${errorOutput.split('\n').map(line => `  ${line}`).join('\n')}
+
+To fix this:
+  1. Run 'npm run build' manually in your Vue project:
+     cd ${projectPath}
+     npm run build
+
+  2. Fix any compilation errors shown above
+
+  3. Run 'magentrix vue-build-stage' again
+
+Alternatively, use --skip-build to stage an existing dist/ folder.`;
+}
+
+/**
+ * Format validation error for display.
+ *
+ * @param {string} distPath - Path to the dist directory
+ * @param {string[]} errors - Validation errors
+ * @returns {string} - Formatted error message
+ */
+export function formatValidationError(distPath, errors) {
+    return `Invalid Build Output
+────────────────────────────────────────────────────
+
+The build output at ${distPath} is missing required files.
+
+Missing:
+${errors.map(e => `  ✗ ${e}`).join('\n')}
+
+Required files for an Iris app:
+  - remoteEntry.js (Module Federation entry point)
+  - assets/hostInit*.js (Host initialization script)
+  - assets/main*.js (Main entry point)
+  - assets/index*.js (Index entry)
+
+This usually means:
+  1. The project is not configured as a Module Federation remote
+  2. The build did not complete successfully
+  3. The dist directory contains an old or incorrect build
+
+Try rebuilding the project:
+  cd ${distPath.replace('/dist', '')}
+  npm run build`;
+}